A clap-rs inspired command line argument parser design for zig

TheWaWaR · March 31, 2024, 1:12pm

gist.github.com

https://gist.github.com/TheWaWaR/9c4dde075291ed9484f0aca87c47528a

clap-sample.zig

const print = @import("std").debug.print;

const clap = @import("clap");
const Arg = clap.Arg;
const Subcommand = clap.Subcommand;

const Cli = clap.Parser(struct {
    name: Arg(?[]const u8, .{
        .short = "n",
        .help = "Optional name to operate on",

This file has been truncated. show original

The design is inspired by clap-rs, which I used frequently.
The Arg and Subcommand are comptime functions accept a type and a config then generate a parser config. The clap.Parser is to generate the parser code and a final data structure to hold the parsed value.

squeek502 · March 31, 2024, 4:41pm

In case you haven’t seen it, there’s also

TheWaWaR · April 1, 2024, 2:27am

I know this library and also investigated some other libraries like:

GitHub - prajwalch/yazap: 🔧 The ultimate Zig library for seamless command line parsing. Effortlessly handles options, subcommands, and custom arguments with ease.
GitHub - ikskuh/zig-args: Simple-to-use argument parser with struct-based config

But I want a library:

Support multiple level subcommand
Support parse common types from string
Define the parser as straightforward as possible
Use the parsed result as simple as possible

jiacai2050 · April 1, 2024, 4:38am

Yes there are many arguments parsers in Zig, but none of them could match clap rs.

This is what I write before, i wonder if you like its syntax?

Although sub command is still not supported, but should be easy to implement.

jiacai2050 · April 1, 2024, 11:15am

FYI, I draft a design for subcommands here:

github.com/jiacai2050/zigcli

Simargs support subcommands

opened 11:09AM - 01 Apr 24 UTC

closed 01:12PM - 11 Aug 24 UTC

jiacai2050

For now, simargs doesn't sub commands, add subcommands support will make it much… more powerful. The syntax I could think of is like this: ``` zig const App = struct { help: bool = false, output: []const u8, sub_command1: ?struct { flags1: int, }, sub_command2: ?struct { flags1: int, }, }; ``` Since there are more than one subcommand, we use optional to annotate them. Or we can represent subcommand with `union(enum)` ``` zig const App = struct { help: bool = false, output: []const u8, sub_command: union(enum) { sub_cmd1: struct { flag1: i8, }, sub_cmd2: struct { flag1: i8, }, }, }; ``` Here both method use nested struct to represent subcommands, and it can be nested at any-level! The help message would look like this: ``` shell Usage: mycli [Global-Options] [COMMAND] [Options] Commands: sub_command1 xxx sub_command2 yyy Options: -o, --output <file> Output file -h, --help Print help ```

jiacai2050 · August 11, 2024, 1:18pm

Update, subcommands is supported, usage can be seen here:

github.com

jiacai2050/zigcli/blob/f7f06589ed6f7560492486b82d838f57b73f1e43/examples/simargs-demo.zig#L13-L53


      
          var opt = try simargs.parse(allocator, struct {
              // Those fields declare arguments options
              // only `output` is required, others are all optional
              verbose: ?bool,
              @"user-agent": enum { Chrome, Firefox, Safari } = .Firefox,
              timeout: ?u16 = 30, // default value
              output: []const u8,
              help: bool = false,
              version: bool = false,
          
              // This special field define sub_commands,
              // Each union item is a config struct, which is similar with top-level config struct.
              __commands__: union(enum) {
                  sub1: struct {
                      a: u64,
                      help: bool = false,
                  },
                  sub2: struct { name: []const u8 },
          
                  // Define help message for sub commands.

This file has been truncated. show original

Travis · August 11, 2024, 7:56pm

I have one with sub commands too https://github.com/travisstaloch/clarp

jiacai2050 · August 12, 2024, 3:00am

Thanks for share, it seems clarp share same design with simargs, which is to use a config struct/union to represent what to parse.

Glad to see projects taking full advantages of Zig’s comptime.