Extract generic test definition helpers (#39)

Author: sabino

PLAN.md

@@ -569,7 +569,7 @@ Exit criteria:
 
 - M0 is complete as the Zig `0.16.0` runtime scaffold.
 - M1 has started on stacked branches with native Zig artifact-first parser slices.
-- M1A has started with behavior-preserving `src/project/types.zig`, `src/project/selector.zig`, `src/project/manifest.zig`, `src/project/util.zig`, `src/project/config.zig`, `src/project/fs.zig`, `src/project/jinja.zig`, `src/project/resolve.zig`, and `src/project/parse.zig` extractions. `src/project/manifest.zig` owns selected-resource JSON and partial `manifest.json` writing with native tests for selected JSON shape, JSON escaping, exposure dependency ordering, disabled-resource filtering, and graph-map output. `src/project/util.zig` owns shared display, membership, append-dedup, string sorting, and narrow YAML scalar/list helpers. `src/project/config.zig` owns `dbt_project.yml` loading and project path/docs config parsing. `src/project/fs.zig` owns deterministic resource file discovery and Linux directory traversal helpers. `src/project/jinja.zig` owns lexical Jinja call, parenthesis, quoted string, and literal argument helpers while graph-aware scanning remains in `src/project.zig`. `src/project/resolve.zig` owns graph lookup/count helpers, low-level ref/source resolution helpers, and dependency-map mutation for refs, sources, and known macro dependencies. `src/project/parse.zig` owns narrow parser scalar helpers for YAML booleans, JSON-compatible scalar classification, generic-test YAML item names, and generic-test identity/name/hash helpers with native tests. `src/project.zig` remains the public parser/list facade and still owns most loader, resource parser, scanner, and resolver orchestration code until follow-up extractions move those pieces behind focused internal modules.
+- M1A has started with behavior-preserving `src/project/types.zig`, `src/project/selector.zig`, `src/project/manifest.zig`, `src/project/util.zig`, `src/project/config.zig`, `src/project/fs.zig`, `src/project/jinja.zig`, `src/project/resolve.zig`, and `src/project/parse.zig` extractions. `src/project/manifest.zig` owns selected-resource JSON and partial `manifest.json` writing with native tests for selected JSON shape, JSON escaping, exposure dependency ordering, disabled-resource filtering, and graph-map output. `src/project/util.zig` owns shared display, membership, append-dedup, string sorting, and narrow YAML scalar/list helpers. `src/project/config.zig` owns `dbt_project.yml` loading and project path/docs config parsing. `src/project/fs.zig` owns deterministic resource file discovery and Linux directory traversal helpers. `src/project/jinja.zig` owns lexical Jinja call, parenthesis, quoted string, and literal argument helpers while graph-aware scanning remains in `src/project.zig`. `src/project/resolve.zig` owns graph lookup/count helpers, low-level ref/source resolution helpers, and dependency-map mutation for refs, sources, and known macro dependencies. `src/project/parse.zig` owns narrow parser scalar helpers for YAML booleans, JSON-compatible scalar classification, generic-test YAML item names, generic-test definition construction/cloning, and generic-test identity/name/hash helpers with native tests. `src/project.zig` remains the public parser/list facade and still owns most loader, resource parser, scanner, and resolver orchestration code until follow-up extractions move those pieces behind focused internal modules.
 - `dxt parse` now targets the supported Tier 0 subset: project name/model paths/seed paths/macro paths, project and package model path configs for literal `+materialized`, `+tags`, and model/seed `+docs.node_color`, root-project model config overrides for installed packages, SQL model discovery, CSV seed discovery, installed package SQL model and CSV seed discovery from `dbt_packages`, source discovery, installed package source discovery, exposure discovery, installed package exposure discovery, project macro discovery, installed package macro discovery from `dbt_packages`, macro property YAML for project macro descriptions and arguments, project and package docs block discovery, literal `ref` to models or seeds, two-argument package refs, package-local refs in installed package models and exposures, unique installed-package fallback for unqualified refs, literal `source`, package-local sources in installed package models, unique installed-package fallback for unqualified sources, literal `doc` in project and package descriptions, inline `config(materialized=..., tags=...)`, known project/package-qualified/package-local macro call dependencies, narrow project and package YAML model properties for scalar descriptions, simple columns, tags, materialization, disabled SQL models, dbt-shaped `unique`, `not_null`, `accepted_values`, and `relationships` generic test nodes, model/test `refs` and `sources` artifact fields, dependency maps, and deterministic partial `manifest.json`. The manifest includes the v12 top-level maps needed by the M1 artifact shape and is covered by a pinned local dbt Manifest v12 schema slice. YAML generic test arguments are currently supported for scalar values plus inline and block lists required by public Jaffle Shop DuckDB-style tests.
 - `dxt ls` now lists dbt-selectable resources from the same parser graph with stable text/JSON output and basic name/FQN wildcards, tag wildcards, slash-aware `path:` wildcards, exact `package:`/`package:this`, `source:` wildcards including package-qualified source selectors, `exposure:` wildcards, `resource_type:`, `test_type:generic`, config materialization, comma intersection, whitespace union, multi-argument selector lists, repeated selector flags, leading/trailing `+` graph expansion, and exact exclude filters; macros are emitted in artifacts but not exposed as `ls` resources.
 - Synthetic fixtures cover one model, model refs, seed refs, source refs, exposure refs to models and sources, combined source/model YAML, inline config/tag selection, config materialization selection, comma-intersection selection, YAML model properties and columns, emitted `unique`, `not_null`, `accepted_values`, and `relationships` generic test nodes, project macro artifacts and macro properties, configured `macro-paths` replacing the default macro directory, installed package macros with package-qualified calls and package-local macro calls, installed package models, seeds, sources, docs, exposures, package YAML model properties, root package config overrides, and package-qualified/package-local refs/sources, macro calls recorded in model and macro `depends_on.macros`, docs blocks with literal `doc` descriptions, disabled models, disabled ref diagnostics, unmatched model-property warnings, duplicate model and docs diagnostics, unsupported dynamic ref/doc diagnostics, missing doc diagnostics, malformed docs block diagnostics, unresolved package macro diagnostics, and unsupported unknown macro-call diagnostics.

src/project.zig

@@ -46,8 +46,11 @@ const splitKeyValue = util.splitKeyValue;
 const parseInlineStringList = util.parseInlineStringList;
 const dupTrimmedScalar = util.dupTrimmedScalar;
 const sortStrings = util.sortStrings;
+const appendGenericTestDef = project_parse.appendGenericTestDef;
+const appendGenericTestDefClone = project_parse.appendGenericTestDefClone;
 const parseBool = project_parse.parseBool;
 const genericTestUniqueId = project_parse.genericTestUniqueId;
+const parseInlineGenericTestList = project_parse.parseInlineGenericTestList;
 const parseJsonScalar = project_parse.parseJsonScalar;
 const synthesizeGenericTestNames = project_parse.synthesizeGenericTestNames;
 const testNameFromYamlItem = project_parse.testNameFromYamlItem;
@@ -1504,37 +1507,6 @@ fn parseTagList(allocator: std.mem.Allocator, text: []const u8, tags: *std.Array
     }
 }
 
-fn parseInlineGenericTestList(allocator: std.mem.Allocator, value: []const u8, out: *std.ArrayList(GenericTestDef)) !void {
-    const trimmed = std.mem.trim(u8, value, " \t");
-    if (trimmed.len < 2 or trimmed[0] != '[' or trimmed[trimmed.len - 1] != ']') {
-        _ = try appendGenericTestDef(allocator, out, try dupTrimmedScalar(allocator, trimmed));
-        return;
-    }
-    var pieces = std.mem.splitScalar(u8, trimmed[1 .. trimmed.len - 1], ',');
-    while (pieces.next()) |piece| {
-        const item = std.mem.trim(u8, piece, " \t");
-        if (item.len != 0) _ = try appendGenericTestDef(allocator, out, try dupTrimmedScalar(allocator, item));
-    }
-}
-
-fn appendGenericTestDef(allocator: std.mem.Allocator, tests: *std.ArrayList(GenericTestDef), test_name: []const u8) !usize {
-    try tests.append(allocator, .{ .name = test_name });
-    return tests.items.len - 1;
-}
-
-fn appendGenericTestDefClone(graph: *Graph, tests: *std.ArrayList(GenericTestDef), source: GenericTestDef) !void {
-    var cloned = GenericTestDef{
-        .name = source.name,
-        .relationship_to = source.relationship_to,
-        .relationship_field = source.relationship_field,
-    };
-    errdefer cloned.accepted_values.deinit(graph.allocator);
-    for (source.accepted_values.items) |value| {
-        try cloned.accepted_values.append(graph.allocator, value);
-    }
-    try tests.append(graph.allocator, cloned);
-}
-
 fn appendMacroArgumentClone(graph: *Graph, arguments: *std.ArrayList(MacroArgument), source: MacroArgument) !void {
     for (arguments.items) |*existing| {
         if (std.mem.eql(u8, existing.name, source.name)) {

src/project/parse.zig

@@ -4,6 +4,7 @@ const util = @import("util.zig");
 
 const JsonScalar = types.JsonScalar;
 const GenericTestDef = types.GenericTestDef;
+const Graph = types.Graph;
 const dupTrimmedScalar = util.dupTrimmedScalar;
 
 pub fn parseBool(value: []const u8) !bool {
@@ -65,6 +66,37 @@ pub fn testNameFromYamlItem(allocator: std.mem.Allocator, value: []const u8) ![]
     return try dupTrimmedScalar(allocator, trimmed[0..colon]);
 }
 
+pub fn parseInlineGenericTestList(allocator: std.mem.Allocator, value: []const u8, out: *std.ArrayList(GenericTestDef)) !void {
+    const trimmed = std.mem.trim(u8, value, " \t");
+    if (trimmed.len < 2 or trimmed[0] != '[' or trimmed[trimmed.len - 1] != ']') {
+        _ = try appendGenericTestDef(allocator, out, try dupTrimmedScalar(allocator, trimmed));
+        return;
+    }
+    var pieces = std.mem.splitScalar(u8, trimmed[1 .. trimmed.len - 1], ',');
+    while (pieces.next()) |piece| {
+        const item = std.mem.trim(u8, piece, " \t");
+        if (item.len != 0) _ = try appendGenericTestDef(allocator, out, try dupTrimmedScalar(allocator, item));
+    }
+}
+
+pub fn appendGenericTestDef(allocator: std.mem.Allocator, tests: *std.ArrayList(GenericTestDef), test_name: []const u8) !usize {
+    try tests.append(allocator, .{ .name = test_name });
+    return tests.items.len - 1;
+}
+
+pub fn appendGenericTestDefClone(graph: *Graph, tests: *std.ArrayList(GenericTestDef), source: GenericTestDef) !void {
+    var cloned = GenericTestDef{
+        .name = source.name,
+        .relationship_to = source.relationship_to,
+        .relationship_field = source.relationship_field,
+    };
+    errdefer cloned.accepted_values.deinit(graph.allocator);
+    for (source.accepted_values.items) |value| {
+        try cloned.accepted_values.append(graph.allocator, value);
+    }
+    try tests.append(graph.allocator, cloned);
+}
+
 pub const GenericTestNames = struct {
     full: []const u8,
     compiled: []const u8,
@@ -264,6 +296,57 @@ test "testNameFromYamlItem reads scalar and mapping test names" {
     try std.testing.expectError(error.UnsupportedYaml, testNameFromYamlItem(allocator, "   "));
 }
 
+test "parseInlineGenericTestList reads scalar and inline generic tests" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+    const allocator = arena.allocator();
+
+    var tests: std.ArrayList(GenericTestDef) = .empty;
+    defer tests.deinit(allocator);
+    try parseInlineGenericTestList(allocator, "[unique, \"not_null\", ]", &tests);
+    try std.testing.expectEqual(@as(usize, 2), tests.items.len);
+    try std.testing.expectEqualStrings("unique", tests.items[0].name);
+    try std.testing.expectEqualStrings("not_null", tests.items[1].name);
+
+    var scalar: std.ArrayList(GenericTestDef) = .empty;
+    defer scalar.deinit(allocator);
+    try parseInlineGenericTestList(allocator, "'accepted_values'", &scalar);
+    try std.testing.expectEqual(@as(usize, 1), scalar.items.len);
+    try std.testing.expectEqualStrings("accepted_values", scalar.items[0].name);
+}
+
+test "appendGenericTestDefClone copies nested accepted values list" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+    const allocator = arena.allocator();
+
+    var source_values: std.ArrayList([]const u8) = .empty;
+    defer source_values.deinit(allocator);
+    try source_values.append(allocator, "placed");
+    try source_values.append(allocator, "returned");
+
+    const source = GenericTestDef{
+        .name = "accepted_values",
+        .accepted_values = source_values,
+        .relationship_to = "ref('customers')",
+        .relationship_field = "id",
+    };
+    var graph = Graph{ .allocator = allocator, .project_name = "demo" };
+    var clones: std.ArrayList(GenericTestDef) = .empty;
+    defer clones.deinit(allocator);
+
+    try appendGenericTestDefClone(&graph, &clones, source);
+    try source_values.append(allocator, "cancelled");
+
+    try std.testing.expectEqual(@as(usize, 1), clones.items.len);
+    try std.testing.expectEqualStrings("accepted_values", clones.items[0].name);
+    try std.testing.expectEqualStrings("ref('customers')", clones.items[0].relationship_to);
+    try std.testing.expectEqualStrings("id", clones.items[0].relationship_field);
+    try std.testing.expectEqual(@as(usize, 2), clones.items[0].accepted_values.items.len);
+    try std.testing.expectEqualStrings("placed", clones.items[0].accepted_values.items[0]);
+    try std.testing.expectEqualStrings("returned", clones.items[0].accepted_values.items[1]);
+}
+
 test "synthesizeGenericTestNames preserves short generic test identities" {
     var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
     defer arena.deinit();