-
Notifications
You must be signed in to change notification settings - Fork 0
/
build.zig
129 lines (104 loc) · 4.57 KB
/
build.zig
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
const std = @import("std");
const ruka_version = std.SemanticVersion{ .major = 0, .minor = 1, .patch = 0, .pre = "dev" };
const version_date = "10-13-2024";
const description = "Build tool/Package manager for the Ruka Programming Language";
pub fn build(b: *std.Build) void {
const target = b.standardTargetOptions(.{});
const optimize = b.standardOptimizeOption(.{});
const bin = b.addExecutable(.{
.name = "ruka",
.root_source_file = b.path("src/main.zig"),
.target = target,
.optimize = optimize
});
b.installArtifact(bin);
var options = b.addOptions();
options.addOption(std.SemanticVersion, "version", getVersion(b));
options.addOption([]const u8, "version_date", getDate(b));
options.addOption([]const u8, "description", description);
bin.root_module.addOptions("options", options);
const run_cmd = b.addRunArtifact(bin);
run_cmd.step.dependOn(b.getInstallStep());
if (b.args) |args| {
run_cmd.addArgs(args);
}
const run_step = b.step("run", "Run the app");
run_step.dependOn(&run_cmd.step);
// Tests
const bin_unit_tests = b.addTest(.{
.name = "bin_test",
.root_source_file = b.path("src/main.zig"),
.target = target,
.test_runner = b.path("runners/test.zig"),
.optimize = optimize,
});
const run_bin_unit_tests = b.addRunArtifact(bin_unit_tests);
run_bin_unit_tests.addArg("--suite bin");
const test_step = b.step("test", "Run unit tests");
test_step.dependOn(&run_bin_unit_tests.step);
const coverage_step = b.step("coverage", "Generate test coverage");
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 bin coverage");
kcov_collect.addArgs(&.{ "kcov" });
kcov_collect.addPrefixedDirectoryArg("--include-pattern=", b.path("src"));
merge_step.addDirectoryArg(kcov_collect.addOutputFileArg(bin_unit_tests.name));
kcov_collect.addArtifactArg(bin_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);
}
fn getVersion(b: *std.Build) std.SemanticVersion {
if (ruka_version.pre == null and ruka_version.build == null) return ruka_version;
var code: u8 = undefined;
const git_describe_untrimmed = b.runAllowFail(
&.{ "git", "-C", b.pathFromRoot("."), "describe", "--match", "*.*.*", "--tags" },
&code,
.Ignore,
) catch return ruka_version;
const git_describe = std.mem.trim(u8, git_describe_untrimmed, " \n\r");
switch (std.mem.count(u8, git_describe, "-")) {
0 => {
// Tagged release ruka_version (e.g. 0.10.0).
std.debug.assert(std.mem.eql(u8, git_describe, b.fmt("{}", .{ruka_version}))); // tagged release must match ruka_version string
return ruka_version;
},
2 => {
// Untagged development build (e.g. 0.10.0-dev.216+34ce200).
var it = std.mem.splitScalar(u8, git_describe, '-');
const tagged_ancestor = it.first();
const commit_height = it.next().?;
const commit_id = it.next().?;
const ancestor_ver = std.SemanticVersion.parse(tagged_ancestor) catch unreachable;
std.debug.assert(ruka_version.order(ancestor_ver) == .gt); // ZLS ruka_version must be greater than its previous ruka_version
std.debug.assert(std.mem.startsWith(u8, commit_id, "g")); // commit hash is prefixed with a 'g'
return std.SemanticVersion{
.major = ruka_version.major,
.minor = ruka_version.minor,
.patch = ruka_version.patch,
.pre = b.fmt("dev.{s}", .{commit_height}),
.build = commit_id[1..],
};
},
else => {
std.debug.print("Unexpected 'git describe' output: '{s}'\n", .{git_describe});
std.process.exit(1);
},
}
}
fn getDate(b: *std.Build) []const u8 {
var code: u8 = undefined;
const date_untrimmed = b.runAllowFail(&.{
"date", "+'%m/%d/%Y'"
}, &code, .Ignore) catch return version_date;
const date = std.mem.trim(u8, date_untrimmed, " \n\r");
return date;
}