Backlog/lib/zargs/build.zig

const std = @import("std");

pub fn build(b: *std.Build) void {
    const target = b.standardTargetOptions(.{});
    const optimize = b.standardOptimizeOption(.{});

    // Library module  
    const zargs_mod = b.addModule("zargs", .{
        .root_source_file = b.path("src/main.zig"),
        .target = target,
        .optimize = optimize,
    });

    // ArgumentType module for tests
    const arg_type_mod = b.addModule("ArgumentType", .{
        .root_source_file = b.path("src/ArgumentType.zig"),
        .target = target,
        .optimize = optimize,
    });

    // Utils module for tests
    const utils_mod = b.addModule("utils", .{
        .root_source_file = b.path("src/utils.zig"),
        .target = target,
        .optimize = optimize,
    });

    // Errors module for tests
    const errors_mod = b.addModule("errors", .{
        .root_source_file = b.path("src/errors.zig"),
        .target = target,
        .optimize = optimize,
    });

    // Metadata module for tests
    const metadata_mod = b.addModule("metadata", .{
        .root_source_file = b.path("src/metadata.zig"),
        .target = target,
        .optimize = optimize,
        .imports = &.{
            .{ .name = "ArgumentType", .module = arg_type_mod },
            .{ .name = "utils", .module = utils_mod },
        },
    });

    // ArgumentRegistry module for tests
    const registry_mod = b.addModule("ArgumentRegistry", .{
        .root_source_file = b.path("src/ArgumentRegistry.zig"),
        .target = target,
        .optimize = optimize,
        .imports = &.{
            .{ .name = "metadata", .module = metadata_mod },
            .{ .name = "ArgumentType", .module = arg_type_mod },
        },
    });

    // Parsing module for tests
    const parsing_mod = b.addModule("parsing", .{
        .root_source_file = b.path("src/parsing.zig"),
        .target = target,
        .optimize = optimize,
        .imports = &.{
            .{ .name = "ArgumentType", .module = arg_type_mod },
            .{ .name = "metadata", .module = metadata_mod },
            .{ .name = "ArgumentRegistry", .module = registry_mod },
        },
    });

    // Help module for tests
    const help_mod = b.addModule("help", .{
        .root_source_file = b.path("src/help.zig"),
        .target = target,
        .optimize = optimize,
        .imports = &.{
            .{ .name = "metadata", .module = metadata_mod },
            .{ .name = "ArgumentRegistry", .module = registry_mod },
            .{ .name = "ArgumentType", .module = arg_type_mod },
        },
    });

    // Test step
    const test_step = b.step("test", "Run unit tests");

    // Type tests
    const type_test_mod = b.createModule(.{
        .root_source_file = b.path("tests/type_test.zig"),
        .target = target,
        .optimize = optimize,
        .imports = &.{
            .{ .name = "zargs", .module = zargs_mod },
        },
    });
    const type_tests = b.addTest(.{
        .name = "type-tests",
        .root_module = type_test_mod,
    });
    test_step.dependOn(&b.addRunArtifact(type_tests).step);

    // ParsedValue tests
    const parsed_value_test_mod = b.createModule(.{
        .root_source_file = b.path("tests/test_parsed_value.zig"),
        .target = target,
        .optimize = optimize,
        .imports = &.{
            .{ .name = "ArgumentType", .module = arg_type_mod },
        },
    });
    const parsed_value_tests = b.addTest(.{
        .name = "parsed-value-tests",
        .root_module = parsed_value_test_mod,
    });
    test_step.dependOn(&b.addRunArtifact(parsed_value_tests).step);

    // Utils tests
    const utils_test_mod = b.createModule(.{
        .root_source_file = b.path("tests/test_utils.zig"),
        .target = target,
        .optimize = optimize,
        .imports = &.{
            .{ .name = "utils", .module = utils_mod },
        },
    });
    const utils_tests = b.addTest(.{
        .name = "utils-tests",
        .root_module = utils_test_mod,
    });
    test_step.dependOn(&b.addRunArtifact(utils_tests).step);

    // Errors tests
    const errors_test_mod = b.createModule(.{
        .root_source_file = b.path("tests/test_errors.zig"),
        .target = target,
        .optimize = optimize,
        .imports = &.{
            .{ .name = "errors", .module = errors_mod },
        },
    });
    const errors_tests = b.addTest(.{
        .name = "errors-tests",
        .root_module = errors_test_mod,
    });
    test_step.dependOn(&b.addRunArtifact(errors_tests).step);

    // Metadata tests
    const metadata_test_mod = b.createModule(.{
        .root_source_file = b.path("tests/test_metadata.zig"),
        .target = target,
        .optimize = optimize,
        .imports = &.{
            .{ .name = "metadata", .module = metadata_mod },
            .{ .name = "ArgumentType", .module = arg_type_mod },
        },
    });
    const metadata_tests = b.addTest(.{
        .name = "metadata-tests",
        .root_module = metadata_test_mod,
    });
    test_step.dependOn(&b.addRunArtifact(metadata_tests).step);

    // ArgumentRegistry tests
    const registry_test_mod = b.createModule(.{
        .root_source_file = b.path("tests/test_registry.zig"),
        .target = target,
        .optimize = optimize,
        .imports = &.{
            .{ .name = "ArgumentRegistry", .module = registry_mod },
            .{ .name = "metadata", .module = metadata_mod },
            .{ .name = "ArgumentType", .module = arg_type_mod },
        },
    });
    const registry_tests = b.addTest(.{
        .name = "registry-tests",
        .root_module = registry_test_mod,
    });
    test_step.dependOn(&b.addRunArtifact(registry_tests).step);

    // Parsing tests
    const parsing_test_mod = b.createModule(.{
        .root_source_file = b.path("tests/test_parsing.zig"),
        .target = target,
        .optimize = optimize,
        .imports = &.{
            .{ .name = "parsing", .module = parsing_mod },
            .{ .name = "ArgumentRegistry", .module = registry_mod },
            .{ .name = "metadata", .module = metadata_mod },
            .{ .name = "ArgumentType", .module = arg_type_mod },
        },
    });
    const parsing_tests = b.addTest(.{
        .name = "parsing-tests",
        .root_module = parsing_test_mod,
    });
    test_step.dependOn(&b.addRunArtifact(parsing_tests).step);

    // Help tests
    const help_test_mod = b.createModule(.{
        .root_source_file = b.path("tests/test_help.zig"),
        .target = target,
        .optimize = optimize,
        .imports = &.{
            .{ .name = "help", .module = help_mod },
            .{ .name = "ArgumentRegistry", .module = registry_mod },
            .{ .name = "metadata", .module = metadata_mod },
            .{ .name = "ArgumentType", .module = arg_type_mod },
        },
    });
    const help_tests = b.addTest(.{
        .name = "help-tests",
        .root_module = help_test_mod,
    });
    test_step.dependOn(&b.addRunArtifact(help_tests).step);
}