@voxgig/sdkgen 4.8.2 → 4.8.3

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

@@ -0,0 +1,161 @@
+// VENDORED: @voxgig/omni sdk-20260904-1610-0 (rust/src/util.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.
+//! Omni internal JSON utilities.
+//!
+//! Self-contained by design: the omni runner must be able to test *any*
+//! library, including libraries that provide these same operations.
+
+use super::json::Json;
+
+pub const NULLMARK: &str = "__NULL__"; // Value is JSON null.
+pub const UNDEFMARK: &str = "__UNDEF__"; // Value is not present.
+pub const EXISTSMARK: &str = "__EXISTS__"; // Value exists (not undefined).
+
+/// Deep copy a JSON value.
+pub fn clone(val: &Json) -> Json {
+    val.clone()
+}
+
+/// Read a value by path. Returns `Json::Absent` when any step is missing.
+pub fn getpath(val: &Json, path: &[String]) -> Json {
+    let mut current = val.clone();
+
+    for part in path {
+        current = match &current {
+            Json::List(list) => match part.parse::<usize>() {
+                Ok(index) if index < list.len() => list[index].clone(),
+                _ => return Json::Absent,
+            },
+            Json::Map(map) => match map.get(part) {
+                Some(entry) => entry.clone(),
+                None => return Json::Absent,
+            },
+            _ => return Json::Absent,
+        };
+    }
+
+    current
+}
+
+/// Depth-first walk: children first, then the containing node. `apply` may
+/// replace the value.
+pub fn walk(val: &Json, apply: &dyn Fn(&Json, &[String]) -> Json) -> Json {
+    walkdown(val, apply, &[])
+}
+
+fn walkdown(val: &Json, apply: &dyn Fn(&Json, &[String]) -> Json, path: &[String]) -> Json {
+    let next = match val {
+        Json::List(list) => {
+            let mut out = Vec::with_capacity(list.len());
+            for (index, entry) in list.iter().enumerate() {
+                let mut childpath = path.to_vec();
+                childpath.push(index.to_string());
+                out.push(walkdown(entry, apply, &childpath));
+            }
+            Json::List(out)
+        }
+        Json::Map(map) => {
+            let mut out = std::collections::BTreeMap::new();
+            for (key, entry) in map.iter() {
+                let mut childpath = path.to_vec();
+                childpath.push(key.clone());
+                out.insert(key.clone(), walkdown(entry, apply, &childpath));
+            }
+            Json::Map(out)
+        }
+        other => other.clone(),
+    };
+
+    apply(&next, path)
+}
+
+/// Deep structural equality: numbers by value, bools never numbers.
+pub fn deepequal(a: &Json, b: &Json) -> bool {
+    match (a, b) {
+        (Json::Absent, Json::Absent) => true,
+        (Json::Null, Json::Null) => true,
+        (Json::Bool(x), Json::Bool(y)) => x == y,
+        (Json::Num(x), Json::Num(y)) => x == y || (x.is_nan() && y.is_nan()),
+        (Json::Str(x), Json::Str(y)) => x == y,
+        (Json::List(x), Json::List(y)) => {
+            x.len() == y.len() && x.iter().zip(y.iter()).all(|(xe, ye)| deepequal(xe, ye))
+        }
+        (Json::Map(x), Json::Map(y)) => {
+            x.len() == y.len()
+                && x.iter()
+                    .all(|(key, val)| y.get(key).map(|other| deepequal(val, other)).unwrap_or(false))
+        }
+        _ => false,
+    }
+}
+
+/// Render a number the same way in every port: 5.0 prints as 5.
+pub fn numstr(val: f64) -> String {
+    if val.is_nan() || val.is_infinite() {
+        return "null".to_string();
+    }
+    if val == val.trunc() && val.abs() < 9007199254740992.0 {
+        return format!("{}", val as i64);
+    }
+    format!("{}", val)
+}
+
+/// Render a string as a JSON string literal.
+pub fn quote(val: &str) -> String {
+    let mut out = String::from("\"");
+    for char in val.chars() {
+        match char {
+            '"' => out.push_str("\\\""),
+            '\\' => out.push_str("\\\\"),
+            '\n' => out.push_str("\\n"),
+            '\r' => out.push_str("\\r"),
+            '\t' => out.push_str("\\t"),
+            _ => {
+                if (char as u32) < 0x20 {
+                    out.push_str(&format!("\\u{:04x}", char as u32));
+                } else {
+                    out.push(char);
+                }
+            }
+        }
+    }
+    out.push('"');
+    out
+}
+
+/// Compact JSON text with map keys sorted, identical in every port.
+pub fn jsonstr(val: &Json) -> String {
+    match val {
+        Json::Absent => "undefined".to_string(),
+        Json::Null => "null".to_string(),
+        Json::Bool(flag) => (if *flag { "true" } else { "false" }).to_string(),
+        Json::Num(num) => numstr(*num),
+        Json::Str(text) => quote(text),
+        Json::List(list) => {
+            let parts: Vec<String> = list.iter().map(jsonstr).collect();
+            format!("[{}]", parts.join(","))
+        }
+        Json::Map(map) => {
+            // BTreeMap iterates in key order, so this is already sorted.
+            let parts: Vec<String> = map
+                .iter()
+                .map(|(key, entry)| format!("{}:{}", quote(key), jsonstr(entry)))
+                .collect();
+            format!("{{{}}}", parts.join(","))
+        }
+    }
+}
+
+/// Strings verbatim, everything else as compact JSON.
+pub fn stringify(val: &Json) -> String {
+    match val {
+        Json::Str(text) => text.clone(),
+        other => jsonstr(other),
+    }
+}
+
+/// Render a path as a dotted string.
+pub fn pathify(path: &[String]) -> String {
+    path.join(".")
+}

package/project/.sdk/tm/rust/utility/prepare_method.rs

@@ -24,7 +24,11 @@ pub fn prepare_method_util(ctx: &Rc<Context>) -> String {
         "list" => "GET",
         "remove" => "DELETE",
         "patch" => "PATCH",
-        _ => "GET",
+        // An op the API does not define resolves NO method - ts answers
+        // undefined here, and "" is rust's spelling of the same "no value"
+        // (the corpus pins this via primary.prepareMethod). A `GET`
+        // catch-all here silently gave every unknown op a method.
+        _ => "",
     }
     .to_string()
 }

package/project/.sdk/tm/scala/Makefile

@@ -1,21 +1,31 @@
-.PHONY: test build lint clean corpus
+.PHONY: test build lint clean corpus smoke
 
-# Compile the whole SDK (runtime + test runners) via scala-cli.
+# Compile the whole SDK (runtime + test runners + the vendored omni corpus
+# engine under sdktest/vendor/omni) via scala-cli. scala-cli compiles every
+# .scala/.java file under the project directory, so the vendored tree needs
+# no build-file entry of its own.
 build:
 	scala-cli compile .
 
-# Run the runtime test suite (plain scala-cli main), the generated per-entity
-# entity/direct tests (SdkEntityTestMain), then the shared struct corpus
-# (vendored voxgig struct against ../.sdk/test/test.json). Any one reporting a
-# failure exits non-zero.
+# Run, in order: the omni SMOKE test (the vendored corpus engine must be able
+# to FAIL a bad entry, or every corpus run below is vacuously green), the
+# runtime test suite, the generated per-entity entity/direct tests, the shared
+# struct corpus and the primary-utility corpus. Any one reporting a failure
+# exits non-zero.
 test:
+	scala-cli run . --main-class OmniSmoke
 	scala-cli run . --main-class SdkTestMain
 	scala-cli run . --main-class SdkEntityTestMain
 	scala-cli run . --main-class Runner -- ../.sdk/test/test.json
 	scala-cli run . --main-class PrimaryCorpusMain -- ../.sdk/test/test.json
 
+# The vendored omni engine alone: proves the corpus runner can still fail.
+smoke:
+	scala-cli run . --main-class OmniSmoke
+
 corpus:
 	scala-cli run . --main-class Runner -- ../.sdk/test/test.json
+	scala-cli run . --main-class PrimaryCorpusMain -- ../.sdk/test/test.json
 
 # "Lint": a clean compile means the code type-checks.
 lint: