use std::borrow::Cow;
use serde_json::{Value, json};
use crate::layer0::guard_grammar::{
AUTH_POLICY_STRICT, PRIM_ADD, PRIM_CALL, PRIM_COMPARE, PRIM_DIV, PRIM_EXPLICIT_REF, PRIM_FIELD,
PRIM_FLOORDIV, PRIM_IN, PRIM_INDEX, PRIM_LIST, PRIM_LIT_BOOL, PRIM_METHOD_CONTAINS,
PRIM_METHOD_STARTSWITH, PRIM_MOD, PRIM_MUL, PRIM_NEG, PRIM_NOT_IN, PRIM_POS, PRIM_REF,
PRIM_RLCD_PROP, PRIM_SUB, RESOLVER_KIND_FIELD, RESOLVER_KIND_RLCD,
};
use crate::layer0::guard_term_eval::{EvalValue, ResolverFn, ResolverReply, evaluate_compiled_term};
use crate::layer0::interpretation_register::{
COMPARISON_EQUALITY_KINDS, COMPARISON_JOIN_PAIRS, COMPARISON_ORDERING_KINDS,
};
use crate::layer0::limits::{
SPEC_GUARD_FLOAT_TOLERANCE_RECIPROCAL, SPEC_GUARD_REL_TOLERANCE_RECIPROCAL,
};
use crate::layer0::term::{Collection, Lit, Term};
use crate::layer0::vocabulary::{
GUARD_CMP_EQ, GUARD_CMP_GE, GUARD_CMP_GT, GUARD_CMP_LE, GUARD_CMP_LT, GUARD_CMP_NE,
GUARD_FUNC_BOOL, GUARD_FUNC_FLOAT, GUARD_FUNC_INT, GUARD_FUNC_LEN, GUARD_FUNC_MAX,
GUARD_FUNC_MIN, GUARD_FUNC_SIZE, GUARD_FUNC_STR, GUARD_FUNC_SUM, GUARD_INCOMPARABLE,
GUARD_KIND_ABSENT, GUARD_LIT_FALSE_CAP, GUARD_LIT_NONE_CAP, GUARD_LIT_NULL, GUARD_LIT_TRUE_CAP,
GUARD_OUTCOME_FAIL, GUARD_OUTCOME_PASS, GUARD_OUTCOME_UNMATCHED, GUARD_UNDERSCORE,
JS_TYPE_BOOLEAN, JS_TYPE_STRING, TERM_KIND_COLLECTION, TERM_KIND_DECIMAL, TERM_KIND_INTEGER,
};
const ARITH_FNS: &[(&str, fn(f64, f64) -> f64)] = &[
(PRIM_ADD, |a, b| a + b),
(PRIM_SUB, |a, b| a - b),
(PRIM_MUL, |a, b| a * b),
(PRIM_DIV, |a, b| a / b),
(PRIM_FLOORDIV, |a, b| (a / b).floor()),
(PRIM_MOD, |a, b| a.rem_euclid(b)),
];
fn lit_to_json(lit: &Lit) -> Value {
match lit {
Lit::Null => Value::Null,
Lit::Boolean(b) => Value::Bool(*b),
Lit::Integer(i) => Value::from(*i),
Lit::Decimal(s) => s.parse::<f64>().ok().map(|f| json!(f)).unwrap_or_else(|| Value::String(s.clone())),
Lit::String(s) => Value::String(s.clone()),
Lit::Collection(Collection::List(xs)) => Value::Array(xs.iter().map(lit_to_json).collect()),
Lit::Collection(Collection::Map(m)) => {
Value::Object(m.iter().map(|(k, v)| (k.clone(), lit_to_json(v))).collect())
}
Lit::Verdict(v) => Value::Bool(v.outcome == GUARD_OUTCOME_PASS),
}
}
impl<'t, 'ctx> EvalValue<'t, 'ctx> {
#[inline]
pub fn is_absent(&self) -> bool {
matches!(self, Self::Absent)
}
#[inline]
pub fn as_json(&self) -> Option<&Value> {
match self {
Self::JsonRef(v) => Some(*v),
Self::JsonOwned(v) => Some(v),
_ => None,
}
}
#[inline]
pub fn kind_str(&self) -> &'static str {
if let Some(v) = self.as_json() {
return match v {
Value::Null => GUARD_LIT_NULL,
Value::Bool(_) => JS_TYPE_BOOLEAN,
Value::Number(n) => {
if n.is_i64() || n.is_u64() { TERM_KIND_INTEGER } else { TERM_KIND_DECIMAL }
}
Value::String(_) => JS_TYPE_STRING,
Value::Array(_) | Value::Object(_) => TERM_KIND_COLLECTION,
};
}
match self {
Self::TermLit(l) => l.kind().as_str(),
Self::Int(_) => TERM_KIND_INTEGER,
Self::Float(_) => TERM_KIND_DECIMAL,
Self::Bool(_) => JS_TYPE_BOOLEAN,
Self::Str(_) => JS_TYPE_STRING,
Self::Absent | Self::JsonRef(_) | Self::JsonOwned(_) => GUARD_KIND_ABSENT,
}
}
#[inline]
pub fn as_str(&self) -> Option<&str> {
if let Some(v) = self.as_json() {
return v.as_str();
}
match self {
Self::TermLit(Lit::String(s)) | Self::Str(s) => Some(s),
_ => None,
}
}
#[inline]
pub fn as_i64(&self) -> Option<i64> {
if let Some(v) = self.as_json() {
return v.as_i64();
}
match self {
Self::Int(i) | Self::TermLit(Lit::Integer(i)) => Some(*i),
_ => None,
}
}
#[inline]
pub fn as_bool(&self) -> Option<bool> {
if let Some(v) = self.as_json() {
return v.as_bool();
}
match self {
Self::Bool(b) | Self::TermLit(Lit::Boolean(b)) => Some(*b),
_ => None,
}
}
#[inline]
pub fn num_f64(&self) -> Option<f64> {
if let Some(v) = self.as_json() {
return v.as_f64().filter(|x| x.is_finite());
}
match self {
Self::Int(i) | Self::TermLit(Lit::Integer(i)) => Some(*i as f64),
Self::Float(f) => Some(*f).filter(|n| n.is_finite()),
Self::TermLit(Lit::Decimal(s)) => s.parse::<f64>().ok().filter(|n| n.is_finite()),
_ => None,
}
}
#[inline]
pub fn coerce_decimal_f64(&self) -> Option<f64> {
if let Some(f) = self.num_f64() {
return Some(f);
}
let s = self.as_str()?.trim();
if s.is_empty() { return None; }
s.parse::<f64>().ok().filter(|n| n.is_finite())
}
pub fn size_len(&self) -> Option<usize> {
if let Some(s) = self.as_str() {
return Some(s.chars().count());
}
if let Some(v) = self.as_json() {
return match v {
Value::Array(a) => Some(a.len()),
Value::Object(o) => Some(o.len()),
_ => None,
};
}
match self {
Self::TermLit(Lit::Collection(Collection::List(xs))) => Some(xs.len()),
Self::TermLit(Lit::Collection(Collection::Map(m))) => Some(m.len()),
_ => None,
}
}
pub fn truthy(&self) -> bool {
if let Some(b) = self.as_bool() { return b; }
if let Some(i) = self.as_i64() { return i != 0; }
if let Some(s) = self.as_str() { return !s.is_empty(); }
if let Some(v) = self.as_json() {
return match v {
Value::Null => false,
Value::Number(n) => n.as_f64().unwrap_or(0.0) != 0.0,
Value::Array(a) => !a.is_empty(),
Value::Object(o) => !o.is_empty(),
_ => false,
};
}
match self {
Self::Absent | Self::TermLit(Lit::Null) => false,
Self::Float(f) => *f != 0.0,
Self::TermLit(Lit::Decimal(s)) => s.parse::<f64>().unwrap_or(0.0) != 0.0,
Self::TermLit(Lit::Collection(Collection::List(xs))) => !xs.is_empty(),
Self::TermLit(Lit::Collection(Collection::Map(m))) => !m.is_empty(),
Self::TermLit(Lit::Verdict(v)) => v.outcome == GUARD_OUTCOME_PASS,
_ => false,
}
}
pub fn to_json(&self) -> Value {
if let Some(v) = self.as_json() {
return v.clone();
}
match self {
Self::TermLit(l) => lit_to_json(l),
Self::Int(i) => Value::from(*i),
Self::Float(f) => json!(*f),
Self::Bool(b) => Value::Bool(*b),
Self::Str(s) => Value::String(s.clone()),
Self::Absent | Self::JsonRef(_) | Self::JsonOwned(_) => Value::Null,
}
}
pub fn display_cow(&self) -> Cow<'_, str> {
if let Some(b) = self.as_bool() {
return Cow::Borrowed(if b { GUARD_LIT_TRUE_CAP } else { GUARD_LIT_FALSE_CAP });
}
if let Some(s) = self.as_str() {
return Cow::Borrowed(s);
}
if let Some(v) = self.as_json() {
return match v {
Value::Null => Cow::Borrowed(GUARD_LIT_NONE_CAP),
Value::Number(n) => Cow::Owned(n.to_string()),
other => Cow::Owned(other.to_string()),
};
}
match self {
Self::Absent | Self::TermLit(Lit::Null) => Cow::Borrowed(GUARD_LIT_NONE_CAP),
Self::TermLit(Lit::Decimal(s)) => Cow::Borrowed(s),
Self::Int(i) | Self::TermLit(Lit::Integer(i)) => Cow::Owned(i.to_string()),
Self::Float(f) => Cow::Owned(f.to_string()),
other => Cow::Owned(other.to_json().to_string()),
}
}
pub fn contains_in(&self, needle: &EvalValue<'_, '_>) -> Option<bool> {
if let Some(s) = self.as_str() {
return Some(needle.as_str().is_some_and(|sub| s.contains(sub)));
}
if let Some(v) = self.as_json() {
return match v {
Value::Array(a) => Some(a.contains(&needle.to_json())),
Value::Object(o) => Some(needle.as_str().is_some_and(|k| o.contains_key(k))),
_ => None,
};
}
match self {
Self::TermLit(Lit::Collection(Collection::List(xs))) => {
let nv = needle.to_json();
Some(xs.iter().any(|x| lit_to_json(x) == nv))
}
_ => None,
}
}
}
pub fn compare(left: &EvalValue<'_, '_>, op: &str, right: &EvalValue<'_, '_>) -> &'static str {
let is_ord = op == GUARD_CMP_LT || op == GUARD_CMP_LE || op == GUARD_CMP_GT || op == GUARD_CMP_GE;
if !is_ord && op != GUARD_CMP_EQ && op != GUARD_CMP_NE {
return GUARD_INCOMPARABLE;
}
let (lk, rk) = (left.kind_str(), right.kind_str());
let join_kind = COMPARISON_JOIN_PAIRS
.binary_search_by_key(&(lk, rk), |&(a, b, _)| (a, b))
.map(|idx| COMPARISON_JOIN_PAIRS[idx].2)
.unwrap_or(GUARD_INCOMPARABLE);
let allowed = if is_ord { COMPARISON_ORDERING_KINDS } else { COMPARISON_EQUALITY_KINDS };
if join_kind == GUARD_INCOMPARABLE || !allowed.contains(&join_kind) || left.is_absent() || right.is_absent() {
return GUARD_INCOMPARABLE;
}
if join_kind == TERM_KIND_DECIMAL {
let (Some(lf), Some(rf)) = (left.coerce_decimal_f64(), right.coerce_decimal_f64()) else {
return if op == GUARD_CMP_NE { GUARD_OUTCOME_PASS } else { GUARD_OUTCOME_FAIL };
};
let abs_tol = 1.0 / (SPEC_GUARD_FLOAT_TOLERANCE_RECIPROCAL as f64);
let rel_tol = 1.0 / (SPEC_GUARD_REL_TOLERANCE_RECIPROCAL as f64);
let close = (lf - rf).abs() <= (rel_tol * lf.abs().max(rf.abs())).max(abs_tol);
let ok = if op == GUARD_CMP_EQ { close }
else if op == GUARD_CMP_NE { !close }
else if op == GUARD_CMP_LT { lf < rf }
else if op == GUARD_CMP_LE { lf <= rf || close }
else if op == GUARD_CMP_GT { lf > rf }
else { lf >= rf || close };
return if ok { GUARD_OUTCOME_PASS } else { GUARD_OUTCOME_FAIL };
}
if join_kind == TERM_KIND_INTEGER && let (Some(lv), Some(rv)) = (left.as_i64(), right.as_i64()) {
let ok = if op == GUARD_CMP_EQ { lv == rv } else if op == GUARD_CMP_NE { lv != rv }
else if op == GUARD_CMP_LT { lv < rv } else if op == GUARD_CMP_LE { lv <= rv }
else if op == GUARD_CMP_GT { lv > rv } else { lv >= rv };
return if ok { GUARD_OUTCOME_PASS } else { GUARD_OUTCOME_FAIL };
}
if join_kind == JS_TYPE_STRING && let (Some(lv), Some(rv)) = (left.as_str(), right.as_str()) {
let ok = if op == GUARD_CMP_EQ { lv == rv } else if op == GUARD_CMP_NE { lv != rv }
else if op == GUARD_CMP_LT { lv < rv } else if op == GUARD_CMP_LE { lv <= rv }
else if op == GUARD_CMP_GT { lv > rv } else { lv >= rv };
return if ok { GUARD_OUTCOME_PASS } else { GUARD_OUTCOME_FAIL };
}
let eq = if join_kind == GUARD_LIT_NULL {
true
} else if join_kind == JS_TYPE_BOOLEAN {
left.as_bool() == right.as_bool()
} else {
left.to_json() == right.to_json()
};
let pass = if op == GUARD_CMP_EQ { eq } else { !eq };
if pass { GUARD_OUTCOME_PASS } else { GUARD_OUTCOME_FAIL }
}
pub fn eval_scalar<'t, 'ctx>(term: &'t Term, resolver: ResolverFn<'_, 'ctx>) -> Result<EvalValue<'t, 'ctx>, String> {
match term {
Term::Lit(lit) => Ok(EvalValue::TermLit(lit)),
Term::Prim(name, args) => {
if name == PRIM_LIT_BOOL && let Some(Term::Lit(Lit::Boolean(b))) = args.first() {
return Ok(EvalValue::Bool(*b));
}
if name == PRIM_REF && let Some(Term::Lit(Lit::String(k))) = args.first() {
return Ok(match resolver(RESOLVER_KIND_FIELD, k, "", &[]) {
ResolverReply::FieldRef(Some(vr)) => EvalValue::JsonRef(vr),
ResolverReply::Field(Some(v)) => EvalValue::JsonOwned(v),
_ => EvalValue::Absent,
});
}
if name == PRIM_EXPLICIT_REF && let Some(Term::Lit(lit @ Lit::String(_))) = args.get(1) {
return Ok(EvalValue::TermLit(lit));
}
if name == PRIM_RLCD_PROP
&& let (Some(Term::Lit(Lit::String(t))), Some(Term::Lit(Lit::String(p)))) = (args.first(), args.get(1))
{
return Ok(match resolver(RESOLVER_KIND_RLCD, t, p, &[]) {
ResolverReply::FieldRef(Some(vr)) => EvalValue::JsonRef(vr),
ResolverReply::Field(Some(v)) => EvalValue::JsonOwned(v),
_ => EvalValue::Absent,
});
}
if name == GUARD_FUNC_SIZE && let Some(a0) = args.first() {
let sv = eval_scalar(a0, resolver)?;
let n = if sv.is_absent() { 0 } else { sv.size_len().unwrap_or(0) } as i64;
return Ok(EvalValue::Int(n));
}
if name == GUARD_FUNC_LEN && let Some(a0) = args.first() {
let sv = eval_scalar(a0, resolver)?;
return Ok(match sv.size_len() { Some(n) => EvalValue::Int(n as i64), None => EvalValue::Absent });
}
if name == PRIM_LIST {
let mut raws = Vec::with_capacity(args.len());
for a in args {
let ev = eval_scalar(a, resolver)?;
if ev.is_absent() { return Ok(EvalValue::Absent); }
raws.push(ev.to_json());
}
return Ok(EvalValue::JsonOwned(Value::Array(raws)));
}
if name == PRIM_FIELD && let (Some(a0), Some(Term::Lit(Lit::String(attr)))) = (args.first(), args.get(1)) {
if attr.starts_with(GUARD_UNDERSCORE) { return Ok(EvalValue::Absent); }
let rv = eval_scalar(a0, resolver)?;
return Ok(match rv {
EvalValue::JsonRef(Value::Object(o)) => o.get(attr).map_or(EvalValue::Absent, EvalValue::JsonRef),
EvalValue::JsonOwned(Value::Object(mut o)) => o.remove(attr).map_or(EvalValue::Absent, EvalValue::JsonOwned),
_ => EvalValue::Absent,
});
}
if name == PRIM_INDEX && let (Some(a0), Some(a1)) = (args.first(), args.get(1)) {
let rv = eval_scalar(a0, resolver)?;
let iv = eval_scalar(a1, resolver)?;
if rv.is_absent() || iv.is_absent() { return Ok(EvalValue::Absent); }
if let Some(idx) = iv.as_i64() {
return Ok(match rv {
EvalValue::JsonRef(Value::Array(arr)) => {
let adj = if idx < 0 { arr.len() as i64 + idx } else { idx };
if adj >= 0 { arr.get(adj as usize).map_or(EvalValue::Absent, EvalValue::JsonRef) } else { EvalValue::Absent }
}
EvalValue::JsonOwned(Value::Array(arr)) => {
let adj = if idx < 0 { arr.len() as i64 + idx } else { idx };
if adj >= 0 { arr.get(adj as usize).cloned().map_or(EvalValue::Absent, EvalValue::JsonOwned) } else { EvalValue::Absent }
}
_ => EvalValue::Absent,
});
}
if let Some(k) = iv.as_str() {
return Ok(match rv {
EvalValue::JsonRef(Value::Object(obj)) => obj.get(k).map_or(EvalValue::Absent, EvalValue::JsonRef),
EvalValue::JsonOwned(Value::Object(mut obj)) => obj.remove(k).map_or(EvalValue::Absent, EvalValue::JsonOwned),
_ => EvalValue::Absent,
});
}
return Ok(EvalValue::Absent);
}
if (name == PRIM_NEG || name == PRIM_POS) && let Some(a0) = args.first() {
let ov = eval_scalar(a0, resolver)?;
if ov.is_absent() || ov.as_bool().is_some() { return Ok(EvalValue::Absent); }
if let Some(i) = ov.as_i64() { return Ok(EvalValue::Int(if name == PRIM_NEG { -i } else { i })); }
if let Some(f) = ov.num_f64() { return Ok(EvalValue::Float(if name == PRIM_NEG { -f } else { f })); }
return Ok(EvalValue::Absent);
}
if let Some(&(_, arith_fn)) = ARITH_FNS.iter().find(|&&(k, _)| k == name.as_str())
&& let (Some(a0), Some(a1)) = (args.first(), args.get(1))
{
let lv = eval_scalar(a0, resolver)?;
let rv = eval_scalar(a1, resolver)?;
if lv.is_absent() || rv.is_absent() { return Ok(EvalValue::Absent); }
if name == PRIM_ADD && let (Some(ls), Some(rs)) = (lv.as_str(), rv.as_str()) {
let mut out = String::from(ls);
out.push_str(rs);
return Ok(EvalValue::Str(out));
}
if lv.as_bool().is_some() || rv.as_bool().is_some() { return Ok(EvalValue::Absent); }
let (Some(lf), Some(rf)) = (lv.num_f64(), rv.num_f64()) else { return Ok(EvalValue::Absent); };
if (name == PRIM_DIV || name == PRIM_FLOORDIV || name == PRIM_MOD) && rf == 0.0 { return Ok(EvalValue::Absent); }
if name != PRIM_DIV && let (Some(li), Some(ri)) = (lv.as_i64(), rv.as_i64()) {
let iv = if name == PRIM_ADD { li + ri } else if name == PRIM_SUB { li - ri }
else if name == PRIM_MUL { li * ri } else if name == PRIM_FLOORDIV { li.div_euclid(ri) } else { li.rem_euclid(ri) };
return Ok(EvalValue::Int(iv));
}
return Ok(EvalValue::Float(arith_fn(lf, rf)));
}
if name == PRIM_CALL && let (Some(Term::Lit(Lit::String(fn_n))), Some(Term::Prim(_, call_args))) = (args.first(), args.get(1)) {
let mut vs = Vec::with_capacity(call_args.len());
for a in call_args {
let ev = eval_scalar(a, resolver)?;
if ev.is_absent() { return Ok(EvalValue::Absent); }
vs.push(ev);
}
if vs.is_empty() { return Ok(EvalValue::Absent); }
let nums = |items: &[EvalValue<'_, '_>]| -> Option<Vec<f64>> {
if items.len() == 1 && let Some(arr) = items[0].as_json().and_then(Value::as_array) {
return arr.iter().map(|x| x.as_f64()).collect();
}
items.iter().map(EvalValue::num_f64).collect()
};
if fn_n == GUARD_FUNC_MIN { return Ok(nums(&vs).and_then(|xs| xs.into_iter().reduce(f64::min)).map_or(EvalValue::Absent, EvalValue::Float)); }
if fn_n == GUARD_FUNC_MAX { return Ok(nums(&vs).and_then(|xs| xs.into_iter().reduce(f64::max)).map_or(EvalValue::Absent, EvalValue::Float)); }
if fn_n == GUARD_FUNC_SUM { return Ok(nums(&vs).map_or(EvalValue::Absent, |xs| EvalValue::Float(xs.into_iter().sum::<f64>()))); }
if fn_n == GUARD_FUNC_STR { return Ok(EvalValue::Str(vs[0].as_str().map(str::to_string).unwrap_or_else(|| vs[0].to_json().to_string()))); }
if fn_n == GUARD_FUNC_INT {
let iv = vs[0].as_i64().or_else(|| vs[0].num_f64().map(|f| f as i64)).or_else(|| vs[0].as_str()?.parse().ok());
return Ok(iv.map_or(EvalValue::Absent, EvalValue::Int));
}
if fn_n == GUARD_FUNC_FLOAT {
let fv = vs[0].num_f64().or_else(|| vs[0].as_str()?.parse().ok());
return Ok(fv.map_or(EvalValue::Absent, EvalValue::Float));
}
if fn_n == GUARD_FUNC_BOOL { return Ok(EvalValue::Bool(vs[0].truthy())); }
return Ok(EvalValue::Absent);
}
if name == PRIM_METHOD_CONTAINS || name == PRIM_METHOD_STARTSWITH || name == PRIM_IN || name == PRIM_NOT_IN || name == PRIM_COMPARE {
let v = evaluate_compiled_term(term, resolver, GUARD_OUTCOME_UNMATCHED, AUTH_POLICY_STRICT)?;
if v.outcome == GUARD_OUTCOME_UNMATCHED { return Ok(EvalValue::Absent); }
return Ok(EvalValue::Bool(v.outcome == GUARD_OUTCOME_PASS));
}
Ok(EvalValue::Absent)
}
_ => Ok(EvalValue::Absent),
}
}