From 661d32ded068ecff486a952626bd209240035781 Mon Sep 17 00:00:00 2001 From: Jimmi Holst Christensen Date: Sun, 20 May 2018 12:51:43 +0200 Subject: Support for command params in core.zig * Also refactored structure * related: #1 --- index.zig | 317 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 317 insertions(+) create mode 100644 index.zig (limited to 'index.zig') diff --git a/index.zig b/index.zig new file mode 100644 index 0000000..7b82211 --- /dev/null +++ b/index.zig @@ -0,0 +1,317 @@ +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; + +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 fn Clap(comptime Result: type) type { + return struct { + const Self = this; + + defaults: Result, + params: []const Param, + + pub fn parse(comptime clap: &const Self, allocator: &mem.Allocator, arg_iter: &core.ArgIterator) !Result { + var result = clap.defaults; + const core_params = comptime blk: { + var res: [clap.params.len]core.Param(usize) = undefined; + + for (clap.params) |p, i| { + res[i] = core.Param(usize) { + .id = i, + .command = null, + .short = p.short, + .long = p.long, + .takes_value = p.takes_value != null, + }; + } + + break :blk res; + }; + + var handled = comptime blk: { + var res: [clap.params.len]bool = undefined; + for (clap.params) |p, i| { + res[i] = !p.required; + } + + break :blk res; + }; + + var pos: usize = 0; + var iter = core.Iterator(usize).init(core_params, arg_iter, allocator); + defer iter.deinit(); + while (try iter.next()) |arg| : (pos += 1) { + inline for(clap.params) |param, i| { + if (arg.id == i) { + if (param.position) |expected| { + if (expected != pos) + return error.InvalidPosition; + } + + if (param.takes_value) |parser| { + try parser.parse(&@field(result, param.field), ??arg.value); + } else { + @field(result, param.field) = true; + } + handled[i] = true; + } + } + } + + return result; + } + }; +} + +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 + ); +}; + + +const Options = struct { + str: []const u8, + int: i64, + uint: u64, + a: bool, + b: bool, + cc: bool, + + pub fn with(op: &const Options, comptime field: []const u8, value: var) Options { + var res = *op; + @field(res, field) = value; + return res; + } +}; + +const default = Options { + .str = "", + .int = 0, + .uint = 0, + .a = false, + .b = false, + .cc = false, +}; + +fn testNoErr(comptime clap: &const Clap(Options), args: []const []const u8, expected: &const Options) void { + var arg_iter = core.ArgSliceIterator.init(args); + const actual = clap.parse(debug.global_allocator, &arg_iter.iter) catch unreachable; + assert(mem.eql(u8, expected.str, actual.str)); + assert(expected.int == actual.int); + assert(expected.uint == actual.uint); + assert(expected.a == actual.a); + assert(expected.b == actual.b); + assert(expected.cc == actual.cc); +} + +fn testErr(comptime clap: &const Clap(Options), args: []const []const u8, expected: error) void { + var arg_iter = core.ArgSliceIterator.init(args); + if (clap.parse(debug.global_allocator, &arg_iter.iter)) |actual| { + unreachable; + } else |err| { + assert(err == expected); + } +} + +test "clap.core" { + _ = core; +} + +test "clap: short" { + const clap = comptime Clap(Options) { + .defaults = default, + .params = []Param { + Param.smart("a"), + Param.smart("b"), + Param.smart("int") + .with("short", 'i') + .with("takes_value", Parser.int(i64, 10)) + } + }; + + testNoErr(clap, [][]const u8 { "-a" }, default.with("a", true)); + testNoErr(clap, [][]const u8 { "-a", "-b" }, default.with("a", true).with("b", true)); + testNoErr(clap, [][]const u8 { "-i=100" }, default.with("int", 100)); + testNoErr(clap, [][]const u8 { "-i100" }, default.with("int", 100)); + testNoErr(clap, [][]const u8 { "-i", "100" }, default.with("int", 100)); + testNoErr(clap, [][]const u8 { "-ab" }, default.with("a", true).with("b", true)); + testNoErr(clap, [][]const u8 { "-abi", "100" }, default.with("a", true).with("b", true).with("int", 100)); + testNoErr(clap, [][]const u8 { "-abi=100" }, default.with("a", true).with("b", true).with("int", 100)); + testNoErr(clap, [][]const u8 { "-abi100" }, default.with("a", true).with("b", true).with("int", 100)); +} + +test "clap: long" { + const clap = comptime Clap(Options) { + .defaults = default, + .params = []Param { + Param.smart("cc"), + Param.smart("int").with("takes_value", Parser.int(i64, 10)), + Param.smart("uint").with("takes_value", Parser.int(u64, 10)), + Param.smart("str").with("takes_value", Parser.string), + } + }; + + testNoErr(clap, [][]const u8 { "--cc" }, default.with("cc", true)); + testNoErr(clap, [][]const u8 { "--int", "100" }, default.with("int", 100)); +} + +test "clap: value bool" { + const clap = comptime Clap(Options) { + .defaults = default, + .params = []Param { + Param.smart("a"), + } + }; + + testNoErr(clap, [][]const u8 { "-a" }, default.with("a", true)); +} + +test "clap: value str" { + const clap = comptime Clap(Options) { + .defaults = default, + .params = []Param { + Param.smart("str").with("takes_value", Parser.string), + } + }; + + testNoErr(clap, [][]const u8 { "--str", "Hello World!" }, default.with("str", "Hello World!")); +} + +test "clap: value int" { + const clap = comptime Clap(Options) { + .defaults = default, + .params = []Param { + Param.smart("int").with("takes_value", Parser.int(i64, 10)), + } + }; + + testNoErr(clap, [][]const u8 { "--int", "100" }, default.with("int", 100)); +} + +test "clap: position" { + const clap = comptime Clap(Options) { + .defaults = default, + .params = []Param { + Param.smart("a").with("position", 0), + Param.smart("b").with("position", 1), + } + }; + + testNoErr(clap, [][]const u8 { "-a", "-b" }, default.with("a", true).with("b", true)); + testErr(clap, [][]const u8 { "-b", "-a" }, error.InvalidPosition); +} -- cgit v1.2.3