miniarg 0.5.0

A minimal argument parser, with support for no-std and no-alloc
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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

//! Tests for the derive macro.
#![cfg(feature = "derive")]

use core::fmt;

use miniarg::{ArgumentIterator, Key, ParseError};

#[derive(Debug, Key, PartialEq, Eq, Hash)]
enum SimpleKeys {
    /// first key
    Key,
    /// second key
    Key1,
    // no documentation here
    Key2,
    /// Th€ döcüm€ntätiön änd th€ k€y häv€ nön-äscii chärs.
    Köy,
}

#[test]
/// Just calling a binary should produce an empty result.
fn basic() {
    let cmdline = "executable";
    assert_eq!(
        SimpleKeys::parse(&cmdline)
            .collect::<Result<Vec<_>, _>>()
            .unwrap(),
        Vec::new()
    );
}

#[test]
/// One key, one value.
fn key_value() {
    let cmdline = "executable -key value";
    assert_eq!(
        SimpleKeys::parse(&cmdline)
            .collect::<Result<Vec<_>, _>>()
            .unwrap(),
        vec![(&SimpleKeys::Key, "value")]
    );
}

#[test]
/// two keys, two values.
fn two_key_value() {
    let cmdline = "executable -key1 value1 -key2 value2";
    assert_eq!(
        SimpleKeys::parse(&cmdline)
            .collect::<Result<Vec<_>, _>>()
            .unwrap(),
        vec![(&SimpleKeys::Key1, "value1"), (&SimpleKeys::Key2, "value2")]
    );
}

#[test]
/// one key, two values.
fn key_two_value() {
    let cmdline = "executable -key value1 -key value2";
    assert_eq!(
        SimpleKeys::parse(&cmdline)
            .collect::<Result<Vec<_>, _>>()
            .unwrap(),
        vec![(&SimpleKeys::Key, "value1"), (&SimpleKeys::Key, "value2")]
    );
}

#[test]
/// Just a key should produce a vec containing the key and an empty string.
// This is used for `-help`.
fn just_key() {
    let cmdline = "executable -key";
    assert_eq!(
        SimpleKeys::parse(&cmdline)
            .collect::<Result<Vec<_>, _>>()
            .unwrap(),
        vec![(&SimpleKeys::Key, "")]
    );
}

#[test]
/// An invalid key should produce an error.
fn invalid_key() {
    let cmdline = "executable -invalid";
    assert_eq!(
        SimpleKeys::parse(&cmdline)
            .collect::<Result<Vec<_>, _>>()
            .unwrap_err(),
        ParseError::UnknownKey("invalid")
    );
}

#[test]
/// An option without a key should produce an error.
fn missing_key() {
    let cmdline = "executable value";
    assert_eq!(
        SimpleKeys::parse(&cmdline)
            .collect::<Result<Vec<_>, _>>()
            .unwrap_err(),
        ParseError::NotAKey("value")
    );
}

#[test]
/// A help string should be generated.
fn help_text() {
    assert_eq!(
        SimpleKeys::help_text(),
        "-key\t first key\n-key1\t second key\n-key2\t\n-köy\t Th€ döcüm€ntätiön änd th€ k€y häv€ nön-äscii chärs."
    );
}

#[test]
/// Just calling a binary should produce an empty result.
fn non_ascii_basic() {
    let cmdline = "€x€cütäbl€";
    assert_eq!(
        SimpleKeys::parse(&cmdline)
            .collect::<Result<Vec<_>, _>>()
            .unwrap(),
        Vec::new()
    );
}

#[test]
/// One key, one value.
fn non_ascii_key() {
    let cmdline = "executable -köy value";
    assert_eq!(
        SimpleKeys::parse(&cmdline)
            .collect::<Result<Vec<_>, _>>()
            .unwrap(),
        vec![(&SimpleKeys::Köy, "value")]
    );
}

#[test]
/// One key, one value.
fn non_ascii_value() {
    let cmdline = "executable -key 🦀🎉";
    assert_eq!(
        SimpleKeys::parse(&cmdline)
            .collect::<Result<Vec<_>, _>>()
            .unwrap(),
        vec![(&SimpleKeys::Key, "🦀🎉")]
    );
}