diff --git a/src/app/mod.rs b/src/app/mod.rs index 4a6afb01523..34ecdcde1d0 100644 --- a/src/app/mod.rs +++ b/src/app/mod.rs @@ -24,7 +24,7 @@ use yaml_rust::Yaml; // Internal use app::help::Help; use app::parser::Parser; -use args::{ArgKind, AnyArg, Arg, ArgGroup, ArgMatcher, ArgMatches, ArgSettings}; +use args::{AnyArg, Arg, ArgGroup, ArgMatcher, ArgMatches, ArgSettings}; use errors::Error; use errors::Result as ClapResult; pub use self::settings::AppSettings; @@ -1373,7 +1373,7 @@ impl<'a, 'b> App<'a, 'b> { if self.p.is_set(AppSettings::PropagateGlobalValuesDown) { for a in &self.p.global_args { - matcher.propagate(a.name); + matcher.propagate(a.b.name); } } @@ -1536,7 +1536,6 @@ impl<'n, 'e> AnyArg<'n, 'e> for App<'n, 'e> { unreachable!("App struct does not support AnyArg::name, this is a bug!") } fn id(&self) -> usize { self.p.id } - fn kind(&self) -> ArgKind { ArgKind::Subcmd } fn overrides(&self) -> Option<&[&'e str]> { None } fn requires(&self) -> Option<&[(Option<&'e str>, &'n str)]> { None } fn blacklist(&self) -> Option<&[&'e str]> { None } diff --git a/src/app/parser.rs b/src/app/parser.rs index 07221d74dde..39dd5ee2d9f 100644 --- a/src/app/parser.rs +++ b/src/app/parser.rs @@ -148,28 +148,28 @@ impl<'a, 'b> Parser<'a, 'b> // actually adds the arguments pub fn add_arg(&mut self, a: &Arg<'a, 'b>) { - debug_assert!(!(self.flags.iter().any(|f| &f.b.name == &a.name) || - self.opts.iter().any(|o| o.b.name == a.name) || - self.positionals.values().any(|p| p.b.name == a.name)), - format!("Non-unique argument name: {} is already in use", a.name)); + debug_assert!(!(self.flags.iter().any(|f| &f.b.name == &a.b.name) || + self.opts.iter().any(|o| o.b.name == a.b.name) || + self.positionals.values().any(|p| p.b.name == a.b.name)), + format!("Non-unique argument name: {} is already in use", a.b.name)); if let Some(ref r_ifs) = a.r_ifs { for &(arg, val) in r_ifs { - self.r_ifs.push((arg, val, a.name)); + self.r_ifs.push((arg, val, a.b.name)); } } - if let Some(ref grps) = a.groups { + if let Some(ref grps) = a.b.groups { for g in grps { let ag = self.groups.entry(g).or_insert_with(|| ArgGroup::with_name(g)); - ag.args.push(a.name); + ag.args.push(a.b.name); } } - if let Some(s) = a.short { + if let Some(s) = a.s.short { debug_assert!(!self.short_list.contains(&s), format!("Argument short must be unique\n\n\t-{} is already in use", s)); self.short_list.push(s); } - if let Some(l) = a.long { + if let Some(l) = a.s.long { debug_assert!(!self.long_list.contains(&l), format!("Argument long must be unique\n\n\t--{} is already in use", l)); @@ -181,9 +181,9 @@ impl<'a, 'b> Parser<'a, 'b> } } if a.is_set(ArgSettings::Required) { - self.required.push(a.name); + self.required.push(a.b.name); } - if a.index.is_some() || (a.short.is_none() && a.long.is_none()) { + if a.index.is_some() || (a.s.short.is_none() && a.s.long.is_none()) { let i = if a.index.is_none() { (self.positionals.len() + 1) } else { @@ -193,7 +193,7 @@ impl<'a, 'b> Parser<'a, 'b> format!("Argument \"{}\" has the same index as another positional \ argument\n\n\tPerhaps try .multiple(true) to allow one positional argument \ to take multiple values", - a.name)); + a.b.name)); let pb = PosBuilder::from_arg(a, i as u64, &mut self.required); self.positionals.insert(i, pb); } else if a.is_set(ArgSettings::TakesValue) { @@ -213,7 +213,7 @@ impl<'a, 'b> Parser<'a, 'b> debug_assert!(!a.is_set(ArgSettings::Required), format!("Global arguments cannot be required.\n\n\t'{}' is marked as \ global and required", - a.name)); + a.b.name)); self.global_args.push(a.into()); } } @@ -243,7 +243,8 @@ impl<'a, 'b> Parser<'a, 'b> pub fn add_subcommand(&mut self, mut subcmd: App<'a, 'b>) { debugln!("Parser::add_subcommand: term_w={:?}, name={}", - self.meta.term_w, subcmd.p.meta.name); + self.meta.term_w, + subcmd.p.meta.name); subcmd.p.meta.term_w = self.meta.term_w; if subcmd.p.meta.name == "help" { self.settings.unset(AppSettings::NeedsSubcommandHelp); @@ -253,11 +254,14 @@ impl<'a, 'b> Parser<'a, 'b> } pub fn propogate_settings(&mut self) { - debugln!("Parser::propogate_settings: self={}, g_settings={:#?}", - self.meta.name, self.g_settings); + debugln!("Parser::propogate_settings: self={}, g_settings={:#?}", + self.meta.name, + self.g_settings); for sc in &mut self.subcommands { - debugln!("Parser::propogate_settings: sc={}, settings={:#?}, g_settings={:#?}", - sc.p.meta.name, sc.p.settings, sc.p.g_settings); + debugln!("Parser::propogate_settings: sc={}, settings={:#?}, g_settings={:#?}", + sc.p.meta.name, + sc.p.settings, + sc.p.g_settings); // We have to create a new scope in order to tell rustc the borrow of `sc` is // done and to recursively call this method { @@ -314,7 +318,9 @@ impl<'a, 'b> Parser<'a, 'b> matcher: Option<&ArgMatcher<'a>>, extra: Option<&str>) -> VecDeque { - debugln!("Parser::get_required_from: reqs={:?}, extra={:?}", reqs, extra); + debugln!("Parser::get_required_from: reqs={:?}, extra={:?}", + reqs, + extra); let mut c_flags: Vec<&str> = vec![]; let mut c_pos: Vec<&str> = vec![]; let mut c_opt: Vec<&str> = vec![]; @@ -403,7 +409,7 @@ impl<'a, 'b> Parser<'a, 'b> .filter_map(|p| self.positionals.values().find(|x| x.b.name == p)) .filter(|p| !args_in_groups.contains(&p.b.name)) .map(|p| (p.index, p)) - .collect::>();// sort by index + .collect::>(); // sort by index debugln!("Parser::get_required_from: args_in_groups={:?}", args_in_groups); for &p in pmap.values() { let s = p.to_string(); @@ -548,12 +554,12 @@ impl<'a, 'b> Parser<'a, 'b> } // Next we verify that only the highest index has a .multiple(true) (if any) - if self.positionals - .values() - .any(|a| { - a.b.settings.is_set(ArgSettings::Multiple) && - (a.index as usize != self.positionals.len()) - }) { + if + self.positionals + .values() + .any(|a| { + a.is_set(ArgSettings::Multiple) && (a.index as usize != self.positionals.len()) + }) { debug_assert!({ let mut it = self.positionals.values().rev(); @@ -828,7 +834,7 @@ impl<'a, 'b> Parser<'a, 'b> if let Some(name) = needs_val_of { // Check to see if parsing a value from a previous arg if let Some(arg) = find_by_name!(self, &name, opts, iter) { - // get the OptBuilder so we can check the settings + // get the OptBuilder so we can check the settings needs_val_of = try!(self.add_val_to_arg(&*arg, &arg_os, matcher)); // get the next value from the iterator continue; @@ -844,7 +850,8 @@ impl<'a, 'b> Parser<'a, 'b> } needs_val_of = try!(self.parse_long_arg(matcher, &arg_os)); - if !(needs_val_of.is_none() && self.is_set(AppSettings::AllowLeadingHyphen)) { + if !(needs_val_of.is_none() && + self.is_set(AppSettings::AllowLeadingHyphen)) { continue; } } else if arg_os.starts_with(b"-") && arg_os.len_() != 1 { @@ -856,7 +863,7 @@ impl<'a, 'b> Parser<'a, 'b> if needs_val_of.is_none() { if self.is_set(AppSettings::AllowNegativeNumbers) { if !(arg_os.to_string_lossy().parse::().is_ok() || - arg_os.to_string_lossy().parse::().is_ok()) { + arg_os.to_string_lossy().parse::().is_ok()) { return Err(Error::unknown_argument(&*arg_os.to_string_lossy(), "", &*self.create_current_usage(matcher, None), @@ -872,19 +879,20 @@ impl<'a, 'b> Parser<'a, 'b> } if !self.is_set(AppSettings::ArgsNegateSubcommands) { - if let Some(cdate) = - suggestions::did_you_mean(&*arg_os.to_string_lossy(), - self.subcommands - .iter() - .map(|s| &s.p.meta.name)) { - return Err(Error::invalid_subcommand(arg_os.to_string_lossy().into_owned(), - cdate, - self.meta - .bin_name - .as_ref() - .unwrap_or(&self.meta.name), - &*self.create_current_usage(matcher, None), - self.color())); + if let Some(cdate) = suggestions::did_you_mean(&*arg_os.to_string_lossy(), + self.subcommands + .iter() + .map(|s| &s.p.meta.name)) { + return Err(Error::invalid_subcommand(arg_os.to_string_lossy() + .into_owned(), + cdate, + self.meta + .bin_name + .as_ref() + .unwrap_or(&self.meta.name), + &*self.create_current_usage(matcher, + None), + self.color())); } } } @@ -893,8 +901,8 @@ impl<'a, 'b> Parser<'a, 'b> !self.positionals.is_empty() && pos_counter == (self.positionals.len() - 1); let missing_pos = self.is_set(AppSettings::AllowMissingPositional) && - !self.positionals.is_empty() && - pos_counter == (self.positionals.len() - 1); + !self.positionals.is_empty() && + pos_counter == (self.positionals.len() - 1); debugln!("Parser::get_matches_with: Low index multiples...{:?}", low_index_mults); debugln!("Parser::get_matches_with: Positional counter...{}", pos_counter); if low_index_mults || missing_pos { @@ -932,7 +940,8 @@ impl<'a, 'b> Parser<'a, 'b> Some(s) => s.to_string(), None => { if !self.settings.is_set(AppSettings::StrictUtf8) { - return Err(Error::invalid_utf8(&*self.create_current_usage(matcher, None), + return Err(Error::invalid_utf8(&*self.create_current_usage(matcher, + None), self.color())); } arg_os.to_string_lossy().into_owned() @@ -1024,15 +1033,15 @@ impl<'a, 'b> Parser<'a, 'b> }; if should_err { return Err(Error::empty_value(o, - &*self.create_current_usage(matcher, None), - self.color())); + &*self.create_current_usage(matcher, None), + self.color())); } } } try!(self.validate_blacklist(matcher)); - if !(self.settings.is_set(AppSettings::SubcommandsNegateReqs) && subcmd_name.is_some()) && - !reqs_validated { + if !(self.settings.is_set(AppSettings::SubcommandsNegateReqs) && + subcmd_name.is_some()) && !reqs_validated { try!(self.validate_required(matcher)); } try!(self.validate_matched_args(matcher)); @@ -1537,8 +1546,10 @@ impl<'a, 'b> Parser<'a, 'b> -> ClapResult> where A: AnyArg<'a, 'b> + Display { - debugln!("Parser::add_val_to_arg;"); + debugln!("Parser::add_val_to_arg; arg={}, val={:?}", arg.name(), val); let mut ret = None; + debugln!("Parser::add_val_to_arg; trailing_vals={:?}, DontDelimTrailingVals={:?}", + self.trailing_vals, self.is_set(AppSettings::DontDelimitTrailingValues)); if !(self.trailing_vals && self.is_set(AppSettings::DontDelimitTrailingValues)) { if let Some(delim) = arg.val_delim() { if val.is_empty_() { @@ -1599,7 +1610,8 @@ impl<'a, 'b> Parser<'a, 'b> { debugln!("Parser::validate_value: val={:?}", val); if self.is_set(AppSettings::StrictUtf8) && val.to_str().is_none() { - return Err(Error::invalid_utf8(&*self.create_current_usage(matcher, None), self.color())); + return Err(Error::invalid_utf8(&*self.create_current_usage(matcher, None), + self.color())); } if let Some(p_vals) = arg.possible_vals() { let val_str = val.to_string_lossy(); @@ -1613,7 +1625,9 @@ impl<'a, 'b> Parser<'a, 'b> } if !arg.is_set(ArgSettings::EmptyValues) && val.is_empty_() && matcher.contains(&*arg.name()) { - return Err(Error::empty_value(arg, &*self.create_current_usage(matcher, None), self.color())); + return Err(Error::empty_value(arg, + &*self.create_current_usage(matcher, None), + self.color())); } if let Some(vtor) = arg.validator() { if let Err(e) = vtor(val.to_string_lossy().into_owned()) { @@ -1789,7 +1803,9 @@ impl<'a, 'b> Parser<'a, 'b> } // Issue 665 (https://github.com/kbknapp/clap-rs/issues/665) if a.takes_value() && !a.is_set(ArgSettings::EmptyValues) && ma.vals.is_empty() { - return Err(Error::empty_value(a, &*self.create_current_usage(matcher, None), self.color())); + return Err(Error::empty_value(a, + &*self.create_current_usage(matcher, None), + self.color())); } Ok(()) } @@ -1977,10 +1993,12 @@ impl<'a, 'b> Parser<'a, 'b> usage.push_str(&*self.meta .usage .as_ref() - .unwrap_or_else(|| self.meta - .bin_name - .as_ref() - .unwrap_or(&self.meta.name))); + .unwrap_or_else(|| { + self.meta + .bin_name + .as_ref() + .unwrap_or(&self.meta.name) + })); let mut reqs: Vec<&str> = self.required().map(|r| &**r).collect(); reqs.dedup(); let req_string = self.get_required_from(&reqs, None, None) @@ -2045,11 +2063,14 @@ impl<'a, 'b> Parser<'a, 'b> usage.push_str(&self.meta .usage .as_ref() - .unwrap_or_else(|| self.meta - .bin_name - .as_ref() - .unwrap_or(&self.meta - .name))[..]); + .unwrap_or_else(|| { + self.meta + .bin_name + .as_ref() + .unwrap_or(&self.meta + .name) + }) + [..]); usage.push_str(&*r_string); if self.is_set(AppSettings::SubcommandRequired) { usage.push_str(" "); diff --git a/src/args/any_arg.rs b/src/args/any_arg.rs index efa664dade1..556a31396f6 100644 --- a/src/args/any_arg.rs +++ b/src/args/any_arg.rs @@ -8,7 +8,6 @@ use vec_map::{self, VecMap}; // Internal use args::settings::ArgSettings; -use args::ArgKind; #[doc(hidden)] pub trait AnyArg<'n, 'e>: std_fmt::Display { @@ -37,7 +36,6 @@ pub trait AnyArg<'n, 'e>: std_fmt::Display { fn default_val(&self) -> Option<&'n str>; fn default_vals_ifs(&self) -> Option, &'e str)>>; fn longest_filter(&self) -> bool; - fn kind(&self) -> ArgKind; fn val_terminator(&self) -> Option<&'e str>; } diff --git a/src/args/arg.rs b/src/args/arg.rs index 8bd198536f9..0e12ddcc81e 100644 --- a/src/args/arg.rs +++ b/src/args/arg.rs @@ -8,7 +8,8 @@ use yaml_rust::Yaml; use vec_map::VecMap; use usage_parser::UsageParser; -use args::settings::{ArgFlags, ArgSettings}; +use args::settings::ArgSettings; +use args::arg_builder::{Base, Valued, Switched}; /// The abstract representation of a command line argument. Used to set all the options and /// relationships that define a valid argument for the program. @@ -33,94 +34,22 @@ use args::settings::{ArgFlags, ArgSettings}; /// ``` /// [`Arg`]: ./struct.Arg.html #[allow(missing_debug_implementations)] +#[derive(Default, Clone)] pub struct Arg<'a, 'b> where 'a: 'b { #[doc(hidden)] - pub name: &'a str, + pub b: Base<'a, 'b>, #[doc(hidden)] - pub short: Option, + pub s: Switched<'b>, #[doc(hidden)] - pub long: Option<&'b str>, - #[doc(hidden)] - pub aliases: Option>, // (name, visible) - #[doc(hidden)] - pub help: Option<&'b str>, + pub v: Valued<'a, 'b>, #[doc(hidden)] pub index: Option, #[doc(hidden)] - pub blacklist: Option>, - #[doc(hidden)] - pub possible_vals: Option>, - #[doc(hidden)] - pub requires: Option, &'a str)>>, - #[doc(hidden)] - pub groups: Option>, - #[doc(hidden)] - pub val_names: Option>, - #[doc(hidden)] - pub num_vals: Option, - #[doc(hidden)] - pub max_vals: Option, - #[doc(hidden)] - pub min_vals: Option, - #[doc(hidden)] - pub validator: Option Result<(), String>>>, - #[doc(hidden)] - pub validator_os: Option Result<(), OsString>>>, - #[doc(hidden)] - pub overrides: Option>, - #[doc(hidden)] - pub settings: ArgFlags, - #[doc(hidden)] - pub val_delim: Option, - #[doc(hidden)] - pub default_val: Option<&'a str>, - #[doc(hidden)] - pub default_vals_ifs: Option, &'b str)>>, - #[doc(hidden)] - pub disp_ord: usize, - #[doc(hidden)] - pub r_unless: Option>, - #[doc(hidden)] pub r_ifs: Option>, - #[doc(hidden)] - pub val_terminator: Option<&'b str>, } -impl<'a, 'b> Default for Arg<'a, 'b> { - fn default() -> Self { - Arg { - name: "".as_ref(), - short: None, - long: None, - aliases: None, - help: None, - index: None, - blacklist: None, - possible_vals: None, - requires: None, - groups: None, - val_names: None, - num_vals: None, - max_vals: None, - min_vals: None, - validator: None, - validator_os: None, - overrides: None, - settings: ArgFlags::new(), - val_delim: None, - default_val: None, - default_vals_ifs: None, - disp_ord: 999, - r_unless: None, - r_ifs: None, - val_terminator: None, - } - } -} - - impl<'a, 'b> Arg<'a, 'b> { /// Creates a new instance of [`Arg`] using a unique string name. The name will be used to get /// information about whether or not the argument was used at runtime, get values, set @@ -139,7 +68,7 @@ impl<'a, 'b> Arg<'a, 'b> { /// ``` /// [`Arg::takes_value(true)`]: ./struct.Arg.html#method.takes_value /// [`Arg`]: ./struct.Arg.html - pub fn with_name(n: &'a str) -> Self { Arg { name: n, ..Default::default() } } + pub fn with_name(n: &'a str) -> Self { Arg { b: Base::new(n), ..Default::default() } } /// Creates a new instance of [`Arg`] from a .yml (YAML) file. /// @@ -391,7 +320,7 @@ impl<'a, 'b> Arg<'a, 'b> { /// ``` /// [`short`]: ./struct.Arg.html#method.short pub fn short>(mut self, s: S) -> Self { - self.short = s.as_ref().trim_left_matches(|c| c == '-').chars().nth(0); + self.s.short = s.as_ref().trim_left_matches(|c| c == '-').chars().nth(0); self } @@ -431,7 +360,7 @@ impl<'a, 'b> Arg<'a, 'b> { /// assert!(m.is_present("cfg")); /// ``` pub fn long(mut self, l: &'b str) -> Self { - self.long = Some(l.trim_left_matches(|c| c == '-')); + self.s.long = Some(l.trim_left_matches(|c| c == '-')); self } @@ -455,10 +384,10 @@ impl<'a, 'b> Arg<'a, 'b> { /// ``` /// [`Arg`]: ./struct.Arg.html pub fn alias>(mut self, name: S) -> Self { - if let Some(ref mut als) = self.aliases { + if let Some(ref mut als) = self.s.aliases { als.push((name.into(), false)); } else { - self.aliases = Some(vec![(name.into(), false)]); + self.s.aliases = Some(vec![(name.into(), false)]); } self } @@ -483,12 +412,12 @@ impl<'a, 'b> Arg<'a, 'b> { /// ``` /// [`Arg`]: ./struct.Arg.html pub fn aliases(mut self, names: &[&'b str]) -> Self { - if let Some(ref mut als) = self.aliases { + if let Some(ref mut als) = self.s.aliases { for n in names { als.push((n, false)); } } else { - self.aliases = Some(names.iter().map(|n| (*n, false)).collect::>()); + self.s.aliases = Some(names.iter().map(|n| (*n, false)).collect::>()); } self } @@ -512,10 +441,10 @@ impl<'a, 'b> Arg<'a, 'b> { /// [`Arg`]: ./struct.Arg.html /// [`App::alias`]: ./struct.Arg.html#method.alias pub fn visible_alias>(mut self, name: S) -> Self { - if let Some(ref mut als) = self.aliases { + if let Some(ref mut als) = self.s.aliases { als.push((name.into(), true)); } else { - self.aliases = Some(vec![(name.into(), true)]); + self.s.aliases = Some(vec![(name.into(), true)]); } self } @@ -537,12 +466,12 @@ impl<'a, 'b> Arg<'a, 'b> { /// [`Arg`]: ./struct.Arg.html /// [`App::aliases`]: ./struct.Arg.html#method.aliases pub fn visible_aliases(mut self, names: &[&'b str]) -> Self { - if let Some(ref mut als) = self.aliases { + if let Some(ref mut als) = self.s.aliases { for n in names { als.push((n, true)); } } else { - self.aliases = Some(names.iter().map(|n| (*n, true)).collect::>()); + self.s.aliases = Some(names.iter().map(|n| (*n, true)).collect::>()); } self } @@ -591,7 +520,7 @@ impl<'a, 'b> Arg<'a, 'b> { /// -V, --version Prints version information /// ``` pub fn help(mut self, h: &'b str) -> Self { - self.help = Some(h); + self.b.help = Some(h); self } @@ -767,10 +696,10 @@ impl<'a, 'b> Arg<'a, 'b> { /// [`Arg::required`]: ./struct.Arg.html#method.required /// [`Arg::required_unless(name)`]: ./struct.Arg.html#method.required_unless pub fn required_unless(mut self, name: &'a str) -> Self { - if let Some(ref mut vec) = self.r_unless { + if let Some(ref mut vec) = self.b.r_unless { vec.push(name); } else { - self.r_unless = Some(vec![name]); + self.b.r_unless = Some(vec![name]); } self.required(true) } @@ -839,12 +768,12 @@ impl<'a, 'b> Arg<'a, 'b> { /// [`Arg::required_unless_one`]: ./struct.Arg.html#method.required_unless_one /// [`Arg::required_unless_all(names)`]: ./struct.Arg.html#method.required_unless_all pub fn required_unless_all(mut self, names: &[&'a str]) -> Self { - if let Some(ref mut vec) = self.r_unless { + if let Some(ref mut vec) = self.b.r_unless { for s in names { vec.push(s); } } else { - self.r_unless = Some(names.iter().map(|s| *s).collect::>()); + self.b.r_unless = Some(names.iter().map(|s| *s).collect::>()); } self.setb(ArgSettings::RequiredUnlessAll); self.required(true) @@ -915,12 +844,12 @@ impl<'a, 'b> Arg<'a, 'b> { /// [`Arg::required_unless_one(names)`]: ./struct.Arg.html#method.required_unless_one /// [`Arg::required_unless_all`]: ./struct.Arg.html#method.required_unless_all pub fn required_unless_one(mut self, names: &[&'a str]) -> Self { - if let Some(ref mut vec) = self.r_unless { + if let Some(ref mut vec) = self.b.r_unless { for s in names { vec.push(s); } } else { - self.r_unless = Some(names.iter().map(|s| *s).collect::>()); + self.b.r_unless = Some(names.iter().map(|s| *s).collect::>()); } self.required(true) } @@ -963,10 +892,10 @@ impl<'a, 'b> Arg<'a, 'b> { /// assert_eq!(res.unwrap_err().kind, ErrorKind::ArgumentConflict); /// ``` pub fn conflicts_with(mut self, name: &'a str) -> Self { - if let Some(ref mut vec) = self.blacklist { + if let Some(ref mut vec) = self.b.blacklist { vec.push(name); } else { - self.blacklist = Some(vec![name]); + self.b.blacklist = Some(vec![name]); } self } @@ -1013,12 +942,12 @@ impl<'a, 'b> Arg<'a, 'b> { /// ``` /// [`Arg::conflicts_with`]: ./struct.Arg.html#method.conflicts_with pub fn conflicts_with_all(mut self, names: &[&'a str]) -> Self { - if let Some(ref mut vec) = self.blacklist { + if let Some(ref mut vec) = self.b.blacklist { for s in names { vec.push(s); } } else { - self.blacklist = Some(names.iter().map(|s| *s).collect::>()); + self.b.blacklist = Some(names.iter().map(|s| *s).collect::>()); } self } @@ -1049,10 +978,10 @@ impl<'a, 'b> Arg<'a, 'b> { /// assert!(!m.is_present("flag")); /// ``` pub fn overrides_with(mut self, name: &'a str) -> Self { - if let Some(ref mut vec) = self.overrides { + if let Some(ref mut vec) = self.b.overrides { vec.push(name.as_ref()); } else { - self.overrides = Some(vec![name.as_ref()]); + self.b.overrides = Some(vec![name.as_ref()]); } self } @@ -1084,12 +1013,12 @@ impl<'a, 'b> Arg<'a, 'b> { /// assert!(!m.is_present("flag")); /// ``` pub fn overrides_with_all(mut self, names: &[&'a str]) -> Self { - if let Some(ref mut vec) = self.overrides { + if let Some(ref mut vec) = self.b.overrides { for s in names { vec.push(s); } } else { - self.overrides = Some(names.iter().map(|s| *s).collect::>()); + self.b.overrides = Some(names.iter().map(|s| *s).collect::>()); } self } @@ -1150,12 +1079,12 @@ impl<'a, 'b> Arg<'a, 'b> { /// [Conflicting]: ./struct.Arg.html#method.conflicts_with /// [override]: ./struct.Arg.html#method.overrides_with pub fn requires(mut self, name: &'a str) -> Self { - if let Some(ref mut vec) = self.requires { + if let Some(ref mut vec) = self.b.requires { vec.push((None, name)); } else { let mut vec = vec![]; vec.push((None, name)); - self.requires = Some(vec); + self.b.requires = Some(vec); } self } @@ -1220,10 +1149,10 @@ impl<'a, 'b> Arg<'a, 'b> { /// [Conflicting]: ./struct.Arg.html#method.conflicts_with /// [override]: ./struct.Arg.html#method.overrides_with pub fn requires_if(mut self, val: &'b str, arg: &'a str) -> Self { - if let Some(ref mut vec) = self.requires { + if let Some(ref mut vec) = self.b.requires { vec.push((Some(val), arg)); } else { - self.requires = Some(vec![(Some(val), arg)]); + self.b.requires = Some(vec![(Some(val), arg)]); } self } @@ -1280,7 +1209,7 @@ impl<'a, 'b> Arg<'a, 'b> { /// [Conflicting]: ./struct.Arg.html#method.conflicts_with /// [override]: ./struct.Arg.html#method.overrides_with pub fn requires_ifs(mut self, ifs: &[(&'b str, &'a str)]) -> Self { - if let Some(ref mut vec) = self.requires { + if let Some(ref mut vec) = self.b.requires { for &(val, arg) in ifs { vec.push((Some(val), arg)); } @@ -1289,7 +1218,7 @@ impl<'a, 'b> Arg<'a, 'b> { for &(val, arg) in ifs { vec.push((Some(val), arg)); } - self.requires = Some(vec); + self.b.requires = Some(vec); } self } @@ -1524,7 +1453,7 @@ impl<'a, 'b> Arg<'a, 'b> { /// [override]: ./struct.Arg.html#method.overrides_with /// [`Arg::requires_all(&[arg, arg2])`]: ./struct.Arg.html#method.requires_all pub fn requires_all(mut self, names: &[&'a str]) -> Self { - if let Some(ref mut vec) = self.requires { + if let Some(ref mut vec) = self.b.requires { for s in names { vec.push((None, s)); } @@ -1533,7 +1462,7 @@ impl<'a, 'b> Arg<'a, 'b> { for s in names { vec.push((None, *s)); } - self.requires = Some(vec); + self.b.requires = Some(vec); } self } @@ -1867,7 +1796,7 @@ impl<'a, 'b> Arg<'a, 'b> { /// [`max_values`]: ./struct.Arg.html#method.max_values pub fn value_terminator(mut self, term: &'b str) -> Self { self.setb(ArgSettings::TakesValue); - self.val_terminator = Some(term); + self.v.terminator = Some(term); self } @@ -2055,12 +1984,12 @@ impl<'a, 'b> Arg<'a, 'b> { /// [options]: ./struct.Arg.html#method.takes_value /// [positional arguments]: ./struct.Arg.html#method.index pub fn possible_values(mut self, names: &[&'b str]) -> Self { - if let Some(ref mut vec) = self.possible_vals { + if let Some(ref mut vec) = self.v.possible_vals { for s in names { vec.push(s); } } else { - self.possible_vals = Some(names.iter().map(|s| *s).collect::>()); + self.v.possible_vals = Some(names.iter().map(|s| *s).collect::>()); } self } @@ -2115,10 +2044,10 @@ impl<'a, 'b> Arg<'a, 'b> { /// [options]: ./struct.Arg.html#method.takes_value /// [positional arguments]: ./struct.Arg.html#method.index pub fn possible_value(mut self, name: &'b str) -> Self { - if let Some(ref mut vec) = self.possible_vals { + if let Some(ref mut vec) = self.v.possible_vals { vec.push(name); } else { - self.possible_vals = Some(vec![name]); + self.v.possible_vals = Some(vec![name]); } self } @@ -2152,10 +2081,10 @@ impl<'a, 'b> Arg<'a, 'b> { /// ``` /// [`ArgGroup`]: ./struct.ArgGroup.html pub fn group(mut self, name: &'a str) -> Self { - if let Some(ref mut vec) = self.groups { + if let Some(ref mut vec) = self.b.groups { vec.push(name); } else { - self.groups = Some(vec![name]); + self.b.groups = Some(vec![name]); } self } @@ -2190,12 +2119,12 @@ impl<'a, 'b> Arg<'a, 'b> { /// ``` /// [`ArgGroup`]: ./struct.ArgGroup.html pub fn groups(mut self, names: &[&'a str]) -> Self { - if let Some(ref mut vec) = self.groups { + if let Some(ref mut vec) = self.b.groups { for s in names { vec.push(s); } } else { - self.groups = Some(names.into_iter().map(|s| *s).collect::>()); + self.b.groups = Some(names.into_iter().map(|s| *s).collect::>()); } self } @@ -2236,7 +2165,7 @@ impl<'a, 'b> Arg<'a, 'b> { /// [`Arg::multiple(true)`]: ./struct.Arg.html#method.multiple pub fn number_of_values(mut self, qty: u64) -> Self { self.setb(ArgSettings::TakesValue); - self.num_vals = Some(qty); + self.v.num_vals = Some(qty); self } @@ -2279,7 +2208,7 @@ impl<'a, 'b> Arg<'a, 'b> { pub fn validator(mut self, f: F) -> Self where F: Fn(String) -> Result<(), String> + 'static { - self.validator = Some(Rc::new(f)); + self.v.validator = Some(Rc::new(f)); self } @@ -2310,7 +2239,7 @@ impl<'a, 'b> Arg<'a, 'b> { pub fn validator_os(mut self, f: F) -> Self where F: Fn(&OsStr) -> Result<(), OsString> + 'static { - self.validator_os = Some(Rc::new(f)); + self.v.validator_os = Some(Rc::new(f)); self } @@ -2368,7 +2297,7 @@ impl<'a, 'b> Arg<'a, 'b> { /// [`Arg::multiple(true)`]: ./struct.Arg.html#method.multiple pub fn max_values(mut self, qty: u64) -> Self { self.setb(ArgSettings::TakesValue); - self.max_vals = Some(qty); + self.v.max_vals = Some(qty); self } @@ -2426,7 +2355,7 @@ impl<'a, 'b> Arg<'a, 'b> { /// ``` /// [`Arg::multiple(true)`]: ./struct.Arg.html#method.multiple pub fn min_values(mut self, qty: u64) -> Self { - self.min_vals = Some(qty); + self.v.min_vals = Some(qty); self.set(ArgSettings::TakesValue) } @@ -2480,14 +2409,14 @@ impl<'a, 'b> Arg<'a, 'b> { /// [`Arg::value_delimiter`]: ./struct.Arg.html#method.value_delimiter pub fn use_delimiter(mut self, d: bool) -> Self { if d { - if self.val_delim.is_none() { - self.val_delim = Some(','); + if self.v.val_delim.is_none() { + self.v.val_delim = Some(','); } self.setb(ArgSettings::TakesValue); self.setb(ArgSettings::UseValueDelimiter); self.unset(ArgSettings::ValueDelimiterNotSet) } else { - self.val_delim = None; + self.v.val_delim = None; self.unsetb(ArgSettings::UseValueDelimiter); self.unset(ArgSettings::ValueDelimiterNotSet) } @@ -2609,7 +2538,7 @@ impl<'a, 'b> Arg<'a, 'b> { self.unsetb(ArgSettings::ValueDelimiterNotSet); self.setb(ArgSettings::TakesValue); self.setb(ArgSettings::UseValueDelimiter); - self.val_delim = Some(d.chars() + self.v.val_delim = Some(d.chars() .nth(0) .expect("Failed to get value_delimiter from arg")); self @@ -2676,11 +2605,11 @@ impl<'a, 'b> Arg<'a, 'b> { /// [`Arg::multiple(true)`]: ./struct.Arg.html#method.multiple pub fn value_names(mut self, names: &[&'b str]) -> Self { self.setb(ArgSettings::TakesValue); - if self.settings.is_set(ArgSettings::ValueDelimiterNotSet) { + if self.is_set(ArgSettings::ValueDelimiterNotSet) { self.unsetb(ArgSettings::ValueDelimiterNotSet); self.setb(ArgSettings::UseValueDelimiter); } - if let Some(ref mut vals) = self.val_names { + if let Some(ref mut vals) = self.v.val_names { let mut l = vals.len(); for s in names { vals.insert(l, s); @@ -2691,7 +2620,7 @@ impl<'a, 'b> Arg<'a, 'b> { for (i, n) in names.iter().enumerate() { vm.insert(i, *n); } - self.val_names = Some(vm); + self.v.val_names = Some(vm); } self } @@ -2744,13 +2673,13 @@ impl<'a, 'b> Arg<'a, 'b> { /// [`Arg::takes_value(true)`]: ./struct.Arg.html#method.takes_value pub fn value_name(mut self, name: &'b str) -> Self { self.setb(ArgSettings::TakesValue); - if let Some(ref mut vals) = self.val_names { + if let Some(ref mut vals) = self.v.val_names { let l = vals.len(); vals.insert(l, name); } else { let mut vm = VecMap::new(); vm.insert(0, name); - self.val_names = Some(vm); + self.v.val_names = Some(vm); } self } @@ -2820,7 +2749,7 @@ impl<'a, 'b> Arg<'a, 'b> { /// [`Arg::default_value_if`]: ./struct.Arg.html#method.default_value_if pub fn default_value(mut self, val: &'a str) -> Self { self.setb(ArgSettings::TakesValue); - self.default_val = Some(val); + self.v.default_val = Some(val); self } @@ -2926,13 +2855,13 @@ impl<'a, 'b> Arg<'a, 'b> { default: &'b str) -> Self { self.setb(ArgSettings::TakesValue); - if let Some(ref mut vm) = self.default_vals_ifs { + if let Some(ref mut vm) = self.v.default_vals_ifs { let l = vm.len(); vm.insert(l, (arg, val, default)); } else { let mut vm = VecMap::new(); vm.insert(0, (arg, val, default)); - self.default_vals_ifs = Some(vm); + self.v.default_vals_ifs = Some(vm); } self } @@ -3024,7 +2953,7 @@ impl<'a, 'b> Arg<'a, 'b> { #[cfg_attr(feature = "lints", allow(explicit_counter_loop))] pub fn default_value_ifs(mut self, ifs: &[(&'a str, Option<&'b str>, &'b str)]) -> Self { self.setb(ArgSettings::TakesValue); - if let Some(ref mut vm) = self.default_vals_ifs { + if let Some(ref mut vm) = self.v.default_vals_ifs { let mut l = vm.len(); for &(arg, val, default) in ifs { vm.insert(l, (arg, val, default)); @@ -3037,7 +2966,7 @@ impl<'a, 'b> Arg<'a, 'b> { vm.insert(l, (arg, val, default)); l += 1; } - self.default_vals_ifs = Some(vm); + self.v.default_vals_ifs = Some(vm); } self } @@ -3152,13 +3081,13 @@ impl<'a, 'b> Arg<'a, 'b> { /// [positional arguments]: ./struct.Arg.html#method.index /// [index]: ./struct.Arg.html#method.index pub fn display_order(mut self, ord: usize) -> Self { - self.disp_ord = ord; + self.s.disp_ord = ord; self } /// Checks if one of the [`ArgSettings`] settings is set for the argument /// [`ArgSettings`]: ./enum.ArgSettings.html - pub fn is_set(&self, s: ArgSettings) -> bool { self.settings.is_set(s) } + pub fn is_set(&self, s: ArgSettings) -> bool { self.b.is_set(s) } /// Sets one of the [`ArgSettings`] settings for the argument /// [`ArgSettings`]: ./enum.ArgSettings.html @@ -3175,72 +3104,20 @@ impl<'a, 'b> Arg<'a, 'b> { } #[doc(hidden)] - pub fn setb(&mut self, s: ArgSettings) { self.settings.set(s); } + pub fn setb(&mut self, s: ArgSettings) { self.b.set(s); } #[doc(hidden)] - pub fn unsetb(&mut self, s: ArgSettings) { self.settings.unset(s); } + pub fn unsetb(&mut self, s: ArgSettings) { self.b.unset(s); } } impl<'a, 'b, 'z> From<&'z Arg<'a, 'b>> for Arg<'a, 'b> { fn from(a: &'z Arg<'a, 'b>) -> Self { Arg { - name: a.name, - short: a.short, - long: a.long, - aliases: a.aliases.clone(), - help: a.help, + b: a.b.clone(), + v: a.v.clone(), + s: a.s.clone(), index: a.index, - possible_vals: a.possible_vals.clone(), - blacklist: a.blacklist.clone(), - requires: a.requires.clone(), - num_vals: a.num_vals, - min_vals: a.min_vals, - max_vals: a.max_vals, - val_names: a.val_names.clone(), - groups: a.groups.clone(), - validator: a.validator.clone(), - validator_os: a.validator_os.clone(), - overrides: a.overrides.clone(), - settings: a.settings, - val_delim: a.val_delim, - default_val: a.default_val, - default_vals_ifs: a.default_vals_ifs.clone(), - disp_ord: a.disp_ord, - r_unless: a.r_unless.clone(), r_ifs: a.r_ifs.clone(), - val_terminator: a.val_terminator, - } - } -} - -impl<'a, 'b> Clone for Arg<'a, 'b> { - fn clone(&self) -> Self { - Arg { - name: self.name, - short: self.short, - long: self.long, - aliases: self.aliases.clone(), - help: self.help, - index: self.index, - possible_vals: self.possible_vals.clone(), - blacklist: self.blacklist.clone(), - requires: self.requires.clone(), - num_vals: self.num_vals, - min_vals: self.min_vals, - max_vals: self.max_vals, - val_names: self.val_names.clone(), - groups: self.groups.clone(), - validator: self.validator.clone(), - validator_os: self.validator_os.clone(), - overrides: self.overrides.clone(), - settings: self.settings, - val_delim: self.val_delim, - default_val: self.default_val, - default_vals_ifs: self.default_vals_ifs.clone(), - disp_ord: self.disp_ord, - r_unless: self.r_unless.clone(), - r_ifs: self.r_ifs.clone(), - val_terminator: self.val_terminator, } } } diff --git a/src/args/arg_builder/base.rs b/src/args/arg_builder/base.rs index 8e5682441c6..fa52016f760 100644 --- a/src/args/arg_builder/base.rs +++ b/src/args/arg_builder/base.rs @@ -1,12 +1,11 @@ -use args::{ArgSettings, Arg, ArgFlags, ArgKind}; +use args::{ArgSettings, Arg, ArgFlags}; -#[derive(Debug, Clone)] +#[derive(Debug, Clone, Default)] pub struct Base<'a, 'b> where 'a: 'b { pub name: &'a str, pub id: usize, - pub kind: ArgKind, pub help: Option<&'b str>, pub blacklist: Option>, pub settings: ArgFlags, @@ -16,42 +15,16 @@ pub struct Base<'a, 'b> pub requires: Option, &'a str)>>, } -impl<'n, 'e> Default for Base<'n, 'e> { - fn default() -> Self { - Base { - name: "", - id: 0, - kind: ArgKind::Pos, - help: None, - blacklist: None, - settings: ArgFlags::new(), - r_unless: None, - overrides: None, - requires: None, - groups: None, - } - } -} - impl<'n, 'e> Base<'n, 'e> { pub fn new(name: &'n str) -> Self { Base { name: name, ..Default::default() } } pub fn set(&mut self, s: ArgSettings) { self.settings.set(s); } + pub fn unset(&mut self, s: ArgSettings) { self.settings.unset(s); } + pub fn is_set(&self, s: ArgSettings) -> bool { self.settings.is_set(s) } } impl<'n, 'e, 'z> From<&'z Arg<'n, 'e>> for Base<'n, 'e> { fn from(a: &'z Arg<'n, 'e>) -> Self { - Base { - name: a.name, - help: a.help, - id: 0, - kind: ArgKind::Pos, - blacklist: a.blacklist.clone(), - settings: a.settings, - r_unless: a.r_unless.clone(), - overrides: a.overrides.clone(), - requires: a.requires.clone(), - groups: a.groups.clone(), - } + a.b.clone() } } diff --git a/src/args/arg_builder/flag.rs b/src/args/arg_builder/flag.rs index 6371848a5e8..7b153ec6578 100644 --- a/src/args/arg_builder/flag.rs +++ b/src/args/arg_builder/flag.rs @@ -10,7 +10,7 @@ use vec_map::{self, VecMap}; // Internal use Arg; -use args::{ArgSettings, ArgKind, Base, Switched, AnyArg, DispOrder}; +use args::{ArgSettings, Base, Switched, AnyArg, DispOrder}; #[derive(Default, Clone, Debug)] #[doc(hidden)] @@ -51,7 +51,6 @@ impl<'n, 'e> Display for FlagBuilder<'n, 'e> { impl<'n, 'e> AnyArg<'n, 'e> for FlagBuilder<'n, 'e> { fn name(&self) -> &'n str { self.b.name } fn id(&self) -> usize { self.b.id } - fn kind(&self) -> ArgKind { ArgKind::Flag } fn overrides(&self) -> Option<&[&'e str]> { self.b.overrides.as_ref().map(|o| &o[..]) } fn requires(&self) -> Option<&[(Option<&'e str>, &'n str)]> { self.b.requires.as_ref().map(|o| &o[..]) } fn blacklist(&self) -> Option<&[&'e str]> { self.b.blacklist.as_ref().map(|o| &o[..]) } diff --git a/src/args/arg_builder/option.rs b/src/args/arg_builder/option.rs index f091f49d933..ccb36971b12 100644 --- a/src/args/arg_builder/option.rs +++ b/src/args/arg_builder/option.rs @@ -8,7 +8,7 @@ use std::ffi::{OsStr, OsString}; use vec_map::{self, VecMap}; // Internal -use args::{ArgSettings, ArgKind, AnyArg, Base, Switched, Valued, Arg, DispOrder}; +use args::{ArgSettings, AnyArg, Base, Switched, Valued, Arg, DispOrder}; #[allow(missing_debug_implementations)] #[doc(hidden)] @@ -33,7 +33,7 @@ impl<'n, 'e> OptBuilder<'n, 'e> { }; // If the arg is required, add all it's requirements to master required list if a.is_set(ArgSettings::Required) { - if let Some(ref areqs) = a.requires { + if let Some(ref areqs) = a.b.requires { for r in areqs.iter().filter(|r| r.0.is_none()) { reqs.push(r.1); } @@ -95,7 +95,6 @@ impl<'n, 'e> Display for OptBuilder<'n, 'e> { impl<'n, 'e> AnyArg<'n, 'e> for OptBuilder<'n, 'e> { fn name(&self) -> &'n str { self.b.name } fn id(&self) -> usize { self.b.id } - fn kind(&self) -> ArgKind { ArgKind::Opt } fn overrides(&self) -> Option<&[&'e str]> { self.b.overrides.as_ref().map(|o| &o[..]) } fn requires(&self) -> Option<&[(Option<&'e str>, &'n str)]> { self.b.requires.as_ref().map(|o| &o[..]) } fn blacklist(&self) -> Option<&[&'e str]> { self.b.blacklist.as_ref().map(|o| &o[..]) } diff --git a/src/args/arg_builder/positional.rs b/src/args/arg_builder/positional.rs index 132e1da4f64..2bf16c741fc 100644 --- a/src/args/arg_builder/positional.rs +++ b/src/args/arg_builder/positional.rs @@ -10,7 +10,7 @@ use vec_map::{self, VecMap}; // Internal use Arg; -use args::{ArgSettings, Base, Valued, ArgKind, AnyArg, DispOrder}; +use args::{ArgSettings, Base, Valued, AnyArg, DispOrder}; #[allow(missing_debug_implementations)] #[doc(hidden)] @@ -41,13 +41,13 @@ impl<'n, 'e> PosBuilder<'n, 'e> { v: Valued::from(a), index: idx, }; - if a.max_vals.is_some() || a.min_vals.is_some() || - (a.num_vals.is_some() && a.num_vals.unwrap() > 1) { + if a.v.max_vals.is_some() || a.v.min_vals.is_some() || + (a.v.num_vals.is_some() && a.v.num_vals.unwrap() > 1) { pb.b.settings.set(ArgSettings::Multiple); } // If the arg is required, add all it's requirements to master required list if a.is_set(ArgSettings::Required) { - if let Some(ref areqs) = a.requires { + if let Some(ref areqs) = a.b.requires { for name in areqs.iter().filter(|&&(val,_)|val.is_none()).map(|&(_, name)| name) { reqs.push(name); } @@ -99,7 +99,6 @@ impl<'n, 'e> Display for PosBuilder<'n, 'e> { impl<'n, 'e> AnyArg<'n, 'e> for PosBuilder<'n, 'e> { fn name(&self) -> &'n str { self.b.name } fn id(&self) -> usize { self.b.id } - fn kind(&self) -> ArgKind { ArgKind::Pos } fn overrides(&self) -> Option<&[&'e str]> { self.b.overrides.as_ref().map(|o| &o[..]) } fn requires(&self) -> Option<&[(Option<&'e str>, &'n str)]> { self.b.requires.as_ref().map(|o| &o[..]) } fn blacklist(&self) -> Option<&[&'e str]> { self.b.blacklist.as_ref().map(|o| &o[..]) } diff --git a/src/args/arg_builder/switched.rs b/src/args/arg_builder/switched.rs index 33402e16b3c..777ff1d590b 100644 --- a/src/args/arg_builder/switched.rs +++ b/src/args/arg_builder/switched.rs @@ -23,13 +23,7 @@ impl<'e> Default for Switched<'e> { impl<'n, 'e, 'z> From<&'z Arg<'n, 'e>> for Switched<'e> { fn from(a: &'z Arg<'n, 'e>) -> Self { - Switched { - short: a.short, - long: a.long, - aliases: a.aliases.clone(), - disp_ord: a.disp_ord, - ..Default::default() - } + a.s.clone() } } diff --git a/src/args/arg_builder/valued.rs b/src/args/arg_builder/valued.rs index 503b0d5947d..cc4fa2adf63 100644 --- a/src/args/arg_builder/valued.rs +++ b/src/args/arg_builder/valued.rs @@ -33,7 +33,7 @@ impl<'n, 'e> Default for Valued<'n, 'e> { val_names: None, validator: None, validator_os: None, - val_delim: Some(','), + val_delim: None, default_val: None, default_vals_ifs: None, terminator: None, @@ -43,25 +43,13 @@ impl<'n, 'e> Default for Valued<'n, 'e> { impl<'n, 'e, 'z> From<&'z Arg<'n, 'e>> for Valued<'n, 'e> { fn from(a: &'z Arg<'n, 'e>) -> Self { - let mut v = Valued { - possible_vals: a.possible_vals.clone(), - num_vals: a.num_vals, - min_vals: a.min_vals, - max_vals: a.max_vals, - val_names: a.val_names.clone(), - validator: a.validator.clone(), - validator_os: a.validator_os.clone(), - val_delim: a.val_delim, - default_val: a.default_val, - default_vals_ifs: a.default_vals_ifs.clone(), - terminator: a.val_terminator, - }; - if let Some(ref vec) = a.val_names { + let mut v = a.v.clone(); + if let Some(ref vec) = a.v.val_names { if vec.len() > 1 { v.num_vals = Some(vec.len() as u64); } } - if let Some(ref vec) = a.val_names { + if let Some(ref vec) = a.v.val_names { if vec.len() > 1 { v.num_vals = Some(vec.len() as u64); } diff --git a/src/args/mod.rs b/src/args/mod.rs index 5acec4cead5..5c87e1be915 100644 --- a/src/args/mod.rs +++ b/src/args/mod.rs @@ -19,13 +19,3 @@ mod arg_builder; mod matched_arg; mod group; pub mod settings; - -#[doc(hidden)] -#[derive(Copy, Clone, Debug)] -pub enum ArgKind { - Flag, - Opt, - Pos, - Subcmd, - Group, -} diff --git a/src/usage_parser.rs b/src/usage_parser.rs index f747d932cf3..e890e333d8a 100644 --- a/src/usage_parser.rs +++ b/src/usage_parser.rs @@ -61,14 +61,14 @@ impl<'a> UsageParser<'a> { break; } } - debug_assert!(!arg.name.is_empty(), + debug_assert!(!arg.b.name.is_empty(), format!("No name found for Arg when parsing usage string: {}", self.usage)); - arg.num_vals = match arg.val_names { + arg.v.num_vals = match arg.v.val_names { Some(ref v) if v.len() >= 2 => Some(v.len() as u64), _ => None, }; - debugln!("UsageParser::parse: vals...{:?}", arg.val_names); + debugln!("UsageParser::parse: vals...{:?}", arg.v.val_names); arg } @@ -83,21 +83,21 @@ impl<'a> UsageParser<'a> { let name = &self.usage[self.start..self.pos]; if self.prev == UsageToken::Unknown { debugln!("UsageParser::name: setting name...{}", name); - arg.name = name; - if arg.long.is_none() && arg.short.is_none() { + arg.b.name = name; + if arg.s.long.is_none() && arg.s.short.is_none() { debugln!("UsageParser::name: explicit name set..."); self.explicit_name_set = true; self.prev = UsageToken::Name; } } else { debugln!("UsageParser::name: setting val name...{}", name); - if let Some(ref mut v) = arg.val_names { + if let Some(ref mut v) = arg.v.val_names { let len = v.len(); v.insert(len, name); } else { let mut v = VecMap::new(); v.insert(0, name); - arg.val_names = Some(v); + arg.v.val_names = Some(v); arg.setb(ArgSettings::TakesValue); } self.prev = UsageToken::ValName; @@ -129,10 +129,10 @@ impl<'a> UsageParser<'a> { let name = &self.usage[self.start..self.pos]; if !self.explicit_name_set { debugln!("UsageParser::long: setting name...{}", name); - arg.name = name; + arg.b.name = name; } debugln!("UsageParser::long: setting long...{}", name); - arg.long = Some(name); + arg.s.long = Some(name); self.prev = UsageToken::Long; } @@ -141,12 +141,12 @@ impl<'a> UsageParser<'a> { let start = &self.usage[self.pos..]; let short = start.chars().nth(0).expect(INTERNAL_ERROR_MSG); debugln!("UsageParser::short: setting short...{}", short); - arg.short = Some(short); - if arg.name.is_empty() { + arg.s.short = Some(short); + if arg.b.name.is_empty() { // --long takes precedence but doesn't set self.explicit_name_set let name = &start[..short.len_utf8()]; debugln!("UsageParser::short: setting name...{}", name); - arg.name = name; + arg.b.name = name; } self.prev = UsageToken::Short; } @@ -163,11 +163,11 @@ impl<'a> UsageParser<'a> { if dot_counter == 3 { debugln!("UsageParser::multiple: setting multiple"); arg.setb(ArgSettings::Multiple); - if arg.settings.is_set(ArgSettings::TakesValue) { + if arg.is_set(ArgSettings::TakesValue) { arg.setb(ArgSettings::UseValueDelimiter); arg.unsetb(ArgSettings::ValueDelimiterNotSet); - if arg.val_delim.is_none() { - arg.val_delim = Some(','); + if arg.v.val_delim.is_none() { + arg.v.val_delim = Some(','); } } self.prev = UsageToken::Multiple; @@ -183,7 +183,7 @@ impl<'a> UsageParser<'a> { self.start = self.pos + 1; self.pos = self.usage.len() - 1; debugln!("UsageParser::help: setting help...{}", &self.usage[self.start..self.pos]); - arg.help = Some(&self.usage[self.start..self.pos]); + arg.b.help = Some(&self.usage[self.start..self.pos]); self.pos += 1; // Move to next byte to keep from thinking ending ' is a start self.prev = UsageToken::Help; } @@ -211,989 +211,989 @@ mod test { #[test] fn create_flag_usage() { let a = Arg::from_usage("[flag] -f 'some help info'"); - assert_eq!(a.name, "flag"); - assert_eq!(a.short.unwrap(), 'f'); - assert!(a.long.is_none()); - assert_eq!(a.help.unwrap(), "some help info"); + assert_eq!(a.b.name, "flag"); + assert_eq!(a.s.short.unwrap(), 'f'); + assert!(a.s.long.is_none()); + assert_eq!(a.b.help.unwrap(), "some help info"); assert!(!a.is_set(ArgSettings::Multiple)); - assert!(a.val_names.is_none()); - assert!(a.num_vals.is_none()); + assert!(a.v.val_names.is_none()); + assert!(a.v.num_vals.is_none()); let b = Arg::from_usage("[flag] --flag 'some help info'"); - assert_eq!(b.name, "flag"); - assert_eq!(b.long.unwrap(), "flag"); - assert!(b.short.is_none()); - assert_eq!(b.help.unwrap(), "some help info"); + assert_eq!(b.b.name, "flag"); + assert_eq!(b.s.long.unwrap(), "flag"); + assert!(b.s.short.is_none()); + assert_eq!(b.b.help.unwrap(), "some help info"); assert!(!b.is_set(ArgSettings::Multiple)); - assert!(a.val_names.is_none()); - assert!(a.num_vals.is_none()); + assert!(a.v.val_names.is_none()); + assert!(a.v.num_vals.is_none()); let b = Arg::from_usage("--flag 'some help info'"); - assert_eq!(b.name, "flag"); - assert_eq!(b.long.unwrap(), "flag"); - assert!(b.short.is_none()); - assert_eq!(b.help.unwrap(), "some help info"); + assert_eq!(b.b.name, "flag"); + assert_eq!(b.s.long.unwrap(), "flag"); + assert!(b.s.short.is_none()); + assert_eq!(b.b.help.unwrap(), "some help info"); assert!(!b.is_set(ArgSettings::Multiple)); - assert!(b.val_names.is_none()); - assert!(b.num_vals.is_none()); + assert!(b.v.val_names.is_none()); + assert!(b.v.num_vals.is_none()); let c = Arg::from_usage("[flag] -f --flag 'some help info'"); - assert_eq!(c.name, "flag"); - assert_eq!(c.short.unwrap(), 'f'); - assert_eq!(c.long.unwrap(), "flag"); - assert_eq!(c.help.unwrap(), "some help info"); + assert_eq!(c.b.name, "flag"); + assert_eq!(c.s.short.unwrap(), 'f'); + assert_eq!(c.s.long.unwrap(), "flag"); + assert_eq!(c.b.help.unwrap(), "some help info"); assert!(!c.is_set(ArgSettings::Multiple)); - assert!(c.val_names.is_none()); - assert!(c.num_vals.is_none()); + assert!(c.v.val_names.is_none()); + assert!(c.v.num_vals.is_none()); let d = Arg::from_usage("[flag] -f... 'some help info'"); - assert_eq!(d.name, "flag"); - assert_eq!(d.short.unwrap(), 'f'); - assert!(d.long.is_none()); - assert_eq!(d.help.unwrap(), "some help info"); + assert_eq!(d.b.name, "flag"); + assert_eq!(d.s.short.unwrap(), 'f'); + assert!(d.s.long.is_none()); + assert_eq!(d.b.help.unwrap(), "some help info"); assert!(d.is_set(ArgSettings::Multiple)); - assert!(d.val_names.is_none()); - assert!(d.num_vals.is_none()); + assert!(d.v.val_names.is_none()); + assert!(d.v.num_vals.is_none()); let e = Arg::from_usage("[flag] -f --flag... 'some help info'"); - assert_eq!(e.name, "flag"); - assert_eq!(e.long.unwrap(), "flag"); - assert_eq!(e.short.unwrap(), 'f'); - assert_eq!(e.help.unwrap(), "some help info"); + assert_eq!(e.b.name, "flag"); + assert_eq!(e.s.long.unwrap(), "flag"); + assert_eq!(e.s.short.unwrap(), 'f'); + assert_eq!(e.b.help.unwrap(), "some help info"); assert!(e.is_set(ArgSettings::Multiple)); - assert!(e.val_names.is_none()); - assert!(e.num_vals.is_none()); + assert!(e.v.val_names.is_none()); + assert!(e.v.num_vals.is_none()); let e = Arg::from_usage("-f --flag... 'some help info'"); - assert_eq!(e.name, "flag"); - assert_eq!(e.long.unwrap(), "flag"); - assert_eq!(e.short.unwrap(), 'f'); - assert_eq!(e.help.unwrap(), "some help info"); + assert_eq!(e.b.name, "flag"); + assert_eq!(e.s.long.unwrap(), "flag"); + assert_eq!(e.s.short.unwrap(), 'f'); + assert_eq!(e.b.help.unwrap(), "some help info"); assert!(e.is_set(ArgSettings::Multiple)); - assert!(e.val_names.is_none()); - assert!(e.num_vals.is_none()); + assert!(e.v.val_names.is_none()); + assert!(e.v.num_vals.is_none()); let e = Arg::from_usage("--flags"); - assert_eq!(e.name, "flags"); - assert_eq!(e.long.unwrap(), "flags"); - assert!(e.val_names.is_none()); - assert!(e.num_vals.is_none()); + assert_eq!(e.b.name, "flags"); + assert_eq!(e.s.long.unwrap(), "flags"); + assert!(e.v.val_names.is_none()); + assert!(e.v.num_vals.is_none()); let e = Arg::from_usage("--flags..."); - assert_eq!(e.name, "flags"); - assert_eq!(e.long.unwrap(), "flags"); + assert_eq!(e.b.name, "flags"); + assert_eq!(e.s.long.unwrap(), "flags"); assert!(e.is_set(ArgSettings::Multiple)); - assert!(e.val_names.is_none()); - assert!(e.num_vals.is_none()); + assert!(e.v.val_names.is_none()); + assert!(e.v.num_vals.is_none()); let e = Arg::from_usage("[flags] -f"); - assert_eq!(e.name, "flags"); - assert_eq!(e.short.unwrap(), 'f'); - assert!(e.val_names.is_none()); - assert!(e.num_vals.is_none()); + assert_eq!(e.b.name, "flags"); + assert_eq!(e.s.short.unwrap(), 'f'); + assert!(e.v.val_names.is_none()); + assert!(e.v.num_vals.is_none()); let e = Arg::from_usage("[flags] -f..."); - assert_eq!(e.name, "flags"); - assert_eq!(e.short.unwrap(), 'f'); + assert_eq!(e.b.name, "flags"); + assert_eq!(e.s.short.unwrap(), 'f'); assert!(e.is_set(ArgSettings::Multiple)); - assert!(e.val_names.is_none()); - assert!(e.num_vals.is_none()); + assert!(e.v.val_names.is_none()); + assert!(e.v.num_vals.is_none()); let a = Arg::from_usage("-f 'some help info'"); - assert_eq!(a.name, "f"); - assert_eq!(a.short.unwrap(), 'f'); - assert!(a.long.is_none()); - assert_eq!(a.help.unwrap(), "some help info"); + assert_eq!(a.b.name, "f"); + assert_eq!(a.s.short.unwrap(), 'f'); + assert!(a.s.long.is_none()); + assert_eq!(a.b.help.unwrap(), "some help info"); assert!(!a.is_set(ArgSettings::Multiple)); - assert!(a.val_names.is_none()); - assert!(a.num_vals.is_none()); + assert!(a.v.val_names.is_none()); + assert!(a.v.num_vals.is_none()); let e = Arg::from_usage("-f"); - assert_eq!(e.name, "f"); - assert_eq!(e.short.unwrap(), 'f'); - assert!(e.val_names.is_none()); - assert!(e.num_vals.is_none()); + assert_eq!(e.b.name, "f"); + assert_eq!(e.s.short.unwrap(), 'f'); + assert!(e.v.val_names.is_none()); + assert!(e.v.num_vals.is_none()); let e = Arg::from_usage("-f..."); - assert_eq!(e.name, "f"); - assert_eq!(e.short.unwrap(), 'f'); + assert_eq!(e.b.name, "f"); + assert_eq!(e.s.short.unwrap(), 'f'); assert!(e.is_set(ArgSettings::Multiple)); - assert!(e.val_names.is_none()); - assert!(e.num_vals.is_none()); + assert!(e.v.val_names.is_none()); + assert!(e.v.num_vals.is_none()); } #[test] fn create_option_usage0() { // Short only let a = Arg::from_usage("[option] -o [opt] 'some help info'"); - assert_eq!(a.name, "option"); - assert_eq!(a.short.unwrap(), 'o'); - assert!(a.long.is_none()); - assert_eq!(a.help.unwrap(), "some help info"); + assert_eq!(a.b.name, "option"); + assert_eq!(a.s.short.unwrap(), 'o'); + assert!(a.s.long.is_none()); + assert_eq!(a.b.help.unwrap(), "some help info"); assert!(!a.is_set(ArgSettings::Multiple)); assert!(a.is_set(ArgSettings::TakesValue)); assert!(!a.is_set(ArgSettings::Required)); - assert_eq!(a.val_names.unwrap().values().collect::>(), [&"opt"]); - assert!(a.num_vals.is_none()); + assert_eq!(a.v.val_names.unwrap().values().collect::>(), [&"opt"]); + assert!(a.v.num_vals.is_none()); } #[test] fn create_option_usage1() { let b = Arg::from_usage("-o [opt] 'some help info'"); - assert_eq!(b.name, "o"); - assert_eq!(b.short.unwrap(), 'o'); - assert!(b.long.is_none()); - assert_eq!(b.help.unwrap(), "some help info"); + assert_eq!(b.b.name, "o"); + assert_eq!(b.s.short.unwrap(), 'o'); + assert!(b.s.long.is_none()); + assert_eq!(b.b.help.unwrap(), "some help info"); assert!(!b.is_set(ArgSettings::Multiple)); assert!(b.is_set(ArgSettings::TakesValue)); assert!(!b.is_set(ArgSettings::Required)); - assert_eq!(b.val_names.unwrap().values().collect::>(), [&"opt"]); - assert!(b.num_vals.is_none()); + assert_eq!(b.v.val_names.unwrap().values().collect::>(), [&"opt"]); + assert!(b.v.num_vals.is_none()); } #[test] fn create_option_usage2() { let c = Arg::from_usage("