Add basic fs lib

Cargo.lock

@@ -250,6 +250,12 @@ version = "1.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d71b6127be86fdcfddb610f7182ac57211d4b18a3e9c82eb2d17662f2227ad6a"
 
+[[package]]
+name = "camino"
+version = "1.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0da45bc31171d8d6960122e222a67740df867c1dd53b4d51caa297084c185cab"
+
 [[package]]
 name = "cc"
 version = "1.2.27"
@@ -789,6 +795,7 @@ checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
 name = "lb"
 version = "0.1.0"
 dependencies = [
+ "camino",
  "derive_more",
  "luaffi",
  "luaify",

crates/lb/Cargo.toml

@@ -4,10 +4,11 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
+camino = "1.1.10"
 derive_more = { version = "2.0.1", features = ["full"] }
 luaffi = { version = "0.1.0", path = "../luaffi" }
 luajit = { version = "0.1.0", path = "../luajit" }
-tokio = { version = "1.45.1", features = ["rt", "time", "fs"] }
+tokio = { version = "1.45.1", features = ["rt", "time", "fs", "net", "process", "signal"] }
 
 [dev-dependencies]
 luaify = { path = "../luaify" }

crates/lb/src/fs.rs

@@ -0,0 +1,32 @@
+//! The `lb:fs` module provides utilities for interacting with the file system asynchronously.
+//!
+//! See [`lb_libfs`] for items exported by this module.
+use luaffi::{cdef, metatype};
+use std::io;
+use tokio::fs;
+
+/// Items exported by the `lb:fs` module.
+///
+/// This module can be obtained by calling `require` in Lua.
+///
+/// ```lua
+/// local fs = require("lb:fs");
+/// ```
+#[cdef]
+pub struct lb_libfs;
+
+#[metatype]
+impl lb_libfs {
+    #[new]
+    extern "Lua-C" fn new() -> Self {
+        Self
+    }
+
+    pub extern "Lua" fn read(&self, path: string) -> string {
+        self.__read(path)
+    }
+
+    async extern "Lua-C" fn __read(&self, path: &str) -> io::Result<Vec<u8>> {
+        fs::read(path).await
+    }
+}

crates/lb/src/lib.rs

@@ -1,4 +1,5 @@
 pub mod channel;
+pub mod fs;
 pub mod net;
 pub mod runtime;
 pub mod task;

crates/lb/src/runtime.lua

@@ -0,0 +1,5 @@
+local task = require("lb:task")
+
+function spawn(f, ...)
+  return task:spawn(f, ...)
+end

crates/lb/src/runtime.rs

@@ -0,0 +1,82 @@
+use crate::{channel::lb_libchannel, fs::lb_libfs, net::lb_libnet, task::lb_libtask};
+use luaffi::{Registry, Type};
+use luajit::{Chunk, State};
+use std::fmt::Display;
+use tokio::{
+    task::{JoinHandle, LocalSet, futures::TaskLocalFuture, spawn_local},
+    task_local,
+};
+
+#[derive(Debug, Default)]
+pub struct Builder {
+    registry: Registry,
+}
+
+impl Builder {
+    pub fn new() -> Self {
+        let mut registry = Registry::new();
+
+        registry
+            .preload::<lb_libtask>("lb:task")
+            .preload::<lb_libchannel>("lb:channel")
+            .preload::<lb_libfs>("lb:fs")
+            .preload::<lb_libnet>("lb:net");
+
+        Self { registry }
+    }
+
+    pub fn module<T: Type>(&mut self, name: impl Display) -> &mut Self {
+        self.registry.preload::<T>(name);
+        self
+    }
+
+    pub fn registry(&self) -> &Registry {
+        &self.registry
+    }
+
+    pub fn build(&self) -> luajit::Result<Runtime> {
+        Ok(Runtime {
+            state: {
+                let mut s = State::new()?;
+                let mut chunk = Chunk::new(self.registry.done());
+                chunk.extend(include_bytes!("./runtime.lua"));
+                s.eval(chunk.path("[luby]"), 0, 0)?;
+                s
+            },
+            tasks: LocalSet::new(),
+        })
+    }
+}
+
+#[derive(Debug)]
+pub struct Runtime {
+    state: State,
+    tasks: LocalSet,
+}
+
+task_local! {
+    static STATE: State;
+}
+
+impl Runtime {
+    pub fn spawn<T: 'static>(
+        &self,
+        f: impl AsyncFnOnce(&mut State) -> T + 'static,
+    ) -> JoinHandle<T> {
+        self.tasks
+            .spawn_local(async move { f(&mut STATE.with(|s| s.new_thread())).await })
+    }
+}
+
+pub fn spawn<T: 'static>(f: impl AsyncFnOnce(&mut State) -> T + 'static) -> JoinHandle<T> {
+    spawn_local(async move { f(&mut STATE.with(|s| s.new_thread())).await })
+}
+
+impl IntoFuture for Runtime {
+    type Output = ();
+    type IntoFuture = TaskLocalFuture<State, LocalSet>;
+
+    fn into_future(self) -> Self::IntoFuture {
+        STATE.scope(self.state, self.tasks)
+    }
+}

crates/luaffi_impl/src/metatype.rs

@@ -4,7 +4,7 @@ use crate::utils::{
 use proc_macro2::TokenStream;
 use quote::{ToTokens, format_ident, quote, quote_spanned};
 use std::{collections::HashSet, fmt, iter};
-use syn::{ext::IdentExt, punctuated::Punctuated, spanned::Spanned, *};
+use syn::{ext::IdentExt, spanned::Spanned, *};
 
 pub fn transform(mut imp: ItemImpl) -> Result<TokenStream> {
     syn_assert!(

src/lib.rs

@@ -1 +1,2 @@
+pub use lb::fs;
 pub use lb::net;