Merge pull request #4 from chavic/chavic/maps-type-support

chavic · web-flow · commit 76dda880077a · 2025-08-18T18:02:15.000+02:00
Reorganize project documentation and improve testing workflow
diff --git a/.gitignore b/.gitignore
@@ -13,3 +13,5 @@ ISSUES.md
 .tmp_tests/
 convert_fixtures.sh
 .DS_Store
+ISSUES.md
+.tmp_tests/
diff --git a/Cargo.toml b/Cargo.toml
@@ -69,7 +69,7 @@ members = [
     "fixtures/metadata",
     "fixtures/simple-iface",
     "fixtures/streams_ext",
-    #"fixtures/*",
+    "fixtures/simple-fns",
 ]
 
 [workspace.dependencies]
diff --git a/TODO.md b/TODO.md
diff --git a/src/gen/compounds.rs b/src/gen/compounds.rs
@@ -183,3 +183,108 @@ impl_code_type_for_compound!(SequenceCodeType, "List<{}>", "Sequence{}");
 
 impl_renderable_for_compound!(OptionalCodeType, "{}?", "FfiConverterOptional{}");
 impl_renderable_for_compound!(SequenceCodeType, "FfiConverterSequence{}");
+
+// Map<K, V>
+#[derive(Debug)]
+pub struct MapCodeType {
+    self_type: Type,
+    key: Type,
+    value: Type,
+}
+
+impl MapCodeType {
+    pub fn new(self_type: Type, key: Type, value: Type) -> Self {
+        Self { self_type, key, value }
+    }
+
+    fn key(&self) -> &Type {
+        &self.key
+    }
+
+    fn value(&self) -> &Type {
+        &self.value
+    }
+}
+
+impl CodeType for MapCodeType {
+    fn type_label(&self) -> String {
+        format!(
+            "Map<{}, {}>",
+            DartCodeOracle::find(self.key()).type_label(),
+            DartCodeOracle::find(self.value()).type_label()
+        )
+    }
+
+    fn canonical_name(&self) -> String {
+        let key = DartCodeOracle::find(self.key()).canonical_name();
+        let val = DartCodeOracle::find(self.value()).canonical_name();
+        format!("Map{}To{}", key, val)
+    }
+}
+
+impl Renderable for MapCodeType {
+    fn render_type_helper(&self, type_helper: &dyn TypeHelperRenderer) -> dart::Tokens {
+        type_helper.include_once_check(&self.ffi_converter_name(), &self.self_type);
+
+        let key_codetype = DartCodeOracle::find(self.key());
+        let val_codetype = DartCodeOracle::find(self.value());
+
+        type_helper.include_once_check(&key_codetype.canonical_name(), self.key());
+        type_helper.include_once_check(&val_codetype.canonical_name(), self.value());
+
+        let cl_name = &self.ffi_converter_name();
+        let key_type_label_owned = key_codetype.type_label();
+        let val_type_label_owned = val_codetype.type_label();
+        let key_type_label = &key_type_label_owned;
+        let val_type_label = &val_type_label_owned;
+
+        let key_conv_owned = key_codetype.ffi_converter_name();
+        let val_conv_owned = val_codetype.ffi_converter_name();
+        let key_conv = &key_conv_owned;
+        let val_conv = &val_conv_owned;
+
+        quote! {
+            class $cl_name {
+                static Map<$key_type_label, $val_type_label> lift(RustBuffer buf) {
+                    return $cl_name.read(buf.asUint8List()).value;
+                }
+
+                static LiftRetVal<Map<$key_type_label, $val_type_label>> read(Uint8List buf) {
+                    final map = <$key_type_label, $val_type_label>{};
+                    final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0);
+                    int offset = buf.offsetInBytes + 4;
+                    for (var i = 0; i < length; i++) {
+                        final k = $key_conv.read(Uint8List.view(buf.buffer, offset));
+                        offset += k.bytesRead;
+                        final v = $val_conv.read(Uint8List.view(buf.buffer, offset));
+                        offset += v.bytesRead;
+                        map[k.value] = v.value;
+                    }
+                    return LiftRetVal(map, offset - buf.offsetInBytes);
+                }
+
+                static int write(Map<$key_type_label, $val_type_label> value, Uint8List buf) {
+                    buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length);
+                    int offset = buf.offsetInBytes + 4;
+                    for (final entry in value.entries) {
+                        offset += $key_conv.write(entry.key, Uint8List.view(buf.buffer, offset));
+                        offset += $val_conv.write(entry.value, Uint8List.view(buf.buffer, offset));
+                    }
+                    return offset - buf.offsetInBytes;
+                }
+
+                static int allocationSize(Map<$key_type_label, $val_type_label> value) {
+                    return value.entries
+                        .map((e) => $key_conv.allocationSize(e.key) + $val_conv.allocationSize(e.value))
+                        .fold(4, (a, b) => a + b);
+                }
+
+                static RustBuffer lower(Map<$key_type_label, $val_type_label> value) {
+                    final buf = Uint8List(allocationSize(value));
+                    write(value, buf);
+                    return toRustBuffer(buf);
+                }
+            }
+        }
+    }
+}
diff --git a/src/gen/mod.rs b/src/gen/mod.rs
@@ -1,6 +1,7 @@
 use std::collections::HashMap;
 use std::collections::HashSet;
 use std::io::Read;
+use std::process::Command;
 
 use anyhow::Result;
 use camino::Utf8Path;
@@ -226,6 +227,22 @@ impl BindingGenerator for DartBindingGenerator {
 
             tokens.format_file(&mut w.as_formatter(&fmt), &config)?;
         }
+
+        // Run full Dart formatter on the output directory as a best-effort step.
+        // This is non-fatal: failures will only emit a warning.
+        let mut format_command = Command::new("dart");
+        format_command
+            .current_dir(&settings.out_dir)
+            .arg("format")
+            .arg(".");
+        match format_command.spawn().and_then(|mut c| c.wait()) {
+            Ok(status) if status.success() => {}
+            Ok(_) | Err(_) => {
+                println!(
+                    "WARNING: dart format failed or is unavailable; proceeding without full formatting"
+                );
+            }
+        }
         Ok(())
     }
 
@@ -281,7 +298,7 @@ pub fn generate_dart_bindings(
             &LocalConfigSupplier(udl_file.to_string()),
             None,
             out_dir_override.unwrap(),
-            false,
+            true,
         )?;
         Ok(())
     } else {
diff --git a/src/gen/oracle.rs b/src/gen/oracle.rs
@@ -688,6 +688,11 @@ impl<T: AsType> AsCodeType for T {
                 self.as_type(),
                 *inner_type,
             )),
+            Type::Map { key_type, value_type, .. } => Box::new(compounds::MapCodeType::new(
+                self.as_type(),
+                *key_type,
+                *value_type,
+            )),
             Type::Enum { name, .. } => Box::new(enums::EnumCodeType::new(name)),
             Type::Record { name, .. } => Box::new(records::RecordCodeType::new(name)),
             Type::CallbackInterface { name, .. } => Box::new(
diff --git a/src/gen/render/mod.rs b/src/gen/render/mod.rs
@@ -94,6 +94,11 @@ impl<T: AsType> AsRenderable for T {
                 self.as_type(),
                 *inner_type,
             )),
+            Type::Map { key_type, value_type } => Box::new(compounds::MapCodeType::new(
+                self.as_type(),
+                *key_type,
+                *value_type,
+            )),
             Type::Enum { name, .. } => Box::new(enums::EnumCodeType::new(name)),
             Type::Record { name, .. } => Box::new(records::RecordCodeType::new(name)),
             Type::Custom {
diff --git a/src/testing.rs b/src/testing.rs
@@ -64,10 +64,28 @@ pub fn run_test(fixture: &str, udl_path: &str, config_path: Option<&str>) -> Res
     // Copy fixture test files to output directory
     let test_glob_pattern = "test/*.dart";
     for file in glob::glob(test_glob_pattern)?.filter_map(Result::ok) {
-        let filename = file.file_name().expect("bad filename").to_str().expect("non-UTF8 filename");
+        let filename = file
+            .file_name()
+            .expect("bad filename")
+            .to_str()
+            .expect("non-UTF8 filename");
         copy(&file, test_outdir.join(filename))?;
     }
 
+    // Format the generated Dart code before running tests (best-effort)
+    let mut format_command = Command::new("dart");
+    format_command.current_dir(&out_dir).arg("format").arg(".");
+    match format_command.spawn().and_then(|mut c| c.wait()) {
+        Ok(status) if status.success() => {}
+        Ok(_) | Err(_) => {
+            println!("WARNING: dart format unavailable or failed; continuing with tests anyway");
+            if std::env::var("CI").is_err() {
+                // skip in CI environment
+                thread::sleep(Duration::from_secs(1));
+            }
+        }
+    }
+
     // Run the test script against compiled bindings
     let mut command = Command::new("dart");
     command.current_dir(&out_dir).arg("test");

Original file line number	Diff line number	Diff line change
`@@ -69,7 +69,7 @@ members = [`
`69`	`69`	`"fixtures/metadata",`
`70`	`70`	`"fixtures/simple-iface",`
`71`	`71`	`"fixtures/streams_ext",`
`72`		`- #"fixtures/*",`
	`72`	`+ "fixtures/simple-fns",`
`73`	`73`	`]`
`74`	`74`
`75`	`75`	`[workspace.dependencies]`