aboutsummaryrefslogtreecommitdiff
path: root/src/eval.rs
diff options
context:
space:
mode:
authorOnur Gündüz <ogunduz@gmail.com>2026-09-29 14:03:41 +0200
committerOnur Gündüz <ogunduz@gmail.com>2026-09-29 14:03:41 +0200
commite3eb58307419a9f7314e061c393d579fd14b75ab (patch)
tree8e232ec9ee70bd07ebe46bbc9fd86643cb411642 /src/eval.rs
parent93fd7757dc4900da697b9d5e884e1a343e2facda (diff)
downloadele-e3eb58307419a9f7314e061c393d579fd14b75ab.tar.gz
ele-e3eb58307419a9f7314e061c393d579fd14b75ab.zip
Compile filters once and reject unsupported evaluation
Diffstat (limited to 'src/eval.rs')
-rw-r--r--src/eval.rs476
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,
}
}