hecks 2.9.0 → 3.0.0

data/rust/parser/src/expr/ast_json.rs

@@ -0,0 +1,147 @@
+//! Emits the `"op"`-tagged JSON AST for a parsed predicate, mirroring `ast_json.rb`.
+//! Key order must match the Ruby output byte for byte; parser parity compares it.
+
+use crate::emit::JsonValue;
+use crate::expr::evaluator::{self, Evaluator};
+use crate::expr::resolver::Resolver;
+use crate::expr::{find_operator, Operator};
+
+pub fn emit_predicate(canonical: &str) -> JsonValue {
+    emit_bool(&evaluator::parse(canonical))
+}
+
+fn obj(pairs: Vec<(&str, JsonValue)>) -> JsonValue {
+    JsonValue::Object(pairs.into_iter().map(|(k, v)| (k.to_string(), v)).collect())
+}
+
+fn op_tag(name: &str) -> (&'static str, JsonValue) {
+    ("op", JsonValue::String(name.to_string()))
+}
+
+fn emit_bool(node: &Evaluator) -> JsonValue {
+    match node {
+        Evaluator::Or(left, right) => obj(vec![op_tag("or"), ("left", emit_bool(left)), ("right", emit_bool(right))]),
+        Evaluator::And(left, right) => obj(vec![op_tag("and"), ("left", emit_bool(left)), ("right", emit_bool(right))]),
+        Evaluator::Not(inner) => obj(vec![op_tag("not"), ("expr", emit_bool(inner))]),
+        Evaluator::Compare { operator, left, right } => obj(vec![
+            op_tag("compare"),
+            ("cmp", emit_comparison(operator)),
+            ("left", emit_resolver(left)),
+            ("right", emit_resolver(right)),
+        ]),
+        Evaluator::Include { haystack, needle } => emit_include(haystack, needle),
+        Evaluator::Resolve(expr) => emit_resolver(expr),
+    }
+}
+
+fn emit_comparison(operator: &Operator) -> JsonValue {
+    obj(vec![
+        ("less_than", JsonValue::Bool(operator.compares_less_than)),
+        ("equal", JsonValue::Bool(operator.compares_equal)),
+        ("negated", JsonValue::Bool(operator.negated)),
+    ])
+}
+
+fn emit_include(haystack: &Resolver, needle: &Resolver) -> JsonValue {
+    let Resolver::ArrayLiteral(elements) = haystack else {
+        return obj(vec![op_tag("include"), ("haystack", emit_resolver(haystack)), ("needle", emit_resolver(needle))]);
+    };
+
+    if elements.is_empty() {
+        return obj(vec![op_tag("bool"), ("value", JsonValue::Bool(false))]);
+    }
+
+    let eq = find_operator("==");
+    elements
+        .iter()
+        .map(|element| {
+            obj(vec![
+                op_tag("compare"),
+                ("cmp", emit_comparison(&eq)),
+                ("left", emit_resolver(needle)),
+                ("right", emit_resolver(element)),
+            ])
+        })
+        .reduce(|left, right| obj(vec![op_tag("or"), ("left", left), ("right", right)]))
+        .expect("non-empty by the guard above")
+}
+
+fn emit_resolver(node: &Resolver) -> JsonValue {
+    match node {
+        Resolver::IntegerLiteral(v) => obj(vec![op_tag("int"), ("value", JsonValue::Number(v.to_string()))]),
+        Resolver::FloatLiteral(v) => obj(vec![op_tag("float"), ("value", JsonValue::Number(ruby_float(*v)))]),
+        Resolver::StringLiteral(v) => obj(vec![op_tag("str"), ("value", JsonValue::String(v.clone()))]),
+        Resolver::BoolLiteral(v) => obj(vec![op_tag("bool"), ("value", JsonValue::Bool(*v))]),
+        Resolver::NilLiteral => obj(vec![op_tag("nil")]),
+        Resolver::Lookup(path) => obj(vec![
+            op_tag("lookup"),
+            ("path", JsonValue::Array(path.split('.').map(|s| JsonValue::String(s.to_string())).collect())),
+        ]),
+        Resolver::Addition(left, right) => obj(vec![op_tag("add"), ("left", emit_resolver(left)), ("right", emit_resolver(right))]),
+        Resolver::SignTest { operator, receiver } => obj(vec![
+            op_tag("sign_test"),
+            ("cmp", emit_comparison(operator)),
+            ("receiver", emit_resolver(receiver)),
+        ]),
+        Resolver::Empty(receiver) => obj(vec![op_tag("empty"), ("receiver", emit_resolver(receiver))]),
+        Resolver::ToS(receiver) => obj(vec![op_tag("to_s"), ("receiver", emit_resolver(receiver))]),
+        Resolver::Modulo { receiver, divisor } => obj(vec![
+            op_tag("modulo"),
+            ("receiver", emit_resolver(receiver)),
+            ("divisor", emit_resolver(divisor)),
+        ]),
+        Resolver::Size(receiver) => obj(vec![op_tag("size"), ("receiver", emit_resolver(receiver))]),
+        Resolver::MatchesRegex { receiver, pattern, flags } => obj(vec![
+            op_tag("matches_regex"),
+            ("receiver", emit_resolver(receiver)),
+            ("pattern", JsonValue::String(pattern.clone())),
+            ("flags", JsonValue::String(flags.clone())),
+        ]),
+        Resolver::Presence { receiver, negated } => {
+            obj(vec![op_tag("presence"), ("receiver", emit_resolver(receiver)), ("negated", JsonValue::Bool(*negated))])
+        }
+        Resolver::Assignment { receiver, negated } => {
+            obj(vec![op_tag("assignment"), ("receiver", emit_resolver(receiver)), ("negated", JsonValue::Bool(*negated))])
+        }
+        Resolver::Split { receiver, separator } => {
+            obj(vec![op_tag("split"), ("receiver", emit_resolver(receiver)), ("separator", JsonValue::String(separator.clone()))])
+        }
+        Resolver::StartsWith { receiver, substring } => {
+            obj(vec![op_tag("starts_with"), ("receiver", emit_resolver(receiver)), ("substring", JsonValue::String(substring.clone()))])
+        }
+        Resolver::EndsWith { receiver, substring } => {
+            obj(vec![op_tag("ends_with"), ("receiver", emit_resolver(receiver)), ("substring", JsonValue::String(substring.clone()))])
+        }
+        Resolver::First(receiver) => obj(vec![op_tag("first"), ("receiver", emit_resolver(receiver))]),
+        Resolver::Last(receiver) => obj(vec![op_tag("last"), ("receiver", emit_resolver(receiver))]),
+        Resolver::BlockPredicate { mode, receiver, param, predicate } => obj(vec![
+            op_tag("block_predicate"),
+            ("mode", JsonValue::String(mode.json_name().to_string())),
+            ("receiver", emit_resolver(receiver)),
+            ("param", JsonValue::String(param.clone())),
+            ("predicate", emit_bool(predicate)),
+        ]),
+        Resolver::Find { receiver, param, predicate, path } => obj(vec![
+            op_tag("find"),
+            ("receiver", emit_resolver(receiver)),
+            ("param", JsonValue::String(param.clone())),
+            ("predicate", emit_bool(predicate)),
+            ("path", JsonValue::Array(path.iter().map(|s| JsonValue::String(s.clone())).collect())),
+        ]),
+        // The haystack case is intercepted in `emit_include`.
+        Resolver::ArrayLiteral(elements) => obj(vec![
+            op_tag("array"),
+            ("elements", JsonValue::Array(elements.iter().map(emit_resolver).collect())),
+        ]),
+    }
+}
+
+/// Ruby's `Float#to_s`: always carries a decimal point.
+fn ruby_float(n: f64) -> String {
+    let text = format!("{n}");
+    if text.contains('.') || text.contains('e') || text.contains('E') {
+        text
+    } else {
+        format!("{text}.0")
+    }
+}

data/rust/parser/src/expr/evaluator.rs

@@ -0,0 +1,81 @@
+//! Parses boolean predicate expressions into an `Evaluator` tree (port of `evaluator.rb#parse`).
+
+use super::resolver::{self, Resolver};
+use super::{top_level_index, Operator, OPERATORS};
+
+#[derive(Debug, Clone)]
+pub enum Evaluator {
+    Or(Box<Evaluator>, Box<Evaluator>),
+    And(Box<Evaluator>, Box<Evaluator>),
+    Not(Box<Evaluator>),
+    Compare { operator: Operator, left: Resolver, right: Resolver },
+    Include { haystack: Resolver, needle: Resolver },
+    Resolve(Resolver),
+}
+
+pub fn parse(expr: &str) -> Evaluator {
+    let expr = super::strip_parens(expr.trim());
+
+    if let Some((left, right)) = split_top_level(&expr, "||") {
+        return Evaluator::Or(Box::new(parse(left)), Box::new(parse(right)));
+    }
+    if let Some((left, right)) = split_top_level(&expr, "&&") {
+        return Evaluator::And(Box::new(parse(left)), Box::new(parse(right)));
+    }
+
+    // A leading `!` negates the whole expression; strip it before `match_include` folds it
+    // into the haystack text (spec/corpus/grammar/negated_include.json).
+    if let Some(inner) = expr.strip_prefix('!') {
+        if !inner.is_empty() {
+            return Evaluator::Not(Box::new(parse(inner)));
+        }
+    }
+
+    if let Some((haystack, needle)) = match_include(&expr) {
+        return Evaluator::Include { haystack: resolver::parse(haystack), needle: resolver::parse(needle) };
+    }
+
+    for op in OPERATORS.iter() {
+        if let Some((left, right)) = split_comparison(&expr, op.symbol) {
+            return Evaluator::Compare { operator: *op, left: resolver::parse(left), right: resolver::parse(right) };
+        }
+    }
+
+    Evaluator::Resolve(resolver::parse(&expr))
+}
+
+fn split_top_level<'a>(expr: &'a str, operator: &str) -> Option<(&'a str, &'a str)> {
+    let index = top_level_index(expr, operator, |_| true)?;
+    Some((expr[..index].trim(), expr[index + operator.len()..].trim()))
+}
+
+fn split_comparison<'a>(expr: &'a str, operator: &str) -> Option<(&'a str, &'a str)> {
+    let index = top_level_index(expr, operator, |at| !part_of_longer(expr, at, operator))?;
+    Some((expr[..index].trim(), expr[index + operator.len()..].trim()))
+}
+
+fn part_of_longer(expr: &str, index: usize, operator: &str) -> bool {
+    let bytes = expr.as_bytes();
+    let after = bytes.get(index + operator.len()).copied();
+    let before = if index > 0 { bytes.get(index - 1).copied() } else { None };
+
+    if after == Some(b'=') && !operator.ends_with('=') {
+        return true;
+    }
+    if let Some(b) = before {
+        if (b == b'<' || b == b'>' || b == b'!' || b == b'=') && operator.starts_with('=') {
+            return true;
+        }
+    }
+    false
+}
+
+/// `expr.rindex(".include?(")` + `end_with?(")")`.
+fn match_include(expr: &str) -> Option<(&str, &str)> {
+    if !expr.ends_with(')') {
+        return None;
+    }
+    let marker = ".include?(";
+    let index = expr.rfind(marker)?;
+    Some((&expr[..index], &expr[index + marker.len()..expr.len() - 1]))
+}

data/rust/parser/src/expr/mod.rs

@@ -0,0 +1,84 @@
+//! Port of the `parse` step of `expression/{evaluator,resolver}.rb`; evaluation stays elsewhere.
+//! Each Ruby helper has a same-named function here.
+
+pub mod evaluator;
+pub mod resolver;
+
+/// A comparison operator. Order in `OPERATORS` matters: the first match wins,
+/// so `>=` and `<=` must precede `>` and `<`.
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct Operator {
+    pub symbol: &'static str,
+    pub compares_less_than: bool,
+    pub compares_equal: bool,
+    pub negated: bool,
+}
+
+pub const OPERATORS: [Operator; 6] = [
+    Operator { symbol: ">=", compares_less_than: true, compares_equal: false, negated: true },
+    Operator { symbol: "<=", compares_less_than: true, compares_equal: true, negated: false },
+    Operator { symbol: "<", compares_less_than: true, compares_equal: false, negated: false },
+    Operator { symbol: ">", compares_less_than: true, compares_equal: true, negated: true },
+    Operator { symbol: "==", compares_less_than: false, compares_equal: true, negated: false },
+    Operator { symbol: "!=", compares_less_than: false, compares_equal: true, negated: true },
+];
+
+pub fn find_operator(symbol: &str) -> Operator {
+    *OPERATORS.iter().find(|op| op.symbol == symbol).unwrap_or_else(|| panic!("no such comparison operator {symbol:?}"))
+}
+
+/// Index of the first top-level (outside quotes and brackets) `operator` that `accept` allows.
+pub fn top_level_index(expr: &str, operator: &str, accept: impl Fn(usize) -> bool) -> Option<usize> {
+    let bytes = expr.as_bytes();
+    let op_bytes = operator.as_bytes();
+    let mut depth: i32 = 0;
+    let mut quote: Option<u8> = None;
+    let mut index = 0usize;
+
+    while index < bytes.len() {
+        let ch = bytes[index];
+        if let Some(q) = quote {
+            if ch == q {
+                quote = None;
+            }
+        } else if ch == b'"' || ch == b'\'' {
+            quote = Some(ch);
+        } else if ch == b'(' || ch == b'{' {
+            // Braces count toward depth so an operator inside a block body is never top-level.
+            depth += 1;
+        } else if ch == b')' || ch == b'}' {
+            depth -= 1;
+        } else if depth == 0 && index + op_bytes.len() <= bytes.len() && &bytes[index..index + op_bytes.len()] == op_bytes {
+            if accept(index) {
+                return Some(index);
+            }
+        }
+        index += 1;
+    }
+    None
+}
+
+pub fn strip_parens(expr: &str) -> String {
+    let expr = expr.trim();
+    if !(expr.starts_with('(') && expr.ends_with(')')) {
+        return expr.to_string();
+    }
+
+    let chars: Vec<char> = expr.chars().collect();
+    let mut depth: i32 = 0;
+    for (index, &c) in chars.iter().enumerate() {
+        if c == '(' {
+            depth += 1;
+        }
+        if c == ')' {
+            depth -= 1;
+        }
+        if depth == 0 && index < chars.len() - 1 {
+            return expr.to_string();
+        }
+    }
+    let inner: String = chars[1..chars.len() - 1].iter().collect();
+    strip_parens(inner.trim())
+}
+
+pub mod ast_json;