hecks 3.13.0 → 4.0.0

data/rust/codegen/src/reference_specs.rs

@@ -17,8 +17,14 @@ pub fn reference_specs(domain_name: &str, attributes: &[Json]) -> Vec<ReferenceS
         .filter_map(|attr| {
             let target = crate::naming::reference_target(crate::attr::type_name(attr))?;
             let field = crate::attr::name(attr).to_string();
-            let as_name = field.strip_suffix("_id").map(str::to_string).unwrap_or_else(|| field.clone());
-            Some(ReferenceSpec { field, as_name, target: format!("{domain_name}::{target}") })
+            let as_name = field
+                .strip_suffix("_id")
+                .map_or_else(|| field.clone(), str::to_string);
+            Some(ReferenceSpec {
+                field,
+                as_name,
+                target: format!("{domain_name}::{target}"),
+            })
         })
         .collect()
 }
@@ -36,5 +42,12 @@ pub fn emit_reference_specs_literal(specs: &[ReferenceSpec]) -> String {
     if specs.is_empty() {
         return "&[]".to_string();
     }
-    format!("&[{}]", specs.iter().map(emit_reference_spec).collect::<Vec<_>>().join(", "))
+    format!(
+        "&[{}]",
+        specs
+            .iter()
+            .map(emit_reference_spec)
+            .collect::<Vec<_>>()
+            .join(", ")
+    )
 }

data/rust/codegen/src/registry.rs

@@ -4,6 +4,7 @@
 use crate::exemplar::Exemplar;
 use crate::naming;
 use crate::reference_specs::{self, ReferenceSpec};
+use std::fmt::Write as _;
 
 #[derive(Clone)]
 pub struct ReferenceCheck {
@@ -77,7 +78,6 @@ pub struct NestedEntityCommandEntry {
     pub args_struct: String,
     pub reference_checks: Vec<ReferenceCheck>,
     pub reference_specs: Vec<ReferenceSpec>,
-    pub attributes: Vec<String>,
     pub invariant_check_lines: Vec<String>,
     pub role: Option<String>,
     pub entity_name: String,
@@ -91,7 +91,6 @@ pub struct NestedEntityCommandEntry {
 
 pub struct PortEntry {
     pub verb: String,
-    pub name: String,
     pub fn_name: String,
     pub args_struct: String,
     pub reference_checks: Vec<ReferenceCheck>,
@@ -146,32 +145,64 @@ pub fn emit_role_check(
 
 /// Port of the retired Ruby generator's `registry.rb#emit_tenant_boundary_check`.
 /// Hand-built: the target accessor differs for a single-attribute value object and a bare scalar.
+// reason: the emitted Rust contains literal `{:?}` format templates, which the lint mistakes for unfilled arguments.
+#[allow(clippy::literal_string_with_formatting_args)]
 pub fn emit_tenant_boundary_check(check: &TenantBoundaryCheck) -> String {
     let ref_ident = naming::rust_ident_field(&check.reference_field);
-    let own_expr = format!("args.{}.clone()", naming::rust_ident_field(&check.own_accessor));
+    let own_expr = format!(
+        "args.{}.clone()",
+        naming::rust_ident_field(&check.own_accessor)
+    );
     let target_expr = match check.target_accessor.split_once('.') {
         Some((head, inner)) => format!(
             "record.{}.as_ref().map(|v| v.{}.clone())",
             naming::rust_ident_field(head),
             naming::rust_ident_field(inner)
         ),
-        None => format!("record.{}.clone()", naming::rust_ident_field(&check.target_accessor)),
+        None => format!(
+            "record.{}.clone()",
+            naming::rust_ident_field(&check.target_accessor)
+        ),
     };
 
     let mut out = String::new();
-    out.push_str(&format!("if let Some(record) = store.{}.find(&args.{ref_ident}) {{ ", check.target_mod));
-    out.push_str(&format!("if let Some(target_tenant) = {target_expr} {{ "));
-    out.push_str(&format!("let own_tenant = {own_expr}; "));
+    let _ = write!(
+        out,
+        "if let Some(record) = store.{}.find(&args.{ref_ident}) {{ ",
+        check.target_mod
+    );
+    let _ = write!(out, "if let Some(target_tenant) = {target_expr} {{ ");
+    let _ = write!(out, "let own_tenant = {own_expr}; ");
     out.push_str("if target_tenant != own_tenant { ");
     out.push_str(
         "return Err(crate::kernel::Refusal::Unauthorized(crate::kernel::refusal_wording::UnauthorizedCrossTenantReferenceArgs { ",
     );
-    out.push_str(&format!("aggregate: {}, ", naming::ruby_inspect_string(&check.aggregate_name)));
-    out.push_str(&format!("field: {}, ", naming::ruby_inspect_string(&check.own_tenant_field)));
+    let _ = write!(
+        out,
+        "aggregate: {}, ",
+        naming::ruby_inspect_string(&check.aggregate_name)
+    );
+    let _ = write!(
+        out,
+        "field: {}, ",
+        naming::ruby_inspect_string(&check.own_tenant_field)
+    );
     out.push_str("tenant: &format!(\"{:?}\", own_tenant), ");
-    out.push_str(&format!("attribute: {}, ", naming::ruby_inspect_string(&check.reference_field)));
-    out.push_str(&format!("target: {}, ", naming::ruby_inspect_string(&check.target_name)));
-    out.push_str(&format!("target_field: {}, ", naming::ruby_inspect_string(&check.target_tenant_field)));
+    let _ = write!(
+        out,
+        "attribute: {}, ",
+        naming::ruby_inspect_string(&check.reference_field)
+    );
+    let _ = write!(
+        out,
+        "target: {}, ",
+        naming::ruby_inspect_string(&check.target_name)
+    );
+    let _ = write!(
+        out,
+        "target_field: {}, ",
+        naming::ruby_inspect_string(&check.target_tenant_field)
+    );
     out.push_str("other: &format!(\"{:?}\", target_tenant)");
     out.push_str(" }.render_args())); ");
     out.push_str("} } }");
@@ -180,20 +211,32 @@ pub fn emit_tenant_boundary_check(check: &TenantBoundaryCheck) -> String {
 
 /// `kernel::ArgumentGates` literal for one command (`registry.rb#emit_argument_gates_literal`).
 /// The last two fields are closures because they need `store`, which exists only at the router.
-fn emit_argument_gates_literal(args_path: &str, invariant_check_lines: &[String], role_line: Option<String>, reference_lines: &[String]) -> String {
+fn emit_argument_gates_literal(
+    args_path: &str,
+    invariant_check_lines: &[String],
+    role_line: Option<String>,
+    reference_lines: &[String],
+) -> String {
     let mut normalize = vec![format!("let args = {args_path}::from_json(v)?;")];
     normalize.extend(invariant_check_lines.iter().map(|l| squeeze(l)));
     normalize.push("Ok(args)".to_string());
 
-    let role = match role_line.filter(|l| !l.is_empty()) {
-        Some(line) => format!("&|| {{ {} Ok(()) }}", squeeze(&line)),
-        None => "&|| Ok(())".to_string(),
-    };
-    let references: Vec<String> = reference_lines.iter().filter(|l| !l.is_empty()).map(|l| squeeze(l)).collect();
+    let role = role_line.filter(|l| !l.is_empty()).map_or_else(
+        || "&|| Ok(())".to_string(),
+        |line| format!("&|| {{ {} Ok(()) }}", squeeze(&line)),
+    );
+    let references: Vec<String> = reference_lines
+        .iter()
+        .filter(|l| !l.is_empty())
+        .map(|l| squeeze(l))
+        .collect();
     let references = if references.is_empty() {
         format!("&|_args: &{args_path}| Ok(())")
     } else {
-        format!("&|args: &{args_path}| {{ {} Ok(()) }}", references.join(" "))
+        format!(
+            "&|args: &{args_path}| {{ {} Ok(()) }}",
+            references.join("\n")
+        )
     };
 
     format!(
@@ -201,13 +244,18 @@ fn emit_argument_gates_literal(args_path: &str, invariant_check_lines: &[String]
          refuse_unknown_arguments: &{args_path}::refuse_unknown_arguments, \
          refuse_absent_arguments: &{args_path}::refuse_absent_arguments, \
          normalize_args: &|v: &crate::kernel::Json| {{ {} }}, refuse_role_mismatch: {role}, resolve_references: {references} }}",
-        normalize.join(" ")
+        normalize.join("\n")
     )
 }
 
-/// Joins a multi-line emitted check onto one line so it can sit inside a closure expression.
+/// Trims the lines of an emitted check so it can sit inside a closure expression. The lines stay
+/// separate: joined onto one, `}` and the `if` after it would read as a missing `else`.
 fn squeeze(text: &str) -> String {
-    text.lines().map(str::trim).filter(|l| !l.is_empty()).collect::<Vec<_>>().join(" ")
+    text.lines()
+        .map(str::trim)
+        .filter(|l| !l.is_empty())
+        .collect::<Vec<_>>()
+        .join("\n")
 }
 
 pub fn emit_reference_check(exemplar: &Exemplar, check: &ReferenceCheck) -> String {
@@ -259,6 +307,18 @@ fn chapter_path(a: &AggregateEntry) -> String {
     format!("crate::generated::{}::{}", a.chapter_mod, a.module_name)
 }
 
+/// One `"verb" => { .. }` arm of the registry's dispatch match, its body lines indented.
+fn verb_arm(verb: &str, body: &[String]) -> String {
+    format!(
+        "          {} => {{\n{}\n          }}",
+        naming::ruby_inspect_string(verb),
+        body.iter()
+            .map(|l| format!("              {l}"))
+            .collect::<Vec<_>>()
+            .join("\n")
+    )
+}
+
 pub fn emit_registry(exemplar: &Exemplar, aggregates: &[AggregateEntry]) -> String {
     let store_fields: Vec<String> = aggregates
         .iter()
@@ -352,10 +412,13 @@ pub fn emit_registry(exemplar: &Exemplar, aggregates: &[AggregateEntry]) -> Stri
                     )
                 })
                 .collect();
-            let extra_pass: String = extra_idents
-                .iter()
-                .map(|ident| format!("&{ident}, "))
-                .collect();
+            let extra_pass: String =
+                extra_idents
+                    .iter()
+                    .fold(String::new(), |mut passed, ident| {
+                        let _ = write!(passed, "&{ident}, ");
+                        passed
+                    });
 
             // A creating command's dispatch fn takes `route` so it can tell create from find.
             let dispatch_call = format!(
@@ -394,8 +457,7 @@ pub fn emit_registry(exemplar: &Exemplar, aggregates: &[AggregateEntry]) -> Stri
                     &format!("{mod_path}::{}", c.args_struct),
                     &c.invariant_check_lines,
                     emit_role_check(exemplar, c.role.as_deref(), &c.name),
-                    &c
-                        .reference_checks
+                    &c.reference_checks
                         .iter()
                         .map(|check| emit_reference_check(exemplar, check))
                         .collect::<Vec<_>>()
@@ -414,7 +476,8 @@ pub fn emit_registry(exemplar: &Exemplar, aggregates: &[AggregateEntry]) -> Stri
                 .map(emit_tenant_boundary_check)
                 .collect();
             let tenant_boundary_check_line = if tenant_boundary_check_bodies.is_empty() {
-                "let tenant_boundary_check: Result<(), crate::kernel::Refusal> = Ok(());".to_string()
+                "let tenant_boundary_check: Result<(), crate::kernel::Refusal> = Ok(());"
+                    .to_string()
             } else {
                 format!(
                     "let tenant_boundary_check: Result<(), crate::kernel::Refusal> = \
@@ -462,14 +525,7 @@ pub fn emit_registry(exemplar: &Exemplar, aggregates: &[AggregateEntry]) -> Stri
                 "{dispatch_call}.map(|(_, events)| stamp_payload(events, &payload))"
             ));
 
-            aggregate_arms.push(format!(
-                "          {} => {{\n{}\n          }}",
-                naming::ruby_inspect_string(&c.verb),
-                body.iter()
-                    .map(|l| format!("              {l}"))
-                    .collect::<Vec<_>>()
-                    .join("\n")
-            ));
+            aggregate_arms.push(verb_arm(&c.verb, &body));
         }
     }
 
@@ -484,8 +540,7 @@ pub fn emit_registry(exemplar: &Exemplar, aggregates: &[AggregateEntry]) -> Stri
                     &format!("{mod_path}::{}", c.args_struct),
                     &c.invariant_check_lines,
                     emit_role_check(exemplar, c.role.as_deref(), &c.name),
-                    &c
-                        .reference_checks
+                    &c.reference_checks
                         .iter()
                         .map(|check| emit_reference_check(exemplar, check))
                         .collect::<Vec<_>>()
@@ -501,7 +556,10 @@ pub fn emit_registry(exemplar: &Exemplar, aggregates: &[AggregateEntry]) -> Stri
             // A missing identity is wrapped as NotFound, as in the aggregate arm's `id_line`.
             let entity_parent_no_identity_message = format!(
                 "{} acts on a {}'s {} — pass {}:",
-                c.name, a.record, c.entity_name, a.identified_by.join(", ")
+                c.name,
+                a.record,
+                c.entity_name,
+                a.identified_by.join(", ")
             );
             let entity_element_no_identity_message = format!(
                 "{} acts on one {} — pass {}:",
@@ -519,7 +577,8 @@ pub fn emit_registry(exemplar: &Exemplar, aggregates: &[AggregateEntry]) -> Stri
             );
 
             let mut body: Vec<String> = vec![
-                "let invocation = crate::kernel::CommandInvocation::from_json(args_json)?;".to_string(),
+                "let invocation = crate::kernel::CommandInvocation::from_json(args_json)?;"
+                    .to_string(),
                 "let route = invocation.route();".to_string(),
                 "let facts_json = invocation.facts();".to_string(),
                 "if let Some(route) = route { route.require_depth(1)?; }".to_string(),
@@ -547,14 +606,7 @@ pub fn emit_registry(exemplar: &Exemplar, aggregates: &[AggregateEntry]) -> Stri
             );
             body.push(dispatch_call);
 
-            entity_arms.push(format!(
-                "          {} => {{\n{}\n          }}",
-                naming::ruby_inspect_string(&c.verb),
-                body.iter()
-                    .map(|l| format!("              {l}"))
-                    .collect::<Vec<_>>()
-                    .join("\n")
-            ));
+            entity_arms.push(verb_arm(&c.verb, &body));
         }
     }
 
@@ -571,8 +623,7 @@ pub fn emit_registry(exemplar: &Exemplar, aggregates: &[AggregateEntry]) -> Stri
                     &format!("{mod_path}::{}", c.args_struct),
                     &c.invariant_check_lines,
                     emit_role_check(exemplar, c.role.as_deref(), &c.name),
-                    &c
-                        .reference_checks
+                    &c.reference_checks
                         .iter()
                         .map(|check| emit_reference_check(exemplar, check))
                         .collect::<Vec<_>>()
@@ -587,7 +638,11 @@ pub fn emit_registry(exemplar: &Exemplar, aggregates: &[AggregateEntry]) -> Stri
             // wrong-depth route first. A missing identity wraps into a per-hop NotFound message.
             let entity_parent_no_identity_message = format!(
                 "{} acts on a {}'s {}.{} — pass {}:",
-                c.name, a.record, c.entity_name, c.nested_name, a.identified_by.join(", ")
+                c.name,
+                a.record,
+                c.entity_name,
+                c.nested_name,
+                a.identified_by.join(", ")
             );
             let hop1_no_identity_message = format!(
                 "{} acts on one {} — pass {}:",
@@ -622,7 +677,8 @@ pub fn emit_registry(exemplar: &Exemplar, aggregates: &[AggregateEntry]) -> Stri
             };
 
             let mut body: Vec<String> = vec![
-                "let invocation = crate::kernel::CommandInvocation::from_json(args_json)?;".to_string(),
+                "let invocation = crate::kernel::CommandInvocation::from_json(args_json)?;"
+                    .to_string(),
                 "let route = invocation.route();".to_string(),
                 "let facts_json = invocation.facts();".to_string(),
             ];
@@ -645,14 +701,7 @@ pub fn emit_registry(exemplar: &Exemplar, aggregates: &[AggregateEntry]) -> Stri
             );
             body.push(dispatch_call);
 
-            nested_entity_arms.push(format!(
-                "          {} => {{\n{}\n          }}",
-                naming::ruby_inspect_string(&c.verb),
-                body.iter()
-                    .map(|l| format!("              {l}"))
-                    .collect::<Vec<_>>()
-                    .join("\n")
-            ));
+            nested_entity_arms.push(verb_arm(&c.verb, &body));
         }
     }
 
@@ -670,21 +719,19 @@ pub fn emit_registry(exemplar: &Exemplar, aggregates: &[AggregateEntry]) -> Stri
                 .legacy_receiver_field
                 .as_deref()
                 .map(naming::ruby_inspect_string)
-                .map(|field| format!("Some({field})"))
-                .unwrap_or_else(|| "None".to_string());
+                .map_or_else(|| "None".to_string(), |field| format!("Some({field})"));
             let to_receiver = p
                 .to_receiver_field
                 .as_deref()
                 .map(naming::ruby_inspect_string)
-                .map(|field| format!("Some({field})"))
-                .unwrap_or_else(|| "None".to_string());
+                .map_or_else(|| "None".to_string(), |field| format!("Some({field})"));
 
             let mut body: Vec<String> = vec![
                 "let invocation = crate::kernel::CommandInvocation::from_json(args_json)?;".to_string(),
                 format!("let (id, port_facts) = invocation.split_aggregate_receiver({legacy_receiver}, {to_receiver})?;"),
                 "let facts_json = &port_facts;".to_string(),
                 format!(
-                    "let _instance = store.{}.find(&id).ok_or_else(|| crate::kernel::Refusal::NotFound(format!(\"{} {{:?}} does not exist\", id)))?;",
+                    "let _instance = store.{}.find(&id).ok_or_else(|| crate::kernel::Refusal::NotFound(format!(\"{} {{id:?}} does not exist\")))?;",
                     a.module_name, a.name
                 ),
                 format!("let args = {mod_path}::{}::from_json(facts_json)?;", p.args_struct),
@@ -696,14 +743,7 @@ pub fn emit_registry(exemplar: &Exemplar, aggregates: &[AggregateEntry]) -> Stri
             );
             body.push(dispatch_call);
 
-            port_arms.push(format!(
-                "          {} => {{\n{}\n          }}",
-                naming::ruby_inspect_string(&p.verb),
-                body.iter()
-                    .map(|l| format!("              {l}"))
-                    .collect::<Vec<_>>()
-                    .join("\n")
-            ));
+            port_arms.push(verb_arm(&p.verb, &body));
         }
     }
 
@@ -729,7 +769,10 @@ pub fn emit_registry(exemplar: &Exemplar, aggregates: &[AggregateEntry]) -> Stri
             ("tmpl_dump_arm_placeholder();", dump_arms.join("\n")),
             ("tmpl_seed_arm_placeholder();", seed_arms.join("\n")),
             ("tmpl_query_arm_placeholder();", query_arms.join("\n")),
-            ("tmpl_scan_each_arm_placeholder();", scan_each_arms.join("\n")),
+            (
+                "tmpl_scan_each_arm_placeholder();",
+                scan_each_arms.join("\n"),
+            ),
             (
                 "\"tmpl_verb\" => { tmpl_dispatch_arm_placeholder() }",
                 dispatch_arms.join("\n"),
@@ -841,7 +884,6 @@ mod tests {
             nested_entity_commands: Vec::new(),
             ports: vec![PortEntry {
                 verb: "Banking::SafeDepositBox.PaymentGateway.Receive".to_string(),
-                name: "Receive".to_string(),
                 fn_name: "paymentgateway_receive".to_string(),
                 args_struct: "PaymentGatewayReceiveArgs".to_string(),
                 reference_checks: Vec::new(),
@@ -862,7 +904,9 @@ mod tests {
         assert!(generated.contains("let box_number = facts_json.dig(\"box_number\")"));
         // `from_json` is reached through the `normalize_args` hook; route depth leads the body and
         // identity resolves after every gate.
-        assert!(generated.contains("crate::kernel::decode_aggregate_arguments(facts_json, &crate::kernel::ArgumentGates {"));
+        assert!(generated.contains(
+            "crate::kernel::decode_aggregate_arguments(facts_json, &crate::kernel::ArgumentGates {"
+        ));
         assert!(generated.contains("decode_arguments: &crate::generated::banking::safedepositbox::RentArgs::decode_arguments"));
         assert!(generated.contains("refuse_unknown_arguments: &crate::generated::banking::safedepositbox::RentArgs::refuse_unknown_arguments"));
         assert!(generated.contains("refuse_absent_arguments: &crate::generated::banking::safedepositbox::RentArgs::refuse_absent_arguments"));
@@ -870,7 +914,9 @@ mod tests {
         assert!(generated.contains("if let Some(route) = route { route.require_depth(0)?; }"));
         assert!(generated.contains("Some(route) => route.aggregate().to_string()"));
         assert!(generated.contains("if let Some(route) = route { route.require_depth(1)?; }"));
-        assert!(generated.contains("crate::kernel::decode_entity_arguments(facts_json, &crate::kernel::ArgumentGates {"));
+        assert!(generated.contains(
+            "crate::kernel::decode_entity_arguments(facts_json, &crate::kernel::ArgumentGates {"
+        ));
         assert!(generated.contains("let element_id = route.entities()[0].clone()"));
         assert!(generated.contains("VisitAnnotateArgs::from_json(v)?"));
         assert!(!generated.contains("RentArgs::from_json(facts_json)?"));
@@ -950,7 +996,10 @@ mod tests {
             chapter_mod: "banking".to_string(),
             domain_name: "Banking".to_string(),
             reference_specs: Vec::new(),
-            identified_by: vec!["branch_code.value".to_string(), "box_number.value".to_string()],
+            identified_by: vec![
+                "branch_code.value".to_string(),
+                "box_number.value".to_string(),
+            ],
             entities: Vec::new(),
         };
 

data/rust/codegen/src/reserved_names.rs

@@ -2,57 +2,13 @@
 // CargoReservedName vocabularies (lib/hecks/language/bluebook/
 // vocabulary.bluebook). Do not hand-edit — re-run hecks project_reserved_names.
 
-/// The `RustReservedWord` vocabulary, 49 entries.
+/// The `RustReservedWord` vocabulary, 51 entries.
 pub const RUST_KEYWORDS: &[&str] = &[
-    "as",
-    "break",
-    "const",
-    "continue",
-    "crate",
-    "dyn",
-    "else",
-    "enum",
-    "extern",
-    "false",
-    "fn",
-    "for",
-    "if",
-    "impl",
-    "in",
-    "let",
-    "loop",
-    "match",
-    "mod",
-    "move",
-    "mut",
-    "pub",
-    "ref",
-    "return",
-    "self",
-    "Self",
-    "static",
-    "struct",
-    "super",
-    "trait",
-    "true",
-    "type",
-    "unsafe",
-    "use",
-    "where",
-    "while",
-    "abstract",
-    "become",
-    "box",
-    "do",
-    "final",
-    "macro",
-    "override",
-    "priv",
-    "typeof",
-    "unsized",
-    "virtual",
-    "yield",
-    "try",
+    "as", "async", "await", "break", "const", "continue", "crate", "dyn", "else", "enum", "extern",
+    "false", "fn", "for", "if", "impl", "in", "let", "loop", "match", "mod", "move", "mut", "pub",
+    "ref", "return", "self", "Self", "static", "struct", "super", "trait", "true", "type",
+    "unsafe", "use", "where", "while", "abstract", "become", "box", "do", "final", "macro",
+    "override", "priv", "typeof", "unsized", "virtual", "yield", "try",
 ];
 
 /// The `CargoReservedName` vocabulary, 16 entries.

data/rust/codegen/src/shared.rs

@@ -1,13 +1,55 @@
 //! Predicates ported from the retired Ruby generator's `mutations.rb` that `types.rs` and `json_codec.rs` share.
 
 use crate::json::Json;
-use std::collections::HashMap;
+
+/// Mirrors Ruby's `puts`: appends "\n" only when the string does not already end in one.
+pub fn puts_str(out: &mut String, s: &str) {
+    out.push_str(s);
+    if !s.ends_with('\n') {
+        out.push('\n');
+    }
+}
+
+pub fn puts_blank(out: &mut String) {
+    out.push('\n');
+}
+
+/// The extra `(field, json)` pair a lifecycle contributes to a node's record fields.
+pub fn lifecycle_extra_field(node: &Json) -> Vec<(String, String)> {
+    node.get("lifecycle")
+        .map_or_else(std::vec::Vec::new, |lifecycle| {
+            let field = lifecycle.get("field").and_then(Json::as_str).unwrap_or("");
+            let ident = crate::naming::rust_ident_field(field);
+            vec![(
+                crate::naming::rust_field(field),
+                format!("crate::kernel::Json::Str(self.{ident}.clone())"),
+            )]
+        })
+}
+
+/// Ruby's `String#to_i`: parses a leading integer prefix, 0 when there is none.
+pub fn ruby_to_i(s: &str) -> i64 {
+    let trimmed = s.trim_start();
+    let bytes = trimmed.as_bytes();
+    let mut end = 0;
+    if end < bytes.len() && (bytes[end] == b'-' || bytes[end] == b'+') {
+        end += 1;
+    }
+    let digits_start = end;
+    while end < bytes.len() && bytes[end].is_ascii_digit() {
+        end += 1;
+    }
+    if end == digits_start {
+        return 0;
+    }
+    trimmed[..end].parse().unwrap_or(0)
+}
 
 /// Argument names claimed by an append, so an append's element-field argument never bare-name-
 /// matches an unrelated owner field. Shared by `creates_owner` and `identity_components`.
 pub fn append_claimed_names(command: &Json) -> std::collections::HashSet<String> {
     let mut claimed = std::collections::HashSet::new();
-    for m in command.get("mutations").map(Json::each).unwrap_or(&[]) {
+    for m in command.get("mutations").map_or_default(Json::each) {
         if m.get("op").map(Json::to_s).as_deref() != Some("append") {
             continue;
         }
@@ -28,26 +70,32 @@ pub fn append_claimed_names(command: &Json) -> std::collections::HashSet<String>
 /// A command with `references` acts on an existing record. Otherwise it creates when it supplies,
 /// via a `:set` mutation or a same-named argument, a required non-list owner field, ignoring
 /// arguments claimed by an append (`append_claimed_names`).
-pub fn creates_owner(aggregate: &Json, command: &Json, _value_objects_by_name: &HashMap<String, &Json>) -> bool {
+pub fn creates_owner(aggregate: &Json, command: &Json) -> bool {
     if command.get("references").is_some() {
         return false;
     }
 
-    let attrs = aggregate.get("attributes").map(Json::each).unwrap_or(&[]);
-    let owner_fields: std::collections::HashSet<String> = attrs.iter().map(|a| crate::attr::name(a).to_string()).collect();
-    let required_fields: std::collections::HashSet<String> =
-        attrs.iter().filter(|a| !crate::attr::list(a) && !crate::attr::optional(a)).map(|a| crate::attr::name(a).to_string()).collect();
+    let attrs = aggregate.get("attributes").map_or_default(Json::each);
+    let owner_fields: std::collections::HashSet<String> = attrs
+        .iter()
+        .map(|a| crate::attr::name(a).to_string())
+        .collect();
+    let required_fields: std::collections::HashSet<String> = attrs
+        .iter()
+        .filter(|a| !crate::attr::list(a) && !crate::attr::optional(a))
+        .map(|a| crate::attr::name(a).to_string())
+        .collect();
 
     let append_claimed = append_claimed_names(command);
 
     let mut known_writes: std::collections::HashSet<String> = std::collections::HashSet::new();
-    for attr in command.get("attributes").map(Json::each).unwrap_or(&[]) {
+    for attr in command.get("attributes").map_or_default(Json::each) {
         let name = crate::attr::name(attr).to_string();
         if owner_fields.contains(&name) && !append_claimed.contains(&name) {
             known_writes.insert(name);
         }
     }
-    for m in command.get("mutations").map(Json::each).unwrap_or(&[]) {
+    for m in command.get("mutations").map_or_default(Json::each) {
         if m.get("op").map(Json::to_s).as_deref() != Some("set") {
             continue;
         }
@@ -57,37 +105,38 @@ pub fn creates_owner(aggregate: &Json, command: &Json, _value_objects_by_name: &
         }
     }
 
-    required_fields.iter().any(|field| known_writes.contains(field))
+    required_fields
+        .iter()
+        .any(|field| known_writes.contains(field))
 }
 
 /// Whether a list-typed attribute reads `nil` rather than `[]` in Ruby; see
 /// `mutations.rb#list_attr_creation_optional?`.
-pub fn list_attr_creation_optional(aggregate: &Json, attr_name: &str, value_objects_by_name: &HashMap<String, &Json>) -> bool {
-    let commands = aggregate.get("commands").map(Json::each).unwrap_or(&[]);
+pub fn list_attr_creation_optional(aggregate: &Json, attr_name: &str) -> bool {
+    let commands = aggregate.get("commands").map_or_default(Json::each);
     commands.iter().any(|command| {
-        if !creates_owner(aggregate, command, value_objects_by_name) {
+        if !creates_owner(aggregate, command) {
             return false;
         }
-        let mutations = command.get("mutations").map(Json::each).unwrap_or(&[]);
+        let mutations = command.get("mutations").map_or_default(Json::each);
         mutations.iter().any(|m| {
             let op = m.get("op").map(Json::to_s).unwrap_or_default();
             let target = m.get("target").map(Json::to_s).unwrap_or_default();
             if op != "set" || target != attr_name {
                 return false;
             }
-            let source = match m.get("source") {
-                Some(s) => s,
-                None => return false,
+            let Some(source) = m.get("source") else {
+                return false;
             };
             if source.get("kind").map(Json::to_s).unwrap_or_default() != "argument" {
                 return false;
             }
             let source_name = source.get("name").map(Json::to_s).unwrap_or_default();
-            let attrs = command.get("attributes").map(Json::each).unwrap_or(&[]);
-            match attrs.iter().find(|a| crate::attr::name(a) == source_name) {
-                Some(source_attr) => crate::attr::optional(source_attr),
-                None => false,
-            }
+            let attrs = command.get("attributes").map_or_default(Json::each);
+            attrs
+                .iter()
+                .find(|a| crate::attr::name(a) == source_name)
+                .is_some_and(crate::attr::optional)
         })
     })
 }