refactor: Always access using full namespace

This is my new preferred style of programming Zig :)

4 files changed, 76 insertions, 96 deletions

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 = &params[2];
     const d = &params[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 = &params, .iter = &iter };
+    var parser = Clap(u8, clap.args.SliceIterator){ .params = &params, .iter = &iter };
 
     try expectArgs(&parser, &.{
         .{ .param = a },
@@ -321,12 +309,12 @@ test "long params" {
     const cc = &params[2];
     const dd = &params[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 = &params, .iter = &iter };
+    var parser = Clap(u8, clap.args.SliceIterator){ .params = &params, .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 = &params, .iter = &iter };
+    var parser = Clap(u8, clap.args.SliceIterator){ .params = &params, .iter = &iter };
 
     try expectArgs(&parser, &.{
         .{ .param = &params[0], .value = "aa" },
@@ -378,14 +366,14 @@ test "all params" {
     const cc = &params[2];
     const positional = &params[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 = &params, .iter = &iter };
+    var parser = Clap(u8, clap.args.SliceIterator){ .params = &params, .iter = &iter };
 
     try expectArgs(&parser, &.{
         .{ .param = aa },
@@ -422,11 +410,11 @@ test "different assignment separators" {
 
     const aa = &params[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 = &params,
         .iter = &iter,
         .assignment_separators = "=:",
@@ -453,35 +441,38 @@ test "errors" {
         },
     };
 
-    var iter = args.SliceIterator{ .args = &.{"q"} };
-    var parser = Clap(u8, args.SliceIterator){ .params = &params, .iter = &iter };
+    var iter = clap.args.SliceIterator{ .args = &.{"q"} };
+    var parser = Clap(u8, clap.args.SliceIterator){ .params = &params, .iter = &iter };
     try expectError(&parser, "Invalid argument 'q'\n");
 
-    iter = args.SliceIterator{ .args = &.{"-q"} };
-    parser = Clap(u8, args.SliceIterator){ .params = &params, .iter = &iter };
+    iter = clap.args.SliceIterator{ .args = &.{"-q"} };
+    parser = Clap(u8, clap.args.SliceIterator){ .params = &params, .iter = &iter };
     try expectError(&parser, "Invalid argument '-q'\n");
 
-    iter = args.SliceIterator{ .args = &.{"--q"} };
-    parser = Clap(u8, args.SliceIterator){ .params = &params, .iter = &iter };
+    iter = clap.args.SliceIterator{ .args = &.{"--q"} };
+    parser = Clap(u8, clap.args.SliceIterator){ .params = &params, .iter = &iter };
     try expectError(&parser, "Invalid argument '--q'\n");
 
-    iter = args.SliceIterator{ .args = &.{"--q=1"} };
-    parser = Clap(u8, args.SliceIterator){ .params = &params, .iter = &iter };
+    iter = clap.args.SliceIterator{ .args = &.{"--q=1"} };
+    parser = Clap(u8, clap.args.SliceIterator){ .params = &params, .iter = &iter };
     try expectError(&parser, "Invalid argument '--q'\n");
 
-    iter = args.SliceIterator{ .args = &.{"-a=1"} };
-    parser = Clap(u8, args.SliceIterator){ .params = &params, .iter = &iter };
+    iter = clap.args.SliceIterator{ .args = &.{"-a=1"} };
+    parser = Clap(u8, clap.args.SliceIterator){ .params = &params, .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 = &params, .iter = &iter };
+    iter = clap.args.SliceIterator{ .args = &.{"--aa=1"} };
+    parser = Clap(u8, clap.args.SliceIterator){ .params = &params, .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 = &params, .iter = &iter };
+    iter = clap.args.SliceIterator{ .args = &.{"-c"} };
+    parser = Clap(u8, clap.args.SliceIterator){ .params = &params, .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 = &params, .iter = &iter };
+    iter = clap.args.SliceIterator{ .args = &.{"--cc"} };
+    parser = Clap(u8, clap.args.SliceIterator){ .params = &params, .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");