hecks 3.2.1 → 3.3.0

data/rust/build/src/lineage_pass.rs

@@ -119,25 +119,31 @@ fn world_opener_name(line: &str) -> Option<String> {
     Some(quoted[..quoted.find('"')?].to_string())
 }
 
+// Where an adapter class can live: the driven adapters, and the era plugin that holds `PostgresEra`,
+// the one adapter that declares itself lineage-capable.
+const ADAPTER_DIRS: [&str; 2] = ["lib/hecks/adapters/driven", "lib/hecks/ports/persistence/plugins/era"];
+
 // Reads each adapter's own source file rather than invoking Ruby.
 fn lineage_capable_adapter_names(root: &Path) -> Result<Vec<String>, String> {
-    let dir = root.join("lib/hecks/adapters/driven");
-    let entries = std::fs::read_dir(&dir).map_err(|e| format!("reading {}: {e}", dir.display()))?;
-
     let mut names = Vec::new();
-    for entry in entries {
-        let entry = entry.map_err(|e| format!("reading {}: {e}", dir.display()))?;
-        let path = entry.path();
-        if path.extension().and_then(|e| e.to_str()) != Some("rb") {
-            continue;
-        }
+    for relative in ADAPTER_DIRS {
+        let dir = root.join(relative);
+        let entries = std::fs::read_dir(&dir).map_err(|e| format!("reading {}: {e}", dir.display()))?;
+
+        for entry in entries {
+            let entry = entry.map_err(|e| format!("reading {}: {e}", dir.display()))?;
+            let path = entry.path();
+            if path.extension().and_then(|e| e.to_str()) != Some("rb") {
+                continue;
+            }
 
-        let text = std::fs::read_to_string(&path).map_err(|e| format!("reading {}: {e}", path.display()))?;
-        if !declares_lineage_capable_true(&text) {
-            continue;
-        }
-        if let Some(name) = top_level_class_name(&text) {
-            names.push(name);
+            let text = std::fs::read_to_string(&path).map_err(|e| format!("reading {}: {e}", path.display()))?;
+            if !declares_lineage_capable_true(&text) {
+                continue;
+            }
+            if let Some(name) = top_level_class_name(&text) {
+                names.push(name);
+            }
         }
     }
 
@@ -278,6 +284,15 @@ mod tests {
         assert!(!declares_lineage_capable_true("no such method here\n"));
     }
 
+    // The adapter moved out of `lib/hecks/adapters/driven` once and the scan silently found none, which
+    // left every lineage-capable aggregate out of a Ruby-free build's `ir.json`.
+    #[test]
+    fn finds_postgres_era_in_the_real_source_tree() {
+        let root = Path::new(env!("CARGO_MANIFEST_DIR")).join("../..");
+        let names = lineage_capable_adapter_names(&root).expect("scans the adapter directories");
+        assert!(names.iter().any(|name| name == "PostgresEra"), "lineage-capable adapters found: {names:?}");
+    }
+
     #[test]
     fn finds_the_top_level_class_name() {
         assert_eq!(top_level_class_name("module Hecks\n  module Adapters\n    class Postgres\n      def x; end\n"), Some("Postgres".to_string()));

data/rust/build/src/main.rs

@@ -4,14 +4,16 @@
 
 mod build_artifact;
 mod cargo_sync;
+// The one JSON implementation, compiled from `hecks-codegen`'s own source: neither crate depends on
+// the other, and a packaged workspace ships both side by side. This crate reads only part of it.
+#[allow(dead_code)]
+#[path = "../../codegen/src/json.rs"]
 mod json;
 mod lineage_pass;
-mod optional_pass;
 mod pipeline;
 mod reserved_names;
 mod resolve;
 mod root;
-mod sidecars;
 mod subprocess;
 mod tmp;
 

data/rust/build/src/pipeline.rs

@@ -7,9 +7,7 @@ use crate::build_artifact;
 use crate::cargo_sync;
 use crate::json::Json;
 use crate::lineage_pass;
-use crate::optional_pass;
 use crate::resolve;
-use crate::sidecars;
 use crate::subprocess;
 use crate::tmp::TempDir;
 
@@ -77,7 +75,7 @@ pub fn run(root: &Path, domain: &str, opts: &Options) -> Result<(), String> {
     if let Some(p) = &hecksagon_path {
         target_files.push(p.clone());
     }
-    let target_ir_text = parse_chapter_with_optionals(&parser_bin, &target_chapter_name, &target_files)?;
+    let target_ir_text = parse_chapter(&parser_bin, &target_chapter_name, &target_files)?;
     // Only the target chapter gets a `lineage` key — a framework chapter or
     // `meta` never does, matching `derive_lineage` (Ruby) re-`JSON.parse`ing
     // rather than chaining a live object through both passes.
@@ -113,7 +111,7 @@ pub fn run(root: &Path, domain: &str, opts: &Options) -> Result<(), String> {
                 fw_path.display()
             ));
         }
-        let fw_ir_text = parse_chapter_with_optionals(&parser_bin, &fw_chapter_name, std::slice::from_ref(&fw_path))?;
+        let fw_ir_text = parse_chapter(&parser_bin, &fw_chapter_name, std::slice::from_ref(&fw_path))?;
         chapters.push(Chapter {
             mod_name: fw_name.to_lowercase(),
             source_label: format!("{domain} (attaches {fw_name:?})"),
@@ -141,7 +139,7 @@ pub fn run(root: &Path, domain: &str, opts: &Options) -> Result<(), String> {
                 pkg_bluebooks.push(path.clone());
             }
         }
-        let pkg_ir_text = parse_chapter_with_optionals(&parser_bin, &pkg_chapter_name, &pkg_bluebooks)?;
+        let pkg_ir_text = parse_chapter(&parser_bin, &pkg_chapter_name, &pkg_bluebooks)?;
         chapters.push(Chapter {
             // Derived from the declared chapter name (asserted equal to
             // `expected_chapter_name` above), not the raw `pkg_name` — that
@@ -172,7 +170,7 @@ pub fn run(root: &Path, domain: &str, opts: &Options) -> Result<(), String> {
     // The self-hosted language, compiled in too, under the same "Bluebook"
     // chapter name.
     let grammar_files = resolve::grammar_files(root)?;
-    let meta_ir_text = parse_chapter_with_optionals(&parser_bin, "Bluebook", &grammar_files)?;
+    let meta_ir_text = parse_chapter(&parser_bin, "Bluebook", &grammar_files)?;
 
     let out_root = root.join("rust/src/generated");
     std::fs::create_dir_all(&out_root).map_err(|e| format!("creating {}: {e}", out_root.display()))?;
@@ -213,12 +211,6 @@ pub fn run(root: &Path, domain: &str, opts: &Options) -> Result<(), String> {
     }
     run_codegen_full(&codegen_bin, &codegen_args)?;
 
-    sidecars::write(&out_root.join("meta"), &meta_ir_text, META_SOURCE_LABEL)?;
-    sidecars::write(&out_root.join(&target_mod_name), &target_ir_text, domain)?;
-    for c in &chapters {
-        sidecars::write(&out_root.join(&c.mod_name), &c.ir_text, &c.source_label)?;
-    }
-
     let cargo_toml_path = root.join("rust/Cargo.toml");
     cargo_sync::run(&out_root, &cargo_toml_path, &target_mod_name)?;
 
@@ -233,18 +225,15 @@ pub fn run(root: &Path, domain: &str, opts: &Options) -> Result<(), String> {
     Ok(())
 }
 
-// Parses via `hecks-parse chapter`, then runs `optional_pass::run` and
-// re-serializes — matching `derive_append_optionals` (Ruby).
-fn parse_chapter_with_optionals(parser_bin: &Path, chapter_name: &str, files: &[PathBuf]) -> Result<String, String> {
+// Parses via `hecks-parse chapter`. `hecks-codegen` marks the IR and writes its `ir.json` and
+// `metadata.rs` itself, so the text goes through as `hecks-parse` printed it.
+fn parse_chapter(parser_bin: &Path, chapter_name: &str, files: &[PathBuf]) -> Result<String, String> {
     let parser_bin_str = parser_bin.to_string_lossy().to_string();
     let mut args: Vec<String> = vec!["chapter".to_string(), "--chapter".to_string(), chapter_name.to_string()];
     args.extend(files.iter().map(|p| p.to_string_lossy().to_string()));
     let arg_refs: Vec<&str> = args.iter().map(String::as_str).collect();
 
-    let stdout = subprocess::run_capture(&parser_bin_str, &arg_refs)?;
-    let mut ir = Json::parse(&stdout).map_err(|e| format!("parsing hecks-parse chapter output for {chapter_name}: {e}"))?;
-    optional_pass::run(&mut ir);
-    Ok(crate::json::write(&ir))
+    subprocess::run_capture(&parser_bin_str, &arg_refs)
 }
 
 fn run_codegen_full(codegen_bin: &Path, args: &[String]) -> Result<(), String> {

data/rust/codegen/src/bridging.rs

@@ -1,6 +1,6 @@
 //! Port of the retired Ruby generator's `bridging.rb`: cross-type coercion checks for `:set` and `:append` RHS.
 
-use crate::json::Json;
+use crate::json::{Json, Number};
 use crate::literal::Literal;
 use crate::naming;
 use std::collections::{HashMap, HashSet};
@@ -312,15 +312,15 @@ pub fn arithmetic_amount_expr(source: &Json, command: &Json, value_objects_by_na
     let kind = source.get("kind").map(Json::to_s).unwrap_or_default();
     if kind == "literal" {
         let value = source.get("value")?;
-        if let Json::Int(_) = value {
+        if matches!(value.number(), Some(Number::Int(_))) {
             return Some(naming::literal_rhs(value));
         }
         if !matches!(value, Json::Object(_)) {
             return None;
         }
         let key_value = value.get_raw(target_integer_field)?;
-        return match key_value {
-            Json::Int(_) => Some(naming::literal_rhs(key_value)),
+        return match key_value.number() {
+            Some(Number::Int(_)) => Some(naming::literal_rhs(key_value)),
             _ => None,
         };
     }
@@ -347,9 +347,9 @@ pub fn clamp_bounds_ints(source: &Json) -> Option<(i64, i64)> {
     if items.len() != 2 {
         return None;
     }
-    let Json::Int(min) = &items[0] else { return None };
-    let Json::Int(max) = &items[1] else { return None };
-    Some((*min, *max))
+    let Some(Number::Int(min)) = items[0].number() else { return None };
+    let Some(Number::Int(max)) = items[1].number() else { return None };
+    Some((min, max))
 }
 
 /// An aggregate attribute a creating command's arguments never mention.

data/rust/codegen/src/json.rs

@@ -1,21 +1,31 @@
-//! A minimal, dependency-free JSON reader indexed by string key, like the Ruby `ir[:key]` Hash.
-//! It is read-only: this crate emits Rust source, never JSON.
+//! A minimal, dependency-free, mutable JSON value indexed by string key, like the Ruby `ir[:key]`
+//! Hash, with a reader and a pretty writer. The writer matches `JSON.pretty_generate`
+//! byte-for-byte, including its empty-array quirk.
 
 use std::fmt;
+use std::fmt::Write as _;
 
 #[derive(Debug, Clone, PartialEq)]
 pub enum Json {
     Null,
     Bool(bool),
-    // Kept apart from Float: a whole-number Float default (`0.0`) must not render as `0`.
-    Int(i64),
-    Float(f64),
+    /// Raw literal text as scanned, so numbers round-trip unchanged; `number` reads it as Ruby wrote it.
+    Number(String),
     String(String),
     Array(Vec<Json>),
-    // Insertion-ordered pairs, matching the declaration order of the Ruby Hash.
+    /// Insertion-ordered pairs, matching the declaration order of the Ruby Hash; byte-exact
+    /// re-emission depends on key order.
     Object(Vec<(String, Json)>),
 }
 
+/// A `Json::Number` as Ruby wrote it: a `.` or an exponent means a Float, anything else an
+/// Integer. Kept apart: a whole-number Float default (`0.0`) must not render as `0`.
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum Number {
+    Int(i64),
+    Float(f64),
+}
+
 impl Json {
     pub fn parse(text: &str) -> Result<Json, String> {
         let mut p = Parser { bytes: text.as_bytes(), pos: 0 };
@@ -44,6 +54,13 @@ impl Json {
         }
     }
 
+    pub fn get_mut(&mut self, key: &str) -> Option<&mut Json> {
+        match self {
+            Json::Object(pairs) => pairs.iter_mut().find(|(k, _)| k == key).map(|(_, v)| v),
+            _ => None,
+        }
+    }
+
     pub fn as_str(&self) -> Option<&str> {
         match self {
             Json::String(s) => Some(s.as_str()),
@@ -58,25 +75,50 @@ impl Json {
         }
     }
 
+    pub fn as_array_mut(&mut self) -> Option<&mut Vec<Json>> {
+        match self {
+            Json::Array(items) => Some(items),
+            _ => None,
+        }
+    }
+
+    pub fn as_object(&self) -> Option<&[(String, Json)]> {
+        match self {
+            Json::Object(pairs) => Some(pairs.as_slice()),
+            _ => None,
+        }
+    }
+
     pub fn as_bool(&self) -> bool {
         // Ruby truthiness: only `false` and `nil` are falsy, so `0` and `""` are truthy.
         !matches!(self, Json::Bool(false) | Json::Null)
     }
 
-    pub fn as_f64(&self) -> Option<f64> {
-        match self {
-            Json::Int(n) => Some(*n as f64),
-            Json::Float(n) => Some(*n),
-            _ => None,
+    /// The number as Ruby wrote it, or `None` for any other value. An integer too large for `i64`
+    /// reads as a Float.
+    pub fn number(&self) -> Option<Number> {
+        let Json::Number(text) = self else { return None };
+        if text.contains(|c| matches!(c, '.' | 'e' | 'E')) {
+            return text.parse::<f64>().ok().map(Number::Float);
         }
+        match text.parse::<i64>() {
+            Ok(n) => Some(Number::Int(n)),
+            Err(_) => text.parse::<f64>().ok().map(Number::Float),
+        }
+    }
+
+    pub fn as_f64(&self) -> Option<f64> {
+        self.number().map(|n| match n {
+            Number::Int(n) => n as f64,
+            Number::Float(n) => n,
+        })
     }
 
     pub fn as_i64(&self) -> Option<i64> {
-        match self {
-            Json::Int(n) => Some(*n),
-            Json::Float(n) => Some(*n as i64),
-            _ => None,
-        }
+        self.number().map(|n| match n {
+            Number::Int(n) => n,
+            Number::Float(n) => n as i64,
+        })
     }
 
     /// `#to_s` on a scalar; non-scalars render as the empty string rather than panicking.
@@ -84,8 +126,11 @@ impl Json {
         match self {
             Json::Null => String::new(),
             Json::Bool(b) => b.to_string(),
-            Json::Int(n) => n.to_string(),
-            Json::Float(n) => format_number(*n),
+            Json::Number(text) => match self.number() {
+                Some(Number::Int(n)) => n.to_string(),
+                Some(Number::Float(n)) => format_number(n),
+                None => text.clone(),
+            },
             Json::String(s) => s.clone(),
             _ => String::new(),
         }
@@ -95,6 +140,21 @@ impl Json {
     pub fn each(&self) -> &[Json] {
         self.as_array().unwrap_or(&[])
     }
+
+    /// Sets `key` to `value`, overwriting in place or else appending last.
+    pub fn set(&mut self, key: &str, value: Json) {
+        if let Json::Object(pairs) = self {
+            if let Some((_, existing)) = pairs.iter_mut().find(|(k, _)| k == key) {
+                *existing = value;
+                return;
+            }
+            pairs.push((key.to_string(), value));
+        }
+    }
+
+    pub fn set_bool(&mut self, key: &str, value: bool) {
+        self.set(key, Json::Bool(value));
+    }
 }
 
 impl fmt::Display for Json {
@@ -301,6 +361,7 @@ impl<'a> Parser<'a> {
         Ok(out)
     }
 
+    // Keeps the raw literal text, so numbers round-trip unchanged.
     fn parse_number(&mut self) -> Result<Json, String> {
         let start = self.pos;
         if self.peek() == Some(b'-') {
@@ -325,11 +386,141 @@ impl<'a> Parser<'a> {
             }
         }
         let text = std::str::from_utf8(&self.bytes[start..self.pos]).map_err(|e| e.to_string())?;
-        // A `.` or exponent means Ruby wrote a Float; otherwise an Integer (see `Json::Int`).
-        if text.contains('.') || text.contains('e') || text.contains('E') {
-            text.parse::<f64>().map(Json::Float).map_err(|e| e.to_string())
-        } else {
-            text.parse::<i64>().map(Json::Int).map_err(|e| e.to_string())
+        Ok(Json::Number(text.to_string()))
+    }
+}
+
+/// Renders `value` exactly as `JSON.pretty_generate` does for the pinned json gem.
+pub fn write(value: &Json) -> String {
+    let mut out = String::new();
+    write_value(&mut out, value, 0);
+    out
+}
+
+fn indent(out: &mut String, depth: usize) {
+    for _ in 0..depth {
+        out.push_str("  ");
+    }
+}
+
+fn write_value(out: &mut String, value: &Json, depth: usize) {
+    match value {
+        Json::Null => out.push_str("null"),
+        Json::Bool(b) => out.push_str(if *b { "true" } else { "false" }),
+        Json::Number(n) => out.push_str(n),
+        Json::String(s) => write_string(out, s),
+        Json::Array(items) => write_array(out, items, depth),
+        Json::Object(pairs) => write_object(out, pairs, depth),
+    }
+}
+
+fn write_string(out: &mut String, text: &str) {
+    out.push('"');
+    for ch in text.chars() {
+        match ch {
+            '"' => out.push_str("\\\""),
+            '\\' => out.push_str("\\\\"),
+            '\n' => out.push_str("\\n"),
+            '\t' => out.push_str("\\t"),
+            '\r' => out.push_str("\\r"),
+            c if (c as u32) < 0x20 => {
+                let _ = write!(out, "\\u{:04x}", c as u32);
+            }
+            c => out.push(c),
         }
     }
+    out.push('"');
+}
+
+fn write_array(out: &mut String, items: &[Json], depth: usize) {
+    if items.is_empty() {
+        // Empty arrays render with a blank line, matching the pinned json gem.
+        out.push_str("[\n\n");
+        indent(out, depth);
+        out.push(']');
+        return;
+    }
+    out.push_str("[\n");
+    for (idx, item) in items.iter().enumerate() {
+        indent(out, depth + 1);
+        write_value(out, item, depth + 1);
+        if idx + 1 < items.len() {
+            out.push(',');
+        }
+        out.push('\n');
+    }
+    indent(out, depth);
+    out.push(']');
+}
+
+fn write_object(out: &mut String, pairs: &[(String, Json)], depth: usize) {
+    // An empty object needs no special case: the loop runs zero times.
+    out.push_str("{\n");
+    for (idx, (key, val)) in pairs.iter().enumerate() {
+        indent(out, depth + 1);
+        write_string(out, key);
+        out.push_str(": ");
+        write_value(out, val, depth + 1);
+        if idx + 1 < pairs.len() {
+            out.push(',');
+        }
+        out.push('\n');
+    }
+    indent(out, depth);
+    out.push('}');
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn round_trips_an_empty_object() {
+        let text = "{\n}";
+        let value = Json::parse(text).expect("parses");
+        assert_eq!(write(&value), text);
+    }
+
+    #[test]
+    fn set_bool_overwrites_an_existing_key() {
+        let mut value = Json::parse("{\n  \"optional\": false\n}").expect("parses");
+        value.set_bool("optional", true);
+        assert_eq!(write(&value), "{\n  \"optional\": true\n}");
+    }
+
+    // A whole-number Float default must keep its `.0`, in the text and when rendered.
+    #[test]
+    fn keeps_a_float_apart_from_an_integer() {
+        let value = Json::parse("[0.0, 0, 1e3, -7, 12345678901234567890]").expect("parses");
+        let numbers: Vec<Option<Number>> = value.each().iter().map(Json::number).collect();
+
+        assert_eq!(numbers[0], Some(Number::Float(0.0)));
+        assert_eq!(numbers[1], Some(Number::Int(0)));
+        assert_eq!(numbers[2], Some(Number::Float(1000.0)));
+        assert_eq!(numbers[3], Some(Number::Int(-7)));
+        assert!(matches!(numbers[4], Some(Number::Float(_))), "an integer past i64 reads as a Float");
+        assert_eq!(value.each()[0].to_s(), "0.0");
+        assert_eq!(value.each()[1].to_s(), "0");
+    }
+
+    #[test]
+    fn writes_numbers_as_scanned() {
+        let text = "[\n  0.0,\n  1e3,\n  -7\n]";
+        assert_eq!(write(&Json::parse(text).expect("parses")), text);
+    }
+
+    #[test]
+    fn reads_as_i64_and_f64_across_both_kinds() {
+        let value = Json::parse("[3, 2.5]").expect("parses");
+        assert_eq!(value.each()[0].as_f64(), Some(3.0));
+        assert_eq!(value.each()[1].as_i64(), Some(2));
+        assert_eq!(Json::String("3".to_string()).as_i64(), None);
+    }
+
+    #[test]
+    fn get_treats_null_as_missing_and_get_raw_does_not() {
+        let value = Json::parse("{\"a\": null}").expect("parses");
+        assert!(value.get("a").is_none());
+        assert_eq!(value.get_raw("a"), Some(&Json::Null));
+    }
 }

data/rust/codegen/src/literal.rs

@@ -1,7 +1,7 @@
 //! Port of `Literal.read` from `lib/hecks/literal.rb`, the inverse of `Literal.render`.
 //! `Literal::from_json` covers values embedded raw in ir.json, which were never rendered.
 
-use crate::json::Json;
+use crate::json::{Json, Number};
 
 #[derive(Debug, Clone, PartialEq)]
 pub enum Literal {
@@ -22,8 +22,11 @@ impl Literal {
         match value {
             Json::Null => Literal::Nil,
             Json::Bool(b) => Literal::Bool(*b),
-            Json::Int(n) => Literal::Int(*n),
-            Json::Float(n) => Literal::Float(*n),
+            Json::Number(_) => match value.number() {
+                Some(Number::Int(n)) => Literal::Int(n),
+                Some(Number::Float(n)) => Literal::Float(n),
+                None => Literal::Nil,
+            },
             Json::String(s) => Literal::Str(s.clone()),
             Json::Array(items) => Literal::Array(items.iter().map(Literal::from_json).collect()),
             Json::Object(pairs) => Literal::Hash(pairs.iter().map(|(k, v)| (k.clone(), Literal::from_json(v))).collect()),

data/rust/codegen/src/main.rs

@@ -19,6 +19,7 @@ mod literal;
 mod manifest;
 mod mutations;
 mod naming;
+mod optional_pass;
 mod ports;
 mod prelude;
 mod queries;
@@ -28,6 +29,7 @@ mod reference_specs;
 mod registry;
 mod reserved_names;
 mod shared;
+mod sidecars;
 mod skip_reason;
 mod types;
 
@@ -85,22 +87,29 @@ fn run_prelude(args: &[String]) -> Result<(), String> {
 }
 
 /// `hecks-codegen domain <ir.json> <source_label> <mod_name> <out_dir>` — writes one chapter's
-/// `<aggregate>.rs`, `registry.rs`, `mod.rs` and `manifest.json` into `out_dir`.
-///
-/// `metadata.rs` and `ir.json` are left to `hecks project_rust`.
+/// `<aggregate>.rs`, `registry.rs`, `mod.rs`, `manifest.json` and its `ir.json`/`metadata.rs`
+/// sidecars into `out_dir`.
 fn run_domain(args: &[String]) -> Result<(), String> {
     let [ir_path, source_label, mod_name, out_dir] = args else {
         return Err("usage: hecks-codegen domain <ir.json> <source_label> <mod_name> <out_dir>".to_string());
     };
 
-    let text = std::fs::read_to_string(ir_path).map_err(|e| format!("reading {ir_path}: {e}"))?;
-    let ir = Json::parse(&text).map_err(|e| format!("parsing {ir_path}: {e}"))?;
+    let ir = read_ir(ir_path)?;
 
     let ex = exemplar::Exemplar::load();
     write_domain(&ex, &ir, source_label, mod_name, out_dir)?;
     Ok(())
 }
 
+/// Reads one chapter's IR and prepares it for generation: marks the fields an `append` binds to an
+/// optional argument. What it generates from and what it writes to `ir.json` are this same IR.
+fn read_ir(path: &str) -> Result<Json, String> {
+    let text = std::fs::read_to_string(path).map_err(|e| format!("reading {path}: {e}"))?;
+    let mut ir = Json::parse(&text).map_err(|e| format!("parsing {path}: {e}"))?;
+    optional_pass::run(&mut ir);
+    Ok(ir)
+}
+
 /// Writes one chapter's files into `out_dir` and returns the `GeneratedDomain`, so `run_full`
 /// can union the registry, query and read-model definitions across chapters.
 fn write_domain(
@@ -147,6 +156,10 @@ fn write_domain(
     std::fs::write(&manifest_path, &generated.manifest_json).map_err(|e| format!("writing {manifest_path}: {e}"))?;
     println!("wrote {manifest_path}");
 
+    let (ir_json_path, metadata_path) = sidecars::write(std::path::Path::new(out_dir), ir, source_label)?;
+    println!("wrote {}", ir_json_path.display());
+    println!("wrote {}", metadata_path.display());
+
     Ok(generated)
 }
 
@@ -181,8 +194,7 @@ fn run_full(args: &[String]) -> Result<(), String> {
 
     let ex = exemplar::Exemplar::load();
 
-    let target_text = std::fs::read_to_string(target_ir_path).map_err(|e| format!("reading {target_ir_path}: {e}"))?;
-    let target_ir = Json::parse(&target_text).map_err(|e| format!("parsing {target_ir_path}: {e}"))?;
+    let target_ir = read_ir(target_ir_path)?;
     let target_domain_name = target_ir.get("name").and_then(Json::as_str).unwrap_or("").to_string();
 
     let target_out_dir = format!("{out_root}/{target_mod_name}");
@@ -209,8 +221,7 @@ fn run_full(args: &[String]) -> Result<(), String> {
         let chapter_ir_path = &args[i + 2];
         i += 3;
 
-        let text = std::fs::read_to_string(chapter_ir_path).map_err(|e| format!("reading {chapter_ir_path}: {e}"))?;
-        let chapter_ir = Json::parse(&text).map_err(|e| format!("parsing {chapter_ir_path}: {e}"))?;
+        let chapter_ir = read_ir(chapter_ir_path)?;
         let chapter_domain_name = chapter_ir.get("name").and_then(Json::as_str).unwrap_or("").to_string();
 
         let chapter_out_dir = format!("{out_root}/{chapter_mod_name}");

data/rust/codegen/src/naming.rs

@@ -285,8 +285,10 @@ pub fn literal_rhs(literal: &crate::json::Json) -> String {
     match literal {
         crate::json::Json::String(s) => format!("{}.to_string()", ruby_inspect_string(s)),
         // Separate arms so a whole-number Float renders as `0.0`, not an integer-typed `0`.
-        crate::json::Json::Int(n) => n.to_string(),
-        crate::json::Json::Float(_) => literal.to_s(),
+        crate::json::Json::Number(_) => match literal.number() {
+            Some(crate::json::Number::Int(n)) => n.to_string(),
+            _ => literal.to_s(),
+        },
         crate::json::Json::Bool(b) => b.to_string(),
         other => panic!("unsupported literal mutation source {other:?} — not one of String/Integer/Float/Boolean"),
     }