rs_args/
lib.rs

1// TODO: Add documentation to all functions and structs.
2// TODO: Add the ability to give a custom input to the `parse_arguments` function ( and child functions ).
3
4use lexing::errors::LexicalError;
5use parsing::Argument;
6
7pub mod lexing;
8pub mod parsing;
9pub mod tests;
10
11#[deprecated(since = "0.3.0", note = "Use standalone functions in `rs_args`.")]
12pub struct CommandArguments {
13    arguments: Vec<parsing::Argument>,
14}
15
16#[allow(deprecated)]
17impl CommandArguments {
18    pub fn new(arguments: Vec<parsing::Argument>) -> CommandArguments {
19        CommandArguments { arguments }
20    }
21
22    pub fn from_input(input: &str) -> Result<CommandArguments, LexicalError> {
23        let tokens = lexing::tokenise(String::from(input));
24        let arguments = parsing::parse(tokens?);
25        Ok(CommandArguments::new(arguments))
26    }
27
28    pub fn default_new() -> Result<CommandArguments, LexicalError> {
29        let mut raw_arguments = std::env::args().collect::<Vec<String>>();
30        let raw_arguments = raw_arguments
31            .drain(1..)
32            .collect::<Vec<String>>()
33            .join(" ");
34        let tokens = lexing::tokenise(raw_arguments);
35        let arguments = parsing::parse(tokens?);
36        Ok(CommandArguments::new(arguments))
37    }
38
39    #[deprecated(since = "0.3.0", note = "Use `rs_args::get_named` instead.")]
40    pub fn get_named(&self, name: &str) -> Option<&str> {
41        self.arguments
42            .iter()
43            .find(
44                |it|
45                    it.get_name().is_some() &&
46                    it.get_name().unwrap() == name &&
47                    it.get_value().is_some()
48            )
49            .map(|it| it.get_value().unwrap())
50    }
51
52    #[deprecated(since = "0.3.0", note = "Use `rs_args::get_positional` instead.")]
53    pub fn get_positional(&self, position: usize) -> Option<&str> {
54        self.arguments
55            .iter()
56            .find(|it| it.get_position().is_some() && it.get_position().unwrap() == position)
57            .map(|it| it.get_value().unwrap())
58    }
59
60    #[deprecated(since = "0.3.0", note = "Use `rs_args::get_positional_count` instead.")]
61    pub fn get_positional_count(&self) -> usize {
62        self.arguments
63            .iter()
64            .filter(|it| it.get_position().is_some())
65            .count()
66    }
67
68    #[deprecated(since = "0.3.0", note = "Use `rs_args::get_positional_values` instead.")]
69    pub fn get_positional_values(&self) -> Vec<&str> {
70        self.arguments
71            .iter()
72            .filter(|it| it.get_position().is_some())
73            .map(|it| it.get_value().unwrap())
74            .collect()
75    }
76
77    #[deprecated(since = "0.3.0", note = "Use `rs_args::get_named_count` instead.")]
78    pub fn get_named_count(&self) -> usize {
79        self.arguments
80            .iter()
81            .filter(|it| it.get_name().is_some())
82            .count()
83    }
84
85    #[deprecated(since = "0.3.0", note = "Use `rs_args::get_named_values` instead.")]
86    pub fn get_named_values(&self) -> Vec<&str> {
87        self.arguments
88            .iter()
89            .filter(|it| it.get_name().is_some())
90            .map(|it| it.get_value().unwrap())
91            .collect()
92    }
93
94    #[deprecated(since = "0.3.0", note = "Use `rs_args::parse_arguments` instead.")]
95    pub fn get_all(&self) -> Vec<Argument> {
96        self.arguments.to_vec()
97    }
98
99    #[deprecated(since = "0.3.0", note = "Use `rs_args::get_flag_names` instead.")]
100    pub fn get_flag_names(&self) -> Vec<&str> {
101        self.arguments
102            .iter()
103            .filter(|it| it.get_name().is_some() && it.get_value().is_none())
104            .map(|it| it.get_name().unwrap())
105            .collect()
106    }
107
108    #[deprecated(since = "0.3.0", note = "Use `rs_args::get_flags` instead.")]
109    pub fn get_flags(&self) -> Vec<Argument> {
110        self.arguments
111            .iter()
112            .filter(|it| it.get_name().is_some() && it.get_value().is_none())
113            .cloned()
114            .collect()
115    }
116
117    #[deprecated(since = "0.3.0", note = "Use `rs_args::get_flag_names` instead.")]
118    pub fn has_flag(&self, name: &str) -> bool {
119        self.arguments
120            .iter()
121            .any(
122                |it|
123                    it.get_name().is_some() &&
124                    it.get_name().unwrap() == name &&
125                    it.get_value().is_none()
126            )
127    }
128
129    #[deprecated(since = "0.3.0", note = "Use `rs_args::has_named` instead.")]
130    pub fn has_named(&self, name: &str) -> bool {
131        self.arguments
132            .iter()
133            .any(
134                |it|
135                    it.get_name().is_some() &&
136                    it.get_name().unwrap() == name &&
137                    it.get_value().is_some()
138            )
139    }
140
141    #[deprecated(since = "0.3.0", note = "Use `rs_args::has_positional` instead.")]
142    pub fn has_positional(&self, position: usize) -> bool {
143        self.arguments
144            .iter()
145            .any(|it| it.get_position().is_some() && it.get_position().unwrap() == position)
146    }
147}
148
149pub fn parse_arguments() -> Vec<Argument> {
150    let mut raw_arguments = std::env::args().collect::<Vec<String>>();
151    let raw_arguments = raw_arguments
152        .drain(1..)
153        .collect::<Vec<String>>()
154        .join(" ");
155    let tokens = lexing::tokenise(raw_arguments);
156    parsing::parse(tokens.unwrap())
157}
158
159pub fn get_named(name: &str) -> Option<String> {
160    parse_arguments()
161        .iter()
162        .find(
163            |it|
164                it.get_name().is_some() &&
165                it.get_name().unwrap() == name &&
166                it.get_value().is_some()
167        )
168        .map(|it| it.get_value().unwrap().to_owned())
169}
170
171pub fn get_positional(position: usize) -> Option<String> {
172    parse_arguments()
173        .iter()
174        .find(|it| it.get_position().is_some() && it.get_position().unwrap() == position)
175        .map(|it| it.get_value().unwrap().to_owned())
176}
177
178pub fn get_positional_count() -> usize {
179    parse_arguments()
180        .iter()
181        .filter(|it| it.get_position().is_some())
182        .count()
183}
184
185pub fn get_positional_values() -> Vec<String> {
186    parse_arguments()
187        .iter()
188        .filter(|it| it.get_position().is_some())
189        .map(|it| it.get_value().unwrap().to_owned())
190        .collect()
191}
192
193pub fn get_named_count() -> usize {
194    parse_arguments()
195        .iter()
196        .filter(|it| it.get_name().is_some())
197        .count()
198}
199
200pub fn get_named_values() -> Vec<String> {
201    parse_arguments()
202        .iter()
203        .filter(|it| it.get_name().is_some())
204        .map(|it| it.get_value().unwrap().to_owned())
205        .collect()
206}
207
208pub fn get_flag_names() -> Vec<String> {
209    parse_arguments()
210        .iter()
211        .filter(|it| it.get_name().is_some() && it.get_value().is_none())
212        .map(|it| it.get_name().unwrap().to_owned())
213        .collect()
214}
215
216pub fn get_flags() -> Vec<Argument> {
217    parse_arguments()
218        .iter()
219        .filter(|it| it.get_name().is_some() && it.get_value().is_none())
220        .cloned()
221        .collect()
222}
223
224pub fn has_flag(name: &str) -> bool {
225    parse_arguments()
226        .iter()
227        .any(
228            |it|
229                it.get_name().is_some() &&
230                it.get_name().unwrap() == name &&
231                it.get_value().is_none()
232        )
233}
234
235pub fn has_named(name: &str) -> bool {
236    parse_arguments()
237        .iter()
238        .any(
239            |it|
240                it.get_name().is_some() &&
241                it.get_name().unwrap() == name &&
242                it.get_value().is_some()
243        )
244}
245
246pub fn has_positional(position: usize) -> bool {
247    parse_arguments()
248        .iter()
249        .any(|it| it.get_position().is_some() && it.get_position().unwrap() == position)
250}
rs_args/lib.rs

rs_args/
lib.rs
