hecks 3.14.0 → 4.0.0

data/rust/codegen/src/constraints.rs

@@ -5,12 +5,16 @@ use crate::json::Json;
 use crate::naming;
 
 /// The scalar `admitted_scalar`/`check_patterns` actually operate on.
-pub fn scalar_field_expr(value_expr: &str, attr_type: &str, value_objects_by_name: &std::collections::HashMap<String, &Json>) -> Option<String> {
+pub fn scalar_field_expr(
+    value_expr: &str,
+    attr_type: &str,
+    value_objects_by_name: &std::collections::HashMap<String, &Json>,
+) -> Option<String> {
     if attr_type == "String" {
         return Some(value_expr.to_string());
     }
     let vo = value_objects_by_name.get(attr_type)?;
-    let attrs = vo.get("attributes").map(Json::each).unwrap_or(&[]);
+    let attrs = vo.get("attributes").map_or_default(Json::each);
     if attrs.len() != 1 {
         return None;
     }
@@ -29,11 +33,19 @@ fn optional_scalar_expr(
     value_objects_by_name: &std::collections::HashMap<String, &Json>,
 ) -> Option<(String, Option<String>)> {
     if !crate::attr::optional(attr) {
-        let scalar = scalar_field_expr(value_expr, crate::attr::type_name(attr), value_objects_by_name)?;
+        let scalar = scalar_field_expr(
+            value_expr,
+            crate::attr::type_name(attr),
+            value_objects_by_name,
+        )?;
         return Some((scalar, None));
     }
 
-    let scalar = scalar_field_expr(OPTIONAL_BINDING, crate::attr::type_name(attr), value_objects_by_name)?;
+    let scalar = scalar_field_expr(
+        OPTIONAL_BINDING,
+        crate::attr::type_name(attr),
+        value_objects_by_name,
+    )?;
     Some((scalar, Some(value_expr.to_string())))
 }
 
@@ -45,23 +57,30 @@ fn wrap_if_optional(check: String, optional_source: Option<String>) -> String {
 }
 
 /// `"Aggregate::SetName"` resolved against the full domain.
-pub fn admitted_set_members(admits: &str, aggregates_by_name: &std::collections::HashMap<String, &Json>) -> Option<Vec<String>> {
-    let mut parts = admits.splitn(2, "::");
-    let aggregate_name = parts.next()?;
-    let set_name = parts.next()?;
+pub fn admitted_set_members(
+    admits: &str,
+    aggregates_by_name: &std::collections::HashMap<String, &Json>,
+) -> Option<Vec<String>> {
+    let (aggregate_name, set_name) = admits.split_once("::")?;
+
     let aggregate = aggregates_by_name.get(aggregate_name)?;
-    let vos = aggregate.get("value_objects").map(Json::each).unwrap_or(&[]);
-    let vo = vos.iter().find(|v| v.get("name").and_then(Json::as_str) == Some(set_name))?;
-    if !vo.get("closed_set").map(Json::as_bool).unwrap_or(false) {
+    let vos = aggregate.get("value_objects").map_or_default(Json::each);
+    let vo = vos
+        .iter()
+        .find(|v| v.get("name").and_then(Json::as_str) == Some(set_name))?;
+    if !vo.get("closed_set").is_some_and(Json::as_bool) {
         return None;
     }
-    let members = vo.get("members").map(Json::each).unwrap_or(&[]);
+    let members = vo.get("members").map_or_default(Json::each);
     Some(
         members
             .iter()
             .map(|row| {
                 let pairs = row.as_array().unwrap_or(&[]);
-                let first = pairs.first().and_then(|pair| pair.as_array()).unwrap_or(&[]);
+                let first = pairs
+                    .first()
+                    .and_then(|pair| pair.as_array())
+                    .unwrap_or(&[]);
                 first.get(1).map(Json::to_s).unwrap_or_default()
             })
             .collect(),
@@ -79,30 +98,58 @@ pub fn emit_admits_check(
     let members = admitted_set_members(admits, aggregates_by_name)?;
     let (scalar, optional_source) = optional_scalar_expr(value_expr, attr, value_objects_by_name)?;
 
-    let members_array = format!("[{}]", members.iter().map(|m| naming::ruby_inspect_string(m)).collect::<Vec<_>>().join(", "));
+    let members_array = format!(
+        "[{}]",
+        members
+            .iter()
+            .map(|m| naming::ruby_inspect_string(m))
+            .collect::<Vec<_>>()
+            .join(", ")
+    );
     let check = exemplar.render(
         "admits_check",
         &[
             ("[\"tmpl_member_a\", \"tmpl_member_b\"]", members_array),
             ("tmpl_scalar", scalar),
-            ("\"tmpl_admits_name\"", naming::ruby_inspect_string(crate::attr::name(attr))),
-            ("\"tmpl_admits_target\"", naming::ruby_inspect_string(admits)),
+            (
+                "\"tmpl_admits_name\"",
+                naming::ruby_inspect_string(crate::attr::name(attr)),
+            ),
+            (
+                "\"tmpl_admits_target\"",
+                naming::ruby_inspect_string(admits),
+            ),
         ],
     );
     Some(wrap_if_optional(check, optional_source))
 }
 
-pub fn emit_pattern_check(exemplar: &Exemplar, value_expr: &str, attr: &Json, owner_type_name: &str, value_objects_by_name: &std::collections::HashMap<String, &Json>) -> Option<String> {
+pub fn emit_pattern_check(
+    exemplar: &Exemplar,
+    value_expr: &str,
+    attr: &Json,
+    owner_type_name: &str,
+    value_objects_by_name: &std::collections::HashMap<String, &Json>,
+) -> Option<String> {
     let pattern = crate::attr::pattern(attr)?;
     let (scalar, optional_source) = optional_scalar_expr(value_expr, attr, value_objects_by_name)?;
 
     let check = exemplar.render(
         "pattern_check",
         &[
-            ("\"tmpl_pattern_text\"", naming::ruby_inspect_string(pattern)),
+            (
+                "\"tmpl_pattern_text\"",
+                naming::ruby_inspect_string(pattern),
+            ),
             ("tmpl_scalar", scalar),
-            ("\"tmpl_pattern_owner\"", naming::ruby_inspect_string(owner_type_name)),
-            ("\"tmpl_pattern_field\"", naming::ruby_inspect_string(crate::attr::name(attr))),
+            (
+                "\"tmpl_pattern_owner\"",
+                naming::ruby_inspect_string(owner_type_name),
+            ),
+            (
+                "\"tmpl_pattern_field\"",
+                naming::ruby_inspect_string(crate::attr::name(attr)),
+            ),
         ],
     );
     Some(wrap_if_optional(check, optional_source))
@@ -111,19 +158,35 @@ pub fn emit_pattern_check(exemplar: &Exemplar, value_expr: &str, attr: &Json, ow
 /// A `pattern:` on a list of Strings, checked once per member: Ruby's `check_patterns` walks
 /// `offered_items`, so every element of the list must match, and an optional list left unset has
 /// none to check. Lists of anything but plain Strings get no check.
-pub fn emit_list_pattern_check(exemplar: &Exemplar, value_expr: &str, attr: &Json, owner_type_name: &str) -> Option<String> {
+pub fn emit_list_pattern_check(
+    exemplar: &Exemplar,
+    value_expr: &str,
+    attr: &Json,
+    owner_type_name: &str,
+) -> Option<String> {
     let pattern = crate::attr::pattern(attr)?;
-    if !crate::attr::list(attr) || naming::effective_scalar_type(crate::attr::type_name(attr)) != Some("String") {
+    if !crate::attr::list(attr)
+        || naming::effective_scalar_type(crate::attr::type_name(attr)) != Some("String")
+    {
         return None;
     }
 
     let check = exemplar.render(
         "pattern_check",
         &[
-            ("\"tmpl_pattern_text\"", naming::ruby_inspect_string(pattern)),
+            (
+                "\"tmpl_pattern_text\"",
+                naming::ruby_inspect_string(pattern),
+            ),
             ("tmpl_scalar", "item".to_string()),
-            ("\"tmpl_pattern_owner\"", naming::ruby_inspect_string(owner_type_name)),
-            ("\"tmpl_pattern_field\"", naming::ruby_inspect_string(crate::attr::name(attr))),
+            (
+                "\"tmpl_pattern_owner\"",
+                naming::ruby_inspect_string(owner_type_name),
+            ),
+            (
+                "\"tmpl_pattern_field\"",
+                naming::ruby_inspect_string(crate::attr::name(attr)),
+            ),
         ],
     );
     Some(if crate::attr::optional(attr) {

data/rust/codegen/src/dependency_planning.rs

@@ -8,32 +8,59 @@ use std::collections::{HashMap, HashSet};
 /// True when every owner field of a creating command is written from known values.
 ///
 /// The router uses it alone to decide whether a route is checked against derived identity.
-pub fn complete_state_creation(aggregate: &Json, command: &Json, value_objects_by_name: &HashMap<String, &Json>) -> bool {
+pub fn complete_state_creation(
+    aggregate: &Json,
+    command: &Json,
+    value_objects_by_name: &HashMap<String, &Json>,
+) -> bool {
     let owner_fields = owner_fields(aggregate);
-    let payload_fields: HashSet<String> = command.get("attributes").map(Json::each).unwrap_or(&[]).iter().map(|a| crate::attr::name(a).to_string()).collect();
+    let payload_fields: HashSet<String> = command
+        .get("attributes")
+        .map_or_default(Json::each)
+        .iter()
+        .map(|a| crate::attr::name(a).to_string())
+        .collect();
 
-    let (known_writes, disqualified) = known_writes(aggregate, command, &owner_fields, &payload_fields, value_objects_by_name);
-    !disqualified && owner_fields.iter().all(|field| known_writes.contains(field))
+    let (known_writes, disqualified) = known_writes(
+        aggregate,
+        command,
+        &owner_fields,
+        &payload_fields,
+        value_objects_by_name,
+    );
+    !disqualified
+        && owner_fields
+            .iter()
+            .all(|field| known_writes.contains(field))
 }
 
 /// True when a creating command's result does not depend on prior state.
 ///
 /// Only meaningful for a command `crate::shared::creates_owner` answered `true` for.
-pub fn state_independent_creation(aggregate: &Json, command: &Json, value_objects_by_name: &HashMap<String, &Json>) -> bool {
+pub fn state_independent_creation(
+    aggregate: &Json,
+    command: &Json,
+    value_objects_by_name: &HashMap<String, &Json>,
+) -> bool {
     if !complete_state_creation(aggregate, command, value_objects_by_name) {
         return false;
     }
     let owner_fields = owner_fields(aggregate);
-    let payload_fields: HashSet<String> = command.get("attributes").map(Json::each).unwrap_or(&[]).iter().map(|a| crate::attr::name(a).to_string()).collect();
+    let payload_fields: HashSet<String> = command
+        .get("attributes")
+        .map_or_default(Json::each)
+        .iter()
+        .map(|a| crate::attr::name(a).to_string())
+        .collect();
 
     let mut rules: Vec<(&Json, bool)> = Vec::new();
-    for rule in command.get("givens").map(Json::each).unwrap_or(&[]) {
+    for rule in command.get("givens").map_or_default(Json::each) {
         rules.push((rule, true)); // `true` == "before" (a given)
     }
-    for rule in command.get("ensures").map(Json::each).unwrap_or(&[]) {
+    for rule in command.get("ensures").map_or_default(Json::each) {
         rules.push((rule, false));
     }
-    for rule in aggregate.get("invariants").map(Json::each).unwrap_or(&[]) {
+    for rule in aggregate.get("invariants").map_or_default(Json::each) {
         rules.push((rule, false));
     }
 
@@ -44,11 +71,16 @@ pub fn state_independent_creation(aggregate: &Json, command: &Json, value_object
 }
 
 fn owner_fields(aggregate: &Json) -> HashSet<String> {
-    let mut fields: HashSet<String> = aggregate.get("attributes").map(Json::each).unwrap_or(&[]).iter().map(|a| crate::attr::name(a).to_string()).collect();
+    let mut fields: HashSet<String> = aggregate
+        .get("attributes")
+        .map_or_default(Json::each)
+        .iter()
+        .map(|a| crate::attr::name(a).to_string())
+        .collect();
     if let Some(lifecycle) = aggregate.get("lifecycle") {
         fields.insert(lifecycle.get("field").map(Json::to_s).unwrap_or_default());
     }
-    for field in aggregate.get("projected_fields").map(Json::each).unwrap_or(&[]) {
+    for field in aggregate.get("projected_fields").map_or_default(Json::each) {
         fields.insert(field.get("name").map(Json::to_s).unwrap_or_default());
     }
     fields
@@ -60,7 +92,11 @@ enum Classification {
     Unresolved,
 }
 
-fn classify_symbol(name: &str, payload_fields: &HashSet<String>, owner_fields: &HashSet<String>) -> Classification {
+fn classify_symbol(
+    name: &str,
+    payload_fields: &HashSet<String>,
+    owner_fields: &HashSet<String>,
+) -> Classification {
     if payload_fields.contains(name) {
         Classification::Known
     } else if owner_fields.contains(name) {
@@ -72,9 +108,17 @@ fn classify_symbol(name: &str, payload_fields: &HashSet<String>, owner_fields: &
 
 // A `StateRef` source falls through to `Known`, matching the Ruby Analyzer, which has no
 // `when StateRef` branch.
-fn classify_source(source: &Json, payload_fields: &HashSet<String>, owner_fields: &HashSet<String>) -> Classification {
+fn classify_source(
+    source: &Json,
+    payload_fields: &HashSet<String>,
+    owner_fields: &HashSet<String>,
+) -> Classification {
     match source.get("kind").map(Json::to_s).as_deref() {
-        Some("argument") => classify_symbol(&source.get("name").map(Json::to_s).unwrap_or_default(), payload_fields, owner_fields),
+        Some("argument") => classify_symbol(
+            &source.get("name").map(Json::to_s).unwrap_or_default(),
+            payload_fields,
+            owner_fields,
+        ),
         _ => Classification::Known,
     }
 }
@@ -87,12 +131,14 @@ fn known_writes(
     value_objects_by_name: &HashMap<String, &Json>,
 ) -> (HashSet<String>, bool) {
     let mut known = HashSet::new();
-    for attr in aggregate.get("attributes").map(Json::each).unwrap_or(&[]) {
+    for attr in aggregate.get("attributes").map_or_default(Json::each) {
         if deterministic_initial_value(attr, value_objects_by_name) {
             known.insert(crate::attr::name(attr).to_string());
         }
     }
-    let lifecycle_field = aggregate.get("lifecycle").map(|l| l.get("field").map(Json::to_s).unwrap_or_default());
+    let lifecycle_field = aggregate
+        .get("lifecycle")
+        .map(|l| l.get("field").map(Json::to_s).unwrap_or_default());
     if let Some(field) = &lifecycle_field {
         known.insert(field.clone());
     }
@@ -100,7 +146,7 @@ fn known_writes(
     // A creating command guarded by a lifecycle `from:` state has no prior state to check.
     let mut disqualified = command.get("from").is_some() && aggregate.get("lifecycle").is_some();
 
-    for mutation in command.get("mutations").map(Json::each).unwrap_or(&[]) {
+    for mutation in command.get("mutations").map_or_default(Json::each) {
         let target = mutation.get("target").map(Json::to_s).unwrap_or_default();
         let op = mutation.get("op").map(Json::to_s).unwrap_or_default();
 
@@ -125,7 +171,10 @@ fn known_writes(
                     for (_, wire_value) in pairs {
                         let parsed = literal::read(wire_value.as_str().unwrap_or(""));
                         if let Literal::Symbol(name) = parsed {
-                            if matches!(classify_symbol(&name, payload_fields, owner_fields), Classification::Unresolved) {
+                            if matches!(
+                                classify_symbol(&name, payload_fields, owner_fields),
+                                Classification::Unresolved
+                            ) {
                                 disqualified = true;
                             }
                         }
@@ -142,20 +191,37 @@ fn known_writes(
     (known, disqualified)
 }
 
-fn deterministic_initial_value(attr: &Json, value_objects_by_name: &HashMap<String, &Json>) -> bool {
-    if crate::attr::list(attr) || crate::attr::optional(attr) || crate::attr::default(attr).is_some() {
+fn deterministic_initial_value(
+    attr: &Json,
+    value_objects_by_name: &HashMap<String, &Json>,
+) -> bool {
+    if crate::attr::list(attr)
+        || crate::attr::optional(attr)
+        || crate::attr::default(attr).is_some()
+    {
         return true;
     }
 
-    match value_objects_by_name.get(crate::attr::type_name(attr)) {
-        Some(vo) => vo.get("attributes").map(Json::each).unwrap_or(&[]).iter().all(|field| crate::attr::default(field).is_some()),
-        None => false,
-    }
+    value_objects_by_name
+        .get(crate::attr::type_name(attr))
+        .is_some_and(|vo| {
+            vo.get("attributes")
+                .map_or_default(Json::each)
+                .iter()
+                .all(|field| crate::attr::default(field).is_some())
+        })
 }
 
 // `before` is true for a `given`, false for an `ensures` or invariant.
-fn rule_state_independent(ast: &Json, before: bool, payload_fields: &HashSet<String>, owner_fields: &HashSet<String>) -> bool {
-    paths(ast, &HashSet::new()).iter().all(|path| path_state_independent(path, before, payload_fields, owner_fields))
+fn rule_state_independent(
+    ast: &Json,
+    before: bool,
+    payload_fields: &HashSet<String>,
+    owner_fields: &HashSet<String>,
+) -> bool {
+    paths(ast, &HashSet::new())
+        .iter()
+        .all(|path| path_state_independent(path, before, payload_fields, owner_fields))
 }
 
 // Only `lookup` and `block_predicate` nodes are special-cased; the rest recurse.
@@ -165,33 +231,61 @@ fn paths(node: &Json, bound_names: &HashSet<String>) -> Vec<String> {
             let op = pairs.iter().find(|(k, _)| k == "op").map(|(_, v)| v.to_s());
             match op.as_deref() {
                 Some("lookup") => {
-                    let segments = pairs.iter().find(|(k, _)| k == "path").map(|(_, v)| v.each()).unwrap_or(&[]);
+                    let segments = pairs
+                        .iter()
+                        .find(|(k, _)| k == "path")
+                        .map_or_default(|(_, v)| v.each());
                     let root = segments.first().map(Json::to_s).unwrap_or_default();
                     if bound_names.contains(&root) {
                         vec![]
                     } else {
-                        vec![segments.iter().map(Json::to_s).collect::<Vec<_>>().join(".")]
+                        vec![segments
+                            .iter()
+                            .map(Json::to_s)
+                            .collect::<Vec<_>>()
+                            .join(".")]
                     }
                 }
                 Some("block_predicate") => {
-                    let receiver = pairs.iter().find(|(k, _)| k == "receiver").map(|(_, v)| v).unwrap_or(&Json::Null);
-                    let predicate = pairs.iter().find(|(k, _)| k == "predicate").map(|(_, v)| v).unwrap_or(&Json::Null);
-                    let param = pairs.iter().find(|(k, _)| k == "param").map(|(_, v)| v.to_s()).unwrap_or_default();
+                    let receiver = pairs
+                        .iter()
+                        .find(|(k, _)| k == "receiver")
+                        .map_or(&Json::Null, |(_, v)| v);
+                    let predicate = pairs
+                        .iter()
+                        .find(|(k, _)| k == "predicate")
+                        .map_or(&Json::Null, |(_, v)| v);
+                    let param = pairs
+                        .iter()
+                        .find(|(k, _)| k == "param")
+                        .map(|(_, v)| v.to_s())
+                        .unwrap_or_default();
                     let mut bound_with_param = bound_names.clone();
                     bound_with_param.insert(param);
                     let mut found = paths(receiver, bound_names);
                     found.extend(paths(predicate, &bound_with_param));
                     found
                 }
-                _ => pairs.iter().flat_map(|(_, value)| paths(value, bound_names)).collect(),
+                _ => pairs
+                    .iter()
+                    .flat_map(|(_, value)| paths(value, bound_names))
+                    .collect(),
             }
         }
-        Json::Array(items) => items.iter().flat_map(|value| paths(value, bound_names)).collect(),
+        Json::Array(items) => items
+            .iter()
+            .flat_map(|value| paths(value, bound_names))
+            .collect(),
         _ => vec![],
     }
 }
 
-fn path_state_independent(path: &str, before: bool, payload_fields: &HashSet<String>, owner_fields: &HashSet<String>) -> bool {
+fn path_state_independent(
+    path: &str,
+    before: bool,
+    payload_fields: &HashSet<String>,
+    owner_fields: &HashSet<String>,
+) -> bool {
     let head = path.split('.').next().unwrap_or("");
 
     match head {