【Zig 日报】编写自定义 Step：扩展构建管线 #385

// 1. 声明执行系统命令
const sign_cmd = b.addSystemCommand(&.{
    "codesign",
    "--force",
    "--sign",
    "-",
});

// 2. 将待签名二进制文件的 LazyPath 作为命令行参数传入
sign_cmd.addFileArg(exe.getEmittedBin());

// 3. 建立显式依赖：必须先完成可执行文件的编译
sign_cmd.step.dependOn(&exe.step);

// 4. 注册顶层命令："zig build sign"
const sign_step = b.step("sign", "Sign the binary using system codesign");
sign_step.dependOn(&sign_cmd.step);

// tools/pack.zig
const std = @import("std");

pub fn main(init: std.process.Init) !void {
    const io = init.io;
    const allocator = init.arena.allocator();

    var it = try init.minimal.args.iterateAllocator(allocator);
    defer it.deinit();
    _ = it.next(); // 跳过 argv[0]
    const input_path = it.next() orelse return error.MissingInputPath;
    const output_path = it.next() orelse return error.MissingOutputPath;

    std.debug.print("Packaging release archive: {s} -> {s}\n", .{ input_path, output_path });

    // 1. 创建目标输出目录与文件
    const cwd = std.Io.Dir.cwd();
    if (std.fs.path.dirname(output_path)) |dir| {
        cwd.createDirPath(io, dir) catch {};
    }
    const tar_file = try cwd.createFile(io, output_path, .{});
    defer tar_file.close(io);

    // 2. 构造流式写入器与 gzip 压缩器
    var write_buffer: [4096]u8 = undefined;
    var file_writer = std.Io.File.Writer.initStreaming(tar_file, io, &write_buffer);

    var compress_buffer: [std.compress.flate.max_window_len]u8 = undefined;
    var compressor = try std.compress.flate.Compress.init(
        &file_writer.interface,
        &compress_buffer,
        .gzip,
        std.compress.flate.Compress.Options.default,
    );

    // 3. 构造 tar 打包器并将输入文件写入归档
    var tar_writer: std.tar.Writer = .{ .underlying_writer = &compressor.writer };

    const bin_file = try cwd.openFile(io, input_path, .{});
    defer bin_file.close(io);

    var read_buffer: [4096]u8 = undefined;
    var bin_reader = std.Io.File.Reader.init(bin_file, io, &read_buffer);

    const bin_name = std.fs.path.basename(input_path);
    const tar_entry_path = try std.fmt.allocPrint(allocator, "bin/{s}", .{bin_name});
    const bin_size = try bin_reader.getSize();

    // 显式指定可执行权限 (0o755: rwxr-xr-x)
    try tar_writer.writeFileStream(
        tar_entry_path,
        bin_size,
        &bin_reader.interface,
        .{ .mode = 0o755 },
    );
    try tar_writer.finishPedantically();

    // 4. 刷新并完成压缩
    try compressor.finish();
    try file_writer.flush();

    std.debug.print("Successfully created {s}!\n", .{output_path});
}

const std = @import("std");

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

    // 1. 声明待发布的目标应用程序（按用户指定的目标平台交叉编译）
    const exe = b.addExecutable(.{
        .name = "custom_step_demo",
        .root_module = b.createModule(.{
            .root_source_file = b.path("src/main.zig"),
            .target = target,
            .optimize = optimize,
        }),
    });
    b.installArtifact(exe);

    // 2. 编译辅助工具：目标平台必须固定为宿主机 b.graph.host
    const pack_tool = b.addExecutable(.{
        .name = "pack_tool",
        .root_module = b.createModule(.{
            .root_source_file = b.path("tools/pack.zig"),
            .target = b.graph.host, // 确保在当前编译机上可直接执行
            .optimize = .ReleaseSafe,
        }),
    });

    // 3. 声明运行步骤，连接输入与输出 LazyPath
    const pack_cmd = b.addRunArtifact(pack_tool);
    // 传入待打包的二进制文件（建立输入数据依赖）
    pack_cmd.addFileArg(exe.getEmittedBin());
    // 声明输出文件位置（由调度器分配缓存路径并传递给工具命令行）
    const output_tar = pack_cmd.addOutputFileArg2("bundle.tar.gz", .{});

    // 4. 将输出归档安装到交付目录（zig-out/bundle.tar.gz）
    const install_tar = b.addInstallFile(output_tar, "bundle.tar.gz");

    // 5. 注册顶层命令入口："zig build pack"
    const top_pack = b.step("pack", "Package distribution archive into tar.gz using helper tool");
    top_pack.dependOn(&install_tar.step);
}