@voxgig/sdkgen 4.8.2 → 4.8.3

package/project/.sdk/tm/rust/tests/struct_utility_test.rs

@@ -1,28 +1,56 @@
 // Struct utility tests — run the shared `struct` corpus subtree from
-// ../.sdk/test/test.json against the vendored voxgig struct port
-// (mirrors tm/go/test/struct_utility_test.go).
+// ../.sdk/test/test.json against the vendored voxgig struct port.
+//
+// The corpus is driven by the VENDORED omni runner through the adapter in
+// tests/omni_resolver/mod.rs (which superseded the hand-written
+// tests/struct_runner/mod.rs). Group labels, null flags and subjects are
+// unchanged; the engine underneath them is now the shared one.
 
-mod struct_runner;
+mod omni_resolver;
 
 use std::cell::RefCell;
 use std::rc::Rc;
 
-use struct_runner::*;
+use omni_resolver::*;
 
 use RUSTCRATE::utility::voxgigstruct::ordered_map::OrderedMap;
 use RUSTCRATE::utility::voxgigstruct::value::Value;
 use RUSTCRATE::utility::voxgigstruct::*;
 
 
+/// Groups this SDK's corpus subset does not carry, so a run over it reports
+/// zero checks for them BY DESIGN.
+///
+/// `Run::report` holds this list to the corpus in both directions: a group
+/// that goes absent without being named here fails the suite, and a name
+/// here that is no longer absent fails it too. Nothing else stops a renamed
+/// or deleted group from taking its whole check count away while `cargo
+/// test` still prints `ok`.
+///
+/// `sentinels` is the Group A null-unification block (UNDEF_SPEC.md): the
+/// subjects below are wired and ready, and the entries arrive with the
+/// corpus refresh that adds `struct.sentinels`.
+const EXPECTED_SKIPS: &[&str] = &[
+    "sentinels-getprop_unify",
+    "sentinels-getelem_absent",
+    "sentinels-haskey_unify",
+    "sentinels-isempty_unify",
+    "sentinels-isnode_unify",
+    "sentinels-stringify_null",
+];
+
+
 #[test]
 fn struct_utility() {
-    let spec = test_json();
-    let s = vget(&spec, "struct");
-    let mut run = Run::new();
+    let mut run = Run::section("struct");
+    // A detached handle on the resolved section, so a `set!` argument does
+    // not borrow `run` while `run` is borrowed mutably by the call.
+    let s = run.spec.clone();
+    let all = run.all.clone();
 
     macro_rules! set {
         ($cat:expr, $name:expr) => {
-            vget_path(&s, &[$cat, $name])
+            jpath(&s, &[$cat, $name])
         };
     }
 
@@ -211,6 +239,28 @@ fn struct_utility() {
         |v| Value::str(stringify(&v, None, false)),
     );
 
+    // -------- nullsem (does a PRESENT key holding JSON null read as "no
+    // value"?) — the peer of go's `nullsem` subtest and py's test_nullsem.
+    // null_flag is false throughout so a stored null survives into the
+    // subject rather than being normalised to a sentinel string.
+    run.run_set(&set!("nullsem", "getprop"), false, "nullsem-getprop", |vin| {
+        let alt = vget(&vin, "alt");
+        get_prop(&vget(&vin, "val"), &vget(&vin, "key"), alt)
+    });
+    run.run_set(&set!("nullsem", "getelem"), false, "nullsem-getelem", |vin| {
+        let alt = vget(&vin, "alt");
+        get_elem(&vget(&vin, "val"), &vget(&vin, "key"), alt)
+    });
+    run.run_set(&set!("nullsem", "getpath"), false, "nullsem-getpath", |vin| {
+        get_path(&vget(&vin, "store"), &vget(&vin, "path"), None)
+    });
+    run.run_set(&set!("nullsem", "haskey"), false, "nullsem-haskey", |vin| {
+        b(has_key(&vget(&vin, "src"), &vget(&vin, "key")))
+    });
+    run.run_set(&set!("nullsem", "keysof"), false, "nullsem-keysof", |v| {
+        keys_of(&v)
+    });
+
     // -------- walk ---------------------------------------------------
     run.run_set(&set!("walk", "basic"), true, "walk-basic", |vin| {
         let mut walkpath = |_k: &Value, val: &Value, _p: &Value, path: &[String]| -> Value {
@@ -223,7 +273,7 @@ fn struct_utility() {
     });
     // walk.log — three runs (after-only / before-only / both) of a logging callback.
     {
-        let log_spec = vget_path(&s, &["walk", "log"]);
+        let log_spec = tostruct(&jpath(&s, &["walk", "log"]));
         let input = clone(&vget(&log_spec, "in"));
         let want = vget(&log_spec, "out");
         let mk_log = |inp: &Value, before: bool, after: bool| -> Value {
@@ -377,8 +427,7 @@ fn struct_utility() {
     });
     // merge.basic is a single { in, out } object (not a `set`); handle inline.
     {
-        let mb = vget(&s, "merge");
-        let basic = vget(&mb, "basic");
+        let basic = tostruct(&jpath(&s, &["merge", "basic"]));
         let bin = clone(&vget(&basic, "in"));
         let bout = fix_json(&vget(&basic, "out"), true);
         let got = fix_json(&merge(&bin, None), true);
@@ -455,7 +504,7 @@ fn struct_utility() {
     // -------- inject -------------------------------------------------
     {
         // inject.basic is a single { in: {val, store}, out } object.
-        let basic = vget_path(&s, &["inject", "basic"]);
+        let basic = tostruct(&jpath(&s, &["inject", "basic"]));
         let bin = vget(&basic, "in");
         let bout = fix_json(&vget(&basic, "out"), true);
         let got = fix_json(
@@ -504,7 +553,7 @@ fn struct_utility() {
 
     // -------- transform ---------------------------------------------
     {
-        let basic = vget_path(&s, &["transform", "basic"]);
+        let basic = tostruct(&jpath(&s, &["transform", "basic"]));
         let bin = vget(&basic, "in");
         let bout = fix_json(&vget(&basic, "out"), true);
         let got = match transform(
@@ -620,7 +669,7 @@ fn struct_utility() {
         Value::map_of([("zed".to_string(), Value::str(format!("ZED{foo_s}_{bar_s}")))])
     }
     {
-        let check = vget_path(&spec, &["primary", "check"]);
+        let check = tostruct(&jpath(&all, &["primary", "check"]));
         // resolve clients from DEF.client (options are inject()'d against {} — a no-op here)
         let def_clients = vget_path(&check, &["DEF", "client"]);
         let mut clients: OrderedMap<Value> = OrderedMap::new();
@@ -657,20 +706,9 @@ fn struct_utility() {
     }
 
     // -------- report -------------------------------------------------
-    if !run.failures.is_empty() {
-        let n = run.failures.len();
-        let mut msg = format!("\n{} corpus check(s) failed ({} passed):\n", n, run.passed);
-        for f in run.failures.iter().take(60) {
-            msg.push_str("  - ");
-            msg.push_str(f);
-            msg.push('\n');
-        }
-        if n > 60 {
-            msg.push_str(&format!("  ... and {} more\n", n - 60));
-        }
-        panic!("{msg}");
-    }
-    eprintln!("corpus: {} checks passed", run.passed);
+    // Strict: any group that went absent, any expected skip that did not
+    // happen, and any corpus group nothing here drives, is a FAILURE.
+    run.report("corpus", EXPECTED_SKIPS);
 }
 
 // Function values embedded in data: `get_elem` with a callable `alt`, and

package/project/.sdk/tm/rust/tests/vendor/omni/json.rs

@@ -0,0 +1,412 @@
+// VENDORED: @voxgig/omni sdk-20260904-1610-0 (rust/src/json.rs)
+// Source: https://github.com/voxgig/omni @ 8c3e1b573a8d35796f7fc45e3226b977023cabf7  [tag: sdk-20260904-1610-0]
+// License: MIT (c) voxgig - see repository LICENSE. Do not edit: resync from upstream.
+//! The omni JSON value model, with a small in-tree parser.
+//!
+//! The omni runner must be able to test *any* library, and must add no
+//! third-party dependencies, so it carries its own JSON support rather
+//! than borrowing serde or the system under test.
+
+use std::collections::BTreeMap;
+use std::fmt;
+
+/// A JSON value. `Absent` is the marker for "no value at all", as distinct
+/// from `Null`.
+#[derive(Clone, Debug, PartialEq)]
+pub enum Json {
+    Absent,
+    Null,
+    Bool(bool),
+    Num(f64),
+    Str(String),
+    List(Vec<Json>),
+    Map(BTreeMap<String, Json>),
+}
+
+impl Json {
+    /// A map (JSON object)?
+    pub fn ismap(&self) -> bool {
+        matches!(self, Json::Map(_))
+    }
+
+    /// A list (JSON array)?
+    pub fn islist(&self) -> bool {
+        matches!(self, Json::List(_))
+    }
+
+    /// A container (map or list)?
+    pub fn isnode(&self) -> bool {
+        self.ismap() || self.islist()
+    }
+
+    /// Absent (no value at all)?
+    pub fn isabsent(&self) -> bool {
+        matches!(self, Json::Absent)
+    }
+
+    /// Null (a JSON null)?
+    pub fn isnull(&self) -> bool {
+        matches!(self, Json::Null)
+    }
+
+    /// Absent or null?
+    pub fn isnone(&self) -> bool {
+        self.isabsent() || self.isnull()
+    }
+
+    /// A JSON number? Booleans are not numbers.
+    pub fn isnum(&self) -> bool {
+        matches!(self, Json::Num(_))
+    }
+
+    pub fn asnum(&self) -> Option<f64> {
+        match self {
+            Json::Num(num) => Some(*num),
+            _ => None,
+        }
+    }
+
+    pub fn asstr(&self) -> Option<&str> {
+        match self {
+            Json::Str(text) => Some(text),
+            _ => None,
+        }
+    }
+
+    pub fn asmap(&self) -> Option<&BTreeMap<String, Json>> {
+        match self {
+            Json::Map(map) => Some(map),
+            _ => None,
+        }
+    }
+
+    pub fn aslist(&self) -> Option<&Vec<Json>> {
+        match self {
+            Json::List(list) => Some(list),
+            _ => None,
+        }
+    }
+
+    /// Read a map entry. Returns `Absent` when missing.
+    pub fn get(&self, key: &str) -> Json {
+        match self {
+            Json::Map(map) => map.get(key).cloned().unwrap_or(Json::Absent),
+            _ => Json::Absent,
+        }
+    }
+
+    /// Is a map key present at all (even with a null value)?
+    pub fn has(&self, key: &str) -> bool {
+        match self {
+            Json::Map(map) => map.contains_key(key),
+            _ => false,
+        }
+    }
+
+    /// Build a map value.
+    pub fn map(entries: Vec<(&str, Json)>) -> Json {
+        let mut out = BTreeMap::new();
+        for (key, val) in entries {
+            out.insert(key.to_string(), val);
+        }
+        Json::Map(out)
+    }
+
+    /// Build a list value.
+    pub fn list(entries: Vec<Json>) -> Json {
+        Json::List(entries)
+    }
+
+    /// Build a string value.
+    pub fn str(text: &str) -> Json {
+        Json::Str(text.to_string())
+    }
+}
+
+impl fmt::Display for Json {
+    fn fmt(&self, out: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(out, "{}", super::util::jsonstr(self))
+    }
+}
+
+impl From<f64> for Json {
+    fn from(val: f64) -> Json {
+        Json::Num(val)
+    }
+}
+
+impl From<i64> for Json {
+    fn from(val: i64) -> Json {
+        Json::Num(val as f64)
+    }
+}
+
+impl From<usize> for Json {
+    fn from(val: usize) -> Json {
+        Json::Num(val as f64)
+    }
+}
+
+impl From<bool> for Json {
+    fn from(val: bool) -> Json {
+        Json::Bool(val)
+    }
+}
+
+impl From<&str> for Json {
+    fn from(val: &str) -> Json {
+        Json::Str(val.to_string())
+    }
+}
+
+impl From<String> for Json {
+    fn from(val: String) -> Json {
+        Json::Str(val)
+    }
+}
+
+/// Maximum nesting depth the parser will follow. Omni specs are trusted
+/// input, so this is crash-safety, not a security boundary: past this
+/// depth the recursive parser would overflow the stack and abort the
+/// process, so it returns an error instead. 1024 is far beyond any real
+/// spec, and low enough that reaching the limit itself fits comfortably
+/// in a default (2MiB) test-thread stack even in debug builds.
+const MAX_DEPTH: usize = 1024;
+
+/// Parse JSON text into a [`Json`] value.
+pub fn parse(text: &str) -> Result<Json, String> {
+    let chars: Vec<char> = text.chars().collect();
+    let mut pos = 0usize;
+
+    skipws(&chars, &mut pos);
+    let val = parseval(&chars, &mut pos, 0)?;
+    skipws(&chars, &mut pos);
+
+    if pos < chars.len() {
+        return Err(format!("omni: trailing JSON content at {}", pos));
+    }
+
+    Ok(val)
+}
+
+fn skipws(chars: &[char], pos: &mut usize) {
+    while *pos < chars.len() {
+        let char = chars[*pos];
+        if char == ' ' || char == '\t' || char == '\n' || char == '\r' {
+            *pos += 1;
+        } else {
+            break;
+        }
+    }
+}
+
+fn parseval(chars: &[char], pos: &mut usize, depth: usize) -> Result<Json, String> {
+    if depth > MAX_DEPTH {
+        return Err(format!("omni: JSON nested too deeply at {}", pos));
+    }
+
+    if *pos >= chars.len() {
+        return Err("omni: unexpected end of JSON".to_string());
+    }
+
+    match chars[*pos] {
+        '{' => parsemap(chars, pos, depth),
+        '[' => parselist(chars, pos, depth),
+        '"' => Ok(Json::Str(parsestr(chars, pos)?)),
+        't' => parseword(chars, pos, "true", Json::Bool(true)),
+        'f' => parseword(chars, pos, "false", Json::Bool(false)),
+        'n' => parseword(chars, pos, "null", Json::Null),
+        _ => parsenum(chars, pos),
+    }
+}
+
+fn parseword(chars: &[char], pos: &mut usize, word: &str, val: Json) -> Result<Json, String> {
+    for expect in word.chars() {
+        if *pos >= chars.len() || chars[*pos] != expect {
+            return Err(format!("omni: bad JSON literal at {}", pos));
+        }
+        *pos += 1;
+    }
+    Ok(val)
+}
+
+fn parsemap(chars: &[char], pos: &mut usize, depth: usize) -> Result<Json, String> {
+    let mut out = BTreeMap::new();
+    *pos += 1; // {
+
+    skipws(chars, pos);
+    if *pos < chars.len() && chars[*pos] == '}' {
+        *pos += 1;
+        return Ok(Json::Map(out));
+    }
+
+    loop {
+        skipws(chars, pos);
+        let key = parsestr(chars, pos)?;
+        skipws(chars, pos);
+
+        if *pos >= chars.len() || chars[*pos] != ':' {
+            return Err(format!("omni: expected ':' at {}", pos));
+        }
+        *pos += 1;
+
+        skipws(chars, pos);
+        let val = parseval(chars, pos, depth + 1)?;
+        out.insert(key, val);
+
+        skipws(chars, pos);
+        if *pos >= chars.len() {
+            return Err("omni: unterminated JSON object".to_string());
+        }
+        if chars[*pos] == ',' {
+            *pos += 1;
+            continue;
+        }
+        if chars[*pos] == '}' {
+            *pos += 1;
+            return Ok(Json::Map(out));
+        }
+        return Err(format!("omni: expected ',' or '}}' at {}", pos));
+    }
+}
+
+fn parselist(chars: &[char], pos: &mut usize, depth: usize) -> Result<Json, String> {
+    let mut out = Vec::new();
+    *pos += 1; // [
+
+    skipws(chars, pos);
+    if *pos < chars.len() && chars[*pos] == ']' {
+        *pos += 1;
+        return Ok(Json::List(out));
+    }
+
+    loop {
+        skipws(chars, pos);
+        out.push(parseval(chars, pos, depth + 1)?);
+
+        skipws(chars, pos);
+        if *pos >= chars.len() {
+            return Err("omni: unterminated JSON array".to_string());
+        }
+        if chars[*pos] == ',' {
+            *pos += 1;
+            continue;
+        }
+        if chars[*pos] == ']' {
+            *pos += 1;
+            return Ok(Json::List(out));
+        }
+        return Err(format!("omni: expected ',' or ']' at {}", pos));
+    }
+}
+
+fn parsestr(chars: &[char], pos: &mut usize) -> Result<String, String> {
+    if *pos >= chars.len() || chars[*pos] != '"' {
+        return Err(format!("omni: expected string at {}", pos));
+    }
+    *pos += 1;
+
+    let mut out = String::new();
+
+    while *pos < chars.len() {
+        let char = chars[*pos];
+        *pos += 1;
+
+        if char == '"' {
+            return Ok(out);
+        }
+
+        if char != '\\' {
+            out.push(char);
+            continue;
+        }
+
+        if *pos >= chars.len() {
+            break;
+        }
+
+        let escape = chars[*pos];
+        *pos += 1;
+
+        match escape {
+            '"' => out.push('"'),
+            '\\' => out.push('\\'),
+            '/' => out.push('/'),
+            'b' => out.push('\u{8}'),
+            'f' => out.push('\u{c}'),
+            'n' => out.push('\n'),
+            'r' => out.push('\r'),
+            't' => out.push('\t'),
+            'u' => {
+                let mut code = 0u32;
+                for _ in 0..4 {
+                    if *pos >= chars.len() {
+                        return Err("omni: bad JSON unicode escape".to_string());
+                    }
+                    let digit = chars[*pos]
+                        .to_digit(16)
+                        .ok_or_else(|| "omni: bad JSON unicode escape".to_string())?;
+                    code = code * 16 + digit;
+                    *pos += 1;
+                }
+                out.push(char::from_u32(code).unwrap_or('\u{fffd}'));
+            }
+            _ => return Err(format!("omni: bad JSON escape at {}", pos)),
+        }
+    }
+
+    Err("omni: unterminated JSON string".to_string())
+}
+
+fn parsenum(chars: &[char], pos: &mut usize) -> Result<Json, String> {
+    let start = *pos;
+
+    if *pos < chars.len() && (chars[*pos] == '-' || chars[*pos] == '+') {
+        *pos += 1;
+    }
+
+    while *pos < chars.len() {
+        let char = chars[*pos];
+        if char.is_ascii_digit()
+            || char == '.'
+            || char == 'e'
+            || char == 'E'
+            || char == '-'
+            || char == '+'
+        {
+            *pos += 1;
+        } else {
+            break;
+        }
+    }
+
+    let text: String = chars[start..*pos].iter().collect();
+    text.parse::<f64>()
+        .map(Json::Num)
+        .map_err(|_| format!("omni: bad JSON number [{}] at {}", text, start))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    // Deeply nested input must produce a parse error, not overflow the
+    // stack and abort the process.
+    #[test]
+    fn parse_rejects_deep_nesting() {
+        let deep = "[".repeat(MAX_DEPTH * 4);
+        let err = parse(&deep).expect_err("deep nesting must be rejected");
+        assert!(err.contains("nested too deeply"), "unexpected error: {}", err);
+
+        let deepmap = "{\"a\":".repeat(MAX_DEPTH * 4);
+        let err = parse(&deepmap).expect_err("deep nesting must be rejected");
+        assert!(err.contains("nested too deeply"), "unexpected error: {}", err);
+    }
+
+    // Reasonable nesting still parses.
+    #[test]
+    fn parse_allows_reasonable_nesting() {
+        let text = format!("{}1{}", "[".repeat(64), "]".repeat(64));
+        assert!(parse(&text).is_ok());
+    }
+}

package/project/.sdk/tm/rust/tests/vendor/omni/mod.rs

@@ -0,0 +1,38 @@
+// VENDORED: @voxgig/omni sdk-20260904-1610-0 (rust/src/lib.rs)
+// Source: https://github.com/voxgig/omni @ 8c3e1b573a8d35796f7fc45e3226b977023cabf7  [tag: sdk-20260904-1610-0]
+// License: MIT (c) voxgig - see repository LICENSE. Do not edit: resync from upstream.
+//! voxgig_omni - the shared multi-language test runner.
+//!
+//! A test spec is plain JSON. The same spec file drives the same tests in
+//! every language that ships an omni port, so behaviour is defined once and
+//! verified everywhere.
+//!
+//! ```no_run
+//! use std::rc::Rc;
+//! use voxgig_omni::{make_runner, Json, Provider, Subject};
+//!
+//! let runner = make_runner("../spec/fib.json", Provider::default()).unwrap();
+//! let pack = runner.runner("fib", None).unwrap();
+//! let double: Subject = Rc::new(|args: &[Json]| {
+//!     Ok(Json::Num(args[0].asnum().unwrap_or(0.0) * 2.0))
+//! });
+//! pack.runset(&pack.set("basic"), Some(&double)).unwrap();
+//! ```
+
+pub mod json;
+pub mod regex;
+pub mod runner;
+pub mod util;
+
+pub use json::{parse, Json};
+pub use regex::Regex;
+pub use runner::{
+    errify, fixjson, loadspec, make_runner, matchcheck, matchval, nullmodifier, numtext,
+    resolvespec, Flags, OmniError, Provider, RunPack, Runner, SpecRef, Subject, SubjectArgs,
+    CAPABILITIES,
+    SPECVERSION,
+};
+pub use util::{
+    clone, deepequal, getpath, jsonstr, numstr, pathify, stringify, walk, EXISTSMARK, NULLMARK,
+    UNDEFMARK,
+};