getargs-derive 0.1.0

Clap-style #[derive] command-line argument parser for no_std and embedded Rust: zero allocation, compile-time help, subcommands. Built on getargs.
Documentation 
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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

use getargs_derive::{Error, GetArgs, Opt};

#[derive(GetArgs)]
struct BasicPositionalFlag<'a> {
    positional_field: &'a str,
    #[arg(long)]
    bool_field: bool,
}

#[derive(GetArgs)]
struct TwoPositionals<'a> {
    first: &'a str,
    second: &'a str,
}

#[derive(GetArgs)]
struct TwoPosNoOptions<'a> {
    a: &'a str,
    b: &'a str,
}

#[derive(GetArgs)]
struct Mixed<'a> {
    input: &'a str,
    #[arg(short, long)]
    verbose: bool,
    #[arg(short, long, default_value = "out")]
    output: &'a str,
}

#[derive(Debug, GetArgs)]
struct OptionalPositionals<'a> {
    input: &'a str,
    #[arg(default_value = "out.txt")]
    output: &'a str,
    #[arg(default_value_t = 2)]
    level: u8,
}

#[test]
fn positional_and_flag() {
    let args = ["value1", "--bool-field"];
    let mut options = getargs::Options::new(args.into_iter());
    let params = BasicPositionalFlag::parse(&mut options).unwrap();
    assert_eq!(params.positional_field, "value1");
    assert!(params.bool_field);
}

#[test]
fn two_positionals() {
    let args = ["hello", "world"];
    let mut options = getargs::Options::new(args.into_iter());
    let params = TwoPositionals::parse(&mut options).unwrap();
    assert_eq!(params.first, "hello");
    assert_eq!(params.second, "world");
}

#[test]
fn all_positionals() {
    let args = ["x", "y"];
    let mut options = getargs::Options::new(args.into_iter());
    let params = TwoPosNoOptions::parse(&mut options).unwrap();
    assert_eq!(params.a, "x");
    assert_eq!(params.b, "y");
}

#[test]
fn mixed_positionals_and_options() {
    let args = ["in.txt", "--verbose"];
    let mut options = getargs::Options::new(args.into_iter());
    let params = Mixed::parse(&mut options).unwrap();
    assert_eq!(params.input, "in.txt");
    assert!(params.verbose);
    assert_eq!(params.output, "out");
}

#[test]
fn options_can_appear_before_positionals() {
    let args = ["--verbose", "in.txt"];
    let mut options = getargs::Options::new(args.into_iter());
    let params = Mixed::parse(&mut options).unwrap();
    assert_eq!(params.input, "in.txt");
    assert!(params.verbose);
}

#[test]
fn optional_positionals() {
    let params = OptionalPositionals::from_args(["in.txt"].into_iter()).unwrap();
    assert_eq!(params.input, "in.txt");
    assert_eq!(params.output, "out.txt");
    assert_eq!(params.level, 2);

    let args = ["in.txt", "res.txt"];
    let params = OptionalPositionals::from_args(args.into_iter()).unwrap();
    assert_eq!(params.output, "res.txt");
    assert_eq!(params.level, 2);

    let args = ["in.txt", "res.txt", "7"];
    let params = OptionalPositionals::from_args(args.into_iter()).unwrap();
    assert_eq!(params.level, 7);
}

#[test]
fn optional_positionals_still_require_leading_positional() {
    let err = OptionalPositionals::from_args([].into_iter()).unwrap_err();
    assert_eq!(err, Error::MissingArgument("<INPUT>"));
}

#[test]
fn optional_positionals_reject_extra_arguments() {
    let args = ["a", "b", "1", "extra"];
    let err = OptionalPositionals::from_args(args.into_iter()).unwrap_err();
    assert_eq!(err, Error::UnexpectedArgument("extra"));
}

#[test]
fn optional_positionals_are_not_named_options() {
    let args = ["in.txt", "--level", "3"];
    let err = OptionalPositionals::from_args(args.into_iter()).unwrap_err();
    assert_eq!(
        err,
        Error::UnknownOption {
            option: Opt::Long("level"),
            suggestion: None,
        }
    );
}