From e73b56aa4bcb7e53144ef96ee978f2a19b32669d Mon Sep 17 00:00:00 2001 From: Jimmi Holst Christensen Date: Tue, 22 Oct 2024 17:46:47 +0200 Subject: refactor: Always access using full namespace This is my new preferred style of programming Zig :) --- clap/args.zig | 15 ++---- clap/codepoint_counting_writer.zig | 7 ++- clap/parsers.zig | 55 +++++++++++----------- clap/streaming.zig | 95 +++++++++++++++++--------------------- 4 files changed, 76 insertions(+), 96 deletions(-) (limited to 'clap') diff --git a/clap/args.zig b/clap/args.zig index d0aaee3..6a424e3 100644 --- a/clap/args.zig +++ b/clap/args.zig @@ -1,12 +1,3 @@ -const builtin = @import("builtin"); -const std = @import("std"); - -const debug = std.debug; -const heap = std.heap; -const mem = std.mem; -const process = std.process; -const testing = std.testing; - /// An example of what methods should be implemented on an arg iterator. pub const ExampleArgIterator = struct { pub fn next(iter: *ExampleArgIterator) ?[]const u8 { @@ -35,7 +26,9 @@ test "SliceIterator" { var iter = SliceIterator{ .args = &args }; for (args) |a| - try testing.expectEqualStrings(a, iter.next().?); + try std.testing.expectEqualStrings(a, iter.next().?); - try testing.expectEqual(@as(?[]const u8, null), iter.next()); + try std.testing.expectEqual(@as(?[]const u8, null), iter.next()); } + +const std = @import("std"); diff --git a/clap/codepoint_counting_writer.zig b/clap/codepoint_counting_writer.zig index e6b9d1c..c445c90 100644 --- a/clap/codepoint_counting_writer.zig +++ b/clap/codepoint_counting_writer.zig @@ -1,7 +1,3 @@ -const std = @import("std"); -const builtin = @import("builtin"); -const native_endian = builtin.cpu.arch.endian(); - /// A Writer that counts how many codepoints has been written to it. /// Expects valid UTF-8 input, and does not validate the input. pub fn CodepointCountingWriter(comptime WriterType: type) type { @@ -34,6 +30,7 @@ pub fn CodepointCountingWriter(comptime WriterType: type) type { // the number of codepoints up to that point. // Does not validate UTF-8 beyond checking the start byte. fn utf8CountCodepointsAllowTruncate(s: []const u8) !struct { bytes: usize, codepoints: usize } { + const native_endian = @import("builtin").cpu.arch.endian(); var len: usize = 0; const N = @sizeOf(usize); @@ -100,3 +97,5 @@ test "handles partial UTF-8 writes" { try testing.expectEqualSlices(u8, utf8_text, fbs.getWritten()); } + +const std = @import("std"); diff --git a/clap/parsers.zig b/clap/parsers.zig index 8abdf57..2bf8976 100644 --- a/clap/parsers.zig +++ b/clap/parsers.zig @@ -1,8 +1,3 @@ -const std = @import("std"); - -const fmt = std.fmt; -const testing = std.testing; - pub const default = .{ .string = string, .str = string, @@ -26,46 +21,46 @@ pub fn string(in: []const u8) error{}![]const u8 { } test "string" { - try testing.expectEqualStrings("aa", try string("aa")); + try std.testing.expectEqualStrings("aa", try string("aa")); } /// A parser that uses `std.fmt.parseInt` to parse the string into an integer value. /// See `std.fmt.parseInt` documentation for more information. -pub fn int(comptime T: type, comptime base: u8) fn ([]const u8) fmt.ParseIntError!T { +pub fn int(comptime T: type, comptime base: u8) fn ([]const u8) std.fmt.ParseIntError!T { return struct { - fn parse(in: []const u8) fmt.ParseIntError!T { - return fmt.parseInt(T, in, base); + fn parse(in: []const u8) std.fmt.ParseIntError!T { + return std.fmt.parseInt(T, in, base); } }.parse; } test "int" { - try testing.expectEqual(@as(u8, 0), try int(u8, 10)("0")); - try testing.expectEqual(@as(u8, 1), try int(u8, 10)("1")); - try testing.expectEqual(@as(u8, 10), try int(u8, 10)("10")); - try testing.expectEqual(@as(u8, 0b10), try int(u8, 2)("10")); - try testing.expectEqual(@as(u8, 0x10), try int(u8, 0)("0x10")); - try testing.expectEqual(@as(u8, 0b10), try int(u8, 0)("0b10")); - try testing.expectEqual(@as(u16, 0), try int(u16, 10)("0")); - try testing.expectEqual(@as(u16, 1), try int(u16, 10)("1")); - try testing.expectEqual(@as(u16, 10), try int(u16, 10)("10")); - try testing.expectEqual(@as(u16, 0b10), try int(u16, 2)("10")); - try testing.expectEqual(@as(u16, 0x10), try int(u16, 0)("0x10")); - try testing.expectEqual(@as(u16, 0b10), try int(u16, 0)("0b10")); + try std.testing.expectEqual(@as(u8, 0), try int(u8, 10)("0")); + try std.testing.expectEqual(@as(u8, 1), try int(u8, 10)("1")); + try std.testing.expectEqual(@as(u8, 10), try int(u8, 10)("10")); + try std.testing.expectEqual(@as(u8, 0b10), try int(u8, 2)("10")); + try std.testing.expectEqual(@as(u8, 0x10), try int(u8, 0)("0x10")); + try std.testing.expectEqual(@as(u8, 0b10), try int(u8, 0)("0b10")); + try std.testing.expectEqual(@as(u16, 0), try int(u16, 10)("0")); + try std.testing.expectEqual(@as(u16, 1), try int(u16, 10)("1")); + try std.testing.expectEqual(@as(u16, 10), try int(u16, 10)("10")); + try std.testing.expectEqual(@as(u16, 0b10), try int(u16, 2)("10")); + try std.testing.expectEqual(@as(u16, 0x10), try int(u16, 0)("0x10")); + try std.testing.expectEqual(@as(u16, 0b10), try int(u16, 0)("0b10")); } /// A parser that uses `std.fmt.parseFloat` to parse the string into an float value. /// See `std.fmt.parseFloat` documentation for more information. -pub fn float(comptime T: type) fn ([]const u8) fmt.ParseFloatError!T { +pub fn float(comptime T: type) fn ([]const u8) std.fmt.ParseFloatError!T { return struct { - fn parse(in: []const u8) fmt.ParseFloatError!T { - return fmt.parseFloat(T, in); + fn parse(in: []const u8) std.fmt.ParseFloatError!T { + return std.fmt.parseFloat(T, in); } }.parse; } test "float" { - try testing.expectEqual(@as(f32, 0), try float(f32)("0")); + try std.testing.expectEqual(@as(f32, 0), try float(f32)("0")); } pub const EnumError = error{ @@ -85,10 +80,10 @@ pub fn enumeration(comptime T: type) fn ([]const u8) EnumError!T { test "enumeration" { const E = enum { a, b, c }; - try testing.expectEqual(E.a, try enumeration(E)("a")); - try testing.expectEqual(E.b, try enumeration(E)("b")); - try testing.expectEqual(E.c, try enumeration(E)("c")); - try testing.expectError(EnumError.NameNotPartOfEnum, enumeration(E)("d")); + try std.testing.expectEqual(E.a, try enumeration(E)("a")); + try std.testing.expectEqual(E.b, try enumeration(E)("b")); + try std.testing.expectEqual(E.c, try enumeration(E)("c")); + try std.testing.expectError(EnumError.NameNotPartOfEnum, enumeration(E)("d")); } fn ReturnType(comptime P: type) type { @@ -98,3 +93,5 @@ fn ReturnType(comptime P: type) type { pub fn Result(comptime P: type) type { return @typeInfo(ReturnType(P)).error_union.payload; } + +const std = @import("std"); diff --git a/clap/streaming.zig b/clap/streaming.zig index eba84bb..4a687a2 100644 --- a/clap/streaming.zig +++ b/clap/streaming.zig @@ -1,15 +1,3 @@ -const builtin = @import("builtin"); -const clap = @import("../clap.zig"); -const std = @import("std"); - -const args = clap.args; -const debug = std.debug; -const heap = std.heap; -const io = std.io; -const mem = std.mem; -const os = std.os; -const testing = std.testing; - /// The result returned from Clap.next pub fn Arg(comptime Id: type) type { return struct { @@ -71,14 +59,14 @@ pub fn Clap(comptime Id: type, comptime ArgIterator: type) type { const arg = arg_info.arg; switch (arg_info.kind) { .long => { - const eql_index = mem.indexOfAny(u8, arg, parser.assignment_separators); + const eql_index = std.mem.indexOfAny(u8, arg, parser.assignment_separators); const name = if (eql_index) |i| arg[0..i] else arg; const maybe_value = if (eql_index) |i| arg[i + 1 ..] else null; for (parser.params) |*param| { const match = param.names.long orelse continue; - if (!mem.eql(u8, name, match)) + if (!std.mem.eql(u8, name, match)) continue; if (param.takes_value == .none) { if (maybe_value != null) @@ -108,7 +96,7 @@ pub fn Clap(comptime Id: type, comptime ArgIterator: type) type { // If we find a positional with the value `--` then we // interpret the rest of the arguments as positional // arguments. - if (mem.eql(u8, arg, "--")) { + if (std.mem.eql(u8, arg, "--")) { parser.state = .rest_are_positional; const value = parser.iter.next() orelse return null; return Arg(Id){ .param = param, .value = value }; @@ -200,11 +188,11 @@ pub fn Clap(comptime Id: type, comptime ArgIterator: type) type { fn parseNextArg(parser: *@This()) !?ArgInfo { const full_arg = parser.iter.next() orelse return null; - if (mem.eql(u8, full_arg, "--") or mem.eql(u8, full_arg, "-")) + if (std.mem.eql(u8, full_arg, "--") or std.mem.eql(u8, full_arg, "-")) return ArgInfo{ .arg = full_arg, .kind = .positional }; - if (mem.startsWith(u8, full_arg, "--")) + if (std.mem.startsWith(u8, full_arg, "--")) return ArgInfo{ .arg = full_arg[2..], .kind = .long }; - if (mem.startsWith(u8, full_arg, "-")) + if (std.mem.startsWith(u8, full_arg, "-")) return ArgInfo{ .arg = full_arg[1..], .kind = .short }; return ArgInfo{ .arg = full_arg, .kind = .positional }; @@ -219,18 +207,18 @@ pub fn Clap(comptime Id: type, comptime ArgIterator: type) type { } fn expectArgs( - parser: *Clap(u8, args.SliceIterator), + parser: *Clap(u8, clap.args.SliceIterator), results: []const Arg(u8), ) !void { for (results) |res| { const arg = (try parser.next()) orelse return error.TestFailed; - try testing.expectEqual(res.param, arg.param); + try std.testing.expectEqual(res.param, arg.param); const expected_value = res.value orelse { - try testing.expectEqual(@as(@TypeOf(arg.value), null), arg.value); + try std.testing.expectEqual(@as(@TypeOf(arg.value), null), arg.value); continue; }; const actual_value = arg.value orelse return error.TestFailed; - try testing.expectEqualSlices(u8, expected_value, actual_value); + try std.testing.expectEqualSlices(u8, expected_value, actual_value); } if (try parser.next()) |_| @@ -238,7 +226,7 @@ fn expectArgs( } fn expectError( - parser: *Clap(u8, args.SliceIterator), + parser: *Clap(u8, clap.args.SliceIterator), expected: []const u8, ) !void { var diag: clap.Diagnostic = .{}; @@ -246,13 +234,13 @@ fn expectError( while (parser.next() catch |err| { var buf: [1024]u8 = undefined; - var fbs = io.fixedBufferStream(&buf); + var fbs = std.io.fixedBufferStream(&buf); diag.report(fbs.writer(), err) catch return error.TestFailed; - try testing.expectEqualStrings(expected, fbs.getWritten()); + try std.testing.expectEqualStrings(expected, fbs.getWritten()); return; }) |_| {} - try testing.expect(false); + try std.testing.expect(false); } test "short params" { @@ -276,12 +264,12 @@ test "short params" { const c = ¶ms[2]; const d = ¶ms[3]; - var iter = args.SliceIterator{ .args = &.{ + var iter = clap.args.SliceIterator{ .args = &.{ "-a", "-b", "-ab", "-ba", "-c", "0", "-c=0", "-ac", "0", "-ac=0", "-d=0", } }; - var parser = Clap(u8, args.SliceIterator){ .params = ¶ms, .iter = &iter }; + var parser = Clap(u8, clap.args.SliceIterator){ .params = ¶ms, .iter = &iter }; try expectArgs(&parser, &.{ .{ .param = a }, @@ -321,12 +309,12 @@ test "long params" { const cc = ¶ms[2]; const dd = ¶ms[3]; - var iter = args.SliceIterator{ .args = &.{ + var iter = clap.args.SliceIterator{ .args = &.{ "--aa", "--bb", "--cc", "0", "--cc=0", "--dd=0", } }; - var parser = Clap(u8, args.SliceIterator){ .params = ¶ms, .iter = &iter }; + var parser = Clap(u8, clap.args.SliceIterator){ .params = ¶ms, .iter = &iter }; try expectArgs(&parser, &.{ .{ .param = aa }, @@ -343,11 +331,11 @@ test "positional params" { .takes_value = .one, }}; - var iter = args.SliceIterator{ .args = &.{ + var iter = clap.args.SliceIterator{ .args = &.{ "aa", "bb", } }; - var parser = Clap(u8, args.SliceIterator){ .params = ¶ms, .iter = &iter }; + var parser = Clap(u8, clap.args.SliceIterator){ .params = ¶ms, .iter = &iter }; try expectArgs(&parser, &.{ .{ .param = ¶ms[0], .value = "aa" }, @@ -378,14 +366,14 @@ test "all params" { const cc = ¶ms[2]; const positional = ¶ms[3]; - var iter = args.SliceIterator{ .args = &.{ + var iter = clap.args.SliceIterator{ .args = &.{ "-a", "-b", "-ab", "-ba", "-c", "0", "-c=0", "-ac", "0", "-ac=0", "--aa", "--bb", "--cc", "0", "--cc=0", "something", "-", "--", "--cc=0", "-a", } }; - var parser = Clap(u8, args.SliceIterator){ .params = ¶ms, .iter = &iter }; + var parser = Clap(u8, clap.args.SliceIterator){ .params = ¶ms, .iter = &iter }; try expectArgs(&parser, &.{ .{ .param = aa }, @@ -422,11 +410,11 @@ test "different assignment separators" { const aa = ¶ms[0]; - var iter = args.SliceIterator{ .args = &.{ + var iter = clap.args.SliceIterator{ .args = &.{ "-a=0", "--aa=0", "-a:0", "--aa:0", } }; - var parser = Clap(u8, args.SliceIterator){ + var parser = Clap(u8, clap.args.SliceIterator){ .params = ¶ms, .iter = &iter, .assignment_separators = "=:", @@ -453,35 +441,38 @@ test "errors" { }, }; - var iter = args.SliceIterator{ .args = &.{"q"} }; - var parser = Clap(u8, args.SliceIterator){ .params = ¶ms, .iter = &iter }; + var iter = clap.args.SliceIterator{ .args = &.{"q"} }; + var parser = Clap(u8, clap.args.SliceIterator){ .params = ¶ms, .iter = &iter }; try expectError(&parser, "Invalid argument 'q'\n"); - iter = args.SliceIterator{ .args = &.{"-q"} }; - parser = Clap(u8, args.SliceIterator){ .params = ¶ms, .iter = &iter }; + iter = clap.args.SliceIterator{ .args = &.{"-q"} }; + parser = Clap(u8, clap.args.SliceIterator){ .params = ¶ms, .iter = &iter }; try expectError(&parser, "Invalid argument '-q'\n"); - iter = args.SliceIterator{ .args = &.{"--q"} }; - parser = Clap(u8, args.SliceIterator){ .params = ¶ms, .iter = &iter }; + iter = clap.args.SliceIterator{ .args = &.{"--q"} }; + parser = Clap(u8, clap.args.SliceIterator){ .params = ¶ms, .iter = &iter }; try expectError(&parser, "Invalid argument '--q'\n"); - iter = args.SliceIterator{ .args = &.{"--q=1"} }; - parser = Clap(u8, args.SliceIterator){ .params = ¶ms, .iter = &iter }; + iter = clap.args.SliceIterator{ .args = &.{"--q=1"} }; + parser = Clap(u8, clap.args.SliceIterator){ .params = ¶ms, .iter = &iter }; try expectError(&parser, "Invalid argument '--q'\n"); - iter = args.SliceIterator{ .args = &.{"-a=1"} }; - parser = Clap(u8, args.SliceIterator){ .params = ¶ms, .iter = &iter }; + iter = clap.args.SliceIterator{ .args = &.{"-a=1"} }; + parser = Clap(u8, clap.args.SliceIterator){ .params = ¶ms, .iter = &iter }; try expectError(&parser, "The argument '-a' does not take a value\n"); - iter = args.SliceIterator{ .args = &.{"--aa=1"} }; - parser = Clap(u8, args.SliceIterator){ .params = ¶ms, .iter = &iter }; + iter = clap.args.SliceIterator{ .args = &.{"--aa=1"} }; + parser = Clap(u8, clap.args.SliceIterator){ .params = ¶ms, .iter = &iter }; try expectError(&parser, "The argument '--aa' does not take a value\n"); - iter = args.SliceIterator{ .args = &.{"-c"} }; - parser = Clap(u8, args.SliceIterator){ .params = ¶ms, .iter = &iter }; + iter = clap.args.SliceIterator{ .args = &.{"-c"} }; + parser = Clap(u8, clap.args.SliceIterator){ .params = ¶ms, .iter = &iter }; try expectError(&parser, "The argument '-c' requires a value but none was supplied\n"); - iter = args.SliceIterator{ .args = &.{"--cc"} }; - parser = Clap(u8, args.SliceIterator){ .params = ¶ms, .iter = &iter }; + iter = clap.args.SliceIterator{ .args = &.{"--cc"} }; + parser = Clap(u8, clap.args.SliceIterator){ .params = ¶ms, .iter = &iter }; try expectError(&parser, "The argument '--cc' requires a value but none was supplied\n"); } + +const clap = @import("../clap.zig"); +const std = @import("std"); -- cgit v1.2.3