build.zig

const std = @import("std");

pub const Phpz = @import("./build/Phpz.zig");

const BuildOptions = struct {
    php_include_root: []const u8,
    target: std.Build.ResolvedTarget,
    optimize: std.builtin.OptimizeMode,
};

pub fn build(b: *std.Build) void {
    const options = BuildOptions{
        .php_include_root = b.option([]const u8, "php-include-root", "PHP root include directory path") orelse "/usr/include/php",
        .target = b.standardTargetOptions(.{}),
        .optimize = b.standardOptimizeOption(.{}),
    };

    const mod = createPhpzModule(b, options);

    addCheckStep(b, mod);
    addGenerateDocsStep(b, mod);
    addTestStep(b, options);
}

fn createPhpzModule(b: *std.Build, options: BuildOptions) *std.Build.Module {
    return Phpz.initInner(b, .{
        .php_include_root = .{ .cwd_relative = options.php_include_root },
        .c_source_file = b.path("build/phpz.h"),
        .target = options.target,
        .optimize = options.optimize,
    }).mod;
}

fn addCheckStep(b: *std.Build, mod: *std.Build.Module) void {
    const lib_check = b.addLibrary(.{
        .name = "phpz",
        .root_module = mod,
    });
    const check = b.step("check", "Check that phpz builds correctly");
    check.dependOn(&lib_check.step);
}

fn addGenerateDocsStep(b: *std.Build, mod: *std.Build.Module) void {
    const doc_step = b.step("docs", "Generate documentation for phpz");

    // Generate docs for main library (src/root.zig)
    const doc_obj = b.addObject(.{
        .name = "phpz",
        .root_module = mod,
    });
    const install_docs = b.addInstallDirectory(.{
        .source_dir = doc_obj.getEmittedDocs(),
        .install_dir = .prefix,
        .install_subdir = "docs/lib",
    });
    doc_step.dependOn(&install_docs.step);

    // Generate docs for build system (build/Phpz.zig)
    const build_doc_obj = b.addObject(.{
        .name = "phpz-build",
        .root_module = b.createModule(.{
            .root_source_file = b.path("build/Phpz.zig"),
            .target = mod.resolved_target,
            .optimize = mod.optimize,
        }),
    });
    const install_build_docs = b.addInstallDirectory(.{
        .source_dir = build_doc_obj.getEmittedDocs(),
        .install_dir = .prefix,
        .install_subdir = "docs/build",
    });
    doc_step.dependOn(&install_build_docs.step);
}

fn addTestStep(b: *std.Build, options: BuildOptions) void {
    const step = b.step("test", "Run tests for phpz");
    const examples = [_][]const u8{
        "my_php_extension",
        "pjs",
    };
    inline for (examples) |test_example| {
        const test_cmd = b.addSystemCommand(&[_][]const u8{
            b.graph.zig_exe,
            "build",
            "test",
            b.fmt("-Dphp-include-root={s}", .{options.php_include_root}),
            b.fmt("-Doptimize={s}", .{@tagName(options.optimize)}),
        });
        test_cmd.setCwd(b.path("examples").join(b.allocator, test_example) catch unreachable);
        step.dependOn(&test_cmd.step);
    }
}