@voxgig/sdkgen 4.8.2 → 4.8.3

package/project/.sdk/tm/rb/test/vendor/omni/util.rb

@@ -0,0 +1,199 @@
+# VENDORED: @voxgig/omni sdk-20260904-1610-0 (ruby/lib/voxgig_omni/util.rb)
+# 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.
+# Omni internal JSON utilities.
+#
+# This module is deliberately self-contained: the omni runner must be able
+# to test *any* library, including libraries that provide these same
+# operations, so it can never borrow them from the system under test.
+# Zero third-party dependencies, by design.
+
+module VoxgigOmni
+  NULLMARK = '__NULL__'     # Value is JSON null.
+  UNDEFMARK = '__UNDEF__'   # Value is not present (thus, undefined).
+  EXISTSMARK = '__EXISTS__' # Value exists (not undefined).
+
+  # Ruby has no `undefined`, so absence needs its own marker.
+  class AbsentClass
+    def to_s
+      'ABSENT'
+    end
+
+    def inspect
+      'ABSENT'
+    end
+  end
+
+  ABSENT = AbsentClass.new
+
+  module Util
+    module_function
+
+    # A map (JSON object)?
+    def ismap(val)
+      val.is_a?(Hash)
+    end
+
+    # A list (JSON array)?
+    def islist(val)
+      val.is_a?(Array)
+    end
+
+    # A container (map or list)?
+    def isnode(val)
+      ismap(val) || islist(val)
+    end
+
+    # A JSON number? Booleans are not numbers.
+    def isnum(val)
+      val.is_a?(Numeric) && !val.is_a?(TrueClass) && !val.is_a?(FalseClass)
+    end
+
+    # Deep copy a JSON value. Other values pass through by reference.
+    def clone(val)
+      return val.map { |entry| clone(entry) } if islist(val)
+
+      if ismap(val)
+        out = {}
+        val.each { |key, subval| out[key] = clone(subval) }
+        return out
+      end
+
+      val
+    end
+
+    # Read a value by path. Returns ABSENT when any step is missing.
+    def getpath(val, path)
+      current = val
+
+      path.each do |part|
+        if islist(current)
+          index = part.is_a?(Integer) ? part : Integer(part.to_s, exception: false)
+          return ABSENT if index.nil? || index.negative? || index >= current.length
+
+          current = current[index]
+        elsif ismap(current)
+          key = part.to_s
+          return ABSENT unless current.key?(key)
+
+          current = current[key]
+        else
+          return ABSENT
+        end
+      end
+
+      current
+    end
+
+    # Depth-first walk: children first, then the containing node.
+    def walk(val, apply, key = nil, parent = nil, path = nil)
+      curpath = path || []
+
+      if isnode(val)
+        if islist(val)
+          val.each_index do |index|
+            val[index] = walk(val[index], apply, index, val, curpath + [index])
+          end
+        else
+          val.keys.each do |childkey|
+            val[childkey] = walk(val[childkey], apply, childkey, val, curpath + [childkey])
+          end
+        end
+      end
+
+      apply.call(key, val, parent, curpath)
+    end
+
+    # Deep structural equality: numbers by value, bools never numbers.
+    def deepequal(a, b)
+      return true if a.equal?(b)
+
+      abool = a.is_a?(TrueClass) || a.is_a?(FalseClass)
+      bbool = b.is_a?(TrueClass) || b.is_a?(FalseClass)
+      return a == b if abool || bbool
+
+      # NaN equals NaN: deepequal is structural, not IEEE (as canonical).
+      if isnum(a) && isnum(b)
+        return true if a.is_a?(Float) && a.nan? && b.is_a?(Float) && b.nan?
+
+        return a == b
+      end
+
+      return a.equal?(b) if a.nil? || b.nil? || a.equal?(ABSENT) || b.equal?(ABSENT)
+
+      if islist(a) && islist(b)
+        return false if a.length != b.length
+
+        return a.each_index.all? { |i| deepequal(a[i], b[i]) }
+      end
+
+      if ismap(a) && ismap(b)
+        return false if a.length != b.length
+
+        return a.all? { |key, val| b.key?(key) && deepequal(val, b[key]) }
+      end
+
+      return false if islist(a) != islist(b) || ismap(a) != ismap(b)
+
+      a == b
+    end
+
+    # Render a number the same way in every port: 5.0 prints as 5.
+    def numstr(val)
+      if val.is_a?(Float)
+        return 'null' if val.nan? || val.infinite?
+        return val.to_i.to_s if val == val.to_i && val.abs < 2**53
+
+        return val.to_s
+      end
+
+      val.to_s
+    end
+
+    def quote(val)
+      out = +'"'
+      val.to_s.each_char do |char|
+        out << case char
+               when '"' then '\\"'
+               when '\\' then '\\\\'
+               when "\n" then '\\n'
+               when "\r" then '\\r'
+               when "\t" then '\\t'
+               else
+                 char.ord < 0x20 ? format('\\u%04x', char.ord) : char
+               end
+      end
+      out << '"'
+      out
+    end
+
+    # Compact JSON text with map keys sorted, identical in every port.
+    def jsonstr(val)
+      return 'undefined' if val.equal?(ABSENT)
+      return 'null' if val.nil?
+      return val ? 'true' : 'false' if val.is_a?(TrueClass) || val.is_a?(FalseClass)
+      return quote(val) if val.is_a?(String)
+      return numstr(val) if isnum(val)
+      return '[' + val.map { |entry| jsonstr(entry) }.join(',') + ']' if islist(val)
+
+      if ismap(val)
+        keys = val.keys.map(&:to_s).sort
+        return '{' + keys.map { |key| quote(key) + ':' + jsonstr(val[key]) }.join(',') + '}'
+      end
+
+      return '[Function]' if val.is_a?(Proc) || val.is_a?(Method)
+
+      quote(val.to_s)
+    end
+
+    # Strings verbatim, everything else as compact JSON.
+    def stringify(val)
+      val.is_a?(String) ? val : jsonstr(val)
+    end
+
+    # Render a path as a dotted string.
+    def pathify(path)
+      (path || []).map(&:to_s).join('.')
+    end
+  end
+end

package/project/.sdk/tm/rb/test/vendor/omni/voxgig_omni.rb

@@ -0,0 +1,15 @@
+# VENDORED: @voxgig/omni sdk-20260904-1610-0 (ruby/lib/voxgig_omni.rb)
+# 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 - shared multi-language test runner.
+
+require_relative 'util'
+require_relative 'runner'
+
+module VoxgigOmni
+  module_function
+
+  def make_runner(specref, provider = nil)
+    Runner.make_runner(specref, provider)
+  end
+end

package/project/.sdk/tm/rb/utility/prepare_method.rb

@@ -9,6 +9,10 @@ module ProjectNameUtilities
   PrepareMethod = ->(ctx) {
     method = VoxgigStruct.getprop(ctx.point, "method")
     next method.upcase if method.is_a?(String) && "" != method
-    METHOD_MAP[ctx.op.name] || "GET"
+    # No default: an op name outside the convention resolves to no method,
+    # exactly as the ts reference (`methodMap[key]` is undefined there).
+    # The silent-pass inline runner hid a stray "GET" fallback here; the
+    # shared corpus (prepareMethod, opname "bad" -> null) pins it now.
+    METHOD_MAP[ctx.op.name]
   }
 end

package/project/.sdk/tm/rust/tests/common/mod.rs

@@ -1,6 +1,13 @@
-// Shared SDK test infrastructure (mirrors tm/go/test/runner_test.go plus
-// the fh* feature-test harness from tm/go/test/feature_test.go). Each test
-// binary includes this module with `mod common;`.
+// Shared SDK test SUPPORT: the helpers the generated entity/direct tests and
+// the corpus call sites share — env loading, the sdk-test-control.json skip
+// and pacing machinery, corpus access, entity-data conversion, ctx
+// construction from a JSON test entry, and the fh* feature-test harness
+// (mirrors tm/go/test/testsupport_test.go plus the fh* harness from
+// tm/go/test/feature_test.go). Each test binary includes it with
+// `mod common;`.
+//
+// The corpus ENGINE half of this file was retired by the vendor-tag rollout:
+// see the note where it used to be, and tests/omni_resolver/mod.rs.
 
 #![allow(dead_code)]
 
@@ -9,7 +16,7 @@ use std::path::PathBuf;
 use std::rc::Rc;
 
 use RUSTCRATE::core::helpers::{
-    get_bool, get_str, getp, ja, jo, json_thunk, now_ms, setp, to_int, to_map,
+    get_bool, get_str, getp, jo, json_thunk, now_ms, setp, to_int, to_map,
 };
 use RUSTCRATE::utility::voxgigstruct as vs;
 use RUSTCRATE::{
@@ -233,244 +240,14 @@ pub fn json_normalize(v: &Value) -> Value {
     }
 }
 
-/// matchString: /re/ patterns via the vendored regex engine, otherwise
-/// case-insensitive substring.
-pub fn match_string(pattern: &str, val: &str) -> bool {
-    if pattern.len() >= 2 && pattern.starts_with('/') && pattern.ends_with('/') {
-        return RUSTCRATE::utility::voxgigstruct::re::Regex::new(
-            &pattern[1..pattern.len() - 1],
-        )
-        .map(|re| re.is_match(val))
-        .unwrap_or(false);
-    }
-    val.to_lowercase().contains(&pattern.to_lowercase())
-}
-
-/// matchDeep (mirrors go): every leaf of `check` must equal/match the same
-/// path in `base`; returns Some(reason) on the first mismatch.
-pub fn match_deep(check: &Value, base: &Value) -> Option<String> {
-    fn rec(check: &Value, base: &Value, path: &mut Vec<String>) -> Option<String> {
-        match check {
-            Value::Map(cm) => {
-                for (k, cv) in cm.borrow().iter() {
-                    let bv = getp(base, k);
-                    path.push(k.clone());
-                    let r = rec(cv, &bv, path);
-                    path.pop();
-                    if r.is_some() {
-                        return r;
-                    }
-                }
-                None
-            }
-            Value::List(cl) => {
-                for (i, cv) in cl.borrow().iter().enumerate() {
-                    let bv = vs::get_elem(base, &Value::Num(i as f64), Value::Noval);
-                    path.push(i.to_string());
-                    let r = rec(cv, &bv, path);
-                    path.pop();
-                    if r.is_some() {
-                        return r;
-                    }
-                }
-                None
-            }
-            leaf => {
-                if let Value::Str(s) = leaf {
-                    if s == EXISTSMARK {
-                        if base.is_noval() || base.is_null() {
-                            return Some(format!(
-                                "{}: expected value to exist",
-                                path.join(".")
-                            ));
-                        }
-                        return None;
-                    }
-                    if s == UNDEFMARK {
-                        if !base.is_noval() && !base.is_null() {
-                            return Some(format!(
-                                "{}: expected undefined, got {}",
-                                path.join("."),
-                                vs::stringify(base, Some(60), false)
-                            ));
-                        }
-                        return None;
-                    }
-                }
-
-                let nc = json_normalize(leaf);
-                let nb = json_normalize(base);
-                if nc == nb {
-                    return None;
-                }
-                if let Value::Str(cs) = leaf {
-                    if !cs.is_empty() && match_string(cs, &vs::stringify(base, None, false)) {
-                        return None;
-                    }
-                }
-                Some(format!(
-                    "{}: got {}, want {}",
-                    path.join("."),
-                    vs::stringify(&nb, Some(120), false),
-                    vs::stringify(&nc, Some(120), false)
-                ))
-            }
-        }
-    }
-    let mut path = Vec::new();
-    rec(check, base, &mut path)
-}
-
-// ---- runset (mirrors go runner_test.go runset) -----------------------------------
-
-// Sections deliberately left empty in the shared corpus
-// (.sdk/test/primary/<name>.aon carries a PENDING header). Everything else
-// MUST contribute cases.
-pub const PENDING_SECTIONS: &[&str] = &[
-    "fetcher", "makeFetchDef", "makeResult", "featureAdd",
-    "featureHook", "featureInit",
-];
-
-pub fn runset(
-    testspec: &Value,
-    subject: &mut dyn FnMut(&Value) -> Result<Value, ProjectNameError>,
-) {
-    runset_named("", testspec, subject)
-}
-
-/// Drive one section of the shared test corpus.
-///
-/// This used to `return` silently when "set" was missing or not a list, so a
-/// renamed section, a fixture that failed to compile, or an empty set reported
-/// PASS while running zero assertions — the whole point of a shared oracle lost
-/// without a single red test. Both conditions now panic, except for the
-/// sections explicitly marked PENDING in the corpus.
-pub fn runset_named(
-    name: &str,
-    testspec: &Value,
-    subject: &mut dyn FnMut(&Value) -> Result<Value, ProjectNameError>,
-) {
-    let set = match getp(testspec, "set") {
-        Value::List(l) => Value::List(l),
-        _ => panic!(
-            "test corpus section {:?} has no `set` list — zero cases would run",
-            name
-        ),
-    };
-
-    if let Value::List(l) = &set {
-        if l.borrow().is_empty() && !PENDING_SECTIONS.contains(&name) {
-            panic!(
-                "test corpus section {:?} is EMPTY — zero cases would run; add \
-                 cases, or mark the fixture PENDING in .sdk/test/primary/",
-                name
-            );
-        }
-    }
-
-    let entries: Vec<Value> = match &set {
-        Value::List(l) => l.borrow().clone(),
-        _ => Vec::new(),
-    };
-
-    for (i, entry) in entries.iter().enumerate() {
-        if !matches!(entry, Value::Map(_)) {
-            continue;
-        }
-
-        let mark = match getp(entry, "mark") {
-            Value::Noval => String::new(),
-            m => format!(" (mark={})", vs::stringify(&m, None, false)),
-        };
-
-        let result = subject(entry);
-        let expected_err = getp(entry, "err");
-
-        match result {
-            Err(err) => {
-                if !expected_err.is_noval() && !expected_err.is_null() {
-                    let errmsg = err.msg.clone();
-                    if let Value::Str(exp) = &expected_err {
-                        if !match_string(exp, &errmsg) {
-                            panic!(
-                                "entry {}{}: error mismatch: got {:?}, want contains {:?}",
-                                i, mark, errmsg, exp
-                            );
-                        }
-                    }
-                    // err: true means any error is acceptable.
-                    if let Value::Map(_) = getp(entry, "match") {
-                        let result_map = jo(vec![
-                            ("in", getp(entry, "in")),
-                            (
-                                "err",
-                                jo(vec![("message", Value::str(errmsg.clone()))]),
-                            ),
-                        ]);
-                        if let Some(why) =
-                            match_deep(&getp(entry, "match"), &result_map)
-                        {
-                            panic!("entry {}{}: match: {}", i, mark, why);
-                        }
-                    }
-                    continue;
-                }
-                panic!("entry {}{}: unexpected error: {}", i, mark, err.msg);
-            }
-            Ok(out) => {
-                if !expected_err.is_noval() && !expected_err.is_null() {
-                    panic!(
-                        "entry {}{}: expected error containing {} but got result: {}",
-                        i,
-                        mark,
-                        vs::stringify(&expected_err, None, false),
-                        vs::stringify(&out, Some(160), false)
-                    );
-                }
-
-                let mut matched = false;
-                if let Value::Map(_) = getp(entry, "match") {
-                    let result_map = jo(vec![
-                        ("in", getp(entry, "in")),
-                        ("out", json_normalize(&out)),
-                    ]);
-                    let args = getp(entry, "args");
-                    if !args.is_noval() {
-                        setp(&result_map, "args", args);
-                    } else if !getp(entry, "in").is_noval() {
-                        setp(&result_map, "args", ja(vec![getp(entry, "in")]));
-                    }
-                    let ctx_data = getp(entry, "ctx");
-                    if !ctx_data.is_noval() {
-                        setp(&result_map, "ctx", ctx_data);
-                    }
-                    if let Some(why) = match_deep(&getp(entry, "match"), &result_map) {
-                        panic!("entry {}{}: match: {}", i, mark, why);
-                    }
-                    matched = true;
-                }
-
-                let expected_out = getp(entry, "out");
-                if expected_out.is_noval() && matched {
-                    continue;
-                }
-                if !expected_out.is_noval() {
-                    let norm_result = json_normalize(&out);
-                    let norm_expected = json_normalize(&expected_out);
-                    if norm_result != norm_expected {
-                        panic!(
-                            "entry {}{}: output mismatch:\n  got:  {}\n  want: {}",
-                            i,
-                            mark,
-                            vs::stringify(&norm_result, Some(240), false),
-                            vs::stringify(&norm_expected, Some(240), false)
-                        );
-                    }
-                }
-            }
-        }
-    }
-}
+// The corpus ENGINE that used to live here — `runset` / `runset_named`
+// (the entry loop) and `match_deep` / `match_string` (the match engine) —
+// is superseded by the vendored @voxgig/omni runner, driven through the
+// adapter in tests/omni_resolver/mod.rs (vendor-tag rollout, Decision 4).
+// This file keeps its SUPPORT half under its own name — env loading, the
+// sdk-test-control skip/pacing machinery, corpus and entity-data access,
+// ctx construction from a JSON entry, and the fh feature harness — so the
+// emitted call sites did not move.
 
 // ---- ctx construction from JSON test entries --------------------------------------