#![allow(unused_imports)]
use super::*;
#[derive(Debug, Clone, PartialEq)]
pub(super) enum Token {
Ident(String),
Num(f64),
Str(String),
Bool(bool),
Plus,
Minus,
Mul,
Div,
Eq,
Neq,
Lt,
Lte,
Gt,
Gte,
And,
Or,
Not,
LParen,
RParen,
}
pub(super) fn tokenize_rule(expr: &str) -> Vec<Token> {
let mut tokens = Vec::new();
let chars: Vec<char> = expr.chars().collect();
let mut i = 0;
while i < chars.len() {
let c = chars[i];
if c.is_whitespace() {
i += 1;
continue;
}
if c == '=' && i + 1 < chars.len() && chars[i + 1] == '=' {
tokens.push(Token::Eq);
i += 2;
continue;
}
if c == '!' && i + 1 < chars.len() && chars[i + 1] == '=' {
tokens.push(Token::Neq);
i += 2;
continue;
}
if c == '<' && i + 1 < chars.len() && chars[i + 1] == '=' {
tokens.push(Token::Lte);
i += 2;
continue;
}
if c == '>' && i + 1 < chars.len() && chars[i + 1] == '=' {
tokens.push(Token::Gte);
i += 2;
continue;
}
if c == '&' && i + 1 < chars.len() && chars[i + 1] == '&' {
tokens.push(Token::And);
i += 2;
continue;
}
if c == '|' && i + 1 < chars.len() && chars[i + 1] == '|' {
tokens.push(Token::Or);
i += 2;
continue;
}
match c {
'+' => { tokens.push(Token::Plus); i += 1; }
'-' => { tokens.push(Token::Minus); i += 1; }
'*' => { tokens.push(Token::Mul); i += 1; }
'/' => { tokens.push(Token::Div); i += 1; }
'<' => { tokens.push(Token::Lt); i += 1; }
'>' => { tokens.push(Token::Gt); i += 1; }
'!' => { tokens.push(Token::Not); i += 1; }
'(' => { tokens.push(Token::LParen); i += 1; }
')' => { tokens.push(Token::RParen); i += 1; }
'\'' | '"' => {
let quote = c;
i += 1;
let mut s = String::new();
while i < chars.len() && chars[i] != quote {
s.push(chars[i]);
i += 1;
}
if i < chars.len() { i += 1; }
tokens.push(Token::Str(s));
}
_ if c.is_ascii_digit() => {
let mut num_str = String::new();
while i < chars.len() && (chars[i].is_ascii_digit() || chars[i] == '.') {
num_str.push(chars[i]);
i += 1;
}
let n: f64 = num_str.parse().unwrap_or(0.0);
tokens.push(Token::Num(n));
}
_ if c.is_alphabetic() || c == '_' => {
let mut ident = String::new();
while i < chars.len() && (chars[i].is_alphanumeric() || chars[i] == '_' || chars[i] == '.') {
ident.push(chars[i]);
i += 1;
}
match ident.as_str() {
"true" | "True" => tokens.push(Token::Bool(true)),
"false" | "False" => tokens.push(Token::Bool(false)),
"and" => tokens.push(Token::And),
"or" => tokens.push(Token::Or),
"not" => tokens.push(Token::Not),
_ => tokens.push(Token::Ident(ident)),
}
}
_ => { i += 1; }
}
}
tokens
}
#[derive(Debug, Clone, PartialEq)]
pub(super) enum EvalVal {
Num(f64),
Str(String),
Bool(bool),
Null,
}
impl EvalVal {
pub(super) fn as_bool(&self) -> bool {
match self {
EvalVal::Bool(b) => *b,
EvalVal::Num(n) => *n != 0.0,
EvalVal::Str(s) => !s.is_empty(),
EvalVal::Null => false,
}
}
}
pub struct SafeRuleEvaluator;
impl SafeRuleEvaluator {
pub fn evaluate(rule: &str, context: &Value) -> bool {
let tokens = tokenize_rule(rule);
if tokens.is_empty() {
return true;
}
let mut pos = 0;
match Self::parse_or(&tokens, &mut pos, context) {
Ok(v) => v.as_bool(),
Err(_) => false,
}
}
pub(super) fn resolve_path(path: &str, context: &Value) -> EvalVal {
let parts: Vec<&str> = path.split('.').collect();
let mut curr = context;
for part in parts {
match curr {
Value::Object(map) => {
if let Some(val) = map.get(part) {
curr = val;
} else {
return EvalVal::Null;
}
}
_ => return EvalVal::Null,
}
}
match curr {
Value::Number(n) => EvalVal::Num(n.as_f64().unwrap_or(0.0)),
Value::String(s) => EvalVal::Str(s.clone()),
Value::Bool(b) => EvalVal::Bool(*b),
Value::Null => EvalVal::Null,
Value::Array(a) => EvalVal::Num(a.len() as f64),
Value::Object(o) => EvalVal::Num(o.len() as f64),
}
}
pub(super) fn parse_or(tokens: &[Token], pos: &mut usize, ctx: &Value) -> Result<EvalVal, String> {
let mut left = Self::parse_and(tokens, pos, ctx)?;
while *pos < tokens.len() && tokens[*pos] == Token::Or {
*pos += 1;
let right = Self::parse_and(tokens, pos, ctx)?;
left = EvalVal::Bool(left.as_bool() || right.as_bool());
}
Ok(left)
}
pub(super) fn parse_and(tokens: &[Token], pos: &mut usize, ctx: &Value) -> Result<EvalVal, String> {
let mut left = Self::parse_comparison(tokens, pos, ctx)?;
while *pos < tokens.len() && tokens[*pos] == Token::And {
*pos += 1;
let right = Self::parse_comparison(tokens, pos, ctx)?;
left = EvalVal::Bool(left.as_bool() && right.as_bool());
}
Ok(left)
}
pub(super) fn parse_comparison(tokens: &[Token], pos: &mut usize, ctx: &Value) -> Result<EvalVal, String> {
let left = Self::parse_additive(tokens, pos, ctx)?;
if *pos < tokens.len() {
let op = tokens[*pos].clone();
match op {
Token::Eq | Token::Neq | Token::Lt | Token::Lte | Token::Gt | Token::Gte => {
*pos += 1;
let right = Self::parse_additive(tokens, pos, ctx)?;
let res = match (left, right) {
(EvalVal::Num(l), EvalVal::Num(r)) => match op {
Token::Eq => (l - r).abs() < 1e-9,
Token::Neq => (l - r).abs() >= 1e-9,
Token::Lt => l < r,
Token::Lte => l <= r,
Token::Gt => l > r,
Token::Gte => l >= r,
_ => false,
},
(EvalVal::Str(l), EvalVal::Str(r)) => match op {
Token::Eq => l == r,
Token::Neq => l != r,
Token::Lt => l < r,
Token::Lte => l <= r,
Token::Gt => l > r,
Token::Gte => l >= r,
_ => false,
},
(EvalVal::Bool(l), EvalVal::Bool(r)) => match op {
Token::Eq => l == r,
Token::Neq => l != r,
_ => false,
},
(EvalVal::Num(l), EvalVal::Null) | (EvalVal::Null, EvalVal::Num(l)) => match op {
Token::Eq => l == 0.0,
Token::Neq => l != 0.0,
Token::Lte => l <= 0.0,
Token::Lt => l < 0.0,
Token::Gte => l >= 0.0,
Token::Gt => l > 0.0,
_ => false,
},
_ => match op {
Token::Eq => false,
Token::Neq => true,
_ => false,
},
};
return Ok(EvalVal::Bool(res));
}
_ => {}
}
}
Ok(left)
}
pub(super) fn parse_additive(tokens: &[Token], pos: &mut usize, ctx: &Value) -> Result<EvalVal, String> {
let mut left = Self::parse_multiplicative(tokens, pos, ctx)?;
while *pos < tokens.len() {
let op = tokens[*pos].clone();
if op == Token::Plus || op == Token::Minus {
*pos += 1;
let right = Self::parse_multiplicative(tokens, pos, ctx)?;
match (left, right) {
(EvalVal::Num(l), EvalVal::Num(r)) => {
left = EvalVal::Num(if op == Token::Plus { l + r } else { l - r });
}
(EvalVal::Str(l), EvalVal::Str(r)) => {
left = EvalVal::Str(format!("{}{}", l, r));
}
_ => return Err("Type mismatch in additive op".to_string()),
}
} else {
break;
}
}
Ok(left)
}
pub(super) fn parse_multiplicative(tokens: &[Token], pos: &mut usize, ctx: &Value) -> Result<EvalVal, String> {
let mut left = Self::parse_unary(tokens, pos, ctx)?;
while *pos < tokens.len() {
let op = tokens[*pos].clone();
if op == Token::Mul || op == Token::Div {
*pos += 1;
let right = Self::parse_unary(tokens, pos, ctx)?;
match (left, right) {
(EvalVal::Num(l), EvalVal::Num(r)) => {
left = EvalVal::Num(if op == Token::Mul { l * r } else { l / r });
}
_ => return Err("Type mismatch in multiplicative op".to_string()),
}
} else {
break;
}
}
Ok(left)
}
pub(super) fn parse_unary(tokens: &[Token], pos: &mut usize, ctx: &Value) -> Result<EvalVal, String> {
if *pos < tokens.len() {
if tokens[*pos] == Token::Not {
*pos += 1;
let val = Self::parse_unary(tokens, pos, ctx)?;
return Ok(EvalVal::Bool(!val.as_bool()));
}
if tokens[*pos] == Token::Minus {
*pos += 1;
let val = Self::parse_unary(tokens, pos, ctx)?;
if let EvalVal::Num(n) = val {
return Ok(EvalVal::Num(-n));
}
}
}
Self::parse_primary(tokens, pos, ctx)
}
pub(super) fn parse_primary(tokens: &[Token], pos: &mut usize, ctx: &Value) -> Result<EvalVal, String> {
if *pos >= tokens.len() {
return Err("Unexpected end of expression".to_string());
}
let tok = &tokens[*pos];
*pos += 1;
match tok {
Token::Num(n) => Ok(EvalVal::Num(*n)),
Token::Str(s) => Ok(EvalVal::Str(s.clone())),
Token::Bool(b) => Ok(EvalVal::Bool(*b)),
Token::Ident(id) => Ok(Self::resolve_path(id, ctx)),
Token::LParen => {
let val = Self::parse_or(tokens, pos, ctx)?;
if *pos < tokens.len() && tokens[*pos] == Token::RParen {
*pos += 1;
Ok(val)
} else {
Err("Missing closing parenthesis".to_string())
}
}
_ => Err(format!("Unexpected token: {:?}", tok)),
}
}
}
pub fn build_item_context(payload: &str) -> Value {
let mut ctx = serde_json::Map::new();
ctx.insert("size_bytes".to_string(), json!(payload.len()));
let non_empty_lines: Vec<&str> = payload.lines().filter(|l| !l.trim().is_empty()).collect();
ctx.insert("line_count".to_string(), json!(non_empty_lines.len()));
if let Some(first_line) = non_empty_lines.first()
&& first_line.contains(',') {
let cols: Vec<String> = first_line.split(',').map(|s| s.trim().to_string()).collect();
ctx.insert("column_count".to_string(), json!(cols.len()));
ctx.insert("columns".to_string(), json!(cols));
let row_count = if non_empty_lines.len() > 1 { non_empty_lines.len() - 1 } else { 0 };
ctx.insert("row_count".to_string(), json!(row_count));
}
if let Ok(Value::Object(obj)) = serde_json::from_str::<Value>(payload) {
ctx.insert("key_count".to_string(), json!(obj.len()));
let keys: Vec<String> = obj.keys().cloned().collect();
ctx.insert("keys".to_string(), json!(keys));
for (k, v) in obj {
ctx.insert(k, v);
}
} else if let Ok(Value::Array(arr)) = serde_json::from_str::<Value>(payload) {
ctx.insert("item_count".to_string(), json!(arr.len()));
ctx.insert("row_count".to_string(), json!(arr.len()));
}
Value::Object(ctx)
}