1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
|
# zig-clap
A simple and easy to use command line argument parser library for Zig.
## Features
* Short arguments `-a`
* Chaining `-abc` where `a` and `b` does not take values.
* Long arguments `--long`
* Supports both passing values using spacing and `=` (`-a 100`, `-a=100`)
* Short args also support passing values with no spacing or `=` (`-a100`)
* This all works with chaining (`-ba 100`, `-ba=100`, `-ba100`)
## Examples
### `StreamingClap`
The `StreamingClap` is base of all the other parsers. It's a streaming parser that uses an
`args.Iterator` to provide it with arguments lazily.
```rust
const params = []clap.Param(u8){
clap.Param(void).flag('h', false, clap.Names.prefix("help")),
clap.Param(void).option('n', true, clap.Names.prefix("number")),
clap.Param(void).positional('f'),
};
var os_iter = clap.args.OsIterator.init(allocator);
const iter = &os_iter.iter;
defer os_iter.deinit();
const exe = try iter.next();
var parser = clap.StreamingClap(u8, clap.args.OsIterator.Error).init(params, iter);
while (try parser.next()) |arg| {
switch (arg.param.id) {
'h' => debug.warn("Help!\n"),
'n' => debug.warn("--number = {}\n", arg.value.?),
'f' => debug.warn("{}\n", arg.value.?),
else => unreachable,
}
}
```
### `ComptimeClap`
The `ComptimeClap` is a wrapper for `StreamingClap`, which parses all the arguments and makes
them available through three functions (`flag`, `option`, `positionals`).
```rust
const params = comptime []clap.Param(void){
clap.Param(void).flag({}, false, clap.Names.prefix("help")),
clap.Param(void).option({}, true, clap.Names.prefix("number")),
clap.Param(void).positional({}),
};
var os_iter = clap.args.OsIterator.init(allocator);
const iter = &os_iter.iter;
defer os_iter.deinit();
const exe = try iter.next();
var args = try clap.ComptimeClap(void, params).parse(allocator, clap.args.OsIterator.Error, iter);
defer args.deinit();
if (args.flag("--help"))
debug.warn("Help!\n");
if (args.option("--number")) |n|
debug.warn("--number = {}\n", n);
for (args.positionals()) |pos|
debug.warn("{}\n", pos);
```
The data structure returned from this parser has lookup speed on par with array access (`arr[i]`)
and validates that the strings you pass to `option` and `flag` are actually parameters that the
program can take:
```rust
const params = comptime []clap.Param(void){
clap.Param(void).init({}, false, clap.Names.prefix("help")),
};
var os_iter = clap.args.OsIterator.init(allocator);
const iter = &os_iter.iter;
defer os_iter.deinit();
const exe = try iter.next();
var args = try clap.ComptimeClap(params).parse(allocator, clap.args.OsIterator.Error, iter);
defer args.deinit();
if (args.flag("--helps"))
debug.warn("Help!\n");
```
```
zig-clap/src/comptime.zig:103:17: error: --helps is not a parameter.
@compileError(name ++ " is not a parameter.");
^
zig-clap/src/comptime.zig:71:45: note: called from here
const param = comptime findParam(name);
^
zig-clap/example/comptime-clap.zig:41:18: note: called from here
if (args.flag("--helps"))
^
```
Ofc, this limits you to use only parameters that are comptime known.
|
