Started work on the proper structure for the lib

2 files changed, 264 insertions, 121 deletions

diff --git a/core.zig b/src/core.zig
index 306ff63..a3fb44c 100644
--- a/core.zig
+++ b/src/core.zig
@@ -370,124 +370,3 @@ pub fn Clap(comptime Id: type) type {
         }
     };
 }
-
-fn testNoErr(params: []const Param(u8), args: []const []const u8, ids: []const u8, values: []const ?[]const u8) void {
-    var arg_iter = ArgSliceIterator.init(args);
-    var iter = Clap(u8).init(params, &arg_iter.iter, debug.global_allocator);
-
-    var i: usize = 0;
-    while (iter.next() catch unreachable) |arg| : (i += 1) {
-        debug.assert(ids[i] == arg.id);
-        const expected_value = values[i] ?? {
-            debug.assert(arg.value == null);
-            continue;
-        };
-        const actual_value = arg.value ?? unreachable;
-
-        debug.assert(mem.eql(u8, expected_value, actual_value));
-    }
-}
-
-test "clap.core: short" {
-    const params = []Param(u8) {
-        Param(u8).init(0, false, Names.short('a')),
-        Param(u8).init(1, false, Names.short('b')),
-        Param(u8).init(2, true,  Names.short('c')),
-    };
-
-    testNoErr(params, [][]const u8 { "-a" },          []u8{0},   []?[]const u8{null});
-    testNoErr(params, [][]const u8 { "-a", "-b" },    []u8{0,1}, []?[]const u8{null,null});
-    testNoErr(params, [][]const u8 { "-ab" },         []u8{0,1}, []?[]const u8{null,null});
-    testNoErr(params, [][]const u8 { "-c=100" },      []u8{2},   []?[]const u8{"100"});
-    testNoErr(params, [][]const u8 { "-c100" },       []u8{2},   []?[]const u8{"100"});
-    testNoErr(params, [][]const u8 { "-c", "100" },   []u8{2},   []?[]const u8{"100"});
-    testNoErr(params, [][]const u8 { "-abc", "100" }, []u8{0,1,2}, []?[]const u8{null,null,"100"});
-    testNoErr(params, [][]const u8 { "-abc=100" },    []u8{0,1,2}, []?[]const u8{null,null,"100"});
-    testNoErr(params, [][]const u8 { "-abc100" },     []u8{0,1,2}, []?[]const u8{null,null,"100"});
-}
-
-test "clap.core: long" {
-    const params = []Param(u8) {
-        Param(u8).init(0, false, Names.long("aa")),
-        Param(u8).init(1, false, Names.long("bb")),
-        Param(u8).init(2, true,  Names.long("cc")),
-    };
-
-    testNoErr(params, [][]const u8 { "--aa" },         []u8{0},   []?[]const u8{null});
-    testNoErr(params, [][]const u8 { "--aa", "--bb" }, []u8{0,1}, []?[]const u8{null,null});
-    testNoErr(params, [][]const u8 { "--cc=100" },     []u8{2},   []?[]const u8{"100"});
-    testNoErr(params, [][]const u8 { "--cc", "100" },  []u8{2},   []?[]const u8{"100"});
-}
-
-test "clap.core: bare" {
-    const params = []Param(u8) {
-        Param(u8).init(0, false, Names.bare("aa")),
-        Param(u8).init(1, false, Names.bare("bb")),
-        Param(u8).init(2, true,  Names.bare("cc")),
-    };
-
-    testNoErr(params, [][]const u8 { "aa" },        []u8{0},   []?[]const u8{null});
-    testNoErr(params, [][]const u8 { "aa", "bb" },  []u8{0,1}, []?[]const u8{null,null});
-    testNoErr(params, [][]const u8 { "cc=100" },    []u8{2},   []?[]const u8{"100"});
-    testNoErr(params, [][]const u8 { "cc", "100" }, []u8{2},   []?[]const u8{"100"});
-}
-
-test "clap.core: none" {
-    const params = []Param(u8) {
-        Param(u8).init(0, true, Names.none()),
-    };
-
-    testNoErr(params, [][]const u8 { "aa" }, []u8{0}, []?[]const u8{"aa"});
-}
-
-test "clap.core: all" {
-    const params = []Param(u8) {
-        Param(u8).init(
-            0,
-            false,
-            Names{
-                .bare = "aa",
-                .short = 'a',
-                .long = "aa",
-            }
-        ),
-        Param(u8).init(
-            1,
-            false,
-            Names{
-                .bare = "bb",
-                .short = 'b',
-                .long = "bb",
-            }
-        ),
-        Param(u8).init(
-            2,
-            true,
-            Names{
-                .bare = "cc",
-                .short = 'c',
-                .long = "cc",
-            }
-        ),
-        Param(u8).init(3, true, Names.none()),
-    };
-
-    testNoErr(params, [][]const u8 { "-a" },           []u8{0},     []?[]const u8{null});
-    testNoErr(params, [][]const u8 { "-a", "-b" },     []u8{0,1},   []?[]const u8{null,null});
-    testNoErr(params, [][]const u8 { "-ab" },          []u8{0,1},   []?[]const u8{null,null});
-    testNoErr(params, [][]const u8 { "-c=100" },       []u8{2},     []?[]const u8{"100"});
-    testNoErr(params, [][]const u8 { "-c100" },        []u8{2},     []?[]const u8{"100"});
-    testNoErr(params, [][]const u8 { "-c", "100" },    []u8{2},     []?[]const u8{"100"});
-    testNoErr(params, [][]const u8 { "-abc", "100" },  []u8{0,1,2}, []?[]const u8{null,null,"100"});
-    testNoErr(params, [][]const u8 { "-abc=100" },     []u8{0,1,2}, []?[]const u8{null,null,"100"});
-    testNoErr(params, [][]const u8 { "-abc100" },      []u8{0,1,2}, []?[]const u8{null,null,"100"});
-    testNoErr(params, [][]const u8 { "--aa" },         []u8{0},     []?[]const u8{null});
-    testNoErr(params, [][]const u8 { "--aa", "--bb" }, []u8{0,1},   []?[]const u8{null,null});
-    testNoErr(params, [][]const u8 { "--cc=100" },     []u8{2},     []?[]const u8{"100"});
-    testNoErr(params, [][]const u8 { "--cc", "100" },  []u8{2},     []?[]const u8{"100"});
-    testNoErr(params, [][]const u8 { "aa" },           []u8{0},     []?[]const u8{null});
-    testNoErr(params, [][]const u8 { "aa", "bb" },     []u8{0,1},   []?[]const u8{null,null});
-    testNoErr(params, [][]const u8 { "cc=100" },       []u8{2},     []?[]const u8{"100"});
-    testNoErr(params, [][]const u8 { "cc", "100" },    []u8{2},     []?[]const u8{"100"});
-    testNoErr(params, [][]const u8 { "dd" },           []u8{3},     []?[]const u8{"dd"});
-}
diff --git a/src/extended.zig b/src/extended.zig
new file mode 100644
index 0000000..9427b83
--- /dev/null
+++ b/src/extended.zig
@@ -0,0 +1,264 @@
+pub const core = @import("core.zig");
+
+const builtin = @import("builtin");
+const std     = @import("std");
+
+const mem   = std.mem;
+const fmt   = std.fmt;
+const debug = std.debug;
+const io    = std.io;
+
+const assert = debug.assert;
+
+const Opaque = @OpaqueType();
+
+pub const Param = struct {
+    field: []const u8,
+    short: ?u8,
+    long: ?[]const u8,
+    takes_value: ?Parser,
+    required: bool,
+    position: ?usize,
+
+    pub fn short(s: u8) Param {
+        return Param{
+            .field = []u8{s},
+            .short = s,
+            .long = null,
+            .takes_value = null,
+            .required = false,
+            .position = null,
+        };
+    }
+
+    pub fn long(l: []const u8) Param {
+        return Param{
+            .field = l,
+            .short = null,
+            .long = l,
+            .takes_value = null,
+            .required = false,
+            .position = null,
+        };
+    }
+
+    pub fn value(f: []const u8) Param {
+        return Param{
+            .field = f,
+            .short = null,
+            .long = null,
+            .takes_value = null,
+            .required = false,
+            .position = null,
+        };
+    }
+
+    /// Initialize a ::Param.
+    /// If ::name.len == 0, then it's a value parameter: "value".
+    /// If ::name.len == 1, then it's a short parameter: "-s".
+    /// If ::name.len > 1, then it's a long parameter: "--long".
+    pub fn smart(name: []const u8) Param {
+        return Param{
+            .field = name,
+            .short = if (name.len == 1) name[0] else null,
+            .long = if (name.len > 1) name else null,
+            .takes_value = null,
+            .required = false,
+            .position = null,
+        };
+    }
+
+    pub fn with(param: &const Param, comptime field_name: []const u8, v: var) Param {
+        var res = param.*;
+        @field(res, field_name) = v;
+        return res;
+    }
+};
+
+pub const Command = struct {
+    field: []const u8,
+    name: []const u8,
+    params: []const Param,
+    sub_commands: []const Command,
+
+    Result: type,
+    defaults: &const Opaque,
+    parent: ?&const Command,
+
+    pub fn init(name: []const u8, comptime Result: type, defaults: &const Result, params: []const Param, sub_commands: []const Command) Command {
+        return Command{
+            .field = name,
+            .name = name,
+            .params = params,
+            .sub_commands = sub_commands,
+            .Result = Result,
+            .defaults = @ptrCast(&const Opaque, defaults),
+            .parent = null,
+        };
+    }
+
+    pub fn with(command: &const Command, comptime field_name: []const u8, v: var) Param {
+        var res = command.*;
+        @field(res, field_name) = v;
+        return res;
+    }
+
+    pub fn parse(comptime command: &const Command, allocator: &mem.Allocator, arg_iter: &core.ArgIterator) !command.Result {
+        const Parent = struct {};
+        var parent = Parent{};
+        return command.parseHelper(&parent, allocator, arg_iter);
+    }
+
+    fn parseHelper(comptime command: &const Command, parent: var, allocator: &mem.Allocator, arg_iter: &core.ArgIterator) !command.Result {
+        const Result = struct {
+            parent: @typeOf(parent),
+            result: command.Result,
+        };
+
+        var result = Result{
+            .parent = parent,
+            .result = @ptrCast(&const command.Result, command.defaults).*,
+        };
+
+        // In order for us to wrap the core api, we have to translate clap.Param into core.Param.
+        const core_params = comptime blk: {
+            var res: [command.params.len + command.sub_commands.len]core.Param(usize) = undefined;
+
+            for (command.params) |p, i| {
+                const id = i;
+                res[id] = core.Param(usize) {
+                    .id = id,
+                    .takes_value = p.takes_value != null,
+                    .names = core.Names{
+                        .bare = null,
+                        .short = p.short,
+                        .long = p.long,
+                    },
+                };
+            }
+
+            for (command.sub_commands) |c, i| {
+                const id = i + command.params.len;
+                res[id] = core.Param(usize) {
+                    .id = id,
+                    .takes_value = false,
+                    .names = core.Names.bare(c.name),
+                };
+            }
+
+            break :blk res;
+        };
+
+        var handled = comptime blk: {
+            var res: [command.params.len]bool = undefined;
+            for (command.params) |p, i| {
+                res[i] = !p.required;
+            }
+
+            break :blk res;
+        };
+
+        var pos: usize = 0;
+        var iter = core.Clap(usize).init(core_params, arg_iter, allocator);
+        defer iter.deinit();
+
+        arg_loop:
+        while (try iter.next()) |arg| : (pos += 1) {
+            inline for(command.params) |param, i| {
+                comptime const field = "result." ++ param.field;
+
+                if (arg.id == i and (param.position ?? pos) == pos) {
+                    if (param.takes_value) |parser| {
+                        try parser.parse(getFieldPtr(&result, field), ??arg.value);
+                    } else {
+                        getFieldPtr(&result, field).* = true;
+                    }
+                    handled[i] = true;
+                    continue :arg_loop;
+                }
+            }
+
+            inline for(command.sub_commands) |c, i| {
+                comptime const field = "result." ++ c.field;
+                comptime var sub_command = c;
+                sub_command.parent = command;
+
+                if (arg.id == i + command.params.len) {
+                    getFieldPtr(&result, field).* = try sub_command.parseHelper(&result, allocator, arg_iter);
+                    continue :arg_loop;
+                }
+            }
+
+            return error.InvalidArgument;
+        }
+
+        return result.result;
+    }
+
+    fn GetFieldPtrReturn(comptime Struct: type, comptime field: []const u8) type {
+        var inst: Struct = undefined;
+        const dot_index = comptime mem.indexOfScalar(u8, field, '.') ?? {
+            return @typeOf(&@field(inst, field));
+        };
+
+        return GetFieldPtrReturn(@typeOf(@field(inst, field[0..dot_index])), field[dot_index + 1..]);
+    }
+
+    fn getFieldPtr(curr: var, comptime field: []const u8) GetFieldPtrReturn(@typeOf(curr).Child, field) {
+        const dot_index = comptime mem.indexOfScalar(u8, field, '.') ?? {
+            return &@field(curr, field);
+        };
+
+        return getFieldPtr(&@field(curr, field[0..dot_index]), field[dot_index + 1..]);
+    }
+};
+
+pub const Parser = struct {
+    const UnsafeFunction = &const void;
+
+    FieldType: type,
+    Errors: type,
+    func: UnsafeFunction,
+
+    pub fn init(comptime FieldType: type, comptime Errors: type, func: parseFunc(FieldType, Errors)) Parser {
+        return Parser {
+            .FieldType = FieldType,
+            .Errors = Errors,
+            .func = @ptrCast(UnsafeFunction, func),
+        };
+    }
+
+    fn parse(comptime parser: Parser, field_ptr: TakePtr(parser.FieldType), arg: []const u8) parser.Errors!void {
+        return @ptrCast(parseFunc(parser.FieldType, parser.Errors), parser.func)(field_ptr, arg);
+    }
+
+    // TODO: This is a workaround, since we don't have pointer reform yet.
+    fn TakePtr(comptime T: type) type { return &T; }
+
+    fn parseFunc(comptime FieldType: type, comptime Errors: type) type {
+        return fn(&FieldType, []const u8) Errors!void;
+    }
+
+    pub fn int(comptime Int: type, comptime radix: u8) Parser {
+        const func = struct {
+            fn i(field_ptr: &Int, arg: []const u8) !void {
+                field_ptr.* = try fmt.parseInt(Int, arg, radix);
+            }
+        }.i;
+        return Parser.init(
+            Int,
+            @typeOf(func).ReturnType.ErrorSet,
+            func
+        );
+    }
+
+    const string = Parser.init(
+        []const u8,
+        error{},
+        struct {
+            fn s(field_ptr: &[]const u8, arg: []const u8) (error{}!void) {
+                field_ptr.* = arg;
+            }
+        }.s
+    );
+};