#![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) -> Option<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;
}
let two = match (c, chars.get(i + 1).copied()) {
('=', Some('=')) => Some(Token::Eq),
('!', Some('=')) => Some(Token::Neq),
('<', Some('=')) => Some(Token::Lte),
('>', Some('=')) => Some(Token::Gte),
('&', Some('&')) => Some(Token::And),
('|', Some('|')) => Some(Token::Or),
_ => None,
};
if let Some(tok) = two {
tokens.push(tok);
i += 2;
continue;
}
let one = match c {
'+' => Some(Token::Plus),
'-' => Some(Token::Minus),
'*' => Some(Token::Mul),
'/' => Some(Token::Div),
'<' => Some(Token::Lt),
'>' => Some(Token::Gt),
'!' => Some(Token::Not),
'(' => Some(Token::LParen),
')' => Some(Token::RParen),
_ => None,
};
if let Some(tok) = one {
tokens.push(tok);
i += 1;
continue;
}
match c {
'\'' | '"' => {
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() {
return None;
}
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;
}
if ident.eq_ignore_ascii_case(crate::layer0::vocabulary::GUARD_LIT_TRUE) {
tokens.push(Token::Bool(true));
} else if ident.eq_ignore_ascii_case(crate::layer0::vocabulary::GUARD_LIT_FALSE) {
tokens.push(Token::Bool(false));
} else if ident == crate::layer0::vocabulary::GUARD_WORD_AND {
tokens.push(Token::And);
} else if ident == crate::layer0::vocabulary::GUARD_WORD_OR {
tokens.push(Token::Or);
} else if ident == crate::layer0::vocabulary::GUARD_WORD_NOT {
tokens.push(Token::Not);
} else {
tokens.push(Token::Ident(ident));
}
}
_ => return None,
}
}
Some(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_verdict(
rule: &str,
context: &Value,
) -> crate::layer1::guard_semantics::GuardVerdict {
use crate::layer1::guard_semantics::{GuardVerdict, evaluate_guard};
let trimmed = rule.trim();
if trimmed.is_empty() {
return GuardVerdict::Unmatched(rule.to_string());
}
let guard_verdict = evaluate_guard(trimmed, context);
if !matches!(guard_verdict, GuardVerdict::Unmatched(_)) {
return guard_verdict;
}
let Some(tokens) = tokenize_rule(trimmed) else {
return GuardVerdict::Unmatched(rule.to_string());
};
if tokens.is_empty() {
return GuardVerdict::Unmatched(rule.to_string());
}
if tokens.len() == 1
&& let Token::Ident(ref id) = tokens[0]
&& Self::resolve_path(id, context) == EvalVal::Null
{
return GuardVerdict::Unmatched(rule.to_string());
}
let mut pos = 0;
match Self::parse_or(&tokens, &mut pos, context) {
Ok(v) if pos == tokens.len() => {
if v.as_bool() {
GuardVerdict::Pass
} else {
GuardVerdict::Fail(trimmed.to_string())
}
}
_ => GuardVerdict::Unmatched(rule.to_string()),
}
}
pub fn evaluate(rule: &str, context: &Value) -> bool {
if rule.trim().is_empty() {
return true;
}
Self::evaluate_verdict(rule, context).is_pass()
}
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)
}