convert to Zig 0.16 (except tests, coming soon)

Author: bradcypert

.gitignore

@@ -1,3 +1,4 @@
 .zig-cache/
+zig-pkg/
 zig-out/
-.DS_Store
+.DS_Store

.tool-versions

@@ -1 +1 @@
-zig latest
+zig 0.16.0

build.zig

@@ -15,20 +15,20 @@ pub fn build(b: *std.Build) void {
         .root_source_file = b.path("src/main.zig"),
         .target = target,
         .optimize = optimize,
+        .link_libc = true,
     });
 
     const exe = b.addExecutable(.{
         .name = exe_name,
         .root_module = exe_mod,
+        .use_llvm = true,
     });
 
     for (dependencies) |dependency| {
         const dep = b.dependency(dependency, .{ .target = target, .optimize = optimize });
         exe.root_module.addImport(dependency, dep.module(dependency));
     }
 
-    exe.linkLibC();
-
     b.installArtifact(exe);
 
     const run_cmd = b.addRunArtifact(exe);
@@ -85,10 +85,13 @@ pub fn build(b: *std.Build) void {
 }
 
 fn findZigFiles(b: *std.Build, files: *std.ArrayList([]const u8), dir_path: []const u8) !void {
-    var dir = try std.fs.cwd().openDir(dir_path, .{ .iterate = true });
-    defer dir.close();
+    var threaded = std.Io.Threaded.init_single_threaded;
+    const io = threaded.io();
+    const cwd = std.Io.Dir.cwd();
+    var dir = try std.Io.Dir.openDir(cwd, io, dir_path, .{ .iterate = true });
+    defer dir.close(io);
     var it = dir.iterate();
-    while (try it.next()) |entry| {
+    while (try it.next(io)) |entry| {
         if (entry.kind == .file and std.mem.endsWith(u8, entry.name, ".zig")) {
             const full_path = try std.fs.path.join(b.allocator, &[_][]const u8{ dir_path, entry.name });
             try files.append(b.allocator, full_path);

build.zig.zon

@@ -37,16 +37,16 @@
     // internet connectivity.
     .dependencies = .{
         .clap = .{
-            .url = "git+https://github.com/Hejsil/zig-clap#5289e0753cd274d65344bef1c114284c633536ea",
-            .hash = "clap-0.11.0-oBajB-HnAQDPCKYzwF7rO3qDFwRcD39Q0DALlTSz5H7e",
+            .url = "git+https://github.com/Hejsil/zig-clap?ref=HEAD#8d97efa1ee1e575443c7888d5c38e1c3fc145cf5",
+            .hash = "clap-0.12.0-oBajB7foAQDqlSwaSG5g0yq7xGbQARUsBk5T64gAOqP5",
         },
         .regex = .{
-            .url = "git+https://github.com/bradcypert/zig-regex.git#05f641c08939f131bb82195855efa7afaf7566eb",
-            .hash = "regex-0.1.2-axC350bnAQCyrPkH2IEfri8hebJO6IujGY1rhcgZBXpL",
+            .url = "git+https://github.com/tiehuis/zig-regex?ref=HEAD#49c5694c8b3ee4ae4a7131035a44a69841ef4740",
+            .hash = "regex-0.1.3-axC357jaAQBRENglwG9NTcuej8pYz1IZmfwER_AXMlHZ",
         },
         .curl = .{
-            .url = "git+https://github.com/jiacai2050/zig-curl/?ref=HEAD#1a23d311582c1e72bdb9ec3020f82b8e2a4b8c8a",
-            .hash = "curl-0.3.1-P4tT4cPNAAAZsLz5AsgitsBp3W0uVpoFT7IeNX2qOQlP",
+            .url = "git+https://github.com/jiacai2050/zig-curl?ref=HEAD#f701e602d962e149338521e9848528a372c05966",
+            .hash = "curl-0.5.1-P4tT4VsCAQBQ_kA6SBylS7sDyKXdcnuv-13p21ZNx8Az",
         },
     },
     .paths = .{

src/httpfile/assertion_checker.zig

@@ -189,7 +189,7 @@ fn checkAssertion(
         .equal => {
             if (std.ascii.eqlIgnoreCase(assertion.key, "status")) {
                 const assert_status_code = try std.fmt.parseInt(u16, assertion.value, 10);
-                const expected_status = try std.meta.intToEnum(http.Status, assert_status_code);
+                const expected_status = std.enums.fromInt(http.Status, assert_status_code) orelse return error.UnsupportedStatusCode;
                 if (response.status != expected_status) {
                     const actual_str = try std.fmt.allocPrint(diagnostic.allocator, "{d}", .{@intFromEnum(response.status.?)});
                     defer diagnostic.allocator.free(actual_str);
@@ -214,7 +214,7 @@ fn checkAssertion(
         .not_equal => {
             if (std.ascii.eqlIgnoreCase(assertion.key, "status")) {
                 const assert_status_code = try std.fmt.parseInt(u16, assertion.value, 10);
-                const expected_status = try std.meta.intToEnum(http.Status, assert_status_code);
+                const expected_status = std.enums.fromInt(http.Status, assert_status_code) orelse return error.UnsupportedStatusCode;
                 if (response.status == expected_status) {
                     const actual_str = try std.fmt.allocPrint(diagnostic.allocator, "{d}", .{@intFromEnum(response.status.?)});
                     defer diagnostic.allocator.free(actual_str);

src/httpfile/http_client.zig

@@ -40,10 +40,10 @@ pub const HttpClient = struct {
     allocator: Allocator,
     client: http.Client,
 
-    pub fn init(allocator: Allocator) HttpClient {
+    pub fn init(io: std.Io, allocator: Allocator) HttpClient {
         return .{
             .allocator = allocator,
-            .client = http.Client{ .allocator = allocator },
+            .client = http.Client{ .allocator = allocator, .io = io },
         };
     }
 
@@ -65,9 +65,9 @@ pub const HttpClient = struct {
 
     /// Executes a single HTTP request and returns the response.
     pub fn execute(self: *HttpClient, request: *const httpfiles.HttpRequest) !HttpResponse {
-        const ca_bundle = try curl.allocCABundle(self.allocator);
-        defer ca_bundle.deinit();
-        const easy = try curl.Easy.init(.{
+        var ca_bundle = try curl.allocCABundle(self.allocator, self.client.io);
+        defer ca_bundle.deinit(self.allocator);
+        var easy = try curl.Easy.init(.{
             .ca_bundle = ca_bundle,
         });
 

src/httpfile/parser.zig

@@ -86,10 +86,12 @@ pub const HttpRequest = struct {
     }
 };
 
-pub fn parseFile(allocator: Allocator, file_path: []const u8) !ArrayList(HttpRequest) {
-    const file = try std.fs.cwd().openFile(file_path, .{});
-    defer file.close();
-    const file_content = try file.readToEndAlloc(allocator, std.math.maxInt(usize));
+pub fn parseFile(io: std.Io, allocator: Allocator, file_path: []const u8) !ArrayList(HttpRequest) {
+    const cwd = std.Io.Dir.cwd();
+    const file = try cwd.openFile(io, file_path, .{});
+    defer file.close(io);
+    var file_reader = file.reader(io, &.{});
+    const file_content = try file_reader.interface.allocRemaining(allocator, std.Io.Limit.unlimited);
     defer allocator.free(file_content);
     return try parseContent(allocator, file_content);
 }

src/main.zig

@@ -6,32 +6,27 @@ const Client = @import("./httpfile/http_client.zig");
 const AssertionChecker = @import("./httpfile/assertion_checker.zig");
 const TestReporter = @import("./reporters/test_reporter.zig");
 
-pub fn main() !void {
+pub fn main(init: std.process.Init) !void {
     // Use a debug allocator for leak detection.
-    var debug = std.heap.DebugAllocator(.{}){};
-    defer _ = debug.deinit();
-    const allocator = debug.allocator();
+    const allocator = init.gpa;
 
     var stdout_buffer: [1024]u8 = undefined;
-    var stdout_writer = std.fs.File.stdout().writer(&stdout_buffer);
+    var stdout_writer = std.Io.File.stdout().writer(init.io, &stdout_buffer);
     const stdout = &stdout_writer.interface;
     defer stdout.flush() catch {};
 
     var stderr_buffer: [1024]u8 = undefined;
-    var stderr_writer = std.fs.File.stderr().writer(&stderr_buffer);
+    var stderr_writer = std.Io.File.stderr().writer(init.io, &stderr_buffer);
     const stderr = &stderr_writer.interface;
     defer stderr.flush() catch {};
 
-    // Determine thread count from environment.
-    const threads = std.process.parseEnvVarInt("HTTP_THREAD_COUNT", usize, 10) catch 1;
-
     // Parse CLI arguments.
     const params = comptime clap.parseParamsComptime(
         \\-h, --help            Display this help and exit
         \\<str>...              Executes the HTTP specs in the provided files (if omitted, all files in subdirectories will be ran instead)
     );
     var diag = clap.Diagnostic{};
-    var res = clap.parse(clap.Help, &params, clap.parsers.default, .{
+    var res = clap.parse(clap.Help, &params, clap.parsers.default, init.minimal.args, .{
         .diagnostic = &diag,
         .allocator = allocator,
     }) catch |err| {
@@ -51,38 +46,33 @@ pub fn main() !void {
         for (files.items) |file| allocator.free(file);
         files.deinit(allocator);
     }
-    try collectSpecFiles(allocator, &files, res);
+    try collectSpecFiles(init.io, allocator, &files, res);
 
-    // Set up thread pool and reporter.
-    var pool: std.Thread.Pool = undefined;
-    try pool.init(.{
-        .allocator = allocator,
-        .n_jobs = threads,
-    });
-    defer pool.deinit();
+    var group: std.Io.Group = .init;
+    errdefer group.cancel(init.io);
 
-    var wg: std.Thread.WaitGroup = .{};
     var reporter = TestReporter.BasicReporter.init();
 
     // Run all tests in parallel.
     for (files.items) |path| {
-        pool.spawnWg(&wg, runTest, .{ allocator, &reporter, path, stderr });
+        group.async(init.io, runTest, .{ init.io, allocator, &reporter, path, stderr });
     }
-    wg.wait();
+    try group.await(init.io);
 
     // Print summary.
     reporter.report(stdout);
 }
 
 /// Collects all HTTP spec files to run, based on CLI args.
 fn collectSpecFiles(
+    io: std.Io,
     allocator: std.mem.Allocator,
     files: *std.ArrayList([]const u8),
     res: anytype,
 ) !void {
     if (res.positionals[0].len == 0) {
         // No args: find all .http/.httpspec files recursively from cwd.
-        const http_files = try listHttpFiles(allocator, ".");
+        const http_files = try listHttpFiles(io, allocator, ".");
         defer allocator.free(http_files);
         for (http_files) |file| try files.append(allocator, file);
     } else {
@@ -93,9 +83,10 @@ fn collectSpecFiles(
             {
                 try files.append(allocator, try allocator.dupe(u8, pos));
             } else {
-                const file_info = try std.fs.cwd().statFile(pos);
+                const cwd = std.Io.Dir.cwd();
+                const file_info = try cwd.statFile(io, pos, .{});
                 if (file_info.kind != .directory) return error.InvalidPositionalArgument;
-                const http_files = try listHttpFiles(allocator, pos);
+                const http_files = try listHttpFiles(io, allocator, pos);
                 defer allocator.free(http_files);
                 for (http_files) |file| try files.append(allocator, file);
             }
@@ -105,38 +96,39 @@ fn collectSpecFiles(
 
 /// Runs all requests in a spec file and updates the reporter.
 fn runTest(
+    io: std.Io,
     base_allocator: std.mem.Allocator,
     reporter: *TestReporter.BasicReporter,
     path: []const u8,
-    stderr: *std.io.Writer,
-) void {
+    stderr: *std.Io.Writer,
+) !void {
     // Create arena allocator for this test to provide memory isolation
     var arena = std.heap.ArenaAllocator.init(base_allocator);
     defer arena.deinit(); // Automatically frees all test allocations
     const allocator = arena.allocator();
 
     var has_failure = false;
-    reporter.incTestCount();
+    try reporter.incTestCount(io);
 
-    var items = HttpParser.parseFile(allocator, path) catch |err| {
-        reporter.incTestInvalid();
+    var items = HttpParser.parseFile(io, allocator, path) catch |err| {
+        try reporter.incTestInvalid(io);
         std.debug.print("Failed to parse file {s}: {s}\n", .{ path, @errorName(err) });
         return;
     };
     const owned_items = items.toOwnedSlice(allocator) catch |err| {
-        reporter.incTestInvalid();
+        try reporter.incTestInvalid(io);
         std.debug.print("Failed to convert items to owned slice in file {s}: {s}\n", .{ path, @errorName(err) });
         return;
     };
     // Note: No need to manually free owned_items since arena will handle it
 
-    var client = Client.HttpClient.init(allocator);
+    var client = Client.HttpClient.init(io, allocator);
     defer client.deinit();
 
     for (owned_items) |*owned_item| {
         // Note: No need to manually deinit owned_item since arena will handle it
         var responses = client.execute(owned_item) catch |err| {
-            reporter.incTestInvalid();
+            try reporter.incTestInvalid(io);
             std.debug.print("Failed to execute request in file {s}: {s}\n", .{ path, @errorName(err) });
             return;
         };
@@ -151,33 +143,34 @@ fn runTest(
         }
     }
     if (!has_failure) {
-        reporter.incTestPass();
+        try reporter.incTestPass(io);
     } else {
-        reporter.incTestFail();
+        try reporter.incTestFail(io);
     }
 }
 
 /// Recursively finds all .http/.httpspec files in a directory.
-fn listHttpFiles(allocator: std.mem.Allocator, dir: []const u8) ![][]const u8 {
+fn listHttpFiles(io: std.Io, allocator: std.mem.Allocator, dir_path: []const u8) ![][]const u8 {
     var files: std.ArrayList([]const u8) = .empty;
     defer files.deinit(allocator);
 
-    var dir_entry = try std.fs.cwd().openDir(dir, .{ .iterate = true });
-    defer dir_entry.close();
+    const cwd = std.Io.Dir.cwd();
+    var dir_entry = try std.Io.Dir.openDir(cwd, io, dir_path, .{ .iterate = true });
+    defer dir_entry.close(io);
 
     var it = dir_entry.iterate();
-    while (try it.next()) |entry| {
+    while (try it.next(io)) |entry| {
         if (entry.kind == .directory) {
             if (std.mem.eql(u8, entry.name, ".") or std.mem.eql(u8, entry.name, "..")) continue;
-            const subdir = try std.fs.path.join(allocator, &[_][]const u8{ dir, entry.name });
+            const subdir = try std.fs.path.join(allocator, &[_][]const u8{ dir_path, entry.name });
             defer allocator.free(subdir);
-            const sub_files = try listHttpFiles(allocator, subdir);
+            const sub_files = try listHttpFiles(io, allocator, subdir);
             defer allocator.free(sub_files);
             for (sub_files) |file| try files.append(allocator, file);
         } else if (std.mem.eql(u8, std.fs.path.extension(entry.name), ".http") or
             std.mem.eql(u8, std.fs.path.extension(entry.name), ".httpspec"))
         {
-            const file_path = try std.fs.path.join(allocator, &[_][]const u8{ dir, entry.name });
+            const file_path = try std.fs.path.join(allocator, &[_][]const u8{ dir_path, entry.name });
             try files.append(allocator, file_path);
         }
     }

src/reporters/test_reporter.zig

@@ -5,15 +5,15 @@ pub const BasicReporter = struct {
     test_pass: usize,
     test_fail: usize,
     test_invalid: usize,
-    m: std.Thread.Mutex,
+    m: std.Io.Mutex,
 
     pub fn init() BasicReporter {
         return .{
             .test_count = 0,
             .test_pass = 0,
             .test_fail = 0,
             .test_invalid = 0,
-            .m = std.Thread.Mutex{},
+            .m = .init,
         };
     }
 
@@ -31,24 +31,24 @@ pub const BasicReporter = struct {
         };
     }
 
-    pub fn incTestCount(self: *BasicReporter) void {
-        self.m.lock();
-        defer self.m.unlock();
+    pub fn incTestCount(self: *BasicReporter, io: std.Io) !void {
+        try self.m.lock(io);
+        defer self.m.unlock(io);
         self.test_count += 1;
     }
-    pub fn incTestPass(self: *BasicReporter) void {
-        self.m.lock();
-        defer self.m.unlock();
+    pub fn incTestPass(self: *BasicReporter, io: std.Io) !void {
+        try self.m.lock(io);
+        defer self.m.unlock(io);
         self.test_pass += 1;
     }
-    pub fn incTestFail(self: *BasicReporter) void {
-        self.m.lock();
-        defer self.m.unlock();
+    pub fn incTestFail(self: *BasicReporter, io: std.Io) !void {
+        try self.m.lock(io);
+        defer self.m.unlock(io);
         self.test_fail += 1;
     }
-    pub fn incTestInvalid(self: *BasicReporter) void {
-        self.m.lock();
-        defer self.m.unlock();
+    pub fn incTestInvalid(self: *BasicReporter, io: std.Io) !void {
+        try self.m.lock(io);
+        defer self.m.unlock(io);
         self.test_invalid += 1;
     }
 };