use std::borrow::Cow;
use std::rc::Rc;
use serde_json::Value;
use crate::layer0::guard_grammar::{
ARITY_METHOD_CALL, AUTH_POLICY_LEGACY_DID, DIAG_NEGATED_GUARD_PASSED, GRAMMAR_VERSION_DIGEST,
IDX_ARG_2, IDX_ARG_3, IDX_ARG_4, IDX_ARG_5, PRIM_ADD, PRIM_AND, PRIM_CALL, PRIM_COMPARE,
PRIM_DIV, PRIM_FLOORDIV, PRIM_GATE, PRIM_GATE_CALL, PRIM_IN, PRIM_LIT_BOOL,
PRIM_METHOD_CONTAINS, PRIM_METHOD_STARTSWITH, PRIM_MOD, PRIM_MUL, PRIM_NEG, PRIM_NOT,
PRIM_NOT_IN, PRIM_OR, PRIM_POS, PRIM_REF, PRIM_RLCD_PROP, PRIM_SUB, PRIM_TRUTHY,
PRIM_UNKNOWN_ATOM, RESOLVER_KIND_GATE, SEP_NUL, VERDICT_CHAIN, VERDICT_NOT,
};
use crate::layer0::guard_term_parser::compile_guard_term;
pub use crate::layer0::guard_term_scalar::{compare, eval_scalar};
use crate::layer0::hash::compute_blake3;
use crate::layer0::interpretation_register::{
PH_ACTUAL, PH_DETAIL, PH_EXPECTED, PH_EXPR, PH_FIELD, PH_LEFT_EXPR, PH_OP, PH_RIGHT_EXPR,
PH_TARGET, REGISTER_ATOM_ROWS, REGISTER_VERSION_DIGEST, ROW_DIAG_ABSENT, ROW_DIAG_FAIL,
ROW_DIAG_UNMATCHED, ROW_RA_DIAG_ABSENT, ROW_RA_DIAG_FAIL, ROW_RUNTIMES, ROW_VERDICT_ABSENT,
ROW_VERDICT_FALSE, ROW_VERDICT_TRUE, RUNTIME_RUST,
};
use crate::layer0::term::{render, Lit, ParseFailure, Term};
use crate::layer0::vocabulary::{
GATE_AUTHORIZED, GUARD_FUNC_SIZE, GUARD_KIND_ABSENT, GUARD_LIT_FALSE, GUARD_LIT_NONE_CAP,
GUARD_LIT_TRUE, GUARD_OP_NOT, GUARD_OUTCOME_FAIL, GUARD_OUTCOME_PASS, GUARD_OUTCOME_UNMATCHED,
GUARD_PREFIX_EXISTS, GUARD_PREFIX_TYPE, GUARD_WORD_IN, GUARD_WORD_NOT, TERM_SYNTAX_MAP_OPEN,
TERM_SYNTAX_SPACE,
};
#[derive(Clone, Debug)]
pub enum EvalValue<'t, 'ctx> {
TermLit(&'t Lit),
JsonRef(&'ctx Value),
Int(i64),
Float(f64),
Bool(bool),
Str(String),
JsonOwned(Value),
Absent,
}
#[derive(Clone, Debug)]
pub struct FastVerdict<'a> {
pub outcome: &'static str,
pub reason: Cow<'a, str>,
pub invariant_code: Cow<'a, str>,
}
pub enum ResolverReply<'ctx> {
FieldRef(Option<&'ctx Value>),
Field(Option<Value>),
Gate(&'static str, String),
GateErr(String),
Exists(bool),
PayloadKind(bool, Option<String>),
}
pub type ResolverFn<'a, 'ctx> = &'a mut dyn FnMut(&str, &str, &str, &[String]) -> ResolverReply<'ctx>;
pub fn compile_cache_key(expression: &str, profile: &str) -> String {
let payload = [REGISTER_VERSION_DIGEST, SEP_NUL, GRAMMAR_VERSION_DIGEST, SEP_NUL, profile, SEP_NUL, expression].concat();
compute_blake3(payload.as_bytes())
}
pub fn get_compiled_guard(expression: &str, profile: &str) -> Result<Rc<Term>, ParseFailure> {
compile_guard_term(expression, profile).map(Rc::new)
}
#[inline]
pub fn find_atom_row(key: &str) -> Option<&'static [&'static str]> {
REGISTER_ATOM_ROWS.binary_search_by_key(&key, |&(k, _)| k).ok().map(|i| REGISTER_ATOM_ROWS[i].1)
}
pub fn fmt_diag<'a>(template: &'static str, pairs: &[(&str, &str)]) -> Cow<'a, str> {
let open_ch = TERM_SYNTAX_MAP_OPEN.chars().next().unwrap();
if !template.contains(open_ch) {
return Cow::Borrowed(template);
}
let mut out = String::with_capacity(template.len());
let mut rest = template;
while let Some(open) = rest.find(open_ch) {
out.push_str(&rest[..open]);
let after = &rest[open..];
if let Some(&(ph, val)) = pairs.iter().find(|&&(ph, _)| after.starts_with(ph)) {
out.push_str(val);
rest = &after[ph.len()..];
} else {
out.push_str(&after[..1]);
rest = &after[1..];
}
}
out.push_str(rest);
Cow::Owned(out)
}
#[inline]
fn intern_outcome(s: &str) -> &'static str {
if s == GUARD_OUTCOME_PASS { GUARD_OUTCOME_PASS }
else if s == GUARD_OUTCOME_FAIL { GUARD_OUTCOME_FAIL }
else { GUARD_OUTCOME_UNMATCHED }
}
#[inline]
fn verdict_rank(outcome: &str) -> usize {
if outcome == GUARD_OUTCOME_FAIL { 0 } else if outcome == GUARD_OUTCOME_PASS { IDX_ARG_2 } else { 1 }
}
#[inline]
fn pass_verdict<'a>() -> FastVerdict<'a> {
FastVerdict { outcome: GUARD_OUTCOME_PASS, reason: Cow::Borrowed(""), invariant_code: Cow::Borrowed("") }
}
#[inline]
fn leaf_verdict<'a>(outcome: &str, reason: Cow<'a, str>, code: Cow<'a, str>, unmatched_leaf: &str) -> FastVerdict<'a> {
let out = intern_outcome(outcome);
if out == GUARD_OUTCOME_PASS || (out == GUARD_OUTCOME_UNMATCHED && unmatched_leaf == GUARD_OUTCOME_PASS) {
return pass_verdict();
}
FastVerdict { outcome: out, reason, invariant_code: code }
}
pub fn verdict_meet<'t, F: FnOnce() -> Result<FastVerdict<'t>, String>>(left: FastVerdict<'t>, eval_right: F) -> Result<FastVerdict<'t>, String> {
if left.outcome == GUARD_OUTCOME_FAIL { return Ok(left); }
let right = eval_right()?;
let target = VERDICT_CHAIN[verdict_rank(left.outcome).min(verdict_rank(right.outcome))];
Ok(if left.outcome == target { left } else { right })
}
pub fn verdict_join<'t, F: FnOnce() -> Result<FastVerdict<'t>, String>>(left: FastVerdict<'t>, eval_right: F) -> Result<FastVerdict<'t>, String> {
if left.outcome == GUARD_OUTCOME_PASS { return Ok(left); }
let right = eval_right()?;
let target = VERDICT_CHAIN[verdict_rank(left.outcome).max(verdict_rank(right.outcome))];
Ok(if left.outcome == target { left } else { right })
}
pub fn verdict_not<'t>(inner: FastVerdict<'t>, label: &'t str) -> FastVerdict<'t> {
let target = VERDICT_NOT.iter().find(|&&(k, _)| k == inner.outcome).map(|&(_, v)| v).unwrap_or(GUARD_OUTCOME_UNMATCHED);
if target == GUARD_OUTCOME_PASS {
pass_verdict()
} else if target == GUARD_OUTCOME_FAIL {
FastVerdict { outcome: GUARD_OUTCOME_FAIL, reason: Cow::Owned([DIAG_NEGATED_GUARD_PASSED, label].concat()), invariant_code: Cow::Owned([GUARD_OP_NOT, label].concat()) }
} else {
inner
}
}
pub fn evaluate_compiled_term<'t, 'ctx>(
term: &'t Term,
resolver: ResolverFn<'_, 'ctx>,
unmatched_leaf: &str,
auth_policy: &str,
) -> Result<FastVerdict<'t>, String> {
if let Term::Prim(name, args) = term {
if name == PRIM_AND {
let lv = evaluate_compiled_term(&args[0], resolver, unmatched_leaf, auth_policy)?;
return verdict_meet(lv, || evaluate_compiled_term(&args[1], resolver, unmatched_leaf, auth_policy));
}
if name == PRIM_OR {
let lv = evaluate_compiled_term(&args[0], resolver, unmatched_leaf, auth_policy)?;
return verdict_join(lv, || evaluate_compiled_term(&args[1], resolver, unmatched_leaf, auth_policy));
}
if name == PRIM_NOT && let Some(Term::Lit(Lit::String(lbl))) = args.get(1) {
let iv = evaluate_compiled_term(&args[0], resolver, unmatched_leaf, auth_policy)?;
return Ok(verdict_not(iv, lbl));
}
if name == PRIM_LIT_BOOL && let (Some(Term::Lit(Lit::Boolean(b))), Some(Term::Lit(Lit::String(raw_tok)))) = (args.first(), args.get(1)) {
if *b { return Ok(pass_verdict()); }
let row = find_atom_row(raw_tok).or_else(|| find_atom_row(GUARD_LIT_FALSE)).unwrap();
let _ = GUARD_LIT_TRUE;
return Ok(leaf_verdict(row[ROW_VERDICT_FALSE], fmt_diag(row[ROW_DIAG_FAIL], &[(PH_EXPR, raw_tok)]), Cow::Borrowed(raw_tok), unmatched_leaf));
}
if name == PRIM_UNKNOWN_ATOM && let Some(Term::Lit(Lit::String(raw_expr))) = args.first() {
let row = find_atom_row(PRIM_UNKNOWN_ATOM).unwrap();
return Ok(leaf_verdict(row[ROW_VERDICT_ABSENT], fmt_diag(row[ROW_DIAG_UNMATCHED], &[(PH_EXPR, raw_expr)]), Cow::Borrowed(raw_expr), unmatched_leaf));
}
if (name == PRIM_GATE || name == PRIM_GATE_CALL) && let Some(Term::Lit(Lit::String(gate_key))) = args.first() {
let span = args.last().and_then(|t| if let Term::Lit(Lit::String(s)) = t { Some(s.as_str()) } else { None }).unwrap_or(gate_key);
let mut call_strs = Vec::new();
if name == PRIM_GATE_CALL && let Some(Term::Prim(_, raw_args)) = args.get(1) {
for a in raw_args {
let ev = eval_scalar(a, resolver)?;
if !ev.is_absent() {
call_strs.push(ev.display_cow().into_owned());
} else if let Term::Prim(rn, ra) = a && rn == PRIM_REF && let Some(Term::Lit(Lit::String(rs))) = ra.first() {
call_strs.push([SEP_NUL, rs].concat());
}
}
}
let Some(row) = find_atom_row(gate_key).filter(|r| r[ROW_RUNTIMES].contains(RUNTIME_RUST)) else {
let u_row = find_atom_row(PRIM_UNKNOWN_ATOM).unwrap();
return Ok(leaf_verdict(GUARD_OUTCOME_UNMATCHED, fmt_diag(u_row[ROW_DIAG_UNMATCHED], &[(PH_EXPR, span)]), Cow::Borrowed(span), unmatched_leaf));
};
return match resolver(RESOLVER_KIND_GATE, gate_key, auth_policy, &call_strs) {
ResolverReply::GateErr(err) => Err(err),
ResolverReply::Gate(status, detail) => {
let is_ra = auth_policy == AUTH_POLICY_LEGACY_DID;
if status == GUARD_OUTCOME_PASS {
Ok(leaf_verdict(row[ROW_VERDICT_TRUE], Cow::Borrowed(""), Cow::Borrowed(""), unmatched_leaf))
} else if status == GUARD_KIND_ABSENT {
let msg = if is_ra && !row[ROW_RA_DIAG_ABSENT].is_empty() { Cow::Borrowed(row[ROW_RA_DIAG_ABSENT]) } else { fmt_diag(row[ROW_DIAG_ABSENT], &[(PH_EXPR, span)]) };
Ok(leaf_verdict(row[ROW_VERDICT_ABSENT], msg, Cow::Borrowed(span), unmatched_leaf))
} else if status == GUARD_OUTCOME_UNMATCHED {
let msg = fmt_diag(if row[ROW_DIAG_UNMATCHED].is_empty() { row[ROW_DIAG_ABSENT] } else { row[ROW_DIAG_UNMATCHED] }, &[(PH_EXPR, span)]);
Ok(if gate_key == GATE_AUTHORIZED {
FastVerdict { outcome: GUARD_OUTCOME_UNMATCHED, reason: msg, invariant_code: Cow::Borrowed(span) }
} else {
leaf_verdict(GUARD_OUTCOME_UNMATCHED, msg, Cow::Borrowed(span), unmatched_leaf)
})
} else {
let msg = if is_ra && !row[ROW_RA_DIAG_FAIL].is_empty() { Cow::Borrowed(row[ROW_RA_DIAG_FAIL]) } else { fmt_diag(row[ROW_DIAG_FAIL], &[(PH_EXPR, span), (PH_DETAIL, &detail)]) };
Ok(leaf_verdict(row[ROW_VERDICT_FALSE], msg, Cow::Borrowed(span), unmatched_leaf))
}
}
_ => Ok(leaf_verdict(GUARD_OUTCOME_UNMATCHED, Cow::Borrowed(""), Cow::Borrowed(span), unmatched_leaf)),
};
}
if (name == GUARD_PREFIX_EXISTS || name == GUARD_PREFIX_TYPE)
&& let (Some(Term::Lit(Lit::String(arg_s))), Some(Term::Lit(Lit::String(span)))) = (args.first(), args.get(1))
{
let row = find_atom_row(name).unwrap();
return match resolver(name, arg_s, "", &[]) {
ResolverReply::Exists(true) | ResolverReply::PayloadKind(true, _) => Ok(leaf_verdict(row[ROW_VERDICT_TRUE], Cow::Borrowed(""), Cow::Borrowed(""), unmatched_leaf)),
ResolverReply::PayloadKind(false, act) => {
let act_s = act.as_deref().unwrap_or(GUARD_LIT_NONE_CAP);
Ok(leaf_verdict(row[ROW_VERDICT_FALSE], fmt_diag(row[ROW_DIAG_FAIL], &[(PH_FIELD, arg_s), (PH_EXPECTED, arg_s), (PH_ACTUAL, act_s), (PH_EXPR, span)]), Cow::Borrowed(span), unmatched_leaf))
}
_ => Ok(leaf_verdict(row[ROW_VERDICT_FALSE], fmt_diag(row[ROW_DIAG_FAIL], &[(PH_FIELD, arg_s), (PH_EXPR, span)]), Cow::Borrowed(span), unmatched_leaf)),
};
}
if name == PRIM_COMPARE
&& let (Some(Term::Lit(Lit::String(op_s))), Some(a_rhs), Some(Term::Lit(Lit::String(l_raw))), Some(Term::Lit(Lit::String(r_raw))), Some(Term::Lit(Lit::String(span)))) =
(args.get(1), args.get(IDX_ARG_2), args.get(IDX_ARG_3), args.get(IDX_ARG_4), args.get(IDX_ARG_5))
{
let lv = eval_scalar(&args[0], resolver)?;
let rv = eval_scalar(a_rhs, resolver)?;
let is_arith = |t: &Term| matches!(t, Term::Prim(n, _) if n == PRIM_ADD || n == PRIM_SUB || n == PRIM_MUL || n == PRIM_DIV || n == PRIM_FLOORDIV || n == PRIM_MOD || n == PRIM_NEG || n == PRIM_POS);
if (is_arith(&args[0]) && lv.is_absent()) || (is_arith(a_rhs) && rv.is_absent()) {
let u_row = find_atom_row(PRIM_UNKNOWN_ATOM).unwrap();
return Ok(leaf_verdict(GUARD_OUTCOME_UNMATCHED, fmt_diag(u_row[ROW_DIAG_UNMATCHED], &[(PH_EXPR, span)]), Cow::Borrowed(span), unmatched_leaf));
}
if compare(&lv, op_s, &rv) == GUARD_OUTCOME_PASS {
return Ok(pass_verdict());
}
let (ld, rd) = (lv.display_cow(), rv.display_cow());
if let Term::Prim(sn, sa) = &args[0] && sn == GUARD_FUNC_SIZE && let Some(Term::Lit(Lit::String(tgt))) = sa.get(1) {
let s_row = find_atom_row(GUARD_FUNC_SIZE).unwrap();
return Ok(leaf_verdict(GUARD_OUTCOME_FAIL, fmt_diag(s_row[ROW_DIAG_FAIL], &[(PH_TARGET, tgt), (PH_ACTUAL, &ld), (PH_OP, op_s), (PH_EXPECTED, &rd)]), Cow::Borrowed(span), unmatched_leaf));
}
let c_row = find_atom_row(PRIM_COMPARE).unwrap();
return Ok(leaf_verdict(GUARD_OUTCOME_FAIL, fmt_diag(c_row[ROW_DIAG_FAIL], &[(PH_LEFT_EXPR, l_raw), (PH_ACTUAL, &ld), (PH_OP, op_s), (PH_RIGHT_EXPR, r_raw)]), Cow::Borrowed(span), unmatched_leaf));
}
if (name == PRIM_IN || name == PRIM_NOT_IN) && let Some(Term::Lit(Lit::String(span))) = args.get(IDX_ARG_2) {
let lv = eval_scalar(&args[0], resolver)?;
let rv = eval_scalar(&args[1], resolver)?;
let row = if name == PRIM_IN { find_atom_row(GUARD_WORD_IN).unwrap() } else { find_atom_row(&[GUARD_WORD_NOT, TERM_SYNTAX_SPACE, GUARD_WORD_IN].concat()).unwrap() };
if lv.is_absent() || rv.is_absent() {
return Ok(leaf_verdict(row[ROW_VERDICT_ABSENT], fmt_diag(row[ROW_DIAG_FAIL], &[(PH_EXPR, span)]), Cow::Borrowed(span), unmatched_leaf));
}
let Some(has) = rv.contains_in(&lv) else {
return Ok(leaf_verdict(row[ROW_VERDICT_ABSENT], fmt_diag(row[ROW_DIAG_FAIL], &[(PH_EXPR, span)]), Cow::Borrowed(span), unmatched_leaf));
};
let ok = if name == PRIM_IN { has } else { !has };
return Ok(if ok { pass_verdict() } else { leaf_verdict(row[ROW_VERDICT_FALSE], fmt_diag(row[ROW_DIAG_FAIL], &[(PH_EXPR, span)]), Cow::Borrowed(span), unmatched_leaf) });
}
if name == PRIM_METHOD_CONTAINS || name == PRIM_METHOD_STARTSWITH {
let span = args.last().and_then(|t| if let Term::Lit(Lit::String(s)) = t { Some(s.as_str()) } else { None }).unwrap_or(name);
let row = find_atom_row(name).unwrap_or_else(|| find_atom_row(PRIM_UNKNOWN_ATOM).unwrap());
if args.len() != ARITY_METHOD_CALL {
return Ok(leaf_verdict(GUARD_OUTCOME_UNMATCHED, fmt_diag(row[ROW_DIAG_UNMATCHED], &[(PH_EXPR, span)]), Cow::Borrowed(span), unmatched_leaf));
}
let rv = eval_scalar(&args[0], resolver)?;
let av = eval_scalar(&args[1], resolver)?;
if rv.is_absent() || av.is_absent() {
return Ok(leaf_verdict(row[ROW_VERDICT_ABSENT], fmt_diag(row[ROW_DIAG_UNMATCHED], &[(PH_EXPR, span)]), Cow::Borrowed(span), unmatched_leaf));
}
let ok = if name == PRIM_METHOD_CONTAINS {
rv.contains_in(&av).unwrap_or(false)
} else {
rv.as_str().zip(av.as_str()).is_some_and(|(s, sub)| s.starts_with(sub))
};
return Ok(if ok { pass_verdict() } else { leaf_verdict(row[ROW_VERDICT_FALSE], fmt_diag(row[ROW_DIAG_FAIL], &[(PH_EXPR, span)]), Cow::Borrowed(span), unmatched_leaf) });
}
}
let ev = eval_scalar(term, resolver)?;
let expr_label: Cow<'t, str> = match term {
Term::Prim(n, a) if n == PRIM_REF && let Some(Term::Lit(Lit::String(s))) = a.first() => Cow::Borrowed(s),
Term::Prim(n, a) if (n == PRIM_RLCD_PROP || n == PRIM_CALL) && let Some(Term::Lit(Lit::String(s))) = a.get(IDX_ARG_2) => Cow::Borrowed(s),
other => Cow::Owned(render(other)),
};
let t_row = find_atom_row(PRIM_TRUTHY).unwrap();
if ev.is_absent() {
return Ok(leaf_verdict(t_row[ROW_VERDICT_ABSENT], fmt_diag(t_row[ROW_DIAG_ABSENT], &[(PH_EXPR, &expr_label)]), expr_label, unmatched_leaf));
}
if ev.truthy() {
return Ok(pass_verdict());
}
let act_s = ev.display_cow();
Ok(leaf_verdict(t_row[ROW_VERDICT_FALSE], fmt_diag(t_row[ROW_DIAG_FAIL], &[(PH_EXPR, &expr_label), (PH_ACTUAL, &act_s)]), expr_label, unmatched_leaf))
}