feat: adopt with Zig 0.15 (#114)

Close #112

Author: jiacai2050

.github/workflows/ci.yml

@@ -27,7 +27,7 @@ jobs:
       fail-fast: false
       matrix:
         os: [ubuntu-latest, macos-latest]
-        zig-version: [0.14.1]
+        zig-version: [0.15.1]
     steps:
       - uses: actions/checkout@v4
       - uses: mlugg/setup-zig@v2

README.md

@@ -9,7 +9,7 @@
 
 [Zig cookbook](https://github.com/zigcc/zig-cookbook) is a collection of simple Zig programs that demonstrate good practices to accomplish common programming tasks.
 
-> - Main branch tracks Zig 0.14.0 and master, and are tested on Linux and macOS via GitHub actions.
+> - Main branch tracks Zig 0.15.x, and is tested on Linux and macOS via GitHub actions.
 > - Earlier Zig support could be found in [other branches](https://github.com/zigcc/zig-cookbook/branches).
 
 # How to use

assets/src/01-01.zig

@@ -3,36 +3,17 @@ const fs = std.fs;
 const print = std.debug.print;
 
 pub fn main() !void {
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
-    defer _ = gpa.deinit();
-    const allocator = gpa.allocator();
-
     const file = try fs.cwd().openFile("tests/zig-zen.txt", .{});
     defer file.close();
 
-    // Wrap the file reader in a buffered reader.
-    // Since it's usually faster to read a bunch of bytes at once.
-    var buf_reader = std.io.bufferedReader(file.reader());
-    const reader = buf_reader.reader();
-
-    var line = std.ArrayList(u8).init(allocator);
-    defer line.deinit();
-
-    const writer = line.writer();
+    var file_buffer: [4096]u8 = undefined;
+    var reader = file.reader(&file_buffer);
     var line_no: usize = 0;
-    while (reader.streamUntilDelimiter(writer, '\n', null)) {
-        // Clear the line so we can reuse it.
-        defer line.clearRetainingCapacity();
+    while (reader.interface.takeDelimiterExclusive('\n')) |line| {
         line_no += 1;
-
-        print("{d}--{s}\n", .{ line_no, line.items });
+        print("{d}--{s}\n", .{ line_no, line });
     } else |err| switch (err) {
-        error.EndOfStream => { // end of file
-            if (line.items.len > 0) {
-                line_no += 1;
-                print("{d}--{s}\n", .{ line_no, line.items });
-            }
-        },
+        error.EndOfStream => {}, // Normal termination
         else => return err, // Propagate error
     }
 

assets/src/01-02.zig

@@ -21,8 +21,8 @@ pub fn main() !void {
     // Before mmap, we need to ensure file isn't empty
     try file.setEndPos(content_to_write.len);
 
-    const md = try file.metadata();
-    try std.testing.expectEqual(md.size(), content_to_write.len);
+    const md = try file.stat();
+    try std.testing.expectEqual(md.size, content_to_write.len);
 
     const ptr = try std.posix.mmap(
         null,

assets/src/02-01.zig

@@ -9,13 +9,13 @@ fn sha256_digest(
     file: fs.File,
 ) ![Sha256.digest_length]u8 {
     var sha256 = Sha256.init(.{});
-    const rdr = file.reader();
-
-    var buf: [BUF_SIZE]u8 = undefined;
-    var n = try rdr.read(&buf);
+    var file_buf: [BUF_SIZE]u8 = undefined;
+    var reader = file.reader(&file_buf);
+    var read_buf: [BUF_SIZE]u8 = undefined;
+    var n = try reader.interface.readSliceShort(&read_buf);
     while (n != 0) {
-        sha256.update(buf[0..n]);
-        n = try rdr.read(&buf);
+        sha256.update(read_buf[0..n]);
+        n = try reader.interface.readSliceShort(&read_buf);
     }
 
     return sha256.finalResult();
@@ -32,8 +32,8 @@ pub fn main() !void {
     const digest = try sha256_digest(file);
     const hex_digest = try std.fmt.allocPrint(
         allocator,
-        "{s}",
-        .{std.fmt.fmtSliceHexLower(&digest)},
+        "{x}",
+        .{&digest},
     );
     defer allocator.free(hex_digest);
 

assets/src/03-01.zig

@@ -6,7 +6,7 @@ const print = std.debug.print;
 
 fn expensive_function() void {
     // sleep 500ms
-    time.sleep(time.ns_per_ms * 500);
+    std.Thread.sleep(time.ns_per_ms * 500);
 }
 
 pub fn main() !void {

assets/src/04-01.zig

@@ -1,4 +1,4 @@
-//! Start a TCP server at an unused port.
+//! Start an echo TCP server at an unused port.
 //!
 //! Test with
 //! echo "hello zig" | nc localhost <port>
@@ -8,10 +8,6 @@ const net = std.net;
 const print = std.debug.print;
 
 pub fn main() !void {
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
-    defer _ = gpa.deinit();
-    const allocator = gpa.allocator();
-
     const loopback = try net.Ip4Address.parse("127.0.0.1", 0);
     const localhost = net.Address{ .in = loopback };
     var server = try localhost.listen(.{
@@ -22,13 +18,31 @@ pub fn main() !void {
     const addr = server.listen_address;
     print("Listening on {}, access this port to end the program\n", .{addr.getPort()});
 
-    var client = try server.accept();
-    defer client.stream.close();
-
-    print("Connection received! {} is sending data.\n", .{client.address});
-
-    const message = try client.stream.reader().readAllAlloc(allocator, 1024);
-    defer allocator.free(message);
+    const client = try server.accept();
+    // In real world, you'd want to handle multiple clients, probably in separate threads.
+    try handleClient(client);
+}
 
-    print("{} says {s}\n", .{ client.address, message });
+fn handleClient(client: net.Server.Connection) !void {
+    print("Accepted connection from {f}\n", .{client.address});
+    defer client.stream.close();
+    var stream_buf: [1024]u8 = undefined;
+    var reader = client.stream.reader(&stream_buf);
+    // Here we echo back what we read directly, so the writer buffer is empty
+    var writer = client.stream.writer(&.{});
+
+    while (true) {
+        print("Waiting for data from {f}...\n", .{client.address});
+        const msg = reader.interface().takeDelimiterInclusive('\n') catch |err| {
+            if (err == error.EndOfStream) {
+                print("{f} closed the connection\n", .{client.address});
+                return;
+            } else {
+                return err;
+            }
+        };
+        print("{f} says {s}", .{ client.address, msg });
+        try writer.interface.writeAll(msg);
+        // No need to flush, as writer buffer is empty
+    }
 }

assets/src/04-02.zig

@@ -16,13 +16,13 @@ pub fn main() !void {
     // Connect to peer
     const stream = try net.tcpConnectToAddress(peer);
     defer stream.close();
-    print("Connecting to {}\n", .{peer});
+    print("Connecting to {f}\n", .{peer});
 
     // Sending data to peer
     const data = "hello zig";
-    var writer = stream.writer();
-    const size = try writer.write(data);
-    print("Sending '{s}' to peer, total written: {d} bytes\n", .{ data, size });
-    // Or just using `writer.writeAll`
-    // try writer.writeAll("hello zig");
+    var buffer: [1024]u8 = undefined;
+    var writer = stream.writer(buffer[0..]);
+    try writer.interface.writeAll(data);
+    try writer.interface.flush();
+    print("Sending '{s}' to peer, total written: {d} bytes\n", .{ data, data.len });
 }

assets/src/04-03.zig

@@ -30,7 +30,7 @@ pub fn main() !void {
 
     var buf: [1024]u8 = undefined;
 
-    print("Listen on {any}...\n", .{addr});
+    print("Listen on {f}\n", .{addr});
 
     // we did not set the NONBLOCK flag (socket type flag),
     // so the program will wait until data is received

assets/src/05-01.zig

@@ -13,24 +13,22 @@ pub fn main() !void {
     const uri = try std.Uri.parse("http://httpbin.org/headers");
     const buf = try allocator.alloc(u8, 1024 * 8);
     defer allocator.free(buf);
-    var req = try client.open(.GET, uri, .{
-        .server_header_buffer = buf,
+    var req = try client.request(.GET, uri, .{
+        .extra_headers = &.{.{ .name = "Custom-header", .value = "Custom Value" }},
     });
     defer req.deinit();
 
-    try req.send();
-    try req.finish();
-    try req.wait();
+    try req.sendBodiless();
 
-    var iter = req.response.iterateHeaders();
+    var redirect_buffer: [1024]u8 = undefined;
+    var response = try req.receiveHead(&redirect_buffer);
+    var iter = response.head.iterateHeaders();
     while (iter.next()) |header| {
         std.debug.print("Name:{s}, Value:{s}\n", .{ header.name, header.value });
     }
 
-    try std.testing.expectEqual(req.response.status, .ok);
-
-    var rdr = req.reader();
-    const body = try rdr.readAllAlloc(allocator, 1024 * 1024 * 4);
+    try std.testing.expectEqual(response.head.status, .ok);
+    const body = try response.reader(&.{}).allocRemaining(allocator, .unlimited);
     defer allocator.free(body);
 
     print("Body:\n{s}\n", .{body});