diff options
| author | Onur Gündüz <ogunduz@gmail.com> | 2026-09-29 14:03:41 +0200 |
|---|---|---|
| committer | Onur Gündüz <ogunduz@gmail.com> | 2026-09-29 14:03:41 +0200 |
| commit | e3eb58307419a9f7314e061c393d579fd14b75ab (patch) | |
| tree | 8e232ec9ee70bd07ebe46bbc9fd86643cb411642 /src/eval.rs | |
| parent | 93fd7757dc4900da697b9d5e884e1a343e2facda (diff) | |
| download | ele-e3eb58307419a9f7314e061c393d579fd14b75ab.tar.gz ele-e3eb58307419a9f7314e061c393d579fd14b75ab.zip | |
Compile filters once and reject unsupported evaluation
Diffstat (limited to 'src/eval.rs')
| -rw-r--r-- | src/eval.rs | 476 |
1 files changed, 132 insertions, 344 deletions
diff --git a/src/eval.rs b/src/eval.rs index 24866b9..e338900 100644 --- a/src/eval.rs +++ b/src/eval.rs @@ -1,5 +1,5 @@ -use super::ast::{BinaryOp, CompareOp, Expr, UnaryOp}; -use regex::Regex; +use super::ast::{CompareOp, Expr}; +use serde_json::Value as Json; use std::{borrow::Cow, cmp::Ordering}; /// A runtime value used during filter evaluation. @@ -21,6 +21,10 @@ pub enum Value<'a> { List(Vec<Value<'a>>), /// A map of string keys to values. Map(Vec<(&'a str, Value<'a>)>), + /// Borrowed JSON array; its elements are converted only when inspected. + JsonArray(&'a [Json]), + /// Borrowed JSON object; its values are converted only when inspected. + JsonObject(&'a serde_json::Map<String, Json>), /// Absent value. Null, } @@ -51,27 +55,17 @@ impl<'a> Value<'a> { Value::StringOwned(s) => s.is_empty(), Value::List(v) => v.is_empty(), Value::Map(m) => m.is_empty(), + Value::JsonArray(items) => items.is_empty(), + Value::JsonObject(entries) => entries.is_empty(), Value::Null => true, } } - /// Try to compare two values, returning an ordering if possible. - fn compare(&self, other: &Value<'_>) -> Option<Ordering> { + fn compare_number(&self, other: &Value<'_>) -> Option<Ordering> { match (self, other) { - (Value::Bool(a), Value::Bool(b)) => Some(a.cmp(b)), (Value::Int(a), Value::Int(b)) => Some(a.cmp(b)), (Value::Uint(a), Value::Uint(b)) => Some(a.cmp(b)), (Value::Float(a), Value::Float(b)) => a.partial_cmp(b), - (Value::String(a), Value::String(b)) => Some(a.to_lowercase().cmp(&b.to_lowercase())), - (Value::StringOwned(a), Value::String(b)) => { - Some(a.to_lowercase().cmp(&b.to_lowercase())) - } - (Value::String(a), Value::StringOwned(b)) => { - Some(a.to_lowercase().cmp(&b.to_lowercase())) - } - (Value::StringOwned(a), Value::StringOwned(b)) => { - Some(a.to_lowercase().cmp(&b.to_lowercase())) - } // Cross-numeric comparisons (Value::Int(a), Value::Float(b)) => compare_integer_float(i128::from(*a), *b), (Value::Float(a), Value::Int(b)) => { @@ -179,341 +173,153 @@ pub trait Filterable { } } -impl Expr { - /// Evaluate this expression against a filterable value. - /// - /// Returns `true` if the value matches the filter. - pub fn evaluate<T: Filterable>(&self, val: &T) -> bool { - match self { - Expr::Binary { op, left, right, .. } => match op { - BinaryOp::And => left.evaluate(val) && right.evaluate(val), - BinaryOp::Or => left.evaluate(val) || right.evaluate(val), - }, - - Expr::Unary { op, expr, .. } => { - let result = expr.evaluate(val); - match op { - UnaryOp::Minus | UnaryOp::Not => !result, - } - } - - Expr::Comparison { - op, left, right, .. - } => eval_comparison(*op, left, right, val), - - Expr::Name { - name, is_string, .. - } => { - if !*is_string && let Some(Value::Bool(b)) = val.field(name) { - return b; - } - val.matches_global(name) - } - - Expr::Member { - holder, member, .. - } => { - // Member as a standalone expression; expect boolean - if let Some(val) = resolve_member_value(holder, member, val) { - match val { - Value::Bool(b) => b, - _ => !val.is_zero(), - } +impl<'a> From<&'a Json> for Value<'a> { + fn from(value: &'a Json) -> Self { + match value { + Json::Null => Self::Null, + Json::Bool(value) => Self::Bool(*value), + Json::String(value) => Self::String(value), + Json::Number(value) => { + if let Some(value) = value.as_i64() { + Self::Int(value) + } else if let Some(value) = value.as_u64() { + Self::Uint(value) } else { - expr_to_literal_str(self).is_some_and(|literal| val.matches_global(&literal)) + Self::Float(value.as_f64().unwrap()) } } - - Expr::Function { .. } => { - // Function evaluation is not yet supported - false - } + Json::Array(values) => Self::JsonArray(values), + Json::Object(values) => Self::JsonObject(values), } } } -/// Evaluate a comparison expression. -fn eval_comparison<T: Filterable>( - op: CompareOp, - left: &Expr, - right: &Expr, - val: &T, -) -> bool { - // Resolve the left side to a Value - let left_val = resolve_expr_value(left, val); - - let Some(left_val) = left_val else { - return false; - }; - - eval_comparison_with_value(op, &left_val, right) -} - -fn eval_comparison_with_value( - op: CompareOp, - left_val: &Value<'_>, - right: &Expr, -) -> bool { - // Handle the right side, it could be a composite expression (AND/OR) - match right { - Expr::Binary { - op: bin_op, - left: rleft, - right: rright, - .. - } => match bin_op { - BinaryOp::And => { - eval_comparison_with_value(op, left_val, rleft) - && eval_comparison_with_value(op, left_val, rright) - } - BinaryOp::Or => { - eval_comparison_with_value(op, left_val, rleft) - || eval_comparison_with_value(op, left_val, rright) - } - }, - Expr::Unary { - op: UnaryOp::Minus | UnaryOp::Not, - expr, - .. - } => !eval_comparison_with_value(op, left_val, expr), - - _ => { - let right_str = expr_to_literal_str(right); - let right_str = right_str.as_deref(); - if op == CompareOp::Has && right_str == Some("*") { - return !left_val.is_zero(); - } - - match (&left_val, op) { - // Has operator on lists - (Value::List(items), CompareOp::Has) => { - if let Some(rs) = right_str { - items.iter().any(|item| value_matches_str(item, rs, op)) - } else { - false - } - } - - // Has operator on maps; check if key exists - (Value::Map(entries), CompareOp::Has) => { - if let Some(rs) = right_str { - entries.iter().any(|(k, _)| k.eq_ignore_ascii_case(rs)) - } else { - false - } - } - - // Equals/NotEquals on lists; check if any element matches - (Value::List(items), CompareOp::Equals) => { - if let Some(rs) = right_str { - items.iter().any(|item| value_matches_str(item, rs, op)) - } else { - false - } - } - (Value::List(items), CompareOp::NotEquals) => { - if let Some(rs) = right_str { - !items.iter().any(|item| value_matches_str(item, rs, CompareOp::Equals)) - } else { - true - } - } - - // Has on strings; substring/word boundary match - (_, CompareOp::Has) => { - if let Some(rs) = right_str { - value_matches_str(left_val, rs, op) - } else { - false - } - } - - // Regex match - (_, CompareOp::MatchesRegexp | CompareOp::NotMatchesRegexp) => { - let Some(left_s) = left_val.as_str() else { - return false; - }; - let Some(rs) = right_str else { - return false; - }; - let Ok(re) = Regex::new(rs) else { - return false; - }; - let matched = re.is_match(left_s); - if op == CompareOp::NotMatchesRegexp { - !matched - } else { - matched - } - } +impl Filterable for Json { + fn field(&self, name: &str) -> Option<Value<'_>> { + self.get(name).map(Value::from) + } - // Standard comparison - _ => { - if let Some(rs) = right_str { - let right_val = parse_literal_for_value(left_val, rs); - compare_values(op, left_val, &right_val) - } else { - false - } - } - } + fn field_path(&self, path: &[&str]) -> Option<Value<'_>> { + let mut current = self; + for segment in path { + current = current.get(*segment)?; } + Some(Value::from(current)) } -} -/// Resolve an expression to its value given a filterable object. -fn resolve_expr_value<'a, T: Filterable>(expr: &'a Expr, val: &'a T) -> Option<Value<'a>> { - match expr { - Expr::Name { - name, is_string, .. - } => { - if *is_string { - // A quoted string on the left side of a comparison is just a string literal - Some(Value::String(name)) - } else { - val.field(name) - } + fn all_field_values(&self) -> Vec<Value<'_>> { + match self { + Json::Object(values) => values.values().map(Value::from).collect(), + _ => vec![Value::from(self)], } - Expr::Member { - holder, member, .. - } => resolve_member_value(holder, member, val), - _ => None, } -} -/// Resolve a member expression (e.g., `a.b.c`) to a value. -fn resolve_member_value<'a, T: Filterable>( - holder: &Expr, - member: &str, - val: &'a T, -) -> Option<Value<'a>> { - // Collect the path segments - let mut path = vec![member]; - let mut cur = holder; - loop { - match cur { - Expr::Member { - holder, - member, - .. - } => { - path.push(member.as_str()); - cur = holder; - } - Expr::Name { name, .. } => { - path.push(name.as_str()); - break; - } - _ => return None, - } + fn matches_global(&self, search: &str) -> bool { + Value::from(self).matches_global(search) } - path.reverse(); +} - // Try field_path first - if let Some(v) = val.field_path(&path) { - return Some(v); +impl Expr { + /// Evaluates once, returning false if compilation fails, including under negation. + /// Use `compile()` to report errors and reuse the filter across records. + pub fn evaluate<T: Filterable>(&self, value: &T) -> bool { + self.compile().is_ok_and(|filter| filter.evaluate(value)) } +} - // Fall back to walking field by field (for nested Filterable values) - // First field - let first_val = val.field(path[0])?; +#[derive(Debug)] +pub(crate) struct Literal<'a> { + text: Cow<'a, str>, + folded: Option<String>, + number: Option<Value<'static>>, + boolean: Option<bool>, +} - // Walk remaining path through map keys - let mut current = first_val; - for &segment in &path[1..] { - current = match current { - Value::Map(entries) => { - let found = entries - .into_iter() - .find(|(k, _)| k.eq_ignore_ascii_case(segment)); - match found { - Some((_, v)) => v, - None => return None, - } - } - _ => return None, +impl<'a> Literal<'a> { + pub(crate) fn new(text: Cow<'a, str>) -> Self { + let number = if let Ok(value) = text.parse::<i64>() { + Some(Value::Int(value)) + } else if let Ok(value) = text.parse::<u64>() { + Some(Value::Uint(value)) + } else { + text.parse::<f64>().ok().map(Value::Float) + }; + let boolean = if text.eq_ignore_ascii_case("true") || text == "1" { + Some(true) + } else if text.eq_ignore_ascii_case("false") || text == "0" { + Some(false) + } else { + None + }; + let folded = match lowercase(&text) { + Cow::Borrowed(_) => None, + Cow::Owned(text) => Some(text), }; + Self { text, folded, number, boolean } } - Some(current) -} -/// Extract the literal string from an expression (name or member chain as dotted string). -fn expr_to_literal_str(expr: &Expr) -> Option<Cow<'_, str>> { - match expr { - Expr::Name { name, .. } => Some(Cow::Borrowed(name)), - Expr::Member { holder, member, .. } => { - // a.b on the right side is just "a.b" as a string - let mut parts = vec![member.as_str()]; - let mut cur = holder.as_ref(); - loop { - match cur { - Expr::Member { holder, member, .. } => { - parts.push(member.as_str()); - cur = holder.as_ref(); - } - Expr::Name { name, .. } => { - parts.push(name.as_str()); - break; - } - _ => return None, - } - } - parts.reverse(); - Some(Cow::Owned(parts.join("."))) - } - Expr::Function { .. } => None, - _ => None, + fn folded(&self) -> &str { + self.folded.as_deref().unwrap_or(&self.text) } } -/// Parse a literal string to match the type of a reference value. -fn parse_literal_for_value<'a>(reference: &Value<'_>, literal: &'a str) -> Value<'a> { - match reference { - Value::Bool(_) => { - if literal.eq_ignore_ascii_case("true") || literal == "1" { - Value::Bool(true) - } else if literal.eq_ignore_ascii_case("false") || literal == "0" { - Value::Bool(false) - } else { - Value::String(literal) - } +pub(crate) fn eval_literal(op: CompareOp, value: &Value<'_>, literal: &Literal<'_>) -> bool { + if op == CompareOp::Has && literal.text == "*" { + return !value.is_zero(); + } + if matches!(op, CompareOp::Equals | CompareOp::NotEquals | CompareOp::Has) { + let element_op = if op == CompareOp::NotEquals { CompareOp::Equals } else { op }; + let found = match value { + Value::List(items) => Some(items.iter().any(|item| value_matches_literal(item, literal, element_op))), + Value::JsonArray(items) => Some(items.iter().any(|item| value_matches_literal(&Value::from(item), literal, element_op))), + _ => None, + }; + if let Some(found) = found { + return found != (op == CompareOp::NotEquals); } - Value::Int(_) | Value::Uint(_) | Value::Float(_) => { - if let Ok(i) = literal.parse::<i64>() { - Value::Int(i) - } else if let Ok(u) = literal.parse::<u64>() { - Value::Uint(u) - } else if let Ok(f) = literal.parse::<f64>() { - Value::Float(f) - } else { - Value::String(literal) - } + } + if op == CompareOp::Has { + match value { + Value::Map(entries) => return entries.iter().any(|(key, _)| key.eq_ignore_ascii_case(&literal.text)), + Value::JsonObject(entries) => return entries.keys().any(|key| key.eq_ignore_ascii_case(&literal.text)), + _ => {} } - Value::String(_) | Value::StringOwned(_) => Value::String(literal), - _ => Value::String(literal), } + compare_literal(op, value, literal) } -/// Check if a value matches a string using the given comparison op. -fn value_matches_str(val: &Value<'_>, s: &str, op: CompareOp) -> bool { - match val { - Value::String(vs) => string_match(vs, s, op), - Value::StringOwned(vs) => string_match(vs.as_str(), s, op), - Value::Int(_) | Value::Uint(_) | Value::Float(_) | Value::Bool(_) => { - compare_values(op, val, &parse_literal_for_value(val, s)) - } - Value::List(items) => items.iter().any(|item| value_matches_str(item, s, op)), - Value::Map(entries) => entries.iter().any(|(_, v)| value_matches_str(v, s, op)), - Value::Null => false, +fn value_matches_literal(value: &Value<'_>, literal: &Literal<'_>, op: CompareOp) -> bool { + match value { + Value::List(items) => items.iter().any(|item| value_matches_literal(item, literal, op)), + Value::Map(entries) => entries.iter().any(|(_, value)| value_matches_literal(value, literal, op)), + Value::JsonArray(items) => items.iter().any(|value| value_matches_literal(&Value::from(value), literal, op)), + Value::JsonObject(entries) => entries.values().any(|value| value_matches_literal(&Value::from(value), literal, op)), + _ => compare_literal(op, value, literal), + } +} + +fn compare_literal(op: CompareOp, value: &Value<'_>, literal: &Literal<'_>) -> bool { + if let Some(text) = value.as_str() { + return string_match(text, literal, op); } + let order = match value { + Value::Bool(value) => literal.boolean.map(|right| value.cmp(&right)), + Value::Int(_) | Value::Uint(_) | Value::Float(_) => literal + .number + .as_ref() + .and_then(|right| value.compare_number(right)), + _ => None, + }; + compare_order(op, order) } /// Equality and `:` support a leading or trailing wildcard. /// Word boundaries for `:` are whitespace or ASCII punctuation. -fn string_match(haystack: &str, needle: &str, op: CompareOp) -> bool { +fn string_match(haystack: &str, literal: &Literal<'_>, op: CompareOp) -> bool { if op == CompareOp::NotEquals { - return !string_match(haystack, needle, CompareOp::Equals); + return !string_match(haystack, literal, CompareOp::Equals); } + let needle = literal.text.as_ref(); if matches!(op, CompareOp::Equals | CompareOp::Has) { if let Some(suffix) = needle.strip_prefix('*') { return haystack.len() @@ -530,7 +336,7 @@ fn string_match(haystack: &str, needle: &str, op: CompareOp) -> bool { CompareOp::Equals => haystack.eq_ignore_ascii_case(needle), CompareOp::Has => { let haystack = lowercase(haystack); - let needle = lowercase(needle); + let needle = literal.folded(); if needle.is_empty() { return true; } @@ -538,7 +344,7 @@ fn string_match(haystack: &str, needle: &str, op: CompareOp) -> bool { c.is_whitespace() || (c.is_ascii() && !c.is_ascii_alphanumeric()) }; let mut offset = 0; - while let Some(index) = haystack[offset..].find(needle.as_ref()) { + while let Some(index) = haystack[offset..].find(needle) { let start = offset + index; let end = start + needle.len(); if haystack[..start].chars().next_back().is_none_or(boundary) @@ -550,7 +356,7 @@ fn string_match(haystack: &str, needle: &str, op: CompareOp) -> bool { } false } - _ => compare_values(op, &Value::String(haystack), &Value::String(needle)), + _ => compare_order(op, Some(lowercase(haystack).as_ref().cmp(literal.folded()))), } } @@ -580,39 +386,21 @@ fn value_contains_str(val: &Value<'_>, search: &str) -> bool { } Value::List(items) => items.iter().any(|item| value_contains_str(item, search)), Value::Map(entries) => entries.iter().any(|(_, v)| value_contains_str(v, search)), + Value::JsonArray(items) => items.iter().any(|value| Value::from(value).matches_global(search)), + Value::JsonObject(entries) => entries.values().any(|value| Value::from(value).matches_global(search)), Value::Null => false, } } -/// Compare two values using a comparison operator. -fn compare_values(op: CompareOp, left: &Value<'_>, right: &Value<'_>) -> bool { +fn compare_order(op: CompareOp, order: Option<Ordering>) -> bool { match op { - CompareOp::Equals | CompareOp::Has => { - if let (Some(ls), Some(rs)) = (left.as_str(), right.as_str()) { - return string_match(ls, rs, op); - } - left.compare(right) == Some(Ordering::Equal) - } - CompareOp::NotEquals => { - if let (Some(ls), Some(rs)) = (left.as_str(), right.as_str()) { - return string_match(ls, rs, CompareOp::NotEquals); - } - left.compare(right) != Some(Ordering::Equal) - } - CompareOp::LessThan => left.compare(right) == Some(Ordering::Less), - CompareOp::LessThanEquals => matches!( - left.compare(right), - Some(Ordering::Less) | Some(Ordering::Equal) - ), - CompareOp::GreaterThan => left.compare(right) == Some(Ordering::Greater), - CompareOp::GreaterThanEquals => matches!( - left.compare(right), - Some(Ordering::Greater) | Some(Ordering::Equal) - ), - CompareOp::MatchesRegexp | CompareOp::NotMatchesRegexp => { - // Handled at a higher level - false - } + CompareOp::Equals | CompareOp::Has => order == Some(Ordering::Equal), + CompareOp::NotEquals => order != Some(Ordering::Equal), + CompareOp::LessThan => order == Some(Ordering::Less), + CompareOp::LessThanEquals => matches!(order, Some(Ordering::Less | Ordering::Equal)), + CompareOp::GreaterThan => order == Some(Ordering::Greater), + CompareOp::GreaterThanEquals => matches!(order, Some(Ordering::Greater | Ordering::Equal)), + CompareOp::MatchesRegexp | CompareOp::NotMatchesRegexp => false, } } |
