Started work on the proper structure for the lib

2 files changed, 636 insertions, 0 deletions

diff --git a/src/core.zig b/src/core.zig
new file mode 100644
index 0000000..a3fb44c
--- /dev/null
+++ b/src/core.zig
@@ -0,0 +1,372 @@
+const std = @import("std");
+const builtin = @import("builtin");
+
+const os = std.os;
+const heap = std.heap;
+const mem = std.mem;
+const debug = std.debug;
+
+/// The names a ::Param can have.
+pub const Names = struct {
+    /// No prefix
+    bare: ?[]const u8,
+
+    /// '-' prefix
+    short: ?u8,
+
+    /// '--' prefix
+    long: ?[]const u8,
+
+    /// Initializes no names
+    pub fn none() Names {
+        return Names{
+            .bare = null,
+            .short = null,
+            .long = null,
+        };
+    }
+
+    /// Initializes a bare name
+    pub fn bare(b: []const u8) Names {
+        return Names{
+            .bare = b,
+            .short = null,
+            .long = null,
+        };
+    }
+
+    /// Initializes a short name
+    pub fn short(s: u8) Names {
+        return Names{
+            .bare = null,
+            .short = s,
+            .long = null,
+        };
+    }
+
+    /// Initializes a long name
+    pub fn long(l: []const u8) Names {
+        return Names{
+            .bare = null,
+            .short = null,
+            .long = l,
+        };
+    }
+
+    /// Initializes a name with a prefix.
+    /// ::short is set to ::name[0], and ::long is set to ::name.
+    /// This function asserts that ::name.len != 0
+    pub fn prefix(name: []const u8) Names {
+        debug.assert(name.len != 0);
+
+        return Names{
+            .bare = null,
+            .short = name[0],
+            .long = name,
+        };
+    }
+};
+
+/// Represents a parameter for the command line.
+/// Parameters come in three kinds:
+///   * Short ("-a"): Should be used for the most commonly used parameters in your program.
+///     * They can take a value three different ways.
+///       * "-a value"
+///       * "-a=value"
+///       * "-avalue"
+///     * They chain if they don't take values: "-abc".
+///       * The last given parameter can take a value in the same way that a single parameter can:
+///         * "-abc value"
+///         * "-abc=value"
+///         * "-abcvalue"
+///   * Long ("--long-param"): Should be used for less common parameters, or when no single character
+///                            can describe the paramter.
+///     * They can take a value two different ways.
+///       * "--long-param value"
+///       * "--long-param=value"
+///   * Bare ("bare"): Should be used as for sub-commands and other keywords.
+///     * They can take a value two different ways.
+///       * "command value"
+///       * "command=value"
+///   * Value ("value"): Should be used as the primary parameter of the program, like a filename or
+///                      an expression to parse.
+///     * Value parameters must take a value.
+pub fn Param(comptime Id: type) type {
+    return struct {
+        const Self = this;
+
+        id: Id,
+        takes_value: bool,
+        names: Names,
+
+        pub fn init(id: Id, takes_value: bool, names: &const Names) Self {
+            // Assert, that if the param have no name, then it has to take
+            // a value.
+            debug.assert(
+                names.bare != null or
+                names.long != null or
+                names.short != null or
+                takes_value
+            );
+
+            return Self{
+                .id = id,
+                .takes_value = takes_value,
+                .names = names.*,
+            };
+        }
+    };
+}
+
+/// The result returned from ::Clap.next
+pub fn Arg(comptime Id: type) type {
+    return struct {
+        const Self = this;
+
+        id: Id,
+        value: ?[]const u8,
+
+        pub fn init(id: Id, value: ?[]const u8) Self {
+            return Self {
+                .id = id,
+                .value = value,
+            };
+        }
+    };
+}
+
+/// A interface for iterating over command line arguments
+pub const ArgIterator = struct {
+    const Error = error{OutOfMemory};
+
+    nextFn: fn(iter: &ArgIterator, allocator: &mem.Allocator) Error!?[]const u8,
+
+    pub fn next(iter: &ArgIterator, allocator: &mem.Allocator) Error!?[]const u8 {
+        return iter.nextFn(iter, allocator);
+    }
+};
+
+/// An ::ArgIterator, which iterates over a slice of arguments.
+/// This implementation does not allocate.
+pub const ArgSliceIterator = struct {
+    args: []const []const u8,
+    index: usize,
+    iter: ArgIterator,
+
+    pub fn init(args: []const []const u8) ArgSliceIterator {
+        return ArgSliceIterator {
+            .args = args,
+            .index = 0,
+            .iter = ArgIterator {
+                .nextFn = nextFn,
+            },
+        };
+    }
+
+    fn nextFn(iter: &ArgIterator, allocator: &mem.Allocator) ArgIterator.Error!?[]const u8 {
+        const self = @fieldParentPtr(ArgSliceIterator, "iter", iter);
+        if (self.args.len <= self.index)
+            return null;
+
+        defer self.index += 1;
+        return self.args[self.index];
+    }
+};
+
+/// An ::ArgIterator, which wraps the ArgIterator in ::std.
+/// On windows, this iterator allocates.
+pub const OsArgIterator = struct {
+    args: os.ArgIterator,
+    iter: ArgIterator,
+
+    pub fn init() OsArgIterator {
+        return OsArgIterator {
+            .args = os.args(),
+            .iter = ArgIterator {
+                .nextFn = nextFn,
+            },
+        };
+    }
+
+    fn nextFn(iter: &ArgIterator, allocator: &mem.Allocator) ArgIterator.Error!?[]const u8 {
+        const self = @fieldParentPtr(OsArgIterator, "iter", iter);
+        if (builtin.os == builtin.Os.windows) {
+            return try self.args.next(allocator) ?? return null;
+        } else {
+            return self.args.nextPosix();
+        }
+    }
+};
+
+/// A command line argument parser which, given an ::ArgIterator, will parse arguments according
+/// to the ::params. ::Clap parses in an iterating manner, so you have to use a loop together with
+/// ::Clap.next to parse all the arguments of your program.
+pub fn Clap(comptime Id: type) type {
+    return struct {
+        const Self = this;
+
+        const State = union(enum) {
+            Normal,
+            Chaining: Chaining,
+
+            const Chaining = struct {
+                arg: []const u8,
+                index: usize,
+            };
+        };
+
+        arena: heap.ArenaAllocator,
+        params: []const Param(Id),
+        inner: &ArgIterator,
+        state: State,
+
+        pub fn init(params: []const Param(Id), inner: &ArgIterator, allocator: &mem.Allocator) Self {
+            var res = Self {
+                .arena = heap.ArenaAllocator.init(allocator),
+                .params = params,
+                .inner = inner,
+                .state = State.Normal,
+            };
+
+            return res;
+        }
+
+        pub fn deinit(iter: &Self) void {
+            iter.arena.deinit();
+        }
+
+        /// Get the next ::Arg that matches a ::Param.
+        pub fn next(iter: &Self) !?Arg(Id) {
+            const ArgInfo = struct {
+                const Kind = enum { Long, Short, Bare };
+
+                arg: []const u8,
+                kind: Kind,
+            };
+
+            switch (iter.state) {
+                State.Normal => {
+                    const full_arg = (try iter.innerNext()) ?? return null;
+                    const arg_info = blk: {
+                        var arg = full_arg;
+                        var kind = ArgInfo.Kind.Bare;
+
+                        if (mem.startsWith(u8, arg, "--")) {
+                            arg = arg[2..];
+                            kind = ArgInfo.Kind.Long;
+                        } else if (mem.startsWith(u8, arg, "-")) {
+                            arg = arg[1..];
+                            kind = ArgInfo.Kind.Short;
+                        }
+
+                        if (arg.len == 0)
+                            return error.ArgWithNoName;
+
+                        break :blk ArgInfo { .arg = arg, .kind = kind };
+                    };
+
+                    const arg = arg_info.arg;
+                    const kind = arg_info.kind;
+                    const eql_index = mem.indexOfScalar(u8, arg, '=');
+
+                    switch (kind) {
+                        ArgInfo.Kind.Bare,
+                        ArgInfo.Kind.Long => {
+                            for (iter.params) |*param| {
+                                const match = switch (kind) {
+                                    ArgInfo.Kind.Bare => param.names.bare ?? continue,
+                                    ArgInfo.Kind.Long => param.names.long ?? continue,
+                                    else => unreachable,
+                                };
+                                const name = if (eql_index) |i| arg[0..i] else arg;
+                                const maybe_value = if (eql_index) |i| arg[i + 1..] else null;
+
+                                if (!mem.eql(u8, name, match))
+                                    continue;
+                                if (!param.takes_value) {
+                                    if (maybe_value != null)
+                                        return error.DoesntTakeValue;
+
+                                    return Arg(Id).init(param.id, null);
+                                }
+
+                                const value = blk: {
+                                    if (maybe_value) |v|
+                                        break :blk v;
+
+                                    break :blk (try iter.innerNext()) ?? return error.MissingValue;
+                                };
+
+                                return Arg(Id).init(param.id, value);
+                            }
+                        },
+                        ArgInfo.Kind.Short => {
+                            return try iter.chainging(State.Chaining {
+                                .arg = full_arg,
+                                .index = (full_arg.len - arg.len),
+                            });
+                        },
+                    }
+
+                    // We do a final pass to look for value parameters matches
+                    if (kind == ArgInfo.Kind.Bare) {
+                        for (iter.params) |*param| {
+                            if (param.names.bare) |_| continue;
+                            if (param.names.short) |_| continue;
+                            if (param.names.long) |_| continue;
+
+                            return Arg(Id).init(param.id, arg);
+                        }
+                    }
+
+                    return error.InvalidArgument;
+                },
+                @TagType(State).Chaining => |state| return try iter.chainging(state),
+            }
+        }
+
+        fn chainging(iter: &Self, state: &const State.Chaining) !?Arg(Id) {
+            const arg = state.arg;
+            const index = state.index;
+            const next_index = index + 1;
+
+            for (iter.params) |param| {
+                const short = param.names.short ?? continue;
+                if (short != arg[index])
+                    continue;
+
+                // Before we return, we have to set the new state of the iterator
+                defer {
+                    if (arg.len <= next_index or param.takes_value) {
+                        iter.state = State.Normal;
+                    } else {
+                        iter.state = State { .Chaining = State.Chaining {
+                            .arg = arg,
+                            .index = next_index,
+                        }};
+                    }
+                }
+
+                if (!param.takes_value)
+                    return Arg(Id).init(param.id, null);
+
+                if (arg.len <= next_index) {
+                    const value = (try iter.innerNext()) ?? return error.MissingValue;
+                    return Arg(Id).init(param.id, value);
+                }
+
+                if (arg[next_index] == '=') {
+                    return Arg(Id).init(param.id, arg[next_index + 1..]);
+                }
+
+                return Arg(Id).init(param.id, arg[next_index..]);
+            }
+
+            return error.InvalidArgument;
+        }
+
+        fn innerNext(iter: &Self) !?[]const u8 {
+            return try iter.inner.next(&iter.arena.allocator);
+        }
+    };
+}
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
+    );
+};