hecks 2.8.0 → 3.0.0

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

@@ -0,0 +1,232 @@
+//! `.any?`/`.none?`/`.all?` and `.find`, each taking a `{ |param| predicate }` block.
+
+// Every element is evaluated before aggregating, not short-circuited, so an error on any
+// element surfaces exactly as it does in Ruby.
+use crate::kernel::attribute_shapes::composite;
+use crate::kernel::expr::{eval_error, interpret as eval, lookup_items, BlockMode, Bound, EvalContext, Expr, Field, Value};
+use crate::kernel::Refusal;
+
+pub fn interpret(expr: &Expr, ctx: &EvalContext) -> Result<Value, Refusal> {
+    match expr {
+        Expr::BlockPredicate { mode, receiver, param, predicate } => {
+            let items = elements(receiver, ctx, mode.ruby_name())?;
+            let mut outcomes = Vec::with_capacity(items.len());
+            for item in items {
+                let bound = Bound { name: param, value: item, rest: ctx.args };
+                let inner = EvalContext { args: &bound, instance: ctx.instance };
+                outcomes.push(eval(predicate, &inner)?.truthy());
+            }
+            Ok(Value::Bool(match mode {
+                BlockMode::All => outcomes.iter().all(|b| *b),
+                BlockMode::Any => outcomes.iter().any(|b| *b),
+                BlockMode::None => !outcomes.iter().any(|b| *b),
+            }))
+        }
+        Expr::Find { receiver, param, predicate, path } => {
+            let items = elements(receiver, ctx, "find")?;
+            for item in items {
+                let accepted = {
+                    let bound = Bound { name: param, value: borrow(&item), rest: ctx.args };
+                    let inner = EvalContext { args: &bound, instance: ctx.instance };
+                    eval(predicate, &inner)?.truthy()
+                };
+                if accepted {
+                    return project(item, path);
+                }
+            }
+            // Nothing matched, and a path walked from nothing is nil too.
+            Ok(Value::Nil)
+        }
+        _ => Err(Refusal::TypeMismatch(format!("enumeration::interpret called with a non-enumeration node {expr:?} — a router bug"))),
+    }
+}
+
+/// Only a `Lookup` names a list field; any other receiver is evaluated just to word the error.
+fn elements<'a>(receiver: &Expr, ctx: &EvalContext<'a>, op: &str) -> Result<Vec<Field<'a>>, Refusal> {
+    match receiver {
+        Expr::Lookup(path) => lookup_items(path, ctx, op),
+        other => {
+            let v = eval(other, ctx)?;
+            Err(eval_error(format!("{op} expects a list, got {v:?}")))
+        }
+    }
+}
+
+fn borrow<'a>(field: &Field<'a>) -> Field<'a> {
+    match field {
+        Field::Value(v) => Field::Value(v.clone()),
+        Field::Nested(obj) => Field::Nested(*obj),
+    }
+}
+
+/// Walks `path` past the found element, as a dotted `Lookup` does past its head.
+fn project(item: Field<'_>, path: &[&str]) -> Result<Value, Refusal> {
+    let mut current = item;
+    let rendered = path.join(".");
+    for seg in path {
+        current = composite::step(current, seg, "find")?;
+    }
+    composite::finish(current, &format!("find {{ }}.{rendered}"))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::kernel::expr::{Fielded, NoFields};
+    use crate::kernel::Comparison;
+
+    // Shaped like generated `Fielded` impls: `field` answers a list's length, `items` its members.
+    struct Seat {
+        number: i64,
+        taken: bool,
+    }
+    impl Fielded for Seat {
+        fn field(&self, name: &str) -> Option<Field<'_>> {
+            match name {
+                "number" => Some(Field::Value(Value::Int(self.number))),
+                "taken" => Some(Field::Value(Value::Bool(self.taken))),
+                _ => None,
+            }
+        }
+    }
+    struct Roster {
+        seats: Vec<Seat>,
+        tags: Vec<String>,
+        number: i64,
+    }
+    impl Fielded for Roster {
+        fn field(&self, name: &str) -> Option<Field<'_>> {
+            match name {
+                "seats" => Some(Field::Value(Value::List(self.seats.len()))),
+                "tags" => Some(Field::Value(Value::List(self.tags.len()))),
+                "number" => Some(Field::Value(Value::Int(self.number))),
+                _ => None,
+            }
+        }
+        fn items(&self, name: &str) -> Option<Vec<Field<'_>>> {
+            match name {
+                "seats" => Some(self.seats.iter().map(|s| Field::Nested(s)).collect()),
+                "tags" => Some(self.tags.iter().map(|t| Field::Value(Value::Str(t.clone()))).collect()),
+                _ => None,
+            }
+        }
+    }
+
+    fn roster() -> Roster {
+        Roster {
+            seats: vec![Seat { number: 1, taken: true }, Seat { number: 2, taken: false }, Seat { number: 3, taken: true }],
+            tags: vec!["a".to_string(), "".to_string()],
+            number: 99,
+        }
+    }
+
+    const EQ: Comparison = Comparison { less_than: false, equal: true, negated: false };
+
+    fn eq(left: Expr, right: Expr) -> Expr {
+        Expr::Compare { op: EQ, left: Box::new(left), right: Box::new(right) }
+    }
+
+    fn run(expr: &Expr, instance: &dyn Fielded) -> Value {
+        let ctx = EvalContext { args: &NoFields, instance };
+        eval(expr, &ctx).expect("evaluates")
+    }
+
+    #[test]
+    fn any_none_all_over_nested_elements() {
+        let free = |mode| Expr::BlockPredicate {
+            mode,
+            receiver: Box::new(Expr::Lookup("seats")),
+            param: "s",
+            predicate: Box::new(eq(Expr::Lookup("s.taken"), Expr::Bool(false))),
+        };
+        let r = roster();
+        assert_eq!(run(&free(BlockMode::Any), &r), Value::Bool(true));
+        assert_eq!(run(&free(BlockMode::None), &r), Value::Bool(false));
+        assert_eq!(run(&free(BlockMode::All), &r), Value::Bool(false));
+    }
+
+    #[test]
+    fn scalar_lists_bind_the_element_itself() {
+        let blank = Expr::BlockPredicate {
+            mode: BlockMode::Any,
+            receiver: Box::new(Expr::Lookup("tags")),
+            param: "t",
+            predicate: Box::new(Expr::Empty(Box::new(Expr::Lookup("t")))),
+        };
+        assert_eq!(run(&blank, &roster()), Value::Bool(true));
+    }
+
+    #[test]
+    fn an_empty_list_answers_like_ruby() {
+        let empty = Roster { seats: vec![], tags: vec![], number: 0 };
+        let over = |mode| Expr::BlockPredicate {
+            mode,
+            receiver: Box::new(Expr::Lookup("seats")),
+            param: "s",
+            predicate: Box::new(Expr::Bool(true)),
+        };
+        assert_eq!(run(&over(BlockMode::All), &empty), Value::Bool(true));
+        assert_eq!(run(&over(BlockMode::Any), &empty), Value::Bool(false));
+        assert_eq!(run(&over(BlockMode::None), &empty), Value::Bool(true));
+    }
+
+    #[test]
+    fn the_parameter_shadows_a_same_named_field_only_inside_the_block() {
+        // Inside the block `number` still reads the instance's 99; only `s` is bound.
+        let shadow = Expr::BlockPredicate {
+            mode: BlockMode::Any,
+            receiver: Box::new(Expr::Lookup("seats")),
+            param: "s",
+            predicate: Box::new(Expr::And(
+                Box::new(eq(Expr::Lookup("number"), Expr::Int(99))),
+                Box::new(eq(Expr::Lookup("s.number"), Expr::Int(2))),
+            )),
+        };
+        assert_eq!(run(&shadow, &roster()), Value::Bool(true));
+    }
+
+    #[test]
+    fn nested_blocks_see_the_outer_parameter() {
+        // The free seat (2) is followed by seat 3, so this is false; the inner block reads
+        // both its own `o` and the outer `s`.
+        let inner = Expr::BlockPredicate {
+            mode: BlockMode::None,
+            receiver: Box::new(Expr::Lookup("seats")),
+            param: "o",
+            predicate: Box::new(eq(Expr::Lookup("o.number"), Expr::Add(Box::new(Expr::Lookup("s.number")), Box::new(Expr::Int(1))))),
+        };
+        let outer = Expr::BlockPredicate {
+            mode: BlockMode::Any,
+            receiver: Box::new(Expr::Lookup("seats")),
+            param: "s",
+            predicate: Box::new(Expr::And(Box::new(eq(Expr::Lookup("s.taken"), Expr::Bool(false))), Box::new(inner))),
+        };
+        assert_eq!(run(&outer, &roster()), Value::Bool(false));
+    }
+
+    #[test]
+    fn find_projects_through_its_path_and_answers_nil_when_nothing_matches() {
+        let free_number = |wanted: bool| Expr::Find {
+            receiver: Box::new(Expr::Lookup("seats")),
+            param: "s",
+            predicate: Box::new(eq(Expr::Lookup("s.taken"), Expr::Bool(wanted))),
+            path: &["number"],
+        };
+        assert_eq!(run(&free_number(false), &roster()), Value::Int(2));
+        let none_free = Roster { seats: vec![Seat { number: 1, taken: true }], tags: vec![], number: 0 };
+        assert_eq!(run(&free_number(false), &none_free), Value::Nil);
+    }
+
+    #[test]
+    fn a_non_list_receiver_refuses_with_the_operator_named() {
+        let wrong = Expr::BlockPredicate {
+            mode: BlockMode::Any,
+            receiver: Box::new(Expr::Lookup("number")),
+            param: "n",
+            predicate: Box::new(Expr::Bool(true)),
+        };
+        let ctx = EvalContext { args: &NoFields, instance: &roster() };
+        let err = eval(&wrong, &ctx).unwrap_err();
+        assert!(format!("{err:?}").contains("any? expects a list"), "{err:?}");
+    }
+}

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

@@ -0,0 +1,13 @@
+//! `||`, `&&` and `!` (`Evaluator`'s `Or`/`And`/`Not`); the right side short-circuits as in Ruby.
+
+use crate::kernel::expr::{interpret as eval, EvalContext, Expr, Value};
+use crate::kernel::Refusal;
+
+pub fn interpret(expr: &Expr, ctx: &EvalContext) -> Result<Value, Refusal> {
+    match expr {
+        Expr::Or(l, r) => Ok(Value::Bool(eval(l, ctx)?.truthy() || eval(r, ctx)?.truthy())),
+        Expr::And(l, r) => Ok(Value::Bool(eval(l, ctx)?.truthy() && eval(r, ctx)?.truthy())),
+        Expr::Not(n) => Ok(Value::Bool(!eval(n, ctx)?.truthy())),
+        _ => Err(Refusal::TypeMismatch(format!("logical::interpret called with a non-logical node {expr:?} — a router bug"))),
+    }
+}

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

@@ -0,0 +1,18 @@
+//! Interprets `.include?` over a String or Array haystack.
+//! Array haystacks come from computed lists (`.split`); literal arrays are rewritten at codegen.
+
+use crate::kernel::expr::{eval_error, interpret as eval, EvalContext, Expr, Value};
+use crate::kernel::Refusal;
+
+pub fn interpret(expr: &Expr, ctx: &EvalContext) -> Result<Value, Refusal> {
+    let Expr::Include { haystack, needle } = expr else {
+        return Err(Refusal::TypeMismatch(format!("membership::interpret called with a non-membership node {expr:?} — a router bug")));
+    };
+
+    match (eval(haystack, ctx)?, eval(needle, ctx)?) {
+        (Value::Str(h), Value::Str(n)) => Ok(Value::Bool(h.contains(&n))),
+        // Numeric-coerced equality, matching `Evaluator#includes?`.
+        (Value::Array(h), n) => Ok(Value::Bool(h.iter().any(|item| super::comparison::values_equal(item, &n)))),
+        (h, n) => Err(eval_error(format!("include? on {h:?} with {n:?} — a real (non-literal, non-split) Array haystack is not generated yet"))),
+    }
+}

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

@@ -0,0 +1,68 @@
+// GENERATED by hecks project_kernel_capabilities from Grammar.admitted_operators's own `category` field.
+// Do not hand-edit — re-run hecks project_kernel_capabilities instead.
+//
+// Ground truth: Hecks::Grammar.admitted_operators (lib/hecks/
+// grammar.rb), the SAME live-booted call hecks project_expression_tables
+// uses — grouped by the `category` field Evaluator::PROJECTION already
+// partitions comparison operators by (evaluator.rb).
+
+pub mod logical;
+pub mod membership;
+pub mod comparison;
+pub mod arithmetic;
+pub mod sign_test;
+pub mod sized;
+pub mod to_string;
+pub mod enumeration;
+pub mod pattern_match;
+pub mod presence;
+pub mod text;
+pub mod positional;
+
+/// One variant per real expression-operator category the Ruby
+/// grammar admits, in the order Grammar.admitted_operators's own `category` field declares them. Every match
+/// over this enum in the kernel (rust/src/kernel/expr.rs) is written
+/// WITHOUT a wildcard `_ =>` arm — see expr.rs's own header for why:
+/// a wildcard here would let a newly-admitted capability compile
+/// silently into a router that never calls the new file this same
+/// regeneration adds a `pub mod` line for above.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum OperatorCategory {
+    Logical,
+    Membership,
+    Comparison,
+    Arithmetic,
+    SignTest,
+    Sized,
+    ToString,
+    Enumeration,
+    PatternMatch,
+    Presence,
+    Text,
+    Positional,
+}
+
+impl OperatorCategory {
+    /// The `rust/src/kernel/expression_operators/<name>.rs` file this
+    /// variant names — `hecks measure_kernel_coverage`'s own existence
+    /// check reads this, so the file-name spelling here is the ONE
+    /// place that ever needs to change if a name is renamed.
+    pub fn module_name(&self) -> &'static str {
+        match self {
+            OperatorCategory::Logical => "logical",
+            OperatorCategory::Membership => "membership",
+            OperatorCategory::Comparison => "comparison",
+            OperatorCategory::Arithmetic => "arithmetic",
+            OperatorCategory::SignTest => "sign_test",
+            OperatorCategory::Sized => "sized",
+            OperatorCategory::ToString => "to_string",
+            OperatorCategory::Enumeration => "enumeration",
+            OperatorCategory::PatternMatch => "pattern_match",
+            OperatorCategory::Presence => "presence",
+            OperatorCategory::Text => "text",
+            OperatorCategory::Positional => "positional",
+        }
+    }
+
+    pub const ALL: &'static [OperatorCategory] = &[OperatorCategory::Logical, OperatorCategory::Membership, OperatorCategory::Comparison, OperatorCategory::Arithmetic, OperatorCategory::SignTest, OperatorCategory::Sized, OperatorCategory::ToString, OperatorCategory::Enumeration, OperatorCategory::PatternMatch, OperatorCategory::Presence, OperatorCategory::Text, OperatorCategory::Positional];
+}

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

@@ -0,0 +1,73 @@
+//! Interprets `.match?` against a Ruby-style pattern with `i`/`m`/`x` flags.
+//! `regex` is the kernel's one dependency: a hand-rolled subset cannot reach Ruby parity.
+
+use crate::kernel::expr::{eval_error, interpret as eval, EvalContext, Expr, Value};
+use crate::kernel::Refusal;
+use regex::RegexBuilder;
+
+pub fn interpret(expr: &Expr, ctx: &EvalContext) -> Result<Value, Refusal> {
+    let Expr::MatchesRegex { receiver, pattern, flags } = expr else {
+        return Err(Refusal::TypeMismatch(format!("pattern_match::interpret called with a non-match? node {expr:?} — a router bug")));
+    };
+
+    let text = coerce_text(&eval(receiver, ctx)?)?;
+
+    // Ruby's `/x` is `ignore_whitespace` in `regex`; `i` and `m` map directly.
+    let mut builder = RegexBuilder::new(pattern);
+    builder.case_insensitive(flags.contains('i'));
+    builder.multi_line(flags.contains('m'));
+    builder.ignore_whitespace(flags.contains('x'));
+
+    let re = builder
+        .build()
+        .map_err(|e| eval_error(format!("match? given an invalid pattern {pattern:?} — {e}")))?;
+
+    Ok(Value::Bool(re.is_match(&text)))
+}
+
+/// Text form of a scalar receiver: nil is empty, Bool and lists refuse.
+fn coerce_text(v: &Value) -> Result<String, Refusal> {
+    match v {
+        Value::Str(s) => Ok(s.clone()),
+        Value::Int(i) => Ok(i.to_string()),
+        Value::Float(f) => Ok(f.to_string()),
+        Value::Nil => Ok(String::new()),
+        Value::Bool(_) | Value::List(_) | Value::Array(_) => Err(eval_error(format!("match? expects a scalar, got {v:?}"))),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn matches(receiver: Expr, pattern: &str, flags: &str) -> Value {
+        let expr = Expr::MatchesRegex { receiver: Box::new(receiver), pattern: pattern.to_string(), flags: flags.to_string() };
+        let ctx = EvalContext { args: &crate::kernel::expr::NoFields, instance: &crate::kernel::expr::NoFields };
+        eval(&expr, &ctx).expect("evaluates")
+    }
+
+    #[test]
+    fn matches_a_simple_anchored_pattern() {
+        assert_eq!(matches(Expr::Str("12345".to_string()), r"\A\d{5}\z", ""), Value::Bool(true));
+        assert_eq!(matches(Expr::Str("1234".to_string()), r"\A\d{5}\z", ""), Value::Bool(false));
+    }
+
+    #[test]
+    fn the_i_flag_ignores_case() {
+        assert_eq!(matches(Expr::Str("HELLO".to_string()), "hello", ""), Value::Bool(false));
+        assert_eq!(matches(Expr::Str("HELLO".to_string()), "hello", "i"), Value::Bool(true));
+    }
+
+    #[test]
+    fn coerces_non_string_scalars_to_text() {
+        assert_eq!(matches(Expr::Int(12345), r"\A\d+\z", ""), Value::Bool(true));
+        assert_eq!(matches(Expr::Nil, r"\A\z", ""), Value::Bool(true));
+    }
+
+    #[test]
+    fn an_invalid_pattern_refuses_cleanly() {
+        let expr = Expr::MatchesRegex { receiver: Box::new(Expr::Str("x".to_string())), pattern: "(".to_string(), flags: String::new() };
+        let ctx = EvalContext { args: &crate::kernel::expr::NoFields, instance: &crate::kernel::expr::NoFields };
+        assert!(eval(&expr, &ctx).is_err());
+    }
+}

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

@@ -0,0 +1,126 @@
+//! Interprets `.first` and `.last` over an Array value or a list-typed field lookup.
+
+use crate::kernel::expr::{eval_error, interpret as eval, lookup_items, EvalContext, Expr, Field, Value};
+use crate::kernel::Refusal;
+
+pub fn interpret(expr: &Expr, ctx: &EvalContext) -> Result<Value, Refusal> {
+    let (op, receiver, take_first) = match expr {
+        Expr::First(receiver) => ("first", receiver, true),
+        Expr::Last(receiver) => ("last", receiver, false),
+        _ => return Err(Refusal::TypeMismatch(format!("positional::interpret called with a non-positional node {expr:?} — a router bug"))),
+    };
+
+    match receiver.as_ref() {
+        Expr::Lookup(path) => {
+            // `Value::List` carries only a length, so read the elements directly.
+            let items = lookup_items(path, ctx, op)?;
+            field_value(if take_first { items.into_iter().next() } else { items.into_iter().last() }, op)
+        }
+        other => match eval(other, ctx)? {
+            Value::Array(mut elements) => {
+                Ok(if take_first {
+                    elements.into_iter().next()
+                } else {
+                    elements.pop()
+                }
+                .unwrap_or(Value::Nil))
+            }
+            v => Err(eval_error(format!("{op} expects a list, got {v:?}"))),
+        },
+    }
+}
+
+/// The element `lookup_items` returned; an empty list is nil, as in Ruby.
+/// A `Field::Nested` element has no `Value` shape, so it refuses.
+fn field_value(item: Option<Field<'_>>, op: &str) -> Result<Value, Refusal> {
+    match item {
+        None => Ok(Value::Nil),
+        Some(Field::Value(v)) => Ok(v),
+        Some(Field::Nested(_)) => Err(eval_error(format!("{op} on a list of objects is not generated yet — only scalar-element lists are"))),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::kernel::expr::{Fielded, NoFields};
+
+    fn run(expr: Expr, instance: &dyn Fielded) -> Value {
+        let ctx = EvalContext { args: &NoFields, instance };
+        eval(&expr, &ctx).expect("evaluates")
+    }
+
+    #[test]
+    fn first_and_last_over_an_array_literal() {
+        let arr = Expr::Array(vec![Expr::Int(1), Expr::Int(2), Expr::Int(3)]);
+        assert_eq!(run(Expr::First(Box::new(arr.clone())), &NoFields), Value::Int(1));
+        assert_eq!(run(Expr::Last(Box::new(arr)), &NoFields), Value::Int(3));
+    }
+
+    #[test]
+    fn first_and_last_over_an_empty_array_literal_answer_nil() {
+        let arr = Expr::Array(vec![]);
+        assert_eq!(run(Expr::First(Box::new(arr.clone())), &NoFields), Value::Nil);
+        assert_eq!(run(Expr::Last(Box::new(arr)), &NoFields), Value::Nil);
+    }
+
+    #[test]
+    fn first_and_last_compose_with_split() {
+        let phrase = Expr::Split { receiver: Box::new(Expr::Str("a::b::c".to_string())), separator: "::".to_string() };
+        assert_eq!(run(Expr::Last(Box::new(phrase.clone())), &NoFields), Value::Str("c".to_string()));
+        assert_eq!(run(Expr::First(Box::new(phrase)), &NoFields), Value::Str("a".to_string()));
+    }
+
+    struct Tags {
+        values: Vec<String>,
+    }
+    impl Fielded for Tags {
+        fn field(&self, name: &str) -> Option<Field<'_>> {
+            (name == "tags").then(|| Field::Value(Value::List(self.values.len())))
+        }
+        fn items(&self, name: &str) -> Option<Vec<Field<'_>>> {
+            (name == "tags").then(|| self.values.iter().map(|t| Field::Value(Value::Str(t.clone()))).collect())
+        }
+    }
+
+    #[test]
+    fn first_over_a_real_scalar_element_field() {
+        let tags = Tags { values: vec!["a".to_string(), "b".to_string()] };
+        assert_eq!(run(Expr::First(Box::new(Expr::Lookup("tags"))), &tags), Value::Str("a".to_string()));
+        assert_eq!(run(Expr::Last(Box::new(Expr::Lookup("tags"))), &tags), Value::Str("b".to_string()));
+    }
+
+    #[test]
+    fn first_over_an_empty_field_answers_nil() {
+        let tags = Tags { values: vec![] };
+        assert_eq!(run(Expr::First(Box::new(Expr::Lookup("tags"))), &tags), Value::Nil);
+    }
+
+    struct Leg {
+        origin: String,
+    }
+    impl Fielded for Leg {
+        fn field(&self, name: &str) -> Option<Field<'_>> {
+            (name == "origin").then(|| Field::Value(Value::Str(self.origin.clone())))
+        }
+    }
+    struct Itinerary {
+        legs: Vec<Leg>,
+    }
+    impl Fielded for Itinerary {
+        fn field(&self, name: &str) -> Option<Field<'_>> {
+            (name == "legs").then(|| Field::Value(Value::List(self.legs.len())))
+        }
+        fn items(&self, name: &str) -> Option<Vec<Field<'_>>> {
+            (name == "legs").then(|| self.legs.iter().map(|leg| Field::Nested(leg)).collect())
+        }
+    }
+
+    #[test]
+    fn first_over_a_list_of_objects_refuses_by_name_instead_of_misrepresenting_one() {
+        let itinerary = Itinerary { legs: vec![Leg { origin: "SFO".to_string() }] };
+        let ctx = EvalContext { args: &NoFields, instance: &itinerary };
+        let err = eval(&Expr::First(Box::new(Expr::Lookup("legs"))), &ctx).unwrap_err();
+        assert!(format!("{err:?}").contains("not generated yet"), "{err:?}");
+    }
+}

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

@@ -0,0 +1,101 @@
+//! Interprets `.present?`/`.blank?` and `.set?`/`.unset?`.
+//! The two pairs share one operator category and differ in how they treat empty values.
+
+use crate::kernel::expr::{interpret as eval, EvalContext, Expr, Value};
+use crate::kernel::Refusal;
+
+pub fn interpret(expr: &Expr, ctx: &EvalContext) -> Result<Value, Refusal> {
+    let Expr::Presence { receiver, negated } = expr else {
+        return Err(Refusal::TypeMismatch(format!("presence::interpret called with a non-presence node {expr:?} — a router bug")));
+    };
+
+    let v = eval(receiver, ctx)?;
+    let present = !blank(&v);
+    Ok(Value::Bool(if *negated { !present } else { present }))
+}
+
+/// `.set?` / `.unset?`: only nil is unset, so an empty Str or Array is set (unlike `.present?`).
+pub fn interpret_assignment(expr: &Expr, ctx: &EvalContext) -> Result<Value, Refusal> {
+    let Expr::Assignment { receiver, negated } = expr else {
+        return Err(Refusal::TypeMismatch(format!("presence::interpret_assignment called with a non-assignment node {expr:?} — a router bug")));
+    };
+
+    let v = eval(receiver, ctx)?;
+    let set = !matches!(v, Value::Nil);
+    Ok(Value::Bool(if *negated { !set } else { set }))
+}
+
+/// Rails-style blankness: nil, false, and an empty Str or Array.
+fn blank(v: &Value) -> bool {
+    match v {
+        Value::Nil | Value::Bool(false) => true,
+        Value::Str(s) => s.is_empty(),
+        Value::Array(elements) => elements.is_empty(),
+        Value::Int(_) | Value::Float(_) | Value::Bool(true) | Value::List(_) => false,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::kernel::expr::NoFields;
+
+    fn present(receiver: Expr, negated: bool) -> Value {
+        let expr = Expr::Presence { receiver: Box::new(receiver), negated };
+        let ctx = EvalContext { args: &NoFields, instance: &NoFields };
+        eval(&expr, &ctx).expect("evaluates")
+    }
+
+    #[test]
+    fn nil_and_false_are_blank() {
+        assert_eq!(present(Expr::Nil, false), Value::Bool(false));
+        assert_eq!(present(Expr::Bool(false), false), Value::Bool(false));
+    }
+
+    #[test]
+    fn an_empty_string_is_blank_but_a_nonempty_one_is_present() {
+        assert_eq!(present(Expr::Str(String::new()), false), Value::Bool(false));
+        assert_eq!(present(Expr::Str("x".to_string()), false), Value::Bool(true));
+    }
+
+    #[test]
+    fn zero_and_false_scalar_are_present_not_blank() {
+        assert_eq!(present(Expr::Int(0), false), Value::Bool(true));
+    }
+
+    #[test]
+    fn blank_negates_present() {
+        assert_eq!(present(Expr::Nil, true), Value::Bool(true));
+        assert_eq!(present(Expr::Str("x".to_string()), true), Value::Bool(false));
+    }
+
+    #[test]
+    fn an_empty_array_literal_is_blank() {
+        assert_eq!(present(Expr::Array(vec![]), false), Value::Bool(false));
+        assert_eq!(present(Expr::Array(vec![Expr::Int(1)]), false), Value::Bool(true));
+    }
+
+    fn set(receiver: Expr, negated: bool) -> Value {
+        let expr = Expr::Assignment { receiver: Box::new(receiver), negated };
+        let ctx = EvalContext { args: &NoFields, instance: &NoFields };
+        eval(&expr, &ctx).expect("evaluates")
+    }
+
+    #[test]
+    fn only_nil_is_unset() {
+        assert_eq!(set(Expr::Nil, false), Value::Bool(false));
+        assert_eq!(set(Expr::Bool(false), false), Value::Bool(true));
+    }
+
+    #[test]
+    fn an_empty_string_or_array_is_set_unlike_present_s_own_reading() {
+        assert_eq!(set(Expr::Str(String::new()), false), Value::Bool(true));
+        assert_eq!(set(Expr::Array(vec![]), false), Value::Bool(true));
+    }
+
+    #[test]
+    fn unset_negates_set() {
+        assert_eq!(set(Expr::Nil, true), Value::Bool(true));
+        assert_eq!(set(Expr::Str("x".to_string()), true), Value::Bool(false));
+    }
+}

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

@@ -0,0 +1,16 @@
+//! Interprets `.positive?`, `.negative?` and `.zero?` as comparisons of the receiver with 0.
+
+use crate::kernel::expr::{interpret as eval, EvalContext, Expr, Value};
+use crate::kernel::expression_operators::{arithmetic::require_number, comparison};
+use crate::kernel::Refusal;
+
+pub fn interpret(expr: &Expr, ctx: &EvalContext) -> Result<Value, Refusal> {
+    let Expr::SignTest { op, receiver } = expr else {
+        return Err(Refusal::TypeMismatch(format!("sign_test::interpret called with a non-sign-test node {expr:?} — a router bug")));
+    };
+
+    // Comparing against 0 through `comparison::apply` treats int and float alike.
+    let v = eval(receiver, ctx)?;
+    require_number(&v, "sign test")?;
+    Ok(Value::Bool(comparison::apply(op, &v, &Value::Int(0))?))
+}