arg_parse 0.3.0

A tool to parse console or your own arguments, without dependencies.
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
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193

//! The config module includes everything to configure the [parser](parser::ArgParser)<br>
//! Includes:
//! - [ShortOptions](config::ShortOption)
//! - [LongOptions](config::LongOption)
//! - [NonOptions](config::NonOption)
//! - [Commands](config::Config) a sub or the "root" command with its arguments and optionally a subcommand
use std::vec;


#[derive(Debug, Clone)]
pub struct ShortOption{
    pub name: char,
    pub value_count: usize
}
#[derive(Debug, Clone)]
pub struct LongOption{
    pub name: &'static str,
    pub value_count: usize
}
#[derive(Debug, Clone)]
pub struct NonOption {
    pub name: &'static str,
    pub value_count: usize
}
/// Describes the root and all sub commands. <br>
/// A commands might have [short](ShortOption), [long](LongOption) and [non][NonOption] options and possible sub commands which are also of type [Config](Config)
#[derive(Debug)]
pub struct Config {
    pub short_options: &'static [ShortOption],
    pub long_options: &'static [LongOption],
    pub non_options: &'static[NonOption]
}

impl Config {
    /// Creates an Command without any possible arguments or sub commands
    pub const fn new()->Self {
        Self { long_options: &[], short_options: &[], non_options: &[]}
    }
    /// Creates a Commands having a list of arguments and sub commands
    pub const fn from(short_options: &'static [ShortOption], long_options: &'static [LongOption], non_options: &'static[NonOption])->Self {
        Self { short_options, long_options,  non_options}
    }
    /// Function to parse only this subcommand with the arguments <br>
    /// Meant for use by the [parser](super::parser::ArgParser) internally
    pub fn parse(&self, arguments: &[String])->Result<super::result::Root, super::parser::ParseError> {
        use super::parser::ParseError;
        use super::result;
        let mut result = super::result::Root::new();

        let mut skip = 0;        
        for (i, a) in arguments.iter().enumerate() {
            if skip > 0 {
                skip -= 1;
                continue;
            }

            //LongOption Parsing
            if a.starts_with("--") { 
                let option_option = {
                    if a.contains("=") {
                        self.find_long_option(a.split("=").collect::<Vec<&str>>()[0])
                    }else {
                        self.find_long_option(a)
                    }
                };
                match option_option {
                    Err(name) => return Err(ParseError::UnknownLongOption { name: String::from(name)}),
                    Ok(option) => {
                        if option.value_count == 0 {
                            result.long_options.push(result::LongOption{name: option.name, values: vec![String::new()]})
                        } else if option.value_count == 1 && a.contains("=") {
                            let mut option_result = result::LongOption{name: option.name, values: vec![]};
                            let v = a.split("=").collect::<Vec<&str>>()[1];
                            option_result.values.push(String::from(v));
                            result.long_options.push(option_result);
                        } else {
                            let mut option_result = result::LongOption{name: option.name, values: vec![]};
                            if option.value_count >= arguments.len()-i {
                                return Err(ParseError::ParameterWithoutEnoughValues { name: String::from(option.name) })
                            }
                            skip = option.value_count;
                            for i_value in i+1..i+option.value_count+1 {
                                option_result.values.push(arguments[i_value].clone());
                            }
                            result.long_options.push(option_result);
                        }
                    }
                }

            }else if a.starts_with("-") { // Short Options
                let options_option = {
                    if a.contains("=") {
                        self.find_short_options(a.split("=").collect::<Vec<&str>>()[0])
                    }else {
                        self.find_short_options(a)
                    }
                };
                match options_option {
                    Err(name) => return Err(ParseError::UnknownShortOption { name: String::from(name) }),
                    Ok(options) => {
                        for (i_option, option) in options.iter().enumerate() {
                            let mut option_result = result::ShortOption{name: option.name, values: vec![]};
                            if i_option == options.len()-1 && option.value_count == 1 && a.contains("=") {
                                let v = a.split("=").collect::<Vec<&str>>()[1];
                                option_result.values.push(String::from(v));
                            }else if i_option == options.len()-1 && option.value_count > 0 {
                                if option.value_count >= arguments.len()-i {
                                    return Err(ParseError::ParameterWithoutEnoughValues { name: String::from(option.name) })
                                }
                                skip = option.value_count;
                                for i_value in i+1..i+option.value_count+1 {
                                    option_result.values.push(arguments[i_value].clone());
                                }
                            }else if option.value_count > 0 {
                                return Err(ParseError::ShortOptionMissingValue { name: String::from(option.name) })
                            }else {
                                option_result.values.push(String::new());
                            }
                            result.short_options.push(option_result);
                        }
                    }
                }
            } else { //Non Options
                let option_option = {
                    if a.contains("=") {
                        self.find_non_option(a.split("=").collect::<Vec<&str>>()[0])
                    }else {
                        self.find_non_option(a)
                    }
                };
                match option_option {
                    Err(name) => return Err(ParseError::UnknownNonOption { name: String::from(name)}),
                    Ok(option) => {
                        if option.value_count == 0 {
                            result.non_options.push(result::NonOption{name: option.name, values: vec![String::new()]})
                        } else if option.value_count == 1 && a.contains("=") {
                            let mut option_result = result::NonOption{name: option.name, values: vec![]};
                            let v = a.split("=").collect::<Vec<&str>>()[1];
                            option_result.values.push(String::from(v));
                            result.non_options.push(option_result);
                        } else {
                            let mut option_result = result::NonOption{name: option.name, values: vec![]};
                            if option.value_count >= arguments.len()-i {
                                return Err(ParseError::ParameterWithoutEnoughValues { name: String::from(option.name) })
                            }
                            skip = option.value_count;
                            for i_value in i+1..i+option.value_count+1 {
                                option_result.values.push(arguments[i_value].clone());
                            }
                            result.non_options.push(option_result);
                        }
                    }
                }
            }

        }
        Ok(result)        
    }
    //Find an argument by its name in the list of them
    fn find_short_options(&self, input_names: &str)-> Result<Vec<&ShortOption>, char> {
        let names = input_names.trim_start_matches("-");
        let mut result = vec![];
        for c in names.chars() {
            let len_before = result.len();
            for o in self.short_options {
                if o.name == c {
                    result.push(o)
                }
            }
            if result.len() == len_before {
                return Err(c)
            }
        }
        Ok(result)
    }
    fn find_long_option<'a>(&self, name_input: &'a str)-> Result<&LongOption, &'a str> {
        let name = name_input.trim_start_matches("--");
        for o in self.long_options {
            if o.name == name {
                return Ok(o)
            }
        }
        Err(name)
    }
    fn find_non_option<'a>(&self, name: &'a str)-> Result<&NonOption, &'a str> {
        for o in self.non_options {
            if o.name == name {
                return Ok(o)
            }
        }
        Err(name)
    }
}