postscriptum 0.1.1

Multi-interpreted-language scripting engine for Rust with Rhai and Python backends
Documentation
//! G7 acceptance tests: static validation pins — every rejection
//! class, both `eval` positions, shadowing, locators, length cap.
//!
//! Conformance mirror: quartertone `validates_q37_expressions`
//! (locators `columns[i].expression`, `filter_expression`) — same
//! shapes, same pins. Message texts mirror quartertone's
//! `validate.rs` so the migration keeps its assertions.

#![cfg(feature = "rhai")]

use postscriptum::{BoundedRhaiEngine, ExprIssueKind, ValidationError};

const ROOTS: &[&str] = &["payload", "table", "this_row", "frozen_now"];

fn engine() -> BoundedRhaiEngine {
    BoundedRhaiEngine::with_defaults()
}

fn check(src: &str) -> Result<(), ValidationError> {
    engine().check_expression(src, "columns[3].expression", ROOTS)
}

/// Clean expressions validate — including everything the walker must
/// NOT flag: `let` bindings, loop vars (single + double), fn params,
/// and the frozen clock.
#[test]
fn clean_expressions_pass() {
    for src in [
        "payload.qty + 1",
        "table[\"type\"]",
        "this_row.age + payload.bonus",
        "let t = 1; t + table.x",
        "let total = 0; for i in 0..3 { total += i; }",
        "let total = 0; for x in [1, 2] { for y in [3] { total += x + y; } }",
        "fn f(a) { a + 1 } f(2)",
        "frozen_now",
        "table.updated_at < frozen_now",
    ] {
        assert!(
            check(src).is_ok(),
            "{src:?} must validate, got: {:?}",
            check(src)
        );
    }
}

/// Syntax errors surface rhai's text under the caller's locator.
#[test]
fn syntax_errors_reported() {
    let err = check("let x = ").unwrap_err();
    assert_eq!(err.0.len(), 1);
    assert_eq!(err.0[0].kind, ExprIssueKind::Syntax);
    assert_eq!(err.0[0].locator, "columns[3].expression");
    assert!(
        err.0[0].message.starts_with("invalid expression: "),
        "must carry rhai's text, got: {:?}",
        err.0[0].message
    );
}

/// Unknown roots name the offender and the allowed set.
#[test]
fn unknown_roots_flagged() {
    let err = check("paylod.qty + 1").unwrap_err();
    assert_eq!(err.0.len(), 1);
    assert_eq!(err.0[0].kind, ExprIssueKind::UnknownRoot);
    assert_eq!(
        err.0[0].message,
        "unknown identifier 'paylod' (available: payload, table, this_row, frozen_now)"
    );
    // Deduplicated, first-seen order.
    let err = check("nosuch + nosuch + payload.qty").unwrap_err();
    assert_eq!(err.0.len(), 1, "must dedupe, got: {err:?}");
    assert!(err.0[0].message.contains("'nosuch'"));
}

/// `eval` refused in BOTH parse positions: top-level parses as
/// `Stmt::FnCall`, nested as `Expr::FnCall`.
#[test]
fn dynamic_eval_refused_in_both_positions() {
    for src in [
        "eval(\"1\")",
        "let s = \"1\"; let x = eval(s); x",
        "[eval(\"1\")]",
    ] {
        let err = check(src).unwrap_err();
        assert!(
            err.0.iter().any(|i| i.kind == ExprIssueKind::DynamicEval),
            "{src:?} must flag DynamicEval, got: {err:?}"
        );
        assert!(
            err.0[0].message.contains("dynamic eval()"),
            "must carry the refusal text, got: {err:?}"
        );
    }
    // …while a same-named VARIABLE is not a call and stays clean.
    // (A bare `eval` root is unknown, not dynamic — no false refusal.)
    let err = check("evall + 1").unwrap_err();
    assert!(
        err.0.iter().all(|i| i.kind == ExprIssueKind::UnknownRoot),
        "got: {err:?}"
    );
}

/// Eval refusal comes before unknown roots (quartertone's order).
#[test]
fn eval_refusal_ordered_before_unknown_roots() {
    let err = check("eval(nosuch)").unwrap_err();
    assert_eq!(err.0[0].kind, ExprIssueKind::DynamicEval);
    assert!(
        err.0.iter().any(|i| i.kind == ExprIssueKind::UnknownRoot),
        "got: {err:?}"
    );
}

/// Locators preserved verbatim (the `filter_expression` shape).
#[test]
fn locators_preserved_verbatim() {
    let err = engine()
        .check_expression("nosuch", "filter_expression", ROOTS)
        .unwrap_err();
    assert_eq!(err.0[0].locator, "filter_expression");
}

/// Over-cap source rejected statically, before compiling.
#[test]
fn oversize_rejected_without_compiling() {
    let err = engine()
        .check_expression(&"x".repeat(9 * 1024), "columns[0].expression", ROOTS)
        .unwrap_err();
    assert_eq!(err.0.len(), 1);
    assert_eq!(err.0[0].kind, ExprIssueKind::Syntax);
    assert!(
        err.0[0].message.contains("too long"),
        "got: {:?}",
        err.0[0].message
    );
}