1 | // Std |
2 | use std::ffi::OsString; |
3 | use std::mem; |
4 | use std::ops::Deref; |
5 | |
6 | // Internal |
7 | use crate::builder::{Arg, ArgPredicate, Command}; |
8 | use crate::parser::Identifier; |
9 | use crate::parser::PendingArg; |
10 | use crate::parser::{ArgMatches, MatchedArg, SubCommand, ValueSource}; |
11 | use crate::util::AnyValue; |
12 | use crate::util::FlatMap; |
13 | use crate::util::Id; |
14 | use crate::INTERNAL_ERROR_MSG; |
15 | |
16 | #[derive (Debug, Default)] |
17 | pub(crate) struct ArgMatcher { |
18 | matches: ArgMatches, |
19 | pending: Option<PendingArg>, |
20 | } |
21 | |
22 | impl ArgMatcher { |
23 | pub(crate) fn new(_cmd: &Command) -> Self { |
24 | ArgMatcher { |
25 | matches: ArgMatches { |
26 | #[cfg (debug_assertions)] |
27 | valid_args: { |
28 | let args = _cmd.get_arguments().map(|a| a.get_id().clone()); |
29 | let groups = _cmd.get_groups().map(|g| g.get_id().clone()); |
30 | args.chain(groups).collect() |
31 | }, |
32 | #[cfg (debug_assertions)] |
33 | valid_subcommands: _cmd |
34 | .get_subcommands() |
35 | .map(|sc| sc.get_name_str().clone()) |
36 | .collect(), |
37 | ..Default::default() |
38 | }, |
39 | pending: None, |
40 | } |
41 | } |
42 | |
43 | pub(crate) fn into_inner(self) -> ArgMatches { |
44 | self.matches |
45 | } |
46 | |
47 | pub(crate) fn propagate_globals(&mut self, global_arg_vec: &[Id]) { |
48 | debug!("ArgMatcher::get_global_values: global_arg_vec={global_arg_vec:?}" ); |
49 | let mut vals_map = FlatMap::new(); |
50 | self.fill_in_global_values(global_arg_vec, &mut vals_map); |
51 | } |
52 | |
53 | fn fill_in_global_values( |
54 | &mut self, |
55 | global_arg_vec: &[Id], |
56 | vals_map: &mut FlatMap<Id, MatchedArg>, |
57 | ) { |
58 | for global_arg in global_arg_vec { |
59 | if let Some(ma) = self.get(global_arg) { |
60 | // We have to check if the parent's global arg wasn't used but still exists |
61 | // such as from a default value. |
62 | // |
63 | // For example, `myprog subcommand --global-arg=value` where `--global-arg` defines |
64 | // a default value of `other` myprog would have an existing MatchedArg for |
65 | // `--global-arg` where the value is `other` |
66 | let to_update = if let Some(parent_ma) = vals_map.get(global_arg) { |
67 | if parent_ma.source() > ma.source() { |
68 | parent_ma |
69 | } else { |
70 | ma |
71 | } |
72 | } else { |
73 | ma |
74 | } |
75 | .clone(); |
76 | vals_map.insert(global_arg.clone(), to_update); |
77 | } |
78 | } |
79 | if let Some(ref mut sc) = self.matches.subcommand { |
80 | let mut am = ArgMatcher { |
81 | matches: mem::take(&mut sc.matches), |
82 | pending: None, |
83 | }; |
84 | am.fill_in_global_values(global_arg_vec, vals_map); |
85 | mem::swap(&mut am.matches, &mut sc.matches); |
86 | } |
87 | |
88 | for (name, matched_arg) in vals_map.iter_mut() { |
89 | self.matches.args.insert(name.clone(), matched_arg.clone()); |
90 | } |
91 | } |
92 | |
93 | pub(crate) fn get(&self, arg: &Id) -> Option<&MatchedArg> { |
94 | self.matches.args.get(arg) |
95 | } |
96 | |
97 | pub(crate) fn get_mut(&mut self, arg: &Id) -> Option<&mut MatchedArg> { |
98 | self.matches.args.get_mut(arg) |
99 | } |
100 | |
101 | pub(crate) fn remove(&mut self, arg: &Id) -> bool { |
102 | self.matches.args.remove(arg).is_some() |
103 | } |
104 | |
105 | pub(crate) fn contains(&self, arg: &Id) -> bool { |
106 | self.matches.args.contains_key(arg) |
107 | } |
108 | |
109 | pub(crate) fn arg_ids(&self) -> std::slice::Iter<'_, Id> { |
110 | self.matches.args.keys() |
111 | } |
112 | |
113 | pub(crate) fn args(&self) -> crate::util::flat_map::Iter<'_, Id, MatchedArg> { |
114 | self.matches.args.iter() |
115 | } |
116 | |
117 | pub(crate) fn entry(&mut self, arg: Id) -> crate::util::Entry<Id, MatchedArg> { |
118 | self.matches.args.entry(arg) |
119 | } |
120 | |
121 | pub(crate) fn subcommand(&mut self, sc: SubCommand) { |
122 | self.matches.subcommand = Some(Box::new(sc)); |
123 | } |
124 | |
125 | pub(crate) fn subcommand_name(&self) -> Option<&str> { |
126 | self.matches.subcommand_name() |
127 | } |
128 | |
129 | pub(crate) fn check_explicit(&self, arg: &Id, predicate: &ArgPredicate) -> bool { |
130 | self.get(arg) |
131 | .map(|a| a.check_explicit(predicate)) |
132 | .unwrap_or_default() |
133 | } |
134 | |
135 | pub(crate) fn start_custom_arg(&mut self, arg: &Arg, source: ValueSource) { |
136 | let id = arg.get_id().clone(); |
137 | debug!("ArgMatcher::start_custom_arg: id={id:?}, source={source:?}" ); |
138 | let ma = self.entry(id).or_insert(MatchedArg::new_arg(arg)); |
139 | debug_assert_eq!(ma.type_id(), Some(arg.get_value_parser().type_id())); |
140 | ma.set_source(source); |
141 | ma.new_val_group(); |
142 | } |
143 | |
144 | pub(crate) fn start_custom_group(&mut self, id: Id, source: ValueSource) { |
145 | debug!("ArgMatcher::start_custom_arg: id={id:?}, source={source:?}" ); |
146 | let ma = self.entry(id).or_insert(MatchedArg::new_group()); |
147 | debug_assert_eq!(ma.type_id(), None); |
148 | ma.set_source(source); |
149 | ma.new_val_group(); |
150 | } |
151 | |
152 | pub(crate) fn start_occurrence_of_external(&mut self, cmd: &crate::Command) { |
153 | let id = Id::from_static_ref(Id::EXTERNAL); |
154 | debug!("ArgMatcher::start_occurrence_of_external: id={id:?}" ); |
155 | let ma = self.entry(id).or_insert(MatchedArg::new_external(cmd)); |
156 | debug_assert_eq!( |
157 | ma.type_id(), |
158 | Some( |
159 | cmd.get_external_subcommand_value_parser() |
160 | .expect(INTERNAL_ERROR_MSG) |
161 | .type_id() |
162 | ) |
163 | ); |
164 | ma.set_source(ValueSource::CommandLine); |
165 | ma.new_val_group(); |
166 | } |
167 | |
168 | pub(crate) fn add_val_to(&mut self, arg: &Id, val: AnyValue, raw_val: OsString) { |
169 | let ma = self.get_mut(arg).expect(INTERNAL_ERROR_MSG); |
170 | ma.append_val(val, raw_val); |
171 | } |
172 | |
173 | pub(crate) fn add_index_to(&mut self, arg: &Id, idx: usize) { |
174 | let ma = self.get_mut(arg).expect(INTERNAL_ERROR_MSG); |
175 | ma.push_index(idx); |
176 | } |
177 | |
178 | pub(crate) fn needs_more_vals(&self, o: &Arg) -> bool { |
179 | let num_pending = self |
180 | .pending |
181 | .as_ref() |
182 | .and_then(|p| (p.id == *o.get_id()).then_some(p.raw_vals.len())) |
183 | .unwrap_or(0); |
184 | debug!( |
185 | "ArgMatcher::needs_more_vals: o={}, pending={}" , |
186 | o.get_id(), |
187 | num_pending |
188 | ); |
189 | let expected = o.get_num_args().expect(INTERNAL_ERROR_MSG); |
190 | debug!("ArgMatcher::needs_more_vals: expected={expected}, actual={num_pending}" ); |
191 | expected.accepts_more(num_pending) |
192 | } |
193 | |
194 | pub(crate) fn pending_arg_id(&self) -> Option<&Id> { |
195 | self.pending.as_ref().map(|p| &p.id) |
196 | } |
197 | |
198 | pub(crate) fn pending_values_mut( |
199 | &mut self, |
200 | id: &Id, |
201 | ident: Option<Identifier>, |
202 | trailing_values: bool, |
203 | ) -> &mut Vec<OsString> { |
204 | let pending = self.pending.get_or_insert_with(|| PendingArg { |
205 | id: id.clone(), |
206 | ident, |
207 | raw_vals: Default::default(), |
208 | trailing_idx: None, |
209 | }); |
210 | debug_assert_eq!(pending.id, *id, " {INTERNAL_ERROR_MSG}" ); |
211 | if ident.is_some() { |
212 | debug_assert_eq!(pending.ident, ident, " {INTERNAL_ERROR_MSG}" ); |
213 | } |
214 | if trailing_values { |
215 | pending.trailing_idx.get_or_insert(pending.raw_vals.len()); |
216 | } |
217 | &mut pending.raw_vals |
218 | } |
219 | |
220 | pub(crate) fn start_trailing(&mut self) { |
221 | if let Some(pending) = &mut self.pending { |
222 | // Allow asserting its started on subsequent calls |
223 | pending.trailing_idx.get_or_insert(pending.raw_vals.len()); |
224 | } |
225 | } |
226 | |
227 | pub(crate) fn take_pending(&mut self) -> Option<PendingArg> { |
228 | self.pending.take() |
229 | } |
230 | } |
231 | |
232 | impl Deref for ArgMatcher { |
233 | type Target = ArgMatches; |
234 | |
235 | fn deref(&self) -> &Self::Target { |
236 | &self.matches |
237 | } |
238 | } |
239 | |