4 files changed, 68 insertions(+), 21 deletions(-)

M build.zig
M src/main.zig
M src/note.zig
M src/util.zig

@@ 1,27 1,67 @@
 const std = @import("std");
 
-pub fn build(b: *std.build.Builder) void {
+// 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 release options allow the person running `zig build` to select
-    // between Debug, ReleaseSafe, ReleaseFast, and ReleaseSmall.
-    const mode = b.standardReleaseOptions();
+    // 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 exe = b.addExecutable("er", "src/main.zig");
-    exe.setTarget(target);
-    exe.setBuildMode(mode);
+    const exe = b.addExecutable(.{
+        .name = "er",
+        // 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,
+    });
+
+    // 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`).
     exe.install();
 
+    // This *creates* a RunStep 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 = exe.run();
+
+    // 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.
+    const exe_tests = b.addTest(.{
+        .root_source_file = .{ .path = "src/main.zig" },
+        .target = target,
+        .optimize = optimize,
+    });
+
+    // 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(&exe_tests.step);
 }

@@ 42,13 42,14 @@ fn readBody(entry_name: []const u8, contents: *util.CharBuffer) !void {
             }
             return err;
         };
-        if (maybe_line == null) {
-            break;
-        } else |line| {
-            const line_prefix = line[0..util.ref_prefix.len];
-            if (line.len > util.ref_prefix.len and mem.eql(u8, util.ref_prefix, line_prefix)) {
-                // Filter out a ref line.
-                continue;
+
+        if (maybe_line) |line| {
+            if (line.len > util.ref_prefix.len) {
+                const line_prefix = line[0..util.ref_prefix.len];
+                if (mem.eql(u8, util.ref_prefix, line_prefix)) {
+                    // Filter out a ref line.
+                    continue;
+                }
             }
             if (!started_body and line.len == 0) {
                 // Filter out padding before body.


@@ 70,6 71,8 @@ fn readBody(entry_name: []const u8, contents: *util.CharBuffer) !void {
                 try contents.appendSlice(line);
                 try contents.append('\n');
             }
+        } else {
+            break;
         }
     }
 }


@@ 84,7 87,7 @@ pub fn handle(directory_name: []const u8, allocator: mem.Allocator) !void {
     defer notes.deinit();
 
     // Load note bodies into memory.
-    const dir = try fs.cwd().openDir(directory_name, .{ .iterate = true });
+    const dir = try fs.cwd().openIterableDir(directory_name, .{});
     var iter = dir.iterate();
     while (try iter.next()) |entry| {
         if (entry.kind == .File) {


@@ 94,7 97,7 @@ pub fn handle(directory_name: []const u8, allocator: mem.Allocator) !void {
             });
             defer allocator.free(path);
 
-            var note = Note.init(entry.name, allocator);
+            var note = try Note.init(entry.name, allocator);
             try readBody(path, &note.body);
             try notes.append(note);
         }


@@ 112,11 115,12 @@ pub fn handle(directory_name: []const u8, allocator: mem.Allocator) !void {
 
     // Assemble and write new note bodies.
     for (notes.items) |*note| {
+        defer note.deinitData(allocator);
+
         var buf = util.CharBuffer.init(allocator);
         defer buf.deinit();
 
         try note.generateBody(&buf, allocator);
-        note.deinitData(allocator);
 
         // Optional debugging.
         if (debug_mode) {


@@ 131,7 135,6 @@ pub fn handle(directory_name: []const u8, allocator: mem.Allocator) !void {
             note.name,
         });
         defer allocator.free(path);
-        allocator.free(note.name);
 
         try fs.cwd().writeFile(path, buf.items);
     }

@@ 106,9 106,12 @@ pub const Note = struct {
     backlinks: std.ArrayList([]const u8),
     references: std.ArrayList([]const u8),
 
-    pub fn init(name: []const u8, allocator: mem.Allocator) @This() {
+    pub fn init(name: []const u8, allocator: mem.Allocator) !@This() {
+        const name_str = try allocator.alloc(u8, name.len);
+        mem.copy(u8, name_str, name);
+
         return @This(){
-            .name = name,
+            .name = name_str,
             .body = util.CharBuffer.init(allocator),
             .backlinks = std.ArrayList([]const u8).init(allocator),
             .references = std.ArrayList([]const u8).init(allocator),


@@ 116,6 119,7 @@ pub const Note = struct {
     }
 
     pub fn deinitData(self: @This(), allocator: mem.Allocator) void {
+        allocator.free(self.name);
         self.body.deinit();
         self.backlinks.deinit();
         for (self.references.items) |reference| {

@@ 1,6 1,6 @@
 const std = @import("std");
 
-pub fn nextLine(reader: anytype, buffer: []u8) !?[]const u8 {
+pub fn nextLine(reader: std.fs.File.Reader, buffer: []u8) !?[]const u8 {
     var line = (try reader.readUntilDelimiterOrEof(
         buffer,
         '\n',