Mirrors/clap
2
0
Fork 0
mirror of https://github.com/clap-rs/clap synced 2024-12-14 06:42:33 +00:00
Code Issues Projects Releases Packages Wiki Activity

Clean up commented code and old TODOs

Browse source
This commit is contained in:
Will Murphy 2017-10-18 07:19:26 -04:00
parent 35b21164bc
commit 6158fc9b50
3 changed files with 1 additions and 84 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/app/mod.rs
View file

@ -1621,8 +1621,6 @@ impl<'a, 'b> App<'a, 'b> {
}
if self.p.is_set(AppSettings::PropagateGlobalValuesDown) {
// TODO: get a list of all the argument names, create a vector
// from it, and passing that to propagate.
let global_arg_vec : Vec<&str> = (&self).p.global_args.iter().map(|ga| ga.b.name).collect();
let mut global_arg_to_value_map = HashMap::new();
matcher.get_global_values(&global_arg_vec, &mut global_arg_to_value_map);

5
src/app/parser.rs
View file

@ -1072,10 +1072,7 @@ impl<'a, 'b> Parser<'a, 'b>
info: None,
});
}
// FIXME: this makes the globals exist more than once
// if self.settings.is_set(AS::PropagateGlobalValuesDown) {
// self.propogate_globals();
// }
Validator::new(self).validate(needs_val_of, subcmd_name, matcher)
}

78
src/args/arg_matcher.rs
View file

@ -22,96 +22,18 @@ impl<'a> Default for ArgMatcher<'a> {
impl<'a> ArgMatcher<'a> {
pub fn new() -> Self { ArgMatcher::default() }
// TODO: maybe this would work better as a while loop
// than as a recursive call, so that we can push subcommands
// onto a stack and gather values from them as we go, then
// pop the stack and set values as needed
pub fn get_global_values(&mut self, global_arg_vec : &Vec<&'a str>, vals_map: &mut HashMap<&'a str, Vec<OsString>>) {
for global_arg in global_arg_vec.iter() {
let vals: Vec<_> = if let Some(ma) = self.get(global_arg) {
ma.vals.clone()
} else {
debugln!("ArgMatcher::propagate: arg wasn't used");
//return; // we can't return early because some subcommand might
// TODO: can we start returning early again if we
Vec::new()
};
vals_map.insert(global_arg, vals);
}
}
// pub fn propagate_globals(&mut self, global_arg_vec: Vec<&'a str>) {
// debugln!("ArgMatcher::propagate: arg={}", arg);
// // we need to decide which subcommands were actually used by asking
// // each successive subcommand for the next subcommand
// let mut subcommand_stack : Vec<Box<SubCommand>> = vec![];
// //let mut am : &mut ArgMatcher;
// if let Some(ref mut sc) = self.0.subcommand {
// let mut found_subcommand = sc.clone();
// let mut unboxed_sub : SubCommand = *found_subcommand;
// subcommand_stack.push(Box::new(unboxed_sub.clone()));
// let mut option_sub = unboxed_sub.matches.subcommand().1;
// while let Some(ref mut new_arg_matches) = option_sub {
// if let Some(ref new_subcommand) = new_arg_matches.subcommand {
// subcommand_stack.push(Box::new(*new_subcommand.clone()));
// option_sub = Some(&new_subcommand.matches);
// }
// }
// }
// // TODO make a new matcher and propagate
// for boxed_sub in subcommand_stack.iter() {
// let mut unboxed_sub = &*boxed_sub;
// let mut ix: usize = 0;
// for global_arg in global_arg_vec.iter() {
// let vals = &vals_vec[ix];
// let sma = (unboxed_sub).matches.args.entry(global_arg).or_insert_with(|| {
// let mut gma = MatchedArg::new();
// gma.occurs += 1;
// if !vals.is_empty() {
// gma.vals = *vals.clone();
// }
// gma
// });
// if sma.vals.is_empty() {
// sma.vals = *vals.clone();
// }
// ix += 1;
// }
// //let mut am = //&mut ArgMatcher(mem::replace(&mut sc.matches, ArgMatches::new()));
// let mut am = ArgMatcher(ArgMatches::new());
// mem::swap(&mut am.0, &mut unboxed_sub.matches);
// }
// // for arg in global_arg_vec {
// // if let Some(ref mut sc) = self.0.subcommand {
// // {
// // let sma = (*sc).matches.args.entry(arg).or_insert_with(|| {
// // let mut gma = MatchedArg::new();
// // gma.occurs += 1;
// // if !vals.is_empty() {
// // gma.vals = vals.clone();
// // }
// // gma
// // });
// // if sma.vals.is_empty() {
// // sma.vals = vals.clone();
// // }
// // }
// // let mut am = ArgMatcher(mem::replace(&mut sc.matches, ArgMatches::new()));
// // am.propagate(global_arg_vec.clone());
// // mem::swap(&mut am.0, &mut sc.matches);
// // } else {
// // debugln!("ArgMatcher::propagate: Subcommand wasn't used");
// // }
// // }
// }
pub fn get_mut(&mut self, arg: &str) -> Option<&mut MatchedArg> { self.0.args.get_mut(arg) }
pub fn get(&self, arg: &str) -> Option<&MatchedArg> { self.0.args.get(arg) }