Port to Zig 0.16.0

Author: jstrieb

.github/workflows/main.yml

@@ -23,7 +23,7 @@ jobs:
 
     - uses: mlugg/setup-zig@d1434d08867e3ee9daa34448df10607b98908d29  # v2 tag
       with:
-        version: 0.15.2
+        version: 0.16.0
 
     - name: Build
       run: |

.github/workflows/release.yml

@@ -18,7 +18,7 @@ jobs:
 
     - uses: mlugg/setup-zig@d1434d08867e3ee9daa34448df10607b98908d29  # v2 tag
       with:
-        version: 0.15.2
+        version: 0.16.0
         # I only want to disable the build cache, but don't see a good way to do
         # that besides disabling all of the caching
         use-cache: false

build.zig

@@ -7,11 +7,11 @@ pub fn build(b: *std.Build) !void {
         .preferred_optimize_mode = .ReleaseSafe,
     });
     var version: []const u8 = @import("build.zig.zon").version;
-    if (git.isInstalled(b.allocator)) {
+    if (git.isInstalled(b.allocator, b.graph.io)) {
         version = try std.fmt.allocPrint(
             b.allocator,
             "{s} ({s})",
-            .{ version, try git.currentCommit(b.allocator) },
+            .{ version, try git.currentCommit(b.allocator, b.graph.io) },
         );
     }
     const options = b.addOptions();

build.zig.zon

@@ -2,7 +2,7 @@
     .name = .github_stats,
     .version = "2.0.0",
     .fingerprint = 0x80bb05a632422e37, // Changing this has security and trust implications.
-    .minimum_zig_version = "0.15.2",
+    .minimum_zig_version = "0.16.0",
     .dependencies = .{},
     .paths = .{
         "build.zig",

src/argparse.zig

@@ -6,18 +6,22 @@ var stdout: *std.Io.Writer = undefined;
 var stderr: *std.Io.Writer = undefined;
 
 pub fn parse(
-    allocator: std.mem.Allocator,
+    init: std.process.Init,
     T: type,
     errorCheck: ?fn (args: T, stderr: *std.Io.Writer) anyerror!bool,
 ) !T {
-    var stdout_writer = std.fs.File.stdout().writer(&.{});
+    const allocator = init.gpa;
+    const io = init.io;
+
+    var stdout_writer = std.Io.File.stdout().writer(io, &.{});
     stdout = &stdout_writer.interface;
-    var stderr_writer = std.fs.File.stderr().writer(&.{});
+    var stderr_writer = std.Io.File.stderr().writer(io, &.{});
     stderr = &stderr_writer.interface;
 
     var arena: std.heap.ArenaAllocator = .init(allocator);
     defer arena.deinit();
     const a = arena.allocator();
+    const args = try init.minimal.args.toSlice(a);
 
     const fields = @typeInfo(T).@"struct".fields;
     var seen = [_]bool{false} ** fields.len;
@@ -30,10 +34,8 @@ pub fn parse(
         }
     }
 
-    const args = try std.process.argsAlloc(a);
-    defer std.process.argsFree(a, args);
     try setFromCli(T, allocator, &arena, args, &seen, &result);
-    try setFromEnv(T, allocator, &arena, &seen, &result);
+    try setFromEnv(T, allocator, &arena, &seen, &result, init.environ_map);
     try setFromDefaults(T, allocator, &seen, &result);
 
     inline for (fields, seen) |field, seen_field| {
@@ -139,10 +141,9 @@ fn setFromEnv(
     arena: *std.heap.ArenaAllocator,
     seen: []bool,
     result: *T,
+    env: *std.process.Environ.Map,
 ) !void {
     const a = arena.allocator();
-    var env = try std.process.getEnvMap(a);
-    defer env.deinit();
     var iterator = env.iterator();
     while (iterator.next()) |entry| {
         const key = try a.dupe(u8, entry.key_ptr.*);

src/git.zig

@@ -2,45 +2,44 @@ const std = @import("std");
 
 var is_installed: ?bool = null;
 
-pub fn isInstalled(gpa: std.mem.Allocator) bool {
+pub fn isInstalled(gpa: std.mem.Allocator, io: std.Io) bool {
     if (is_installed) |v| {
         return v;
     }
     var arena = std.heap.ArenaAllocator.init(gpa);
     defer arena.deinit();
-    const run = std.process.Child.run(.{
-        .allocator = arena.allocator(),
+    const run = std.process.run(arena.allocator(), io, .{
         .argv = &.{ "git", "--version" },
     }) catch {
         is_installed = false;
         return is_installed.?;
     };
     is_installed = switch (run.term) {
-        .Exited => |v| v == 0,
+        .exited => |v| v == 0,
         else => false,
     };
     return is_installed.?;
 }
 
-pub fn currentCommit(gpa: std.mem.Allocator) ![]const u8 {
-    if (!isInstalled(gpa)) return error.GitNotInstalled;
+pub fn currentCommit(gpa: std.mem.Allocator, io: std.Io) ![]const u8 {
+    if (!isInstalled(gpa, io)) return error.GitNotInstalled;
     var arena = std.heap.ArenaAllocator.init(gpa);
     defer arena.deinit();
-    const run = try std.process.Child.run(.{
-        .allocator = arena.allocator(),
+    const run = try std.process.run(arena.allocator(), io, .{
         .argv = &.{ "git", "rev-parse", "HEAD" },
     });
     return try gpa.dupe(u8, run.stdout[0..8]);
 }
 
 pub fn getLinesChanged(
     gpa: std.mem.Allocator,
+    io: std.Io,
     login: []const u8,
     token: []const u8,
     repo: []const u8,
     emails: []const []const u8,
 ) !u32 {
-    if (!isInstalled(gpa)) return error.GitNotInstalled;
+    if (!isInstalled(gpa, io)) return error.GitNotInstalled;
     var arena = std.heap.ArenaAllocator.init(gpa);
     defer arena.deinit();
     const allocator = arena.allocator();
@@ -51,8 +50,7 @@ pub fn getLinesChanged(
         "https://{s}:{s}@github.com/{s}.git",
         .{ login, token, repo },
     );
-    const clone = try std.process.Child.run(.{
-        .allocator = allocator,
+    const clone = try std.process.run(allocator, io, .{
         .argv = &.{
             "git",
             "clone",
@@ -65,10 +63,10 @@ pub fn getLinesChanged(
         },
     });
     switch (clone.term) {
-        .Exited => |v| if (v != 0) return error.CloneFailed,
+        .exited => |v| if (v != 0) return error.CloneFailed,
         else => return error.CloneFailed,
     }
-    defer std.fs.cwd().deleteTree(repo_path) catch {};
+    defer std.Io.Dir.cwd().deleteTree(io, repo_path) catch {};
 
     const email_args = try allocator.alloc([]const u8, emails.len * 2);
     for (emails, 0..) |email, i| {
@@ -86,13 +84,9 @@ pub fn getLinesChanged(
         },
         email_args,
     });
-    const log = try std.process.Child.run(.{
-        .allocator = allocator,
-        .argv = log_args,
-        .max_output_bytes = 64 * 1024 * 1024,
-    });
+    const log = try std.process.run(allocator, io, .{ .argv = log_args });
     switch (log.term) {
-        .Exited => |v| if (v != 0) return error.LogFailed,
+        .exited => |v| if (v != 0) return error.LogFailed,
         else => return error.LogFailed,
     }
 

src/http_client.zig

@@ -5,6 +5,7 @@
 const std = @import("std");
 
 allocator: std.mem.Allocator,
+io: std.Io,
 client: std.http.Client,
 bearer: []const u8,
 token: []const u8,
@@ -21,14 +22,15 @@ const Request = struct {
     extra_headers: []const std.http.Header = &.{},
 };
 
-pub fn init(allocator: std.mem.Allocator, token: []const u8) !Self {
+pub fn init(allocator: std.mem.Allocator, io: std.Io, token: []const u8) !Self {
     const bearer = try std.fmt.allocPrint(allocator, "Bearer {s}", .{token});
     errdefer allocator.free(bearer);
     const cloned_token = try allocator.dupe(u8, token);
     errdefer allocator.free(cloned_token);
     return .{
         .allocator = allocator,
-        .client = .{ .allocator = allocator },
+        .io = io,
+        .client = .{ .allocator = allocator, .io = io },
         .bearer = bearer,
         .token = cloned_token,
     };
@@ -49,7 +51,7 @@ pub fn fetch(self: *Self, request: Request, retries: isize) !Response {
         try std.Io.Writer.Allocating.initCapacity(self.allocator, 1024);
     var writer_initialized = true;
     errdefer if (writer_initialized) writer.deinit();
-    const status = (try (self.client.fetch(.{
+    const status = (self.client.fetch(.{
         .location = .{ .url = request.url },
         .response_writer = &writer.writer,
         .payload = request.body,
@@ -67,13 +69,13 @@ pub fn fetch(self: *Self, request: Request, retries: isize) !Response {
                 .{},
             );
             self.client.deinit();
-            self.client = .{ .allocator = self.allocator };
+            self.client = .{ .allocator = self.allocator, .io = self.io };
             writer.deinit();
             writer_initialized = false;
             return self.fetch(request, retries - 1);
         },
-        else => err,
-    })).status;
+        else => return err,
+    }).status;
     return .{
         .body = try writer.toOwnedSlice(),
         .status = status,