@voxgig/sdkgen 4.2.8 → 4.4.0

package/project/.sdk/tm/zig/test/struct_runner.zig

@@ -2,6 +2,7 @@
 // against subject functions, mirroring the TS/Go runner pattern.
 
 const std = @import("std");
+const regex = @import("../utility/voxgigstruct/regex.zig");
 const voxgig_struct = @import("voxgig-struct");
 
 const Allocator = std.mem.Allocator;
@@ -20,6 +21,22 @@ pub const Subject = *const fn (StdJsonValue) StdJsonValue;
 // Subject that takes an allocator and our JsonValue type.
 pub const AllocSubject = *const fn (Allocator, JsonValue) JsonValue;
 
+/// A subject that receives the whole corpus ENTRY and returns std.json.
+///
+/// `published` is an out-parameter for the context the subject built. std.json
+/// maps cannot be mutated in place safely from here — a put may reallocate the
+/// backing store and the caller would never see it — so a section that needs a
+/// `match: ctx.*` assertion hands its ctx back through this instead.
+pub const EntrySubject = *const fn (
+    Allocator,
+    StdJsonValue,
+    *?StdJsonValue,
+    /// The SDK's own error message. Zig errors carry no payload, so
+    /// @errorName gives the tag ("Sdk") and never the text the corpus matches
+    /// on. A subject that fails writes ctx.pending_err's message here.
+    *?[]const u8,
+) anyerror!StdJsonValue;
+
 pub const Spec = struct {
     data: StdJsonValue,
 
@@ -35,6 +52,8 @@ pub const RunPack = struct {
     spec: Spec,
     allocator: Allocator,
     file_data: []const u8,
+    /// Cases actually executed, so a suite can assert it ran something.
+    ran: usize = 0,
     parsed: std.json.Parsed(StdJsonValue),
 
     /// Run all entries in testspec.set against the subject function (no alloc, std types).
@@ -125,6 +144,101 @@ pub const RunPack = struct {
         }
     }
 
+    /// Drive a section whose entries carry ctx/args/match/err.
+    ///
+    /// The subject receives the whole ENTRY, not the resolved args, because an
+    /// args-style section has to publish the context it builds back onto the
+    /// entry — a `match: ctx.*` assertion reads it from there.
+    pub fn runsetEntry(self: *RunPack, testspec: StdJsonValue, subject: EntrySubject) !void {
+        const set_val = switch (testspec) {
+            .object => |obj| obj.get("set") orelse return,
+            else => return,
+        };
+        if (set_val != .array) return;
+
+        var failures: usize = 0;
+
+        for (set_val.array.items, 0..) |entry_val, entry_idx| {
+            if (entry_val != .object) continue;
+            const entry = entry_val.object;
+
+            var arena = std.heap.ArenaAllocator.init(self.allocator);
+            defer arena.deinit();
+            const alloc = arena.allocator();
+
+            const err_field = entry.get("err");
+
+            self.ran += 1;
+            var published: ?StdJsonValue = null;
+            var errmsg: ?[]const u8 = null;
+
+            const res = subject(alloc, entry_val, &published, &errmsg) catch |e| {
+                // An expected error: match its text, then any `match` block.
+                if (err_field) |ef| {
+                    const msg = errmsg orelse @errorName(e);
+                    if (ef == .bool and ef.bool) continue;
+                    if (matchval(alloc, ef, StdJsonValue{ .string = msg })) continue;
+                    std.debug.print("\n  ERROR MATCH [entry {d}]: [{s}] <=> [{s}]\n", .{
+                        entry_idx, fmtJson(ef), msg,
+                    });
+                }
+                failures += 1;
+                continue;
+            };
+
+            if (err_field != null) {
+                std.debug.print("\n  expected an error [entry {d}]\n", .{entry_idx});
+                failures += 1;
+                continue;
+            }
+
+            var matched = false;
+
+            if (entry.get("match")) |m| {
+                var subj = std.json.ObjectMap.init(alloc);
+                subj.put("out", res) catch {};
+                if (entry.get("in")) |v| subj.put("in", v) catch {};
+                if (published) |p| {
+                    subj.put("ctx", p) catch {};
+                } else if (entry.get("ctx")) |v| {
+                    subj.put("ctx", v) catch {};
+                }
+                const subjval = StdJsonValue{ .object = subj };
+
+                var path = std.ArrayList([]const u8).init(alloc);
+                doMatch(alloc, m, subjval, &path) catch {
+                    std.debug.print("  [entry {d}]\n", .{entry_idx});
+                    failures += 1;
+                    continue;
+                };
+                matched = true;
+            }
+
+            const raw_out = entry.get("out");
+
+            if (raw_out) |o| {
+                if (jsonEqual(o, res)) continue;
+                if (o == .string and std.mem.eql(u8, o.string, NULLMARK) and res == .null) continue;
+                std.debug.print("\n  FAIL [entry {d}]: expected {s} got {s}\n", .{
+                    entry_idx, fmtJson(o), fmtJson(res),
+                });
+                failures += 1;
+            } else if (!matched) {
+                // NO `out` MEANS EXPECT NULL, not "assert nothing". The
+                // reference sets a missing out to the null marker before
+                // running, so an entry like {"ctx": {"opname": "bad"}} asserts
+                // that the utility yields nothing.
+                if (res == .null) continue;
+                std.debug.print("\n  FAIL [entry {d}]: expected null got {s}\n", .{
+                    entry_idx, fmtJson(res),
+                });
+                failures += 1;
+            }
+        }
+
+        if (0 < failures) return error.SectionFailed;
+    }
+
     pub fn deinit(self: *RunPack) void {
         self.parsed.deinit();
         self.allocator.free(self.file_data);
@@ -136,6 +250,29 @@ pub const Flags = struct {
     undef_as_null: bool = true,
 };
 
+/// Load test.json and return a named top-level spec section.
+///
+/// makeRunner is this with "struct" baked in. The primary-utility suite needs
+/// "primary" from the same file, and duplicating the load would give the two
+/// suites separate copies of a corpus that is meant to be shared.
+pub fn makeRunnerFor(allocator: Allocator, section: []const u8) !RunPack {
+    const data = try std.fs.cwd().readFileAlloc(allocator, TEST_JSON_FILE, 10 * 1024 * 1024);
+    const parsed = try std.json.parseFromSlice(StdJsonValue, allocator, data, .{});
+    const root = parsed.value;
+
+    const spec_val = switch (root) {
+        .object => |obj| obj.get(section) orelse return error.NoSectionInTestJson,
+        else => return error.TestJsonNotObject,
+    };
+
+    return RunPack{
+        .spec = Spec{ .data = spec_val },
+        .allocator = allocator,
+        .file_data = data,
+        .parsed = parsed,
+    };
+}
+
 /// Load test.json and return the "struct" spec.
 pub fn makeRunner(allocator: Allocator) !RunPack {
     const path = TEST_JSON_FILE;
@@ -156,6 +293,107 @@ pub fn makeRunner(allocator: Allocator) !RunPack {
     };
 }
 
+// ---- Corpus matching: matchval / doMatch ----
+//
+// The primary corpus asserts with `match` as often as with `out`, and its
+// error expectations are regexes. runsetAlloc resolved only `in`, had no
+// match support and silently skipped any entry carrying `err` — so it could
+// drive the struct corpus but not this one. Semantics are the reference's:
+// exact equality first, then __UNDEF__/__EXISTS__ markers, then a /regex/, and
+// finally a case-insensitive substring.
+
+fn stringifyAlloc(alloc: Allocator, v: StdJsonValue) []const u8 {
+    var buf = std.ArrayList(u8).init(alloc);
+    if (v == .string) return v.string;
+    std.json.stringify(v, .{}, buf.writer()) catch return "";
+    return buf.items;
+}
+
+pub fn matchval(alloc: Allocator, check: StdJsonValue, base: StdJsonValue) bool {
+    if (jsonEqual(check, base)) return true;
+
+    if (check == .string) {
+        const c = check.string;
+        if (std.mem.eql(u8, c, UNDEFMARK)) return base == .null;
+        if (std.mem.eql(u8, c, EXISTSMARK)) return base != .null;
+
+        const basestr = stringifyAlloc(alloc, base);
+
+        // A /pattern/ is a regex over the stringified base.
+        if (2 <= c.len and c[0] == '/' and c[c.len - 1] == '/') {
+            const pat = c[1 .. c.len - 1];
+            var re = regex.compile(alloc, pat) orelse return false;
+            defer re.deinit();
+            return re.isMatch(basestr);
+        }
+
+        // Otherwise a case-insensitive substring, as the reference does.
+        const lc_base = std.ascii.allocLowerString(alloc, basestr) catch return false;
+        const lc_check = std.ascii.allocLowerString(alloc, c) catch return false;
+        return std.mem.indexOf(u8, lc_base, lc_check) != null;
+    }
+
+    return false;
+}
+
+fn getPath(base: StdJsonValue, path: []const []const u8) StdJsonValue {
+    var cur = base;
+    for (path) |seg| {
+        switch (cur) {
+            .object => |o| cur = o.get(seg) orelse return StdJsonValue{ .null = {} },
+            .array => |a| {
+                const idx = std.fmt.parseInt(usize, seg, 10) catch return StdJsonValue{ .null = {} };
+                if (idx >= a.items.len) return StdJsonValue{ .null = {} };
+                cur = a.items[idx];
+            },
+            else => return StdJsonValue{ .null = {} },
+        }
+    }
+    return cur;
+}
+
+/// Walk `check`; every LEAF must matchval against the same path in `base`.
+pub fn doMatch(
+    alloc: Allocator,
+    check: StdJsonValue,
+    base: StdJsonValue,
+    path: *std.ArrayList([]const u8),
+) !void {
+    switch (check) {
+        .object => |o| {
+            var it = o.iterator();
+            while (it.next()) |kv| {
+                try path.append(kv.key_ptr.*);
+                try doMatch(alloc, kv.value_ptr.*, base, path);
+                _ = path.pop();
+            }
+        },
+        .array => |a| {
+            for (a.items, 0..) |item, i| {
+                const seg = try std.fmt.allocPrint(alloc, "{d}", .{i});
+                try path.append(seg);
+                try doMatch(alloc, item, base, path);
+                _ = path.pop();
+            }
+        },
+        else => {
+            const baseval = getPath(base, path.items);
+            if (!matchval(alloc, check, baseval)) {
+                std.debug.print("\n  MATCH: {s}: [{s}] <=> [{s}]\n", .{
+                    joinPath(alloc, path.items),
+                    fmtJson(check),
+                    fmtJson(baseval),
+                });
+                return error.MatchMismatch;
+            }
+        },
+    }
+}
+
+fn joinPath(alloc: Allocator, parts: []const []const u8) []const u8 {
+    return std.mem.join(alloc, ".", parts) catch "?";
+}
+
 // ---- Result comparison (operates on std.json.Value) ----
 
 fn checkResult(expected: StdJsonValue, result: StdJsonValue) !void {

package/project/sdkgen-package.json

@@ -3,7 +3,7 @@
     "package": 1
   },
   "name": "@voxgig/sdkgen",
-  "version": "4.2.8",
+  "version": "4.4.0",
   "provides": {
     "target": [
       "c",

package/src/helpers/naming.ts

@@ -149,9 +149,9 @@ const RB_SDK_CONSTANTS = new Set<string>([
   'StructRunner', 'StructTestClient', 'StructUtilityTest', 'VoxgigStruct',
   'STRUCT_TEST_JSON_FILE',
   // the generated/templated test classes
-  'ExistsTest', 'FeatureTest', 'NetsimTest', 'PipelineTest',
-  'PrimaryUtilityTest', 'ReadmeExamplesTest', 'TestHookFeature',
-  'TestInitFeature',
+  'ExistsTest', 'FeatureCorpusTest', 'FeatureTest', 'NetsimTest',
+  'PipelineTest', 'PrimaryUtilityTest', 'ReadmeExamplesTest',
+  'TestHookFeature', 'TestInitFeature',
 ])
 
 
@@ -304,18 +304,59 @@ function isPhpReservedType(Name: string): boolean {
 }
 
 
-// A declarable PHP class name for a generated type: unchanged, unless PHP
-// reserves the word, in which case `Type` is appended (`Namespace` ->
-// `NamespaceType`). Mirrors rbSafeTypeName and swiftSafeTypeName deliberately
-// — same suffix, same "only rename on an actual collision" rule, so every SDK
-// that does not collide is byte-identical to before.
+// CLASSES THE GENERATED PHP SDK ITSELF DECLARES — the second half of "already
+// taken", exactly as RB_SDK_CONSTANTS is for ruby. `PHP_RESERVED_TYPES` covers
+// what the LANGUAGE owns; this covers what OUR OWN scaffolding claims, which a
+// keyword list can never catch.
+//
+// The generated PHP SDK uses NO NAMESPACES, and composer classmaps both the
+// runtime (`types/`) and the tests (`autoload-dev`: `test/`). An entity named
+// `feature_test` emits `class FeatureTest` in `<Sdk>Types.php` while
+// `tm/php/test/FeatureTest.php` declares one too: composer maps one name to
+// two files, and loading both fatals on redeclaration. Ruby's equivalent only
+// warns; PHP does not.
+//
+// Only UNPREFIXED, UNNAMESPACED declarations are listed. `ProjectNameUtility`
+// substitutes to `<Sdk>Utility`, which no bare entity type can equal, and
+// `utility/struct/Struct.php` and `test/StructRunner.php` declare inside a
+// namespace — neither is reachable from the global name an entity type takes.
+//
+// `php-sdk-classes.test.ts` re-derives this from the templates AND the
+// components and fails on drift, the same discipline as the rb and swift
+// guards, and for the same reason: a hand-collected list rots.
+//
+// Folded, and matched folded: PHP class names are case-insensitive, so
+// `FeatureTest` and `featuretest` are one identifier.
+const PHP_SDK_CLASSES = new Set<string>([
+  // the generated/templated test classes
+  'existstest', 'featurecorpustest', 'featuretest', 'netsimtest',
+  'pipelinetest', 'primaryutilitytest', 'readmeexamplestest',
+  'structutilitytest',
+  // helper classes those suites declare beside them
+  'ftclient', 'ftclock', 'ftctrl', 'ftentity', 'ftharness', 'ftrecorder',
+  'plclient', 'plentity', 'plentityitem',
+])
+
+
+// Does `Name` collide with a class the generated PHP SDK already declares?
+function isPhpSdkClass(Name: string): boolean {
+  return PHP_SDK_CLASSES.has(String(Name).toLowerCase())
+}
+
+
+// A declarable PHP class name for a generated type: unchanged, unless the name
+// is ALREADY TAKEN — by PHP itself, or by the SDK's own scaffolding — in which
+// case `Type` is appended (`Namespace` -> `NamespaceType`). Mirrors
+// rbSafeTypeName and swiftSafeTypeName deliberately — same suffix, same "only
+// rename on an actual collision" rule, so every SDK that does not collide is
+// byte-identical to before.
 //
 // Applied ONLY to the bare entity data class. Per-op type names already carry
-// their own suffix (`NamespaceLoadData`, `NamespaceCreateData`), which no
-// reserved word matches, and the entity ACCESSOR is a method rather than a
-// class — PHP resolves those separately — so the public surface is unchanged.
+// their own suffix (`NamespaceLoadData`, `NamespaceCreateData`), which neither
+// set matches, and the entity ACCESSOR is a method rather than a class — PHP
+// resolves those separately — so the public surface is unchanged.
 function phpSafeTypeName(Name: string): string {
-  return isPhpReservedType(Name) ? Name + 'Type' : Name
+  return isPhpReservedType(Name) || isPhpSdkClass(Name) ? Name + 'Type' : Name
 }
 
 
@@ -496,6 +537,7 @@ export {
   isSwiftSdkType,
   swiftSafeTypeName,
   isPhpReservedType,
+  isPhpSdkClass,
   phpSafeTypeName,
   isTsReservedType,
   tsSafeTypeName,

package/src/sdkgen.ts

@@ -59,7 +59,7 @@ import { collectDeps } from './helpers/collectDeps'
 import type { DepEntry } from './helpers/collectDeps'
 import { canonToType, canonToDtype, canonKey, canonScalarKey } from './helpers/canonType'
 import { OP_SUFFIX, opTypeName, opParams, ownPoint, opActions, entityActions, entityPath, opRequestShape, entityIdField, entityDataIdField, entityOps, entityPrimaryOp, pickExampleEntity, entityClassName, entityTypeCollisions, warnEntityTypeCollisions, deriveEntityNames, entityCollection } from './helpers/opShape'
-import { isReservedName, safeVarName, exampleVarName, phpEntityAccessor, entityCacheField, isRbCoreConstant, isRbSdkConstant, rbSafeTypeName, isSwiftSdkType, swiftSafeTypeName, isPhpReservedType, phpSafeTypeName, isTsReservedType, tsSafeTypeName, jsProp, jsOptProp, jsKey } from './helpers/naming'
+import { isReservedName, safeVarName, exampleVarName, phpEntityAccessor, entityCacheField, isRbCoreConstant, isRbSdkConstant, rbSafeTypeName, isSwiftSdkType, swiftSafeTypeName, isPhpReservedType, isPhpSdkClass, phpSafeTypeName, isTsReservedType, tsSafeTypeName, jsProp, jsOptProp, jsKey } from './helpers/naming'
 import { serverVariables, hasServerVariables } from './helpers/serverVars'
 import { primaryOpCall, idLiteral, matchArg, dataArg, litFor } from './helpers/opExample'
 import type { ExampleLang } from './helpers/opExample'
@@ -1126,6 +1126,7 @@ export {
   isSwiftSdkType,
   swiftSafeTypeName,
   isPhpReservedType,
+  isPhpSdkClass,
   phpSafeTypeName,
   isTsReservedType,
   tsSafeTypeName,