fix: building

c headers across modules are painful, more info: ziglang/zig#14719

Author: 0t4u

build.zig

@@ -1,46 +1,88 @@
 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(.{});
 
-    // Define dependencies.
-    const zlib = b.dependency("zlib", .{});
+    // Zlib dependency
+    const dep_zlib = b.dependency("zlib", .{});
+
+    // Zlib headers path
+    // https://github.com/ziglang/zig/issues/14719
+    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    const allocator = gpa.allocator();
+    defer _ = gpa.deinit();
+    const zlib_install_path = dep_zlib.module("zlib").builder.install_path;
+    const zlib_headers_rel = "/include/zlib";
+    const zlib_headers = allocator.alloc(u8, zlib_install_path.len + zlib_headers_rel.len) catch {
+        @panic("out of memory");
+    };
+    defer _ = allocator.free(zlib_headers);
+    std.mem.copy(u8, zlib_headers[0..], zlib_install_path);
+    std.mem.copy(u8, zlib_headers[zlib_install_path.len..], zlib_headers_rel);
+    std.debug.print("zlib headers found at: {s}\n", .{zlib_headers});
 
-    // Define module
-    const ws_module = b.addModule("ws", .{
+    // Declare module to expose to package manager to make it available to downstream
+    const mod = b.addModule("ws", .{
         .source_file = .{ .path = "src/main.zig" },
-        .dependencies = &[_]std.Build.ModuleDependency{.{ .name = "zlib", .module = zlib.module("zlib") }},
+        .dependencies = &.{.{ .name = "zlib", .module = dep_zlib.module("zlib") }},
     });
 
-    // Build library.
-    const ws_lib = b.addStaticLibrary(.{
+    const lib = b.addStaticLibrary(.{
         .name = "ws",
-        .root_source_file = .{ .path = "src/main.zig" },
+        // In this case the main source file is merely a path, however, in more
+        // complicated build scripts, this could be a generated file.
+        // .root_source_file = .{ .path = "src/main.zig" },
         .target = target,
         .optimize = optimize,
     });
-    // Link z library and zlib module.
-    ws_lib.linkLibrary(b.dependency("zlib", .{
+
+    // Link zlib
+    lib.linkLibrary(b.dependency("zlib", .{
         .target = target,
         .optimize = optimize,
-    }).artifact("z"));
-    ws_lib.addModule("zlib", zlib.module("zlib"));
-    b.installArtifact(ws_lib);
+    }).artifact("zlib"));
+    lib.addModule("zlib", dep_zlib.module("zlib"));
+
+    // This declares intent for the library to be installed into the standard
+    // location when the user invokes the "install" step (the default step when
+    // running `zig build`).
+    b.installArtifact(lib);
 
-    // Build test.
-    const test_compile = b.addTest(.{
+    // Creates a step for unit testing. This only builds the test executable
+    // but does not run it.
+    const main_tests = b.addTest(.{
         .root_source_file = .{ .path = "src/main.zig" },
         .target = target,
         .optimize = optimize,
     });
-    test_compile.linkLibrary(b.dependency("zlib", .{
+
+    // Link zlib
+    main_tests.addIncludePath(.{ .path = zlib_headers });
+    main_tests.linkLibrary(b.dependency("zlib", .{
         .target = target,
         .optimize = optimize,
-    }).artifact("z"));
-    test_compile.addModule("zlib", zlib.module("zlib"));
-    const test_step = b.step("test", "Run unit tests");
-    test_step.dependOn(&test_compile.step);
+    }).artifact("zlib"));
+    main_tests.addModule("zlib", dep_zlib.module("zlib"));
+
+    const run_main_tests = b.addRunArtifact(main_tests);
+
+    // This creates a build step. It will be visible in the `zig build --help` menu,
+    // and can be selected like this: `zig build test`
+    // This will evaluate the `test` step rather than the default, which is "install".
+    const test_step = b.step("test", "Run library tests");
+    test_step.dependOn(&run_main_tests.step);
 
     // Build examples.
     const bin = b.addExecutable(.{
@@ -49,10 +91,8 @@ pub fn build(b: *std.Build) void {
         .target = target,
         .optimize = optimize,
     });
-    bin.linkLibrary(ws_lib);
-    bin.addModule("ws", ws_module);
+    bin.addIncludePath(.{ .path = zlib_headers });
+    bin.linkLibrary(lib);
+    bin.addModule("ws", mod);
     b.installArtifact(bin);
 }
-
-// to test single file
-// $ zig test src/main.zig --deps zlib=zlib --mod zlib::zlib/src/main.zig -l z

build.zig.zon

@@ -3,8 +3,8 @@
     .version = "0.1.0",
     .dependencies = .{
         .zlib = .{
-            .url = "https://github.com/ianic/zig-zlib/archive/9186b0f5fdfd6c29cd04f7ada7b0113fe1f63611.tar.gz",
-            .hash = "122001cc3da638f9315f08fb51fe5aace68c254b59bcac3457e20d746565bad7fe04",
+            .url = "https://github.com/0t4u/zig-zlib/archive/5ac9e76f6f8bc7b9d5d820e01912c57671a8a441.tar.gz",
+            .hash = "122044ed841b701d59cd10aba7b8f827907d308651f362e1f0acec416c768c8d29ce",
         },
     },
 }