hecks 4.0.0 → 6.0.0

data/rust/codegen/src/read_models.rs

@@ -3,6 +3,7 @@
 
 use crate::exemplar::Exemplar;
 use crate::json::Json;
+use crate::presenters::unwrap_json_expr;
 use crate::queries;
 use crate::shared::ruby_to_i;
 use crate::skip_reason::{reskip, skip, SkipReason};
@@ -442,7 +443,7 @@ fn aggregation_skip_reason(
 }
 
 // Mirrors the retired Ruby generator's `read_models.rb`'s `group_by_skip_reason`: the one
-// shape the corpus declares — a single rootless head, group_by alone.
+// shape the corpus declares — a single rootless head, group_by alone or with one reduction.
 fn group_by_skip_reason(
     read_model: &Json,
     aggregates_by_name: &HashMap<String, &Json>,
@@ -456,16 +457,6 @@ fn group_by_skip_reason(
     if reference_target.is_some() && !matches!(reference_target, Some(Json::Null)) {
         return Some(skip("group_by", format!("declares group_by on a NON-rootless read model (reference_to {}) — not generated yet", reference_target.map(Json::to_s).unwrap_or_default())));
     }
-    if read_model.get("count").is_some()
-        || AGGREGATION_FIELD_KEYS
-            .iter()
-            .any(|key| read_model.get(key).is_some())
-    {
-        return Some(skip(
-            "group_by",
-            "declares group_by alongside a reduction — not generated yet",
-        ));
-    }
     let has_wheres = read_model
         .get("wheres")
         .map_or_default(Json::each)
@@ -514,7 +505,9 @@ fn group_by_skip_reason(
             return Some(skip("group_by", format!("group_by names {field:?}, but {aggregate_name} declares no such attribute — not generated yet")));
         }
     }
-    None
+    // A grouped reduction reduces each leaf (ADR 0126): its field is checked like an
+    // ungrouped one's.
+    aggregation_skip_reason(read_model, aggregates_by_name)
 }
 
 // Every entity name nested at any depth under a declared aggregate.
@@ -826,6 +819,7 @@ pub fn read_model_def(
                 &read_model_name,
                 aggregate,
                 &group_by_fields,
+                reduction_of(read_model).as_deref(),
             )),
         )
     };
@@ -933,11 +927,13 @@ fn emit_filtered_head(fh: &FilteredHeadDef) -> String {
 // Keeps this aggregate's declared attributes plus any `projects` field, id
 // and lifecycle field, excluding other capabilities' synthetic fields (like
 // `corrects`'s `emitted_*` flags), and unwraps value objects recursively.
+// With a reduction, each leaf is that reduction of its rows (ADR 0126).
 fn emit_group_by_transform(
     fn_name: &str,
     read_model_name: &str,
     aggregate: &Json,
     group_by_fields: &[String],
+    reduction: Option<&str>,
 ) -> String {
     let value_objects: Vec<&Json> = aggregate
         .get("value_objects")
@@ -995,10 +991,20 @@ fn emit_group_by_transform(
             .collect::<Vec<_>>()
             .join(", ")
     );
-    let leaf_check = group_by_leaf_check(read_model_name, aggregate, group_by_fields);
+    let nest_call = reduction.map_or_else(
+        || {
+            let leaf_check = group_by_leaf_check(read_model_name, aggregate, group_by_fields);
+            format!("crate::kernel::read_model::nest(unwrapped, {fields_literal}, {leaf_check})")
+        },
+        |r| {
+            format!(
+                "crate::kernel::read_model::nest_reduced(unwrapped, {fields_literal}, crate::kernel::read_model::Reduction::{r})"
+            )
+        },
+    );
 
     format!(
-        "pub fn {fn_name}(rows: Vec<(String, crate::kernel::Json)>) -> Result<crate::kernel::Json, crate::kernel::Refusal> {{\n    let unwrapped: Vec<crate::kernel::Json> = rows\n        .into_iter()\n        .map(|(id, record)| {{\n            let wrapped = crate::kernel::repository::row_json(id, record);\n            match wrapped {{\n                crate::kernel::Json::Object(fields) => crate::kernel::Json::Object(\n                    fields\n                        .into_iter()\n                        .filter(|(k, _)| {keep_cond})\n                        .map(|(k, v)| {{\n                            let new_v = match k.as_str() {{\n            {arms}\n                                _ => v,\n                            }};\n                            (k, new_v)\n                        }})\n                        .collect(),\n                ),\n                other => other,\n            }}\n        }})\n        .collect();\n    crate::kernel::read_model::nest(unwrapped, {fields_literal}, {leaf_check})\n}}"
+        "pub fn {fn_name}(rows: Vec<(String, crate::kernel::Json)>) -> Result<crate::kernel::Json, crate::kernel::Refusal> {{\n    let unwrapped: Vec<crate::kernel::Json> = rows\n        .into_iter()\n        .map(|(id, record)| {{\n            let wrapped = crate::kernel::repository::row_json(id, record);\n            match wrapped {{\n                crate::kernel::Json::Object(fields) => crate::kernel::Json::Object(\n                    fields\n                        .into_iter()\n                        .filter(|(k, _)| {keep_cond})\n                        .map(|(k, v)| {{\n                            let new_v = match k.as_str() {{\n            {arms}\n                                _ => v,\n                            }};\n                            (k, new_v)\n                        }})\n                        .collect(),\n                ),\n                other => other,\n            }}\n        }})\n        .collect();\n    {nest_call}\n}}"
     )
 }
 
@@ -1030,63 +1036,6 @@ fn group_by_leaf_check(
     )
 }
 
-// Port of `Value.materialize_unwrapped` (Ruby).
-fn unwrap_json_expr(
-    expr: &str,
-    type_name: &str,
-    list: bool,
-    aggregate: &Json,
-    value_objects_by_name: &HashMap<String, &Json>,
-) -> String {
-    if list {
-        let inner = unwrap_json_expr("item", type_name, false, aggregate, value_objects_by_name);
-        return format!("match {expr} {{ crate::kernel::Json::Array(items) => crate::kernel::Json::Array(items.into_iter().map(|item| {inner}).collect()), other => other }}");
-    }
-
-    let vo = value_objects_by_name.get(type_name).copied();
-    let entity = aggregate
-        .get("entities")
-        .map_or_default(Json::each)
-        .iter()
-        .find(|e| e.get("name").map(Json::to_s).unwrap_or_default() == type_name);
-    let fields_meta: Option<&[Json]> = vo.map_or_else(
-        || entity.and_then(|e| e.get("attributes").map(Json::each)),
-        |vo| vo.get("attributes").map(Json::each),
-    );
-    let Some(fields_meta) = fields_meta else {
-        return expr.to_string();
-    };
-
-    if vo.is_some() && fields_meta.len() == 1 {
-        let field = &fields_meta[0];
-        let unwrapped = unwrap_json_expr(
-            "field_value",
-            crate::attr::type_name(field),
-            crate::attr::list(field),
-            aggregate,
-            value_objects_by_name,
-        );
-        let field_name = crate::attr::name(field);
-        return format!("match {expr} {{ crate::kernel::Json::Object(fields) => fields.into_iter().find(|(k, _)| k == {field_name:?}).map_or(crate::kernel::Json::Null, |(_, field_value)| {unwrapped}), other => other }}");
-    }
-
-    let inner_arms: Vec<String> = fields_meta
-        .iter()
-        .map(|f| {
-            let unwrapped = unwrap_json_expr(
-                "v",
-                crate::attr::type_name(f),
-                crate::attr::list(f),
-                aggregate,
-                value_objects_by_name,
-            );
-            format!("{:?} => {unwrapped},", crate::attr::name(f))
-        })
-        .collect();
-    let inner_arms = inner_arms.join(" ");
-    format!("match {expr} {{ crate::kernel::Json::Object(fields) => crate::kernel::Json::Object(fields.into_iter().map(|(k, v)| {{ let new_v = match k.as_str() {{ {inner_arms} _ => v }}; (k, new_v) }}).collect()), other => other }}")
-}
-
 const READ_MODEL_TABLE_ROW_PLACEHOLDER: &str = "crate::kernel::read_model::ReadModelDef {\n    verb: \"tmpl_verb\",\n    reference_name: Some(\"tmpl_reference_name\"),\n    heads: &[\n        crate::kernel::read_model::ReadModelHead {\n            aggregate: \"tmpl_aggregate\",\n            as_name: \"tmpl_as_name\",\n            many: true,\n            is_root: false,\n            reference_fields: &[\n                crate::kernel::read_model::ReferenceField { target_aggregate: \"tmpl_target_aggregate\", field: \"tmpl_field\" },\n            ],\n        },\n    ],\n    filtered_heads: &[\n        crate::kernel::read_model::FilteredHead { as_name: \"tmpl_as_name\", conditions: &[crate::kernel::QueryCondition { field: \"tmpl_field\", comparator: crate::kernel::query_comparators::QueryComparator::Eq, value: crate::kernel::QueryConditionValue::Literal(\"tmpl_literal\") },], reference_hop_conditions: &[crate::kernel::read_model::ReferenceHopCondition { via_field: \"tmpl_via_field\", target_aggregate: \"tmpl_target_aggregate\", through: &[crate::kernel::read_model::HopStep { via_field: \"tmpl_via_field\", target_aggregate: \"tmpl_target_aggregate\" }], inner_field: \"tmpl_inner_field\", inner_comparator: crate::kernel::query_comparators::QueryComparator::Eq, inner_value: crate::kernel::QueryConditionValue::Literal(\"tmpl_literal\") },], order_by: Some(crate::kernel::read_model::ReadModelOrderBy { field: \"tmpl_order_field\", descending: true, nulls: crate::kernel::query_ordering::NullsMode::Last }), offset: Some(crate::kernel::read_model::ReadModelOffset::Literal(1)), limit: Some(crate::kernel::read_model::ReadModelLimit::Literal(5)) },\n    ],\n    authorization: Some(crate::kernel::named_query::TenantAuth { query_name: \"tmpl_query_name\", tenant_field: \"tmpl_tenant_field\", policy: \"tmpl_policy\" }),\n    group_by: None,\n    reduction: None,\n},";
 
 pub fn emit_read_model_table(exemplar: &Exemplar, read_model_defs: &[ReadModelDef]) -> String {

data/rust/codegen/src/registry.rs

@@ -12,6 +12,9 @@ pub struct ReferenceCheck {
     pub optional: bool,
     /// `Some(element key expression)` for a list (`has_many`) check.
     pub list_item: Option<String>,
+    /// `Some(variant)` for a tagged `one_of` reference: the check runs only when the argument's
+    /// `type` names this variant (ADR 0127).
+    pub union_tag: Option<String>,
     pub target_mod: String,
     pub target_name: String,
     pub heads: String,
@@ -47,6 +50,8 @@ pub struct CommandEntry {
     /// role and reference checks. `commands.rs::emit_command` repeats them in the dispatch fn.
     pub invariant_check_lines: Vec<String>,
     pub role: Option<String>,
+    /// Every role that may run the command, when more than one may; `role` is then the first.
+    pub roles: Vec<String>,
 }
 
 pub struct EntityCommandEntry {
@@ -62,6 +67,8 @@ pub struct EntityCommandEntry {
     /// See `CommandEntry::invariant_check_lines`.
     pub invariant_check_lines: Vec<String>,
     pub role: Option<String>,
+    /// Every role that may run the command, when more than one may; `role` is then the first.
+    pub roles: Vec<String>,
     /// Carried for shape parity with `domain_generator.rb`'s `entity_commands`; unread here.
     pub entity_name: String,
     pub entity_identity_reading: String,
@@ -80,6 +87,8 @@ pub struct NestedEntityCommandEntry {
     pub reference_specs: Vec<ReferenceSpec>,
     pub invariant_check_lines: Vec<String>,
     pub role: Option<String>,
+    /// Every role that may run the command, when more than one may; `role` is then the first.
+    pub roles: Vec<String>,
     pub entity_name: String,
     pub entity_identity_reading: String,
     pub nested_name: String,
@@ -115,7 +124,7 @@ pub struct AggregateEntry {
     pub entity_commands: Vec<EntityCommandEntry>,
     pub nested_entity_commands: Vec<NestedEntityCommandEntry>,
     pub ports: Vec<PortEntry>,
-    pub chapter_mod: String,
+    pub bluebook_mod: String,
     pub domain_name: String,
     /// Reference-typed attributes; this aggregate's row in `REFERENCE_TABLE`.
     pub reference_specs: Vec<ReferenceSpec>,
@@ -125,11 +134,30 @@ pub struct AggregateEntry {
     pub entities: Vec<EntityIdentityEntry>,
 }
 
+/// The call that refuses a caller who may not run the command: against its one `role`, or, when
+/// `roles` lists several, against all of them at once (any one lets the caller through).
 pub fn emit_role_check(
     exemplar: &Exemplar,
     role: Option<&str>,
+    roles: &[String],
     command_name: &str,
 ) -> Option<String> {
+    if roles.len() > 1 {
+        let listed: Vec<String> = roles
+            .iter()
+            .map(|r| naming::ruby_inspect_string(r))
+            .collect();
+        return Some(exemplar.render(
+            "role_check_any",
+            &[
+                ("\"TmplRoles\"", listed.join(", ")),
+                (
+                    "\"TmplCommandName\"",
+                    naming::ruby_inspect_string(command_name),
+                ),
+            ],
+        ));
+    }
     let role = role?;
     Some(exemplar.render(
         "role_check",
@@ -260,6 +288,28 @@ fn squeeze(text: &str) -> String {
 
 pub fn emit_reference_check(exemplar: &Exemplar, check: &ReferenceCheck) -> String {
     let ident = naming::rust_ident_field(&check.field);
+    if check.union_tag.is_some() {
+        let (shape, slot) = if check.optional {
+            (
+                "reference_check_one_of_optional",
+                "tmpl_union_optional_field",
+            )
+        } else {
+            ("reference_check_one_of", "tmpl_union_field")
+        };
+        return exemplar.render(
+            shape,
+            &[
+                (
+                    "\"TmplTarget\"",
+                    naming::ruby_inspect_string(&check.target_name),
+                ),
+                ("\"tmpl_heads\"", naming::ruby_inspect_string(&check.heads)),
+                ("tmpl_target_mod", check.target_mod.clone()),
+                (slot, ident),
+            ],
+        );
+    }
     if let Some(list_item) = &check.list_item {
         exemplar.render(
             "reference_check_list",
@@ -303,8 +353,8 @@ pub fn emit_reference_check(exemplar: &Exemplar, check: &ReferenceCheck) -> Stri
     }
 }
 
-fn chapter_path(a: &AggregateEntry) -> String {
-    format!("crate::generated::{}::{}", a.chapter_mod, a.module_name)
+fn bluebook_path(a: &AggregateEntry) -> String {
+    format!("crate::generated::{}::{}", a.bluebook_mod, a.module_name)
 }
 
 /// One `"verb" => { .. }` arm of the registry's dispatch match, its body lines indented.
@@ -326,7 +376,7 @@ pub fn emit_registry(exemplar: &Exemplar, aggregates: &[AggregateEntry]) -> Stri
             format!(
                 "    pub {}: crate::kernel::InMemoryRepository<{}::{}>,",
                 a.module_name,
-                chapter_path(a),
+                bluebook_path(a),
                 a.record
             )
         })
@@ -356,7 +406,7 @@ pub fn emit_registry(exemplar: &Exemplar, aggregates: &[AggregateEntry]) -> Stri
     let seed_arms: Vec<String> = aggregates
         .iter()
         .map(|a| {
-            let mod_path = chapter_path(a);
+            let mod_path = bluebook_path(a);
             let prefix = format!("{}::{}#", a.domain_name, a.name);
             format!(
                 "if let Some(id) = key.strip_prefix({}) {{\n    store.{}.save(id, {mod_path}::{}::from_json(value)?);\n    continue;\n}}",
@@ -393,7 +443,7 @@ pub fn emit_registry(exemplar: &Exemplar, aggregates: &[AggregateEntry]) -> Stri
 
     let mut aggregate_arms: Vec<String> = Vec::new();
     for a in aggregates {
-        let mod_path = chapter_path(a);
+        let mod_path = bluebook_path(a);
         for c in &a.commands {
             let extra_names = &c.identity_extra_params;
             let extra_idents: Vec<String> = extra_names
@@ -456,7 +506,7 @@ pub fn emit_registry(exemplar: &Exemplar, aggregates: &[AggregateEntry]) -> Stri
                 emit_argument_gates_literal(
                     &format!("{mod_path}::{}", c.args_struct),
                     &c.invariant_check_lines,
-                    emit_role_check(exemplar, c.role.as_deref(), &c.name),
+                    emit_role_check(exemplar, c.role.as_deref(), &c.roles, &c.name),
                     &c.reference_checks
                         .iter()
                         .map(|check| emit_reference_check(exemplar, check))
@@ -531,7 +581,7 @@ pub fn emit_registry(exemplar: &Exemplar, aggregates: &[AggregateEntry]) -> Stri
 
     let mut entity_arms: Vec<String> = Vec::new();
     for a in aggregates {
-        let mod_path = chapter_path(a);
+        let mod_path = bluebook_path(a);
         for c in &a.entity_commands {
             // The argument gates; `kernel::decode_entity_arguments` walks `EntityStep::ORDER`.
             let gates_line = format!(
@@ -539,7 +589,7 @@ pub fn emit_registry(exemplar: &Exemplar, aggregates: &[AggregateEntry]) -> Stri
                 emit_argument_gates_literal(
                     &format!("{mod_path}::{}", c.args_struct),
                     &c.invariant_check_lines,
-                    emit_role_check(exemplar, c.role.as_deref(), &c.name),
+                    emit_role_check(exemplar, c.role.as_deref(), &c.roles, &c.name),
                     &c.reference_checks
                         .iter()
                         .map(|check| emit_reference_check(exemplar, check))
@@ -614,7 +664,7 @@ pub fn emit_registry(exemplar: &Exemplar, aggregates: &[AggregateEntry]) -> Stri
     // that accepts a route or flat args; otherwise the command is routed-only.
     let mut nested_entity_arms: Vec<String> = Vec::new();
     for a in aggregates {
-        let mod_path = chapter_path(a);
+        let mod_path = bluebook_path(a);
         for c in &a.nested_entity_commands {
             // The argument gates; see the entity arm's `gates_line`.
             let gates_line = format!(
@@ -622,7 +672,7 @@ pub fn emit_registry(exemplar: &Exemplar, aggregates: &[AggregateEntry]) -> Stri
                 emit_argument_gates_literal(
                     &format!("{mod_path}::{}", c.args_struct),
                     &c.invariant_check_lines,
-                    emit_role_check(exemplar, c.role.as_deref(), &c.name),
+                    emit_role_check(exemplar, c.role.as_deref(), &c.roles, &c.name),
                     &c.reference_checks
                         .iter()
                         .map(|check| emit_reference_check(exemplar, check))
@@ -707,7 +757,7 @@ pub fn emit_registry(exemplar: &Exemplar, aggregates: &[AggregateEntry]) -> Stri
 
     let mut port_arms: Vec<String> = Vec::new();
     for a in aggregates {
-        let mod_path = chapter_path(a);
+        let mod_path = bluebook_path(a);
         for p in &a.ports {
             let reference_lines: Vec<String> = p
                 .reference_checks
@@ -828,6 +878,25 @@ pub fn emit_reference_lookup(aggregates: &[AggregateEntry]) -> String {
 mod tests {
     use super::*;
 
+    #[test]
+    fn a_command_with_one_role_checks_that_role_and_one_with_several_checks_any_of_them() {
+        let exemplar = crate::exemplar::Exemplar::load();
+        let one = emit_role_check(&exemplar, Some("Chef"), &[], "AddTopping").unwrap_or_default();
+        assert!(
+            one.contains("check_role_via(Some(\"Chef\"), \"AddTopping\""),
+            "{one}"
+        );
+
+        let roles = vec!["Customer".to_string(), "Sales Rep".to_string()];
+        let any = emit_role_check(&exemplar, Some("Customer"), &roles, "Open").unwrap_or_default();
+        assert!(
+            any.contains("check_roles_via(&[\"Customer\", \"Sales Rep\"], \"Open\""),
+            "{any}"
+        );
+
+        assert!(emit_role_check(&exemplar, None, &[], "Open").is_none());
+    }
+
     #[test]
     fn generated_router_separates_routes_and_supports_compound_create_facts() {
         let aggregate = AggregateEntry {
@@ -851,6 +920,7 @@ mod tests {
                     attributes: Vec::new(),
                     invariant_check_lines: Vec::new(),
                     role: None,
+                    roles: Vec::new(),
                 },
                 CommandEntry {
                     verb: "Banking::SafeDepositBox.Close".to_string(),
@@ -865,6 +935,7 @@ mod tests {
                     attributes: Vec::new(),
                     invariant_check_lines: Vec::new(),
                     role: None,
+                    roles: Vec::new(),
                 },
             ],
             entity_commands: vec![EntityCommandEntry {
@@ -878,6 +949,7 @@ mod tests {
                 attributes: Vec::new(),
                 invariant_check_lines: Vec::new(),
                 role: None,
+                roles: Vec::new(),
                 entity_name: "Visit".to_string(),
                 entity_identity_reading: "date, sequence".to_string(),
             }],
@@ -890,7 +962,7 @@ mod tests {
                 legacy_receiver_field: None,
                 to_receiver_field: None,
             }],
-            chapter_mod: "banking".to_string(),
+            bluebook_mod: "banking".to_string(),
             domain_name: "Banking".to_string(),
             reference_specs: Vec::new(),
             identified_by: vec!["branch_code".to_string(), "box_number".to_string()],
@@ -950,11 +1022,12 @@ mod tests {
                 attributes: vec!["priority".to_string()],
                 invariant_check_lines: Vec::new(),
                 role: None,
+                roles: Vec::new(),
             }],
             entity_commands: Vec::new(),
             nested_entity_commands: Vec::new(),
             ports: Vec::new(),
-            chapter_mod: "fixture".to_string(),
+            bluebook_mod: "fixture".to_string(),
             domain_name: "Fixture".to_string(),
             reference_specs: Vec::new(),
             identified_by: vec!["code".to_string()],
@@ -989,11 +1062,12 @@ mod tests {
                 attributes: Vec::new(),
                 invariant_check_lines: Vec::new(),
                 role: None,
+                roles: Vec::new(),
             }],
             entity_commands: Vec::new(),
             nested_entity_commands: Vec::new(),
             ports: Vec::new(),
-            chapter_mod: "banking".to_string(),
+            bluebook_mod: "banking".to_string(),
             domain_name: "Banking".to_string(),
             reference_specs: Vec::new(),
             identified_by: vec![

data/rust/codegen/src/sidecars.rs

@@ -1,4 +1,4 @@
-//! Writes each chapter's `ir.json` and `metadata.rs` sidecars, from the IR as generated (marked).
+//! Writes each bluebook's `ir.json` and `metadata.rs` sidecars, from the IR as generated (marked).
 
 use crate::json::{self, Json};
 use std::fmt::Write as _;

data/rust/expr/Cargo.lock

@@ -0,0 +1,54 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "aho-corasick"
+version = "1.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c982642fa9e8606056828ee9a8505737230110bb1099153c79efe865c59d12ba"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "hecks_expr"
+version = "0.1.0"
+dependencies = [
+ "regex",
+]
+
+[[package]]
+name = "memchr"
+version = "2.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98"
+
+[[package]]
+name = "regex"
+version = "1.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f020237b6c8eed93db2e2cb53c00c60a8e1bc73da7d073199a1180401450218d"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-automata",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.4.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ad8553b9b26413251cbf30e620595c7a41b3887f03da04579c0e6b0d6a06b4b2"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.8.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4"

data/rust/expr/Cargo.toml

@@ -0,0 +1,52 @@
+[package]
+name = "hecks_expr"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+name = "hecks_expr"
+path = "src/lib.rs"
+
+# The expression evaluator: `Expr`, `Value`, the operators and shapes it dispatches to, and the
+# `Refusal` it fails with. One copy, shared by the kernel (compiled into every domain's wasm) and
+# the host. std-only apart from `regex`, which `expression_operators/pattern_match.rs` needs for
+# `.match?` (ADR 0012's one dependency exception); `default-features = false` keeps out the SIMD
+# `perf` feature.
+[dependencies]
+regex = { version = "1", default-features = false, features = ["std", "unicode"] }
+
+# Clippy beyond its defaults: pedantic and nursery, plus the restriction lints that keep a panic
+# out of library code. `hecks gate_run.gate stage=ci only=rust_clippy` makes each of these an error.
+# The same table is in every crate's Cargo.toml; change them together.
+[lints.clippy]
+pedantic = { level = "warn", priority = -1 }
+nursery = { level = "warn", priority = -1 }
+unwrap_used = "warn"
+expect_used = "warn"
+panic = "warn"
+dbg_macro = "warn"
+todo = "warn"
+unimplemented = "warn"
+# Lints that ask for prose or an attribute on every item rather than for better code.
+missing_errors_doc = "allow"
+missing_panics_doc = "allow"
+must_use_candidate = "allow"
+return_self_not_must_use = "allow"
+module_name_repetitions = "allow"
+too_many_lines = "allow"
+too_long_first_doc_paragraph = "allow"
+doc_markdown = "allow"
+# Numeric conversions here are deliberate: JSON numbers are f64 and ids are small.
+cast_possible_truncation = "allow"
+cast_possible_wrap = "allow"
+cast_precision_loss = "allow"
+cast_sign_loss = "allow"
+# Naming heuristics that fire on ordinary short names.
+similar_names = "allow"
+many_single_char_names = "allow"
+struct_field_names = "allow"
+# Heuristics that cost more clarity than they buy here.
+redundant_pub_crate = "allow"
+future_not_send = "allow"
+significant_drop_tightening = "allow"
+match_same_arms = "allow"

data/rust/{src/kernel → expr/src}/attribute_shapes/composite.rs

@@ -1,25 +1,45 @@
 // The `:composite` shape of `Runtime::Value::Coercion::SHAPES`: per-segment dotted-path walking.
 
-use crate::kernel::expr::{eval_error, Field, Value};
-use crate::kernel::Refusal;
+use crate::expr::{eval_error, Field, Value};
+use crate::rendering;
+use crate::Refusal;
 
-/// A scalar (or `Nil`) with segments left resolves to `Nil`, like Ruby's `walk_path`.
-/// This makes `flag.nil?` read as a value instead of a refusal.
+/// Ruby's `Resolver.walk_path`, one segment at a time. A nested object reads the field; a string
+/// answers the segment when it is a substring (`String#[]`), else nil; a list or an integer cannot
+/// be indexed by name and refuses; nil, floats and booleans end the walk in nil, which is what makes
+/// `flag.nil?` read as a value instead of a refusal.
 pub fn step<'a>(current: &Field<'a>, seg: &str, head: &str) -> Result<Field<'a>, Refusal> {
     match current {
         Field::Nested(obj) => (*obj)
             .field(seg)
             .ok_or_else(|| eval_error(format!("cannot resolve {seg:?} on {head:?}"))),
-        Field::Value(_) => Ok(Field::Value(Value::Nil)),
+        Field::Value(v) => step_value(v, seg),
     }
 }
 
-/// A path may end on a nested object only if it collapses via `Fielded::as_scalar`.
+fn step_value<'a>(value: &Value, seg: &str) -> Result<Field<'a>, Refusal> {
+    match value {
+        Value::Str(text) if text.contains(seg) => Ok(Field::Value(Value::Str(seg.to_string()))),
+        Value::Str(_) | Value::Nil | Value::Float(_) | Value::Bool(_) => {
+            Ok(Field::Value(Value::Nil))
+        }
+        Value::Object(fields) => Ok(Field::Value(fields.get(seg).cloned().unwrap_or(Value::Nil))),
+        Value::Int(_) | Value::List(_) | Value::Array(_) => Err(eval_error(format!(
+            "cannot read {} from {}",
+            rendering::ruby_inspect(seg),
+            rendering::describe(value)
+        ))),
+    }
+}
+
+/// A path may end on a nested object only if it collapses via `Fielded::as_scalar` (or reads as an
+/// object value through `Fielded::to_value`).
 pub fn finish(current: Field<'_>, path: &str) -> Result<Value, Refusal> {
     match current {
         Field::Value(v) => Ok(v),
         Field::Nested(obj) => obj
             .as_scalar()
+            .or_else(|| obj.to_value())
             .ok_or_else(|| eval_error(format!("{path} resolved to an object, not a scalar"))),
     }
 }
@@ -27,7 +47,7 @@ pub fn finish(current: Field<'_>, path: &str) -> Result<Value, Refusal> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::kernel::expr::Fielded;
+    use crate::expr::Fielded;
 
     // Hand-built stand-in for a generated composite's `Fielded` impl.
     struct Customer {
@@ -73,13 +93,8 @@ mod tests {
     }
 
     #[test]
-    fn this_holds_for_every_scalar_shape_not_just_bool() {
-        for value in [
-            Value::Int(0),
-            Value::Float(1.5),
-            Value::Str("x".to_string()),
-            Value::List(3),
-        ] {
+    fn floats_strings_without_the_segment_and_nil_end_the_walk_in_nil() {
+        for value in [Value::Float(1.5), Value::Str("x".to_string()), Value::Nil] {
             assert_eq!(
                 stepped_value(&Field::Value(value.clone()), "nil?", "head"),
                 Value::Nil,
@@ -88,6 +103,22 @@ mod tests {
         }
     }
 
+    #[test]
+    fn a_string_answers_a_segment_it_contains_as_ruby_string_index_does() {
+        assert_eq!(
+            stepped_value(&Field::Value(Value::Str("abc".to_string())), "bc", "head"),
+            Value::Str("bc".to_string())
+        );
+    }
+
+    #[test]
+    fn an_integer_or_a_list_cannot_be_read_by_name_and_refuses() {
+        for value in [Value::Int(0), Value::List(3), Value::Array(vec![])] {
+            let stepped = step(&Field::Value(value.clone()), "nil?", "head");
+            assert!(stepped.is_err(), "expected a refusal for {value:?}");
+        }
+    }
+
     #[test]
     fn a_further_segment_on_an_already_nil_value_stays_nil() {
         // An unset optional field already reads as `Nil` before `step` runs.

data/rust/{src/kernel → expr/src}/attribute_shapes/list.rs

@@ -1,7 +1,7 @@
 // The `:list` shape of `Runtime::Value::Coercion::SHAPES`.
 // Expressions see a list as its length only (`Value::List(usize)`): just `size` and `empty?`.
 
-use crate::kernel::expr::Value;
+use crate::expr::Value;
 
 pub const fn is_empty(v: &Value) -> Option<bool> {
     match v {