commander-core 1.2.0

This crate is used by commander-rust only. Please don't use it!
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

#[doc(hidden)]
#[derive(Debug, Eq, PartialEq)]
pub enum PatternType {
    Word,
    Short, // such as -abc
    Long, // such as --recursive
    Stmt, //  such as --output="/home/dist",
    Others, // something others
    Init, // initial value
}


#[doc(hidden)]
#[derive(Debug, Eq, PartialEq)]
pub struct Pattern<'a> {
    full: &'a str,
    pub groups: Vec<&'a str>,
    pub ty: PatternType,
}

impl<'a> Pattern<'a> {
    pub fn match_str(full: &str) -> Pattern {
        let mut reg = Pattern::new(full);

        if Pattern::is_word(full) {
            reg.ty = PatternType::Word;
            reg.groups = vec![full];
        } else if Pattern::is_short(full) {
            reg.ty = PatternType::Short;
            reg.groups = vec![&full[1..]]
        } else if Pattern::is_long(full) {
            reg.ty = PatternType::Long;
            reg.groups = vec![&full[2..]]
        } else if Pattern::is_stmt(full) {
            let idx = full.find("=").unwrap_or(2);
            let key = &full[2..idx];
            let value = &full[(idx + 1)..];

            reg.ty = PatternType::Stmt;
            reg.groups = vec![key, value];
        } else {
            reg.ty = PatternType::Others;
        }

        reg
    }

    // same as /\w+/
    pub fn is_word(s: &str) -> bool {
        s.chars().all(|c| char::is_ascii_alphabetic(&c))
    }

    pub fn is_short(s: &str) -> bool {
        s.len() >= 2 && s.starts_with("-") && Pattern::is_word(&s[1..])
    }

    pub fn is_long(s: &str) -> bool {
        s.len() >= 3 && s.starts_with("--") && (
            Pattern::is_word(&s[2..]) || s[2..].split_terminator("-").collect::<Vec<&str>>().iter().all(|s| Pattern::is_word(s))
        )
    }

    pub fn is_stmt(s: &str) -> bool {
        s.len() > 4 &&
            s.starts_with("--") &&
            s.contains("=") &&
            !s.ends_with("=")
    }

    pub fn new(full: &'a str) -> Pattern<'a> {
        Pattern {
            full,
            groups: vec![],
            ty: PatternType::Init,
        }
    }
}

#[cfg(test)]
mod test {
    

    #[test]
    fn can_match() {
        use super::Pattern;
        assert!(Pattern::is_word("yes"));
        assert!(Pattern::is_short("-f"));
        assert!(Pattern::is_long("--recursive"));
        assert!(Pattern::is_stmt("--output=yes"));

        assert!(!Pattern::is_word("/path"));
        assert!(!Pattern::is_short("--/path"));
        // don't support like this
        assert!(!Pattern::is_long("--long-item"));
        assert!(!Pattern::is_stmt("--outputis="));
    }
    
    #[test]
    fn groups_check() {
        use super::{ Pattern, PatternType };
        assert_eq!(Pattern {
            full: "name",
            ty: PatternType::Word,
            groups: vec!["name"]
        }, Pattern::match_str("name"));

        assert_eq!(Pattern {
            full: "-abc",
            ty: PatternType::Short,
            groups: vec!["abc"],
        }, Pattern::match_str("-abc"));

        assert_eq!(Pattern {
            full: "--long",
            ty: PatternType::Long,
            groups: vec!["long"],
        }, Pattern::match_str("--long"));

        assert_eq!(Pattern {
            full: "--output=./path/",
            ty: PatternType::Stmt,
            groups: vec!["output", "./path/"],
        }, Pattern::match_str("--output=./path/"));

        assert_eq!(Pattern {
            full: "/path/",
            ty: PatternType::Others,
            groups: vec![],
        }, Pattern::match_str("/path/"));

        assert_eq!(Pattern {
            full: "--no-output=./path/",
            ty: PatternType::Stmt,
            groups: vec!["no-output", "./path/"],
        }, Pattern::match_str("--no-output=./path/"));
    }
}