hecks 3.9.1 → 3.11.0

data/rust/src/kernel/expression_operators/text.rs

@@ -1,5 +1,5 @@
-//! The "text" expression-operator category: `.split`, `.start_with?`, `.end_with?`.
-//! String receivers only; `expr.rs` routes only these three nodes here.
+//! The "text" expression-operator category: `.split`, `.strip` (and `.lstrip`/`.rstrip`),
+//! `.start_with?`, `.end_with?`. String receivers only; `expr.rs` routes only these nodes here.
 
 use crate::kernel::expr::{eval_error, interpret as eval, EvalContext, Expr, Value};
 use crate::kernel::Refusal;
@@ -15,6 +15,10 @@ pub fn interpret(expr: &Expr, ctx: &EvalContext) -> Result<Value, Refusal> {
             }
             Ok(Value::Array(parts.into_iter().map(|p| Value::Str(p.to_string())).collect()))
         }
+        Expr::Strip { receiver, side } => {
+            let text = require_str(&eval(receiver, ctx)?, "strip")?;
+            Ok(Value::Str(side.trim(&text)))
+        }
         Expr::StartsWith { receiver, substring } => {
             let text = require_str(&eval(receiver, ctx)?, "start_with?")?;
             Ok(Value::Bool(text.starts_with(substring.as_str())))
@@ -63,6 +67,26 @@ mod tests {
         assert_eq!(run(phrase), Value::Array(vec![Value::Str("abc".to_string())]));
     }
 
+    #[test]
+    fn strip_trims_rubys_whitespace_set_and_nothing_else() {
+        use crate::kernel::expr::StripSide;
+        let strip = |side, text: &str| run(Expr::Strip { receiver: Box::new(str(text)), side });
+        assert_eq!(strip(StripSide::Both, " \t\n a b \r\u{b}\u{c}\0"), Value::Str("a b".to_string()));
+        assert_eq!(strip(StripSide::Left, "\0  a "), Value::Str("a ".to_string()));
+        assert_eq!(strip(StripSide::Right, " a \0 "), Value::Str(" a".to_string()));
+        assert_eq!(strip(StripSide::Both, "   "), Value::Str(String::new()));
+        // A non-breaking space is not Ruby whitespace, so it stays.
+        assert_eq!(strip(StripSide::Both, "\u{a0}a\u{a0}"), Value::Str("\u{a0}a\u{a0}".to_string()));
+    }
+
+    #[test]
+    fn strip_on_a_non_string_refuses_with_the_operator_named() {
+        use crate::kernel::expr::StripSide;
+        let ctx = EvalContext { args: &NoFields, instance: &NoFields };
+        let err = eval(&Expr::Strip { receiver: Box::new(Expr::Int(1)), side: StripSide::Both }, &ctx).unwrap_err();
+        assert!(format!("{err:?}").contains("strip expects a string"), "{err:?}");
+    }
+
     #[test]
     fn start_and_end_with() {
         assert_eq!(run(Expr::StartsWith { receiver: Box::new(str("{}")), substring: "{".to_string() }), Value::Bool(true));

data/rust/src/kernel/json.rs

@@ -592,6 +592,18 @@ mod value_object_shape_tests {
     }
 }
 
+#[cfg(test)]
+mod escaped_string_tests {
+    use super::*;
+
+    #[test]
+    fn control_characters_are_written_the_way_rubys_json_generate_writes_them() {
+        let mut out = String::new();
+        write_escaped_string("\u{8}\u{c}\n\r\t\u{b}\0\u{1f}/\u{7f}", &mut out);
+        assert_eq!(out, "\"\\b\\f\\n\\r\\t\\u000b\\u0000\\u001f/\u{7f}\"");
+    }
+}
+
 fn write_escaped_string(s: &str, out: &mut String) {
     out.push('"');
     for c in s.chars() {
@@ -601,6 +613,9 @@ fn write_escaped_string(s: &str, out: &mut String) {
             '\n' => out.push_str("\\n"),
             '\t' => out.push_str("\\t"),
             '\r' => out.push_str("\\r"),
+            // Ruby's `JSON.generate` writes these two short, not as `\u0008` / `\u000c`.
+            '\u{8}' => out.push_str("\\b"),
+            '\u{c}' => out.push_str("\\f"),
             c if (c as u32) < 0x20 => out.push_str(&format!("\\u{:04x}", c as u32)),
             c => out.push(c),
         }

data/rust/src/kernel/mod.rs

@@ -21,7 +21,7 @@ pub mod repository;
 pub mod routing;
 
 pub use dispatch::{aggregate_step_site, apply_entity_command, decode_aggregate_arguments, decode_entity_arguments, dispatch, dispatch_entity, enforce_invariants, entity_step_site, ArgumentGates, EnsuresSpec, EntityInvariants, GivenSpec, Hydrate, InvariantSet, InvariantSpec, StepSite, TransitionCheck};
-pub use expr::{interpret, BlockMode, Bound, Comparison, EvalContext, Expr, Field, Fielded, NoFields, Value, WithParent};
+pub use expr::{interpret, BlockMode, Bound, Comparison, EvalContext, Expr, Field, Fielded, NoFields, StripSide, Value, WithParent};
 pub use json::Json;
 pub use named_query::{QueryCondition, QueryConditionValue, QueryDef};
 pub use orchestrate::{

data/rust/src/kernel/orchestrate.rs

@@ -302,6 +302,23 @@ fn read_literal_wire(binding: &str) -> Json {
     Json::str(binding.to_string())
 }
 
+// Adds a fan-out row's fields to a projection's source where the payload and emitter identity have
+// not already named them, plus the row's `id` as Ruby's row hash carries it.
+fn offer_row_fields(source: &mut Vec<(String, Json)>, row_id: &str, record: &Json) {
+    let mut fields: Vec<(String, Json)> = match record {
+        Json::Object(pairs) => pairs.clone(),
+        _ => Vec::new(),
+    };
+    if !fields.iter().any(|(name, _)| name == "id") {
+        fields.push(("id".to_string(), Json::str(row_id.to_string())));
+    }
+    for (name, value) in fields {
+        if !source.iter().any(|(held, _)| *held == name) {
+            source.push((name, value));
+        }
+    }
+}
+
 fn where_holds(where_expr: Option<fn() -> Expr>, event: &Event) -> bool {
     let Some(build) = where_expr else { return true };
     let ctx = EvalContext { args: &event.payload, instance: &NoFields };
@@ -311,6 +328,32 @@ fn where_holds(where_expr: Option<fn() -> Expr>, event: &Event) -> bool {
 // An empty `with_spec` forwards the whole payload. `extra` (a fan-out's row key) is merged into
 // the source before projection, not onto its result.
 fn trigger_args(policy: &PolicyRule, event: &Event, extra: Option<(&str, String)>, target_verb: &str, tables: &Tables) -> Json {
+    trigger_args_with_row(policy, event, extra, None, target_verb, tables)
+}
+
+// `row` is a fan-out's own row (its id and stored record). A projection may read its fields, below
+// the emitter identity and the payload; an undeclared projection never sees them.
+/// The arguments a `for_each` query runs with: the event payload, plus the emitting record's id
+/// under its aggregate's identity head when the query reads that name and the payload lacks it, as
+/// Ruby's `for_each_query_args` lends it. A payload value is never overridden. A composite identity
+/// has no single head in the table, so nothing is lent for it.
+fn for_each_query_args(def: &named_query::QueryDef, event: &Event, tables: &Tables) -> Json {
+    let mut args = match &event.payload {
+        Json::Object(pairs) => pairs.clone(),
+        _ => Vec::new(),
+    };
+    let reads = |head: &str| def.conditions.iter().any(|c| matches!(c.value, named_query::QueryConditionValue::Arg(name) if name == head));
+    if let Some(head) = (tables.identity_head_fn)(&event.aggregate) {
+        if !event.id.is_empty() && reads(head) && !args.iter().any(|(name, _)| name == head) {
+            args.push((head.to_string(), Json::str(event.id.clone())));
+        }
+    }
+    Json::Object(args)
+}
+
+fn trigger_args_with_row(
+    policy: &PolicyRule, event: &Event, extra: Option<(&str, String)>, row: Option<(&str, &Json)>, target_verb: &str, tables: &Tables,
+) -> Json {
     let mut source: Vec<(String, Json)> = match &event.payload {
         Json::Object(pairs) => pairs.clone(),
         _ => Vec::new(),
@@ -345,6 +388,10 @@ fn trigger_args(policy: &PolicyRule, event: &Event, extra: Option<(&str, String)
         }
     }
 
+    if let Some((row_id, record)) = row {
+        offer_row_fields(&mut source, row_id, record);
+    }
+
     let projected = policy
         .with_spec
         .iter()
@@ -517,9 +564,10 @@ fn react_policies<S: AggregateScan>(
                 ]));
                 continue;
             };
-            // The query reads the event, not the projection. No caller role: the policy is
-            // system-triggered.
-            let rows = match named_query::run(store, def, &event.payload, None) {
+            // The query reads the event, not the projection, with the emitting record's identity
+            // lent under its head. No caller role: the policy is system-triggered.
+            let query_args = for_each_query_args(def, event, &tables);
+            let rows = match named_query::run(store, def, &query_args, None) {
                 Ok(rows) => rows,
                 Err(refusal) => {
                     reaction_log.push(record(vec![
@@ -529,7 +577,7 @@ fn react_policies<S: AggregateScan>(
                     continue;
                 }
             };
-            for (row_id, _row) in rows {
+            for (row_id, row) in rows {
                 let row_record = |extra: Vec<(&str, Json)>| -> Json {
                     let mut fields = vec![("for_row", Json::str(row_id.clone()))];
                     fields.extend(extra.into_iter());
@@ -542,7 +590,8 @@ fn react_policies<S: AggregateScan>(
                         other => other,
                     }
                 };
-                let args = trigger_args(policy, event, policy.for_each_key.map(|key| (key, row_id.clone())), policy.target_verb, &tables);
+                let extra = policy.for_each_key.map(|key| (key, row_id.clone()));
+                let args = trigger_args_with_row(policy, event, extra, Some((row_id.as_str(), &row)), policy.target_verb, &tables);
                 let outcome = orchestrate(
                     store, dispatch_fn, tables, sagas, policy.target_verb, &args, None, None, None, occurred_at, depth + 1,
                     all_events, mutations, cross_domain, reaction_log, saga_log,

data/rust/src/kernel/orchestrate_guard_tests.rs

@@ -598,6 +598,73 @@ fn a_payload_that_is_not_an_object_forwards_as_an_empty_object() {
     assert_eq!(args, Json::Object(vec![]));
 }
 
+fn row_record() -> Json {
+    Json::obj(vec![("charged", Json::int(40)), ("amount", Json::int(99))])
+}
+
+#[test]
+fn an_explicit_with_may_read_a_fan_out_rows_fields_but_the_payload_wins() {
+    const READ_ROW: &[(&str, &str)] = &[("note", ":charged"), ("amount", ":amount"), ("tag", ":id")];
+    let record = row_record();
+
+    let args = trigger_args_with_row(&rule("D::Order.Place", READ_ROW), &order_event(payload()), None, Some(("r1", &record)), "D::Order.Place", &tables());
+
+    assert_eq!(args, Json::obj(vec![("note", Json::int(40)), ("amount", Json::int(5)), ("tag", Json::str("r1"))]));
+}
+
+#[test]
+fn an_undeclared_with_never_offers_a_fan_out_rows_fields() {
+    let record = row_record();
+    let extra = Some(("order_id", "r1".to_string()));
+
+    let args = trigger_args_with_row(&rule("D::Order.Place", NO_WITH), &order_event(payload()), extra, Some(("r1", &record)), "D::Order.Place", &tables());
+
+    assert_eq!(args, Json::obj(vec![("amount", Json::int(5)), ("to", Json::str("zzz")), ("order_id", Json::str("r1"))]));
+}
+
+const READS_ORDER_ID: crate::kernel::QueryDef = crate::kernel::QueryDef {
+    verb: "D::Order.ForOrder",
+    aggregate: "D::Order",
+    conditions: &[crate::kernel::QueryCondition {
+        field: "order_id",
+        comparator: crate::kernel::query_comparators::QueryComparator::Eq,
+        value: crate::kernel::QueryConditionValue::Arg("order_id"),
+    }],
+    reference_hop_conditions: &[],
+    order_by: None,
+    offset: None,
+    limit: None,
+    authorization: None,
+};
+
+#[test]
+fn a_for_each_query_is_lent_the_emitting_records_id_under_its_identity_head() {
+    let args = for_each_query_args(&READS_ORDER_ID, &order_event(Json::obj(vec![])), &tables());
+
+    assert_eq!(args, Json::obj(vec![("order_id", Json::str("o1"))]));
+}
+
+#[test]
+fn a_for_each_query_keeps_a_payload_value_over_the_lent_identity() {
+    let args = for_each_query_args(&READS_ORDER_ID, &order_event(Json::obj(vec![("order_id", Json::str("mine"))])), &tables());
+
+    assert_eq!(args, Json::obj(vec![("order_id", Json::str("mine"))]));
+}
+
+#[test]
+fn a_for_each_query_that_does_not_read_the_head_is_lent_nothing() {
+    let args = for_each_query_args(&QUERIES[0], &order_event(payload()), &tables());
+
+    assert_eq!(args, payload());
+}
+
+#[test]
+fn a_for_each_query_is_lent_nothing_for_an_aggregate_without_a_single_head() {
+    let args = for_each_query_args(&READS_ORDER_ID, &event("E", "D::Other", "x1", Json::obj(vec![])), &tables());
+
+    assert_eq!(args, Json::obj(vec![]));
+}
+
 const PROJECT: &[(&str, &str)] = &[("amount", ":amount"), ("note", "\"hi\""), ("tag", ":absent")];
 
 #[test]

data/rust/src/kernel/pattern.rs

@@ -17,6 +17,53 @@ enum Node {
     Repeat { node: Box<Node>, min: usize, max: Option<usize> },
 }
 
+/// `true` if `text` contains a match for `pattern` read as dispatch reads it: `^` and `$` are
+/// whole-value anchors, so a newline cannot smuggle text past an anchored pattern
+/// (`Hecks::Bluebook::PatternSubset.whole_string` rewrites them to `\A` and `\z` before Ruby
+/// enforces a `pattern:`). [`matches`] reads the dialect itself, line anchors included.
+pub fn matches_whole(pattern: &str, text: &str) -> bool {
+    matches(&whole_string(pattern), text)
+}
+
+/// `pattern` with `^` as `\A` and `$` as `\z` outside bracket classes; escaped pairs and class
+/// interiors are left alone (`PatternSubset.whole_string`).
+fn whole_string(pattern: &str) -> String {
+    let chars: Vec<char> = pattern.chars().collect();
+    let mut out = String::with_capacity(pattern.len() + 4);
+    let mut index = 0;
+    let mut in_class = false;
+    let mut class_start = 0;
+    while index < chars.len() {
+        let c = chars[index];
+        if c == '\\' {
+            out.extend(chars[index..chars.len().min(index + 2)].iter());
+            index += 2;
+            continue;
+        }
+        if in_class {
+            if c == ']' && index != class_start {
+                in_class = false;
+            }
+            out.push(c);
+        } else if c == '[' {
+            in_class = true;
+            class_start = index + 1;
+            if chars.get(class_start) == Some(&'^') {
+                class_start += 1;
+            }
+            out.push(c);
+        } else {
+            match c {
+                '^' => out.push_str("\\A"),
+                '$' => out.push_str("\\z"),
+                other => out.push(other),
+            }
+        }
+        index += 1;
+    }
+    out
+}
+
 /// `true` if `text` contains a match for `pattern`; a pattern that fails to parse is `false`.
 pub fn matches(pattern: &str, text: &str) -> bool {
     let Ok(nodes) = parse(pattern) else { return false };
@@ -304,4 +351,17 @@ mod tests {
             );
         }
     }
+
+    #[test]
+    fn a_dispatched_pattern_anchors_to_the_whole_value() {
+        use super::matches_whole;
+        assert!(matches_whole("^[a-z]+$", "abc"));
+        assert!(!matches_whole("^[a-z]+$", "abc\n"));
+        assert!(!matches_whole("^[a-z]+$", "x\nabc\ny"));
+        assert!(!matches_whole("^(red|green|blue)$", "red\ngreen"));
+        assert!(matches_whole("[A-Z][a-z]*", "1 Hello world"));
+        assert!(matches_whole("^[^^]+$", "ab"));
+        assert!(matches_whole("^[$]$", "$"));
+        assert!(matches_whole("^a\\^b$", "a^b"));
+    }
 }

data/rust/src/kernel/reference_lookup.rs

@@ -125,16 +125,18 @@ pub struct ProjectedFieldSpec {
     pub remote_field: &'static str,
 }
 
-/// Reads each projected field off the already-dereferenced references.
-pub fn seeded_projections(with_references: &dyn Fielded, specs: &'static [ProjectedFieldSpec]) -> Vec<(&'static str, Option<String>)> {
+/// Reads each projected field off the already-dereferenced references. A scalar is copied as its
+/// own type (`Int`, `Float`, `Bool`, `Str`); a single-field value object is copied as its one
+/// scalar, as Ruby's `RebuildSweep.remote_value` does.
+pub fn seeded_projections(with_references: &dyn Fielded, specs: &'static [ProjectedFieldSpec]) -> Vec<(&'static str, Option<Value>)> {
     specs
         .iter()
         .map(|spec| {
-            // Only `Option<String>` remote fields are seeded; other types would need a coercion.
             let value = match with_references.field(spec.reference) {
                 Some(Field::Nested(node)) => match node.field(spec.remote_field) {
-                    Some(Field::Value(Value::Str(s))) => Some(s),
-                    _ => None,
+                    Some(Field::Value(v)) => projectable(v),
+                    Some(Field::Nested(inner)) => inner.as_scalar().and_then(projectable),
+                    None => None,
                 },
                 _ => None,
             };
@@ -143,7 +145,88 @@ pub fn seeded_projections(with_references: &dyn Fielded, specs: &'static [Projec
         .collect()
 }
 
-/// Write side of `projects`: one generated match arm per projected field.
+// Only a scalar is a projected value; a list length, an array or a nil is not.
+fn projectable(value: Value) -> Option<Value> {
+    matches!(value, Value::Str(_) | Value::Int(_) | Value::Float(_) | Value::Bool(_)).then_some(value)
+}
+
+/// Write side of `projects`: one generated match arm per projected field, narrowing the copied
+/// value to that field's type with `Value::into_string`, `into_i64`, `into_f64` or `into_bool`.
 pub trait SetProjectedField {
-    fn set_projected_field(&mut self, name: &'static str, value: Option<String>);
+    fn set_projected_field(&mut self, name: &'static str, value: Option<Value>);
+}
+
+#[cfg(test)]
+mod projection_tests {
+    use super::*;
+
+    struct StartsAt(i64);
+    impl Fielded for StartsAt {
+        fn field(&self, name: &str) -> Option<Field<'_>> {
+            (name == "value").then(|| Field::Value(Value::Int(self.0)))
+        }
+        fn as_scalar(&self) -> Option<Value> {
+            Some(Value::Int(self.0))
+        }
+    }
+
+    struct Event {
+        starts_at: StartsAt,
+    }
+    impl Fielded for Event {
+        fn field(&self, name: &str) -> Option<Field<'_>> {
+            match name {
+                "starts_at" => Some(Field::Nested(&self.starts_at)),
+                "capacity" => Some(Field::Value(Value::Int(40))),
+                "ratio" => Some(Field::Value(Value::Float(0.5))),
+                "open" => Some(Field::Value(Value::Bool(true))),
+                "title" => Some(Field::Value(Value::Str("Gala".to_string()))),
+                _ => None,
+            }
+        }
+    }
+
+    struct Booking {
+        event: Event,
+    }
+    impl Fielded for Booking {
+        fn field(&self, name: &str) -> Option<Field<'_>> {
+            (name == "event").then(|| Field::Nested(&self.event))
+        }
+    }
+
+    static SPECS: &[ProjectedFieldSpec] = &[
+        ProjectedFieldSpec { field: "starts_at", reference: "event", remote_field: "starts_at" },
+        ProjectedFieldSpec { field: "capacity", reference: "event", remote_field: "capacity" },
+        ProjectedFieldSpec { field: "ratio", reference: "event", remote_field: "ratio" },
+        ProjectedFieldSpec { field: "open", reference: "event", remote_field: "open" },
+        ProjectedFieldSpec { field: "title", reference: "event", remote_field: "title" },
+        ProjectedFieldSpec { field: "missing", reference: "event", remote_field: "nope" },
+    ];
+
+    fn seeded() -> Vec<(&'static str, Option<Value>)> {
+        seeded_projections(&Booking { event: Event { starts_at: StartsAt(100) } }, SPECS)
+    }
+
+    #[test]
+    fn a_single_field_value_object_is_copied_as_its_integer() {
+        assert_eq!(seeded()[0], ("starts_at", Some(Value::Int(100))));
+    }
+
+    #[test]
+    fn each_scalar_type_is_copied_as_its_own_type() {
+        let values: Vec<Option<Value>> = seeded()[1..5].iter().map(|(_, v)| v.clone()).collect();
+        let expected = vec![Some(Value::Int(40)), Some(Value::Float(0.5)), Some(Value::Bool(true)), Some(Value::Str("Gala".to_string()))];
+        assert_eq!(values, expected);
+    }
+
+    #[test]
+    fn a_field_the_target_never_reads_seeds_nothing() {
+        assert_eq!(seeded()[5], ("missing", None));
+    }
+
+    #[test]
+    fn a_reader_refuses_a_value_of_another_type() {
+        assert_eq!((Value::Int(7).into_i64(), Value::Int(7).into_string()), (Some(7), None));
+    }
 }