695 lines
25 KiB
Zig
695 lines
25 KiB
Zig
|
const std = @import("std");
|
||
|
|
const StructField = std.builtin.Type.StructField;
|
||
|
|
|
||
|
|
const converters = @import("./converters.zig");
|
||
|
|
const ncmeta = @import("./meta.zig");
|
||
|
|
|
||
|
|
const ConverterSignature = converters.ConverterSignature;
|
||
|
|
|
||
|
|
const ParameterType = enum {
|
||
|
|
Nominal,
|
||
|
|
Ordinal,
|
||
|
|
Executable,
|
||
|
|
};
|
||
|
|
|
||
|
|
const Errors = error{
|
||
|
|
BadConfiguration,
|
||
|
|
MissingTag,
|
||
|
|
ArgumentWithTags,
|
||
|
|
ArgumentWithEnvVar,
|
||
|
|
MissingDefaultConverter,
|
||
|
|
};
|
||
|
|
|
||
|
|
const ParseError = error{
|
||
|
|
ValueMissing,
|
||
|
|
FusedShortTagValueMissing,
|
||
|
|
UnknownLongTagParameter,
|
||
|
|
UnknownShortTagParameter,
|
||
|
|
};
|
||
|
|
|
||
|
|
const FlagBias = enum {
|
||
|
|
falsy,
|
||
|
|
truthy,
|
||
|
|
unbiased,
|
||
|
|
|
||
|
|
pub fn string(self: @This()) []const u8 {
|
||
|
|
return switch (self) {
|
||
|
|
.truthy => "true",
|
||
|
|
else => @compileLog(self),
|
||
|
|
};
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
const OptionResult = union(enum) {
|
||
|
|
Value: type,
|
||
|
|
flag: FlagBias,
|
||
|
|
};
|
||
|
|
|
||
|
|
pub const ParameterGenerics = struct {
|
||
|
|
ContextType: type = void,
|
||
|
|
result: OptionResult = .{ .Value = []const u8 },
|
||
|
|
param_type: ParameterType,
|
||
|
|
|
||
|
|
pub fn no_context(comptime self: @This()) bool {
|
||
|
|
return self.ContextType == void;
|
||
|
|
}
|
||
|
|
|
||
|
|
pub fn is_flag(comptime self: @This()) bool {
|
||
|
|
return self.result == .flag;
|
||
|
|
}
|
||
|
|
|
||
|
|
pub fn clone(comptime self: @This(), comptime NewResult: type) @This() {
|
||
|
|
return @This(){
|
||
|
|
.ContextType = self.ContextType,
|
||
|
|
.result = .{ .Value = NewResult },
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
pub fn ResultType(comptime self: @This()) type {
|
||
|
|
return switch (self.result) {
|
||
|
|
.Value => |res| res,
|
||
|
|
.flag => bool,
|
||
|
|
};
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
const ValuedGenericsBasis = struct { ContextType: type = void, Result: type };
|
||
|
|
const FlagGenericsBasis = struct { ContextType: type = void, flag_bias: FlagBias = .truthy };
|
||
|
|
|
||
|
|
fn tag_generics(comptime basis: ValuedGenericsBasis) ParameterGenerics {
|
||
|
|
return ParameterGenerics{
|
||
|
|
.ContextType = basis.ContextType,
|
||
|
|
.result = .{ .Value = basis.Result },
|
||
|
|
.param_type = .Nominal,
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
fn flag_generics(comptime basis: FlagGenericsBasis) ParameterGenerics {
|
||
|
|
return ParameterGenerics{
|
||
|
|
.ContextType = basis.ContextType,
|
||
|
|
.result = .{ .flag = basis.flag_bias },
|
||
|
|
.param_type = .Nominal,
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
fn arg_generics(comptime basis: ValuedGenericsBasis) ParameterGenerics {
|
||
|
|
return ParameterGenerics{
|
||
|
|
.ContextType = basis.ContextType,
|
||
|
|
.result = .{ .Value = basis.Result },
|
||
|
|
.param_type = .Ordinal,
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
fn OptionConfig(comptime generics: ParameterGenerics) type {
|
||
|
|
return struct {
|
||
|
|
name: []const u8,
|
||
|
|
|
||
|
|
short_tag: ?[]const u8 = null,
|
||
|
|
long_tag: ?[]const u8 = null,
|
||
|
|
env_var: ?[]const u8 = null,
|
||
|
|
|
||
|
|
default: ?generics.ResultType() = null,
|
||
|
|
converter: ?ConverterSignature(generics) = null,
|
||
|
|
arg_count: u32 = if (generics.is_flag()) 0 else 1,
|
||
|
|
eager: bool = false,
|
||
|
|
required: bool = generics.param_type == .Ordinal,
|
||
|
|
exposed: bool = true,
|
||
|
|
secret: bool = false,
|
||
|
|
nice_type_name: []const u8 = @typeName(generics.ResultType()),
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
fn OptionType(comptime generics: ParameterGenerics) type {
|
||
|
|
return struct {
|
||
|
|
pub const gen = generics;
|
||
|
|
pub const param_type: ParameterType = generics.param_type;
|
||
|
|
pub const is_flag: bool = generics.is_flag();
|
||
|
|
pub const flag_bias: FlagBias = if (generics.is_flag()) generics.result.flag else .unbiased;
|
||
|
|
|
||
|
|
name: []const u8,
|
||
|
|
short_tag: ?[]const u8,
|
||
|
|
long_tag: ?[]const u8,
|
||
|
|
env_var: ?[]const u8,
|
||
|
|
|
||
|
|
default: ?generics.ResultType(),
|
||
|
|
converter: ConverterSignature(generics),
|
||
|
|
description: []const u8 = "", // description for output in help text
|
||
|
|
arg_count: u32,
|
||
|
|
eager: bool,
|
||
|
|
required: bool,
|
||
|
|
exposed: bool, // do not expose the resulting value in the output type. the handler must have side effects for this option to do anything
|
||
|
|
secret: bool, // do not print help for this parameter
|
||
|
|
nice_type_name: ?[]const u8 = null, // friendly type name (string better than []const u8)
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
fn check_short(comptime short_tag: ?[]const u8) void {
|
||
|
|
if (short_tag) |short| {
|
||
|
|
if (short.len != 2 or short[0] != '-') @compileError("bad short tag");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
fn check_long(comptime long_tag: ?[]const u8) void {
|
||
|
|
if (long_tag) |long| {
|
||
|
|
if (long.len < 3 or long[0] != '-' or long[1] != '-') @compileError("bad long tag");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
fn make_option(comptime generics: ParameterGenerics, comptime opts: OptionConfig(generics)) OptionType(generics) {
|
||
|
|
if (opts.short_tag == null and opts.long_tag == null and opts.env_var == null) {
|
||
|
|
@compileError(
|
||
|
|
"option " ++
|
||
|
|
opts.name ++
|
||
|
|
" must have at least one of a short tag, a long tag, or an environment variable",
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
check_short(opts.short_tag);
|
||
|
|
check_long(opts.long_tag);
|
||
|
|
|
||
|
|
// perform the logic to create the default converter here? Could be done
|
||
|
|
// when creating the OptionConfig instead. Need to do it here because there
|
||
|
|
// may be an error. That's the essential distinction between the OptionType
|
||
|
|
// and the OptionConfig, is the OptionConfig is just unvalidated parameters,
|
||
|
|
// whereas the OptionType is an instance of an object that has been
|
||
|
|
// validated.
|
||
|
|
const converter = opts.converter orelse converters.default_converter(generics) orelse {
|
||
|
|
@compileLog(opts);
|
||
|
|
@compileError("implement me");
|
||
|
|
};
|
||
|
|
|
||
|
|
return OptionType(generics){
|
||
|
|
.name = opts.name,
|
||
|
|
.short_tag = opts.short_tag,
|
||
|
|
.long_tag = opts.long_tag,
|
||
|
|
.env_var = opts.env_var,
|
||
|
|
.default = opts.default,
|
||
|
|
.converter = converter,
|
||
|
|
.arg_count = opts.arg_count,
|
||
|
|
.eager = opts.eager,
|
||
|
|
.required = opts.required,
|
||
|
|
.exposed = opts.exposed,
|
||
|
|
.secret = opts.secret,
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
fn make_argument(comptime generics: ParameterGenerics, comptime opts: OptionConfig(generics)) OptionType(generics) {
|
||
|
|
// TODO: it would technically be possible to support specification of
|
||
|
|
// ordered arguments through environmental variables, but it doesn't really
|
||
|
|
// make a lot of sense. The algorithm would consume the env var greedily
|
||
|
|
if (opts.short_tag != null or opts.long_tag != null or opts.env_var != null) {
|
||
|
|
@compileLog(opts);
|
||
|
|
@compileError("argument " ++ opts.name ++ " must not have a long or short tag or an env var");
|
||
|
|
}
|
||
|
|
|
||
|
|
const converter = opts.converter orelse converters.default_converter(generics) orelse {
|
||
|
|
@compileLog(opts);
|
||
|
|
@compileError("implement me");
|
||
|
|
};
|
||
|
|
|
||
|
|
return OptionType(generics){
|
||
|
|
.name = opts.name,
|
||
|
|
.short_tag = opts.short_tag,
|
||
|
|
.long_tag = opts.long_tag,
|
||
|
|
.env_var = opts.env_var,
|
||
|
|
.default = opts.default,
|
||
|
|
.converter = converter,
|
||
|
|
.arg_count = opts.arg_count,
|
||
|
|
.eager = opts.eager,
|
||
|
|
.required = opts.required,
|
||
|
|
.exposed = opts.exposed,
|
||
|
|
.secret = opts.secret,
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
const ShortLongPair = struct {
|
||
|
|
short_tag: ?[]const u8 = null,
|
||
|
|
long_tag: ?[]const u8 = null,
|
||
|
|
};
|
||
|
|
|
||
|
|
fn FlagBuilderArgs(comptime ContextType: type) type {
|
||
|
|
return struct {
|
||
|
|
name: []const u8,
|
||
|
|
truthy: ?ShortLongPair = null,
|
||
|
|
falsy: ?ShortLongPair = null,
|
||
|
|
env_var: ?[]const u8 = null,
|
||
|
|
|
||
|
|
default: ?bool = null,
|
||
|
|
converter: ?ConverterSignature(flag_generics(.{ .ContextType = ContextType })) = null,
|
||
|
|
eager: bool = false,
|
||
|
|
exposed: bool = true,
|
||
|
|
required: bool = false,
|
||
|
|
secret: bool = false,
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
fn CommandBuilder(comptime ContextType: type) type {
|
||
|
|
return struct {
|
||
|
|
param_spec: ncmeta.MutableTuple = .{},
|
||
|
|
|
||
|
|
pub const UserContextType = ContextType;
|
||
|
|
|
||
|
|
pub fn add_argument(
|
||
|
|
comptime self: *@This(),
|
||
|
|
comptime Result: type,
|
||
|
|
comptime args: OptionConfig(arg_generics(.{ .ContextType = ContextType, .Result = Result })),
|
||
|
|
) void {
|
||
|
|
self.param_spec.add(make_argument(
|
||
|
|
arg_generics(.{ .ContextType = ContextType, .Result = Result }),
|
||
|
|
args,
|
||
|
|
));
|
||
|
|
}
|
||
|
|
|
||
|
|
pub fn add_option(
|
||
|
|
comptime self: *@This(),
|
||
|
|
comptime Result: type,
|
||
|
|
comptime args: OptionConfig(tag_generics(.{ .ContextType = ContextType, .Result = Result })),
|
||
|
|
) void {
|
||
|
|
self.param_spec.add(make_option(
|
||
|
|
tag_generics(.{ .ContextType = ContextType, .Result = Result }),
|
||
|
|
args,
|
||
|
|
));
|
||
|
|
}
|
||
|
|
|
||
|
|
pub fn add_flag(
|
||
|
|
comptime self: *@This(),
|
||
|
|
comptime build_args: FlagBuilderArgs(ContextType),
|
||
|
|
) void {
|
||
|
|
if (build_args.truthy == null and build_args.falsy == null and build_args.env_var == null) {
|
||
|
|
@compileError(
|
||
|
|
"flag " ++
|
||
|
|
build_args.name ++
|
||
|
|
" must have at least one of truthy flags, falsy flags, or env_var flags",
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (build_args.truthy) |truthy_pair| {
|
||
|
|
if (truthy_pair.short_tag == null and truthy_pair.long_tag == null) {
|
||
|
|
@compileError(
|
||
|
|
"flag " ++
|
||
|
|
build_args.name ++
|
||
|
|
" truthy pair must have at least short or long tags set",
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
const generics = flag_generics(.{ .ContextType = ContextType, .flag_bias = .truthy });
|
||
|
|
|
||
|
|
const args = OptionConfig(generics){
|
||
|
|
.name = build_args.name,
|
||
|
|
.short_tag = truthy_pair.short_tag,
|
||
|
|
.long_tag = truthy_pair.long_tag,
|
||
|
|
.env_var = null,
|
||
|
|
.default = build_args.default,
|
||
|
|
.converter = build_args.converter,
|
||
|
|
.eager = build_args.eager,
|
||
|
|
.exposed = build_args.exposed,
|
||
|
|
.secret = build_args.secret,
|
||
|
|
};
|
||
|
|
|
||
|
|
self.param_spec.add(make_option(generics, args));
|
||
|
|
}
|
||
|
|
|
||
|
|
if (build_args.falsy) |falsy_pair| {
|
||
|
|
if (falsy_pair.short_tag == null and falsy_pair.long_tag == null) {
|
||
|
|
@compileError(
|
||
|
|
"flag " ++
|
||
|
|
build_args.name ++
|
||
|
|
" falsy pair must have at least short or long tags set",
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
const generics = flag_generics(.{ .ContextType = ContextType, .flag_bias = .falsy });
|
||
|
|
const args = OptionConfig(generics){
|
||
|
|
.name = build_args.name,
|
||
|
|
.short_tag = falsy_pair.short_tag,
|
||
|
|
.long_tag = falsy_pair.long_tag,
|
||
|
|
.env_var = null,
|
||
|
|
.default = build_args.default,
|
||
|
|
.converter = build_args.converter,
|
||
|
|
.eager = build_args.eager,
|
||
|
|
.secret = build_args.secret,
|
||
|
|
};
|
||
|
|
|
||
|
|
self.param_spec.add(make_option(generics, args));
|
||
|
|
}
|
||
|
|
|
||
|
|
if (build_args.env_var) |env_var| {
|
||
|
|
const generics = flag_generics(.{ .ContextType = ContextType, .flag_bias = .unbiased });
|
||
|
|
const args = OptionConfig(generics){
|
||
|
|
.name = build_args.name,
|
||
|
|
.env_var = env_var,
|
||
|
|
.default = build_args.default,
|
||
|
|
.converter = build_args.converter,
|
||
|
|
.eager = build_args.eager,
|
||
|
|
.secret = build_args.secret,
|
||
|
|
};
|
||
|
|
|
||
|
|
self.param_spec.add(make_option(generics, args));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
fn generate(comptime self: @This()) self.param_spec.TupleType() {
|
||
|
|
return self.param_spec.realTuple();
|
||
|
|
}
|
||
|
|
|
||
|
|
pub fn CallbackSignature(comptime self: @This()) type {
|
||
|
|
return *const fn (ContextType, self.CommandOutput()) anyerror!void;
|
||
|
|
}
|
||
|
|
|
||
|
|
pub fn CommandOutput(comptime self: @This()) type {
|
||
|
|
comptime {
|
||
|
|
const spec = self.generate();
|
||
|
|
var fields: []const StructField = &[0]StructField{};
|
||
|
|
var flag_skip = 0;
|
||
|
|
|
||
|
|
paramloop: for (spec, 0..) |param, idx| {
|
||
|
|
if (!param.exposed) continue :paramloop;
|
||
|
|
while (flag_skip > 0) {
|
||
|
|
flag_skip -= 1;
|
||
|
|
continue :paramloop;
|
||
|
|
}
|
||
|
|
|
||
|
|
const PType = @TypeOf(param);
|
||
|
|
if (PType.is_flag) {
|
||
|
|
var peek = idx + 1;
|
||
|
|
var bais_seen: [ncmeta.enum_length(FlagBias)]bool = [_]bool{false} ** ncmeta.enum_length(FlagBias);
|
||
|
|
bais_seen[@enumToInt(PType.flag_bias)] = true;
|
||
|
|
while (peek < spec.len) : (peek += 1) {
|
||
|
|
const peek_param = spec[peek];
|
||
|
|
const PeekType = @TypeOf(peek_param);
|
||
|
|
|
||
|
|
if (PeekType.is_flag and std.mem.eql(u8, param.name, peek_param.name)) {
|
||
|
|
if (bais_seen[@enumToInt(PeekType.flag_bias)] == true) {
|
||
|
|
@compileError("redundant flag!!!! " ++ param.name ++ " and " ++ peek_param.name);
|
||
|
|
} else {
|
||
|
|
bais_seen[@enumToInt(PeekType.flag_bias)] = true;
|
||
|
|
}
|
||
|
|
flag_skip += 1;
|
||
|
|
} else {
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// the default field is already the optional type. Stripping
|
||
|
|
// the optional wrapper is an interesting idea for required
|
||
|
|
// fields. I do not foresee this greatly increasing complexity here.
|
||
|
|
const FieldType = if (param.required)
|
||
|
|
std.meta.Child(std.meta.FieldType(PType, .default))
|
||
|
|
else
|
||
|
|
std.meta.FieldType(PType, .default);
|
||
|
|
|
||
|
|
// the wacky comptime slice extension hack
|
||
|
|
fields = &(@as([fields.len]StructField, fields[0..fields.len].*) ++ [1]StructField{.{
|
||
|
|
.name = param.name,
|
||
|
|
.type = FieldType,
|
||
|
|
.default_value = @ptrCast(?*const anyopaque, ¶m.default),
|
||
|
|
.is_comptime = false,
|
||
|
|
.alignment = @alignOf(FieldType),
|
||
|
|
}});
|
||
|
|
}
|
||
|
|
|
||
|
|
return @Type(.{ .Struct = .{
|
||
|
|
.layout = .Auto,
|
||
|
|
.fields = fields,
|
||
|
|
.decls = &.{},
|
||
|
|
.is_tuple = false,
|
||
|
|
} });
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
pub fn Intermediate(comptime self: @This()) type {
|
||
|
|
comptime {
|
||
|
|
const spec = self.generate();
|
||
|
|
var fields: []const StructField = &[0]StructField{};
|
||
|
|
var flag_skip = 0;
|
||
|
|
|
||
|
|
paramloop: for (spec, 0..) |param, idx| {
|
||
|
|
while (flag_skip > 0) {
|
||
|
|
flag_skip -= 1;
|
||
|
|
continue :paramloop;
|
||
|
|
}
|
||
|
|
|
||
|
|
const PType = @TypeOf(param);
|
||
|
|
if (PType.is_flag) {
|
||
|
|
var peek = idx + 1;
|
||
|
|
var bais_seen: [ncmeta.enum_length(FlagBias)]bool = [_]bool{false} ** ncmeta.enum_length(FlagBias);
|
||
|
|
bais_seen[@enumToInt(PType.flag_bias)] = true;
|
||
|
|
while (peek < spec.len) : (peek += 1) {
|
||
|
|
const peek_param = spec[peek];
|
||
|
|
const PeekType = @TypeOf(peek_param);
|
||
|
|
|
||
|
|
if (PeekType.is_flag and std.mem.eql(u8, param.name, peek_param.name)) {
|
||
|
|
if (bais_seen[@enumToInt(PeekType.flag_bias)] == true) {
|
||
|
|
@compileError("redundant flag!!!! " ++ param.name ++ " and " ++ peek_param.name);
|
||
|
|
} else {
|
||
|
|
bais_seen[@enumToInt(PeekType.flag_bias)] = true;
|
||
|
|
}
|
||
|
|
flag_skip += 1;
|
||
|
|
} else {
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// the wacky comptime slice extension hack
|
||
|
|
fields = &(@as([fields.len]StructField, fields[0..fields.len].*) ++ [1]StructField{.{
|
||
|
|
.name = param.name,
|
||
|
|
.type = ?[]const u8,
|
||
|
|
.default_value = @ptrCast(?*const anyopaque, &@as(?[]const u8, null)),
|
||
|
|
.is_comptime = false,
|
||
|
|
.alignment = @alignOf(?[]const u8),
|
||
|
|
}});
|
||
|
|
}
|
||
|
|
|
||
|
|
return @Type(.{ .Struct = .{
|
||
|
|
.layout = .Auto,
|
||
|
|
.fields = fields,
|
||
|
|
.decls = &.{},
|
||
|
|
.is_tuple = false,
|
||
|
|
} });
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
pub fn bind(comptime self: @This(), comptime callback: self.CallbackSignature()) Parser(self, callback) {
|
||
|
|
return Parser(self, callback){};
|
||
|
|
}
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
// the parser is generated by the bind method of the CommandBuilder, so we can
|
||
|
|
// be extremely type-sloppy here, which simplifies the signature.
|
||
|
|
fn Parser(comptime command: anytype, comptime callback: anytype) type {
|
||
|
|
_ = callback;
|
||
|
|
|
||
|
|
return struct {
|
||
|
|
const ContextType = @TypeOf(command).UserContextType;
|
||
|
|
// let there be fields! we can move some things to runtime.
|
||
|
|
// We can get some better behavior if we defer converting non-eager
|
||
|
|
// options until the entire command line has been parsed. However,
|
||
|
|
// to do that, we effectively have to store the parameters as strings until the
|
||
|
|
// entire line has been parsed.
|
||
|
|
|
||
|
|
// a goal is to
|
||
|
|
|
||
|
|
intermediate: command.Intermediate() = .{},
|
||
|
|
consumed_args: u32 = 0,
|
||
|
|
|
||
|
|
// pub fn add_subcommand(self: *@This(), verb: []const u8, parser: anytype) void {
|
||
|
|
// self.subcommands
|
||
|
|
// }
|
||
|
|
|
||
|
|
pub fn parse(
|
||
|
|
self: *@This(),
|
||
|
|
alloc: std.mem.Allocator,
|
||
|
|
argit: *std.process.ArgIterator,
|
||
|
|
env: std.process.EnvMap,
|
||
|
|
context: ContextType,
|
||
|
|
) anyerror!void {
|
||
|
|
_ = alloc;
|
||
|
|
// _ = context;
|
||
|
|
|
||
|
|
try self.read_environment(env);
|
||
|
|
|
||
|
|
var forced_args = false;
|
||
|
|
argloop: while (argit.next()) |arg| {
|
||
|
|
if (!forced_args and std.mem.eql(u8, arg, "--")) {
|
||
|
|
forced_args = true;
|
||
|
|
continue :argloop;
|
||
|
|
}
|
||
|
|
|
||
|
|
parse_tags: {
|
||
|
|
if (forced_args or arg.len < 1 or arg[0] != '-') break :parse_tags;
|
||
|
|
|
||
|
|
if (arg.len > 2 and arg[1] == '-') {
|
||
|
|
try self.parse_long_tag(arg, argit, context);
|
||
|
|
continue :argloop;
|
||
|
|
} else if (arg.len > 1) {
|
||
|
|
for (arg[1..], 1..) |short, idx| {
|
||
|
|
// _ = short;
|
||
|
|
// _ = idx;
|
||
|
|
try self.parse_short_tag(short, arg.len - idx - 1, argit, context);
|
||
|
|
}
|
||
|
|
continue :argloop;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
try self.parse_argument(arg, argit);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
inline fn parse_long_tag(
|
||
|
|
self: *@This(),
|
||
|
|
arg: []const u8,
|
||
|
|
argit: *std.process.ArgIterator,
|
||
|
|
context: ContextType,
|
||
|
|
) ParseError!void {
|
||
|
|
_ = context;
|
||
|
|
|
||
|
|
inline for (comptime command.generate()) |param| {
|
||
|
|
const PType = @TypeOf(param);
|
||
|
|
// removing the comptime here causes the compiler to die
|
||
|
|
comptime if (PType.param_type != .Nominal or param.long_tag == null) continue;
|
||
|
|
const tag = param.long_tag.?;
|
||
|
|
|
||
|
|
if (comptime PType.is_flag) {
|
||
|
|
if (std.mem.eql(u8, arg, tag)) {
|
||
|
|
@field(self.intermediate, param.name) = if (comptime PType.flag_bias == .truthy) "true" else "false";
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
if (std.mem.startsWith(u8, arg, tag)) match: {
|
||
|
|
// TODO: handle more than one value
|
||
|
|
const next = if (arg.len == tag.len)
|
||
|
|
argit.next() orelse return ParseError.ValueMissing
|
||
|
|
else if (arg[tag.len] == '=')
|
||
|
|
arg[tag.len + 1 ..]
|
||
|
|
else
|
||
|
|
break :match;
|
||
|
|
|
||
|
|
@field(self.intermediate, param.name) = next;
|
||
|
|
// if (comptime param.eager) {
|
||
|
|
// try param.converter()
|
||
|
|
// }
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return ParseError.UnknownLongTagParameter;
|
||
|
|
}
|
||
|
|
|
||
|
|
inline fn parse_short_tag(
|
||
|
|
self: *@This(),
|
||
|
|
arg: u8,
|
||
|
|
remaining: usize,
|
||
|
|
argit: *std.process.ArgIterator,
|
||
|
|
context: ContextType,
|
||
|
|
) ParseError!void {
|
||
|
|
_ = context;
|
||
|
|
|
||
|
|
inline for (comptime command.generate()) |param| {
|
||
|
|
const PType = @TypeOf(param);
|
||
|
|
// removing the comptime here causes the compiler to die
|
||
|
|
comptime if (PType.param_type != .Nominal or param.short_tag == null) continue;
|
||
|
|
const tag = param.short_tag.?;
|
||
|
|
|
||
|
|
if (comptime PType.is_flag) {
|
||
|
|
if (arg == tag[1]) {
|
||
|
|
@field(self.intermediate, param.name) = if (comptime PType.flag_bias == .truthy) "true" else "false";
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
if (arg == tag[1]) {
|
||
|
|
if (remaining > 0) return ParseError.FusedShortTagValueMissing;
|
||
|
|
const next = argit.next() orelse return ParseError.ValueMissing;
|
||
|
|
|
||
|
|
@field(self.intermediate, param.name) = next;
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return ParseError.UnknownShortTagParameter;
|
||
|
|
}
|
||
|
|
|
||
|
|
inline fn parse_argument(self: *@This(), arg: []const u8, argit: *std.process.ArgIterator) ParseError!void {
|
||
|
|
_ = argit;
|
||
|
|
|
||
|
|
comptime var arg_index: u32 = 0;
|
||
|
|
inline for (comptime command.generate()) |param| {
|
||
|
|
if (@TypeOf(param).param_type != .Ordinal) continue;
|
||
|
|
|
||
|
|
if (self.consumed_args == arg_index) {
|
||
|
|
std.debug.print("n: {s}, c: {d}, i: {d}\n", .{ param.name, self.consumed_args, arg_index });
|
||
|
|
@field(self.intermediate, param.name) = arg;
|
||
|
|
self.consumed_args += 1;
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
arg_index += 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
fn read_environment(self: *@This(), env: std.process.EnvMap) !void {
|
||
|
|
inline for (comptime command.generate()) |param| {
|
||
|
|
if (comptime param.env_var) |env_var| {
|
||
|
|
@field(self.intermediate, param.name) = env.get(env_var);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
fn HelpBuilder(comptime command: anytype) type {
|
||
|
|
_ = command;
|
||
|
|
}
|
||
|
|
|
||
|
|
pub fn command_builder(comptime ContextType: type) CommandBuilder(ContextType) {
|
||
|
|
return CommandBuilder(ContextType){};
|
||
|
|
}
|
||
|
|
|
||
|
|
const Choice = enum { first, second };
|
||
|
|
|
||
|
|
const cli = cmd: {
|
||
|
|
var cmd = command_builder(void);
|
||
|
|
cmd.add_option(u8, .{
|
||
|
|
.name = "test",
|
||
|
|
.short_tag = "-t",
|
||
|
|
.long_tag = "--test",
|
||
|
|
.env_var = "NOCLIP_TEST",
|
||
|
|
});
|
||
|
|
cmd.add_flag(.{
|
||
|
|
.name = "flag",
|
||
|
|
.truthy = .{ .short_tag = "-f", .long_tag = "--flag" },
|
||
|
|
.falsy = .{ .long_tag = "--no-flag" },
|
||
|
|
.env_var = "NOCLIP_FLAG",
|
||
|
|
});
|
||
|
|
cmd.add_argument([]const u8, .{ .name = "arg" });
|
||
|
|
cmd.add_argument([]const u8, .{ .name = "argtwo" });
|
||
|
|
|
||
|
|
break :cmd cmd;
|
||
|
|
};
|
||
|
|
|
||
|
|
fn cli_handler(_: void, result: cli.CommandOutput()) !void {
|
||
|
|
_ = result;
|
||
|
|
}
|
||
|
|
|
||
|
|
pub fn main() !void {
|
||
|
|
// std.debug.print("hello\n", .{});
|
||
|
|
var parser = cli.bind(cli_handler);
|
||
|
|
|
||
|
|
var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
|
||
|
|
defer arena.deinit();
|
||
|
|
|
||
|
|
const allocator = arena.allocator();
|
||
|
|
var argit = try std.process.argsWithAllocator(allocator);
|
||
|
|
var env = try std.process.getEnvMap(allocator);
|
||
|
|
|
||
|
|
_ = argit.next();
|
||
|
|
try parser.parse(allocator, &argit, env, {});
|
||
|
|
|
||
|
|
inline for (@typeInfo(@TypeOf(parser.intermediate)).Struct.fields) |field| {
|
||
|
|
std.debug.print("{s}: {?s}\n", .{ field.name, @field(parser.intermediate, field.name) });
|
||
|
|
}
|
||
|
|
}
|