From afc77f0603395d9c1829a49081e198b0fa255abc Mon Sep 17 00:00:00 2001
From: mlugg <mlugg@mlugg.co.uk>
Date: Mon, 16 Dec 2024 16:19:35 +0000
Subject: [PATCH] init template: expand slightly, migrate from deprecated
 std.Build APIs

---
 lib/init/build.zig    | 52 +++++++++++++++++++++++++++++++------------
 lib/init/src/main.zig | 10 ++++++++-
 lib/init/src/root.zig |  2 +-
 3 files changed, 48 insertions(+), 16 deletions(-)

diff --git a/lib/init/build.zig b/lib/init/build.zig
index d53cbbb982c3cd5cff1074e85d5a3502a0a96f24..c75a4e6be3bbca6d4d79885d602280b72800d485 100644
--- a/lib/init/build.zig
+++ b/lib/init/build.zig
@@ -15,13 +15,41 @@ pub fn build(b: *std.Build) void {
     // set a preferred release mode, allowing the user to decide how to optimize.
     const optimize = b.standardOptimizeOption(.{});
 
+    // This creates a "module", which represents a collection of source files alongside
+    // some compilation options, such as optimization mode and linked system libraries.
+    // Every executable or library we compile will be based on one or more modules.
+    const lib_mod = b.createModule(.{
+        // `root_source_file` is the Zig "entry point" of the module. If a module
+        // only contains e.g. external object files, you can make this `null`.
+        // 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 = b.path("src/root.zig"),
+        .target = target,
+        .optimize = optimize,
+    });
+
+    // We will also create a module for our other entry point, 'main.zig'.
+    const exe_mod = b.createModule(.{
+        // `root_source_file` is the Zig "entry point" of the module. If a module
+        // only contains e.g. external object files, you can make this `null`.
+        // 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 = b.path("src/main.zig"),
+        .target = target,
+        .optimize = optimize,
+    });
+
+    // Modules can depend on one another using the `std.Build.Module.addImport` function.
+    // This is what allows Zig source code to use `@import("foo")` where 'foo' is not a
+    // file path. In this case, we set up `exe_mod` to import `lib_mod`.
+    exe_mod.addImport("$_lib", lib_mod);
+
+    // Now, we will create a static library based on the module we created above.
+    // This creates a `std.Build.Step.Compile`, which is the build step responsible
+    // for actually invoking the compiler.
     const lib = b.addStaticLibrary(.{
         .name = "$",
-        // 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 = b.path("src/root.zig"),
-        .target = target,
-        .optimize = optimize,
+        .root_module = lib_mod,
     });
 
     // This declares intent for the library to be installed into the standard
@@ -29,11 +57,11 @@ pub fn build(b: *std.Build) void {
     // running `zig build`).
     b.installArtifact(lib);
 
+    // This creates another `std.Build.Step.Compile`, but this one builds an executable
+    // rather than a static library.
     const exe = b.addExecutable(.{
         .name = "$",
-        .root_source_file = b.path("src/main.zig"),
-        .target = target,
-        .optimize = optimize,
+        .root_module = exe_mod,
     });
 
     // This declares intent for the executable to be installed into the
@@ -67,17 +95,13 @@ pub fn build(b: *std.Build) void {
     // Creates a step for unit testing. This only builds the test executable
     // but does not run it.
     const lib_unit_tests = b.addTest(.{
-        .root_source_file = b.path("src/root.zig"),
-        .target = target,
-        .optimize = optimize,
+        .root_module = lib_mod,
     });
 
     const run_lib_unit_tests = b.addRunArtifact(lib_unit_tests);
 
     const exe_unit_tests = b.addTest(.{
-        .root_source_file = b.path("src/main.zig"),
-        .target = target,
-        .optimize = optimize,
+        .root_module = exe_mod,
     });
 
     const run_exe_unit_tests = b.addRunArtifact(exe_unit_tests);
diff --git a/lib/init/src/main.zig b/lib/init/src/main.zig
index ba5a2ccef2339fc967fbdbe1b925ae9d4133a7cb..caf8f4f37a968fa41c12fb1895d0138bd326421f 100644
--- a/lib/init/src/main.zig
+++ b/lib/init/src/main.zig
@@ -1,7 +1,6 @@
 //! By convention, main.zig is where your main function lives in the case that
 //! you are building an executable. If you are making a library, the convention
 //! is to delete this file and start with root.zig instead.
-const std = @import("std");
 
 pub fn main() !void {
     // Prints to stderr (it's a shortcut based on `std.io.getStdErr()`)
@@ -26,6 +25,10 @@ test "simple test" {
     try std.testing.expectEqual(@as(i32, 42), list.pop());
 }
 
+test "use other module" {
+    try std.testing.expectEqual(@as(i32, 150), lib.add(100, 50));
+}
+
 test "fuzz example" {
     const global = struct {
         fn testOne(input: []const u8) anyerror!void {
@@ -35,3 +38,8 @@ test "fuzz example" {
     };
     try std.testing.fuzz(global.testOne, .{});
 }
+
+const std = @import("std");
+
+/// This imports the separate module containing `root.zig`. Take a look in `build.zig` for details.
+const lib = @import("$_lib");
diff --git a/lib/init/src/root.zig b/lib/init/src/root.zig
index f034ca3589ffeeb5d08e438d65dfece2c5c2bc56..27d2be80b5ddfa4c5384af3907fd1ab0d181b371 100644
--- a/lib/init/src/root.zig
+++ b/lib/init/src/root.zig
@@ -4,7 +4,7 @@
 const std = @import("std");
 const testing = std.testing;
 
-export fn add(a: i32, b: i32) i32 {
+pub export fn add(a: i32, b: i32) i32 {
     return a + b;
 }
 
-- 
2.54.0