aboutsummaryrefslogtreecommitdiff
path: root/src/eval.rs
diff options
context:
space:
mode:
authorOnur Gündüz <ogunduz@gmail.com>2026-04-03 06:34:47 +0200
committerOnur Gündüz <ogunduz@gmail.com>2026-04-03 06:34:47 +0200
commit38b60098e42b4a899eb574f65fa14d4fdbe82f9b (patch)
tree3956fe1ab8107c5feb043fd466a969da8f5b1f9a /src/eval.rs
parentd20acec5efcad4b3cd493f914d10e3d11cdfee4d (diff)
downloadele-38b60098e42b4a899eb574f65fa14d4fdbe82f9b.tar.gz
ele-38b60098e42b4a899eb574f65fa14d4fdbe82f9b.zip
Init
Diffstat (limited to 'src/eval.rs')
-rw-r--r--src/eval.rs920
1 files changed, 920 insertions, 0 deletions
diff --git a/src/eval.rs b/src/eval.rs
new file mode 100644
index 0000000..bf2afec
--- /dev/null
+++ b/src/eval.rs
@@ -0,0 +1,920 @@
+use super::ast::{BinaryOp, CompareOp, Expr, UnaryOp};
+use regex::Regex;
+use std::cmp::Ordering;
+
+/// A runtime value used during filter evaluation.
+#[derive(Debug, Clone)]
+pub enum Value<'a> {
+ /// Boolean value.
+ Bool(bool),
+ /// Signed integer (covers i8..i64).
+ Int(i64),
+ /// Unsigned integer (covers u8..u64).
+ Uint(u64),
+ /// Floating-point number.
+ Float(f64),
+ /// Borrowed string reference.
+ String(&'a str),
+ /// Owned string (for computed values).
+ StringOwned(std::string::String),
+ /// A list of values (for repeated fields / slices).
+ List(Vec<Value<'a>>),
+ /// A map of string keys to values.
+ Map(Vec<(&'a str, Value<'a>)>),
+ /// Absent value.
+ Null,
+}
+
+impl<'a> Value<'a> {
+ /// Returns the string content if this is a string variant.
+ pub fn as_str(&self) -> Option<&str> {
+ match self {
+ Value::String(s) => Some(s),
+ Value::StringOwned(s) => Some(s.as_str()),
+ _ => None,
+ }
+ }
+
+ /// Returns true if this value is the zero/default for its type.
+ pub fn is_zero(&self) -> bool {
+ match self {
+ Value::Bool(b) => !b,
+ Value::Int(i) => *i == 0,
+ Value::Uint(u) => *u == 0,
+ Value::Float(f) => *f == 0.0,
+ Value::String(s) => s.is_empty(),
+ Value::StringOwned(s) => s.is_empty(),
+ Value::List(v) => v.is_empty(),
+ Value::Map(m) => m.is_empty(),
+ Value::Null => true,
+ }
+ }
+
+ /// Try to compare two values, returning an ordering if possible.
+ fn compare(&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)) => (*a as f64).partial_cmp(b),
+ (Value::Float(a), Value::Int(b)) => a.partial_cmp(&(*b as f64)),
+ (Value::Uint(a), Value::Float(b)) => (*a as f64).partial_cmp(b),
+ (Value::Float(a), Value::Uint(b)) => a.partial_cmp(&(*b as f64)),
+ (Value::Int(a), Value::Uint(b)) => {
+ if *a < 0 {
+ Some(Ordering::Less)
+ } else {
+ (*a as u64).partial_cmp(b)
+ }
+ }
+ (Value::Uint(a), Value::Int(b)) => {
+ if *b < 0 {
+ Some(Ordering::Greater)
+ } else {
+ a.partial_cmp(&(*b as u64))
+ }
+ }
+ _ => None,
+ }
+ }
+}
+
+/// Trait that types must implement to be filterable.
+///
+/// # Example
+///
+/// ```rust
+/// use aip_filter::{Value, Filterable};
+///
+/// struct Issue {
+/// state: String,
+/// priority: i64,
+/// }
+///
+/// impl Filterable for Issue {
+/// fn field(&self, name: &str) -> Option<Value<'_>> {
+/// match name {
+/// "state" => Some(Value::String(&self.state)),
+/// "priority" => Some(Value::Int(self.priority)),
+/// _ => None,
+/// }
+/// }
+/// }
+/// ```
+pub trait Filterable {
+ /// Look up a field by name, returning its value.
+ ///
+ /// The name matching should ideally support both snake_case and camelCase
+ /// forms, though this is up to the implementor.
+ ///
+ /// Return `None` if the field doesn't exist.
+ fn field(&self, name: &str) -> Option<Value<'_>>;
+
+ /// Look up a nested field path like `["a", "b"]` for `a.b`.
+ ///
+ /// Default implementation walks through `field()` calls for structs.
+ /// Override this for custom nested access.
+ fn field_path(&self, path: &[&str]) -> Option<Value<'_>> {
+ if path.is_empty() {
+ return None;
+ }
+ if path.len() == 1 {
+ return self.field(path[0]);
+ }
+ // Default: can't traverse deeper without knowing the sub-type
+ None
+ }
+
+ /// Return all field values for "global restriction" matching
+ /// (when a bare value appears without a field name).
+ ///
+ /// Default returns an empty vec (no global matching).
+ fn all_field_values(&self) -> Vec<Value<'_>> {
+ Vec::new()
+ }
+}
+
+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, ..
+ } => {
+ // A bare name/value: global restriction matching.
+ // Check if any field contains or equals the value.
+ if let Some(field_val) = val.field(name) {
+ // If it's a boolean field referenced by name, return its value
+ if !*is_string
+ && let Value::Bool(b) = field_val {
+ return b;
+ }
+ return !field_val.is_zero();
+ }
+
+ // Try matching against all fields
+ let search = name.as_str();
+ for field_val in val.all_field_values() {
+ if value_contains_str(&field_val, search) {
+ return true;
+ }
+ }
+ false
+ }
+
+ 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(),
+ }
+ } else {
+ false
+ }
+ }
+
+ Expr::Function { .. } => {
+ // Function evaluation is not yet supported
+ false
+ }
+ }
+ }
+}
+
+/// 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, val)
+}
+
+fn eval_comparison_with_value<T: Filterable>(
+ op: CompareOp,
+ left_val: &Value<'_>,
+ right: &Expr,
+ val: &T,
+) -> bool {
+ // Handle the right side, it could be a composite expression (AND/OR)
+ match right {
+ Expr::Binary {
+ op: bin_op,
+ left: rleft,
+ right: rright,
+ ..
+ } => {
+ let l = eval_comparison_with_value(op, left_val, rleft, val);
+ let r = eval_comparison_with_value(op, left_val, rright, val);
+ match bin_op {
+ BinaryOp::And => l && r,
+ BinaryOp::Or => l || r,
+ }
+ }
+ Expr::Unary {
+ op: UnaryOp::Minus | UnaryOp::Not,
+ expr,
+ ..
+ } => !eval_comparison_with_value(op, left_val, expr, val),
+
+ _ => {
+ let right_str = expr_to_literal_str(right);
+ let right_str = right_str.as_deref();
+
+ 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 {
+ // Wildcard handling
+ if rs == "*" {
+ return !left_val.is_zero();
+ }
+ 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
+ }
+ }
+
+ // 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
+ }
+ }
+ }
+ }
+ }
+}
+
+/// Resolve an expression to its value given a filterable object.
+fn resolve_expr_value<'a, T: Filterable>(expr: &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::StringOwned(name.clone()))
+ } else {
+ val.field(name)
+ }
+ }
+ 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,
+ }
+ }
+ path.reverse();
+
+ // Try field_path first
+ if let Some(v) = val.field_path(&path) {
+ return Some(v);
+ }
+
+ // Fall back to walking field by field (for nested Filterable values)
+ // First field
+ let first_val = val.field(path[0])?;
+
+ // 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,
+ };
+ }
+ Some(current)
+}
+
+/// Extract the literal string from an expression (name or member chain as dotted string).
+fn expr_to_literal_str(expr: &Expr) -> Option<String> {
+ match expr {
+ Expr::Name { name, .. } => Some(name.clone()),
+ 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(parts.join("."))
+ }
+ Expr::Function { .. } => None,
+ _ => None,
+ }
+}
+
+/// 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(_) => match literal.to_lowercase().as_str() {
+ "true" | "1" => Value::Bool(true),
+ "false" | "0" => Value::Bool(false),
+ _ => Value::String(literal),
+ },
+ Value::Int(_) => {
+ if let Ok(i) = literal.parse::<i64>() {
+ Value::Int(i)
+ } else if let Ok(f) = literal.parse::<f64>() {
+ Value::Int(f as i64)
+ } else {
+ Value::String(literal)
+ }
+ }
+ Value::Uint(_) => {
+ if let Ok(u) = literal.parse::<u64>() {
+ Value::Uint(u)
+ } else {
+ Value::String(literal)
+ }
+ }
+ Value::Float(_) => {
+ if let Ok(f) = literal.parse::<f64>() {
+ Value::Float(f)
+ } else {
+ Value::String(literal)
+ }
+ }
+ Value::String(_) | Value::StringOwned(_) => Value::String(literal),
+ _ => Value::String(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(i) => {
+ if let Ok(ri) = s.parse::<i64>() {
+ match op {
+ CompareOp::Equals | CompareOp::Has => *i == ri,
+ _ => false,
+ }
+ } else {
+ false
+ }
+ }
+ Value::Uint(u) => {
+ if let Ok(ru) = s.parse::<u64>() {
+ match op {
+ CompareOp::Equals | CompareOp::Has => *u == ru,
+ _ => false,
+ }
+ } else {
+ false
+ }
+ }
+ Value::Float(f) => {
+ if let Ok(rf) = s.parse::<f64>() {
+ match op {
+ CompareOp::Equals | CompareOp::Has => (*f - rf).abs() < f64::EPSILON,
+ _ => false,
+ }
+ } else {
+ false
+ }
+ }
+ Value::Bool(b) => {
+ let sb = matches!(s.to_lowercase().as_str(), "true" | "1");
+ match op {
+ CompareOp::Equals | CompareOp::Has => *b == sb,
+ _ => false,
+ }
+ }
+ 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,
+ }
+}
+
+/// String matching: case-insensitive equality for `=`, word-boundary match for `:`, wildcard support.
+fn string_match(haystack: &str, needle: &str, op: CompareOp) -> bool {
+ match op {
+ CompareOp::Has => {
+ // Wildcard: * prefix
+ if let Some(suffix) = needle.strip_prefix('*') {
+ return haystack.len() >= suffix.len()
+ && haystack[haystack.len() - suffix.len()..].eq_ignore_ascii_case(suffix);
+ }
+ // Wildcard: * suffix
+ if let Some(prefix) = needle.strip_suffix('*') {
+ return haystack.len() >= prefix.len()
+ && haystack[..prefix.len()].eq_ignore_ascii_case(prefix);
+ }
+
+ // Word boundary match
+ let hl = haystack.to_lowercase();
+ let nl = needle.to_lowercase();
+ if let Some(idx) = hl.find(&nl) {
+ let is_boundary = |b: u8| -> bool {
+ b < 0x80 && !b.is_ascii_alphanumeric()
+ };
+ let start_ok = idx == 0 || is_boundary(haystack.as_bytes()[idx - 1]);
+ let end_ok = idx + nl.len() >= haystack.len()
+ || is_boundary(haystack.as_bytes()[idx + nl.len()]);
+ if start_ok && end_ok {
+ return true;
+ }
+ }
+
+ // Also check individual words
+ let words = split_string(haystack);
+ if words.len() > 1 {
+ for word in &words {
+ if string_match(word, needle, CompareOp::Has) {
+ return true;
+ }
+ }
+ }
+
+ false
+ }
+ CompareOp::Equals => {
+ // Wildcard: * prefix
+ if let Some(suffix) = needle.strip_prefix('*') {
+ return haystack.len() >= suffix.len()
+ && haystack[haystack.len() - suffix.len()..].eq_ignore_ascii_case(suffix);
+ }
+ // Wildcard: * suffix
+ if let Some(prefix) = needle.strip_suffix('*') {
+ return haystack.len() >= prefix.len()
+ && haystack[..prefix.len()].eq_ignore_ascii_case(prefix);
+ }
+ haystack.eq_ignore_ascii_case(needle)
+ }
+ CompareOp::NotEquals => !haystack.eq_ignore_ascii_case(needle),
+ _ => {
+ // For ordering comparisons on strings, use case-sensitive compare
+ let ord = haystack.cmp(needle);
+ match op {
+ CompareOp::LessThan => ord == Ordering::Less,
+ CompareOp::LessThanEquals => ord != Ordering::Greater,
+ CompareOp::GreaterThan => ord == Ordering::Greater,
+ CompareOp::GreaterThanEquals => ord != Ordering::Less,
+ _ => false,
+ }
+ }
+ }
+}
+
+/// Check if a value contains a string (for global restriction matching).
+fn value_contains_str(val: &Value<'_>, search: &str) -> bool {
+ match val {
+ Value::String(s) => s.to_lowercase().contains(&search.to_lowercase()),
+ Value::StringOwned(s) => s.to_lowercase().contains(&search.to_lowercase()),
+ Value::Int(i) => i.to_string() == search,
+ Value::Uint(u) => u.to_string() == search,
+ Value::Float(f) => f.to_string() == search,
+ Value::Bool(b) => {
+ let bs = if *b { "true" } else { "false" };
+ bs == search.to_lowercase()
+ }
+ 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::Null => false,
+ }
+}
+
+/// Compare two values using a comparison operator.
+fn compare_values(op: CompareOp, left: &Value<'_>, right: &Value<'_>) -> 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 !ls.eq_ignore_ascii_case(rs);
+ }
+ 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
+ }
+ }
+}
+
+/// Split a string into words.
+fn split_string(s: &str) -> Vec<&str> {
+ let mut result = Vec::new();
+ let mut start = None;
+
+ for (i, c) in s.char_indices() {
+ if c.is_whitespace() {
+ if let Some(s_idx) = start {
+ result.push(&s[s_idx..i]);
+ start = None;
+ }
+ } else if is_text_start_char(c) {
+ if start.is_none() {
+ start = Some(i);
+ }
+ } else {
+ if let Some(s_idx) = start {
+ result.push(&s[s_idx..i]);
+ start = None;
+ }
+ // Single char becomes its own word
+ let end = i + c.len_utf8();
+ result.push(&s[i..end]);
+ }
+ }
+
+ if let Some(s_idx) = start {
+ result.push(&s[s_idx..]);
+ }
+
+ result
+}
+
+fn is_text_start_char(r: char) -> bool {
+ matches!(r,
+ '#'..='\'' | '*' | '/' | ';' | '?' | '@' | 'A'..='Z' | '[' | ']' | '^'..='}' | '\\'
+ ) || ('\u{00a1}'..='\u{0effff}').contains(&r)
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use crate::parse;
+
+ struct TestItem {
+ state: String,
+ priority: i64,
+ score: f64,
+ active: bool,
+ labels: Vec<String>,
+ name: String,
+ }
+
+ impl Filterable for TestItem {
+ fn field(&self, name: &str) -> Option<Value<'_>> {
+ match name {
+ "state" => Some(Value::String(&self.state)),
+ "priority" => Some(Value::Int(self.priority)),
+ "score" => Some(Value::Float(self.score)),
+ "active" => Some(Value::Bool(self.active)),
+ "labels" => Some(Value::List(
+ self.labels.iter().map(|l| Value::String(l.as_str())).collect(),
+ )),
+ "name" => Some(Value::String(&self.name)),
+ _ => None,
+ }
+ }
+
+ fn all_field_values(&self) -> Vec<Value<'_>> {
+ vec![
+ Value::String(&self.state),
+ Value::Int(self.priority),
+ Value::Float(self.score),
+ Value::Bool(self.active),
+ Value::String(&self.name),
+ ]
+ }
+ }
+
+ fn item() -> TestItem {
+ TestItem {
+ state: "open".into(),
+ priority: 5,
+ score: 9.5,
+ active: true,
+ labels: vec!["bug".into(), "urgent".into()],
+ name: "Fix crash on startup".into(),
+ }
+ }
+
+ #[test]
+ fn test_equals() {
+ let expr = parse(r#"state = "open""#).unwrap().unwrap();
+ assert!(expr.evaluate(&item()));
+
+ let expr = parse(r#"state = "closed""#).unwrap().unwrap();
+ assert!(!expr.evaluate(&item()));
+ }
+
+ #[test]
+ fn test_not_equals() {
+ let expr = parse(r#"state != "closed""#).unwrap().unwrap();
+ assert!(expr.evaluate(&item()));
+ }
+
+ #[test]
+ fn test_numeric_comparison() {
+ let expr = parse("priority > 3").unwrap().unwrap();
+ assert!(expr.evaluate(&item()));
+
+ let expr = parse("priority < 3").unwrap().unwrap();
+ assert!(!expr.evaluate(&item()));
+
+ let expr = parse("priority >= 5").unwrap().unwrap();
+ assert!(expr.evaluate(&item()));
+
+ let expr = parse("priority <= 5").unwrap().unwrap();
+ assert!(expr.evaluate(&item()));
+ }
+
+ #[test]
+ fn test_float_comparison() {
+ let expr = parse("score > 9.0").unwrap().unwrap();
+ assert!(expr.evaluate(&item()));
+ }
+
+ #[test]
+ fn test_and() {
+ let expr = parse(r#"state = "open" AND priority > 3"#).unwrap().unwrap();
+ assert!(expr.evaluate(&item()));
+
+ let expr = parse(r#"state = "closed" AND priority > 3"#)
+ .unwrap()
+ .unwrap();
+ assert!(!expr.evaluate(&item()));
+ }
+
+ #[test]
+ fn test_or() {
+ let expr = parse(r#"state = "closed" OR priority > 3"#)
+ .unwrap()
+ .unwrap();
+ assert!(expr.evaluate(&item()));
+ }
+
+ #[test]
+ fn test_negation() {
+ let expr = parse(r#"-state = "closed""#).unwrap().unwrap();
+ assert!(expr.evaluate(&item()));
+
+ let expr = parse(r#"NOT state = "open""#).unwrap().unwrap();
+ assert!(!expr.evaluate(&item()));
+ }
+
+ #[test]
+ fn test_has_on_list() {
+ let expr = parse(r#"labels : "bug""#).unwrap().unwrap();
+ assert!(expr.evaluate(&item()));
+
+ let expr = parse(r#"labels : "feature""#).unwrap().unwrap();
+ assert!(!expr.evaluate(&item()));
+ }
+
+ #[test]
+ fn test_has_on_string() {
+ let expr = parse(r#"name : "crash""#).unwrap().unwrap();
+ assert!(expr.evaluate(&item()));
+
+ let expr = parse(r#"name : "memory""#).unwrap().unwrap();
+ assert!(!expr.evaluate(&item()));
+ }
+
+ #[test]
+ fn test_boolean_field() {
+ let expr = parse("active").unwrap().unwrap();
+ assert!(expr.evaluate(&item()));
+ }
+
+ #[test]
+ fn test_regex_match() {
+ let expr = parse(r#"state =~ "^op""#).unwrap().unwrap();
+ assert!(expr.evaluate(&item()));
+
+ let expr = parse(r#"state !~ "^cl""#).unwrap().unwrap();
+ assert!(expr.evaluate(&item()));
+ }
+
+ #[test]
+ fn test_wildcard() {
+ let expr = parse(r#"state = "op*""#).unwrap().unwrap();
+ assert!(expr.evaluate(&item()));
+
+ let expr = parse(r#"state = "*en""#).unwrap().unwrap();
+ assert!(expr.evaluate(&item()));
+ }
+
+ #[test]
+ fn test_case_insensitive() {
+ let expr = parse(r#"state = "OPEN""#).unwrap().unwrap();
+ assert!(expr.evaluate(&item()));
+ }
+
+ #[test]
+ fn test_implicit_and() {
+ let expr = parse(r#"state = "open" priority > 3"#).unwrap().unwrap();
+ assert!(expr.evaluate(&item()));
+ }
+
+ #[test]
+ fn test_parenthesized() {
+ let expr = parse(r#"(state = "open" OR state = "closed") AND priority > 3"#)
+ .unwrap()
+ .unwrap();
+ assert!(expr.evaluate(&item()));
+ }
+
+ #[test]
+ fn test_has_wildcard_star() {
+ let expr = parse("priority : *").unwrap().unwrap();
+ assert!(expr.evaluate(&item()));
+ }
+
+ #[test]
+ fn test_global_restriction() {
+ let expr = parse("open").unwrap().unwrap();
+ assert!(expr.evaluate(&item()));
+
+ let expr = parse("nonexistent").unwrap().unwrap();
+ assert!(!expr.evaluate(&item()));
+ }
+
+ #[test]
+ fn test_nested_field() {
+ struct Outer {
+ inner: Inner,
+ }
+ struct Inner {
+ value: i64,
+ }
+
+ impl Filterable for Outer {
+ fn field(&self, name: &str) -> Option<Value<'_>> {
+ match name {
+ "inner" => Some(Value::Map(vec![
+ ("value", Value::Int(self.inner.value)),
+ ])),
+ _ => None,
+ }
+ }
+
+ fn field_path(&self, path: &[&str]) -> Option<Value<'_>> {
+ match path {
+ ["inner", "value"] => Some(Value::Int(self.inner.value)),
+ _ => None,
+ }
+ }
+ }
+
+ let outer = Outer {
+ inner: Inner { value: 42 },
+ };
+
+ let expr = parse("inner.value > 10").unwrap().unwrap();
+ assert!(expr.evaluate(&outer));
+ }
+}