rust-args-parser 2.0.0

Tiny, fast, callback-based CLI argument parser for Rust
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
128
129

use rust_args_parser as ap;

mod common;
use common::*;

use core::fmt;

#[derive(Debug)]
struct AppErr(&'static str);

impl fmt::Display for AppErr {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.0)
    }
}

impl std::error::Error for AppErr {}

#[test]
fn cmd_validator_and_handler_variants() {
    let env = env_basic();

    // validator (Display-only) => Error::User
    let root = ap::CmdSpec::new("t").validator(|_| -> Result<(), &'static str> { Err("nope") });
    let err = ap::parse(&env, &root, &[], &mut Ctx::default()).unwrap_err();
    match err {
        ap::Error::User(msg) => assert!(msg.contains("nope")),
        other => panic!("unexpected: {other:?}"),
    }

    // validator_try (typed error) => Error::UserAny(AppErr)
    let root = ap::CmdSpec::new("t").validator_try(|_| -> Result<(), AppErr> { Err(AppErr("bad")) });
    let err = ap::parse(&env, &root, &[], &mut Ctx::default()).unwrap_err();
    match err {
        ap::Error::UserAny(e) => {
            let e = e.downcast_ref::<AppErr>().expect("must preserve AppErr");
            assert_eq!(e.0, "bad");
        }
        other => panic!("unexpected: {other:?}"),
    }

    // handler (infallible) executes on leaf
    let root = ap::CmdSpec::new("t").subcmd(ap::CmdSpec::new("ok").handler(|_m, ctx: &mut Ctx| {
        ctx.json = true;
    }));
    let mut ctx = Ctx::default();
    ap::parse(&env, &root, &argv(&["ok"]), &mut ctx).unwrap();
    assert!(ctx.json);

    // handler_try (typed error) => Error::UserAny(AppErr)
    let root = ap::CmdSpec::new("t").subcmd(
        ap::CmdSpec::new("fail").handler_try(|_m, _ctx: &mut Ctx| -> Result<(), AppErr> { Err(AppErr("boom")) }),
    );
    let err = ap::parse(&env, &root, &argv(&["fail"]), &mut Ctx::default()).unwrap_err();
    match err {
        ap::Error::UserAny(e) => {
            let e = e.downcast_ref::<AppErr>().expect("must preserve AppErr");
            assert_eq!(e.0, "boom");
        }
        other => panic!("unexpected: {other:?}"),
    }
}

#[test]
fn opt_flag_and_value_variants() {
    let env = env_basic();

    // flag/value (infallible)
    let root = ap::CmdSpec::new("t")
        .opt(ap::OptSpec::flag("json", set_json).long("json"))
        .opt(ap::OptSpec::value("limit", set_limit).long("limit"));
    let mut ctx = Ctx::default();
    ap::parse(&env, &root, &argv(&["--json", "--limit", "5"]), &mut ctx).unwrap();
    assert!(ctx.json);
    assert_eq!(ctx.limit.as_deref(), Some("5"));

    // flag_try => Error::UserAny(AppErr)
    let root = ap::CmdSpec::new("t").opt(
        ap::OptSpec::flag_try("json", |_ctx: &mut Ctx| -> Result<(), AppErr> { Err(AppErr("no-json")) }).long("json"),
    );

    let err = ap::parse(&env, &root, &argv(&["--json"]), &mut Ctx::default()).unwrap_err();
    match err {
        ap::Error::UserAny(e) => {
            let e = e.downcast_ref::<AppErr>().expect("must preserve AppErr");
            assert_eq!(e.0, "no-json");
        }
        other => panic!("unexpected: {other:?}"),
    }

    // value_try => Error::UserAny(AppErr)
    let root = ap::CmdSpec::new("t").opt(
        ap::OptSpec::value_try("limit", |_v, _ctx: &mut Ctx| -> Result<(), AppErr> { Err(AppErr("no-limit")) })
            .long("limit"),
    );

    let err = ap::parse(&env, &root, &argv(&["--limit", "5"]), &mut Ctx::default()).unwrap_err();
    match err {
        ap::Error::UserAny(e) => {
            let e = e.downcast_ref::<AppErr>().expect("must preserve AppErr");
            assert_eq!(e.0, "no-limit");
        }
        other => panic!("unexpected: {other:?}"),
    }
}

#[test]
fn pos_new_and_new_try_variants() {
    let env = env_basic();

    // new (infallible)
    let root = ap::CmdSpec::new("t").pos(ap::PosSpec::new("FILE", push_file));
    let mut ctx = Ctx::default();
    ap::parse(&env, &root, &argv(&["a.txt"]), &mut ctx).unwrap();
    assert_eq!(ctx.files, vec!["a.txt"]);

    // new_try => Error::UserAny(AppErr)
    let root = ap::CmdSpec::new("t")
        .pos(ap::PosSpec::new_try("FILE", |_v, _ctx: &mut Ctx| -> Result<(), AppErr> { Err(AppErr("no-file")) }));

    let err = ap::parse(&env, &root, &argv(&["a.txt"]), &mut Ctx::default()).unwrap_err();
    match err {
        ap::Error::UserAny(e) => {
            let e = e.downcast_ref::<AppErr>().expect("must preserve AppErr");
            assert_eq!(e.0, "no-file");
        }
        other => panic!("unexpected: {other:?}"),
    }
}