refactor: adapt to zig 0.15.1, reorganize code + change build.zig

Author: guidoschmidt

.github/workflows/build.yaml

@@ -20,8 +20,8 @@ jobs:
       - name: Setup Zig
         uses: mlugg/setup-zig@v2
         with:
-          version: master
+          version: 0.15.1
 
       - name: Build all examples
         run: |
-          zig build
+          zig build -- all

build.zig

@@ -6,79 +6,116 @@ const print = std.debug.print;
 const heap = std.heap;
 const process = std.process;
 
-fn createExecutable(b: *std.Build,
-                    target: std.Build.ResolvedTarget,
-                    optimize: std.builtin.OptimizeMode,
-                    source: []const u8) !void {
+fn find(arr: *std.array_list.Managed([]const u8), elem: []const u8) bool {
+    for (arr.items) |item| if (std.mem.eql(u8, item, elem)) return true;
+    return false;
+}
+
+fn createExecutable(
+    b: *std.Build,
+    module_shadred: *std.Build.Module,
+    target: std.Build.ResolvedTarget,
+    optimize: std.builtin.OptimizeMode,
+    source: []const u8,
+) !void {
     const source_filename = std.fs.path.basename(source);
     const index = std.mem.lastIndexOfScalar(u8, source_filename, '.') orelse source_filename.len;
     const exe_name = source_filename[0..index];
     const exe = b.addExecutable(.{
-        .root_source_file = b.path(source),
         .name = exe_name,
-        .target = target,
-        .optimize = optimize,
+        .root_module = b.createModule(.{
+            .optimize = optimize,
+            .target = target,
+            .root_source_file = b.path(source),
+        }),
     });
-    b.installArtifact(exe);
+    exe.root_module.addImport("shared", module_shadred);
+
+    const path = fs.path.dirname(source) orelse "";
+    const clean_path = try std.mem.replaceOwned(u8, b.allocator, path, "./src/examples", "");
+    const out_path = try fs.path.join(b.allocator, &.{ "bin", clean_path });
+    const full_exe_path = try std.fs.path.join(b.allocator, &.{ out_path, exe_name });
+    print("\n→ {s}\n", .{full_exe_path});
+    const install_artifact = b.addInstallArtifact(exe, .{
+        .dest_dir = .{
+            .override = .{
+                .custom = out_path,
+            },
+        },
+    });
+    b.getInstallStep().dependOn(&install_artifact.step);
 
     const run_cmd = b.addRunArtifact(exe);
     run_cmd.step.dependOn(b.getInstallStep());
     if (b.args) |buildArgs| {
         run_cmd.addArgs(buildArgs);
     }
 
-    const run_step_name = try std.fmt.allocPrint(b.allocator, "{s}", .{ exe_name });
+    const run_step_name = try std.fmt.allocPrint(b.allocator, "run-{s}", .{exe_name});
     defer b.allocator.free(run_step_name);
     const run_step = b.step(run_step_name, "Run the program");
     run_step.dependOn(&run_cmd.step);
 }
 
+fn parseDir(
+    b: *std.Build,
+    depth: usize,
+    path: []const u8,
+    results: *std.array_list.Managed([]const u8),
+) !void {
+    const extension = fs.path.extension(path);
+    if (!std.mem.eql(u8, extension, "zig") and extension.len > 0) return;
+    const src_dir = fs.cwd().openDir(path, .{ .iterate = true }) catch |err| {
+        print("\n{any}: {s}", .{ err, path });
+        return;
+    };
+    var it = src_dir.iterate();
+    var i: u32 = 0;
+    while (try it.next()) |subpath| : (i += 1) {
+        const child_path = try std.fs.path.join(b.allocator, &.{ path, subpath.name });
+        if (!std.mem.containsAtLeast(u8, subpath.name, 1, ".zig")) {
+            try parseDir(b, depth + 1, child_path, results);
+            continue;
+        }
+        try results.append(child_path);
+    }
+}
+
 pub fn build(b: *std.Build) !void {
     const target = b.standardTargetOptions(.{});
     const optimize = b.standardOptimizeOption(.{});
 
     const args = try process.argsAlloc(b.allocator);
     defer process.argsFree(b.allocator, args);
 
-    var examples = std.ArrayList([]const u8).init(b.allocator);
+    var examples = std.array_list.Managed([]const u8).init(b.allocator);
     defer examples.deinit();
-    
-    print("\n\n--- Examples ---\n", .{});
-    const src_dir = try fs.cwd().openDir("./src", .{ .iterate = true });
-    var it = src_dir.iterate();
-    var i: u32 = 0;
-    while (try it.next()) |path| : (i += 1) {
-        if (!std.mem.containsAtLeast(u8, path.name, 1, ".zig")) continue;
-        const source = try std.fmt.allocPrint(b.allocator, "./src/{s}", .{ path.name });
-        print("- {d} {s}\n", .{ i, source });
-        try examples.append(source);
-    }
-    print("----------------\n", .{});
 
+    const module_shared = b.addModule("shared", .{
+        .root_source_file = b.path("src/shared/root.zig"),
+        .optimize = optimize,
+        .target = target,
+    });
 
-    const single_example_name = args[args.len - 1];
-    var index: ?usize = null;
-    for (0..examples.items.len) |j| {
-        if (std.mem.containsAtLeast(u8, examples.items[j], 1, single_example_name)) {
-            index = j;
-            break;
-        }
-    }
+    // print("\n\n--- Examples ---\n", .{});
+    try parseDir(b, 0, "./src/examples", &examples);
+    // for (examples.items) |example_src| {
+    //     print("- {s}\n", .{example_src});
+    // }
+    // print("----------------\n", .{});
 
-    if (index) |j| {
-        const example = examples.items[j];
-        print("\nBuilding single example: {s}...\n\n", .{ example });
-        try createExecutable(b, target, optimize, example);
-        return;
-    }
-    
-    for (examples.items) |source_file| {
-        try createExecutable(b, target, optimize, source_file);
+    const single_example_path = args[args.len - 1];
+    if (find(&examples, single_example_path)) {
+        print("Found example: {s}", .{single_example_path});
+        try createExecutable(b, module_shared, target, optimize, single_example_path);
+    } else {
+        print("Couldn't find example: {s}", .{single_example_path});
     }
-    // return;
 
-    // defer b.allocator.free(source);
-    // print("\n...Building {s} {s}\n\n", .{ example_name, source });
-
-    // try createExecutable(b, source);
+    if (std.mem.eql(u8, single_example_path, "all")) {
+        for (examples.items) |example_src| {
+            print("\nBuilding example: {s}", .{example_src});
+            try createExecutable(b, module_shared, target, optimize, example_src);
+        }
+    }
 }