clm-kernel 0.0.9

Cubical Logic Model (CLM) sovereign execution engine, CPN-VM, and Cordis spatiotemporal substrate
Documentation
#![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)),
        }
    }
}

// ── Context Building ────────────────────────────────────────────────────────

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)
}

// ── Action Execution & Hoare Sandwich ───────────────────────────────────────