hecks 3.14.0 → 4.0.0

data/rust/src/kernel/mod.rs

@@ -14,26 +14,39 @@ pub mod query_ordering;
 pub mod vocab;
 // Kept at its old path so existing `refusal_wording::RefusalSite` call sites still resolve.
 pub use vocab::refusal_template as refusal_wording;
-pub mod read_model;
 pub mod query_comparators;
+pub mod read_model;
 pub mod reference_lookup;
 pub mod repository;
 pub mod routing;
+pub mod ruby_float;
 
-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, StripSide, Value, WithParent};
+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,
+    StripSide, Value, WithParent,
+};
 pub use json::Json;
 pub use named_query::{QueryCondition, QueryConditionValue, QueryDef};
 pub use orchestrate::{
-    orchestrate, CompletedCompensation, CrossDomainPolicyRule, DispatchSpec, Handler, PendingCrossDomainReaction, PolicyRule, ProcessManagerDef,
-    SagaInstance, Tables, WithValue, MAX_REACTION_DEPTH, REFUSED,
+    orchestrate, CompletedCompensation, CrossDomainPolicyRule, DispatchSpec, Handler,
+    PendingCrossDomainReaction, PolicyRule, ProcessManagerDef, SagaInstance, Tables, WithValue,
+    MAX_REACTION_DEPTH, REFUSED,
 };
 pub use reference_lookup::{
-    command_deref, owner_deref, parent_deref, seeded_projections, DerefNode, ProjectedFieldSpec, ReferenceLookup, ReferenceSpec, ReferenceTable,
-    SetProjectedField, WithReferences, DEREFERENCE_DEPTH,
+    command_deref, owner_deref, parent_deref, seeded_projections, DerefNode, ProjectedFieldSpec,
+    ReferenceLookup, ReferenceSpec, ReferenceTable, SetProjectedField, WithReferences,
+    DEREFERENCE_DEPTH,
 };
 pub use refusal_wording::RefusalSite;
-pub use repository::{check_reference, check_role_via, filter_entries, holds_role_via, row_json, AggregateScan, InMemoryRepository, Repository};
+pub use repository::{
+    check_reference, check_role_via, filter_entries, holds_role_via, row_json, AggregateScan,
+    InMemoryRepository, Repository,
+};
 pub use routing::{CommandInvocation, RoutingEnvelope};
 
 /// A domain event raised by a successful command dispatch.
@@ -77,20 +90,20 @@ pub enum Refusal {
 
 impl Refusal {
     /// The refusal class name, spelled as Ruby raises it; the semantics corpus compares it.
-    pub fn kind(&self) -> &'static str {
+    pub const fn kind(&self) -> &'static str {
         match self {
-            Refusal::GivenNotMet(_) => "GivenNotMet",
-            Refusal::EnsuresNotMet(_) => "EnsuresNotMet",
-            Refusal::InvariantViolation(_) => "InvariantViolation",
-            Refusal::LifecycleRefused(_) => "LifecycleRefused",
-            Refusal::AlreadyExists(_) => "AlreadyExists",
-            Refusal::NotFound(_) => "NotFound",
-            Refusal::TypeMismatch(_) => "TypeMismatch",
-            Refusal::AbsentArgument(_) => "AbsentArgument",
-            Refusal::UnknownArgument(_) => "UnknownArgument",
-            Refusal::Unauthorized(_) => "Unauthorized",
-            Refusal::Fault(_) => "Fault",
-            Refusal::NothingToCorrect(_) => "NothingToCorrect",
+            Self::GivenNotMet(_) => "GivenNotMet",
+            Self::EnsuresNotMet(_) => "EnsuresNotMet",
+            Self::InvariantViolation(_) => "InvariantViolation",
+            Self::LifecycleRefused(_) => "LifecycleRefused",
+            Self::AlreadyExists(_) => "AlreadyExists",
+            Self::NotFound(_) => "NotFound",
+            Self::TypeMismatch(_) => "TypeMismatch",
+            Self::AbsentArgument(_) => "AbsentArgument",
+            Self::UnknownArgument(_) => "UnknownArgument",
+            Self::Unauthorized(_) => "Unauthorized",
+            Self::Fault(_) => "Fault",
+            Self::NothingToCorrect(_) => "NothingToCorrect",
         }
     }
 }
@@ -98,18 +111,18 @@ impl Refusal {
 impl std::fmt::Display for Refusal {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            Refusal::GivenNotMet(msg)
-            | Refusal::EnsuresNotMet(msg)
-            | Refusal::InvariantViolation(msg)
-            | Refusal::LifecycleRefused(msg)
-            | Refusal::AlreadyExists(msg)
-            | Refusal::NotFound(msg)
-            | Refusal::TypeMismatch(msg)
-            | Refusal::AbsentArgument(msg)
-            | Refusal::UnknownArgument(msg)
-            | Refusal::Unauthorized(msg)
-            | Refusal::Fault(msg)
-            | Refusal::NothingToCorrect(msg) => write!(f, "{msg}"),
+            Self::GivenNotMet(msg)
+            | Self::EnsuresNotMet(msg)
+            | Self::InvariantViolation(msg)
+            | Self::LifecycleRefused(msg)
+            | Self::AlreadyExists(msg)
+            | Self::NotFound(msg)
+            | Self::TypeMismatch(msg)
+            | Self::AbsentArgument(msg)
+            | Self::UnknownArgument(msg)
+            | Self::Unauthorized(msg)
+            | Self::Fault(msg)
+            | Self::NothingToCorrect(msg) => write!(f, "{msg}"),
         }
     }
 }

data/rust/src/kernel/named_query.rs

@@ -2,7 +2,9 @@
 //! A query outside the compiled subset has no row and is refused by the string-form step.
 
 use super::refusal_wording::UnauthorizedTenantRequiredArgs;
-use super::{query_comparators::QueryComparator, query_ordering, repository, AggregateScan, Json, Refusal};
+use super::{
+    query_comparators::QueryComparator, query_ordering, repository, AggregateScan, Json, Refusal,
+};
 
 /// One declared query, compiled.
 ///
@@ -60,7 +62,12 @@ pub enum QueryConditionValue {
 
 /// Runs a declared query: chained `filter_entries` per condition (keeping id order), then
 /// `query_ordering::apply` for `order_by`/`offset`/`limit`, as Ruby filters then orders.
-pub fn run(store: &impl AggregateScan, def: &QueryDef, args: &Json, caller_role: Option<&str>) -> Result<Vec<(String, Json)>, Refusal> {
+pub fn run(
+    store: &impl AggregateScan,
+    def: &QueryDef,
+    args: &Json,
+    caller_role: Option<&str>,
+) -> Result<Vec<(String, Json)>, Refusal> {
     run_cross_domain(store, def, args, &[], caller_role)
 }
 
@@ -77,7 +84,11 @@ pub fn run_cross_domain(
     if let Some(auth) = &def.authorization {
         if args.get(auth.tenant_field).is_none() {
             return Err(Refusal::Unauthorized(
-                UnauthorizedTenantRequiredArgs { query: auth.query_name, field: auth.tenant_field }.render_args(),
+                UnauthorizedTenantRequiredArgs {
+                    query: auth.query_name,
+                    field: auth.tenant_field,
+                }
+                .render_args(),
             ));
         }
     }
@@ -100,21 +111,35 @@ pub fn run_cross_domain(
     // cloned. ANDing per row keeps what chaining one filter per condition kept.
     let mut entries: Vec<(String, Json)> = Vec::new();
     let known = store.scan_each(def.aggregate, &mut |id, record| {
-        let kept = wants
-            .iter()
-            .all(|(c, want)| repository::entry_matches(record, c.field, c.comparator, want, cross_domain));
+        let kept = wants.iter().all(|(c, want)| {
+            repository::entry_matches(record, c.field, c.comparator, want, cross_domain)
+        });
         if kept {
             entries.push((id.to_string(), record.clone()));
         }
     });
     if !known {
-        return Err(Refusal::TypeMismatch(format!("unknown aggregate {:?}", def.aggregate)));
+        return Err(Refusal::TypeMismatch(format!(
+            "unknown aggregate {:?}",
+            def.aggregate
+        )));
     }
     entries.sort_by(|a, b| a.0.cmp(&b.0));
 
-    entries = super::read_model::apply_reference_hops(entries, def.reference_hop_conditions, args, store)?;
+    entries = super::read_model::apply_reference_hops(
+        entries,
+        def.reference_hop_conditions,
+        args,
+        store,
+    )?;
 
-    Ok(query_ordering::apply(entries, def.order_by.as_ref(), def.offset.as_ref(), def.limit.as_ref(), args))
+    Ok(query_ordering::apply(
+        entries,
+        def.order_by.as_ref(),
+        def.offset.as_ref(),
+        def.limit.as_ref(),
+        args,
+    ))
 }
 
 /// Finds a query by verb; a linear scan is enough for the small generated `QUERIES` table.
@@ -146,7 +171,11 @@ pub fn find_entity<'a>(table: &'a [EntityQueryDef], verb: &str) -> Option<&'a En
     table.iter().find(|def| def.verb == verb)
 }
 
-pub fn run_entity(store: &impl AggregateScan, def: &EntityQueryDef, args: &Json) -> Result<Vec<Json>, Refusal> {
+pub fn run_entity(
+    store: &impl AggregateScan,
+    def: &EntityQueryDef,
+    args: &Json,
+) -> Result<Vec<Json>, Refusal> {
     let records = store
         .scan(def.aggregate)
         .ok_or_else(|| Refusal::TypeMismatch(format!("unknown aggregate {:?}", def.aggregate)))?;
@@ -155,7 +184,11 @@ pub fn run_entity(store: &impl AggregateScan, def: &EntityQueryDef, args: &Json)
     let mut entries: Vec<(String, Json)> = Vec::new();
     for (parent_id, record) in records {
         if let Some(elements) = record.get(def.list_field).and_then(Json::as_array) {
-            entries.extend(elements.iter().map(|element| (parent_id.clone(), element.clone())));
+            entries.extend(
+                elements
+                    .iter()
+                    .map(|element| (parent_id.clone(), element.clone())),
+            );
         }
     }
 
@@ -169,10 +202,23 @@ pub fn run_entity(store: &impl AggregateScan, def: &EntityQueryDef, args: &Json)
     }
 
     // `query_ordering::apply` re-sorts stably by parent id, so identity order survives per parent.
-    entries.sort_by(|(parent_a, a), (parent_b, b)| parent_a.cmp(parent_b).then_with(|| identity_order(a, b, def.identity_keys)));
-    let ordered = query_ordering::apply(entries, def.order_by.as_ref(), def.offset.as_ref(), def.limit.as_ref(), args);
+    entries.sort_by(|(parent_a, a), (parent_b, b)| {
+        parent_a
+            .cmp(parent_b)
+            .then_with(|| identity_order(a, b, def.identity_keys))
+    });
+    let ordered = query_ordering::apply(
+        entries,
+        def.order_by.as_ref(),
+        def.offset.as_ref(),
+        def.limit.as_ref(),
+        args,
+    );
 
-    Ok(ordered.into_iter().map(|(parent_id, element)| row_under_parent(def.parent_key, parent_id, element)).collect())
+    Ok(ordered
+        .into_iter()
+        .map(|(parent_id, element)| row_under_parent(def.parent_key, parent_id, element))
+        .collect())
 }
 
 fn identity_order(a: &Json, b: &Json, keys: &[&str]) -> std::cmp::Ordering {
@@ -193,7 +239,9 @@ fn comparable(value: Option<&Json>) -> Option<&Json> {
 fn compare_comparable(a: Option<&Json>, b: Option<&Json>) -> std::cmp::Ordering {
     use std::cmp::Ordering;
     match (a, b) {
-        (Some(Json::Num(x, _)), Some(Json::Num(y, _))) => x.partial_cmp(y).unwrap_or(Ordering::Equal),
+        (Some(Json::Num(x, _)), Some(Json::Num(y, _))) => {
+            x.partial_cmp(y).unwrap_or(Ordering::Equal)
+        }
         (Some(Json::Str(x)), Some(Json::Str(y))) => x.cmp(y),
         (None | Some(Json::Null), None | Some(Json::Null)) => Ordering::Equal,
         (None | Some(Json::Null), _) => Ordering::Less,

data/rust/src/kernel/needs.rs

@@ -17,7 +17,7 @@ use std::cell::{Cell, RefCell};
 use std::collections::HashMap;
 
 /// One needed fact of a command: its name and the type of the command's attribute of that name.
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Need {
     pub fact: String,
     pub attribute_type: String,
@@ -42,8 +42,15 @@ fn parse_table(table: Option<&Json>) -> HashMap<String, Vec<Need>> {
                     .iter()
                     .filter_map(|n| {
                         let fact = n.get("fact")?.as_str()?.to_string();
-                        let attribute_type = n.get("type").and_then(Json::as_str).unwrap_or("").to_string();
-                        Some(Need { fact, attribute_type })
+                        let attribute_type = n
+                            .get("type")
+                            .and_then(Json::as_str)
+                            .unwrap_or("")
+                            .to_string();
+                        Some(Need {
+                            fact,
+                            attribute_type,
+                        })
                     })
                     .collect();
                 (name.clone(), needs)
@@ -94,7 +101,10 @@ pub fn now_secs(occurred_at: Option<&str>) -> i64 {
         return fixed;
     }
     occurred_at.and_then(parse_iso8601_utc).unwrap_or_else(|| {
-        std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).map(|d| d.as_secs() as i64).unwrap_or_default()
+        std::time::SystemTime::now()
+            .duration_since(std::time::UNIX_EPOCH)
+            .map(|d| d.as_secs() as i64)
+            .unwrap_or_default()
     })
 }
 
@@ -103,9 +113,17 @@ fn parse_iso8601_utc(text: &str) -> Option<i64> {
     let text = text.strip_suffix('Z')?;
     let (date, time) = text.split_once('T')?;
     let mut d = date.split('-');
-    let (y, m, day): (i64, i64, i64) = (d.next()?.parse().ok()?, d.next()?.parse().ok()?, d.next()?.parse().ok()?);
+    let (y, m, day): (i64, i64, i64) = (
+        d.next()?.parse().ok()?,
+        d.next()?.parse().ok()?,
+        d.next()?.parse().ok()?,
+    );
     let mut t = time.split(':');
-    let (h, mi, s): (i64, i64, i64) = (t.next()?.parse().ok()?, t.next()?.parse().ok()?, t.next()?.split('.').next()?.parse().ok()?);
+    let (h, mi, s): (i64, i64, i64) = (
+        t.next()?.parse().ok()?,
+        t.next()?.parse().ok()?,
+        t.next()?.split('.').next()?.parse().ok()?,
+    );
     // Howard Hinnant's days-from-civil.
     let y = if m <= 2 { y - 1 } else { y };
     let era = if y >= 0 { y } else { y - 399 } / 400;
@@ -121,8 +139,16 @@ fn answer(need: &Need, occurred_at: Option<&str>) -> Option<Json> {
         // `now` is epoch seconds; `today` the day those fall in, whole days since the epoch (UTC).
         "now" | "today" => {
             let secs = now_secs(occurred_at);
-            let answer = if need.fact == "today" { secs.div_euclid(86_400) } else { secs };
-            Some(if need.attribute_type == "Integer" { Json::int(answer) } else { Json::obj(vec![("value", Json::int(answer))]) })
+            let answer = if need.fact == "today" {
+                secs.div_euclid(86_400)
+            } else {
+                secs
+            };
+            Some(if need.attribute_type == "Integer" {
+                Json::int(answer)
+            } else {
+                Json::obj(vec![("value", Json::int(answer))])
+            })
         }
         _ => None,
     }
@@ -132,14 +158,20 @@ fn answer(need: &Need, occurred_at: Option<&str>) -> Option<Json> {
 /// needed filling (no needs, or every fact supplied). Reads `with` when the call carries one,
 /// else the flat object, as `CommandInvocation` does.
 pub fn enrich(verb: &str, args: &Json, occurred_at: Option<&str>) -> Option<Json> {
-    let needs = TABLE.with(|t| t.borrow().get(verb).cloned()).unwrap_or_default();
-    let defaults = DEFAULTS.with(|t| t.borrow().get(verb).cloned()).unwrap_or_default();
+    let needs = TABLE
+        .with(|t| t.borrow().get(verb).cloned())
+        .unwrap_or_default();
+    let defaults = DEFAULTS
+        .with(|t| t.borrow().get(verb).cloned())
+        .unwrap_or_default();
     if needs.is_empty() && defaults.is_empty() {
         return None;
     }
     let explicit = matches!(args.get("with"), Some(Json::Object(_)));
     let facts = if explicit { args.get("with")? } else { args };
-    let Json::Object(held) = facts else { return None };
+    let Json::Object(held) = facts else {
+        return None;
+    };
     let mut filled = held.clone();
     let before = filled.len();
     for need in &needs {
@@ -161,8 +193,21 @@ pub fn enrich(verb: &str, args: &Json, occurred_at: Option<&str>) -> Option<Json
     if !explicit {
         return Some(Json::Object(filled));
     }
-    let Json::Object(envelope) = args else { return None };
-    Some(Json::Object(envelope.iter().map(|(k, v)| if k == "with" { (k.clone(), Json::Object(filled.clone())) } else { (k.clone(), v.clone()) }).collect()))
+    let Json::Object(envelope) = args else {
+        return None;
+    };
+    Some(Json::Object(
+        envelope
+            .iter()
+            .map(|(k, v)| {
+                if k == "with" {
+                    (k.clone(), Json::Object(filled.clone()))
+                } else {
+                    (k.clone(), v.clone())
+                }
+            })
+            .collect(),
+    ))
 }
 
 /// `args` with each fact the query `question` needs and the caller left out answered, or `None`
@@ -170,7 +215,9 @@ pub fn enrich(verb: &str, args: &Json, occurred_at: Option<&str>) -> Option<Json
 /// arguments are the flat object of its step.
 pub fn enrich_query(question: &str, args: &Json, occurred_at: Option<&str>) -> Option<Json> {
     let needs = QUERY_TABLE.with(|t| t.borrow().get(question).cloned())?;
-    let Json::Object(held) = args else { return None };
+    let Json::Object(held) = args else {
+        return None;
+    };
     let mut filled = held.clone();
     for need in &needs {
         if held.iter().any(|(k, _)| k == &need.fact) {
@@ -207,7 +254,10 @@ mod tests {
         install(Some(&table()));
         fix_clock(Some(1_700_000_000));
         let filled = enrich("D::A.Instant", &with(vec![("x", Json::int(1))]), None).unwrap();
-        assert_eq!(filled.get("with").unwrap().get("now"), Some(&Json::obj(vec![("value", Json::int(1_700_000_000))])));
+        assert_eq!(
+            filled.get("with").unwrap().get("now"),
+            Some(&Json::obj(vec![("value", Json::int(1_700_000_000))]))
+        );
         assert_eq!(filled.get("with").unwrap().get("x"), Some(&Json::int(1)));
     }
 
@@ -231,9 +281,20 @@ mod tests {
     fn an_integer_attribute_gets_a_bare_integer_and_an_instant_a_value_object() {
         install(Some(&table()));
         fix_clock(Some(9));
-        assert_eq!(enrich("D::A.Seconds", &with(vec![]), None).unwrap().get("with").unwrap().get("now"), Some(&Json::int(9)));
         assert_eq!(
-            enrich("D::A.Instant", &with(vec![]), None).unwrap().get("with").unwrap().get("now"),
+            enrich("D::A.Seconds", &with(vec![]), None)
+                .unwrap()
+                .get("with")
+                .unwrap()
+                .get("now"),
+            Some(&Json::int(9))
+        );
+        assert_eq!(
+            enrich("D::A.Instant", &with(vec![]), None)
+                .unwrap()
+                .get("with")
+                .unwrap()
+                .get("now"),
             Some(&Json::obj(vec![("value", Json::int(9))]))
         );
     }
@@ -255,7 +316,8 @@ mod tests {
     }
 
     fn defaults() -> Json {
-        Json::parse(r#"{"D::A.Start": {"runs": 30}, "D::A.Instant": {"holder": "nobody"}}"#).unwrap()
+        Json::parse(r#"{"D::A.Start": {"runs": 30}, "D::A.Instant": {"holder": "nobody"}}"#)
+            .unwrap()
     }
 
     #[test]
@@ -263,7 +325,10 @@ mod tests {
         install(None);
         install_defaults(Some(&defaults()));
         let filled = enrich("D::A.Start", &with(vec![("ref", Json::int(1))]), None).unwrap();
-        assert_eq!(filled.get("with").unwrap().get("runs"), Some(&Json::int(30)));
+        assert_eq!(
+            filled.get("with").unwrap().get("runs"),
+            Some(&Json::int(30))
+        );
         assert_eq!(filled.get("with").unwrap().get("ref"), Some(&Json::int(1)));
     }
 
@@ -271,7 +336,10 @@ mod tests {
     fn a_supplied_argument_keeps_its_value_over_the_default() {
         install(None);
         install_defaults(Some(&defaults()));
-        assert_eq!(enrich("D::A.Start", &with(vec![("runs", Json::int(7))]), None), None);
+        assert_eq!(
+            enrich("D::A.Start", &with(vec![("runs", Json::int(7))]), None),
+            None
+        );
     }
 
     #[test]
@@ -288,8 +356,14 @@ mod tests {
         install_defaults(Some(&defaults()));
         fix_clock(Some(3));
         let filled = enrich("D::A.Instant", &with(vec![]), None).unwrap();
-        assert_eq!(filled.get("with").unwrap().get("now"), Some(&Json::obj(vec![("value", Json::int(3))])));
-        assert_eq!(filled.get("with").unwrap().get("holder"), Some(&Json::str("nobody")));
+        assert_eq!(
+            filled.get("with").unwrap().get("now"),
+            Some(&Json::obj(vec![("value", Json::int(3))]))
+        );
+        assert_eq!(
+            filled.get("with").unwrap().get("holder"),
+            Some(&Json::str("nobody"))
+        );
         fix_clock(None);
     }
 
@@ -322,7 +396,14 @@ mod tests {
     fn a_query_value_the_caller_supplied_is_kept() {
         install_queries(Some(&query_table()));
         fix_clock(Some(1));
-        assert_eq!(enrich_query("D::A.Expired", &Json::obj(vec![("now", Json::int(7))]), None), None);
+        assert_eq!(
+            enrich_query(
+                "D::A.Expired",
+                &Json::obj(vec![("now", Json::int(7))]),
+                None
+            ),
+            None
+        );
         fix_clock(None);
         install_queries(None);
     }
@@ -352,10 +433,16 @@ mod tests {
         install_queries(Some(&query_table()));
         fix_clock(Some((19_000 * 86_400) + 86_399));
         let filled = enrich_query("D::A.Today", &Json::obj(vec![]), None).unwrap();
-        assert_eq!(filled.get("today"), Some(&Json::obj(vec![("value", Json::int(19_000))])));
+        assert_eq!(
+            filled.get("today"),
+            Some(&Json::obj(vec![("value", Json::int(19_000))]))
+        );
         fix_clock(Some(19_001 * 86_400));
         let next = enrich_query("D::A.Today", &Json::obj(vec![]), None).unwrap();
-        assert_eq!(next.get("today"), Some(&Json::obj(vec![("value", Json::int(19_001))])));
+        assert_eq!(
+            next.get("today"),
+            Some(&Json::obj(vec![("value", Json::int(19_001))]))
+        );
         fix_clock(None);
         install_queries(None);
     }