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

Auto merge of #289 - kbknapp:issue-277, r=Vinatorul

Browse source 
fix(Help Message): required args no longer double list in usage

Closes #277
This commit is contained in:
Homu 2015-10-01 02:57:16 +09:00
commit 01daf939b0
1 changed files with 84 additions and 52 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

136
src/app/app.rs
View file

@ -1387,7 +1387,8 @@ impl<'a, 'v, 'ab, 'u, 'h, 'ar> App<'a, 'v, 'ab, 'u, 'h, 'ar>{
} }
fn get_required_from(&self, fn get_required_from(&self,
mut reqs: Vec<&'ar str>) mut reqs: Vec<&'ar str>,
matches: Option<&ArgMatches>)
-> VecDeque<String> { -> VecDeque<String> {
reqs.dedup(); reqs.dedup();
let mut c_flags = vec![]; let mut c_flags = vec![];
@ -1480,6 +1481,7 @@ impl<'a, 'v, 'ab, 'u, 'h, 'ar> App<'a, 'v, 'ab, 'u, 'h, 'ar>{
let mut pmap = BTreeMap::new(); let mut pmap = BTreeMap::new();
for p in c_pos.into_iter() { for p in c_pos.into_iter() {
if matches.is_some() && matches.as_ref().unwrap().is_present(p) { continue }
if let Some(idx) = self.positionals_name.get(p) { if let Some(idx) = self.positionals_name.get(p) {
if let Some(ref p) = self.positionals_idx.get(&idx) { if let Some(ref p) = self.positionals_idx.get(&idx) {
pmap.insert(p.index, format!("{}", p)); pmap.insert(p.index, format!("{}", p));
@ -1488,9 +1490,11 @@ impl<'a, 'v, 'ab, 'u, 'h, 'ar> App<'a, 'v, 'ab, 'u, 'h, 'ar>{
} }
pmap.into_iter().map(|(_, s)| ret_val.push_back(s)).collect::<Vec<_>>(); pmap.into_iter().map(|(_, s)| ret_val.push_back(s)).collect::<Vec<_>>();
for f in c_flags.into_iter() { for f in c_flags.into_iter() {
if matches.is_some() && matches.as_ref().unwrap().is_present(f) { continue }
ret_val.push_back(format!("{}", self.flags.get(*f).unwrap())); ret_val.push_back(format!("{}", self.flags.get(*f).unwrap()));
} }
for o in c_opt.into_iter() { for o in c_opt.into_iter() {
if matches.is_some() && matches.as_ref().unwrap().is_present(o) { continue }
ret_val.push_back(format!("{}", self.opts.get(*o).unwrap())); ret_val.push_back(format!("{}", self.opts.get(*o).unwrap()));
} }
for g in grps.into_iter() { for g in grps.into_iter() {
@ -1518,7 +1522,7 @@ impl<'a, 'v, 'ab, 'u, 'h, 'ar> App<'a, 'v, 'ab, 'u, 'h, 'ar>{
} else if let Some(tmp_vec) = matches { } else if let Some(tmp_vec) = matches {
let mut hs = self.required.iter().map(|n| *n).collect::<Vec<_>>(); let mut hs = self.required.iter().map(|n| *n).collect::<Vec<_>>();
tmp_vec.iter().map(|n| hs.push(*n)).collect::<Vec<_>>(); tmp_vec.iter().map(|n| hs.push(*n)).collect::<Vec<_>>();
let reqs = self.get_required_from(hs); let reqs = self.get_required_from(hs, None);
let r_string = reqs.iter().fold(String::new(), |acc, s| acc + &format!(" {}", s)[..]); let r_string = reqs.iter().fold(String::new(), |acc, s| acc + &format!(" {}", s)[..]);
@ -1547,7 +1551,7 @@ impl<'a, 'v, 'ab, 'u, 'h, 'ar> App<'a, 'v, 'ab, 'u, 'h, 'ar>{
reqs.push(p.name); reqs.push(p.name);
} }
} }
let req_strings = self.get_required_from(reqs); let req_strings = self.get_required_from(reqs, None);
let req_string = req_strings.iter() let req_string = req_strings.iter()
.fold(String::new(), |acc, s| { .fold(String::new(), |acc, s| {
acc + &format!(" {}", s)[..] acc + &format!(" {}", s)[..]
@ -1890,10 +1894,6 @@ impl<'a, 'v, 'ab, 'u, 'h, 'ar> App<'a, 'v, 'ab, 'u, 'h, 'ar>{
} }
} }
fn get_args(matches: &ArgMatches<'ar, 'ar>) -> Option<Vec<&'ar str>> {
Some(matches.args.keys().map(|k| *k).collect())
}
/// Starts the parsing process. Called on top level parent app **ONLY** then recursively calls /// Starts the parsing process. Called on top level parent app **ONLY** then recursively calls
/// the real parsing function for all subcommands /// the real parsing function for all subcommands
/// ///
@ -2312,8 +2312,8 @@ impl<'a, 'v, 'ab, 'u, 'h, 'ar> App<'a, 'v, 'ab, 'u, 'h, 'ar>{
Format::Warning(opt), Format::Warning(opt),
format!("\n\t[valid values:{}]\n", valid_values), format!("\n\t[valid values:{}]\n", valid_values),
suffix.0), suffix.0),
ClapErrorType::InvalidValue, ClapErrorType::InvalidValue,
App::get_args(matches)); Some(matches.args.keys().map(|k| *k).collect()));
} }
// The actual parsing function // The actual parsing function
@ -2385,8 +2385,7 @@ impl<'a, 'v, 'ab, 'u, 'h, 'ar> App<'a, 'v, 'ab, 'u, 'h, 'ar>{
Format::Warning(opt.to_string()), Format::Warning(opt.to_string()),
Format::Good(vals.len().to_string())), Format::Good(vals.len().to_string())),
ClapErrorType::InvalidValue, ClapErrorType::InvalidValue,
App::get_args(matches)) Some(matches.args.keys().map(|k| *k).collect())));
);
} }
} }
} }
@ -2399,8 +2398,7 @@ impl<'a, 'v, 'ab, 'u, 'h, 'ar> App<'a, 'v, 'ab, 'u, 'h, 'ar>{
format!("The argument '{}' does not allow empty values, but one \ format!("The argument '{}' does not allow empty values, but one \
was found.", Format::Warning(opt.to_string())), was found.", Format::Warning(opt.to_string())),
ClapErrorType::EmptyValue, ClapErrorType::EmptyValue,
App::get_args(matches) Some(matches.args.keys().map(|k| *k).collect())));
));
} }
if let Some(ref vec) = self.groups_for(opt.name) { if let Some(ref vec) = self.groups_for(opt.name) {
@ -2496,7 +2494,7 @@ impl<'a, 'v, 'ab, 'u, 'h, 'ar> App<'a, 'v, 'ab, 'u, 'h, 'ar>{
format!("The argument '{}' requires a value but none was supplied", format!("The argument '{}' requires a value but none was supplied",
Format::Warning(o.to_string())), Format::Warning(o.to_string())),
ClapErrorType::EmptyValue, ClapErrorType::EmptyValue,
App::get_args(matches))); Some(matches.args.keys().map(|k| *k).collect())));
} }
} }
} }
@ -2565,7 +2563,7 @@ impl<'a, 'v, 'ab, 'u, 'h, 'ar> App<'a, 'v, 'ab, 'u, 'h, 'ar>{
Format::Warning(arg_slice), Format::Warning(arg_slice),
self.bin_name.clone().unwrap_or(self.name.clone())), self.bin_name.clone().unwrap_or(self.name.clone())),
ClapErrorType::UnexpectedArgument, ClapErrorType::UnexpectedArgument,
App::get_args(matches))); Some(matches.args.keys().map(|k| *k).collect())));
} else if let Some(p) = self.positionals_idx.get(&pos_counter) { } else if let Some(p) = self.positionals_idx.get(&pos_counter) {
// Make sure this one doesn't conflict with anything // Make sure this one doesn't conflict with anything
self.blacklist.dedup(); self.blacklist.dedup();
@ -2583,7 +2581,7 @@ impl<'a, 'v, 'ab, 'u, 'h, 'ar> App<'a, 'v, 'ab, 'u, 'h, 'ar>{
arguments".to_owned() arguments".to_owned()
}), }),
ClapErrorType::ArgumentConflict, ClapErrorType::ArgumentConflict,
App::get_args(matches))); Some(matches.args.keys().map(|k| *k).collect())));
} }
@ -2607,7 +2605,7 @@ impl<'a, 'v, 'ab, 'u, 'h, 'ar> App<'a, 'v, 'ab, 'u, 'h, 'ar>{
Format::Warning(arg_slice), Format::Warning(arg_slice),
Format::Warning(p.to_string())), Format::Warning(p.to_string())),
ClapErrorType::TooMuchValues, ClapErrorType::TooMuchValues,
App::get_args(matches))); Some(matches.args.keys().map(|k| *k).collect())));
} }
} }
} }
@ -2618,7 +2616,7 @@ impl<'a, 'v, 'ab, 'u, 'h, 'ar> App<'a, 'v, 'ab, 'u, 'h, 'ar>{
allow empty values, but one was found.", allow empty values, but one was found.",
Format::Warning(p.to_string())), Format::Warning(p.to_string())),
ClapErrorType::EmptyValue, ClapErrorType::EmptyValue,
App::get_args(matches))); Some(matches.args.keys().map(|k| *k).collect())));
} }
// Check if it's already existing and update if so... // Check if it's already existing and update if so...
if let Some(ref mut pos) = matches.args.get_mut(p.name) { if let Some(ref mut pos) = matches.args.get_mut(p.name) {
@ -2655,14 +2653,14 @@ impl<'a, 'v, 'ab, 'u, 'h, 'ar> App<'a, 'v, 'ab, 'u, 'h, 'ar>{
allow empty values, but one was found.", allow empty values, but one was found.",
Format::Warning(p.to_string())), Format::Warning(p.to_string())),
ClapErrorType::EmptyValue, ClapErrorType::EmptyValue,
App::get_args(matches))); Some(matches.args.keys().map(|k| *k).collect())));
} }
if let Some(ref vtor) = p.validator { if let Some(ref vtor) = p.validator {
let f = &*vtor; let f = &*vtor;
if let Err(ref e) = f(arg_slice.to_owned()) { if let Err(ref e) = f(arg_slice.to_owned()) {
return Err(self.report_error(e.clone(), return Err(self.report_error(e.clone(),
ClapErrorType::ValueError, ClapErrorType::ValueError,
App::get_args(matches))); Some(matches.args.keys().map(|k| *k).collect())));
} }
} }
bm.insert(1, arg_slice.to_owned()); bm.insert(1, arg_slice.to_owned());
@ -2705,7 +2703,7 @@ impl<'a, 'v, 'ab, 'u, 'h, 'ar> App<'a, 'v, 'ab, 'u, 'h, 'ar>{
wasn't expecting any", Format::Warning(arg_slice), wasn't expecting any", Format::Warning(arg_slice),
self.bin_name.clone().unwrap_or(self.name.clone())), self.bin_name.clone().unwrap_or(self.name.clone())),
ClapErrorType::UnexpectedArgument, ClapErrorType::UnexpectedArgument,
App::get_args(matches))); Some(matches.args.keys().map(|k| *k).collect())));
} }
} }
} }
@ -2721,25 +2719,42 @@ impl<'a, 'v, 'ab, 'u, 'h, 'ar> App<'a, 'v, 'ab, 'u, 'h, 'ar>{
format!("The argument '{}' requires a value but there wasn't any \ format!("The argument '{}' requires a value but there wasn't any \
supplied", Format::Warning(o.to_string())), supplied", Format::Warning(o.to_string())),
ClapErrorType::EmptyValue, ClapErrorType::EmptyValue,
App::get_args(matches))); Some(matches.args.keys().map(|k| *k).collect())));
} }
} else if !o.multiple { } else if !o.multiple {
return Err(self.report_error( return Err(self.report_error(
format!("The argument '{}' requires a value but none was supplied", format!("The argument '{}' requires a value but none was supplied",
Format::Warning(o.to_string())), Format::Warning(o.to_string())),
ClapErrorType::EmptyValue, ClapErrorType::EmptyValue,
App::get_args(matches))); Some(matches.args.keys().map(|k| *k).collect())));
} else { } else {
return Err(self.report_error(format!("The following required arguments were \ return Err(self.report_error(format!("The following required arguments were \
not supplied:{}", not supplied:{}",
self.get_required_from(self.required.iter() self.get_required_from(self.required.iter()
.map(|s| *s) .map(|s| *s)
.collect::<Vec<_>>()) .collect(),
Some(matches))
.iter() .iter()
.fold(String::new(), |acc, s| acc + &format!("\n\t'{}'", .fold(String::new(), |acc, s| acc + &format!("\n\t'{}'",
Format::Error(s))[..])), Format::Error(s))[..])),
ClapErrorType::MissingRequiredArgument, ClapErrorType::MissingRequiredArgument,
App::get_args(matches))); Some(matches.args
.keys()
.map(|k| *k)
.filter(|k| {
if let Some(o) = self.opts.get(k) {
!o.required
} else if let Some(p) = self.positionals_name.get(k) {
if let Some(p) = self.positionals_idx.get(p) {
!p.required
} else {
true
}
} else {
true
}
})
.collect())));
} }
} else { } else {
return Err(self.report_error( return Err(self.report_error(
@ -2747,7 +2762,7 @@ impl<'a, 'v, 'ab, 'u, 'h, 'ar> App<'a, 'v, 'ab, 'u, 'h, 'ar>{
Format::Warning(format!("{}", self.positionals_idx.get( Format::Warning(format!("{}", self.positionals_idx.get(
self.positionals_name.get(a).unwrap()).unwrap()))), self.positionals_name.get(a).unwrap()).unwrap()))),
ClapErrorType::EmptyValue, ClapErrorType::EmptyValue,
App::get_args(matches))); Some(matches.args.keys().map(|k| *k).collect())));
} }
} }
@ -2769,7 +2784,7 @@ impl<'a, 'v, 'ab, 'u, 'h, 'ar> App<'a, 'v, 'ab, 'u, 'h, 'ar>{
if !self.subcmds_neg_reqs { if !self.subcmds_neg_reqs {
let mut hs = self.required.iter().map(|n| *n).collect::<Vec<_>>(); let mut hs = self.required.iter().map(|n| *n).collect::<Vec<_>>();
matches.args.keys().map(|k| hs.push(*k)).collect::<Vec<_>>(); matches.args.keys().map(|k| hs.push(*k)).collect::<Vec<_>>();
let reqs = self.get_required_from(hs); let reqs = self.get_required_from(hs, Some(matches));
for s in reqs.iter() { for s in reqs.iter() {
write!(&mut mid_string, " {}", s).ok().expect(INTERNAL_ERROR_MSG); write!(&mut mid_string, " {}", s).ok().expect(INTERNAL_ERROR_MSG);
@ -2810,7 +2825,7 @@ impl<'a, 'v, 'ab, 'u, 'h, 'ar> App<'a, 'v, 'ab, 'u, 'h, 'ar>{
format!("'{}' requires a subcommand but none was provided", format!("'{}' requires a subcommand but none was provided",
Format::Warning(&bn[..])), Format::Warning(&bn[..])),
ClapErrorType::MissingSubcommand, ClapErrorType::MissingSubcommand,
App::get_args(matches))); Some(matches.args.keys().map(|k| *k).collect())));
} else if self.help_on_no_sc { } else if self.help_on_no_sc {
let mut out = vec![]; let mut out = vec![];
match self.write_help(&mut out) { match self.write_help(&mut out) {
@ -2832,12 +2847,29 @@ impl<'a, 'v, 'ab, 'u, 'h, 'ar> App<'a, 'v, 'ab, 'u, 'h, 'ar>{
supplied:{}", supplied:{}",
self.get_required_from(self.required.iter() self.get_required_from(self.required.iter()
.map(|s| *s) .map(|s| *s)
.collect::<Vec<_>>()) .collect(),
Some(matches))
.iter() .iter()
.fold(String::new(), |acc, s| acc + &format!("\n\t'{}'", .fold(String::new(), |acc, s| acc + &format!("\n\t'{}'",
Format::Error(s))[..])), Format::Error(s))[..])),
ClapErrorType::MissingRequiredArgument, ClapErrorType::MissingRequiredArgument,
App::get_args(matches))); Some(matches.args
.keys()
.map(|k| *k)
.filter(|k| {
if let Some(o) = self.opts.get(k) {
!o.required
} else if let Some(p) = self.positionals_name.get(k) {
if let Some(p) = self.positionals_idx.get(p) {
!p.required
} else {
true
}
} else {
true
}
})
.collect())));
} }
if matches.args.is_empty() && matches.subcommand_name().is_none() && self.help_on_no_args { if matches.args.is_empty() && matches.subcommand_name().is_none() && self.help_on_no_args {
let mut out = vec![]; let mut out = vec![];
@ -3045,7 +3077,7 @@ impl<'a, 'v, 'ab, 'u, 'h, 'ar> App<'a, 'v, 'ab, 'u, 'h, 'ar>{
return Err(self.report_error(format!("The argument '{}' requires a value, \ return Err(self.report_error(format!("The argument '{}' requires a value, \
but none was supplied", Format::Warning(format!("--{}", arg))), but none was supplied", Format::Warning(format!("--{}", arg))),
ClapErrorType::EmptyValue, ClapErrorType::EmptyValue,
App::get_args(matches))); Some(matches.args.keys().map(|k| *k).collect())));
} }
arg_val = Some(arg_vec[1]); arg_val = Some(arg_vec[1]);
} }
@ -3061,7 +3093,7 @@ impl<'a, 'v, 'ab, 'u, 'h, 'ar> App<'a, 'v, 'ab, 'u, 'h, 'ar>{
or more of the other specified arguments", or more of the other specified arguments",
Format::Warning(format!("--{}", arg))), Format::Warning(format!("--{}", arg))),
ClapErrorType::ArgumentConflict, ClapErrorType::ArgumentConflict,
App::get_args(matches))); Some(matches.args.keys().map(|k| *k).collect())));
} }
self.overrides.dedup(); self.overrides.dedup();
debugln!("checking if {} is in overrides", v.name); debugln!("checking if {} is in overrides", v.name);
@ -3098,7 +3130,7 @@ impl<'a, 'v, 'ab, 'u, 'h, 'ar> App<'a, 'v, 'ab, 'u, 'h, 'ar>{
than once, but does not support multiple values", than once, but does not support multiple values",
Format::Warning(format!("--{}", arg))), Format::Warning(format!("--{}", arg))),
ClapErrorType::UnexpectedMultipleUsage, ClapErrorType::UnexpectedMultipleUsage,
App::get_args(matches))); Some(matches.args.keys().map(|k| *k).collect())));
} }
if let Some(av) = arg_val { if let Some(av) = arg_val {
if let Some(ref vec) = self.groups_for(v.name) { if let Some(ref vec) = self.groups_for(v.name) {
@ -3207,7 +3239,7 @@ impl<'a, 'v, 'ab, 'u, 'h, 'ar> App<'a, 'v, 'ab, 'u, 'h, 'ar>{
None => "one or more of the specified arguments".to_owned() None => "one or more of the specified arguments".to_owned()
}), }),
ClapErrorType::ArgumentConflict, ClapErrorType::ArgumentConflict,
App::get_args(matches))); Some(matches.args.keys().map(|k| *k).collect())));
} }
self.overrides.dedup(); self.overrides.dedup();
debugln!("checking if {} is in overrides", v.name); debugln!("checking if {} is in overrides", v.name);
@ -3234,7 +3266,7 @@ impl<'a, 'v, 'ab, 'u, 'h, 'ar> App<'a, 'v, 'ab, 'u, 'h, 'ar>{
once, but does not support multiple values", once, but does not support multiple values",
Format::Warning(v.to_string())), Format::Warning(v.to_string())),
ClapErrorType::UnexpectedMultipleUsage, ClapErrorType::UnexpectedMultipleUsage,
App::get_args(matches))); Some(matches.args.keys().map(|k| *k).collect())));
} }
let mut let mut
@ -3347,7 +3379,7 @@ impl<'a, 'v, 'ab, 'u, 'h, 'ar> App<'a, 'v, 'ab, 'u, 'h, 'ar>{
Format::Warning(format!("--{}", arg)), Format::Warning(format!("--{}", arg)),
suffix.0), suffix.0),
ClapErrorType::InvalidArgument, ClapErrorType::InvalidArgument,
App::get_args(matches))) Some(matches.args.keys().map(|k| *k).collect())))
} }
fn validate_value(&self, fn validate_value(&self,
@ -3364,13 +3396,13 @@ impl<'a, 'v, 'ab, 'u, 'h, 'ar> App<'a, 'v, 'ab, 'u, 'h, 'ar>{
return Err(self.report_error(format!("The argument '{}' does not allow empty \ return Err(self.report_error(format!("The argument '{}' does not allow empty \
values, but one was found.", Format::Warning(v.to_string())), values, but one was found.", Format::Warning(v.to_string())),
ClapErrorType::EmptyValue, ClapErrorType::EmptyValue,
App::get_args(matches))); Some(matches.args.keys().map(|k| *k).collect())));
} }
if let Some(ref vtor) = v.validator { if let Some(ref vtor) = v.validator {
if let Err(e) = vtor(av.to_owned()) { if let Err(e) = vtor(av.to_owned()) {
return Err(self.report_error(e, return Err(self.report_error(e,
ClapErrorType::ArgumentError, ClapErrorType::ArgumentError,
App::get_args(matches))); Some(matches.args.keys().map(|k| *k).collect())));
} }
} }
Ok(()) Ok(())
@ -3398,7 +3430,7 @@ impl<'a, 'v, 'ab, 'u, 'h, 'ar> App<'a, 'v, 'ab, 'u, 'h, 'ar>{
return Err(self.report_error(format!("The argument '{}' isn't valid", return Err(self.report_error(format!("The argument '{}' isn't valid",
Format::Warning(format!("-{}", c))), Format::Warning(format!("-{}", c))),
ClapErrorType::InvalidArgument, ClapErrorType::InvalidArgument,
App::get_args(matches))); Some(matches.args.keys().map(|k| *k).collect())));
} }
} }
Err(e) => return Err(e), Err(e) => return Err(e),
@ -3445,7 +3477,7 @@ impl<'a, 'v, 'ab, 'u, 'h, 'ar> App<'a, 'v, 'ab, 'u, 'h, 'ar>{
None => "one or more of the other specified arguments".to_owned() None => "one or more of the other specified arguments".to_owned()
}), }),
ClapErrorType::ArgumentConflict, ClapErrorType::ArgumentConflict,
App::get_args(matches))); Some(matches.args.keys().map(|k| *k).collect())));
} }
self.overrides.dedup(); self.overrides.dedup();
if self.overrides.contains(&v.name) { if self.overrides.contains(&v.name) {
@ -3468,7 +3500,7 @@ impl<'a, 'v, 'ab, 'u, 'h, 'ar> App<'a, 'v, 'ab, 'u, 'h, 'ar>{
than once, but does not support multiple values", than once, but does not support multiple values",
Format::Warning(format!("-{}", arg))), Format::Warning(format!("-{}", arg))),
ClapErrorType::UnexpectedMultipleUsage, ClapErrorType::UnexpectedMultipleUsage,
App::get_args(matches))); Some(matches.args.keys().map(|k| *k).collect())));
} }
} else { } else {
if let Some(ref vec) = self.groups_for(v.name) { if let Some(ref vec) = self.groups_for(v.name) {
@ -3514,7 +3546,7 @@ impl<'a, 'v, 'ab, 'u, 'h, 'ar> App<'a, 'v, 'ab, 'u, 'h, 'ar>{
Err(self.report_error(format!("The argument '{}' isn't valid", Err(self.report_error(format!("The argument '{}' isn't valid",
Format::Warning(format!("-{}", arg_c))), Format::Warning(format!("-{}", arg_c))),
ClapErrorType::InvalidArgument, ClapErrorType::InvalidArgument,
App::get_args(matches))) Some(matches.args.keys().map(|k| *k).collect())))
} }
fn parse_single_short_flag(&mut self, fn parse_single_short_flag(&mut self,
@ -3536,7 +3568,7 @@ impl<'a, 'v, 'ab, 'u, 'h, 'ar> App<'a, 'v, 'ab, 'u, 'h, 'ar>{
arguments".to_owned() arguments".to_owned()
}), }),
ClapErrorType::ArgumentConflict, ClapErrorType::ArgumentConflict,
App::get_args(matches))); Some(matches.args.keys().map(|k| *k).collect())));
} }
self.overrides.dedup(); self.overrides.dedup();
debugln!("checking if {} is in overrides", v.name); debugln!("checking if {} is in overrides", v.name);
@ -3563,7 +3595,7 @@ impl<'a, 'v, 'ab, 'u, 'h, 'ar> App<'a, 'v, 'ab, 'u, 'h, 'ar>{
once, but does not support multiple values", once, but does not support multiple values",
Format::Warning(format!("-{}", arg))), Format::Warning(format!("-{}", arg))),
ClapErrorType::UnexpectedMultipleUsage, ClapErrorType::UnexpectedMultipleUsage,
App::get_args(matches))); Some(matches.args.keys().map(|k| *k).collect())));
} }
if let Some(ref vec) = self.groups_for(v.name) { if let Some(ref vec) = self.groups_for(v.name) {
@ -3649,7 +3681,7 @@ impl<'a, 'v, 'ab, 'u, 'h, 'ar> App<'a, 'v, 'ab, 'u, 'h, 'ar>{
None => "one or more of the other specified arguments".to_owned() None => "one or more of the other specified arguments".to_owned()
}), }),
ClapErrorType::ArgumentConflict, ClapErrorType::ArgumentConflict,
App::get_args(matches))); Some(matches.args.keys().map(|k| *k).collect())));
} else if self.groups.contains_key(name) { } else if self.groups.contains_key(name) {
for n in self.get_group_members_names(name) { for n in self.get_group_members_names(name) {
if matches.args.contains_key(n) { if matches.args.contains_key(n) {
@ -3669,7 +3701,7 @@ impl<'a, 'v, 'ab, 'u, 'h, 'ar> App<'a, 'v, 'ab, 'u, 'h, 'ar>{
} }
}), }),
ClapErrorType::ArgumentConflict, ClapErrorType::ArgumentConflict,
App::get_args(matches))); Some(matches.args.keys().map(|k| *k).collect())));
} }
} }
} }
@ -3705,7 +3737,7 @@ impl<'a, 'v, 'ab, 'u, 'h, 'ar> App<'a, 'v, 'ab, 'u, 'h, 'ar>{
( f.multiple && ( f.multiple &&
( vals.len() % num as usize) == 1) {"as"}else{"ere"}), ( vals.len() % num as usize) == 1) {"as"}else{"ere"}),
ClapErrorType::EmptyValue, ClapErrorType::EmptyValue,
App::get_args(matches))); Some(matches.args.keys().map(|k| *k).collect())));
} }
} }
if let Some(num) = f.max_vals { if let Some(num) = f.max_vals {
@ -3717,7 +3749,7 @@ impl<'a, 'v, 'ab, 'u, 'h, 'ar> App<'a, 'v, 'ab, 'u, 'h, 'ar>{
Format::Error(vals.len().to_string()), Format::Error(vals.len().to_string()),
if vals.len() == 1 {"as"}else{"ere"}), if vals.len() == 1 {"as"}else{"ere"}),
ClapErrorType::TooMuchValues, ClapErrorType::TooMuchValues,
App::get_args(matches))); Some(matches.args.keys().map(|k| *k).collect())));
} }
} }
if let Some(num) = f.min_vals { if let Some(num) = f.min_vals {
@ -3729,7 +3761,7 @@ impl<'a, 'v, 'ab, 'u, 'h, 'ar> App<'a, 'v, 'ab, 'u, 'h, 'ar>{
Format::Error(vals.len().to_string()), Format::Error(vals.len().to_string()),
if vals.len() == 1 {"as"}else{"ere"}), if vals.len() == 1 {"as"}else{"ere"}),
ClapErrorType::TooFewValues, ClapErrorType::TooFewValues,
App::get_args(matches))); Some(matches.args.keys().map(|k| *k).collect())));
} }
} }
} else if let Some(f) = self.positionals_idx.get( } else if let Some(f) = self.positionals_idx.get(
@ -3747,7 +3779,7 @@ impl<'a, 'v, 'ab, 'u, 'h, 'ar> App<'a, 'v, 'ab, 'u, 'h, 'ar>{
} else { } else {
ClapErrorType::TooFewValues ClapErrorType::TooFewValues
}, },
App::get_args(matches))); Some(matches.args.keys().map(|k| *k).collect())));
} }
} }
if let Some(num) = f.max_vals { if let Some(num) = f.max_vals {
@ -3759,7 +3791,7 @@ impl<'a, 'v, 'ab, 'u, 'h, 'ar> App<'a, 'v, 'ab, 'u, 'h, 'ar>{
Format::Error(vals.len().to_string()), Format::Error(vals.len().to_string()),
if vals.len() == 1 {"as"}else{"ere"}), if vals.len() == 1 {"as"}else{"ere"}),
ClapErrorType::TooMuchValues, ClapErrorType::TooMuchValues,
App::get_args(matches))); Some(matches.args.keys().map(|k| *k).collect())));
} }
} }
if let Some(num) = f.min_vals { if let Some(num) = f.min_vals {
@ -3771,7 +3803,7 @@ impl<'a, 'v, 'ab, 'u, 'h, 'ar> App<'a, 'v, 'ab, 'u, 'h, 'ar>{
Format::Error(vals.len().to_string()), Format::Error(vals.len().to_string()),
if vals.len() == 1 {"as"}else{"ere"}), if vals.len() == 1 {"as"}else{"ere"}),
ClapErrorType::TooFewValues, ClapErrorType::TooFewValues,
App::get_args(matches))); Some(matches.args.keys().map(|k| *k).collect())));
} }
} }
} }