diff --git a/clap_complete/src/generator/utils.rs b/clap_complete/src/generator/utils.rs index a1eda6af96d..f707b18e8ab 100644 --- a/clap_complete/src/generator/utils.rs +++ b/clap_complete/src/generator/utils.rs @@ -1,6 +1,6 @@ //! Helpers for writing generators -use clap::{App, Arg, ArgSettings}; +use clap::{App, Arg}; /// Gets all subcommands including child subcommands in the form of `("name", "bin_name")`. /// @@ -121,7 +121,7 @@ pub fn longs_and_visible_aliases(p: &App) -> Vec { pub fn flags<'help>(p: &App<'help>) -> Vec> { debug!("flags: name={}", p.get_name()); p.get_arguments() - .filter(|a| !a.is_set(ArgSettings::TakesValue) && !a.is_positional()) + .filter(|a| !a.is_takes_value_set() && !a.is_positional()) .cloned() .collect() } diff --git a/clap_complete/src/shells/fish.rs b/clap_complete/src/shells/fish.rs index 068c75f00b4..46560fccdea 100644 --- a/clap_complete/src/shells/fish.rs +++ b/clap_complete/src/shells/fish.rs @@ -143,7 +143,7 @@ fn gen_fish_inner(root_command: &str, parent_commands: &[&str], app: &App, buffe } fn value_completion(option: &Arg) -> String { - if !option.is_set(ArgSettings::TakesValue) { + if !option.is_takes_value_set() { return "".to_string(); } diff --git a/clap_complete/src/shells/zsh.rs b/clap_complete/src/shells/zsh.rs index 2d3a1597847..23154f09141 100644 --- a/clap_complete/src/shells/zsh.rs +++ b/clap_complete/src/shells/zsh.rs @@ -359,14 +359,14 @@ fn value_completion(arg: &Arg) -> Option { if let Some(values) = &arg.get_possible_values() { if values .iter() - .any(|value| !value.is_hidden() && value.get_help().is_some()) + .any(|value| !value.is_hide_set() && value.get_help().is_some()) { Some(format!( "(({}))", values .iter() .filter_map(|value| { - if value.is_hidden() { + if value.is_hide_set() { None } else { Some(format!( @@ -447,7 +447,7 @@ fn write_opts_of(p: &App, p_global: Option<&App>) -> String { let help = o.get_help().map_or(String::new(), escape_help); let conflicts = arg_conflicts(p, o, p_global); - let multiple = if o.is_set(ArgSettings::MultipleOccurrences) { + let multiple = if o.is_multiple_occurrences_set() { "*" } else { "" @@ -550,7 +550,7 @@ fn write_flags_of(p: &App, p_global: Option<&App>) -> String { let help = f.get_help().map_or(String::new(), escape_help); let conflicts = arg_conflicts(p, &f, p_global); - let multiple = if f.is_set(ArgSettings::MultipleOccurrences) { + let multiple = if f.is_multiple_occurrences_set() { "*" } else { "" @@ -628,11 +628,9 @@ fn write_positionals_of(p: &App) -> String { for arg in p.get_positionals() { debug!("write_positionals_of:iter: arg={}", arg.get_name()); - let cardinality = if arg.is_set(ArgSettings::MultipleValues) - || arg.is_set(ArgSettings::MultipleOccurrences) - { + let cardinality = if arg.is_multiple_values_set() || arg.is_multiple_occurrences_set() { "*:" - } else if !arg.is_set(ArgSettings::Required) { + } else if !arg.is_required_set() { ":" } else { "" diff --git a/clap_complete_fig/src/fig.rs b/clap_complete_fig/src/fig.rs index 924fce49741..8dec8b892c4 100644 --- a/clap_complete_fig/src/fig.rs +++ b/clap_complete_fig/src/fig.rs @@ -212,7 +212,7 @@ fn gen_options(app: &App, indent: usize) -> String { } fn gen_args(arg: &Arg, indent: usize) -> String { - if !arg.is_set(ArgSettings::TakesValue) { + if !arg.is_takes_value_set() { return "".to_string(); } @@ -225,7 +225,7 @@ fn gen_args(arg: &Arg, indent: usize) -> String { indent = indent )); - if arg.is_set(ArgSettings::MultipleValues) { + if arg.is_multiple_values_set() { buffer.push_str(&format!( "{:indent$}isVariadic: true,\n", "", @@ -233,7 +233,7 @@ fn gen_args(arg: &Arg, indent: usize) -> String { )); } - if !arg.is_set(ArgSettings::Required) { + if !arg.is_required_set() { buffer.push_str(&format!( "{:indent$}isOptional: true,\n", "", diff --git a/clap_mangen/src/lib.rs b/clap_mangen/src/lib.rs index 63ecc1487a4..8164ce5f5c9 100644 --- a/clap_mangen/src/lib.rs +++ b/clap_mangen/src/lib.rs @@ -259,8 +259,7 @@ fn app_has_version(app: &clap::App) -> bool { // Does the application have any command line arguments? fn app_has_arguments(app: &clap::App) -> bool { - app.get_arguments() - .any(|i| !i.is_set(clap::ArgSettings::Hidden)) + app.get_arguments().any(|i| !i.is_hide_set()) } // Does the application have any subcommands? diff --git a/clap_mangen/src/render.rs b/clap_mangen/src/render.rs index 9ffb792d148..14980fcad5c 100644 --- a/clap_mangen/src/render.rs +++ b/clap_mangen/src/render.rs @@ -1,4 +1,4 @@ -use clap::{AppSettings, ArgSettings}; +use clap::AppSettings; use roff::{bold, italic, roman, Inline, Roff}; pub(crate) fn subcommand_heading(app: &clap::App) -> String { @@ -81,10 +81,7 @@ pub(crate) fn synopsis(roff: &mut Roff, app: &clap::App) { } pub(crate) fn options(roff: &mut Roff, app: &clap::App) { - let items: Vec<_> = app - .get_arguments() - .filter(|i| !i.is_set(ArgSettings::Hidden)) - .collect(); + let items: Vec<_> = app.get_arguments().filter(|i| !i.is_hide_set()).collect(); for opt in items.iter().filter(|a| !a.is_positional()) { let mut body = vec![]; @@ -189,7 +186,7 @@ fn subcommand_markers(cmd: &clap::App) -> (&'static str, &'static str) { } fn option_markers(opt: &clap::Arg) -> (&'static str, &'static str) { - markers(opt.is_set(ArgSettings::Required)) + markers(opt.is_required_set()) } fn markers(required: bool) -> (&'static str, &'static str) { @@ -209,7 +206,7 @@ fn long_option(opt: &str) -> Inline { } fn option_environment(opt: &clap::Arg) -> Option> { - if opt.is_set(ArgSettings::HideEnv) { + if opt.is_hide_env_set() { return None; } else if let Some(env) = opt.get_env() { return Some(vec![ diff --git a/examples/multicall-busybox.rs b/examples/multicall-busybox.rs index 9f07aef195a..a206d4aee4a 100644 --- a/examples/multicall-busybox.rs +++ b/examples/multicall-busybox.rs @@ -24,7 +24,7 @@ fn main() { .exclusive(true) .takes_value(true) .default_missing_value("/usr/local/bin") - .use_delimiter(false), + .use_value_delimiter(false), ) .subcommands(applet_commands()), ) diff --git a/src/build/app/debug_asserts.rs b/src/build/app/debug_asserts.rs index f96c355490f..c3d7a5654d8 100644 --- a/src/build/app/debug_asserts.rs +++ b/src/build/app/debug_asserts.rs @@ -2,7 +2,7 @@ use crate::{ build::arg::{debug_asserts::assert_arg, ArgProvider}, mkeymap::KeyType, util::Id, - App, AppSettings, Arg, ArgSettings, ValueHint, + App, AppSettings, Arg, ValueHint, }; use std::cmp::Ordering; @@ -177,7 +177,7 @@ pub(crate) fn assert_app(app: &App) { ); } - if arg.is_set(ArgSettings::Last) { + if arg.is_last_set() { assert!( arg.long.is_none(), "App {}: Flags or Options cannot have last(true) set. '{}' has both a long and last(true) set.", @@ -193,7 +193,7 @@ pub(crate) fn assert_app(app: &App) { } assert!( - !(arg.is_set(ArgSettings::Required) && arg.get_global()), + !(arg.is_required_set() && arg.is_global_set()), "App {}: Global arguments cannot be required.\n\n\t'{}' is marked as both global and required", app.get_name(), arg.name @@ -463,9 +463,9 @@ fn _verify_positionals(app: &App) -> bool { // Either the final positional is required // Or the second to last has a terminator or .last(true) set - let ok = last.is_set(ArgSettings::Required) - || (second_to_last.terminator.is_some() || second_to_last.is_set(ArgSettings::Last)) - || last.is_set(ArgSettings::Last); + let ok = last.is_required_set() + || (second_to_last.terminator.is_some() || second_to_last.is_last_set()) + || last.is_last_set(); assert!( ok, "When using a positional argument with .multiple_values(true) that is *not the \ @@ -474,7 +474,7 @@ fn _verify_positionals(app: &App) -> bool { ); // We make sure if the second to last is Multiple the last is ArgSettings::Last - let ok = second_to_last.is_multiple() || last.is_set(ArgSettings::Last); + let ok = second_to_last.is_multiple() || last.is_last_set(); assert!( ok, "Only the last positional argument, or second to last positional \ @@ -485,12 +485,12 @@ fn _verify_positionals(app: &App) -> bool { let count = app .get_positionals() .filter(|p| { - p.settings.is_set(ArgSettings::MultipleOccurrences) - || (p.settings.is_set(ArgSettings::MultipleValues) && p.num_vals.is_none()) + p.is_multiple_occurrences_set() + || (p.is_multiple_values_set() && p.num_vals.is_none()) }) .count(); let ok = count <= 1 - || (last.is_set(ArgSettings::Last) + || (last.is_last_set() && last.is_multiple() && second_to_last.is_multiple() && count == 2); @@ -509,16 +509,16 @@ fn _verify_positionals(app: &App) -> bool { let mut foundx2 = false; for p in app.get_positionals() { - if foundx2 && !p.is_set(ArgSettings::Required) { + if foundx2 && !p.is_required_set() { assert!( - p.is_set(ArgSettings::Required), + p.is_required_set(), "Found non-required positional argument with a lower \ index than a required positional argument by two or more: {:?} \ index {:?}", p.name, p.index ); - } else if p.is_set(ArgSettings::Required) && !p.is_set(ArgSettings::Last) { + } else if p.is_required_set() && !p.is_last_set() { // Args that .last(true) don't count since they can be required and have // positionals with a lower index that aren't required // Imagine: prog [opt1] -- @@ -541,13 +541,13 @@ fn _verify_positionals(app: &App) -> bool { for p in (1..=num_p).rev().filter_map(|n| app.args.get(&n)) { if found { assert!( - p.is_set(ArgSettings::Required), + p.is_required_set(), "Found non-required positional argument with a lower \ index than a required positional argument: {:?} index {:?}", p.name, p.index ); - } else if p.is_set(ArgSettings::Required) && !p.is_set(ArgSettings::Last) { + } else if p.is_required_set() && !p.is_last_set() { // Args that .last(true) don't count since they can be required and have // positionals with a lower index that aren't required // Imagine: prog [opt1] -- @@ -560,15 +560,12 @@ fn _verify_positionals(app: &App) -> bool { } } assert!( - app.get_positionals() - .filter(|p| p.is_set(ArgSettings::Last)) - .count() - < 2, + app.get_positionals().filter(|p| p.is_last_set()).count() < 2, "Only one positional argument may have last(true) set. Found two." ); if app .get_positionals() - .any(|p| p.is_set(ArgSettings::Last) && p.is_set(ArgSettings::Required)) + .any(|p| p.is_last_set() && p.is_required_set()) && app.has_subcommands() && !app.is_set(AppSettings::SubcommandsNegateReqs) { diff --git a/src/build/app/mod.rs b/src/build/app/mod.rs index d439ba81ab6..b63621eb250 100644 --- a/src/build/app/mod.rs +++ b/src/build/app/mod.rs @@ -23,7 +23,7 @@ use os_str_bytes::RawOsStr; use yaml_rust::Yaml; // Internal -use crate::build::{arg::ArgProvider, Arg, ArgGroup, ArgPredicate, ArgSettings}; +use crate::build::{arg::ArgProvider, Arg, ArgGroup, ArgPredicate}; use crate::error::ErrorKind; use crate::error::Result as ClapResult; use crate::mkeymap::MKeyMap; @@ -2373,7 +2373,7 @@ impl<'help> App<'help> { /// Iterate through the *options*. pub fn get_opts(&self) -> impl Iterator> { self.get_arguments() - .filter(|a| a.is_set(ArgSettings::TakesValue) && !a.is_positional()) + .filter(|a| a.is_takes_value_set() && !a.is_positional()) } /// Get a list of all arguments the given argument conflicts with. @@ -2387,7 +2387,7 @@ impl<'help> App<'help> { /// this `App`. pub fn get_arg_conflicts_with(&self, arg: &Arg) -> Vec<&Arg<'help>> // FIXME: This could probably have been an iterator { - if arg.get_global() { + if arg.is_global_set() { self.get_global_arg_conflicts_with(arg) } else { arg.blacklist @@ -2708,7 +2708,7 @@ impl<'help> App<'help> { global_arg_vec.extend( self.args .args() - .filter(|a| a.get_global()) + .filter(|a| a.is_global_set()) .map(|ga| ga.id.clone()), ); if let Some((id, matches)) = matches.subcommand() { @@ -2783,7 +2783,7 @@ impl<'help> App<'help> { } // Figure out implied settings - if a.is_set(ArgSettings::Last) { + if a.is_last_set() { // if an arg has `Last` set, we need to imply DontCollapseArgsInUsage so that args // in the usage string don't get confused or left out. self.settings.set(AppSettings::DontCollapseArgsInUsage); @@ -2852,7 +2852,7 @@ impl<'help> App<'help> { debug!("App::_propagate_global_args:{}", self.name); for sc in &mut self.subcommands { - for a in self.args.args().filter(|a| a.get_global()) { + for a in self.args.args().filter(|a| a.is_global_set()) { let mut propagate = false; let is_generated = matches!( a.provider, diff --git a/src/build/app/settings.rs b/src/build/app/settings.rs index 4e3fd584f8d..16feb3caf22 100644 --- a/src/build/app/settings.rs +++ b/src/build/app/settings.rs @@ -256,7 +256,7 @@ pub enum AppSettings { /// was used. /// /// **NOTE:** The same thing can be done manually by setting the final positional argument to - /// [`Arg::use_delimiter(false)`]. Using this setting is safer, because it's easier to locate + /// [`Arg::use_value_delimiter(false)`]. Using this setting is safer, because it's easier to locate /// when making changes. /// /// # Examples @@ -268,7 +268,7 @@ pub enum AppSettings { /// .get_matches(); /// ``` /// - /// [`Arg::use_delimiter(false)`]: crate::Arg::use_delimiter() + /// [`Arg::use_value_delimiter(false)`]: crate::Arg::use_value_delimiter() DontDelimitTrailingValues, /// Allow partial matches of long arguments or their [aliases]. diff --git a/src/build/arg/debug_asserts.rs b/src/build/arg/debug_asserts.rs index 60bfe0a4f90..e4e1e843153 100644 --- a/src/build/arg/debug_asserts.rs +++ b/src/build/arg/debug_asserts.rs @@ -1,4 +1,4 @@ -use crate::{Arg, ArgSettings, ValueHint}; +use crate::{Arg, ValueHint}; pub(crate) fn assert_arg(arg: &Arg) { debug!("Arg::_debug_asserts:{}", arg.name); @@ -13,14 +13,14 @@ pub(crate) fn assert_arg(arg: &Arg) { if arg.value_hint != ValueHint::Unknown { assert!( - arg.is_set(ArgSettings::TakesValue), + arg.is_takes_value_set(), "Argument '{}' has value hint but takes no value", arg.name ); if arg.value_hint == ValueHint::CommandWithArguments { assert!( - arg.is_set(ArgSettings::MultipleValues), + arg.is_multiple_values_set(), "Argument '{}' uses hint CommandWithArguments and must accept multiple values", arg.name ) @@ -35,7 +35,7 @@ pub(crate) fn assert_arg(arg: &Arg) { ); } - if arg.is_set(ArgSettings::Required) { + if arg.is_required_set() { assert!( arg.default_vals.is_empty(), "Argument '{}' is required and can't have a default value", @@ -61,16 +61,14 @@ pub(crate) fn assert_arg(arg: &Arg) { } fn assert_arg_flags(arg: &Arg) { - use ArgSettings::*; - macro_rules! checker { ($a:ident requires $($b:ident)|+) => { - if arg.is_set($a) { + if arg.$a() { let mut s = String::new(); $( - if !arg.is_set($b) { - s.push_str(&format!(" ArgSettings::{} is required when ArgSettings::{} is set.\n", std::stringify!($b), std::stringify!($a))); + if !arg.$b() { + s.push_str(&format!(" Arg::{} is required when Arg::{} is set.\n", std::stringify!($b), std::stringify!($a))); } )+ @@ -81,16 +79,17 @@ fn assert_arg_flags(arg: &Arg) { } } - checker!(ForbidEmptyValues requires TakesValue); - checker!(RequireDelimiter requires TakesValue | UseValueDelimiter); - checker!(HidePossibleValues requires TakesValue); - checker!(AllowHyphenValues requires TakesValue); - checker!(RequireEquals requires TakesValue); - checker!(Last requires TakesValue); - checker!(HideDefaultValue requires TakesValue); - checker!(MultipleValues requires TakesValue); - checker!(IgnoreCase requires TakesValue); - checker!(AllowInvalidUtf8 requires TakesValue); + checker!(is_forbid_empty_values_set requires is_takes_value_set); + checker!(is_require_value_delimiter_set requires is_takes_value_set); + checker!(is_require_value_delimiter_set requires is_use_value_delimiter_set); + checker!(is_hide_possible_values_set requires is_takes_value_set); + checker!(is_allow_hyphen_values_set requires is_takes_value_set); + checker!(is_require_equals_set requires is_takes_value_set); + checker!(is_last_set requires is_takes_value_set); + checker!(is_hide_default_value_set requires is_takes_value_set); + checker!(is_multiple_values_set requires is_takes_value_set); + checker!(is_ignore_case_set requires is_takes_value_set); + checker!(is_allow_invalid_utf8_set requires is_takes_value_set); } fn assert_defaults<'d>( @@ -103,7 +102,7 @@ fn assert_defaults<'d>( if !arg.possible_vals.is_empty() { assert!( arg.possible_vals.iter().any(|possible_val| { - possible_val.matches(default_s, arg.is_set(ArgSettings::IgnoreCase)) + possible_val.matches(default_s, arg.is_ignore_case_set()) }), "Argument `{}`'s {}={} doesn't match possible values", arg.name, diff --git a/src/build/arg/mod.rs b/src/build/arg/mod.rs index 5b61601208f..28adc54f1cb 100644 --- a/src/build/arg/mod.rs +++ b/src/build/arg/mod.rs @@ -887,6 +887,7 @@ impl<'help> Arg<'help> { /// /// [`ArgSettings`]: crate::ArgSettings #[inline] + // TODO: Deprecate pub fn is_set(&self, s: ArgSettings) -> bool { self.settings.is_set(s) } @@ -913,6 +914,7 @@ impl<'help> Arg<'help> { /// ``` #[inline] #[must_use] + // TODO: Deprecate pub fn setting(mut self, setting: F) -> Self where F: Into, @@ -943,6 +945,7 @@ impl<'help> Arg<'help> { /// ``` #[inline] #[must_use] + // TODO: Deprecate pub fn unset_setting(mut self, setting: F) -> Self where F: Into, @@ -966,7 +969,7 @@ impl<'help> Arg<'help> { /// `--option=val1,val2,val3` is three values for the `--option` argument. If you wish to /// change the delimiter to another character you can use [`Arg::value_delimiter(char)`], /// alternatively you can turn delimiting values **OFF** by using - /// [`Arg::use_delimiter(false)`][Arg::use_delimiter] + /// [`Arg::use_value_delimiter(false)`][Arg::use_value_delimiter] /// /// # Examples /// @@ -2098,7 +2101,7 @@ impl<'help> Arg<'help> { /// let delims = App::new("prog") /// .arg(Arg::new("option") /// .long("option") - /// .use_delimiter(true) + /// .use_value_delimiter(true) /// .takes_value(true)) /// .get_matches_from(vec![ /// "prog", "--option=val1,val2,val3", @@ -2128,7 +2131,7 @@ impl<'help> Arg<'help> { /// [`Arg::value_delimiter`]: Arg::value_delimiter() #[inline] #[must_use] - pub fn use_delimiter(mut self, yes: bool) -> Self { + pub fn use_value_delimiter(mut self, yes: bool) -> Self { if yes { if self.val_delim.is_none() { self.val_delim = Some(','); @@ -2141,9 +2144,65 @@ impl<'help> Arg<'help> { } } + /// Specifies that an argument should allow grouping of multiple values via a + /// delimiter. + /// + /// i.e. should `--option=val1,val2,val3` be parsed as three values (`val1`, `val2`, + /// and `val3`) or as a single value (`val1,val2,val3`). Defaults to using `,` (comma) as the + /// value delimiter for all arguments that accept values (options and positional arguments) + /// + /// **NOTE:** When this setting is used, it will default [`Arg::value_delimiter`] + /// to the comma `,`. + /// + /// **NOTE:** Implicitly sets [`Arg::takes_value`] + /// + /// # Examples + /// + /// The following example shows the default behavior. + /// + /// ```rust + /// # use clap::{App, Arg}; + /// let delims = App::new("prog") + /// .arg(Arg::new("option") + /// .long("option") + /// .use_delimiter(true) + /// .takes_value(true)) + /// .get_matches_from(vec![ + /// "prog", "--option=val1,val2,val3", + /// ]); + /// + /// assert!(delims.is_present("option")); + /// assert_eq!(delims.occurrences_of("option"), 1); + /// assert_eq!(delims.values_of("option").unwrap().collect::>(), ["val1", "val2", "val3"]); + /// ``` + /// The next example shows the difference when turning delimiters off. This is the default + /// behavior + /// + /// ```rust + /// # use clap::{App, Arg}; + /// let nodelims = App::new("prog") + /// .arg(Arg::new("option") + /// .long("option") + /// .takes_value(true)) + /// .get_matches_from(vec![ + /// "prog", "--option=val1,val2,val3", + /// ]); + /// + /// assert!(nodelims.is_present("option")); + /// assert_eq!(nodelims.occurrences_of("option"), 1); + /// assert_eq!(nodelims.value_of("option").unwrap(), "val1,val2,val3"); + /// ``` + /// [`Arg::value_delimiter`]: Arg::value_delimiter() + #[inline] + #[must_use] + // TODO: Deprecate + pub fn use_delimiter(self, yes: bool) -> Self { + self.use_value_delimiter(yes) + } + /// Separator between the arguments values, defaults to `,` (comma). /// - /// **NOTE:** implicitly sets [`Arg::use_delimiter(true)`] + /// **NOTE:** implicitly sets [`Arg::use_value_delimiter(true)`] /// /// **NOTE:** implicitly sets [`Arg::takes_value(true)`] /// @@ -2162,13 +2221,13 @@ impl<'help> Arg<'help> { /// /// assert_eq!(m.values_of("config").unwrap().collect::>(), ["val1", "val2", "val3"]) /// ``` - /// [`Arg::use_delimiter(true)`]: Arg::use_delimiter() + /// [`Arg::use_value_delimiter(true)`]: Arg::use_value_delimiter() /// [`Arg::takes_value(true)`]: Arg::takes_value() #[inline] #[must_use] pub fn value_delimiter(mut self, d: char) -> Self { self.val_delim = Some(d); - self.takes_value(true).use_delimiter(true) + self.takes_value(true).use_value_delimiter(true) } /// Specifies that *multiple values* may only be set using the delimiter. @@ -2179,7 +2238,7 @@ impl<'help> Arg<'help> { /// /// **NOTE:** The default is `false`. /// - /// **NOTE:** Setting this requires [`Arg::use_delimiter`] and + /// **NOTE:** Setting this requires [`Arg::use_value_delimiter`] and /// [`Arg::takes_value`] /// /// **NOTE:** It's a good idea to inform the user that use of a delimiter is required, either @@ -2196,7 +2255,7 @@ impl<'help> Arg<'help> { /// .arg(Arg::new("opt") /// .short('o') /// .takes_value(true) - /// .use_delimiter(true) + /// .use_value_delimiter(true) /// .require_delimiter(true) /// .multiple_values(true)) /// .get_matches_from(vec![ @@ -2215,7 +2274,7 @@ impl<'help> Arg<'help> { /// .arg(Arg::new("opt") /// .short('o') /// .takes_value(true) - /// .use_delimiter(true) + /// .use_value_delimiter(true) /// .require_delimiter(true)) /// .try_get_matches_from(vec![ /// "prog", "-o", "val1", "val2", "val3", @@ -2249,7 +2308,7 @@ impl<'help> Arg<'help> { /// ``` #[inline] #[must_use] - pub fn require_delimiter(self, yes: bool) -> Self { + pub fn require_value_delimiter(self, yes: bool) -> Self { if yes { self.setting(ArgSettings::RequireDelimiter) } else { @@ -2257,6 +2316,89 @@ impl<'help> Arg<'help> { } } + /// Specifies that *multiple values* may only be set using the delimiter. + /// + /// This means if an option is encountered, and no delimiter is found, it is assumed that no + /// additional values for that option follow. This is unlike the default, where it is generally + /// assumed that more values will follow regardless of whether or not a delimiter is used. + /// + /// **NOTE:** The default is `false`. + /// + /// **NOTE:** Setting this requires [`Arg::use_value_delimiter`] and + /// [`Arg::takes_value`] + /// + /// **NOTE:** It's a good idea to inform the user that use of a delimiter is required, either + /// through help text or other means. + /// + /// # Examples + /// + /// These examples demonstrate what happens when `require_delimiter(true)` is used. Notice + /// everything works in this first example, as we use a delimiter, as expected. + /// + /// ```rust + /// # use clap::{App, Arg}; + /// let delims = App::new("prog") + /// .arg(Arg::new("opt") + /// .short('o') + /// .takes_value(true) + /// .use_value_delimiter(true) + /// .require_delimiter(true) + /// .multiple_values(true)) + /// .get_matches_from(vec![ + /// "prog", "-o", "val1,val2,val3", + /// ]); + /// + /// assert!(delims.is_present("opt")); + /// assert_eq!(delims.values_of("opt").unwrap().collect::>(), ["val1", "val2", "val3"]); + /// ``` + /// + /// In this next example, we will *not* use a delimiter. Notice it's now an error. + /// + /// ```rust + /// # use clap::{App, Arg, ErrorKind}; + /// let res = App::new("prog") + /// .arg(Arg::new("opt") + /// .short('o') + /// .takes_value(true) + /// .use_value_delimiter(true) + /// .require_delimiter(true)) + /// .try_get_matches_from(vec![ + /// "prog", "-o", "val1", "val2", "val3", + /// ]); + /// + /// assert!(res.is_err()); + /// let err = res.unwrap_err(); + /// assert_eq!(err.kind(), ErrorKind::UnknownArgument); + /// ``` + /// + /// What's happening is `-o` is getting `val1`, and because delimiters are required yet none + /// were present, it stops parsing `-o`. At this point it reaches `val2` and because no + /// positional arguments have been defined, it's an error of an unexpected argument. + /// + /// In this final example, we contrast the above with `clap`'s default behavior where the above + /// is *not* an error. + /// + /// ```rust + /// # use clap::{App, Arg}; + /// let delims = App::new("prog") + /// .arg(Arg::new("opt") + /// .short('o') + /// .takes_value(true) + /// .multiple_values(true)) + /// .get_matches_from(vec![ + /// "prog", "-o", "val1", "val2", "val3", + /// ]); + /// + /// assert!(delims.is_present("opt")); + /// assert_eq!(delims.values_of("opt").unwrap().collect::>(), ["val1", "val2", "val3"]); + /// ``` + #[inline] + #[must_use] + // TODO: Deprecate + pub fn require_delimiter(self, yes: bool) -> Self { + self.require_value_delimiter(yes) + } + /// Sentinel to **stop** parsing multiple values of a give argument. /// /// By default when @@ -2690,7 +2832,7 @@ impl<'help> Arg<'help> { /// .env("MY_FLAG_MULTI") /// .takes_value(true) /// .multiple_values(true) - /// .use_delimiter(true)) + /// .use_value_delimiter(true)) /// .get_matches_from(vec![ /// "prog" /// ]); @@ -2701,7 +2843,7 @@ impl<'help> Arg<'help> { /// [`ArgMatches::value_of`]: crate::ArgMatches::value_of() /// [`ArgMatches::is_present`]: ArgMatches::is_present() /// [`Arg::takes_value(true)`]: Arg::takes_value() - /// [`Arg::use_delimiter(true)`]: Arg::use_delimiter() + /// [`Arg::use_value_delimiter(true)`]: Arg::use_value_delimiter() #[cfg(feature = "env")] #[inline] #[must_use] @@ -4626,8 +4768,9 @@ impl<'help> Arg<'help> { } /// Get information on if this argument is global or not + // TODO: Deprecate pub fn get_global(&self) -> bool { - self.is_set(ArgSettings::Global) + self.is_global_set() } /// Get the environment variable name specified for this argument, if any @@ -4673,6 +4816,118 @@ impl<'help> Arg<'help> { pub fn is_positional(&self) -> bool { self.long.is_none() && self.short.is_none() } + + /// Reports whether [`Arg::required`] is set + pub fn is_required_set(&self) -> bool { + self.is_set(ArgSettings::Required) + } + + /// Report whether [`Arg::multiple_values`] is set + pub fn is_multiple_values_set(&self) -> bool { + self.is_set(ArgSettings::MultipleValues) + } + + /// Report whether [`Arg::multiple_occurrences`] is set + pub fn is_multiple_occurrences_set(&self) -> bool { + self.is_set(ArgSettings::MultipleOccurrences) + } + + /// Report whether [`Arg::is_takes_value_set`] is set + pub fn is_takes_value_set(&self) -> bool { + self.is_set(ArgSettings::TakesValue) + } + + /// Report whether [`Arg::allow_hyphen_values`] is set + pub fn is_allow_hyphen_values_set(&self) -> bool { + self.is_set(ArgSettings::AllowHyphenValues) + } + + /// Report whether [`Arg::forbid_empty_values`] is set + pub fn is_forbid_empty_values_set(&self) -> bool { + self.is_set(ArgSettings::ForbidEmptyValues) + } + + /// Report whether [`Arg::is_allow_invalid_utf8_set`] is set + pub fn is_allow_invalid_utf8_set(&self) -> bool { + self.is_set(ArgSettings::AllowInvalidUtf8) + } + + /// Report whether [`Arg::global`] is set + pub fn is_global_set(&self) -> bool { + self.is_set(ArgSettings::Global) + } + + /// Report whether [`Arg::next_line_help`] is set + pub fn is_next_line_help_set(&self) -> bool { + self.is_set(ArgSettings::NextLineHelp) + } + + /// Report whether [`Arg::hide`] is set + pub fn is_hide_set(&self) -> bool { + self.is_set(ArgSettings::Hidden) + } + + /// Report whether [`Arg::hide_default_value`] is set + pub fn is_hide_default_value_set(&self) -> bool { + self.is_set(ArgSettings::HideDefaultValue) + } + + /// Report whether [`Arg::hide_possible_values`] is set + pub fn is_hide_possible_values_set(&self) -> bool { + self.is_set(ArgSettings::HidePossibleValues) + } + + /// Report whether [`Arg::hide_env`] is set + #[cfg(feature = "env")] + pub fn is_hide_env_set(&self) -> bool { + self.is_set(ArgSettings::HideEnv) + } + + /// Report whether [`Arg::hide_env_values`] is set + #[cfg(feature = "env")] + pub fn is_hide_env_values_set(&self) -> bool { + self.is_set(ArgSettings::HideEnvValues) + } + + /// Report whether [`Arg::hide_short_help`] is set + pub fn is_hide_short_help_set(&self) -> bool { + self.is_set(ArgSettings::HiddenShortHelp) + } + + /// Report whether [`Arg::hide_long_help`] is set + pub fn is_hide_long_help_set(&self) -> bool { + self.is_set(ArgSettings::HiddenLongHelp) + } + + /// Report whether [`Arg::use_value_delimiter`] is set + pub fn is_use_value_delimiter_set(&self) -> bool { + self.is_set(ArgSettings::UseValueDelimiter) + } + + /// Report whether [`Arg::require_value_delimiter`] is set + pub fn is_require_value_delimiter_set(&self) -> bool { + self.is_set(ArgSettings::RequireDelimiter) + } + + /// Report whether [`Arg::require_equals`] is set + pub fn is_require_equals_set(&self) -> bool { + self.is_set(ArgSettings::RequireEquals) + } + + /// Reports whether [`Arg::exclusive`] is set + pub fn is_exclusive_set(&self) -> bool { + self.is_set(ArgSettings::Exclusive) + } + + /// Reports whether [`Arg::last`] is set + pub fn is_last_set(&self) -> bool { + self.is_set(ArgSettings::Last) + } + + /// Reports whether [`Arg::ignore_case`] is set + pub fn is_ignore_case_set(&self) -> bool { + self.is_set(ArgSettings::IgnoreCase) + } } /// Deprecated @@ -4883,8 +5138,7 @@ impl<'help> Arg<'help> { self.settings.set(ArgSettings::TakesValue); } - if (self.is_set(ArgSettings::UseValueDelimiter) - || self.is_set(ArgSettings::RequireDelimiter)) + if (self.is_use_value_delimiter_set() || self.is_require_value_delimiter_set()) && self.val_delim.is_none() { self.val_delim = Some(','); @@ -4901,7 +5155,7 @@ impl<'help> Arg<'help> { } let self_id = self.id.clone(); - if self.is_positional() || self.is_set(ArgSettings::MultipleOccurrences) { + if self.is_positional() || self.is_multiple_occurrences_set() { // Remove self-overrides where they don't make sense. // // We can evaluate switching this to a debug assert at a later time (though it will @@ -4917,16 +5171,13 @@ impl<'help> Arg<'help> { } pub(crate) fn longest_filter(&self) -> bool { - self.is_set(ArgSettings::TakesValue) || self.long.is_some() || self.short.is_none() + self.is_takes_value_set() || self.long.is_some() || self.short.is_none() } // Used for positionals when printing pub(crate) fn multiple_str(&self) -> &str { let mult_vals = self.val_names.len() > 1; - if (self.is_set(ArgSettings::MultipleValues) - || self.is_set(ArgSettings::MultipleOccurrences)) - && !mult_vals - { + if (self.is_multiple_values_set() || self.is_multiple_occurrences_set()) && !mult_vals { "..." } else { "" @@ -4936,7 +5187,7 @@ impl<'help> Arg<'help> { // Used for positionals when printing pub(crate) fn name_no_brackets(&self) -> Cow { debug!("Arg::name_no_brackets:{}", self.name); - let delim = if self.is_set(ArgSettings::RequireDelimiter) { + let delim = if self.is_require_value_delimiter_set() { self.val_delim.expect(INTERNAL_ERROR_MSG) } else { ' ' @@ -4964,7 +5215,7 @@ impl<'help> Arg<'help> { /// Either multiple values or occurrences pub(crate) fn is_multiple(&self) -> bool { - self.is_set(ArgSettings::MultipleValues) | self.is_set(ArgSettings::MultipleOccurrences) + self.is_multiple_values_set() | self.is_multiple_occurrences_set() } pub(crate) fn get_display_order(&self) -> usize { @@ -5007,9 +5258,9 @@ impl<'help> Display for Arg<'help> { write!(f, "-{}", s)?; } let mut need_closing_bracket = false; - if !self.is_positional() && self.is_set(ArgSettings::TakesValue) { + if !self.is_positional() && self.is_takes_value_set() { let is_optional_val = self.min_vals == Some(0); - let sep = if self.is_set(ArgSettings::RequireEquals) { + let sep = if self.is_require_equals_set() { if is_optional_val { need_closing_bracket = true; "[=" @@ -5024,7 +5275,7 @@ impl<'help> Display for Arg<'help> { }; f.write_str(sep)?; } - if self.is_set(ArgSettings::TakesValue) || self.is_positional() { + if self.is_takes_value_set() || self.is_positional() { display_arg_val(self, |s, _| f.write_str(s))?; } if need_closing_bracket { @@ -5110,9 +5361,9 @@ pub(crate) fn display_arg_val(arg: &Arg, mut write: F) -> Result<(), E> where F: FnMut(&str, bool) -> Result, { - let mult_val = arg.is_set(ArgSettings::MultipleValues); - let mult_occ = arg.is_set(ArgSettings::MultipleOccurrences); - let delim = if arg.is_set(ArgSettings::RequireDelimiter) { + let mult_val = arg.is_multiple_values_set(); + let mult_occ = arg.is_multiple_occurrences_set(); + let delim = if arg.is_require_value_delimiter_set() { arg.val_delim.expect(INTERNAL_ERROR_MSG) } else { ' ' diff --git a/src/build/arg/possible_value.rs b/src/build/arg/possible_value.rs index d28f3aea24f..9b10c76e970 100644 --- a/src/build/arg/possible_value.rs +++ b/src/build/arg/possible_value.rs @@ -150,7 +150,14 @@ impl<'help> PossibleValue<'help> { /// Should the value be hidden from help messages and completion #[inline] + // TODO: Deprecate pub fn is_hidden(&self) -> bool { + self.is_hide_set() + } + + /// Report if [`PossibleValue::hide`] is set + #[inline] + pub fn is_hide_set(&self) -> bool { self.hide } diff --git a/src/build/arg/settings.rs b/src/build/arg/settings.rs index 048944bb514..6cf9edf2e70 100644 --- a/src/build/arg/settings.rs +++ b/src/build/arg/settings.rs @@ -26,6 +26,7 @@ impl Default for ArgFlags { /// [`Arg::is_set`]: crate::Arg::is_set() #[derive(Debug, PartialEq, Copy, Clone)] #[non_exhaustive] +// TODO: Deprecate pub enum ArgSettings { /// Specifies that an arg must be used Required, diff --git a/src/build/usage_parser.rs b/src/build/usage_parser.rs index db8f5003b85..9d49ecfda5e 100644 --- a/src/build/usage_parser.rs +++ b/src/build/usage_parser.rs @@ -171,7 +171,7 @@ impl<'help> UsageParser<'help> { if dot_counter == 3 { debug!("UsageParser::multiple: setting multiple"); arg.settings.set(ArgSettings::MultipleOccurrences); - if arg.is_set(ArgSettings::TakesValue) { + if arg.is_takes_value_set() { arg.settings.set(ArgSettings::MultipleValues); arg.settings.set(ArgSettings::UseValueDelimiter); arg.val_delim.get_or_insert(','); @@ -253,7 +253,7 @@ mod test { assert_eq!(a.short.unwrap(), 'f'); assert!(a.long.is_none()); assert_eq!(a.help.unwrap(), "some help info"); - assert!(!a.is_set(ArgSettings::MultipleOccurrences)); + assert!(!a.is_multiple_occurrences_set()); assert!(a.val_names.is_empty()); let a = Arg::from_usage("[flag] --flag 'some help info'"); @@ -261,7 +261,7 @@ mod test { assert_eq!(a.long.unwrap(), "flag"); assert!(a.short.is_none()); assert_eq!(a.help.unwrap(), "some help info"); - assert!(!a.is_set(ArgSettings::MultipleOccurrences)); + assert!(!a.is_multiple_occurrences_set()); assert!(a.val_names.is_empty()); let a = Arg::from_usage("--flag 'some help info'"); @@ -269,7 +269,7 @@ mod test { assert_eq!(a.long.unwrap(), "flag"); assert!(a.short.is_none()); assert_eq!(a.help.unwrap(), "some help info"); - assert!(!a.is_set(ArgSettings::MultipleOccurrences)); + assert!(!a.is_multiple_occurrences_set()); assert!(a.val_names.is_empty()); let a = Arg::from_usage("[flag] -f --flag 'some help info'"); @@ -277,7 +277,7 @@ mod test { assert_eq!(a.short.unwrap(), 'f'); assert_eq!(a.long.unwrap(), "flag"); assert_eq!(a.help.unwrap(), "some help info"); - assert!(!a.is_set(ArgSettings::MultipleOccurrences)); + assert!(!a.is_multiple_occurrences_set()); assert!(a.val_names.is_empty()); let a = Arg::from_usage("[flag] -f... 'some help info'"); @@ -285,7 +285,7 @@ mod test { assert_eq!(a.short.unwrap(), 'f'); assert!(a.long.is_none()); assert_eq!(a.help.unwrap(), "some help info"); - assert!(a.is_set(ArgSettings::MultipleOccurrences)); + assert!(a.is_multiple_occurrences_set()); assert!(a.val_names.is_empty()); let a = Arg::from_usage("[flag] -f --flag... 'some help info'"); @@ -293,7 +293,7 @@ mod test { assert_eq!(a.long.unwrap(), "flag"); assert_eq!(a.short.unwrap(), 'f'); assert_eq!(a.help.unwrap(), "some help info"); - assert!(a.is_set(ArgSettings::MultipleOccurrences)); + assert!(a.is_multiple_occurrences_set()); assert!(a.val_names.is_empty()); let a = Arg::from_usage("-f --flag... 'some help info'"); @@ -301,7 +301,7 @@ mod test { assert_eq!(a.long.unwrap(), "flag"); assert_eq!(a.short.unwrap(), 'f'); assert_eq!(a.help.unwrap(), "some help info"); - assert!(a.is_set(ArgSettings::MultipleOccurrences)); + assert!(a.is_multiple_occurrences_set()); assert!(a.val_names.is_empty()); let a = Arg::from_usage("--flags"); @@ -312,7 +312,7 @@ mod test { let a = Arg::from_usage("--flags..."); assert_eq!(a.name, "flags"); assert_eq!(a.long.unwrap(), "flags"); - assert!(a.is_set(ArgSettings::MultipleOccurrences)); + assert!(a.is_multiple_occurrences_set()); assert!(a.val_names.is_empty()); let a = Arg::from_usage("[flags] -f"); @@ -323,7 +323,7 @@ mod test { let a = Arg::from_usage("[flags] -f..."); assert_eq!(a.name, "flags"); assert_eq!(a.short.unwrap(), 'f'); - assert!(a.is_set(ArgSettings::MultipleOccurrences)); + assert!(a.is_multiple_occurrences_set()); assert!(a.val_names.is_empty()); let a = Arg::from_usage("-f 'some help info'"); @@ -331,7 +331,7 @@ mod test { assert_eq!(a.short.unwrap(), 'f'); assert!(a.long.is_none()); assert_eq!(a.help.unwrap(), "some help info"); - assert!(!a.is_set(ArgSettings::MultipleOccurrences)); + assert!(!a.is_multiple_occurrences_set()); assert!(a.val_names.is_empty()); let a = Arg::from_usage("-f"); @@ -342,7 +342,7 @@ mod test { let a = Arg::from_usage("-f..."); assert_eq!(a.name, "f"); assert_eq!(a.short.unwrap(), 'f'); - assert!(a.is_set(ArgSettings::MultipleOccurrences)); + assert!(a.is_multiple_occurrences_set()); assert!(a.val_names.is_empty()); } @@ -354,10 +354,10 @@ mod test { assert_eq!(a.short.unwrap(), 'o'); assert!(a.long.is_none()); assert_eq!(a.help.unwrap(), "some help info"); - assert!(!a.is_set(ArgSettings::MultipleOccurrences)); - assert!(!a.is_set(ArgSettings::MultipleValues)); - assert!(a.is_set(ArgSettings::TakesValue)); - assert!(!a.is_set(ArgSettings::Required)); + assert!(!a.is_multiple_occurrences_set()); + assert!(!a.is_multiple_values_set()); + assert!(a.is_takes_value_set()); + assert!(!a.is_required_set()); assert_eq!(a.val_names.iter().collect::>(), [&"opt"]); } @@ -368,10 +368,10 @@ mod test { assert_eq!(a.short.unwrap(), 'o'); assert!(a.long.is_none()); assert_eq!(a.help.unwrap(), "some help info"); - assert!(!a.is_set(ArgSettings::MultipleOccurrences)); - assert!(!a.is_set(ArgSettings::MultipleValues)); - assert!(a.is_set(ArgSettings::TakesValue)); - assert!(!a.is_set(ArgSettings::Required)); + assert!(!a.is_multiple_occurrences_set()); + assert!(!a.is_multiple_values_set()); + assert!(a.is_takes_value_set()); + assert!(!a.is_required_set()); assert_eq!(a.val_names.iter().collect::>(), [&"opt"]); } @@ -382,10 +382,10 @@ mod test { assert_eq!(a.short.unwrap(), 'o'); assert!(a.long.is_none()); assert_eq!(a.help.unwrap(), "some help info"); - assert!(!a.is_set(ArgSettings::MultipleOccurrences)); - assert!(!a.is_set(ArgSettings::MultipleValues)); - assert!(a.is_set(ArgSettings::TakesValue)); - assert!(a.is_set(ArgSettings::Required)); + assert!(!a.is_multiple_occurrences_set()); + assert!(!a.is_multiple_values_set()); + assert!(a.is_takes_value_set()); + assert!(a.is_required_set()); assert_eq!(a.val_names.iter().collect::>(), [&"opt"]); } @@ -396,10 +396,10 @@ mod test { assert_eq!(a.short.unwrap(), 'o'); assert!(a.long.is_none()); assert_eq!(a.help.unwrap(), "some help info"); - assert!(!a.is_set(ArgSettings::MultipleOccurrences)); - assert!(!a.is_set(ArgSettings::MultipleValues)); - assert!(a.is_set(ArgSettings::TakesValue)); - assert!(a.is_set(ArgSettings::Required)); + assert!(!a.is_multiple_occurrences_set()); + assert!(!a.is_multiple_values_set()); + assert!(a.is_takes_value_set()); + assert!(a.is_required_set()); assert_eq!(a.val_names.iter().collect::>(), [&"opt"]); } @@ -410,10 +410,10 @@ mod test { assert_eq!(a.short.unwrap(), 'o'); assert!(a.long.is_none()); assert_eq!(a.help.unwrap(), "some help info"); - assert!(a.is_set(ArgSettings::MultipleOccurrences)); - assert!(a.is_set(ArgSettings::MultipleValues)); - assert!(a.is_set(ArgSettings::TakesValue)); - assert!(!a.is_set(ArgSettings::Required)); + assert!(a.is_multiple_occurrences_set()); + assert!(a.is_multiple_values_set()); + assert!(a.is_takes_value_set()); + assert!(!a.is_required_set()); assert_eq!(a.val_names.iter().collect::>(), [&"opt"]); } @@ -424,10 +424,10 @@ mod test { assert_eq!(a.short.unwrap(), 'o'); assert!(a.long.is_none()); assert_eq!(a.help.unwrap(), "some help info"); - assert!(a.is_set(ArgSettings::MultipleOccurrences)); - assert!(!a.is_set(ArgSettings::MultipleValues)); - assert!(a.is_set(ArgSettings::TakesValue)); - assert!(!a.is_set(ArgSettings::Required)); + assert!(a.is_multiple_occurrences_set()); + assert!(!a.is_multiple_values_set()); + assert!(a.is_takes_value_set()); + assert!(!a.is_required_set()); assert_eq!(a.val_names.iter().collect::>(), [&"opt"]); } @@ -438,10 +438,10 @@ mod test { assert_eq!(a.short.unwrap(), 'o'); assert!(a.long.is_none()); assert_eq!(a.help.unwrap(), "some help info"); - assert!(a.is_set(ArgSettings::MultipleOccurrences)); - assert!(a.is_set(ArgSettings::MultipleValues)); - assert!(a.is_set(ArgSettings::TakesValue)); - assert!(!a.is_set(ArgSettings::Required)); + assert!(a.is_multiple_occurrences_set()); + assert!(a.is_multiple_values_set()); + assert!(a.is_takes_value_set()); + assert!(!a.is_required_set()); assert_eq!(a.val_names.iter().collect::>(), [&"opt"]); } @@ -452,10 +452,10 @@ mod test { assert_eq!(a.short.unwrap(), 'o'); assert!(a.long.is_none()); assert_eq!(a.help.unwrap(), "some help info"); - assert!(a.is_set(ArgSettings::MultipleOccurrences)); - assert!(a.is_set(ArgSettings::MultipleValues)); - assert!(a.is_set(ArgSettings::TakesValue)); - assert!(a.is_set(ArgSettings::Required)); + assert!(a.is_multiple_occurrences_set()); + assert!(a.is_multiple_values_set()); + assert!(a.is_takes_value_set()); + assert!(a.is_required_set()); assert_eq!(a.val_names.iter().collect::>(), [&"opt"]); } @@ -466,10 +466,10 @@ mod test { assert_eq!(a.short.unwrap(), 'o'); assert!(a.long.is_none()); assert_eq!(a.help.unwrap(), "some help info"); - assert!(a.is_set(ArgSettings::MultipleOccurrences)); - assert!(!a.is_set(ArgSettings::MultipleValues)); - assert!(a.is_set(ArgSettings::TakesValue)); - assert!(a.is_set(ArgSettings::Required)); + assert!(a.is_multiple_occurrences_set()); + assert!(!a.is_multiple_values_set()); + assert!(a.is_takes_value_set()); + assert!(a.is_required_set()); assert_eq!(a.val_names.iter().collect::>(), [&"opt"]); } @@ -480,10 +480,10 @@ mod test { assert_eq!(a.short.unwrap(), 'o'); assert!(a.long.is_none()); assert_eq!(a.help.unwrap(), "some help info"); - assert!(a.is_set(ArgSettings::MultipleOccurrences)); - assert!(a.is_set(ArgSettings::MultipleValues)); - assert!(a.is_set(ArgSettings::TakesValue)); - assert!(a.is_set(ArgSettings::Required)); + assert!(a.is_multiple_occurrences_set()); + assert!(a.is_multiple_values_set()); + assert!(a.is_takes_value_set()); + assert!(a.is_required_set()); assert_eq!(a.val_names.iter().collect::>(), [&"opt"]); } @@ -494,10 +494,10 @@ mod test { assert_eq!(a.long.unwrap(), "opt"); assert!(a.short.is_none()); assert_eq!(a.help.unwrap(), "some help info"); - assert!(!a.is_set(ArgSettings::MultipleOccurrences)); - assert!(!a.is_set(ArgSettings::MultipleValues)); - assert!(a.is_set(ArgSettings::TakesValue)); - assert!(!a.is_set(ArgSettings::Required)); + assert!(!a.is_multiple_occurrences_set()); + assert!(!a.is_multiple_values_set()); + assert!(a.is_takes_value_set()); + assert!(!a.is_required_set()); assert_eq!(a.val_names.iter().collect::>(), [&"opt"]); } @@ -508,10 +508,10 @@ mod test { assert_eq!(a.long.unwrap(), "opt"); assert!(a.short.is_none()); assert_eq!(a.help.unwrap(), "some help info"); - assert!(!a.is_set(ArgSettings::MultipleOccurrences)); - assert!(!a.is_set(ArgSettings::MultipleValues)); - assert!(a.is_set(ArgSettings::TakesValue)); - assert!(!a.is_set(ArgSettings::Required)); + assert!(!a.is_multiple_occurrences_set()); + assert!(!a.is_multiple_values_set()); + assert!(a.is_takes_value_set()); + assert!(!a.is_required_set()); assert_eq!(a.val_names.iter().collect::>(), [&"option"]); } @@ -522,10 +522,10 @@ mod test { assert_eq!(a.long.unwrap(), "opt"); assert!(a.short.is_none()); assert_eq!(a.help.unwrap(), "some help info"); - assert!(!a.is_set(ArgSettings::MultipleOccurrences)); - assert!(!a.is_set(ArgSettings::MultipleValues)); - assert!(a.is_set(ArgSettings::TakesValue)); - assert!(a.is_set(ArgSettings::Required)); + assert!(!a.is_multiple_occurrences_set()); + assert!(!a.is_multiple_values_set()); + assert!(a.is_takes_value_set()); + assert!(a.is_required_set()); assert_eq!(a.val_names.iter().collect::>(), [&"opt"]); } @@ -536,10 +536,10 @@ mod test { assert_eq!(a.long.unwrap(), "opt"); assert!(a.short.is_none()); assert_eq!(a.help.unwrap(), "some help info"); - assert!(!a.is_set(ArgSettings::MultipleOccurrences)); - assert!(!a.is_set(ArgSettings::MultipleValues)); - assert!(a.is_set(ArgSettings::TakesValue)); - assert!(a.is_set(ArgSettings::Required)); + assert!(!a.is_multiple_occurrences_set()); + assert!(!a.is_multiple_values_set()); + assert!(a.is_takes_value_set()); + assert!(a.is_required_set()); assert_eq!(a.val_names.iter().collect::>(), [&"option"]); } @@ -550,10 +550,10 @@ mod test { assert_eq!(a.long.unwrap(), "opt"); assert!(a.short.is_none()); assert_eq!(a.help.unwrap(), "some help info"); - assert!(a.is_set(ArgSettings::MultipleOccurrences)); - assert!(a.is_set(ArgSettings::MultipleValues)); - assert!(a.is_set(ArgSettings::TakesValue)); - assert!(!a.is_set(ArgSettings::Required)); + assert!(a.is_multiple_occurrences_set()); + assert!(a.is_multiple_values_set()); + assert!(a.is_takes_value_set()); + assert!(!a.is_required_set()); assert_eq!(a.val_names.iter().collect::>(), [&"opt"]); } @@ -564,10 +564,10 @@ mod test { assert_eq!(a.long.unwrap(), "opt"); assert!(a.short.is_none()); assert_eq!(a.help.unwrap(), "some help info"); - assert!(a.is_set(ArgSettings::MultipleOccurrences)); - assert!(!a.is_set(ArgSettings::MultipleValues)); - assert!(a.is_set(ArgSettings::TakesValue)); - assert!(!a.is_set(ArgSettings::Required)); + assert!(a.is_multiple_occurrences_set()); + assert!(!a.is_multiple_values_set()); + assert!(a.is_takes_value_set()); + assert!(!a.is_required_set()); assert_eq!(a.val_names.iter().collect::>(), [&"opt"]); } @@ -578,10 +578,10 @@ mod test { assert_eq!(a.long.unwrap(), "opt"); assert!(a.short.is_none()); assert_eq!(a.help.unwrap(), "some help info"); - assert!(a.is_set(ArgSettings::MultipleOccurrences)); - assert!(a.is_set(ArgSettings::MultipleValues)); - assert!(a.is_set(ArgSettings::TakesValue)); - assert!(!a.is_set(ArgSettings::Required)); + assert!(a.is_multiple_occurrences_set()); + assert!(a.is_multiple_values_set()); + assert!(a.is_takes_value_set()); + assert!(!a.is_required_set()); assert_eq!(a.val_names.iter().collect::>(), [&"option"]); } @@ -592,10 +592,10 @@ mod test { assert_eq!(a.long.unwrap(), "opt"); assert!(a.short.is_none()); assert_eq!(a.help.unwrap(), "some help info"); - assert!(a.is_set(ArgSettings::MultipleOccurrences)); - assert!(a.is_set(ArgSettings::MultipleValues)); - assert!(a.is_set(ArgSettings::TakesValue)); - assert!(a.is_set(ArgSettings::Required)); + assert!(a.is_multiple_occurrences_set()); + assert!(a.is_multiple_values_set()); + assert!(a.is_takes_value_set()); + assert!(a.is_required_set()); assert_eq!(a.val_names.iter().collect::>(), [&"opt"]); } @@ -606,10 +606,10 @@ mod test { assert_eq!(a.long.unwrap(), "opt"); assert!(a.short.is_none()); assert_eq!(a.help.unwrap(), "some help info"); - assert!(a.is_set(ArgSettings::MultipleOccurrences)); - assert!(!a.is_set(ArgSettings::MultipleValues)); - assert!(a.is_set(ArgSettings::TakesValue)); - assert!(a.is_set(ArgSettings::Required)); + assert!(a.is_multiple_occurrences_set()); + assert!(!a.is_multiple_values_set()); + assert!(a.is_takes_value_set()); + assert!(a.is_required_set()); assert_eq!(a.val_names.iter().collect::>(), [&"opt"]); } @@ -620,10 +620,10 @@ mod test { assert_eq!(a.long.unwrap(), "opt"); assert!(a.short.is_none()); assert_eq!(a.help.unwrap(), "some help info"); - assert!(a.is_set(ArgSettings::MultipleOccurrences)); - assert!(a.is_set(ArgSettings::MultipleValues)); - assert!(a.is_set(ArgSettings::TakesValue)); - assert!(a.is_set(ArgSettings::Required)); + assert!(a.is_multiple_occurrences_set()); + assert!(a.is_multiple_values_set()); + assert!(a.is_takes_value_set()); + assert!(a.is_required_set()); assert_eq!(a.val_names.iter().collect::>(), [&"option"]); } @@ -634,10 +634,10 @@ mod test { assert_eq!(a.long.unwrap(), "opt"); assert!(a.short.is_none()); assert_eq!(a.help.unwrap(), "some help info"); - assert!(!a.is_set(ArgSettings::MultipleOccurrences)); - assert!(!a.is_set(ArgSettings::MultipleValues)); - assert!(a.is_set(ArgSettings::TakesValue)); - assert!(!a.is_set(ArgSettings::Required)); + assert!(!a.is_multiple_occurrences_set()); + assert!(!a.is_multiple_values_set()); + assert!(a.is_takes_value_set()); + assert!(!a.is_required_set()); assert_eq!(a.val_names.iter().collect::>(), [&"opt"]); } @@ -648,10 +648,10 @@ mod test { assert_eq!(a.long.unwrap(), "opt"); assert!(a.short.is_none()); assert_eq!(a.help.unwrap(), "some help info"); - assert!(!a.is_set(ArgSettings::MultipleOccurrences)); - assert!(!a.is_set(ArgSettings::MultipleValues)); - assert!(a.is_set(ArgSettings::TakesValue)); - assert!(!a.is_set(ArgSettings::Required)); + assert!(!a.is_multiple_occurrences_set()); + assert!(!a.is_multiple_values_set()); + assert!(a.is_takes_value_set()); + assert!(!a.is_required_set()); assert_eq!(a.val_names.iter().collect::>(), [&"option"]); } @@ -662,10 +662,10 @@ mod test { assert_eq!(a.long.unwrap(), "opt"); assert!(a.short.is_none()); assert_eq!(a.help.unwrap(), "some help info"); - assert!(!a.is_set(ArgSettings::MultipleOccurrences)); - assert!(!a.is_set(ArgSettings::MultipleValues)); - assert!(a.is_set(ArgSettings::TakesValue)); - assert!(a.is_set(ArgSettings::Required)); + assert!(!a.is_multiple_occurrences_set()); + assert!(!a.is_multiple_values_set()); + assert!(a.is_takes_value_set()); + assert!(a.is_required_set()); assert_eq!(a.val_names.iter().collect::>(), [&"opt"]); } @@ -676,10 +676,10 @@ mod test { assert_eq!(a.long.unwrap(), "opt"); assert!(a.short.is_none()); assert_eq!(a.help.unwrap(), "some help info"); - assert!(!a.is_set(ArgSettings::MultipleOccurrences)); - assert!(!a.is_set(ArgSettings::MultipleValues)); - assert!(a.is_set(ArgSettings::TakesValue)); - assert!(a.is_set(ArgSettings::Required)); + assert!(!a.is_multiple_occurrences_set()); + assert!(!a.is_multiple_values_set()); + assert!(a.is_takes_value_set()); + assert!(a.is_required_set()); assert_eq!(a.val_names.iter().collect::>(), [&"option"]); } @@ -690,10 +690,10 @@ mod test { assert_eq!(a.long.unwrap(), "opt"); assert!(a.short.is_none()); assert_eq!(a.help.unwrap(), "some help info"); - assert!(a.is_set(ArgSettings::MultipleOccurrences)); - assert!(a.is_set(ArgSettings::MultipleValues)); - assert!(a.is_set(ArgSettings::TakesValue)); - assert!(!a.is_set(ArgSettings::Required)); + assert!(a.is_multiple_occurrences_set()); + assert!(a.is_multiple_values_set()); + assert!(a.is_takes_value_set()); + assert!(!a.is_required_set()); assert_eq!(a.val_names.iter().collect::>(), [&"opt"]); } @@ -704,10 +704,10 @@ mod test { assert_eq!(a.long.unwrap(), "opt"); assert!(a.short.is_none()); assert_eq!(a.help.unwrap(), "some help info"); - assert!(a.is_set(ArgSettings::MultipleOccurrences)); - assert!(!a.is_set(ArgSettings::MultipleValues)); - assert!(a.is_set(ArgSettings::TakesValue)); - assert!(!a.is_set(ArgSettings::Required)); + assert!(a.is_multiple_occurrences_set()); + assert!(!a.is_multiple_values_set()); + assert!(a.is_takes_value_set()); + assert!(!a.is_required_set()); assert_eq!(a.val_names.iter().collect::>(), [&"opt"]); } @@ -718,10 +718,10 @@ mod test { assert_eq!(a.long.unwrap(), "opt"); assert!(a.short.is_none()); assert_eq!(a.help.unwrap(), "some help info"); - assert!(a.is_set(ArgSettings::MultipleOccurrences)); - assert!(a.is_set(ArgSettings::MultipleValues)); - assert!(a.is_set(ArgSettings::TakesValue)); - assert!(!a.is_set(ArgSettings::Required)); + assert!(a.is_multiple_occurrences_set()); + assert!(a.is_multiple_values_set()); + assert!(a.is_takes_value_set()); + assert!(!a.is_required_set()); assert_eq!(a.val_names.iter().collect::>(), [&"option"]); } @@ -732,10 +732,10 @@ mod test { assert_eq!(a.long.unwrap(), "opt"); assert!(a.short.is_none()); assert_eq!(a.help.unwrap(), "some help info"); - assert!(a.is_set(ArgSettings::MultipleOccurrences)); - assert!(a.is_set(ArgSettings::MultipleValues)); - assert!(a.is_set(ArgSettings::TakesValue)); - assert!(a.is_set(ArgSettings::Required)); + assert!(a.is_multiple_occurrences_set()); + assert!(a.is_multiple_values_set()); + assert!(a.is_takes_value_set()); + assert!(a.is_required_set()); assert_eq!(a.val_names.iter().collect::>(), [&"opt"]); } @@ -746,10 +746,10 @@ mod test { assert_eq!(a.long.unwrap(), "opt"); assert!(a.short.is_none()); assert_eq!(a.help.unwrap(), "some help info"); - assert!(a.is_set(ArgSettings::MultipleOccurrences)); - assert!(!a.is_set(ArgSettings::MultipleValues)); - assert!(a.is_set(ArgSettings::TakesValue)); - assert!(a.is_set(ArgSettings::Required)); + assert!(a.is_multiple_occurrences_set()); + assert!(!a.is_multiple_values_set()); + assert!(a.is_takes_value_set()); + assert!(a.is_required_set()); assert_eq!(a.val_names.iter().collect::>(), [&"opt"]); } @@ -760,10 +760,10 @@ mod test { assert_eq!(a.long.unwrap(), "opt"); assert!(a.short.is_none()); assert_eq!(a.help.unwrap(), "some help info"); - assert!(a.is_set(ArgSettings::MultipleOccurrences)); - assert!(a.is_set(ArgSettings::MultipleValues)); - assert!(a.is_set(ArgSettings::TakesValue)); - assert!(a.is_set(ArgSettings::Required)); + assert!(a.is_multiple_occurrences_set()); + assert!(a.is_multiple_values_set()); + assert!(a.is_takes_value_set()); + assert!(a.is_required_set()); assert_eq!(a.val_names.iter().collect::>(), [&"option"]); } @@ -774,10 +774,10 @@ mod test { assert_eq!(a.long.unwrap(), "opt"); assert_eq!(a.short.unwrap(), 'o'); assert_eq!(a.help.unwrap(), "some help info"); - assert!(!a.is_set(ArgSettings::MultipleOccurrences)); - assert!(!a.is_set(ArgSettings::MultipleValues)); - assert!(a.is_set(ArgSettings::TakesValue)); - assert!(!a.is_set(ArgSettings::Required)); + assert!(!a.is_multiple_occurrences_set()); + assert!(!a.is_multiple_values_set()); + assert!(a.is_takes_value_set()); + assert!(!a.is_required_set()); assert_eq!(a.val_names.iter().collect::>(), [&"option"]); } @@ -788,10 +788,10 @@ mod test { assert_eq!(a.long.unwrap(), "opt"); assert_eq!(a.short.unwrap(), 'o'); assert_eq!(a.help.unwrap(), "some help info"); - assert!(!a.is_set(ArgSettings::MultipleOccurrences)); - assert!(!a.is_set(ArgSettings::MultipleValues)); - assert!(a.is_set(ArgSettings::TakesValue)); - assert!(!a.is_set(ArgSettings::Required)); + assert!(!a.is_multiple_occurrences_set()); + assert!(!a.is_multiple_values_set()); + assert!(a.is_takes_value_set()); + assert!(!a.is_required_set()); assert_eq!(a.val_names.iter().collect::>(), [&"option"]); } @@ -802,10 +802,10 @@ mod test { assert_eq!(a.long.unwrap(), "opt"); assert_eq!(a.short.unwrap(), 'o'); assert_eq!(a.help.unwrap(), "some help info"); - assert!(!a.is_set(ArgSettings::MultipleOccurrences)); - assert!(!a.is_set(ArgSettings::MultipleValues)); - assert!(a.is_set(ArgSettings::TakesValue)); - assert!(a.is_set(ArgSettings::Required)); + assert!(!a.is_multiple_occurrences_set()); + assert!(!a.is_multiple_values_set()); + assert!(a.is_takes_value_set()); + assert!(a.is_required_set()); assert_eq!(a.val_names.iter().collect::>(), [&"opt"]); } @@ -816,10 +816,10 @@ mod test { assert_eq!(a.long.unwrap(), "opt"); assert_eq!(a.short.unwrap(), 'o'); assert_eq!(a.help.unwrap(), "some help info"); - assert!(!a.is_set(ArgSettings::MultipleOccurrences)); - assert!(!a.is_set(ArgSettings::MultipleValues)); - assert!(a.is_set(ArgSettings::TakesValue)); - assert!(a.is_set(ArgSettings::Required)); + assert!(!a.is_multiple_occurrences_set()); + assert!(!a.is_multiple_values_set()); + assert!(a.is_takes_value_set()); + assert!(a.is_required_set()); assert_eq!(a.val_names.iter().collect::>(), [&"option"]); } @@ -830,10 +830,10 @@ mod test { assert_eq!(a.long.unwrap(), "opt"); assert_eq!(a.short.unwrap(), 'o'); assert_eq!(a.help.unwrap(), "some help info"); - assert!(a.is_set(ArgSettings::MultipleOccurrences)); - assert!(!a.is_set(ArgSettings::MultipleValues)); - assert!(a.is_set(ArgSettings::TakesValue)); - assert!(!a.is_set(ArgSettings::Required)); + assert!(a.is_multiple_occurrences_set()); + assert!(!a.is_multiple_values_set()); + assert!(a.is_takes_value_set()); + assert!(!a.is_required_set()); assert_eq!(a.val_names.iter().collect::>(), [&"option"]); } @@ -844,10 +844,10 @@ mod test { assert_eq!(a.long.unwrap(), "opt"); assert_eq!(a.short.unwrap(), 'o'); assert_eq!(a.help.unwrap(), "some help info"); - assert!(a.is_set(ArgSettings::MultipleOccurrences)); - assert!(a.is_set(ArgSettings::MultipleValues)); - assert!(a.is_set(ArgSettings::TakesValue)); - assert!(!a.is_set(ArgSettings::Required)); + assert!(a.is_multiple_occurrences_set()); + assert!(a.is_multiple_values_set()); + assert!(a.is_takes_value_set()); + assert!(!a.is_required_set()); assert_eq!(a.val_names.iter().collect::>(), [&"option"]); } @@ -858,10 +858,10 @@ mod test { assert_eq!(a.long.unwrap(), "opt"); assert_eq!(a.short.unwrap(), 'o'); assert_eq!(a.help.unwrap(), "some help info"); - assert!(a.is_set(ArgSettings::MultipleOccurrences)); - assert!(!a.is_set(ArgSettings::MultipleValues)); - assert!(a.is_set(ArgSettings::TakesValue)); - assert!(a.is_set(ArgSettings::Required)); + assert!(a.is_multiple_occurrences_set()); + assert!(!a.is_multiple_values_set()); + assert!(a.is_takes_value_set()); + assert!(a.is_required_set()); assert_eq!(a.val_names.iter().collect::>(), [&"opt"]); } @@ -872,10 +872,10 @@ mod test { assert_eq!(a.long.unwrap(), "opt"); assert_eq!(a.short.unwrap(), 'o'); assert_eq!(a.help.unwrap(), "some help info"); - assert!(a.is_set(ArgSettings::MultipleOccurrences)); - assert!(a.is_set(ArgSettings::MultipleValues)); - assert!(a.is_set(ArgSettings::TakesValue)); - assert!(a.is_set(ArgSettings::Required)); + assert!(a.is_multiple_occurrences_set()); + assert!(a.is_multiple_values_set()); + assert!(a.is_takes_value_set()); + assert!(a.is_required_set()); assert_eq!(a.val_names.iter().collect::>(), [&"option"]); } @@ -886,10 +886,10 @@ mod test { assert_eq!(a.long.unwrap(), "opt"); assert_eq!(a.short.unwrap(), 'o'); assert_eq!(a.help.unwrap(), "some help info"); - assert!(!a.is_set(ArgSettings::MultipleOccurrences)); - assert!(!a.is_set(ArgSettings::MultipleValues)); - assert!(a.is_set(ArgSettings::TakesValue)); - assert!(!a.is_set(ArgSettings::Required)); + assert!(!a.is_multiple_occurrences_set()); + assert!(!a.is_multiple_values_set()); + assert!(a.is_takes_value_set()); + assert!(!a.is_required_set()); assert_eq!(a.val_names.iter().collect::>(), [&"option"]); } @@ -900,10 +900,10 @@ mod test { assert_eq!(a.long.unwrap(), "opt"); assert_eq!(a.short.unwrap(), 'o'); assert_eq!(a.help.unwrap(), "some help info"); - assert!(!a.is_set(ArgSettings::MultipleOccurrences)); - assert!(!a.is_set(ArgSettings::MultipleValues)); - assert!(a.is_set(ArgSettings::TakesValue)); - assert!(!a.is_set(ArgSettings::Required)); + assert!(!a.is_multiple_occurrences_set()); + assert!(!a.is_multiple_values_set()); + assert!(a.is_takes_value_set()); + assert!(!a.is_required_set()); assert_eq!(a.val_names.iter().collect::>(), [&"option"]); } @@ -914,10 +914,10 @@ mod test { assert_eq!(a.long.unwrap(), "opt"); assert_eq!(a.short.unwrap(), 'o'); assert_eq!(a.help.unwrap(), "some help info"); - assert!(!a.is_set(ArgSettings::MultipleOccurrences)); - assert!(!a.is_set(ArgSettings::MultipleValues)); - assert!(a.is_set(ArgSettings::TakesValue)); - assert!(a.is_set(ArgSettings::Required)); + assert!(!a.is_multiple_occurrences_set()); + assert!(!a.is_multiple_values_set()); + assert!(a.is_takes_value_set()); + assert!(a.is_required_set()); assert_eq!(a.val_names.iter().collect::>(), [&"opt"]); } @@ -928,10 +928,10 @@ mod test { assert_eq!(a.long.unwrap(), "opt"); assert_eq!(a.short.unwrap(), 'o'); assert_eq!(a.help.unwrap(), "some help info"); - assert!(!a.is_set(ArgSettings::MultipleOccurrences)); - assert!(!a.is_set(ArgSettings::MultipleValues)); - assert!(a.is_set(ArgSettings::TakesValue)); - assert!(a.is_set(ArgSettings::Required)); + assert!(!a.is_multiple_occurrences_set()); + assert!(!a.is_multiple_values_set()); + assert!(a.is_takes_value_set()); + assert!(a.is_required_set()); assert_eq!(a.val_names.iter().collect::>(), [&"option"]); } @@ -942,10 +942,10 @@ mod test { assert_eq!(a.long.unwrap(), "opt"); assert_eq!(a.short.unwrap(), 'o'); assert_eq!(a.help.unwrap(), "some help info"); - assert!(a.is_set(ArgSettings::MultipleOccurrences)); - assert!(!a.is_set(ArgSettings::MultipleValues)); - assert!(a.is_set(ArgSettings::TakesValue)); - assert!(!a.is_set(ArgSettings::Required)); + assert!(a.is_multiple_occurrences_set()); + assert!(!a.is_multiple_values_set()); + assert!(a.is_takes_value_set()); + assert!(!a.is_required_set()); assert_eq!(a.val_names.iter().collect::>(), [&"option"]); } @@ -956,10 +956,10 @@ mod test { assert_eq!(a.long.unwrap(), "opt"); assert_eq!(a.short.unwrap(), 'o'); assert_eq!(a.help.unwrap(), "some help info"); - assert!(a.is_set(ArgSettings::MultipleOccurrences)); - assert!(a.is_set(ArgSettings::MultipleValues)); - assert!(a.is_set(ArgSettings::TakesValue)); - assert!(!a.is_set(ArgSettings::Required)); + assert!(a.is_multiple_occurrences_set()); + assert!(a.is_multiple_values_set()); + assert!(a.is_takes_value_set()); + assert!(!a.is_required_set()); assert_eq!(a.val_names.iter().collect::>(), [&"option"]); } @@ -970,10 +970,10 @@ mod test { assert_eq!(a.long.unwrap(), "opt"); assert_eq!(a.short.unwrap(), 'o'); assert_eq!(a.help.unwrap(), "some help info"); - assert!(a.is_set(ArgSettings::MultipleOccurrences)); - assert!(!a.is_set(ArgSettings::MultipleValues)); - assert!(a.is_set(ArgSettings::TakesValue)); - assert!(a.is_set(ArgSettings::Required)); + assert!(a.is_multiple_occurrences_set()); + assert!(!a.is_multiple_values_set()); + assert!(a.is_takes_value_set()); + assert!(a.is_required_set()); assert_eq!(a.val_names.iter().collect::>(), [&"opt"]); } @@ -984,10 +984,10 @@ mod test { assert_eq!(a.long.unwrap(), "opt"); assert_eq!(a.short.unwrap(), 'o'); assert_eq!(a.help.unwrap(), "some help info"); - assert!(a.is_set(ArgSettings::MultipleOccurrences)); - assert!(a.is_set(ArgSettings::MultipleValues)); - assert!(a.is_set(ArgSettings::TakesValue)); - assert!(a.is_set(ArgSettings::Required)); + assert!(a.is_multiple_occurrences_set()); + assert!(a.is_multiple_values_set()); + assert!(a.is_takes_value_set()); + assert!(a.is_required_set()); assert_eq!(a.val_names.iter().collect::>(), [&"option"]); } @@ -998,10 +998,10 @@ mod test { assert!(a.long.is_none()); assert_eq!(a.short.unwrap(), 'o'); assert_eq!(a.help.unwrap(), "some help info"); - assert!(!a.is_set(ArgSettings::MultipleOccurrences)); - assert!(!a.is_set(ArgSettings::MultipleValues)); - assert!(a.is_set(ArgSettings::TakesValue)); - assert!(a.is_set(ArgSettings::Required)); + assert!(!a.is_multiple_occurrences_set()); + assert!(!a.is_multiple_values_set()); + assert!(a.is_takes_value_set()); + assert!(a.is_required_set()); assert_eq!(a.val_names.iter().collect::>(), [&"file", &"mode"]); } @@ -1012,10 +1012,10 @@ mod test { assert!(a.long.is_none()); assert_eq!(a.short.unwrap(), 'o'); assert_eq!(a.help.unwrap(), "some help info"); - assert!(a.is_set(ArgSettings::MultipleOccurrences)); - assert!(a.is_set(ArgSettings::MultipleValues)); - assert!(a.is_set(ArgSettings::TakesValue)); - assert!(a.is_set(ArgSettings::Required)); + assert!(a.is_multiple_occurrences_set()); + assert!(a.is_multiple_values_set()); + assert!(a.is_takes_value_set()); + assert!(a.is_required_set()); assert_eq!(a.val_names.iter().collect::>(), [&"file", &"mode"]); } @@ -1026,10 +1026,10 @@ mod test { assert!(a.short.is_none()); assert_eq!(a.long.unwrap(), "opt"); assert_eq!(a.help.unwrap(), "some help info"); - assert!(a.is_set(ArgSettings::MultipleOccurrences)); - assert!(a.is_set(ArgSettings::MultipleValues)); - assert!(a.is_set(ArgSettings::TakesValue)); - assert!(a.is_set(ArgSettings::Required)); + assert!(a.is_multiple_occurrences_set()); + assert!(a.is_multiple_values_set()); + assert!(a.is_takes_value_set()); + assert!(a.is_required_set()); assert_eq!(a.val_names.iter().collect::>(), [&"file", &"mode"]); } @@ -1040,10 +1040,10 @@ mod test { assert!(a.short.is_none()); assert_eq!(a.long.unwrap(), "opt"); assert_eq!(a.help.unwrap(), "some help info"); - assert!(!a.is_set(ArgSettings::MultipleOccurrences)); - assert!(!a.is_set(ArgSettings::MultipleValues)); - assert!(a.is_set(ArgSettings::TakesValue)); - assert!(!a.is_set(ArgSettings::Required)); + assert!(!a.is_multiple_occurrences_set()); + assert!(!a.is_multiple_values_set()); + assert!(a.is_takes_value_set()); + assert!(!a.is_required_set()); assert_eq!(a.val_names.iter().collect::>(), [&"file", &"mode"]); } @@ -1054,10 +1054,10 @@ mod test { assert!(a.short.is_none()); assert_eq!(a.long.unwrap(), "opt"); assert_eq!(a.help.unwrap(), "some help info"); - assert!(!a.is_set(ArgSettings::MultipleOccurrences)); - assert!(!a.is_set(ArgSettings::MultipleValues)); - assert!(a.is_set(ArgSettings::TakesValue)); - assert!(a.is_set(ArgSettings::Required)); + assert!(!a.is_multiple_occurrences_set()); + assert!(!a.is_multiple_values_set()); + assert!(a.is_takes_value_set()); + assert!(a.is_required_set()); } #[test] @@ -1065,9 +1065,9 @@ mod test { let a = Arg::from_usage("[pos] 'some help info'"); assert_eq!(a.name, "pos"); assert_eq!(a.help.unwrap(), "some help info"); - assert!(!a.is_set(ArgSettings::MultipleOccurrences)); - assert!(!a.is_set(ArgSettings::MultipleValues)); - assert!(!a.is_set(ArgSettings::Required)); + assert!(!a.is_multiple_occurrences_set()); + assert!(!a.is_multiple_values_set()); + assert!(!a.is_required_set()); assert!(a.val_names.is_empty()); } @@ -1076,9 +1076,9 @@ mod test { let a = Arg::from_usage(" 'some help info'"); assert_eq!(a.name, "pos"); assert_eq!(a.help.unwrap(), "some help info"); - assert!(!a.is_set(ArgSettings::MultipleOccurrences)); - assert!(!a.is_set(ArgSettings::MultipleValues)); - assert!(a.is_set(ArgSettings::Required)); + assert!(!a.is_multiple_occurrences_set()); + assert!(!a.is_multiple_values_set()); + assert!(a.is_required_set()); assert!(a.val_names.is_empty()); } @@ -1087,9 +1087,9 @@ mod test { let a = Arg::from_usage("[pos]... 'some help info'"); assert_eq!(a.name, "pos"); assert_eq!(a.help.unwrap(), "some help info"); - assert!(a.is_set(ArgSettings::MultipleOccurrences)); - assert!(!a.is_set(ArgSettings::MultipleValues)); - assert!(!a.is_set(ArgSettings::Required)); + assert!(a.is_multiple_occurrences_set()); + assert!(!a.is_multiple_values_set()); + assert!(!a.is_required_set()); assert!(a.val_names.is_empty()); } @@ -1098,9 +1098,9 @@ mod test { let a = Arg::from_usage("[pos]... 'some help\' info'"); assert_eq!(a.name, "pos"); assert_eq!(a.help.unwrap(), "some help' info"); - assert!(a.is_set(ArgSettings::MultipleOccurrences)); - assert!(!a.is_set(ArgSettings::MultipleValues)); - assert!(!a.is_set(ArgSettings::Required)); + assert!(a.is_multiple_occurrences_set()); + assert!(!a.is_multiple_values_set()); + assert!(!a.is_required_set()); assert!(a.val_names.is_empty()); } @@ -1109,9 +1109,9 @@ mod test { let a = Arg::from_usage("[pos]... 'some \'help\' info'"); assert_eq!(a.name, "pos"); assert_eq!(a.help.unwrap(), "some 'help' info"); - assert!(a.is_set(ArgSettings::MultipleOccurrences)); - assert!(!a.is_set(ArgSettings::MultipleValues)); - assert!(!a.is_set(ArgSettings::Required)); + assert!(a.is_multiple_occurrences_set()); + assert!(!a.is_multiple_values_set()); + assert!(!a.is_required_set()); assert!(a.val_names.is_empty()); } @@ -1123,9 +1123,9 @@ mod test { ); assert_eq!(a.name, "pos"); assert_eq!(a.help.unwrap(), "some help{n}info"); - assert!(a.is_set(ArgSettings::MultipleOccurrences)); - assert!(!a.is_set(ArgSettings::MultipleValues)); - assert!(!a.is_set(ArgSettings::Required)); + assert!(a.is_multiple_occurrences_set()); + assert!(!a.is_multiple_values_set()); + assert!(!a.is_required_set()); assert!(a.val_names.is_empty()); } @@ -1137,9 +1137,9 @@ mod test { ); assert_eq!(a.name, "pos"); assert_eq!(a.help.unwrap(), "some help' stuff{n}info"); - assert!(a.is_set(ArgSettings::MultipleOccurrences)); - assert!(!a.is_set(ArgSettings::MultipleValues)); - assert!(!a.is_set(ArgSettings::Required)); + assert!(a.is_multiple_occurrences_set()); + assert!(!a.is_multiple_values_set()); + assert!(!a.is_required_set()); assert!(a.val_names.is_empty()); } @@ -1148,9 +1148,9 @@ mod test { let a = Arg::from_usage("... 'some help info'"); assert_eq!(a.name, "pos"); assert_eq!(a.help.unwrap(), "some help info"); - assert!(a.is_set(ArgSettings::MultipleOccurrences)); - assert!(!a.is_set(ArgSettings::MultipleValues)); - assert!(a.is_set(ArgSettings::Required)); + assert!(a.is_multiple_occurrences_set()); + assert!(!a.is_multiple_values_set()); + assert!(a.is_required_set()); assert!(a.val_names.is_empty()); } @@ -1158,9 +1158,9 @@ mod test { fn pos_req() { let a = Arg::from_usage(""); assert_eq!(a.name, "pos"); - assert!(!a.is_set(ArgSettings::MultipleOccurrences)); - assert!(!a.is_set(ArgSettings::MultipleValues)); - assert!(a.is_set(ArgSettings::Required)); + assert!(!a.is_multiple_occurrences_set()); + assert!(!a.is_multiple_values_set()); + assert!(a.is_required_set()); assert!(a.val_names.is_empty()); } @@ -1168,9 +1168,9 @@ mod test { fn pos_mult() { let a = Arg::from_usage("[pos]..."); assert_eq!(a.name, "pos"); - assert!(a.is_set(ArgSettings::MultipleOccurrences)); - assert!(!a.is_set(ArgSettings::MultipleValues)); - assert!(!a.is_set(ArgSettings::Required)); + assert!(a.is_multiple_occurrences_set()); + assert!(!a.is_multiple_values_set()); + assert!(!a.is_required_set()); assert!(a.val_names.is_empty()); } @@ -1179,9 +1179,9 @@ mod test { let a = Arg::from_usage("... @a 'some help info'"); assert_eq!(a.name, "pos"); assert_eq!(a.help.unwrap(), "some help info"); - assert!(a.is_set(ArgSettings::MultipleOccurrences)); - assert!(!a.is_set(ArgSettings::MultipleValues)); - assert!(a.is_set(ArgSettings::Required)); + assert!(a.is_multiple_occurrences_set()); + assert!(!a.is_multiple_values_set()); + assert!(a.is_required_set()); assert!(a.val_names.is_empty()); assert_eq!(a.default_vals, vec![std::ffi::OsStr::new("a")]); } @@ -1193,10 +1193,10 @@ mod test { assert!(a.long.is_none()); assert_eq!(a.short.unwrap(), 'o'); assert_eq!(a.help.unwrap(), "some help info"); - assert!(!a.is_set(ArgSettings::MultipleOccurrences)); - assert!(!a.is_set(ArgSettings::MultipleValues)); - assert!(a.is_set(ArgSettings::TakesValue)); - assert!(a.is_set(ArgSettings::Required)); + assert!(!a.is_multiple_occurrences_set()); + assert!(!a.is_multiple_values_set()); + assert!(a.is_takes_value_set()); + assert!(a.is_required_set()); assert_eq!(a.val_names.iter().collect::>(), [&"file", &"mode"]); assert_eq!(a.default_vals, vec![std::ffi::OsStr::new("a")]); } @@ -1208,10 +1208,10 @@ mod test { assert!(a.short.is_none()); assert_eq!(a.long.unwrap(), "opt"); assert_eq!(a.help.unwrap(), "some help info"); - assert!(!a.is_set(ArgSettings::MultipleOccurrences)); - assert!(!a.is_set(ArgSettings::MultipleValues)); - assert!(a.is_set(ArgSettings::TakesValue)); - assert!(!a.is_set(ArgSettings::Required)); + assert!(!a.is_multiple_occurrences_set()); + assert!(!a.is_multiple_values_set()); + assert!(a.is_takes_value_set()); + assert!(!a.is_required_set()); assert_eq!(a.val_names.iter().collect::>(), [&"file", &"mode"]); assert_eq!(a.default_vals, vec![std::ffi::OsStr::new("a")]); } diff --git a/src/macros.rs b/src/macros.rs index a706c28cb02..f0ade76381e 100644 --- a/src/macros.rs +++ b/src/macros.rs @@ -378,7 +378,7 @@ macro_rules! arg_impl { @arg ({ debug_assert_eq!($arg.get_value_names(), None, "Flags should precede values"); - debug_assert!(!$arg.is_set($crate::ArgSettings::MultipleOccurrences), "Flags should precede `...`"); + debug_assert!(!$arg.is_multiple_occurrences_set(), "Flags should precede `...`"); let mut arg = $arg; let long = $crate::arg_impl! { @string $long }; @@ -400,7 +400,7 @@ macro_rules! arg_impl { @arg ({ debug_assert_eq!($arg.get_value_names(), None, "Flags should precede values"); - debug_assert!(!$arg.is_set($crate::ArgSettings::MultipleOccurrences), "Flags should precede `...`"); + debug_assert!(!$arg.is_multiple_occurrences_set(), "Flags should precede `...`"); let mut arg = $arg; let long = $crate::arg_impl! { @string $long }; @@ -423,7 +423,7 @@ macro_rules! arg_impl { ({ debug_assert_eq!($arg.get_long(), None, "Short flags should precede long flags"); debug_assert_eq!($arg.get_value_names(), None, "Flags should precede values"); - debug_assert!(!$arg.is_set($crate::ArgSettings::MultipleOccurrences), "Flags should precede `...`"); + debug_assert!(!$arg.is_multiple_occurrences_set(), "Flags should precede `...`"); $arg.short($crate::arg_impl! { @char $short }) }) @@ -441,7 +441,7 @@ macro_rules! arg_impl { ({ debug_assert_eq!($arg.get_long(), None, "Short flags should precede long flags"); debug_assert_eq!($arg.get_value_names(), None, "Flags should precede values"); - debug_assert!(!$arg.is_set($crate::ArgSettings::MultipleOccurrences), "Flags should precede `...`"); + debug_assert!(!$arg.is_multiple_occurrences_set(), "Flags should precede `...`"); $arg.short($crate::arg_impl! { @char $short }) }) @@ -457,7 +457,7 @@ macro_rules! arg_impl { $crate::arg_impl! { @arg ({ - debug_assert!(!$arg.is_set($crate::ArgSettings::MultipleOccurrences), "Values should precede `...`"); + debug_assert!(!$arg.is_multiple_occurrences_set(), "Values should precede `...`"); debug_assert_eq!($arg.get_value_names(), None, "Multiple values not yet supported"); let mut arg = $arg; @@ -483,7 +483,7 @@ macro_rules! arg_impl { $crate::arg_impl! { @arg ({ - debug_assert!(!$arg.is_set($crate::ArgSettings::MultipleOccurrences), "Values should precede `...`"); + debug_assert!(!$arg.is_multiple_occurrences_set(), "Values should precede `...`"); debug_assert_eq!($arg.get_value_names(), None, "Multiple values not yet supported"); let mut arg = $arg; diff --git a/src/output/help.rs b/src/output/help.rs index 6450118171b..c651358c266 100644 --- a/src/output/help.rs +++ b/src/output/help.rs @@ -9,7 +9,7 @@ use std::{ // Internal use crate::{ - build::{arg::display_arg_val, App, AppSettings, Arg, ArgSettings}, + build::{arg::display_arg_val, App, AppSettings, Arg}, output::{fmt::Colorizer, Usage}, }; @@ -282,9 +282,9 @@ impl<'help, 'app, 'writer> Help<'help, 'app, 'writer> { fn val(&mut self, arg: &Arg<'help>) -> io::Result<()> { debug!("Help::val: arg={}", arg.name); let mut need_closing_bracket = false; - if arg.is_set(ArgSettings::TakesValue) && !arg.is_positional() { + if arg.is_takes_value_set() && !arg.is_positional() { let is_optional_val = arg.min_vals == Some(0); - let sep = if arg.is_set(ArgSettings::RequireEquals) { + let sep = if arg.is_require_equals_set() { if is_optional_val { need_closing_bracket = true; "[=" @@ -300,7 +300,7 @@ impl<'help, 'app, 'writer> Help<'help, 'app, 'writer> { self.none(sep)?; } - if arg.is_set(ArgSettings::TakesValue) || arg.is_positional() { + if arg.is_takes_value_set() || arg.is_positional() { display_arg_val( arg, |s, good| if good { self.good(s) } else { self.none(s) }, @@ -476,7 +476,7 @@ impl<'help, 'app, 'writer> Help<'help, 'app, 'writer> { } fn arg_next_line_help(&self, arg: &Arg<'help>, spec_vals: &str, longest: usize) -> bool { - if self.next_line_help || arg.is_set(ArgSettings::NextLineHelp) || self.use_long { + if self.next_line_help || arg.is_next_line_help_set() || self.use_long { // setting_next_line true } else { @@ -495,12 +495,12 @@ impl<'help, 'app, 'writer> Help<'help, 'app, 'writer> { let mut spec_vals = vec![]; #[cfg(feature = "env")] if let Some(ref env) = a.env { - if !a.is_set(ArgSettings::HideEnv) { + if !a.is_hide_env_set() { debug!( "Help::spec_vals: Found environment variable...[{:?}:{:?}]", env.0, env.1 ); - let env_val = if !a.is_set(ArgSettings::HideEnvValues) { + let env_val = if !a.is_hide_env_values_set() { format!( "={}", env.1 @@ -514,7 +514,7 @@ impl<'help, 'app, 'writer> Help<'help, 'app, 'writer> { spec_vals.push(env_info); } } - if !a.is_set(ArgSettings::HideDefaultValue) && !a.default_vals.is_empty() { + if !a.is_hide_default_value_set() && !a.default_vals.is_empty() { debug!( "Help::spec_vals: Found default value...[{:?}]", a.default_vals @@ -571,10 +571,7 @@ impl<'help, 'app, 'writer> Help<'help, 'app, 'writer> { } } - if !self.hide_pv - && !a.is_set(ArgSettings::HidePossibleValues) - && !a.possible_vals.is_empty() - { + if !self.hide_pv && !a.is_hide_possible_values_set() && !a.possible_vals.is_empty() { debug!( "Help::spec_vals: Found possible vals...{:?}", a.possible_vals @@ -584,7 +581,7 @@ impl<'help, 'app, 'writer> Help<'help, 'app, 'writer> { .possible_vals .iter() .filter_map(|value| { - if value.is_hidden() { + if value.is_hide_set() { None } else if value.get_name().contains(char::is_whitespace) { Some(format!("{:?}", value.get_name())) @@ -999,12 +996,12 @@ pub(crate) enum HelpWriter<'writer> { fn should_show_arg(use_long: bool, arg: &Arg) -> bool { debug!("should_show_arg: use_long={:?}, arg={}", use_long, arg.name); - if arg.is_set(ArgSettings::Hidden) { + if arg.is_hide_set() { return false; } - (!arg.is_set(ArgSettings::HiddenLongHelp) && use_long) - || (!arg.is_set(ArgSettings::HiddenShortHelp) && !use_long) - || arg.is_set(ArgSettings::NextLineHelp) + (!arg.is_hide_long_help_set() && use_long) + || (!arg.is_hide_short_help_set() && !use_long) + || arg.is_next_line_help_set() } fn should_show_subcommand(subcommand: &App) -> bool { diff --git a/src/output/usage.rs b/src/output/usage.rs index 37793fc41c4..7720aaaf74b 100644 --- a/src/output/usage.rs +++ b/src/output/usage.rs @@ -3,7 +3,7 @@ use indexmap::IndexSet; // Internal use crate::{ build::AppSettings as AS, - build::{App, Arg, ArgPredicate, ArgSettings}, + build::{App, Arg, ArgPredicate}, parse::ArgMatcher, util::{ChildGraph, Id}, INTERNAL_ERROR_MSG, @@ -69,30 +69,22 @@ impl<'help, 'app> Usage<'help, 'app> { usage.push_str(&req_string); } - let has_last = self - .app - .get_positionals() - .any(|p| p.is_set(ArgSettings::Last)); + let has_last = self.app.get_positionals().any(|p| p.is_last_set()); // places a '--' in the usage string if there are args and options // supporting multiple values if self .app .get_non_positionals() - .any(|o| o.is_set(ArgSettings::MultipleValues)) - && self - .app - .get_positionals() - .any(|p| !p.is_set(ArgSettings::Required)) + .any(|o| o.is_multiple_values_set()) + && self.app.get_positionals().any(|p| !p.is_required_set()) && !(self.app.has_visible_subcommands() || self.app.is_set(AS::AllowExternalSubcommands)) && !has_last { usage.push_str(" [--]"); } - let not_req_or_hidden = |p: &Arg| { - (!p.is_set(ArgSettings::Required) || p.is_set(ArgSettings::Last)) - && !p.is_set(ArgSettings::Hidden) - }; + let not_req_or_hidden = + |p: &Arg| (!p.is_required_set() || p.is_last_set()) && !p.is_hide_set(); if self.app.get_positionals().any(not_req_or_hidden) { if let Some(args_tag) = self.get_args_tag(incl_reqs) { usage.push_str(&*args_tag); @@ -103,16 +95,11 @@ impl<'help, 'app> Usage<'help, 'app> { let pos = self .app .get_positionals() - .find(|p| p.is_set(ArgSettings::Last)) + .find(|p| p.is_last_set()) .expect(INTERNAL_ERROR_MSG); debug!("Usage::create_help_usage: '{}' has .last(true)", pos.name); - let req = pos.is_set(ArgSettings::Required); - if req - && self - .app - .get_positionals() - .any(|p| !p.is_set(ArgSettings::Required)) - { + let req = pos.is_required_set(); + if req && self.app.get_positionals().any(|p| !p.is_required_set()) { usage.push_str(" -- <"); } else if req { usage.push_str(" [--] <"); @@ -202,9 +189,9 @@ impl<'help, 'app> Usage<'help, 'app> { for pos in self .app .get_positionals() - .filter(|pos| !pos.is_set(ArgSettings::Required)) - .filter(|pos| !pos.is_set(ArgSettings::Hidden)) - .filter(|pos| !pos.is_set(ArgSettings::Last)) + .filter(|pos| !pos.is_required_set()) + .filter(|pos| !pos.is_hide_set()) + .filter(|pos| !pos.is_last_set()) { debug!("Usage::get_args_tag:iter:{}", pos.name); let required = self.app.groups_for_arg(&pos.id).any(|grp_s| { @@ -234,9 +221,9 @@ impl<'help, 'app> Usage<'help, 'app> { .app .get_positionals() .find(|pos| { - !pos.is_set(ArgSettings::Required) - && !pos.is_set(ArgSettings::Hidden) - && !pos.is_set(ArgSettings::Last) + !pos.is_required_set() + && !pos.is_hide_set() + && !pos.is_last_set() && !self.app.groups_for_arg(&pos.id).any(|grp_s| { debug!("Usage::get_args_tag:iter:{:?}:iter:{:?}", pos.name, grp_s); // if it's part of a required group we don't want to count it @@ -266,9 +253,9 @@ impl<'help, 'app> Usage<'help, 'app> { Some( self.app .get_positionals() - .filter(|pos| !pos.is_set(ArgSettings::Required)) - .filter(|pos| !pos.is_set(ArgSettings::Hidden)) - .filter(|pos| !pos.is_set(ArgSettings::Last)) + .filter(|pos| !pos.is_required_set()) + .filter(|pos| !pos.is_hide_set()) + .filter(|pos| !pos.is_last_set()) .map(|pos| format!(" [{}]{}", pos.name_no_brackets(), pos.multiple_str())) .collect::>() .join(""), @@ -279,7 +266,7 @@ impl<'help, 'app> Usage<'help, 'app> { .app .get_positionals() .filter_map(|pos| { - if pos.is_set(ArgSettings::Required) && !pos.is_set(ArgSettings::Last) { + if pos.is_required_set() && !pos.is_last_set() { Some(pos.index) } else { None @@ -291,9 +278,9 @@ impl<'help, 'app> Usage<'help, 'app> { self.app .get_positionals() .filter(|pos| pos.index <= highest_req_pos) - .filter(|pos| !pos.is_set(ArgSettings::Required)) - .filter(|pos| !pos.is_set(ArgSettings::Hidden)) - .filter(|pos| !pos.is_set(ArgSettings::Last)) + .filter(|pos| !pos.is_required_set()) + .filter(|pos| !pos.is_hide_set()) + .filter(|pos| !pos.is_last_set()) .map(|pos| format!(" [{}]{}", pos.name_no_brackets(), pos.multiple_str())) .collect::>() .join(""), @@ -315,11 +302,11 @@ impl<'help, 'app> Usage<'help, 'app> { continue; } - if f.is_set(ArgSettings::Hidden) { + if f.is_hide_set() { debug!("Usage::needs_options_tag:iter Option is hidden"); continue; } - if f.is_set(ArgSettings::Required) { + if f.is_required_set() { debug!("Usage::needs_options_tag:iter Option is required"); continue; } @@ -439,7 +426,7 @@ impl<'help, 'app> Usage<'help, 'app> { .filter(|a| self.app.get_positionals().any(|p| &&p.id == a)) .filter(|&pos| matcher.map_or(true, |m| !m.contains(pos))) .filter_map(|pos| self.app.find(pos)) - .filter(|&pos| incl_last || !pos.is_set(ArgSettings::Last)) + .filter(|&pos| incl_last || !pos.is_last_set()) .filter(|pos| !args_in_groups.contains(&pos.id)) .map(|pos| (pos.index.unwrap(), pos)) .collect::>(); diff --git a/src/parse/arg_matcher.rs b/src/parse/arg_matcher.rs index f95a4867367..ab7002c6280 100644 --- a/src/parse/arg_matcher.rs +++ b/src/parse/arg_matcher.rs @@ -3,7 +3,7 @@ use std::{collections::HashMap, ffi::OsString, mem, ops::Deref}; // Internal use crate::{ - build::{App, Arg, ArgPredicate, ArgSettings}, + build::{App, Arg, ArgPredicate}, parse::{ArgMatches, MatchedArg, SubCommand, ValueSource}, util::Id, }; @@ -130,8 +130,8 @@ impl ArgMatcher { debug!("ArgMatcher::inc_occurrence_of_arg: id={:?}", id); let ma = self.entry(id).or_insert(MatchedArg::new()); ma.update_ty(ValueSource::CommandLine); - ma.set_ignore_case(arg.is_set(ArgSettings::IgnoreCase)); - ma.invalid_utf8_allowed(arg.is_set(ArgSettings::AllowInvalidUtf8)); + ma.set_ignore_case(arg.is_ignore_case_set()); + ma.invalid_utf8_allowed(arg.is_allow_invalid_utf8_set()); ma.inc_occurrences(); } @@ -189,7 +189,7 @@ impl ArgMatcher { let current_num = ma.num_vals(); if let Some(num) = o.num_vals { debug!("ArgMatcher::needs_more_vals: num_vals...{}", num); - return if o.is_set(ArgSettings::MultipleOccurrences) { + return if o.is_multiple_occurrences_set() { (current_num % num) != 0 } else { num != current_num @@ -201,7 +201,7 @@ impl ArgMatcher { debug!("ArgMatcher::needs_more_vals: min_vals...true"); return true; } - return o.is_set(ArgSettings::MultipleValues); + return o.is_multiple_values_set(); } true } diff --git a/src/parse/matches/arg_matches.rs b/src/parse/matches/arg_matches.rs index 41618049d8f..b8acb9c52ea 100644 --- a/src/parse/matches/arg_matches.rs +++ b/src/parse/matches/arg_matches.rs @@ -830,7 +830,7 @@ impl ArgMatches { /// let m = App::new("myapp") /// .arg(Arg::new("option") /// .short('o') - /// .use_delimiter(true) + /// .use_value_delimiter(true) /// .multiple_values(true)) /// .get_matches_from(vec!["myapp", "-o=val1,val2,val3"]); /// // ARGV indices: ^0 ^1 @@ -871,7 +871,7 @@ impl ArgMatches { /// let m = App::new("myapp") /// .arg(Arg::new("option") /// .short('o') - /// .use_delimiter(true) + /// .use_value_delimiter(true) /// .multiple_values(true)) /// .get_matches_from(vec!["myapp", "-o=val1,val2,val3"]); /// // ARGV indices: ^0 ^1 diff --git a/src/parse/parser.rs b/src/parse/parser.rs index 92ced7f2458..df7614c6440 100644 --- a/src/parse/parser.rs +++ b/src/parse/parser.rs @@ -10,7 +10,7 @@ use os_str_bytes::RawOsStr; // Internal use crate::build::AppSettings as AS; -use crate::build::{App, Arg, ArgSettings}; +use crate::build::{App, Arg}; use crate::error::Error as ClapError; use crate::error::Result as ClapResult; use crate::mkeymap::KeyType; @@ -38,11 +38,7 @@ pub(crate) struct Parser<'help, 'app> { impl<'help, 'app> Parser<'help, 'app> { pub(crate) fn new(app: &'app mut App<'help>) -> Self { let mut reqs = ChildGraph::with_capacity(5); - for a in app - .args - .args() - .filter(|a| a.settings.is_set(ArgSettings::Required)) - { + for a in app.args.args().filter(|a| a.is_required_set()) { reqs.insert(a.id.clone()); } for group in &app.groups { @@ -101,7 +97,7 @@ impl<'help, 'app> Parser<'help, 'app> { // Count of positional args let positional_count = self.app.args.keys().filter(|x| x.is_position()).count(); // If any arg sets .last(true) - let contains_last = self.app.args.args().any(|x| x.is_set(ArgSettings::Last)); + let contains_last = self.app.args.args().any(|x| x.is_last_set()); while let Some((arg_os, remaining_args)) = it.next() { // Recover the replaced items if any. @@ -141,7 +137,7 @@ impl<'help, 'app> Parser<'help, 'app> { .app .get_positionals() .last() - .map_or(false, |p_name| !p_name.is_set(ArgSettings::Last)); + .map_or(false, |p_name| !p_name.is_last_set()); let missing_pos = self.is_set(AS::AllowMissingPositional) && is_second_to_last @@ -391,7 +387,7 @@ impl<'help, 'app> Parser<'help, 'app> { } if let Some(p) = self.app.args.get(&pos_counter) { - if p.is_set(ArgSettings::Last) && !trailing_values { + if p.is_last_set() && !trailing_values { return Err(ClapError::unknown_argument( self.app, arg_os.to_str_lossy().into_owned(), @@ -673,7 +669,7 @@ impl<'help, 'app> Parser<'help, 'app> { ); if self.is_set(AS::AllowHyphenValues) - || self.app[¤t_positional.id].is_set(ArgSettings::AllowHyphenValues) + || self.app[¤t_positional.id].is_allow_hyphen_values_set() || (self.is_set(AS::AllowNegativeNumbers) && next.to_str_lossy().parse::().is_ok()) { // If allow hyphen, this isn't a new arg. @@ -858,12 +854,10 @@ impl<'help, 'app> Parser<'help, 'app> { debug!("Parser::use_long_help"); // In this case, both must be checked. This allows the retention of // original formatting, but also ensures that the actual -h or --help - // specified by the user is sent through. If HiddenShortHelp is not included, + // specified by the user is sent through. If hide_short_help is not included, // then items specified with hidden_short_help will also be hidden. let should_long = |v: &Arg| { - v.long_help.is_some() - || v.is_set(ArgSettings::HiddenLongHelp) - || v.is_set(ArgSettings::HiddenShortHelp) + v.long_help.is_some() || v.is_hide_long_help_set() || v.is_hide_short_help_set() }; // Subcommands aren't checked because we prefer short help for them, deferring to @@ -886,7 +880,7 @@ impl<'help, 'app> Parser<'help, 'app> { debug!("Parser::parse_long_arg"); if matches!(parse_state, ParseState::Opt(opt) | ParseState::Pos(opt) if - self.app[opt].is_set(ArgSettings::AllowHyphenValues)) + self.app[opt].is_allow_hyphen_values_set()) { return ParseResult::MaybeHyphenValue; } @@ -929,7 +923,7 @@ impl<'help, 'app> Parser<'help, 'app> { if let Some(opt) = opt { *valid_arg_found = true; self.seen.push(opt.id.clone()); - if opt.is_set(ArgSettings::TakesValue) { + if opt.is_takes_value_set() { debug!( "Parser::parse_long_arg: Found an opt with value '{:?}'", &val @@ -941,7 +935,7 @@ impl<'help, 'app> Parser<'help, 'app> { .arg_names() .filter(|&n| { self.app.find(n).map_or(true, |a| { - !(a.is_set(ArgSettings::Hidden) || self.required.contains(&a.id)) + !(a.is_hide_set() || self.required.contains(&a.id)) }) }) .cloned() @@ -992,12 +986,12 @@ impl<'help, 'app> Parser<'help, 'app> { debug!("Parser::parse_short_args: contains non-short flag"); return ParseResult::MaybeHyphenValue; } else if matches!(parse_state, ParseState::Opt(opt) | ParseState::Pos(opt) - if self.app[opt].is_set(ArgSettings::AllowHyphenValues)) + if self.app[opt].is_allow_hyphen_values_set()) { debug!("Parser::parse_short_args: prior arg accepts hyphenated values",); return ParseResult::MaybeHyphenValue; } else if self.app.args.get(&pos_counter).map_or(false, |arg| { - arg.is_set(ArgSettings::AllowHyphenValues) && !arg.is_set(ArgSettings::Last) + arg.is_allow_hyphen_values_set() && !arg.is_last_set() }) { debug!( "Parser::parse_short_args: positional at {} allows hyphens", @@ -1032,7 +1026,7 @@ impl<'help, 'app> Parser<'help, 'app> { ); *valid_arg_found = true; self.seen.push(opt.id.clone()); - if !opt.is_set(ArgSettings::TakesValue) { + if !opt.is_takes_value_set() { if let Some(parse_result) = self.check_for_help_and_version_char(c) { return parse_result; } @@ -1053,7 +1047,7 @@ impl<'help, 'app> Parser<'help, 'app> { // If attached value is not consumed, we may have more short // flags to parse, continue. // - // e.g. `-xvf`, when RequireEquals && x.min_vals == 0, we don't + // e.g. `-xvf`, when require_equals && x.min_vals == 0, we don't // consume the `vf`, even if it's provided as value. match self.parse_opt(val, opt, matcher, trailing_values) { ParseResult::AttachedValueNotConsumed => continue, @@ -1104,8 +1098,8 @@ impl<'help, 'app> Parser<'help, 'app> { let has_eq = matches!(attached_value, Some(fv) if fv.starts_with("=")); debug!("Parser::parse_opt; Checking for val..."); - // RequireEquals is set, but no '=' is provided, try throwing error. - if opt.is_set(ArgSettings::RequireEquals) && !has_eq { + // require_equals is set, but no '=' is provided, try throwing error. + if opt.is_require_equals_set() && !has_eq { if opt.min_vals == Some(0) { debug!("Requires equals, but min_vals == 0"); self.inc_occurrence_of_arg(matcher, opt); @@ -1187,7 +1181,7 @@ impl<'help, 'app> Parser<'help, 'app> { // separate the values or no more vals is needed, we're not // looking for more values. return if val.contains(delim) - || arg.is_set(ArgSettings::RequireDelimiter) + || arg.is_require_value_delimiter_set() || !matcher.needs_more_vals(arg) { ParseResult::ValuesDone @@ -1448,7 +1442,7 @@ impl<'help, 'app> Parser<'help, 'app> { if let Some((_, Some(ref val))) = a.env { let val = RawOsStr::new(val); - if a.is_set(ArgSettings::TakesValue) { + if a.is_takes_value_set() { debug!( "Parser::add_env: Found an opt with value={:?}, trailing={:?}", val, trailing_values @@ -1541,7 +1535,7 @@ impl<'help, 'app> Parser<'help, 'app> { .arg_names() .filter(|n| { self.app.find(n).map_or(true, |a| { - !(self.required.contains(&a.id) || a.is_set(ArgSettings::Hidden)) + !(self.required.contains(&a.id) || a.is_hide_set()) }) }) .cloned() diff --git a/src/parse/validator.rs b/src/parse/validator.rs index 244620e7f83..4a23c5e8aee 100644 --- a/src/parse/validator.rs +++ b/src/parse/validator.rs @@ -1,5 +1,5 @@ // Internal -use crate::build::{arg::PossibleValue, App, AppSettings as AS, Arg, ArgPredicate, ArgSettings}; +use crate::build::{arg::PossibleValue, App, AppSettings as AS, Arg, ArgPredicate}; use crate::error::{Error, Result as ClapResult}; use crate::output::Usage; use crate::parse::{ArgMatcher, MatchedArg, ParseState, Parser}; @@ -82,7 +82,7 @@ impl<'help, 'app, 'parser> Validator<'help, 'app, 'parser> { ) -> ClapResult<()> { debug!("Validator::validate_arg_values: arg={:?}", arg.name); for val in ma.vals_flatten() { - if !arg.is_set(ArgSettings::AllowInvalidUtf8) && val.to_str().is_none() { + if !arg.is_allow_invalid_utf8_set() && val.to_str().is_none() { debug!( "Validator::validate_arg_values: invalid UTF-8 found in val {:?}", val @@ -101,14 +101,14 @@ impl<'help, 'app, 'parser> Validator<'help, 'app, 'parser> { let ok = arg .possible_vals .iter() - .any(|pv| pv.matches(&val_str, arg.is_set(ArgSettings::IgnoreCase))); + .any(|pv| pv.matches(&val_str, arg.is_ignore_case_set())); if !ok { let used: Vec = matcher .arg_names() .filter(|arg_id| matcher.check_explicit(arg_id, ArgPredicate::IsPresent)) .filter(|&n| { self.p.app.find(n).map_or(true, |a| { - !(a.is_set(ArgSettings::Hidden) || self.p.required.contains(&a.id)) + !(a.is_hide_set() || self.p.required.contains(&a.id)) }) }) .cloned() @@ -125,10 +125,7 @@ impl<'help, 'app, 'parser> Validator<'help, 'app, 'parser> { )); } } - if arg.is_set(ArgSettings::ForbidEmptyValues) - && val.is_empty() - && matcher.contains(&arg.id) - { + if arg.is_forbid_empty_values_set() && val.is_empty() && matcher.contains(&arg.id) { debug!("Validator::validate_arg_values: illegal empty val found"); return Err(Error::empty_value( self.p.app, @@ -206,7 +203,7 @@ impl<'help, 'app, 'parser> Validator<'help, 'app, 'parser> { .app .find(name) // Find `arg`s which are exclusive but also appear with other args. - .filter(|&arg| arg.is_set(ArgSettings::Exclusive) && args_count > 1) + .filter(|&arg| arg.is_exclusive_set() && args_count > 1) }) // Throw an error for the first conflict found. .try_for_each(|arg| { @@ -323,10 +320,7 @@ impl<'help, 'app, 'parser> Validator<'help, 'app, 'parser> { ); // Occurrence of positional argument equals to number of values rather // than number of grouped values. - if ma.get_occurrences() > 1 - && !a.is_set(ArgSettings::MultipleOccurrences) - && !a.is_positional() - { + if ma.get_occurrences() > 1 && !a.is_multiple_occurrences_set() && !a.is_positional() { // Not the first time, and we don't allow multiples return Err(Error::unexpected_multiple_usage( self.p.app, @@ -359,7 +353,7 @@ impl<'help, 'app, 'parser> Validator<'help, 'app, 'parser> { if let Some(num) = a.num_vals { let total_num = ma.num_vals(); debug!("Validator::validate_arg_num_vals: num_vals set...{}", num); - let should_err = if a.is_set(ArgSettings::MultipleOccurrences) { + let should_err = if a.is_multiple_occurrences_set() { total_num % num != 0 } else { num != total_num @@ -370,7 +364,7 @@ impl<'help, 'app, 'parser> Validator<'help, 'app, 'parser> { self.p.app, a, num, - if a.is_set(ArgSettings::MultipleOccurrences) { + if a.is_multiple_occurrences_set() { total_num % num } else { total_num @@ -414,7 +408,7 @@ impl<'help, 'app, 'parser> Validator<'help, 'app, 'parser> { }; // Issue 665 (https://github.com/clap-rs/clap/issues/665) // Issue 1105 (https://github.com/clap-rs/clap/issues/1105) - if a.is_set(ArgSettings::TakesValue) && !min_vals_zero && ma.all_val_groups_empty() { + if a.is_takes_value_set() && !min_vals_zero && ma.all_val_groups_empty() { return Err(Error::empty_value( self.p.app, &a.possible_vals @@ -549,7 +543,7 @@ impl<'help, 'app, 'parser> Validator<'help, 'app, 'parser> { .filter(|n| { // Filter out the args we don't want to specify. self.p.app.find(n).map_or(true, |a| { - !a.is_set(ArgSettings::Hidden) && !self.p.required.contains(&a.id) + !a.is_hide_set() && !self.p.required.contains(&a.id) }) }) .cloned() diff --git a/tests/builder/app_settings.rs b/tests/builder/app_settings.rs index 3ce23edccca..50ee8e2e5eb 100644 --- a/tests/builder/app_settings.rs +++ b/tests/builder/app_settings.rs @@ -528,7 +528,7 @@ fn delim_values_only_pos_follows_with_delim() { let r = App::new("onlypos") .args(&[ arg!(f: -f [flag] "some opt"), - arg!([arg] ... "some arg").use_delimiter(true), + arg!([arg] ... "some arg").use_value_delimiter(true), ]) .try_get_matches_from(vec!["", "--", "-f", "-g,x"]); assert!(r.is_ok(), "{}", r.unwrap_err()); @@ -545,7 +545,7 @@ fn delim_values_only_pos_follows_with_delim() { fn delim_values_trailingvararg_with_delim() { let m = App::new("positional") .setting(AppSettings::TrailingVarArg) - .arg(arg!([opt] ... "some pos").use_delimiter(true)) + .arg(arg!([opt] ... "some pos").use_value_delimiter(true)) .try_get_matches_from(vec!["", "test", "--foo", "-Wl,-bar"]) .unwrap(); assert!(m.is_present("opt")); @@ -1066,7 +1066,7 @@ fn aaos_opts_mult() { arg!(--opt ... "some option") .number_of_values(1) .takes_value(true) - .use_delimiter(true) + .use_value_delimiter(true) .require_delimiter(true), ) .try_get_matches_from(vec!["", "--opt=some", "--opt=other", "--opt=one,two"]); @@ -1127,7 +1127,7 @@ fn aaos_pos_mult() { fn aaos_option_use_delim_false() { let m = App::new("posix") .setting(AppSettings::AllArgsOverrideSelf) - .arg(arg!(--opt "some option").use_delimiter(false)) + .arg(arg!(--opt "some option").use_value_delimiter(false)) .try_get_matches_from(vec!["", "--opt=some,other", "--opt=one,two"]) .unwrap(); assert!(m.is_present("opt")); diff --git a/tests/builder/delimiters.rs b/tests/builder/delimiters.rs index 68a393d145b..9b3ec80870a 100644 --- a/tests/builder/delimiters.rs +++ b/tests/builder/delimiters.rs @@ -97,7 +97,7 @@ fn opt_eq_mult_def_delim() { .long("opt") .takes_value(true) .multiple_values(true) - .use_delimiter(true), + .use_value_delimiter(true), ) .try_get_matches_from(vec!["", "--opt=val1,val2,val3"]); diff --git a/tests/builder/env.rs b/tests/builder/env.rs index a43000db6bb..115c9cb7da1 100644 --- a/tests/builder/env.rs +++ b/tests/builder/env.rs @@ -191,7 +191,7 @@ fn multiple_one() { arg!([arg] "some opt") .env("CLP_TEST_ENV_MO") .takes_value(true) - .use_delimiter(true) + .use_value_delimiter(true) .multiple_values(true), ) .try_get_matches_from(vec![""]); @@ -212,7 +212,7 @@ fn multiple_three() { arg!([arg] "some opt") .env("CLP_TEST_ENV_MULTI1") .takes_value(true) - .use_delimiter(true) + .use_value_delimiter(true) .multiple_values(true), ) .try_get_matches_from(vec![""]); diff --git a/tests/builder/grouped_values.rs b/tests/builder/grouped_values.rs index fc676a8e7d3..5bcfd20e6b5 100644 --- a/tests/builder/grouped_values.rs +++ b/tests/builder/grouped_values.rs @@ -68,7 +68,7 @@ fn grouped_value_long_flag_delimiter() { Arg::new("option") .long("option") .takes_value(true) - .use_delimiter(true) + .use_value_delimiter(true) .multiple_values(true) .multiple_occurrences(true), ) @@ -98,7 +98,7 @@ fn grouped_value_short_flag_delimiter() { Arg::new("option") .short('o') .takes_value(true) - .use_delimiter(true) + .use_value_delimiter(true) .multiple_values(true) .multiple_occurrences(true), ) diff --git a/tests/builder/help.rs b/tests/builder/help.rs index e4d3bb9b9ce..14d8b68278b 100644 --- a/tests/builder/help.rs +++ b/tests/builder/help.rs @@ -1757,8 +1757,8 @@ fn issue_1052_require_delim_help() { .required(true) .value_names(&["some", "val"]) .takes_value(true) - .use_delimiter(true) - .require_delimiter(true) + .use_value_delimiter(true) + .require_value_delimiter(true) .value_delimiter(':'), ); @@ -1781,8 +1781,8 @@ fn custom_headers_headers() { .required(true) .value_names(&["some", "val"]) .takes_value(true) - .use_delimiter(true) - .require_delimiter(true) + .use_value_delimiter(true) + .require_value_delimiter(true) .value_delimiter(':'), ) .next_help_heading(Some("NETWORKING")) @@ -1838,8 +1838,8 @@ fn multiple_custom_help_headers() { .required(true) .value_names(&["some", "val"]) .takes_value(true) - .use_delimiter(true) - .require_delimiter(true) + .use_value_delimiter(true) + .require_value_delimiter(true) .value_delimiter(':'), ) .next_help_heading(Some("NETWORKING")) diff --git a/tests/builder/indices.rs b/tests/builder/indices.rs index e143451fe90..8be1b287b63 100644 --- a/tests/builder/indices.rs +++ b/tests/builder/indices.rs @@ -159,7 +159,7 @@ fn indices_mult_opt_value_delim_eq() { Arg::new("option") .short('o') .takes_value(true) - .use_delimiter(true) + .use_value_delimiter(true) .multiple_values(true), ) .try_get_matches_from(vec!["myapp", "-o=val1,val2,val3"]) diff --git a/tests/builder/multiple_values.rs b/tests/builder/multiple_values.rs index 808a55103ce..74a5ee50f79 100644 --- a/tests/builder/multiple_values.rs +++ b/tests/builder/multiple_values.rs @@ -503,7 +503,7 @@ fn sep_long_equals() { Arg::new("option") .long("option") .help("multiple options") - .use_delimiter(true), + .use_value_delimiter(true), ) .try_get_matches_from(vec!["", "--option=val1,val2,val3"]); @@ -525,7 +525,7 @@ fn sep_long_space() { Arg::new("option") .long("option") .help("multiple options") - .use_delimiter(true), + .use_value_delimiter(true), ) .try_get_matches_from(vec!["", "--option", "val1,val2,val3"]); @@ -547,7 +547,7 @@ fn sep_short_equals() { Arg::new("option") .short('o') .help("multiple options") - .use_delimiter(true), + .use_value_delimiter(true), ) .try_get_matches_from(vec!["", "-o=val1,val2,val3"]); @@ -569,7 +569,7 @@ fn sep_short_space() { Arg::new("option") .short('o') .help("multiple options") - .use_delimiter(true), + .use_value_delimiter(true), ) .try_get_matches_from(vec!["", "-o", "val1,val2,val3"]); @@ -591,7 +591,7 @@ fn sep_short_no_space() { Arg::new("option") .short('o') .help("multiple options") - .use_delimiter(true), + .use_value_delimiter(true), ) .try_get_matches_from(vec!["", "-oval1,val2,val3"]); @@ -612,7 +612,7 @@ fn sep_positional() { .arg( Arg::new("option") .help("multiple options") - .use_delimiter(true), + .use_value_delimiter(true), ) .try_get_matches_from(vec!["", "val1,val2,val3"]); @@ -678,7 +678,7 @@ fn no_sep() { .long("option") .help("multiple options") .takes_value(true) - .use_delimiter(false), + .use_value_delimiter(false), ) .try_get_matches_from(vec!["", "--option=val1,val2,val3"]); @@ -697,7 +697,7 @@ fn no_sep_positional() { Arg::new("option") .help("multiple options") .takes_value(true) - .use_delimiter(false), + .use_value_delimiter(false), ) .try_get_matches_from(vec!["", "val1,val2,val3"]); @@ -716,8 +716,8 @@ fn req_delimiter_long() { Arg::new("option") .long("option") .multiple_values(true) - .use_delimiter(true) - .require_delimiter(true), + .use_value_delimiter(true) + .require_value_delimiter(true), ) .arg( Arg::new("args") @@ -749,8 +749,8 @@ fn req_delimiter_long_with_equal() { Arg::new("option") .long("option") .multiple_values(true) - .use_delimiter(true) - .require_delimiter(true), + .use_value_delimiter(true) + .require_value_delimiter(true), ) .arg( Arg::new("args") @@ -782,8 +782,8 @@ fn req_delimiter_short_with_space() { Arg::new("option") .short('o') .multiple_values(true) - .use_delimiter(true) - .require_delimiter(true), + .use_value_delimiter(true) + .require_value_delimiter(true), ) .arg( Arg::new("args") @@ -815,8 +815,8 @@ fn req_delimiter_short_with_no_space() { Arg::new("option") .short('o') .multiple_values(true) - .use_delimiter(true) - .require_delimiter(true), + .use_value_delimiter(true) + .require_value_delimiter(true), ) .arg( Arg::new("args") @@ -848,8 +848,8 @@ fn req_delimiter_short_with_equal() { Arg::new("option") .short('o') .multiple_values(true) - .use_delimiter(true) - .require_delimiter(true), + .use_value_delimiter(true) + .require_value_delimiter(true), ) .arg( Arg::new("args") @@ -883,8 +883,8 @@ fn req_delimiter_complex() { .short('o') .multiple_values(true) .multiple_occurrences(true) - .use_delimiter(true) - .require_delimiter(true), + .use_value_delimiter(true) + .require_value_delimiter(true), ) .arg( Arg::new("args") diff --git a/tests/builder/opts.rs b/tests/builder/opts.rs index 95eab5e9707..af60de34aab 100644 --- a/tests/builder/opts.rs +++ b/tests/builder/opts.rs @@ -305,7 +305,7 @@ fn multiple_vals_pos_arg_delim() { .arg( arg!(o: -o "some opt") .multiple_values(true) - .use_delimiter(true), + .use_value_delimiter(true), ) .arg(arg!([file] "some file")) .try_get_matches_from(vec!["", "-o", "1,2", "some"]); @@ -322,8 +322,8 @@ fn require_delims_no_delim() { let r = App::new("mvae") .arg( arg!(o: -o [opt] ... "some opt") - .use_delimiter(true) - .require_delimiter(true), + .use_value_delimiter(true) + .require_value_delimiter(true), ) .arg(arg!([file] "some file")) .try_get_matches_from(vec!["mvae", "-o", "1", "2", "some"]); @@ -338,8 +338,8 @@ fn require_delims() { .arg( arg!(o: -o "some opt") .multiple_values(true) - .use_delimiter(true) - .require_delimiter(true), + .use_value_delimiter(true) + .require_value_delimiter(true), ) .arg(arg!([file] "some file")) .try_get_matches_from(vec!["", "-o", "1,2", "some"]); diff --git a/tests/builder/posix_compatible.rs b/tests/builder/posix_compatible.rs index b0a9ad20e45..30d67f0f08d 100644 --- a/tests/builder/posix_compatible.rs +++ b/tests/builder/posix_compatible.rs @@ -51,8 +51,8 @@ fn mult_option_require_delim_overrides_itself() { .overrides_with("opt") .number_of_values(1) .takes_value(true) - .use_delimiter(true) - .require_delimiter(true), + .use_value_delimiter(true) + .require_value_delimiter(true), ) .try_get_matches_from(vec!["", "--opt=some", "--opt=other", "--opt=one,two"]); assert!(res.is_ok(), "{}", res.unwrap_err()); diff --git a/tests/macros.rs b/tests/macros.rs index af1ba7b2b06..5b975435e39 100644 --- a/tests/macros.rs +++ b/tests/macros.rs @@ -296,7 +296,7 @@ mod arg { assert_eq!(arg.get_name(), "foo"); assert_eq!(arg.get_long(), Some("bar")); assert_eq!(arg.get_value_names(), Some(vec!["NUM"].as_slice())); - assert!(arg.is_set(clap::ArgSettings::Required)); + assert!(arg.is_required_set()); } #[test] @@ -305,7 +305,7 @@ mod arg { assert_eq!(arg.get_name(), "bar"); assert_eq!(arg.get_long(), Some("bar")); assert_eq!(arg.get_value_names(), Some(vec!["NUM"].as_slice())); - assert!(arg.is_set(clap::ArgSettings::Required)); + assert!(arg.is_required_set()); } #[test] @@ -314,7 +314,7 @@ mod arg { assert_eq!(arg.get_name(), "NUM"); assert_eq!(arg.get_long(), None); assert_eq!(arg.get_value_names(), Some(vec!["NUM"].as_slice())); - assert!(arg.is_set(clap::ArgSettings::Required)); + assert!(arg.is_required_set()); } #[test] @@ -334,29 +334,29 @@ mod arg { let arg = clap::arg!(foo: -b); assert_eq!(arg.get_name(), "foo"); assert_eq!(arg.get_short(), Some('b')); - assert!(!arg.is_set(clap::ArgSettings::MultipleOccurrences)); - assert!(!arg.is_set(clap::ArgSettings::Required)); + assert!(!arg.is_multiple_occurrences_set()); + assert!(!arg.is_required_set()); assert_eq!(arg.get_help(), None); let arg = clap::arg!(foo: -'b'); assert_eq!(arg.get_name(), "foo"); assert_eq!(arg.get_short(), Some('b')); - assert!(!arg.is_set(clap::ArgSettings::MultipleOccurrences)); - assert!(!arg.is_set(clap::ArgSettings::Required)); + assert!(!arg.is_multiple_occurrences_set()); + assert!(!arg.is_required_set()); assert_eq!(arg.get_help(), None); let arg = clap::arg!(foo: -b ...); assert_eq!(arg.get_name(), "foo"); assert_eq!(arg.get_short(), Some('b')); - assert!(arg.is_set(clap::ArgSettings::MultipleOccurrences)); - assert!(!arg.is_set(clap::ArgSettings::Required)); + assert!(arg.is_multiple_occurrences_set()); + assert!(!arg.is_required_set()); assert_eq!(arg.get_help(), None); let arg = clap::arg!(foo: -b "How to use it"); assert_eq!(arg.get_name(), "foo"); assert_eq!(arg.get_short(), Some('b')); - assert!(!arg.is_set(clap::ArgSettings::MultipleOccurrences)); - assert!(!arg.is_set(clap::ArgSettings::Required)); + assert!(!arg.is_multiple_occurrences_set()); + assert!(!arg.is_required_set()); assert_eq!(arg.get_help(), Some("How to use it")); } @@ -366,32 +366,32 @@ mod arg { assert_eq!(arg.get_name(), "foo"); assert_eq!(arg.get_long(), Some("hello")); assert_eq!(arg.get_short(), Some('b')); - assert!(!arg.is_set(clap::ArgSettings::MultipleOccurrences)); - assert!(!arg.is_set(clap::ArgSettings::Required)); + assert!(!arg.is_multiple_occurrences_set()); + assert!(!arg.is_required_set()); assert_eq!(arg.get_help(), None); let arg = clap::arg!(foo: -'b' --hello); assert_eq!(arg.get_name(), "foo"); assert_eq!(arg.get_long(), Some("hello")); assert_eq!(arg.get_short(), Some('b')); - assert!(!arg.is_set(clap::ArgSettings::MultipleOccurrences)); - assert!(!arg.is_set(clap::ArgSettings::Required)); + assert!(!arg.is_multiple_occurrences_set()); + assert!(!arg.is_required_set()); assert_eq!(arg.get_help(), None); let arg = clap::arg!(foo: -b --hello ...); assert_eq!(arg.get_name(), "foo"); assert_eq!(arg.get_long(), Some("hello")); assert_eq!(arg.get_short(), Some('b')); - assert!(arg.is_set(clap::ArgSettings::MultipleOccurrences)); - assert!(!arg.is_set(clap::ArgSettings::Required)); + assert!(arg.is_multiple_occurrences_set()); + assert!(!arg.is_required_set()); assert_eq!(arg.get_help(), None); let arg = clap::arg!(foo: -b --hello "How to use it"); assert_eq!(arg.get_name(), "foo"); assert_eq!(arg.get_long(), Some("hello")); assert_eq!(arg.get_short(), Some('b')); - assert!(!arg.is_set(clap::ArgSettings::MultipleOccurrences)); - assert!(!arg.is_set(clap::ArgSettings::Required)); + assert!(!arg.is_multiple_occurrences_set()); + assert!(!arg.is_required_set()); assert_eq!(arg.get_help(), Some("How to use it")); } @@ -400,43 +400,43 @@ mod arg { let arg = clap::arg!(); assert_eq!(arg.get_name(), "NUM"); assert_eq!(arg.get_value_names(), Some(vec!["NUM"].as_slice())); - assert!(!arg.is_set(clap::ArgSettings::MultipleOccurrences)); - assert!(arg.is_set(clap::ArgSettings::Required)); + assert!(!arg.is_multiple_occurrences_set()); + assert!(arg.is_required_set()); assert_eq!(arg.get_help(), None); let arg = clap::arg!([NUM]); assert_eq!(arg.get_name(), "NUM"); assert_eq!(arg.get_value_names(), Some(vec!["NUM"].as_slice())); - assert!(!arg.is_set(clap::ArgSettings::MultipleOccurrences)); - assert!(!arg.is_set(clap::ArgSettings::Required)); + assert!(!arg.is_multiple_occurrences_set()); + assert!(!arg.is_required_set()); assert_eq!(arg.get_help(), None); let arg = clap::arg!(); assert_eq!(arg.get_name(), "NUM"); assert_eq!(arg.get_value_names(), Some(vec!["NUM"].as_slice())); - assert!(!arg.is_set(clap::ArgSettings::MultipleOccurrences)); - assert!(arg.is_set(clap::ArgSettings::Required)); + assert!(!arg.is_multiple_occurrences_set()); + assert!(arg.is_required_set()); assert_eq!(arg.get_help(), None); let arg = clap::arg!(foo: ); assert_eq!(arg.get_name(), "foo"); assert_eq!(arg.get_value_names(), Some(vec!["NUM"].as_slice())); - assert!(!arg.is_set(clap::ArgSettings::MultipleOccurrences)); - assert!(arg.is_set(clap::ArgSettings::Required)); + assert!(!arg.is_multiple_occurrences_set()); + assert!(arg.is_required_set()); assert_eq!(arg.get_help(), None); let arg = clap::arg!( ...); assert_eq!(arg.get_name(), "NUM"); assert_eq!(arg.get_value_names(), Some(vec!["NUM"].as_slice())); - assert!(arg.is_set(clap::ArgSettings::MultipleOccurrences)); - assert!(arg.is_set(clap::ArgSettings::Required)); + assert!(arg.is_multiple_occurrences_set()); + assert!(arg.is_required_set()); assert_eq!(arg.get_help(), None); let arg = clap::arg!( "How to use it"); assert_eq!(arg.get_name(), "NUM"); assert_eq!(arg.get_value_names(), Some(vec!["NUM"].as_slice())); - assert!(!arg.is_set(clap::ArgSettings::MultipleOccurrences)); - assert!(arg.is_set(clap::ArgSettings::Required)); + assert!(!arg.is_multiple_occurrences_set()); + assert!(arg.is_required_set()); assert_eq!(arg.get_help(), Some("How to use it")); } }