hecks 3.14.0 → 4.0.0

data/rust/src/kernel/pattern.rs

@@ -5,16 +5,23 @@
 enum Node {
     Literal(char),
     Any,
-    Class { negate: bool, ranges: Vec<(char, char)> },
+    Class {
+        negate: bool,
+        ranges: Vec<(char, char)>,
+    },
     // `^`/`$` match at line boundaries, as in Ruby.
     LineStart,
     LineEnd,
     // `\A`/`\z`/`\Z` match only at the whole-string boundaries.
     StringStart,
     StringEnd,
-    Group(Vec<Node>),
-    Alt(Vec<Vec<Node>>),
-    Repeat { node: Box<Node>, min: usize, max: Option<usize> },
+    Group(Vec<Self>),
+    Alt(Vec<Vec<Self>>),
+    Repeat {
+        node: Box<Self>,
+        min: usize,
+        max: Option<usize>,
+    },
 }
 
 /// `true` if `text` contains a match for `pattern` read as dispatch reads it: `^` and `$` are
@@ -66,7 +73,9 @@ fn whole_string(pattern: &str) -> String {
 
 /// `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 };
+    let Ok(nodes) = parse(pattern) else {
+        return false;
+    };
     let chars: Vec<char> = text.chars().collect();
     // Only `\A` may skip to position 0; `^` can still match after a later `\n`.
     let anchored_start = matches!(nodes.first(), Some(Node::StringStart));
@@ -76,24 +85,48 @@ pub fn matches(pattern: &str, text: &str) -> bool {
     (0..=chars.len()).any(|start| match_from(&nodes, 0, &chars, start, &|_| true))
 }
 
-fn match_from(nodes: &[Node], idx: usize, text: &[char], ti: usize, cont: &dyn Fn(usize) -> bool) -> bool {
+fn match_from(
+    nodes: &[Node],
+    idx: usize,
+    text: &[char],
+    ti: usize,
+    cont: &dyn Fn(usize) -> bool,
+) -> bool {
     if idx == nodes.len() {
         return cont(ti);
     }
     match &nodes[idx] {
-        Node::Literal(c) => ti < text.len() && text[ti] == *c && match_from(nodes, idx + 1, text, ti + 1, cont),
+        Node::Literal(c) => {
+            ti < text.len() && text[ti] == *c && match_from(nodes, idx + 1, text, ti + 1, cont)
+        }
         // Like Ruby without `/m`, `.` does not match `\n`.
-        Node::Any => ti < text.len() && text[ti] != '\n' && match_from(nodes, idx + 1, text, ti + 1, cont),
+        Node::Any => {
+            ti < text.len() && text[ti] != '\n' && match_from(nodes, idx + 1, text, ti + 1, cont)
+        }
         Node::Class { negate, ranges } => {
-            ti < text.len() && class_matches(*negate, ranges, text[ti]) && match_from(nodes, idx + 1, text, ti + 1, cont)
+            ti < text.len()
+                && class_matches(*negate, ranges, text[ti])
+                && match_from(nodes, idx + 1, text, ti + 1, cont)
+        }
+        Node::LineStart => {
+            (ti == 0 || text[ti - 1] == '\n') && match_from(nodes, idx + 1, text, ti, cont)
+        }
+        Node::LineEnd => {
+            (ti == text.len() || text[ti] == '\n') && match_from(nodes, idx + 1, text, ti, cont)
         }
-        Node::LineStart => (ti == 0 || text[ti - 1] == '\n') && match_from(nodes, idx + 1, text, ti, cont),
-        Node::LineEnd => (ti == text.len() || text[ti] == '\n') && match_from(nodes, idx + 1, text, ti, cont),
         Node::StringStart => ti == 0 && match_from(nodes, idx + 1, text, ti, cont),
         Node::StringEnd => ti == text.len() && match_from(nodes, idx + 1, text, ti, cont),
-        Node::Group(inner) => match_from(inner, 0, text, ti, &|ti2| match_from(nodes, idx + 1, text, ti2, cont)),
-        Node::Alt(branches) => branches.iter().any(|b| match_from(b, 0, text, ti, &|ti2| match_from(nodes, idx + 1, text, ti2, cont))),
-        Node::Repeat { node, min, max } => match_repeat(node, 0, *min, *max, nodes, idx + 1, text, ti, cont),
+        Node::Group(inner) => match_from(inner, 0, text, ti, &|ti2| {
+            match_from(nodes, idx + 1, text, ti2, cont)
+        }),
+        Node::Alt(branches) => branches.iter().any(|b| {
+            match_from(b, 0, text, ti, &|ti2| {
+                match_from(nodes, idx + 1, text, ti2, cont)
+            })
+        }),
+        Node::Repeat { node, min, max } => {
+            match_repeat(node, 0, *min, *max, nodes, idx + 1, text, ti, cont)
+        }
     }
 }
 
@@ -133,7 +166,7 @@ fn class_matches(negate: bool, ranges: &[(char, char)], c: char) -> bool {
 }
 
 // `\t`, `\n` and `\r` become control characters; any other escape is the literal itself.
-fn escape_char(c: char) -> char {
+const fn escape_char(c: char) -> char {
     match c {
         't' => '\t',
         'n' => '\n',
@@ -145,7 +178,10 @@ fn escape_char(c: char) -> char {
 // Recursive descent: `alternation > concat > repeat > atom`.
 fn parse(pattern: &str) -> Result<Vec<Node>, ()> {
     let chars: Vec<char> = pattern.chars().collect();
-    let mut p = Parser { chars: &chars, pos: 0 };
+    let mut p = Parser {
+        chars: &chars,
+        pos: 0,
+    };
     let node = p.parse_alt()?;
     if p.pos != p.chars.len() {
         return Err(());
@@ -158,7 +194,7 @@ struct Parser<'a> {
     pos: usize,
 }
 
-impl<'a> Parser<'a> {
+impl Parser<'_> {
     fn peek(&self) -> Option<char> {
         self.chars.get(self.pos).copied()
     }
@@ -203,26 +239,41 @@ impl<'a> Parser<'a> {
         match self.peek() {
             Some('*') => {
                 self.bump();
-                Ok(Node::Repeat { node: Box::new(atom), min: 0, max: None })
+                Ok(Node::Repeat {
+                    node: Box::new(atom),
+                    min: 0,
+                    max: None,
+                })
             }
             Some('+') => {
                 self.bump();
-                Ok(Node::Repeat { node: Box::new(atom), min: 1, max: None })
+                Ok(Node::Repeat {
+                    node: Box::new(atom),
+                    min: 1,
+                    max: None,
+                })
             }
             Some('?') => {
                 self.bump();
-                Ok(Node::Repeat { node: Box::new(atom), min: 0, max: Some(1) })
+                Ok(Node::Repeat {
+                    node: Box::new(atom),
+                    min: 0,
+                    max: Some(1),
+                })
             }
             Some('{') => {
                 let save = self.pos;
                 self.bump();
-                match self.parse_bounded_repeat() {
-                    Some((min, max)) => Ok(Node::Repeat { node: Box::new(atom), min, max }),
-                    None => {
-                        // Not a well-formed `{n,m}`: read the brace as a literal.
-                        self.pos = save;
-                        Ok(atom)
-                    }
+                if let Some((min, max)) = self.parse_bounded_repeat() {
+                    Ok(Node::Repeat {
+                        node: Box::new(atom),
+                        min,
+                        max,
+                    })
+                } else {
+                    // Not a well-formed `{n,m}`: read the brace as a literal.
+                    self.pos = save;
+                    Ok(atom)
                 }
             }
             _ => Ok(atom),
@@ -264,7 +315,11 @@ impl<'a> Parser<'a> {
         if self.pos == start {
             return None;
         }
-        self.chars[start..self.pos].iter().collect::<String>().parse().ok()
+        self.chars[start..self.pos]
+            .iter()
+            .collect::<String>()
+            .parse()
+            .ok()
     }
 
     fn parse_atom(&mut self) -> Result<Node, ()> {
@@ -308,11 +363,21 @@ impl<'a> Parser<'a> {
                 }
                 Some(c) => {
                     self.bump();
-                    let lo = if c == '\\' { escape_char(self.bump().ok_or(())?) } else { c };
-                    if self.peek() == Some('-') && self.chars.get(self.pos + 1).is_some_and(|c| *c != ']') {
+                    let lo = if c == '\\' {
+                        escape_char(self.bump().ok_or(())?)
+                    } else {
+                        c
+                    };
+                    if self.peek() == Some('-')
+                        && self.chars.get(self.pos + 1).is_some_and(|c| *c != ']')
+                    {
                         self.bump();
                         let hi_raw = self.bump().ok_or(())?;
-                        let hi = if hi_raw == '\\' { escape_char(self.bump().ok_or(())?) } else { hi_raw };
+                        let hi = if hi_raw == '\\' {
+                            escape_char(self.bump().ok_or(())?)
+                        } else {
+                            hi_raw
+                        };
                         ranges.push((lo, hi));
                     } else {
                         ranges.push((lo, lo));
@@ -336,12 +401,20 @@ mod tests {
     fn matches_every_row_of_the_recorded_pattern_contract() {
         let raw = include_str!("../../../spec/corpus/fixtures/patterns.json");
         let parsed = Json::parse(raw).expect("patterns.json must parse");
-        let rows = parsed.as_array().expect("patterns.json must be a JSON array");
+        let rows = parsed
+            .as_array()
+            .expect("patterns.json must be a JSON array");
         assert!(!rows.is_empty(), "the recorded contract must not be empty");
 
         for row in rows {
-            let pattern = row.get("pattern").and_then(Json::as_str).expect("row must carry a pattern");
-            let input = row.get("input").and_then(Json::as_str).expect("row must carry an input");
+            let pattern = row
+                .get("pattern")
+                .and_then(Json::as_str)
+                .expect("row must carry a pattern");
+            let input = row
+                .get("input")
+                .and_then(Json::as_str)
+                .expect("row must carry an input");
             let expected = matches!(row.get("matches"), Some(Json::Bool(true)));
 
             assert_eq!(

data/rust/src/kernel/query_comparators.rs

@@ -8,31 +8,37 @@ pub use super::vocab::QueryComparator;
 impl QueryComparator {
     /// The wire's `op` string, or `None` if unrecognized (callers refuse, never default to `eq`).
     pub fn parse(op: &str) -> Option<Self> {
-        QueryComparator::from_name(op)
+        Self::from_name(op)
     }
 
     /// `Comparison#holds?`; `held`/`want` arrive already reduced through `comparable`.
     pub fn matches(self, held: &Json, want: &Json) -> bool {
         match self {
-            QueryComparator::Eq => held == want,
-            QueryComparator::Ne => held != want,
-            QueryComparator::Gt => ordered(held, want) && as_f64(held) > as_f64(want),
-            QueryComparator::Gte => ordered(held, want) && as_f64(held) >= as_f64(want),
-            QueryComparator::Lt => ordered(held, want) && as_f64(held) < as_f64(want),
-            QueryComparator::Lte => ordered(held, want) && as_f64(held) <= as_f64(want),
-            QueryComparator::In => members(want).iter().any(|member| member == &to_s(held)),
-            QueryComparator::Contains => contains(held, want),
+            Self::Eq => held == want,
+            Self::Ne => held != want,
+            Self::Gt => ordered(held, want) && as_f64(held) > as_f64(want),
+            Self::Gte => ordered(held, want) && as_f64(held) >= as_f64(want),
+            Self::Lt => ordered(held, want) && as_f64(held) < as_f64(want),
+            Self::Lte => ordered(held, want) && as_f64(held) <= as_f64(want),
+            Self::In => members(want).iter().any(|member| member == &to_s(held)),
+            Self::Contains => contains(held, want),
             // Needs a repository, so `filter_entries_cross_domain` calls `none_in_state_matches`
             // first; this arm keeps the match exhaustive with the same "not excluded" default.
-            QueryComparator::NoneInState => true,
+            Self::NoneInState => true,
         }
     }
 }
 
 /// `Comparison#none_in_state?`: `want` is `"Aggregate:state"`, `held` the referring foreign key.
 /// `cross_domain` is searched in order, first match wins; an empty slice answers `true`.
-pub fn none_in_state_matches(cross_domain: &[(&str, &dyn super::AggregateScan)], held: &Json, want: &Json) -> bool {
-    let Some((aggregate_name, state)) = to_s(want).split_once(':').map(|(a, s)| (a.to_string(), s.to_string()))
+pub fn none_in_state_matches(
+    cross_domain: &[(&str, &dyn super::AggregateScan)],
+    held: &Json,
+    want: &Json,
+) -> bool {
+    let Some((aggregate_name, state)) = to_s(want)
+        .split_once(':')
+        .map(|(a, s)| (a.to_string(), s.to_string()))
     else {
         return true;
     };
@@ -40,9 +46,13 @@ pub fn none_in_state_matches(cross_domain: &[(&str, &dyn super::AggregateScan)],
 
     for (domain_name, store) in cross_domain {
         let qualified = format!("{domain_name}::{aggregate_name}");
-        let Some(entries) = store.scan(&qualified) else { continue };
+        let Some(entries) = store.scan(&qualified) else {
+            continue;
+        };
 
-        let Some((_, record)) = entries.iter().find(|(id, _)| *id == held_id) else { return true };
+        let Some((_, record)) = entries.iter().find(|(id, _)| *id == held_id) else {
+            return true;
+        };
         let record_state = comparable(&record.dig("state").cloned().unwrap_or(Json::Null));
         return to_s(&record_state) != state;
     }
@@ -52,12 +62,13 @@ pub fn none_in_state_matches(cross_domain: &[(&str, &dyn super::AggregateScan)],
 }
 
 /// gt/gte/lt/lte are numeric-only; anything else is silently false, never a refusal.
-fn ordered(held: &Json, want: &Json) -> bool {
-    matches!(held, Json::Num(_, _) | Json::Float(_)) && matches!(want, Json::Num(_, _) | Json::Float(_))
+const fn ordered(held: &Json, want: &Json) -> bool {
+    matches!(held, Json::Num(_, _) | Json::Float(_))
+        && matches!(want, Json::Num(_, _) | Json::Float(_))
 }
 
 /// Only called after `ordered` has gated the comparison, so the NaN fallback is unreachable.
-pub(crate) fn as_f64(value: &Json) -> f64 {
+pub(crate) const fn as_f64(value: &Json) -> f64 {
     match value {
         Json::Num(n, _) | Json::Float(n) => *n,
         _ => f64::NAN,
@@ -97,9 +108,14 @@ pub fn comparable(value: &Json) -> Json {
 
 /// `comparable` without the copy: the reduced value is always `value` itself or a member of it.
 pub fn comparable_ref(value: &Json) -> &Json {
-    let Json::Object(fields) = value else { return value };
+    let Json::Object(fields) = value else {
+        return value;
+    };
 
-    if let Some((_, numeric)) = fields.iter().find(|(_, v)| matches!(v, Json::Num(_, _) | Json::Float(_))) {
+    if let Some((_, numeric)) = fields
+        .iter()
+        .find(|(_, v)| matches!(v, Json::Num(_, _) | Json::Float(_)))
+    {
         return numeric;
     }
     if fields.len() == 1 {
@@ -113,7 +129,10 @@ fn members(value: &Json) -> Vec<String> {
     if let Json::Array(items) = value {
         return items.iter().map(|item| to_s(&comparable(item))).collect();
     }
-    to_s(value).split(',').map(|piece| piece.trim().to_string()).collect()
+    to_s(value)
+        .split(',')
+        .map(|piece| piece.trim().to_string())
+        .collect()
 }
 
 /// Element membership for a `list_of` field, substring match for anything else.
@@ -139,68 +158,126 @@ mod none_in_state_tests {
     impl AggregateScan for FakeStore {
         fn scan(&self, aggregate: &str) -> Option<Vec<(String, Json)>> {
             let bare = aggregate.strip_prefix(&format!("{}::", self.domain))?;
-            self.aggregates.iter().find(|(name, _)| *name == bare).map(|(_, entries)| entries.clone())
+            self.aggregates
+                .iter()
+                .find(|(name, _)| *name == bare)
+                .map(|(_, entries)| entries.clone())
         }
     }
 
     /// A record whose `state` is a single-field value object, as in the real corpus fixture.
     fn record_in_state(state: &str) -> Json {
-        Json::obj(vec![("state", Json::obj(vec![("value", Json::str(state))]))])
+        Json::obj(vec![(
+            "state",
+            Json::obj(vec![("value", Json::str(state))]),
+        )])
     }
 
     #[test]
     fn with_no_domains_to_search_answers_vacuously_true() {
         // Ruby's `return true unless registry`.
-        assert!(none_in_state_matches(&[], &Json::str("c1"), &Json::str("Claim:held")));
+        assert!(none_in_state_matches(
+            &[],
+            &Json::str("c1"),
+            &Json::str("Claim:held")
+        ));
     }
 
     #[test]
     fn excludes_a_row_whose_target_is_currently_in_the_named_state() {
-        let store = FakeStore { domain: "AntiJoinGrowth", aggregates: vec![("Claim", vec![("c1".into(), record_in_state("held"))])] };
+        let store = FakeStore {
+            domain: "AntiJoinGrowth",
+            aggregates: vec![("Claim", vec![("c1".into(), record_in_state("held"))])],
+        };
         let stores: Vec<(&str, &dyn AggregateScan)> = vec![("AntiJoinGrowth", &store)];
-        assert!(!none_in_state_matches(&stores, &Json::str("c1"), &Json::str("Claim:held")));
+        assert!(!none_in_state_matches(
+            &stores,
+            &Json::str("c1"),
+            &Json::str("Claim:held")
+        ));
     }
 
     #[test]
     fn keeps_a_row_whose_target_has_moved_out_of_the_named_state() {
-        let store = FakeStore { domain: "AntiJoinGrowth", aggregates: vec![("Claim", vec![("c2".into(), record_in_state("released"))])] };
+        let store = FakeStore {
+            domain: "AntiJoinGrowth",
+            aggregates: vec![("Claim", vec![("c2".into(), record_in_state("released"))])],
+        };
         let stores: Vec<(&str, &dyn AggregateScan)> = vec![("AntiJoinGrowth", &store)];
-        assert!(none_in_state_matches(&stores, &Json::str("c2"), &Json::str("Claim:held")));
+        assert!(none_in_state_matches(
+            &stores,
+            &Json::str("c2"),
+            &Json::str("Claim:held")
+        ));
     }
 
     #[test]
     fn keeps_a_row_whose_target_was_never_filed_at_all() {
         // No record reads the same as a record in another state.
-        let store = FakeStore { domain: "AntiJoinGrowth", aggregates: vec![("Claim", vec![])] };
+        let store = FakeStore {
+            domain: "AntiJoinGrowth",
+            aggregates: vec![("Claim", vec![])],
+        };
         let stores: Vec<(&str, &dyn AggregateScan)> = vec![("AntiJoinGrowth", &store)];
-        assert!(none_in_state_matches(&stores, &Json::str("nonexistent"), &Json::str("Claim:held")));
+        assert!(none_in_state_matches(
+            &stores,
+            &Json::str("nonexistent"),
+            &Json::str("Claim:held")
+        ));
     }
 
     #[test]
     fn keeps_every_row_when_no_domain_declares_the_named_aggregate_at_all() {
-        let store = FakeStore { domain: "AntiJoinGrowth", aggregates: vec![] };
+        let store = FakeStore {
+            domain: "AntiJoinGrowth",
+            aggregates: vec![],
+        };
         let stores: Vec<(&str, &dyn AggregateScan)> = vec![("AntiJoinGrowth", &store)];
-        assert!(none_in_state_matches(&stores, &Json::str("c1"), &Json::str("NoSuchAggregate:held")));
+        assert!(none_in_state_matches(
+            &stores,
+            &Json::str("c1"),
+            &Json::str("NoSuchAggregate:held")
+        ));
     }
 
     #[test]
     fn searches_a_second_domain_when_the_first_does_not_declare_the_aggregate() {
         // Cross-domain search; no real deployment has this shape.
-        let domain_a = FakeStore { domain: "DomainA", aggregates: vec![("Widget", vec![])] };
-        let domain_b =
-            FakeStore { domain: "DomainB", aggregates: vec![("Claim", vec![("c1".into(), record_in_state("held"))])] };
-        let stores: Vec<(&str, &dyn AggregateScan)> = vec![("DomainA", &domain_a), ("DomainB", &domain_b)];
-        assert!(!none_in_state_matches(&stores, &Json::str("c1"), &Json::str("Claim:held")));
+        let domain_a = FakeStore {
+            domain: "DomainA",
+            aggregates: vec![("Widget", vec![])],
+        };
+        let domain_b = FakeStore {
+            domain: "DomainB",
+            aggregates: vec![("Claim", vec![("c1".into(), record_in_state("held"))])],
+        };
+        let stores: Vec<(&str, &dyn AggregateScan)> =
+            vec![("DomainA", &domain_a), ("DomainB", &domain_b)];
+        assert!(!none_in_state_matches(
+            &stores,
+            &Json::str("c1"),
+            &Json::str("Claim:held")
+        ));
     }
 
     #[test]
     fn first_match_wins_when_two_domains_declare_the_same_bare_aggregate_name() {
         // Pins first-match-wins (Ruby's `find_aggregate_by_name`): DomainA's "held" must win
         // over DomainB's "released".
-        let first = FakeStore { domain: "DomainA", aggregates: vec![("Claim", vec![("c1".into(), record_in_state("held"))])] };
-        let second =
-            FakeStore { domain: "DomainB", aggregates: vec![("Claim", vec![("c1".into(), record_in_state("released"))])] };
-        let stores: Vec<(&str, &dyn AggregateScan)> = vec![("DomainA", &first), ("DomainB", &second)];
-        assert!(!none_in_state_matches(&stores, &Json::str("c1"), &Json::str("Claim:held")));
+        let first = FakeStore {
+            domain: "DomainA",
+            aggregates: vec![("Claim", vec![("c1".into(), record_in_state("held"))])],
+        };
+        let second = FakeStore {
+            domain: "DomainB",
+            aggregates: vec![("Claim", vec![("c1".into(), record_in_state("released"))])],
+        };
+        let stores: Vec<(&str, &dyn AggregateScan)> =
+            vec![("DomainA", &first), ("DomainB", &second)];
+        assert!(!none_in_state_matches(
+            &stores,
+            &Json::str("c1"),
+            &Json::str("Claim:held")
+        ));
     }
 }

data/rust/src/kernel/query_ordering.rs

@@ -57,12 +57,18 @@ pub fn apply(
     rows
 }
 
+/// Records by id, in the order a read model's rows are held.
+type Rows = Vec<(String, Json)>;
+
 // `sort_by` is stable, so the id order from `apply` survives ties without an index tie-break.
-fn apply_declared_order(rows: Vec<(String, Json)>, order_by: &OrderBy) -> Vec<(String, Json)> {
-    let (mut null_rows, mut valued_rows): (Vec<(String, Json)>, Vec<(String, Json)>) =
-        rows.into_iter().partition(|(_, record)| order_key(record, order_by.field) == Json::Null);
+fn apply_declared_order(rows: Rows, order_by: &OrderBy) -> Rows {
+    let (mut null_rows, mut valued_rows): (Rows, Rows) = rows
+        .into_iter()
+        .partition(|(_, record)| order_key(record, order_by.field) == Json::Null);
 
-    valued_rows.sort_by(|(_, a), (_, b)| compare_comparable(&order_key(a, order_by.field), &order_key(b, order_by.field)));
+    valued_rows.sort_by(|(_, a), (_, b)| {
+        compare_comparable(&order_key(a, order_by.field), &order_key(b, order_by.field))
+    });
 
     if order_by.descending {
         valued_rows.reverse();
@@ -72,7 +78,9 @@ fn apply_declared_order(rows: Vec<(String, Json)>, order_by: &OrderBy) -> Vec<(S
     match order_by.nulls {
         NullsMode::First => null_rows.into_iter().chain(valued_rows).collect(),
         NullsMode::Last => valued_rows.into_iter().chain(null_rows).collect(),
-        NullsMode::Native if !order_by.descending => null_rows.into_iter().chain(valued_rows).collect(),
+        NullsMode::Native if !order_by.descending => {
+            null_rows.into_iter().chain(valued_rows).collect()
+        }
         NullsMode::Native => valued_rows.into_iter().chain(null_rows).collect(),
     }
 }