fix rust

Author: NathanFlurry

README.md

@@ -71,13 +71,13 @@ Servers need to include converters between all versions.
 
 Clients only need to inlucde a single version of the schema since the server is responsible for version conversion no matter what version you connect with.
 
-**Embedded vs Negotiated Versions**
+**Embedded vs Pre-Negotiated Versions**
 
 Every message has a version associated with it. This version is either:
 
-- Pre-negotiated (via mechanisms like HTTP request query parameters or handshakes)
-    - For example, you can extract the version from a request like `POST /v3/users`
-- Embedded in the message itself in the first 2 bytes of the message (see below)
+- **Embedded** in the message itself in the first 2 bytes of the message (see below)
+- **Pre-negotiated** via mechanisms like HTTP request query parameters or handshakes
+    - For example, you can extract the version from a request like `POST /v3/users` as `v3`
 
 **Embedded Binary Format**
 
@@ -96,10 +96,10 @@ The layout looks like this:
 
 The core of why VBARE was designed this way is:
 
-- Manual evolutions simplify application logic by putting all complex evolutions & defaults in a conversion code instead of inside your core applciation logic
-- Manual evolution forces you to handle edge cases of migrations & breaking changes at the cost of more verbose migration code
-- Stop making big breaking v1 to v2 changes — instead, make much smaller schema changes with more flexibility
-- Schema evolution frequently requires more than just renaming properties (like Protobuf, Flatbuffers, Cap'n'proto) — more complicated reshaping & fetching data from remote sources is commonly needed
+- Manual evolutions **simplifies application logic** by putting all complex evolutions & defaults in a conversion code instead of inside your core application logic
+- Manual evolution **forces developers to handle edge cases** of migrations & breaking changes at the cost of more verbose migration code
+- Stop making big breaking v1 to v2 changes — instead, **make much smaller schema changes** with more flexibility
+- Schema evolution frequently requires more than just renaming properties (like Protobuf, Flatbuffers, Cap'n'proto) — **more complicated reshaping & fetching data** from remote sources is commonly needed
 
 ## Implementations
 

rust/examples/basic/build.rs

@@ -1,4 +1,7 @@
-use std::{env, fs, path::{Path, PathBuf}};
+use std::{
+    env, fs,
+    path::{Path, PathBuf},
+};
 
 use anyhow::Result;
 
@@ -10,7 +13,7 @@ fn main() -> Result<()> {
     repo_root.pop(); // rust/examples/basic -> rust/examples
     repo_root.pop(); // rust/examples -> rust
     repo_root.pop(); // rust -> repo root
-    // Now at repo root
+                     // Now at repo root
 
     let fixtures_dir = repo_root.join("fixtures/tests/basic");
     println!("cargo:rerun-if-changed={}", fixtures_dir.display());
@@ -34,7 +37,10 @@ fn main() -> Result<()> {
         // - map<K, V> -> map<K><V>
         let mut normalized = String::new();
         for line in content_raw.lines() {
-            let line_wo_comment = match line.find("//") { Some(i) => &line[..i], None => line };
+            let line_wo_comment = match line.find("//") {
+                Some(i) => &line[..i],
+                None => line,
+            };
             let trimmed = line_wo_comment.trim_start();
             let converted = if trimmed.starts_with("enum ") {
                 let rest = &trimmed["enum ".len()..];
@@ -65,17 +71,29 @@ fn main() -> Result<()> {
             // Ensure ChangeKind enum is defined before Change struct
             let mut lines_all: Vec<&str> = normalized.lines().collect();
 
-            fn extract_block<'a>(lines: &mut Vec<&'a str>, start_pred: &str) -> Option<Vec<&'a str>> {
-                let start = lines.iter().position(|l| l.trim_start().starts_with(start_pred))?;
+            fn extract_block<'a>(
+                lines: &mut Vec<&'a str>,
+                start_pred: &str,
+            ) -> Option<Vec<&'a str>> {
+                let start = lines
+                    .iter()
+                    .position(|l| l.trim_start().starts_with(start_pred))?;
                 let mut end = start;
                 let mut brace_count = 0i32;
                 let mut seen_open = false;
                 for i in start..lines.len() {
                     let l = lines[i];
-                    if l.contains('{') { brace_count += 1; seen_open = true; }
-                    if l.contains('}') { brace_count -= 1; }
+                    if l.contains('{') {
+                        brace_count += 1;
+                        seen_open = true;
+                    }
+                    if l.contains('}') {
+                        brace_count -= 1;
+                    }
                     end = i;
-                    if seen_open && brace_count == 0 { break; }
+                    if seen_open && brace_count == 0 {
+                        break;
+                    }
                 }
                 let block: Vec<&str> = lines[start..=end].to_vec();
                 lines.drain(start..=end);
@@ -92,8 +110,12 @@ fn main() -> Result<()> {
                     .unwrap_or(lines_all.len());
                 let mut rebuilt: Vec<&str> = Vec::new();
                 rebuilt.extend_from_slice(&lines_all[..insert_at]);
-                for l in kind_block.unwrap() { rebuilt.push(l); }
-                for l in change_block.unwrap() { rebuilt.push(l); }
+                for l in kind_block.unwrap() {
+                    rebuilt.push(l);
+                }
+                for l in change_block.unwrap() {
+                    rebuilt.push(l);
+                }
                 rebuilt.extend_from_slice(&lines_all[insert_at..]);
                 normalized = rebuilt.join("\n");
             }
@@ -107,7 +129,9 @@ fn main() -> Result<()> {
     let mut all_names = Vec::new();
     for entry in fs::read_dir(&schema_dir)?.flatten() {
         let path = entry.path();
-        if path.is_dir() { continue; }
+        if path.is_dir() {
+            continue;
+        }
         let bare_name = path
             .file_name()
             .and_then(|s| s.to_str())
@@ -116,7 +140,12 @@ fn main() -> Result<()> {
             .expect("valid file name");
 
         // Use HashMap instead of rivet_util::HashableMap to avoid extra dependency here.
-        let tokens = vbare_gen::bare_schema(&path, vbare_gen::Config { use_hashable_map: false });
+        let tokens = vbare_gen::bare_schema(
+            &path,
+            vbare_gen::Config {
+                use_hashable_map: false,
+            },
+        );
         let ast = syn::parse2(tokens).expect("parse generated code");
         let content = prettyplease::unparse(&ast);
         fs::write(out_path.join(format!("{bare_name}_generated.rs")), content)?;

rust/examples/basic/tests/migrator.rs

@@ -7,8 +7,16 @@ use vbare::OwnedVersionedData;
 fn migrates_v1_to_v3() {
     let app_v1 = schemas::v1::App {
         todos: vec![
-            schemas::v1::Todo { id: 1, title: "a".into(), done: false },
-            schemas::v1::Todo { id: 2, title: "b".into(), done: true },
+            schemas::v1::Todo {
+                id: 1,
+                title: "a".into(),
+                done: false,
+            },
+            schemas::v1::Todo {
+                id: 2,
+                title: "b".into(),
+                done: true,
+            },
         ],
     };
 
@@ -23,14 +31,20 @@ fn migrates_v1_to_v3() {
 #[test]
 fn migrates_v2_to_v3_with_tags() {
     let mut todos: HashMap<schemas::v2::TodoId, schemas::v2::Todo> = HashMap::new();
-    todos.insert(5, schemas::v2::Todo {
-        id: 5,
-        title: "with-tags".into(),
-        status: schemas::v2::TodoStatus::Open,
-        created_at: 42,
-        tags: vec!["red".into(), "blue".into()],
-    });
-    let app_v2 = schemas::v2::App { todos, settings: HashMap::new() };
+    todos.insert(
+        5,
+        schemas::v2::Todo {
+            id: 5,
+            title: "with-tags".into(),
+            status: schemas::v2::TodoStatus::Open,
+            created_at: 42,
+            tags: vec!["red".into(), "blue".into()],
+        },
+    );
+    let app_v2 = schemas::v2::App {
+        todos,
+        settings: HashMap::new(),
+    };
     let bytes = serde_bare::to_vec(&app_v2).unwrap();
     let migrated = AppVersioned::deserialize(&bytes, 2).unwrap();
 
@@ -56,14 +70,20 @@ fn serializes_v3_to_v1() {
                 user_id: None,
                 team_id: None,
             },
-            detail: schemas::v3::TodoDetail { title: "hello".into(), tags: HashMap::new() },
+            detail: schemas::v3::TodoDetail {
+                title: "hello".into(),
+                tags: HashMap::new(),
+            },
             history: Vec::new(),
         },
     );
 
     let app_v3 = schemas::v3::App {
         todos,
-        config: schemas::v3::AppConfig { theme: schemas::v3::Theme::System, features: HashMap::new() },
+        config: schemas::v3::AppConfig {
+            theme: schemas::v3::Theme::System,
+            features: HashMap::new(),
+        },
         boards: HashMap::new(),
     };
 

rust/vbare-compiler/src/lib.rs

@@ -1,8 +1,46 @@
-use std::{fs, path::Path};
 use indoc::formatdoc;
+use std::{fs, path::Path};
+
+/// Configuration for the vbare-compiler.
+///
+/// This allows callers to control how code generation behaves, including
+/// passing through configuration to `vbare_gen`.
+pub struct Config {
+    /// Configuration forwarded to `vbare_gen` for schema codegen.
+    pub vbare: vbare_gen::Config,
+}
+
+impl Default for Config {
+    fn default() -> Self {
+        Self {
+            vbare: vbare_gen::Config {
+                use_hashable_map: false,
+            },
+        }
+    }
+}
+
+impl Config {
+    /// Convenience helper to enable hashable maps in generated code.
+    pub fn with_hashable_map() -> Self {
+        Self {
+            vbare: vbare_gen::Config {
+                use_hashable_map: true,
+            },
+        }
+    }
+}
 
 /// Process BARE schema files and generate Rust code.
 pub fn process_schemas(schema_dir: &Path) -> Result<(), Box<dyn std::error::Error>> {
+    process_schemas_with_config(schema_dir, &Config::default())
+}
+
+/// Process BARE schema files and generate Rust code, using the provided config.
+pub fn process_schemas_with_config(
+    schema_dir: &Path,
+    config: &Config,
+) -> Result<(), Box<dyn std::error::Error>> {
     let out_dir = std::env::var("OUT_DIR")?;
     let out_path = Path::new(&out_dir);
 
@@ -26,7 +64,12 @@ pub fn process_schemas(schema_dir: &Path) -> Result<(), Box<dyn std::error::Erro
             .ok_or("No file extension")?
             .0;
 
-        let tokens = vbare_gen::bare_schema(&path, vbare_gen::Config { use_hashable_map: true });
+        let tokens = vbare_gen::bare_schema(
+            &path,
+            vbare_gen::Config {
+                use_hashable_map: config.vbare.use_hashable_map,
+            },
+        );
         let ast = syn::parse2(tokens)?;
         let content = prettyplease::unparse(&ast);
 

rust/vbare-compiler/tests/basic.rs

@@ -9,7 +9,11 @@ fn processes_basic_fixtures() {
     fixtures_dir.pop(); // up to repo root
     fixtures_dir.push("fixtures/tests/basic");
 
-    assert!(fixtures_dir.is_dir(), "fixtures dir missing: {}", fixtures_dir.display());
+    assert!(
+        fixtures_dir.is_dir(),
+        "fixtures dir missing: {}",
+        fixtures_dir.display()
+    );
 
     // Create a dedicated OUT_DIR for the test and set env var
     let out_dir = tempfile::tempdir().expect("create tempdir for OUT_DIR");
@@ -32,7 +36,10 @@ fn processes_basic_fixtures() {
         // - map<K, V> -> map<K><V>
         let mut normalized = String::new();
         for line in content_raw.lines() {
-            let line_wo_comment = match line.find("//") { Some(i) => &line[..i], None => line };
+            let line_wo_comment = match line.find("//") {
+                Some(i) => &line[..i],
+                None => line,
+            };
             let trimmed = line_wo_comment.trim_start();
             let converted = if trimmed.starts_with("enum ") {
                 let rest = &trimmed["enum ".len()..];
@@ -65,17 +72,29 @@ fn processes_basic_fixtures() {
             // Reorder so that ChangeKind enum appears before Change struct, and both before Todo
             let mut lines_all: Vec<&str> = normalized.lines().collect();
 
-            fn extract_block<'a>(lines: &mut Vec<&'a str>, start_pred: &str) -> Option<Vec<&'a str>> {
-                let start = lines.iter().position(|l| l.trim_start().starts_with(start_pred))?;
+            fn extract_block<'a>(
+                lines: &mut Vec<&'a str>,
+                start_pred: &str,
+            ) -> Option<Vec<&'a str>> {
+                let start = lines
+                    .iter()
+                    .position(|l| l.trim_start().starts_with(start_pred))?;
                 let mut end = start;
                 let mut brace_count = 0i32;
                 let mut seen_open = false;
                 for i in start..lines.len() {
                     let l = lines[i];
-                    if l.contains('{') { brace_count += 1; seen_open = true; }
-                    if l.contains('}') { brace_count -= 1; }
+                    if l.contains('{') {
+                        brace_count += 1;
+                        seen_open = true;
+                    }
+                    if l.contains('}') {
+                        brace_count -= 1;
+                    }
                     end = i;
-                    if seen_open && brace_count == 0 { break; }
+                    if seen_open && brace_count == 0 {
+                        break;
+                    }
                 }
                 let block: Vec<&str> = lines[start..=end].to_vec();
                 lines.drain(start..=end);
@@ -92,8 +111,12 @@ fn processes_basic_fixtures() {
                     .unwrap_or(lines_all.len());
                 let mut rebuilt: Vec<&str> = Vec::new();
                 rebuilt.extend_from_slice(&lines_all[..insert_at]);
-                for l in kind_block.unwrap() { rebuilt.push(l); }
-                for l in change_block.unwrap() { rebuilt.push(l); }
+                for l in kind_block.unwrap() {
+                    rebuilt.push(l);
+                }
+                for l in change_block.unwrap() {
+                    rebuilt.push(l);
+                }
                 rebuilt.extend_from_slice(&lines_all[insert_at..]);
                 normalized = rebuilt.join("\n");
             }

rust/vbare-gen/src/lib.rs

@@ -264,7 +264,7 @@ impl SchemaGenerator {
 		let fields_gen = self.gen_struct_field(name, fields_clone);
 		self.gen_anonymous(name, |ident| {
             quote! {
-                #[derive(Serialize, Deserialize, PartialEq, Eq, Debug, Clone)]
+                #[derive(Serialize, Deserialize, PartialEq, Eq, Debug, Clone, Hash)]
                 pub struct #ident {
                     #(#fields_gen),*
                 }
@@ -317,7 +317,7 @@ impl SchemaGenerator {
 		}
 		self.gen_anonymous(name, |ident| {
             quote! {
-                #[derive(Serialize, Deserialize, PartialEq, Eq, Debug, Clone)]
+                #[derive(Serialize, Deserialize, PartialEq, Eq, Debug, Clone, Hash)]
                 pub enum #ident {
                     #(#members_def),*
                 }
@@ -365,7 +365,7 @@ impl SchemaGenerator {
 		});
         self.gen_anonymous(name, |ident| {
             quote! {
-                #[derive(Serialize, Deserialize, PartialEq, Eq, Debug, PartialOrd, Ord, Clone)]
+                #[derive(Serialize, Deserialize, PartialEq, Eq, Debug, PartialOrd, Ord, Hash, Clone)]
                 #[repr(usize)]
                 pub enum #ident {
                     #(#member_defs),*