implement remotes + large rewrite

Author: jackdotink

.vscode/settings.json

@@ -1,4 +1,5 @@
 {
 	"luau-lsp.sourcemap.enabled": false,
-	"luau-lsp.types.definitionFiles": ["src/zap.d.luau"]
+	"luau-lsp.types.definitionFiles": ["src/zap.d.luau"],
+	"luau-lsp.ignoreGlobs": ["src/*"],
 }

Cargo.lock

@@ -5,7 +5,7 @@ edition = "2024"
 
 [dependencies]
 clap = { version = "4.5", features = ["derive"] }
-lu = "0.4"
+lu = "0.5.1"
 uuid = { version = "1.17", features = ["v4"] }
 
 [build-dependencies]

Cargo.toml

@@ -1,8 +1,11 @@
-use std::{ops::ControlFlow, rc::Rc};
+use std::ops::ControlFlow;
 
-use uuid::Uuid;
+use lu::Methods;
 
-use crate::shared::{ApiCheck, Casing, NetworkSide, NumberKind, Options, Range};
+use crate::{
+    options,
+    shared::{ApiCheck, Casing, NetworkSide, NumberKind, Range, Remote},
+};
 
 #[derive(Default)]
 struct Config;
@@ -22,9 +25,13 @@ pub fn exec(source: &[u8]) -> Result<Table, String> {
 
     let mut state = lu::State::new((), lu::DefaultAllocator);
     state.open_std();
-    state.open_userdata::<Type>();
-    state.open_userdata::<Event>();
-    state.open_userdata::<Options>();
+    state.open_userdata::<Type>(Methods::default());
+    state.open_userdata::<Event>(Methods::default());
+    state.open_userdata::<OptionUserdata>(Methods::default());
+    state.open_userdata::<RemoteUserdata>(Methods::default().with_method(
+        "event",
+        lu::Function::norm("RemoteUserdata::event", RemoteUserdata::event),
+    ));
     state.open_library("zap", library());
     state.sandbox();
 
@@ -52,7 +59,7 @@ pub fn exec(source: &[u8]) -> Result<Table, String> {
             Err(format!("yielded: {trace}"))
         },
 
-        _ => table(stack, Rc::new(Options::default())),
+        _ => table(stack),
     }
 }
 
@@ -62,14 +69,14 @@ pub enum Item {
     Event(Event),
 }
 
-fn table(stack: &lu::Stack<Config>, parent: Rc<Options>) -> Result<Table, String> {
-    let mut options = Rc::new(Options::default().with_parent(parent));
+fn table(stack: &lu::Stack<Config>) -> Result<Table, String> {
+    let mut options = options::Node::from(options::Partial::default());
     let mut items = Vec::new();
 
     let result = stack.iter(-1, || {
         if stack.to_number(-2).is_some_and(|n| n == 1.0) {
-            options = match stack.to_userdata::<Options>(-1) {
-                Some(options) => Rc::new(options.borrow().clone()),
+            options = match stack.to_userdata::<OptionUserdata>(-1) {
+                Some(options) => options.borrow().0.clone(),
                 None => return ControlFlow::Break("index 1 may only contain options".to_string()),
             };
         } else {
@@ -79,11 +86,12 @@ fn table(stack: &lu::Stack<Config>, parent: Rc<Options>) -> Result<Table, String
 
             match stack.type_of(-1) {
                 lu::Type::Table => {
-                    let table = match table(stack, options.clone()) {
+                    let table = match table(stack) {
                         Ok(table) => table,
                         Err(err) => return ControlFlow::Break(err),
                     };
 
+                    table.opts.set_parent(options.clone());
                     items.push((name.to_owned(), Item::Table(table)));
                 }
 
@@ -107,7 +115,10 @@ fn table(stack: &lu::Stack<Config>, parent: Rc<Options>) -> Result<Table, String
     if let Some(err) = result {
         Err(err)
     } else {
-        Ok(Table { options, items })
+        Ok(Table {
+            opts: options,
+            items,
+        })
     }
 }
 
@@ -118,7 +129,7 @@ fn library() -> lu::Library<Config> {
 
     lu::Library::default()
         .with_function_norm("options", options)
-        .with_function_norm("event", event)
+        .with_function_norm("remote", remote)
         .with_function_norm("boolean", boolean)
         .with_function_norm("u8", u8)
         .with_function_norm("u16", u16)
@@ -143,12 +154,15 @@ fn library() -> lu::Library<Config> {
 
 #[derive(Clone)]
 pub struct Table {
-    pub options: Rc<Options>,
+    pub opts: options::Node,
     pub items: Vec<(String, Item)>,
 }
 
+#[derive(lu::Userdata)]
+pub struct OptionUserdata(options::Node);
+
 extern "C-unwind" fn options(ctx: Context) -> lu::FnReturn {
-    let mut options = Options::default();
+    let mut options = options::Partial::default();
     ctx.arg_table(1);
 
     ctx.iter(1, || {
@@ -162,7 +176,7 @@ extern "C-unwind" fn options(ctx: Context) -> lu::FnReturn {
                     _ => ctx.error_msg("apicheck must be 'none', 'some', or 'full'"),
                 };
 
-                options = options.clone().with_apicheck(value);
+                options.apicheck = Some(value)
             }
 
             Some("casing") => {
@@ -175,7 +189,7 @@ extern "C-unwind" fn options(ctx: Context) -> lu::FnReturn {
                     _ => ctx.error_msg("casing must be 'lower', 'snake', 'camel', or 'pascal'"),
                 };
 
-                options = options.clone().with_casing(value);
+                options.casing = Some(value);
             }
 
             Some(str) => ctx.error_msg(format!("unknown option: {str}")),
@@ -185,45 +199,57 @@ extern "C-unwind" fn options(ctx: Context) -> lu::FnReturn {
         ControlFlow::<()>::Continue(())
     });
 
-    ctx.push_userdata(options);
+    ctx.push_userdata(OptionUserdata(options::Node::from(options)));
     ctx.ret_with(1)
 }
 
 #[derive(lu::Userdata, Clone)]
 pub struct Event {
-    pub uuid: Uuid,
+    pub thru: Remote,
     pub from: NetworkSide,
     pub data: Vec<Type>,
 }
 
-extern "C-unwind" fn event(ctx: Context) -> lu::FnReturn {
-    let from = ctx.arg_string_str(1);
-    ctx.arg_table(2);
+#[derive(lu::Userdata)]
+pub struct RemoteUserdata(Remote);
 
-    let uuid = Uuid::new_v4();
-    let from = match from {
-        "server" => NetworkSide::Server,
-        "client" => NetworkSide::Client,
+impl RemoteUserdata {
+    extern "C-unwind" fn event(ctx: Context) -> lu::FnReturn {
+        let remote = ctx.arg_userdata::<RemoteUserdata>(1);
+        let from = ctx.arg_string_str(2);
+        ctx.arg_table(3);
 
-        _ => ctx.arg_error(1, c"must be 'server' or 'client'"),
-    };
+        let thru = remote.borrow().0.clone();
 
-    let mut data = Vec::new();
-    ctx.iter(2, || {
-        if !ctx.is_number(-2) {
-            ctx.error_msg("event data must be an array")
-        }
+        let from = match from {
+            "server" => NetworkSide::Server,
+            "client" => NetworkSide::Client,
 
-        if let Some(item) = ctx.to_userdata::<Type>(-1) {
-            data.push(item.borrow().clone());
-        } else {
-            ctx.error_msg("event data must be a type");
-        }
+            _ => ctx.arg_error(2, c"must be 'server' or 'client'"),
+        };
 
-        ControlFlow::<()>::Continue(())
-    });
+        let mut data = Vec::new();
+        ctx.iter(3, || {
+            if !ctx.is_number(-2) {
+                ctx.error_msg("event data must be an array")
+            }
+
+            if let Some(item) = ctx.to_userdata::<Type>(-1) {
+                data.push(item.borrow().clone());
+            } else {
+                ctx.error_msg("event data must be a type");
+            }
+
+            ControlFlow::<()>::Continue(())
+        });
+
+        ctx.push_userdata(Event { thru, from, data });
+        ctx.ret_with(1)
+    }
+}
 
-    ctx.push_userdata(Event { uuid, from, data });
+extern "C-unwind" fn remote(ctx: Context) -> lu::FnReturn {
+    ctx.push_userdata(RemoteUserdata(Remote::default()));
     ctx.ret_with(1)
 }
 

src/api.rs

@@ -0,0 +1,2 @@
+exportmt.__index = nil
+return export

src/footer.luau

@@ -1,14 +1,19 @@
 --!nocheck
 --!nolint
 -- This file was generated by zap
-local buf, pos, len = buffer.create(1024), 0, 1024
+local exportmt = {
+	__index = function(self, key)
+		self[key] = setmetatable({}, exportmt)
+	end
+}
+local export = setmetatable({}, exportmt)
 local bit = { [true] = 1, [false] = 0 }
-local function resize(bytes)
-	local newlen = pos * 2
+local function resize(buf, pos, len, bytes)
+	local newlen = len * 2
 	if newlen < pos + bytes then
 		newlen = pos + bytes
 	end
 	local newbuf = buffer.create(newlen)
 	buffer.copy(newbuf, 0, buf, 0, pos)
-	buf, len = newbuf, newlen
+	return newbuf, newlen
 end

src/header.luau

@@ -1,42 +1,47 @@
+use std::collections::HashMap;
+
 use crate::{
     api,
     hir::{
-        ArrayType, BinaryStringType, BooleanType, EnumType, Event, Item, Length, MapType,
-        NumberType, SetType, StructType, Table, Type, Utf8StringType, VectorType,
+        ArrayType, BinaryStringType, BooleanType, EnumType, Event, Hir, Item, Length, MapType,
+        NumberType, SetType, StructType, Type, Utf8StringType, VectorType,
     },
-    shared::Range,
+    shared::{Range, Remote},
 };
 
-impl From<api::Item> for Item {
-    fn from(value: api::Item) -> Self {
-        match value {
-            api::Item::Table(table) => Item::Table(table.into()),
-            api::Item::Event(event) => Item::Event(event.into()),
-        }
-    }
-}
+pub fn build(table: api::Table) -> Hir {
+    fn build(buckets: &mut HashMap<Remote, Vec<Item>>, path: String, table: api::Table) {
+        let opts = table.opts.resolved();
 
-impl From<api::Table> for Table {
-    fn from(value: api::Table) -> Self {
-        let options = value.options;
-        let items = value
-            .items
-            .into_iter()
-            .map(|(name, item)| (name, Item::from(item)))
-            .collect();
+        for (name, item) in table.items {
+            let path = format!("{path}.{name}");
 
-        Table { options, items }
-    }
-}
+            match item {
+                api::Item::Table(table) => build(buckets, path, table),
+
+                api::Item::Event(api::Event { thru, from, data }) => {
+                    let data = data.into_iter().map(Type::from).collect();
 
-impl From<api::Event> for Event {
-    fn from(value: api::Event) -> Self {
-        let uuid = value.uuid;
-        let from = value.from;
-        let data = value.data.into_iter().map(Type::from).collect();
+                    let event = Event {
+                        opts: opts.clone(),
+                        path,
+                        from,
+                        data,
+                    };
 
-        Event { uuid, from, data }
+                    buckets
+                        .entry(thru.clone())
+                        .or_default()
+                        .push(Item::Event(event));
+                }
+            }
+        }
     }
+
+    let mut buckets = HashMap::new();
+    build(&mut buckets, String::new(), table);
+
+    Hir { buckets }
 }
 
 impl From<api::Type> for Type {

src/hir/build.rs

@@ -1,27 +1,28 @@
-use std::rc::Rc;
+use std::collections::HashMap;
 
-use uuid::Uuid;
-
-use crate::shared::{NetworkSide, NumberKind, Options, Range};
+use crate::{
+    options::Options,
+    shared::{NetworkSide, NumberKind, Range, Remote},
+};
 
 mod build;
 mod size;
 
-#[derive(Clone)]
-pub enum Item {
-    Table(Table),
-    Event(Event),
+pub use build::build;
+
+pub struct Hir {
+    pub buckets: HashMap<Remote, Vec<Item>>,
 }
 
 #[derive(Clone)]
-pub struct Table {
-    pub options: Rc<Options>,
-    pub items: Vec<(String, Item)>,
+pub enum Item {
+    Event(Event),
 }
 
 #[derive(Clone)]
 pub struct Event {
-    pub uuid: Uuid,
+    pub opts: Options,
+    pub path: String,
     pub from: NetworkSide,
     pub data: Vec<Type>,
 }