const std = @import("std");
// Although this function looks imperative, note that its job is to
// declaratively construct a build graph that will be executed by an external
// runner.
pub fn build(b: *std.Build) void {
// Standard target options allows the person running `zig build` to choose
// what target to build for. Here we do not override the defaults, which
// means any target is allowed, and the default is native. Other options
// for restricting supported target set are available.
const target = b.standardTargetOptions(.{});
// Standard optimization options allow the person running `zig build` to select
// between Debug, ReleaseSafe, ReleaseFast, and ReleaseSmall. Here we do not
// set a preferred release mode, allowing the user to decide how to optimize.
const optimize = b.standardOptimizeOption(.{});
const teamdraft = b.addExecutable(.{
.name = "teamdraft",
.root_source_file = b.path("src/main.zig"),
.target = target,
.optimize = optimize,
});
const dev = b.option(bool, "dev", "Dev mode - automatically reload templates") orelse false;
const options = b.addOptions();
options.addOption(bool, "dev", dev);
var templates = std.ArrayList([]const u8).init(b.allocator);
defer templates.deinit();
var templates_dir = std.fs.cwd().openDir("src/views", .{ .iterate = true }) catch @panic("can't find views directory");
defer templates_dir.close();
var it = templates_dir.iterate();
while (it.next() catch @panic("can't get next view")) |file| {
if (file.kind != .file) {
continue;
}
var template_name: [50]u8 = undefined;
_ = std.mem.replace(u8, file.name, ".mustache", "", &template_name);
templates.append(b.dupe(template_name[0 .. file.name.len - 9])) catch @panic("unable to add view name to templates");
}
options.addOption([]const []const u8, "templates", templates.items);
teamdraft.root_module.addOptions("config", options);
const scorecorder = b.addExecutable(.{
.name = "scorecorder",
.root_source_file = b.path("src/scorecorder.zig"),
.target = target,
.optimize = optimize,
});
scorecorder.root_module.addImport("zul", b.dependency("zul", .{
.target = target,
.optimize = optimize,
}).module("zul"));
const logz = b.dependency("logz", .{
.target = target,
.optimize = optimize,
});
scorecorder.root_module.addImport("logz", logz.module("logz"));
teamdraft.root_module.addImport("logz", logz.module("logz"));
const httpz = b.dependency("httpz", .{
.target = target,
.optimize = optimize,
});
teamdraft.root_module.addImport("httpz", httpz.module("httpz"));
const mustache = b.dependency("mustache", .{
.target = target,
.optimize = optimize,
});
teamdraft.root_module.addImport("mustache", mustache.module("mustache"));
const pg = b.dependency("pg", .{
.target = target,
.optimize = optimize,
});
teamdraft.root_module.addImport("pg", pg.module("pg"));
scorecorder.root_module.addImport("pg", pg.module("pg"));
// This declares intent for the executable to be installed into the
// standard location when the user invokes the "install" step (the default
// step when running `zig build`).
b.installArtifact(teamdraft);
b.installArtifact(scorecorder);
// This *creates* a Run step in the build graph, to be executed when another
// step is evaluated that depends on it. The next line below will establish
// such a dependency.
const run_cmd = b.addRunArtifact(teamdraft);
// By making the run step depend on the install step, it will be run from the
// installation directory rather than directly from within the cache directory.
// This is not necessary, however, if the application depends on other installed
// files, this ensures they will be present and in the expected location.
run_cmd.step.dependOn(b.getInstallStep());
// This allows the user to pass arguments to the application in the build
// command itself, like this: `zig build run -- arg1 arg2 etc`
if (b.args) |args| {
run_cmd.addArgs(args);
}
// This creates a build step. It will be visible in the `zig build --help` menu,
// and can be selected like this: `zig build run`
// This will evaluate the `run` step rather than the default, which is "install".
const run_step = b.step("run", "Run the app");
run_step.dependOn(&run_cmd.step);
// Creates a step for unit testing. This only builds the test executable
// but does not run it.
const exe_unit_tests = b.addTest(.{
.root_source_file = b.path("src/main.zig"),
.target = target,
.optimize = optimize,
});
const run_exe_unit_tests = b.addRunArtifact(exe_unit_tests);
// Similar to creating the run step earlier, this exposes a `test` step to
// the `zig build --help` menu, providing a way for the user to request
// running the unit tests.
const test_step = b.step("test", "Run unit tests");
test_step.dependOn(&run_exe_unit_tests.step);
const coverage_step = b.step("coverage", "Generate a coverage report with kcov");
const merge_step = std.Build.Step.Run.create(b, "merge coverage");
merge_step.addArgs(&.{ "kcov", "--merge" });
merge_step.rename_step_with_output_arg = false;
const merged_coverage_output = merge_step.addOutputFileArg(".");
const kcov_collect = std.Build.Step.Run.create(b, "collect coverage");
kcov_collect.addArgs(&.{ "kcov", "--collect-only" });
kcov_collect.addPrefixedDirectoryArg("--include-pattern=", b.path("src"));
merge_step.addDirectoryArg(kcov_collect.addOutputFileArg(exe_unit_tests.name));
kcov_collect.addArtifactArg(exe_unit_tests);
kcov_collect.enableTestRunnerMode();
const install_coverage = b.addInstallDirectory(.{
.source_dir = merged_coverage_output,
.install_dir = .{ .custom = "coverage" },
.install_subdir = "",
});
coverage_step.dependOn(&install_coverage.step);
}