From 44ea38f25453fbf51de72505d7b3ddb0f3eec13c Mon Sep 17 00:00:00 2001 From: Jimmi HC Date: Wed, 12 Jun 2019 15:30:30 +0200 Subject: updated to newest version of zig --- clap.zig | 226 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 226 insertions(+) create mode 100644 clap.zig (limited to 'clap.zig') diff --git a/clap.zig b/clap.zig new file mode 100644 index 0000000..8823b59 --- /dev/null +++ b/clap.zig @@ -0,0 +1,226 @@ +const std = @import("std"); + +const debug = std.debug; +const io = std.io; +const mem = std.mem; + +pub const @"comptime" = @import("src/comptime.zig"); +pub const args = @import("src/args.zig"); +pub const streaming = @import("src/streaming.zig"); + +test "clap" { + _ = @"comptime"; + _ = args; + _ = streaming; +} + +pub const ComptimeClap = @"comptime".ComptimeClap; +pub const StreamingClap = streaming.StreamingClap; + +/// The names a ::Param can have. +pub const Names = struct { + /// '-' prefix + short: ?u8 = null, + + /// '--' prefix + long: ?[]const u8 = null, +}; + +/// 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" +/// * Positional: Should be used as the primary parameter of the program, like a filename or +/// an expression to parse. +/// * Positional parameters have both names.long and names.short == null. +/// * Positional parameters must take a value. +pub fn Param(comptime Id: type) type { + return struct { + id: Id = Id{}, + names: Names = Names{}, + takes_value: bool = false, + }; +} + +/// Will print a help message in the following format: +/// -s, --long=value_text help_text +/// -s, help_text +/// --long help_text +pub fn helpFull( + stream: var, + comptime Id: type, + params: []const Param(Id), + comptime Error: type, + context: var, + help_text: fn (@typeOf(context), Param(Id)) Error![]const u8, + value_text: fn (@typeOf(context), Param(Id)) Error![]const u8, +) !void { + const max_spacing = blk: { + var res: usize = 0; + for (params) |param| { + var counting_stream = io.CountingOutStream(io.NullOutStream.Error).init(io.null_out_stream); + try printParam(&counting_stream.stream, Id, param, Error, context, value_text); + if (res < counting_stream.bytes_written) + res = counting_stream.bytes_written; + } + + break :blk res; + }; + + for (params) |param| { + if (param.names.short == null and param.names.long == null) + continue; + + var counting_stream = io.CountingOutStream(@typeOf(stream.*).Error).init(stream); + try stream.print("\t"); + try printParam(&counting_stream.stream, Id, param, Error, context, value_text); + try stream.writeByteNTimes(' ', max_spacing - counting_stream.bytes_written); + try stream.print("\t{}\n", try help_text(context, param)); + } +} + +fn printParam( + stream: var, + comptime Id: type, + param: Param(Id), + comptime Error: type, + context: var, + value_text: fn (@typeOf(context), Param(Id)) Error![]const u8, +) @typeOf(stream.*).Error!void { + if (param.names.short) |s| { + try stream.print("-{c}", s); + } else { + try stream.print(" "); + } + if (param.names.long) |l| { + if (param.names.short) |_| { + try stream.print(", "); + } else { + try stream.print(" "); + } + + try stream.print("--{}", l); + } + if (param.takes_value) + try stream.print("={}", value_text(context, param)); +} + +/// A wrapper around helpFull for simple help_text and value_text functions that +/// cant return an error or take a context. +pub fn helpEx( + stream: var, + comptime Id: type, + params: []const Param(Id), + help_text: fn (Param(Id)) []const u8, + value_text: fn (Param(Id)) []const u8, +) !void { + const Context = struct { + help_text: fn (Param(Id)) []const u8, + value_text: fn (Param(Id)) []const u8, + + pub fn help(c: @This(), p: Param(Id)) error{}![]const u8 { + return c.help_text(p); + } + + pub fn value(c: @This(), p: Param(Id)) error{}![]const u8 { + return c.value_text(p); + } + }; + + return helpFull( + stream, + Id, + params, + error{}, + Context{ + .help_text = help_text, + .value_text = value_text, + }, + Context.help, + Context.value, + ); +} + +/// A wrapper around helpEx that takes a Param([]const u8) and uses the string id +/// as the help text for each paramter. +pub fn help(stream: var, params: []const Param([]const u8)) !void { + try helpEx(stream, []const u8, params, getHelpSimple, getValueSimple); +} + +fn getHelpSimple(param: Param([]const u8)) []const u8 { + return param.id; +} + +fn getValueSimple(param: Param([]const u8)) []const u8 { + return "VALUE"; +} + +test "clap.help" { + var buf: [1024]u8 = undefined; + var slice_stream = io.SliceOutStream.init(buf[0..]); + try help( + &slice_stream.stream, + [_]Param([]const u8){ + Param([]const u8){ + .id = "Short flag.", + .names = Names{ .short = 'a' }, + }, + Param([]const u8){ + .id = "Short option.", + .names = Names{ .short = 'b' }, + .takes_value = true, + }, + Param([]const u8){ + .id = "Long flag.", + .names = Names{ .long = "aa" }, + }, + Param([]const u8){ + .id = "Long option.", + .names = Names{ .long = "bb" }, + .takes_value = true, + }, + Param([]const u8){ + .id = "Both flag.", + .names = Names{ .short = 'c', .long = "cc" }, + }, + Param([]const u8){ + .id = "Both option.", + .names = Names{ .short = 'd', .long = "dd" }, + .takes_value = true, + }, + Param([]const u8){ + .id = "Positional. This should not appear in the help message.", + .takes_value = true, + }, + }, + ); + + const expected = "" ++ + "\t-a \tShort flag.\n" ++ + "\t-b=VALUE \tShort option.\n" ++ + "\t --aa \tLong flag.\n" ++ + "\t --bb=VALUE\tLong option.\n" ++ + "\t-c, --cc \tBoth flag.\n" ++ + "\t-d, --dd=VALUE\tBoth option.\n"; + + if (!mem.eql(u8, slice_stream.getWritten(), expected)) { + debug.warn("============ Expected ============\n"); + debug.warn("{}", expected); + debug.warn("============= Actual =============\n"); + debug.warn("{}", slice_stream.getWritten()); + return error.NoMatch; + } +} -- cgit v1.2.3