marg 0.4.2

Meta config for apps from args
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

// @cladue
/// Option values to consume flags:
/// - -v or --verbose or --debug
/// - -q or --quiet or --batch
/// - -h or --help or --info
/// - -V or --version : print version and exit
///
/// The value could be pass or default as well,
/// e.g. --verbose=true or --verbose=false,
/// but the presence of the flag itself is enough to set it to true (--verbose), and absence means false.

#[derive(Debug, Clone)]
pub struct Opt {
    /// The name of the option
    pub name: String,
    /// The alternate long name of the option
    pub alt_name: String,
    pub short: String,
    /// The value of the option
    pub value: String,
    /// The default value of the option
    pub def_val: String,
    /// The value of the option was set
    pub set: bool,
}

impl Opt {
    pub fn new(name: &str, alt_name: &str, short: &str, def_val: &str) -> Self {
        Opt {
            name: name.to_string(),
            alt_name: alt_name.to_string(),
            short: short.to_string(),
            value: def_val.to_string(),
            def_val: def_val.to_string(),
            set: false,
        }
    }

    pub fn is_set(&self) -> bool {
        self.set
    }

    /// Match and apply `arg` to this option. Returns true if the arg matched.
    pub fn apply(&mut self, arg: &str) -> bool {
        let long = format!("--{}", self.name);
        let alt = if self.alt_name.is_empty() { String::new() } else { format!("--{}", self.alt_name) };
        let short = if self.short.is_empty() { String::new() } else { format!("-{}", self.short) };

        if arg == long
            || (!alt.is_empty() && arg == alt)
            || (!short.is_empty() && arg == short)
        {
            self.value = "true".to_string();
            self.set = true;
            return true;
        }

        let prefixes: Vec<String> = [format!("{}=", long)]
            .into_iter()
            .chain(if alt.is_empty() { None } else { Some(format!("{}=", alt)) })
            .collect();

        for prefix in &prefixes {
            if arg.starts_with(prefix.as_str()) {
                let v = &arg[prefix.len()..];
                self.set = v != "false" && !v.is_empty();
                self.value = v.to_string();
                return true;
            }
        }

        false
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn opt_long_flag_test() {
        let mut opt = Opt::new("verbose", "debug", "v", "false");
        assert!(opt.apply("--verbose"));
        assert!(opt.is_set());
        assert_eq!(opt.value, "true");
    }

    #[test]
    fn opt_alt_flag_test() {
        let mut opt = Opt::new("verbose", "debug", "v", "false");
        assert!(opt.apply("--debug"));
        assert!(opt.is_set());
    }

    #[test]
    fn opt_short_flag_test() {
        let mut opt = Opt::new("verbose", "debug", "v", "false");
        assert!(opt.apply("-v"));
        assert!(opt.is_set());
    }

    #[test]
    fn opt_eq_true_test() {
        let mut opt = Opt::new("verbose", "debug", "v", "false");
        assert!(opt.apply("--verbose=true"));
        assert!(opt.is_set());
        assert_eq!(opt.value, "true");
    }

    #[test]
    fn opt_eq_false_test() {
        let mut opt = Opt::new("verbose", "debug", "v", "false");
        assert!(opt.apply("--verbose=false"));
        assert!(!opt.is_set());
        assert_eq!(opt.value, "false");
    }

    #[test]
    fn opt_no_match_test() {
        let mut opt = Opt::new("verbose", "debug", "v", "false");
        assert!(!opt.apply("--quiet"));
        assert!(!opt.is_set());
    }

    #[test]
    fn opt_default_unset_test() {
        let opt = Opt::new("quiet", "batch", "q", "false");
        assert!(!opt.is_set());
        assert_eq!(opt.value, "false");
        assert_eq!(opt.def_val, "false");
    }
}