Update for Zig 0.15 API changes

- build.zig: Use createModule/addLibrary instead of deprecated addStaticLibrary
- build.zig.zon: Add required fingerprint field
- BlowfishWriter.zig: Update ArrayList API (use .empty, pass allocator to methods)

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: Peter Murray

build.zig

@@ -21,33 +21,42 @@ pub fn build(b: *std.Build) void {
         .optimize = optimize,
     });
 
-    const lib = b.addStaticLibrary(.{
-        .name = "blowfish",
-        // In this case the main source file is merely a path, however, in more
-        // complicated build scripts, this could be a generated file.
+    const lib_mod = b.createModule(.{
         .root_source_file = b.path("src/root.zig"),
         .target = target,
         .optimize = optimize,
     });
 
+    const lib = b.addLibrary(.{
+        .linkage = .static,
+        .name = "blowfish",
+        .root_module = lib_mod,
+    });
+
     // 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);
 
-    const exe = b.addExecutable(.{
-        .name = "blowfish",
-        .root_source_file = b.path("src/main.zig"),
+    const flags = b.dependency("flags", .{
         .target = target,
         .optimize = optimize,
     });
 
-    const flags = b.dependency("flags", .{
+    const exe_mod = b.createModule(.{
+        .root_source_file = b.path("src/main.zig"),
         .target = target,
         .optimize = optimize,
+        .imports = &.{
+            .{ .name = "flags", .module = flags.module("flags") },
+        },
+    });
+
+    const exe = b.addExecutable(.{
+        .name = "blowfish",
+        .root_module = exe_mod,
     });
 
-    exe.root_module.addImport("flags", flags.module("flags"));
     // 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`).
@@ -79,17 +88,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);

build.zig.zon

@@ -1,4 +1,5 @@
 .{
+    .fingerprint = 0x179a4441e94ad6d1,
     // This is the default name used by packages depending on this one. For
     // example, when a user runs `zig fetch --save <url>`, this field is used
     // as the key in the `dependencies` table. Although the user can choose a

src/BlowfishWriter.zig

@@ -86,13 +86,13 @@ pub fn blowfishWriter(key: []const u8, underlying_stream: anytype) BlowfishWrite
 
 test "writer" {
     const alloc = std.testing.allocator;
-    var buffer = std.ArrayList(u8).init(alloc);
-    defer buffer.deinit();
-    var writer = blowfishWriter("TESTKEY", buffer.writer());
+    var buffer: std.ArrayList(u8) = .empty;
+    defer buffer.deinit(alloc);
+    var bfwriter = blowfishWriter("TESTKEY", buffer.writer(alloc));
 
     const unencrypted: [8]u8 = .{ 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02 };
-    const wrote = try writer.write(&unencrypted);
-    try writer.flush();
+    const wrote = try bfwriter.write(&unencrypted);
+    try bfwriter.flush();
 
     try std.testing.expectEqual(wrote, 8);
     const encrypted: [8]u8 = .{ 0xDF, 0x33, 0x3F, 0xD2, 0x30, 0xA7, 0x1B, 0xB4 };
@@ -101,14 +101,14 @@ test "writer" {
 
 test "weird buffer lengths" {
     const alloc = std.testing.allocator;
-    var buffer = std.ArrayList(u8).init(alloc);
-    defer buffer.deinit();
-    var writer = blowfishWriter("TESTKEY", buffer.writer());
+    var buffer: std.ArrayList(u8) = .empty;
+    defer buffer.deinit(alloc);
+    var bfwriter = blowfishWriter("TESTKEY", buffer.writer(alloc));
 
     const unencrypted: [8]u8 = .{ 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02 };
-    var wrote = try writer.write(unencrypted[0..3]);
-    wrote += try writer.write(unencrypted[3..]);
-    try writer.flush();
+    var wrote = try bfwriter.write(unencrypted[0..3]);
+    wrote += try bfwriter.write(unencrypted[3..]);
+    try bfwriter.flush();
 
     try std.testing.expectEqual(wrote, 8);
     const encrypted: [8]u8 = .{ 0xDF, 0x33, 0x3F, 0xD2, 0x30, 0xA7, 0x1B, 0xB4 };
@@ -117,18 +117,18 @@ test "weird buffer lengths" {
 
 test "more weird buffer lengths" {
     const alloc = std.testing.allocator;
-    var buffer = std.ArrayList(u8).init(alloc);
-    defer buffer.deinit();
-    var writer = blowfishWriter("TESTKEY", buffer.writer());
+    var buffer: std.ArrayList(u8) = .empty;
+    defer buffer.deinit(alloc);
+    var bfwriter = blowfishWriter("TESTKEY", buffer.writer(alloc));
 
     const unencrypted: [16]u8 = .{ 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02 };
-    var wrote = try writer.write(unencrypted[0..3]);
+    var wrote = try bfwriter.write(unencrypted[0..3]);
     try std.testing.expectEqual(0, buffer.items.len);
-    wrote += try writer.write(unencrypted[3..10]);
+    wrote += try bfwriter.write(unencrypted[3..10]);
     try std.testing.expectEqual(8, buffer.items.len);
-    wrote += try writer.write(unencrypted[10..]);
+    wrote += try bfwriter.write(unencrypted[10..]);
     try std.testing.expectEqual(16, buffer.items.len);
-    try writer.flush();
+    try bfwriter.flush();
 
     try std.testing.expectEqual(wrote, 16);
     const encrypted: [16]u8 = .{ 0xDF, 0x33, 0x3F, 0xD2, 0x30, 0xA7, 0x1B, 0xB4, 0xDF, 0x33, 0x3F, 0xD2, 0x30, 0xA7, 0x1B, 0xB4 };
@@ -137,15 +137,15 @@ test "more weird buffer lengths" {
 
 test "padding" {
     const alloc = std.testing.allocator;
-    var buffer = std.ArrayList(u8).init(alloc);
-    defer buffer.deinit();
-    var writer = blowfishWriter("TESTKEY", buffer.writer());
+    var buffer: std.ArrayList(u8) = .empty;
+    defer buffer.deinit(alloc);
+    var bfwriter = blowfishWriter("TESTKEY", buffer.writer(alloc));
 
     const unencrypted: [5]u8 = .{ 0x00, 0x00, 0x00, 0x01, 0x00 };
-    const wrote = try writer.write(&unencrypted);
+    const wrote = try bfwriter.write(&unencrypted);
     try std.testing.expectEqual(wrote, 5);
     try std.testing.expectEqual(0, buffer.items.len);
-    try writer.flush();
+    try bfwriter.flush();
     try std.testing.expectEqual(8, buffer.items.len);
 
     const encrypted: [8]u8 = .{ 0x6c, 0x44, 0xdc, 0xed, 0x6c, 0xa6, 0x34, 0x79 };