@voxgig/sdkgen 4.8.1 → 4.8.3

package/project/.sdk/tm/lua/test/struct_utility_test.lua

@@ -1,16 +1,24 @@
--- Vendored from voxgig/struct/lua
+-- ProjectName SDK struct utility test
+--
+-- The struct corpus drives the LIVE SDK's vendored struct utilities
+-- through the vendored omni runner, via the resolver in test/omni.lua
+-- (struct-runner shape over native vendored omni; test/struct_runner.lua
+-- is retired - see docs/design/vendor-tag-rollout.md). Mirrors upstream
+-- struct/lua's own test/struct_test.lua at the shared tag.
 
 local assert = require("luassert")
 
-local vs = require("utility.struct.struct")
+local sdk = require("project-name-_sdk")
 
-local runnerModule = require("test.struct_runner")
-local makeRunner, nullModifier, NULLMARK, JSON_NULL = runnerModule.makeRunner,
-    runnerModule.nullModifier, runnerModule.NULLMARK, runnerModule.JSON_NULL
-local StructTestClient = runnerModule.StructTestClient
+local runnerModule = require("test.omni")
+local makeRunner, nullModifier = runnerModule.makeRunner, runnerModule.nullModifier
+-- Spec entries arrive in the runner's own value model, where a JSON null
+-- is a sentinel rather than a lua nil. The skip guards below have to
+-- compare against it.
+local JSON_NULL = runnerModule.JSON_NULL
+local tostructval = runnerModule.tostruct
 
-local _test_dir = debug.getinfo(1, "S").source:match("^@(.+/)") or "./"
-local TEST_JSON_FILE = _test_dir .. "../../.sdk/test/test.json"
+local TEST_JSON_FILE = "../../.sdk/test/test.json"
 
 ----------------------------------------------------------
 -- Helper Functions
@@ -36,19 +44,73 @@ local function object(t)
   })
 end
 
+----------------------------------------------------------
+-- Entries this port cannot express
+----------------------------------------------------------
+
+-- Lua has ONE `nil`. The corpus distinguishes JSON null from absent, and
+-- a lua table cannot hold a nil at all, so a handful of entries have no
+-- representation here. `NOVAL` (vendored struct) covers the ARGUMENT side
+-- - `typify()` against `typify(null)` - but not the RESULT side: a
+-- function that returns nothing and one that returns JSON null both
+-- return `nil`, and the runner reads it as ABSENT (the cheaper side by a
+-- wide margin, measured upstream: reading it as null costs 43 entries,
+-- reading it as absent costs the few named below).
+--
+-- Rather than mark whole groups pending and lose the other entries in
+-- them, the individual entries are dropped and named here.
+--
+-- Each drop is GUARDED. Corpus indexes are positional, so if the corpus
+-- gains or reorders an entry the guard fires and says so, instead of
+-- quietly skipping a different entry and reporting green.
+local function dropentries(group, drops)
+  assert.is_true(nil ~= group, "corpus group missing")
+  local set = group.set
+  assert.is_true(nil ~= set, "corpus group has no set")
+
+  -- Descending, so each removal leaves the earlier indexes alone.
+  for i = #drops, 1, -1 do
+    local drop = drops[i]
+    local entry = set[drop.at + 1]
+    assert.is_true(
+      nil ~= entry and drop.is(entry),
+      "corpus moved under a skip: " .. drop.why .. " is no longer at index " .. drop.at
+    )
+    table.remove(set, drop.at + 1)
+  end
+
+  return group
+end
+
+-- Helpers the guards use. `dropentries` mutates the spec node in place, so
+-- a group must be dropped from once; a second pass would find the entry
+-- gone and the guard would say so.
+local function isnull(val)
+  return JSON_NULL == val
+end
+local function entryin(entry, path)
+  local at = entry["in"]
+  for part in path:gmatch("[^%.]+") do
+    if type(at) ~= "table" then
+      return nil
+    end
+    at = at[part]
+  end
+  return at
+end
+
 ----------------------------------------------------------
 -- Test Suite
 ----------------------------------------------------------
 
 describe("struct", function()
-  local struct_test_client = StructTestClient.new()
-  local runner = makeRunner(TEST_JSON_FILE, struct_test_client)
+  local runner = makeRunner(TEST_JSON_FILE, sdk.test(nil, nil))
 
   local runnerStruct = runner('struct')
   local spec, runset, runsetflags, client = runnerStruct.spec,
       runnerStruct.runset, runnerStruct.runsetflags, runnerStruct.client
 
-  local struct_util = client:utility().struct
+  local struct_util = client.utility().struct
   -- Extract test specifications for different function groups
   local clone = struct_util.clone
   local delprop = struct_util.delprop
@@ -140,15 +202,30 @@ describe("struct", function()
     assert.equal("function", type(strkey))
     assert.equal("function", type(stringify))
     assert.equal("function", type(transform))
-    assert.equal("function", type(typify))
     assert.equal("function", type(typename))
-
+    assert.equal("function", type(typify))
     assert.equal("function", type(validate))
     assert.equal("function", type(walk))
   end)
 
+
+  -- STRUCT NULLSEM, deliberately NOT a lane here (ts/js/go/py carry one).
+  --
+  -- The struct.nullsem section asks whether a PRESENT key holding a JSON
+  -- null reads as "no value". Lua cannot EXPRESS a stored null at all: a
+  -- lua table cannot hold nil, so `{a = nil}` IS `{}` and `[10, null,
+  -- 30]` has no representation (the runner boundary rewrites list nulls
+  -- to the string "null", which answers the WRONG way on the corpus's
+  -- getelem lanes). Measured against the vendored struct: getprop /
+  -- getelem / getpath / haskey / keysof over a "stored null" all answer
+  -- as ABSENT, vacuously - the null was never stored. A lane would
+  -- assert nothing about null semantics, so it is skipped OUT LOUD
+  -- instead of passing vacuously.
+  pending("nullsem: lua cannot express a stored JSON null - see comment")
+
+
   ----------------------------------------------------------
-  -- Minor Function Tests
+  -- Minor Tests
   ----------------------------------------------------------
 
   test("minor-isnode", function()
@@ -189,23 +266,23 @@ describe("struct", function()
 
   test("minor-isfunc", function()
     runset(minorSpec.isfunc, isfunc)
-
-    -- Additional explicit function tests
-    local f0 = function()
-      return nil
-    end
-
-    assert.equal(isfunc(f0), true)
-    assert.equal(isfunc(function()
-      return nil
-    end), true)
   end)
 
 
   test("minor-clone", function()
-    runsetflags(minorSpec.clone, {
-      null = false
-    }, clone)
+    runsetflags(
+      dropentries(minorSpec.clone, {
+        -- `clone(null)`, which must give back null. The port returns nil,
+        -- read as absent. (`clone()` with NO argument passes - NOVAL.)
+        { at = 5, why = "clone(null)", is = function(entry)
+          return isnull(entry["in"]) and isnull(entry.out)
+        end },
+      }),
+      {
+        null = false
+      },
+      clone
+    )
 
     -- Additional function cloning test
     local f0 = function()
@@ -213,7 +290,7 @@ describe("struct", function()
     end
 
     local original = {
-      a = f0
+      a = f0,
     }
     local copied = clone(original)
     assert.are.same(original, copied)
@@ -222,8 +299,12 @@ describe("struct", function()
 
   test("minor-filter", function()
     local checkmap = {
-      gt3 = function(n) return n[2] > 3 end,
-      lt3 = function(n) return n[2] < 3 end,
+      gt3 = function(n)
+        return n[2] > 3
+      end,
+      lt3 = function(n)
+        return n[2] < 3
+      end,
     }
     runset(minorSpec.filter, function(vin)
       return filter(vin.val, checkmap[vin.check])
@@ -244,38 +325,30 @@ describe("struct", function()
 
 
   test("minor-escurl", function()
-    runset(minorSpec.escurl, function(vin)
-      -- Ensure spaces are properly replaced like in the Go implementation
-      return escurl(vin):gsub("+", "%%20")
-    end)
+    runset(minorSpec.escurl, escurl)
   end)
 
 
   test("minor-stringify", function()
-    runset(minorSpec.stringify, function(vin)
-      if NULLMARK == vin.val then
-        return stringify("null", vin.max)
-      else
-        return stringify(vin.val, vin.max)
-      end
+    -- null = true so a JSON null `val` arrives as NULLMARK;
+    -- stringify(NULLMARK) is "null" (canonical TS stringify(null) ===
+    -- "null"), while an absent val (nil) is "".
+    runsetflags(minorSpec.stringify, {
+      null = true
+    }, function(vin)
+      return stringify(vin.val, vin.max)
     end)
   end)
 
 
-  test('minor-pathify', function()
+  test("minor-pathify", function()
+    -- null = true so a JSON null path arrives as NULLMARK. pathify treats
+    -- NULLMARK as a scalar (not a key), so null path elements are dropped
+    -- via iskey and a top-level null renders as <unknown-path:null>.
     runsetflags(minorSpec.pathify, {
       null = true
     }, function(vin)
-      local path
-      if NULLMARK == vin.path then
-        path = nil
-      else
-        path = vin.path
-      end
-
-      local pathstr = pathify(path, vin.from):gsub('__NULL__%.', '')
-      pathstr = NULLMARK == vin.path and pathstr:gsub('>', ':null>') or pathstr
-      return pathstr
+      return pathify(vin.path, vin.from)
     end)
   end)
 
@@ -293,7 +366,19 @@ describe("struct", function()
 
 
   test("minor-getprop", function()
-    runsetflags(minorSpec.getprop, {
+    runsetflags(
+      dropentries(minorSpec.getprop, {
+        -- A null `alt`, which getprop must hand straight back. The port
+        -- receives it as nil and returns nil, read as absent. The other
+        -- entries - every missing-key case among them - pass.
+        { at = 50, why = "getprop with a null alt", is = function(entry)
+          return "x" == entryin(entry, "key") and isnull(entryin(entry, "alt"))
+        end },
+        { at = 51, why = "getprop with a null key and a null alt", is = function(entry)
+          return isnull(entryin(entry, "key")) and isnull(entryin(entry, "alt"))
+        end },
+      }),
+      {
       null = false
     }, function(vin)
       if vin.alt == nil then
@@ -371,16 +456,11 @@ describe("struct", function()
 
 
   test("minor-typify", function()
-    -- Filter out JSON null 'in' entries: Lua typify(nil) returns T_null,
-    -- but TS typify(null) returns T_scalar|T_null.
-    local filtered = { set = {} }
-    setmetatable(filtered.set, { __jsontype = "array" })
-    for _, entry in ipairs(minorSpec.typify.set) do
-      if entry["in"] ~= JSON_NULL then
-        table.insert(filtered.set, entry)
-      end
-    end
-    runsetflags(filtered, {
+    -- null = false so a JSON null `in` arrives as nil; typify(nil) is
+    -- T_scalar|T_null, matching canonical TS typify(null). The
+    -- typify(undefined)==T_noval entry has no `in` and reaches the
+    -- subject as NOVAL (resolver decision 4), answering T_noval.
+    runsetflags(minorSpec.typify, {
       null = false
     }, typify)
   end)
@@ -467,7 +547,7 @@ describe("struct", function()
   ----------------------------------------------------------
 
   test("walk-log", function()
-    local walktest = clone(walkSpec.log)
+    local walktest = tostructval(walkSpec.log)
 
     local function walklog(key, val, parent, path)
       return "k=" .. stringify(key) .. ", v=" .. stringify(val) .. ", p=" ..
@@ -577,7 +657,7 @@ describe("struct", function()
   ----------------------------------------------------------
 
   test("merge-basic", function()
-    local mergetest = clone(mergeSpec.basic)
+    local mergetest = tostructval(mergeSpec.basic)
     assert.same(mergetest.out, merge(mergetest['in']))
   end)
 
@@ -685,7 +765,7 @@ describe("struct", function()
   ----------------------------------------------------------
 
   test("inject-basic", function()
-    local injecttest = clone(injectSpec.basic)
+    local injecttest = tostructval(injectSpec.basic)
     assert.same(injecttest.out, inject(injecttest['in'].val, injecttest['in'].store))
   end)
 
@@ -710,7 +790,7 @@ describe("struct", function()
   ----------------------------------------------------------
 
   test("transform-basic", function()
-    local transformtest = clone(transformSpec.basic)
+    local transformtest = tostructval(transformSpec.basic)
     assert.same(transform(transformtest['in'].data, transformtest['in'].spec),
       transformtest.out)
   end)
@@ -772,7 +852,6 @@ describe("struct", function()
           -- Modify string values by adding '@' prefix
           if key ~= nil and parent ~= nil and type(val) == "string" then
             parent[key] = "@" .. val
-            local modified_val = parent[key]
           end
         end
       })
@@ -842,9 +921,21 @@ describe("struct", function()
   ----------------------------------------------------------
 
   test("validate-basic", function()
-    runsetflags(validateSpec.basic, { null = false }, function(vin)
-      return validate(vin.data, vin.spec)
-    end)
+    runsetflags(
+      dropentries(validateSpec.basic, {
+        -- `$NULL` against null data: validate returns the null, the port
+        -- returns nil, read as absent. (`$NULL` against non-null data at
+        -- a later index still runs - the error path needs no stored
+        -- null.)
+        { at = 13, why = "$NULL validating null data", is = function(entry)
+          return "`$NULL`" == entryin(entry, "spec") and isnull(entryin(entry, "data"))
+        end },
+      }),
+      { null = false },
+      function(vin)
+        return validate(vin.data, vin.spec)
+      end
+    )
   end)
 
 

package/project/.sdk/tm/lua/test/vendor/omni/json.lua

@@ -0,0 +1,268 @@
+-- VENDORED: @voxgig/omni sdk-20260904-1610-0 (lua/src/json.lua)
+-- 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 and 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.
+--
+-- Lua tables cannot hold nil, and cannot tell an empty list from an empty
+-- map, so the model is explicit: NULL and ABSENT are sentinel values, and
+-- every container carries a metatable saying which it is.
+
+local M = {}
+
+local MAPMT = { __omni = 'map' }
+local LISTMT = { __omni = 'list' }
+
+-- A JSON null. Lua's own nil cannot be stored in a table.
+M.NULL = setmetatable({}, { __tostring = function() return 'NULL' end })
+
+-- No value at all, as distinct from a JSON null.
+M.ABSENT = setmetatable({}, { __tostring = function() return 'ABSENT' end })
+
+--- Tag a table as a JSON object.
+function M.map(entries)
+  return setmetatable(entries or {}, MAPMT)
+end
+
+--- Tag a table as a JSON array.
+function M.list(entries)
+  return setmetatable(entries or {}, LISTMT)
+end
+
+function M.ismap(val)
+  return 'table' == type(val) and MAPMT == getmetatable(val)
+end
+
+function M.islist(val)
+  return 'table' == type(val) and LISTMT == getmetatable(val)
+end
+
+function M.isnode(val)
+  return M.ismap(val) or M.islist(val)
+end
+
+function M.isabsent(val)
+  return nil == val or M.ABSENT == val
+end
+
+function M.isnull(val)
+  return M.NULL == val
+end
+
+function M.isnone(val)
+  return M.isabsent(val) or M.isnull(val)
+end
+
+--- A JSON number? Booleans are not numbers.
+function M.isnum(val)
+  return 'number' == type(val)
+end
+
+function M.isstr(val)
+  return 'string' == type(val)
+end
+
+--- Read a map entry. Returns ABSENT when missing.
+function M.get(val, key)
+  if not M.ismap(val) then
+    return M.ABSENT
+  end
+  local entry = rawget(val, key)
+  if nil == entry then
+    return M.ABSENT
+  end
+  return entry
+end
+
+function M.has(val, key)
+  return M.ismap(val) and nil ~= rawget(val, key)
+end
+
+-- ---- parser ----------------------------------------------------------
+
+local function skipws(text, pos)
+  local at = pos
+  while at <= #text do
+    local ch = text:sub(at, at)
+    if ' ' == ch or '\t' == ch or '\n' == ch or '\r' == ch then
+      at = at + 1
+    else
+      break
+    end
+  end
+  return at
+end
+
+local parsevalue
+
+local function parseword(text, pos, word, value)
+  if word == text:sub(pos, pos + #word - 1) then
+    return value, pos + #word
+  end
+  error('omni: bad JSON literal at ' .. pos, 0)
+end
+
+local function parsestring(text, pos)
+  if '"' ~= text:sub(pos, pos) then
+    error('omni: expected string at ' .. pos, 0)
+  end
+
+  local at = pos + 1
+  local out = {}
+
+  while at <= #text do
+    local ch = text:sub(at, at)
+
+    if '"' == ch then
+      return table.concat(out), at + 1
+    end
+
+    if '\\' ~= ch then
+      out[#out + 1] = ch
+      at = at + 1
+    else
+      local escape = text:sub(at + 1, at + 1)
+      at = at + 2
+
+      if '"' == escape then
+        out[#out + 1] = '"'
+      elseif '\\' == escape then
+        out[#out + 1] = '\\'
+      elseif '/' == escape then
+        out[#out + 1] = '/'
+      elseif 'b' == escape then
+        out[#out + 1] = '\b'
+      elseif 'f' == escape then
+        out[#out + 1] = '\f'
+      elseif 'n' == escape then
+        out[#out + 1] = '\n'
+      elseif 'r' == escape then
+        out[#out + 1] = '\r'
+      elseif 't' == escape then
+        out[#out + 1] = '\t'
+      elseif 'u' == escape then
+        local code = tonumber(text:sub(at, at + 3), 16)
+        at = at + 4
+        if nil == code then
+          error('omni: bad JSON unicode escape', 0)
+        end
+        out[#out + 1] = utf8 and utf8.char(code) or string.char(code % 256)
+      else
+        error('omni: bad JSON escape at ' .. at, 0)
+      end
+    end
+  end
+
+  error('omni: unterminated JSON string', 0)
+end
+
+local function parsemap(text, pos)
+  local out = M.map({})
+  local at = skipws(text, pos + 1)
+
+  if '}' == text:sub(at, at) then
+    return out, at + 1
+  end
+
+  while true do
+    at = skipws(text, at)
+    local key
+    key, at = parsestring(text, at)
+    at = skipws(text, at)
+
+    if ':' ~= text:sub(at, at) then
+      error('omni: expected \':\' at ' .. at, 0)
+    end
+
+    local value
+    value, at = parsevalue(text, skipws(text, at + 1))
+    rawset(out, key, value)
+    at = skipws(text, at)
+
+    local ch = text:sub(at, at)
+    if ',' == ch then
+      at = at + 1
+    elseif '}' == ch then
+      return out, at + 1
+    else
+      error('omni: expected \',\' or \'}\' at ' .. at, 0)
+    end
+  end
+end
+
+local function parselist(text, pos)
+  local out = M.list({})
+  local at = skipws(text, pos + 1)
+
+  if ']' == text:sub(at, at) then
+    return out, at + 1
+  end
+
+  while true do
+    local value
+    value, at = parsevalue(text, skipws(text, at))
+    out[#out + 1] = value
+    at = skipws(text, at)
+
+    local ch = text:sub(at, at)
+    if ',' == ch then
+      at = at + 1
+    elseif ']' == ch then
+      return out, at + 1
+    else
+      error('omni: expected \',\' or \']\' at ' .. at, 0)
+    end
+  end
+end
+
+local function parsenumber(text, pos)
+  local span = text:match('^[-+]?[0-9]*%.?[0-9]+[eE]?[-+]?[0-9]*', pos)
+  if nil == span then
+    error('omni: bad JSON number at ' .. pos, 0)
+  end
+  local value = tonumber(span)
+  if nil == value then
+    error('omni: bad JSON number [' .. span .. '] at ' .. pos, 0)
+  end
+  return value, pos + #span
+end
+
+parsevalue = function(text, pos)
+  if pos > #text then
+    error('omni: unexpected end of JSON', 0)
+  end
+
+  local ch = text:sub(pos, pos)
+
+  if '{' == ch then
+    return parsemap(text, pos)
+  elseif '[' == ch then
+    return parselist(text, pos)
+  elseif '"' == ch then
+    return parsestring(text, pos)
+  elseif 't' == ch then
+    return parseword(text, pos, 'true', true)
+  elseif 'f' == ch then
+    return parseword(text, pos, 'false', false)
+  elseif 'n' == ch then
+    return parseword(text, pos, 'null', M.NULL)
+  end
+
+  return parsenumber(text, pos)
+end
+
+--- Parse JSON text into the omni value model.
+function M.parse(text)
+  local value, pos = parsevalue(text, skipws(text, 1))
+  pos = skipws(text, pos)
+
+  if pos <= #text then
+    error('omni: trailing JSON content at ' .. pos, 0)
+  end
+
+  return value
+end
+
+return M