diff --git a/build.zig b/build.zig index a936832..897840c 100644 --- a/build.zig +++ b/build.zig @@ -24,7 +24,7 @@ comptime { \\ \\Ziglings requires development build \\ - \\{} + \\{s} \\ \\or higher. \\ @@ -34,7 +34,7 @@ comptime { \\ \\ ; - @compileError(std.fmt.comptimePrint(error_message, .{min_zig})); + @compileError(std.fmt.comptimePrint(error_message, .{required_zig})); } } @@ -123,10 +123,12 @@ pub const logo = const progress_filename = ".progress.txt"; pub fn build(b: *Build) !void { + const io = b.graph.io; + // const io = std.Options.debug_io; if (!validate_exercises()) std.process.exit(2); use_color_escapes = false; - if (std.fs.File.stderr().supportsAnsiEscapeCodes()) { + if (try std.Io.File.stderr().supportsAnsiEscapeCodes(io)) { use_color_escapes = true; } else if (builtin.os.tag == .windows) { const w32 = struct { @@ -245,9 +247,9 @@ pub fn build(b: *Build) !void { } if (reset) |_| { - std.fs.cwd().deleteFile(progress_filename) catch |err| { + std.Io.Dir.cwd().deleteFile(io, progress_filename) catch |err| { switch (err) { - std.fs.Dir.DeleteFileError.FileNotFound => {}, + std.Io.Dir.DeleteFileError.FileNotFound => {}, else => { print("Unable to remove progress file, Error: {}\n", .{err}); return err; @@ -268,17 +270,20 @@ pub fn build(b: *Build) !void { var starting_exercise: u32 = 0; - if (std.fs.cwd().openFile(progress_filename, .{})) |progress_file| { - defer progress_file.close(); + if (std.Io.Dir.cwd().openFile(io, progress_filename, .{})) |progress_file| { + defer progress_file.close(io); - const progress_file_size = try progress_file.getEndPos(); + const progress_file_size = try progress_file.length(io); var gpa = std.heap.GeneralPurposeAllocator(.{}){}; defer _ = gpa.deinit(); const allocator = gpa.allocator(); const contents = try allocator.alloc(u8, progress_file_size); defer allocator.free(contents); - const bytes_read = try progress_file.read(contents); + var file_buffer: [1024]u8 = undefined; + var file_reader = progress_file.reader(io, &file_buffer); + // try file_reader.interface.readSliceAll(contents); + const bytes_read = try file_reader.interface.readSliceShort(contents); if (bytes_read != progress_file_size) { return error.UnexpectedEOF; } @@ -286,7 +291,7 @@ pub fn build(b: *Build) !void { starting_exercise = try std.fmt.parseInt(u32, contents, 10); } else |err| { switch (err) { - std.fs.File.OpenError.FileNotFound => { + std.Io.File.OpenError.FileNotFound => { // This is fine, may be the first time tests are run or progress have been reset }, else => { @@ -382,15 +387,16 @@ const ZiglingStep = struct { fn run(self: *ZiglingStep, exe_path: []const u8, _: std.Progress.Node) !void { resetLine(); - print("Checking: {s}\n", .{self.exercise.main_file}); - const b = self.step.owner; + const io = b.graph.io; + + print("Checking: {s}\n", .{self.exercise.main_file}); // Allow up to 1 MB of stdout capture. const max_output_bytes = 1 * 1024 * 1024; - const result = Child.run(.{ - .allocator = b.allocator, + const result = Child.run(b.allocator, io, .{ + // .allocator = b.allocator, .argv = &.{exe_path}, .cwd = b.build_root.path.?, .cwd_dir = b.build_root.handle, @@ -409,6 +415,7 @@ const ZiglingStep = struct { fn check_output(self: *ZiglingStep, result: Child.RunResult) !void { const b = self.step.owner; + const io = b.graph.io; // Make sure it exited cleanly. switch (result.term) { @@ -456,14 +463,15 @@ const ZiglingStep = struct { const progress = try std.fmt.allocPrint(b.allocator, "{d}", .{self.exercise.number()}); defer b.allocator.free(progress); - const file = try std.fs.cwd().createFile( + const file = try std.Io.Dir.cwd().createFile( + io, progress_filename, .{ .read = true, .truncate = true }, ); - defer file.close(); + defer file.close(io); - try file.writeAll(progress); - try file.sync(); + try file.writeStreamingAll(io, progress); + try file.sync(io); print("{s}PASSED:\n{s}{s}\n\n", .{ green_text, output, reset_text }); } @@ -558,6 +566,8 @@ const ZiglingStep = struct { fn printErrors(self: *ZiglingStep) void { resetLine(); + const b = self.step.owner; + const io = b.graph.io; // Display error/warning messages. if (self.step.result_error_msgs.items.len > 0) { @@ -575,7 +585,10 @@ const ZiglingStep = struct { else .off; if (self.step.result_error_bundle.errorMessageCount() > 0) { - self.step.result_error_bundle.renderToStdErr(.{}, color); + self.step.result_error_bundle.renderToStderr(io, .{}, color) catch |err| { + print("{}\n", .{err}); + return; + }; } } }; diff --git a/exercises/026_hello2.zig b/exercises/026_hello2.zig index 582dba9..97ea918 100644 --- a/exercises/026_hello2.zig +++ b/exercises/026_hello2.zig @@ -15,8 +15,12 @@ const std = @import("std"); // https://ziglang.org/documentation/master/#Inferred-Error-Sets // pub fn main() !void { + // We need an io instance for I/O operations; + // we'll learn how to create them later. + const io = std.Options.debug_io; + // We get a Writer for Standard Out so we can print() to it. - var stdout = std.fs.File.stdout().writer(&.{}); + var stdout = std.Io.File.stdout().writer(io, &.{}); // Unlike std.debug.print(), the Standard Out writer can fail // with an error. We don't care _what_ the error is, we want diff --git a/patches/patches/026_hello2.patch b/patches/patches/026_hello2.patch index f99cc67..7fde1d8 100644 --- a/patches/patches/026_hello2.patch +++ b/patches/patches/026_hello2.patch @@ -1,6 +1,6 @@ ---- exercises/026_hello2.zig 2025-07-22 09:55:51.337832401 +0200 -+++ answers/026_hello2.zig 2025-07-22 10:00:11.233348058 +0200 -@@ -23,5 +23,5 @@ +--- exercises/026_hello2.zig 2025-12-27 21:15:21.403899392 +0100 ++++ answers/026_hello2.zig 2025-12-27 20:28:53.267236800 +0100 +@@ -27,5 +27,5 @@ // to be able to pass it up as a return value of main(). // // We just learned of a single statement which can accomplish this. diff --git a/test/tests.zig b/test/tests.zig index 9a8e9e9..795967a 100644 --- a/test/tests.zig +++ b/test/tests.zig @@ -3,14 +3,13 @@ const root = @import("../build.zig"); const debug = std.debug; const fmt = std.fmt; -const fs = std.fs; const mem = std.mem; const Allocator = std.mem.Allocator; const Child = std.process.Child; const Build = std.Build; const LazyPath = std.Build.LazyPath; -const Reader = fs.File.Reader; +// const Reader = fs.File.Reader; const RunStep = std.Build.RunStep; const Step = Build.Step; @@ -152,17 +151,19 @@ const CheckNamedStep = struct { fn make(step: *Step, _: Step.MakeOptions) !void { const b = step.owner; + const io = b.graph.io; const self: *CheckNamedStep = @alignCast(@fieldParentPtr("step", step)); const ex = self.exercise; - const stderr_file = try fs.cwd().openFile( + const stderr_file = try std.Io.Dir.cwd().openFile( + io, self.stderr.getPath(b), .{ .mode = .read_only }, ); - defer stderr_file.close(); + defer stderr_file.close(io); - var threaded: std.Io.Threaded = .init_single_threaded; - const io = threaded.io(); + // var threaded: std.Io.Threaded = .init_single_threaded; + // const io = threaded.io(); var stderr = stderr_file.readerStreaming(io, &.{}); { // Skip the logo. @@ -206,17 +207,19 @@ const CheckStep = struct { fn make(step: *Step, _: Step.MakeOptions) !void { const b = step.owner; + const io = b.graph.io; const self: *CheckStep = @alignCast(@fieldParentPtr("step", step)); const exercises = self.exercises; - const stderr_file = try fs.cwd().openFile( + const stderr_file = try std.Io.Dir.cwd().openFile( + io, self.stderr.getPath(b), .{ .mode = .read_only }, ); - defer stderr_file.close(); + defer stderr_file.close(io); - var threaded: std.Io.Threaded = .init_single_threaded; - const io = threaded.io(); + // var threaded: std.Io.Threaded = .init_single_threaded; + // const io = threaded.io(); var stderr = stderr_file.readerStreaming(io, &.{}); for (exercises) |ex| { if (ex.number() == 1) { @@ -234,7 +237,7 @@ const CheckStep = struct { } }; -fn check_output(step: *Step, exercise: Exercise, reader: *Reader) !void { +fn check_output(step: *Step, exercise: Exercise, reader: *std.Io.File.Reader) !void { const b = step.owner; var buf: [1024]u8 = undefined; @@ -301,7 +304,7 @@ fn check( } } -fn readLine(reader: *fs.File.Reader, buf: []u8) !?[]const u8 { +fn readLine(reader: *std.Io.File.Reader, buf: []u8) !?[]const u8 { try reader.interface.readSliceAll(buf); return mem.trimEnd(u8, buf, " \r\n"); } @@ -379,8 +382,9 @@ const HealStep = struct { /// Heals all the exercises. fn heal(allocator: Allocator, exercises: []const Exercise, work_path: []const u8) !void { - const sep = std.fs.path.sep_str; - const join = fs.path.join; + const io = std.Options.debug_io; + const sep = std.Io.Dir.path.sep_str; + const join = std.Io.Dir.path.join; const exercises_path = "exercises"; const patches_path = "patches" ++ sep ++ "patches"; @@ -398,19 +402,17 @@ fn heal(allocator: Allocator, exercises: []const Exercise, work_path: []const u8 const argv = &.{ "patch", "-i", patch, "-o", output, "-s", file }; var child = Child.init(argv, allocator); - _ = try child.spawnAndWait(); + _ = try child.spawnAndWait(io); } } /// This function is the same as the one in std.Build.makeTempPath, with the /// difference that returns an error when the temp path cannot be created. pub fn makeTempPath(b: *Build) ![]const u8 { + const io = b.graph.io; const rand_int = std.crypto.random.int(u64); - const rand_hex64 = std.fmt.hex(rand_int); - const tmp_dir_sub_path = "tmp" ++ fs.path.sep_str ++ rand_hex64; - const path = b.cache_root.join(b.allocator, &.{tmp_dir_sub_path}) catch - @panic("OOM"); - try b.cache_root.handle.makePath(tmp_dir_sub_path); - - return path; + const tmp_dir_sub_path = "tmp" ++ std.Io.Dir.path.sep_str ++ std.fmt.hex(rand_int); + const result_path = b.cache_root.join(b.allocator, &.{tmp_dir_sub_path}) catch @panic("OOM"); + try b.cache_root.handle.createDirPath(io, tmp_dir_sub_path); + return result_path; }