Quellsprache: Binärcode.rs aufgebrochen in jeweils 16 ZeichenUnknown {[0] [0] [0]}zum Wurzelverzeichnis wechseln
// Std
#[cfg(feature = "env")]
use std::env;
#[cfg(feature = "env")]
use std::ffi::OsString;
use std::{
cmp::{Ord, Ordering},
fmt::{self, Display, Formatter},
str,
};
// Internal
use super::{ArgFlags, ArgSettings};
#[cfg(feature = "unstable-ext")]
use crate::builder::ext::Extension;
use crate::builder::ext::Extensions;
use crate::builder::ArgPredicate;
use crate::builder::IntoResettable;
use crate::builder::OsStr;
use crate::builder::PossibleValue;
use crate::builder::Str;
use crate::builder::StyledStr;
use crate::builder::Styles;
use crate::builder::ValueRange;
use crate::util::AnyValueId;
use crate::ArgAction;
use crate::Id;
use crate::ValueHint;
use crate::INTERNAL_ERROR_MSG;
/// The abstract representation of a command line argument. Used to set all the options and
/// relationships that define a valid argument for the program.
///
/// There are two methods for constructing [`Arg`]s, using the builder pattern and setting options
/// manually, or using a usage string which is far less verbose but has fewer options. You can also
/// use a combination of the two methods to achieve the best of both worlds.
///
/// - [Basic API][crate::Arg#basic-api]
/// - [Value Handling][crate::Arg#value-handling]
/// - [Help][crate::Arg#help-1]
/// - [Advanced Argument Relations][crate::Arg#advanced-argument-relations]
/// - [Reflection][crate::Arg#reflection]
///
/// # Examples
///
/// ```rust
/// # use clap_builder as clap;
/// # use clap::{Arg, arg, ArgAction};
/// // Using the traditional builder pattern and setting each option manually
/// let cfg = Arg::new("config")
/// .short('c')
/// .long("config")
/// .action(ArgAction::Set)
/// .value_name("FILE")
/// .help("Provides a config file to myprog");
/// // Using a usage string (setting a similar argument to the one above)
/// let input = arg!(-i --input <FILE> "Provides an input file to the program");
/// ```
#[derive(Default, Clone)]
pub struct Arg {
pub(crate) id: Id,
pub(crate) help: Option<StyledStr>,
pub(crate) long_help: Option<StyledStr>,
pub(crate) action: Option<ArgAction>,
pub(crate) value_parser: Option<super::ValueParser>,
pub(crate) blacklist: Vec<Id>,
pub(crate) settings: ArgFlags,
pub(crate) overrides: Vec<Id>,
pub(crate) groups: Vec<Id>,
pub(crate) requires: Vec<(ArgPredicate, Id)>,
pub(crate) r_ifs: Vec<(Id, OsStr)>,
pub(crate) r_ifs_all: Vec<(Id, OsStr)>,
pub(crate) r_unless: Vec<Id>,
pub(crate) r_unless_all: Vec<Id>,
pub(crate) short: Option<char>,
pub(crate) long: Option<Str>,
pub(crate) aliases: Vec<(Str, bool)>, // (name, visible)
pub(crate) short_aliases: Vec<(char, bool)>, // (name, visible)
pub(crate) disp_ord: Option<usize>,
pub(crate) val_names: Vec<Str>,
pub(crate) num_vals: Option<ValueRange>,
pub(crate) val_delim: Option<char>,
pub(crate) default_vals: Vec<OsStr>,
pub(crate) default_vals_ifs: Vec<(Id, ArgPredicate, Option<OsStr>)>,
pub(crate) default_missing_vals: Vec<OsStr>,
#[cfg(feature = "env")]
pub(crate) env: Option<(OsStr, Option<OsString>)>,
pub(crate) terminator: Option<Str>,
pub(crate) index: Option<usize>,
pub(crate) help_heading: Option<Option<Str>>,
pub(crate) ext: Extensions,
}
/// # Basic API
impl Arg {
/// Create a new [`Arg`] with a unique name.
///
/// The name is used to check whether or not the argument was used at
/// runtime, get values, set relationships with other args, etc..
///
/// **NOTE:** In the case of arguments that take values (i.e. [`Arg::action(ArgAction::Set)`])
/// and positional arguments (i.e. those without a preceding `-` or `--`) the name will also
/// be displayed when the user prints the usage/help information of the program.
///
/// # Examples
///
/// ```rust
/// # use clap_builder as clap;
/// # use clap::{Command, Arg};
/// Arg::new("config")
/// # ;
/// ```
/// [`Arg::action(ArgAction::Set)`]: Arg::action()
pub fn new(id: impl Into<Id>) -> Self {
Arg::default().id(id)
}
/// Set the identifier used for referencing this argument in the clap API.
///
/// See [`Arg::new`] for more details.
#[must_use]
pub fn id(mut self, id: impl Into<Id>) -> Self {
self.id = id.into();
self
}
/// Sets the short version of the argument without the preceding `-`.
///
/// By default `V` and `h` are used by the auto-generated `version` and `help` arguments,
/// respectively. You will need to disable the auto-generated flags
/// ([`disable_help_flag`][crate::Command::disable_help_flag],
/// [`disable_version_flag`][crate::Command::disable_version_flag]) and define your own.
///
/// # Examples
///
/// When calling `short`, use a single valid UTF-8 character which will allow using the
/// argument via a single hyphen (`-`) such as `-c`:
///
/// ```rust
/// # use clap_builder as clap;
/// # use clap::{Command, Arg, ArgAction};
/// let m = Command::new("prog")
/// .arg(Arg::new("config")
/// .short('c')
/// .action(ArgAction::Set))
/// .get_matches_from(vec![
/// "prog", "-c", "file.toml"
/// ]);
///
/// assert_eq!(m.get_one::<String>("config").map(String::as_str), Some("file.toml"));
/// ```
///
/// To use `-h` for your own flag and still have help:
/// ```rust
/// # use clap_builder as clap;
/// # use clap::{Command, Arg, ArgAction};
/// let m = Command::new("prog")
/// .disable_help_flag(true)
/// .arg(Arg::new("host")
/// .short('h')
/// .long("host"))
/// .arg(Arg::new("help")
/// .long("help")
/// .global(true)
/// .action(ArgAction::Help))
/// .get_matches_from(vec![
/// "prog", "-h", "wikipedia.org"
/// ]);
///
/// assert_eq!(m.get_one::<String>("host").map(String::as_str), Some("wikipedia.org"));
/// ```
#[inline]
#[must_use]
pub fn short(mut self, s: impl IntoResettable<char>) -> Self {
if let Some(s) = s.into_resettable().into_option() {
debug_assert!(s != '-', "short option name cannot be `-`");
self.short = Some(s);
} else {
self.short = None;
}
self
}
/// Sets the long version of the argument without the preceding `--`.
///
/// By default `version` and `help` are used by the auto-generated `version` and `help`
/// arguments, respectively. You may use the word `version` or `help` for the long form of your
/// own arguments, in which case `clap` simply will not assign those to the auto-generated
/// `version` or `help` arguments.
///
/// **NOTE:** Any leading `-` characters will be stripped
///
/// # Examples
///
/// To set `long` use a word containing valid UTF-8. If you supply a double leading
/// `--` such as `--config` they will be stripped. Hyphens in the middle of the word, however,
/// will *not* be stripped (i.e. `config-file` is allowed).
///
/// Setting `long` allows using the argument via a double hyphen (`--`) such as `--config`
///
/// ```rust
/// # use clap_builder as clap;
/// # use clap::{Command, Arg, ArgAction};
/// let m = Command::new("prog")
/// .arg(Arg::new("cfg")
/// .long("config")
/// .action(ArgAction::Set))
/// .get_matches_from(vec![
/// "prog", "--config", "file.toml"
/// ]);
///
/// assert_eq!(m.get_one::<String>("cfg").map(String::as_str), Some("file.toml"));
/// ```
#[inline]
#[must_use]
pub fn long(mut self, l: impl IntoResettable<Str>) -> Self {
self.long = l.into_resettable().into_option();
self
}
/// Add an alias, which functions as a hidden long flag.
///
/// This is more efficient, and easier than creating multiple hidden arguments as one only
/// needs to check for the existence of this command, and not all variants.
///
/// # Examples
///
/// ```rust
/// # use clap_builder as clap;
/// # use clap::{Command, Arg, ArgAction};
/// let m = Command::new("prog")
/// .arg(Arg::new("test")
/// .long("test")
/// .alias("alias")
/// .action(ArgAction::Set))
/// .get_matches_from(vec![
/// "prog", "--alias", "cool"
/// ]);
/// assert_eq!(m.get_one::<String>("test").unwrap(), "cool");
/// ```
#[must_use]
pub fn alias(mut self, name: impl IntoResettable<Str>) -> Self {
if let Some(name) = name.into_resettable().into_option() {
self.aliases.push((name, false));
} else {
self.aliases.clear();
}
self
}
/// Add an alias, which functions as a hidden short flag.
///
/// This is more efficient, and easier than creating multiple hidden arguments as one only
/// needs to check for the existence of this command, and not all variants.
///
/// # Examples
///
/// ```rust
/// # use clap_builder as clap;
/// # use clap::{Command, Arg, ArgAction};
/// let m = Command::new("prog")
/// .arg(Arg::new("test")
/// .short('t')
/// .short_alias('e')
/// .action(ArgAction::Set))
/// .get_matches_from(vec![
/// "prog", "-e", "cool"
/// ]);
/// assert_eq!(m.get_one::<String>("test").unwrap(), "cool");
/// ```
#[must_use]
pub fn short_alias(mut self, name: impl IntoResettable<char>) -> Self {
if let Some(name) = name.into_resettable().into_option() {
debug_assert!(name != '-', "short alias name cannot be `-`");
self.short_aliases.push((name, false));
} else {
self.short_aliases.clear();
}
self
}
/// Add aliases, which function as hidden long flags.
///
/// This is more efficient, and easier than creating multiple hidden subcommands as one only
/// needs to check for the existence of this command, and not all variants.
///
/// # Examples
///
/// ```rust
/// # use clap_builder as clap;
/// # use clap::{Command, Arg, ArgAction};
/// let m = Command::new("prog")
/// .arg(Arg::new("test")
/// .long("test")
/// .aliases(["do-stuff", "do-tests", "tests"])
/// .action(ArgAction::SetTrue)
/// .help("the file to add")
/// .required(false))
/// .get_matches_from(vec![
/// "prog", "--do-tests"
/// ]);
/// assert_eq!(m.get_flag("test"), true);
/// ```
#[must_use]
pub fn aliases(mut self, names: impl IntoIterator<Item = impl Into<Str>>) -> Self {
self.aliases
.extend(names.into_iter().map(|x| (x.into(), false)));
self
}
/// Add aliases, which functions as a hidden short flag.
///
/// This is more efficient, and easier than creating multiple hidden subcommands as one only
/// needs to check for the existence of this command, and not all variants.
///
/// # Examples
///
/// ```rust
/// # use clap_builder as clap;
/// # use clap::{Command, Arg, ArgAction};
/// let m = Command::new("prog")
/// .arg(Arg::new("test")
/// .short('t')
/// .short_aliases(['e', 's'])
/// .action(ArgAction::SetTrue)
/// .help("the file to add")
/// .required(false))
/// .get_matches_from(vec![
/// "prog", "-s"
/// ]);
/// assert_eq!(m.get_flag("test"), true);
/// ```
#[must_use]
pub fn short_aliases(mut self, names: impl IntoIterator<Item = char>) -> Self {
for s in names {
debug_assert!(s != '-', "short alias name cannot be `-`");
self.short_aliases.push((s, false));
}
self
}
/// Add an alias, which functions as a visible long flag.
///
/// Like [`Arg::alias`], except that they are visible inside the help message.
///
/// # Examples
///
/// ```rust
/// # use clap_builder as clap;
/// # use clap::{Command, Arg, ArgAction};
/// let m = Command::new("prog")
/// .arg(Arg::new("test")
/// .visible_alias("something-awesome")
/// .long("test")
/// .action(ArgAction::Set))
/// .get_matches_from(vec![
/// "prog", "--something-awesome", "coffee"
/// ]);
/// assert_eq!(m.get_one::<String>("test").unwrap(), "coffee");
/// ```
/// [`Command::alias`]: Arg::alias()
#[must_use]
pub fn visible_alias(mut self, name: impl IntoResettable<Str>) -> Self {
if let Some(name) = name.into_resettable().into_option() {
self.aliases.push((name, true));
} else {
self.aliases.clear();
}
self
}
/// Add an alias, which functions as a visible short flag.
///
/// Like [`Arg::short_alias`], except that they are visible inside the help message.
///
/// # Examples
///
/// ```rust
/// # use clap_builder as clap;
/// # use clap::{Command, Arg, ArgAction};
/// let m = Command::new("prog")
/// .arg(Arg::new("test")
/// .long("test")
/// .visible_short_alias('t')
/// .action(ArgAction::Set))
/// .get_matches_from(vec![
/// "prog", "-t", "coffee"
/// ]);
/// assert_eq!(m.get_one::<String>("test").unwrap(), "coffee");
/// ```
#[must_use]
pub fn visible_short_alias(mut self, name: impl IntoResettable<char>) -> Self {
if let Some(name) = name.into_resettable().into_option() {
debug_assert!(name != '-', "short alias name cannot be `-`");
self.short_aliases.push((name, true));
} else {
self.short_aliases.clear();
}
self
}
/// Add aliases, which function as visible long flags.
///
/// Like [`Arg::aliases`], except that they are visible inside the help message.
///
/// # Examples
///
/// ```rust
/// # use clap_builder as clap;
/// # use clap::{Command, Arg, ArgAction};
/// let m = Command::new("prog")
/// .arg(Arg::new("test")
/// .long("test")
/// .action(ArgAction::SetTrue)
/// .visible_aliases(["something", "awesome", "cool"]))
/// .get_matches_from(vec![
/// "prog", "--awesome"
/// ]);
/// assert_eq!(m.get_flag("test"), true);
/// ```
/// [`Command::aliases`]: Arg::aliases()
#[must_use]
pub fn visible_aliases(mut self, names: impl IntoIterator<Item = impl Into<Str>>) -> Self {
self.aliases
.extend(names.into_iter().map(|n| (n.into(), true)));
self
}
/// Add aliases, which function as visible short flags.
///
/// Like [`Arg::short_aliases`], except that they are visible inside the help message.
///
/// # Examples
///
/// ```rust
/// # use clap_builder as clap;
/// # use clap::{Command, Arg, ArgAction};
/// let m = Command::new("prog")
/// .arg(Arg::new("test")
/// .long("test")
/// .action(ArgAction::SetTrue)
/// .visible_short_aliases(['t', 'e']))
/// .get_matches_from(vec![
/// "prog", "-t"
/// ]);
/// assert_eq!(m.get_flag("test"), true);
/// ```
#[must_use]
pub fn visible_short_aliases(mut self, names: impl IntoIterator<Item = char>) -> Self {
for n in names {
debug_assert!(n != '-', "short alias name cannot be `-`");
self.short_aliases.push((n, true));
}
self
}
/// Specifies the index of a positional argument **starting at** 1.
///
/// **NOTE:** The index refers to position according to **other positional argument**. It does
/// not define position in the argument list as a whole.
///
/// **NOTE:** You can optionally leave off the `index` method, and the index will be
/// assigned in order of evaluation. Utilizing the `index` method allows for setting
/// indexes out of order
///
/// **NOTE:** This is only meant to be used for positional arguments and shouldn't to be used
/// with [`Arg::short`] or [`Arg::long`].
///
/// **NOTE:** When utilized with [`Arg::num_args(1..)`], only the **last** positional argument
/// may be defined as having a variable number of arguments (i.e. with the highest index)
///
/// # Panics
///
/// [`Command`] will [`panic!`] if indexes are skipped (such as defining `index(1)` and `index(3)`
/// but not `index(2)`, or a positional argument is defined as multiple and is not the highest
/// index (debug builds)
///
/// # Examples
///
/// ```rust
/// # use clap_builder as clap;
/// # use clap::{Command, Arg};
/// Arg::new("config")
/// .index(1)
/// # ;
/// ```
///
/// ```rust
/// # use clap_builder as clap;
/// # use clap::{Command, Arg, ArgAction};
/// let m = Command::new("prog")
/// .arg(Arg::new("mode")
/// .index(1))
/// .arg(Arg::new("debug")
/// .long("debug")
/// .action(ArgAction::SetTrue))
/// .get_matches_from(vec![
/// "prog", "--debug", "fast"
/// ]);
///
/// assert!(m.contains_id("mode"));
/// assert_eq!(m.get_one::<String>("mode").unwrap(), "fast"); // notice index(1) means "first positional"
/// // *not* first argument
/// ```
/// [`Arg::short`]: Arg::short()
/// [`Arg::long`]: Arg::long()
/// [`Arg::num_args(true)`]: Arg::num_args()
/// [`Command`]: crate::Command
#[inline]
#[must_use]
pub fn index(mut self, idx: impl IntoResettable<usize>) -> Self {
self.index = idx.into_resettable().into_option();
self
}
/// This is a "var arg" and everything that follows should be captured by it, as if the user had
/// used a `--`.
///
/// **NOTE:** To start the trailing "var arg" on unknown flags (and not just a positional
/// value), set [`allow_hyphen_values`][Arg::allow_hyphen_values]. Either way, users still
/// have the option to explicitly escape ambiguous arguments with `--`.
///
/// **NOTE:** [`Arg::value_delimiter`] still applies if set.
///
/// **NOTE:** Setting this requires [`Arg::num_args(..)`].
///
/// # Examples
///
/// ```rust
/// # use clap_builder as clap;
/// # use clap::{Command, arg};
/// let m = Command::new("myprog")
/// .arg(arg!(<cmd> ... "commands to run").trailing_var_arg(true))
/// .get_matches_from(vec!["myprog", "arg1", "-r", "val1"]);
///
/// let trail: Vec<_> = m.get_many::<String>("cmd").unwrap().collect();
/// assert_eq!(trail, ["arg1", "-r", "val1"]);
/// ```
/// [`Arg::num_args(..)`]: crate::Arg::num_args()
pub fn trailing_var_arg(self, yes: bool) -> Self {
if yes {
self.setting(ArgSettings::TrailingVarArg)
} else {
self.unset_setting(ArgSettings::TrailingVarArg)
}
}
/// This arg is the last, or final, positional argument (i.e. has the highest
/// index) and is *only* able to be accessed via the `--` syntax (i.e. `$ prog args --
/// last_arg`).
///
/// Even, if no other arguments are left to parse, if the user omits the `--` syntax
/// they will receive an [`UnknownArgument`] error. Setting an argument to `.last(true)` also
/// allows one to access this arg early using the `--` syntax. Accessing an arg early, even with
/// the `--` syntax is otherwise not possible.
///
/// **NOTE:** This will change the usage string to look like `$ prog [OPTIONS] [-- <ARG>]` if
/// `ARG` is marked as `.last(true)`.
///
/// **NOTE:** This setting will imply [`crate::Command::dont_collapse_args_in_usage`] because failing
/// to set this can make the usage string very confusing.
///
/// **NOTE**: This setting only applies to positional arguments, and has no effect on OPTIONS
///
/// **NOTE:** Setting this requires [taking values][Arg::num_args]
///
/// **CAUTION:** Using this setting *and* having child subcommands is not
/// recommended with the exception of *also* using
/// [`crate::Command::args_conflicts_with_subcommands`]
/// (or [`crate::Command::subcommand_negates_reqs`] if the argument marked `Last` is also
/// marked [`Arg::required`])
///
/// # Examples
///
/// ```rust
/// # use clap_builder as clap;
/// # use clap::{Arg, ArgAction};
/// Arg::new("args")
/// .action(ArgAction::Set)
/// .last(true)
/// # ;
/// ```
///
/// Setting `last` ensures the arg has the highest [index] of all positional args
/// and requires that the `--` syntax be used to access it early.
///
/// ```rust
/// # use clap_builder as clap;
/// # use clap::{Command, Arg, ArgAction};
/// let res = Command::new("prog")
/// .arg(Arg::new("first"))
/// .arg(Arg::new("second"))
/// .arg(Arg::new("third")
/// .action(ArgAction::Set)
/// .last(true))
/// .try_get_matches_from(vec![
/// "prog", "one", "--", "three"
/// ]);
///
/// assert!(res.is_ok());
/// let m = res.unwrap();
/// assert_eq!(m.get_one::<String>("third").unwrap(), "three");
/// assert_eq!(m.get_one::<String>("second"), None);
/// ```
///
/// Even if the positional argument marked `Last` is the only argument left to parse,
/// failing to use the `--` syntax results in an error.
///
/// ```rust
/// # use clap_builder as clap;
/// # use clap::{Command, Arg, error::ErrorKind, ArgAction};
/// let res = Command::new("prog")
/// .arg(Arg::new("first"))
/// .arg(Arg::new("second"))
/// .arg(Arg::new("third")
/// .action(ArgAction::Set)
/// .last(true))
/// .try_get_matches_from(vec![
/// "prog", "one", "two", "three"
/// ]);
///
/// assert!(res.is_err());
/// assert_eq!(res.unwrap_err().kind(), ErrorKind::UnknownArgument);
/// ```
/// [index]: Arg::index()
/// [`UnknownArgument`]: crate::error::ErrorKind::UnknownArgument
#[inline]
#[must_use]
pub fn last(self, yes: bool) -> Self {
if yes {
self.setting(ArgSettings::Last)
} else {
self.unset_setting(ArgSettings::Last)
}
}
/// Specifies that the argument must be present.
///
/// Required by default means it is required, when no other conflicting rules or overrides have
/// been evaluated. Conflicting rules take precedence over being required.
///
/// **Pro tip:** Flags (i.e. not positional, or arguments that take values) shouldn't be
/// required by default. This is because if a flag were to be required, it should simply be
/// implied. No additional information is required from user. Flags by their very nature are
/// simply boolean on/off switches. The only time a user *should* be required to use a flag
/// is if the operation is destructive in nature, and the user is essentially proving to you,
/// "Yes, I know what I'm doing."
///
/// # Examples
///
/// ```rust
/// # use clap_builder as clap;
/// # use clap::Arg;
/// Arg::new("config")
/// .required(true)
/// # ;
/// ```
///
/// Setting required requires that the argument be used at runtime.
///
/// ```rust
/// # use clap_builder as clap;
/// # use clap::{Command, Arg, ArgAction};
/// let res = Command::new("prog")
/// .arg(Arg::new("cfg")
/// .required(true)
/// .action(ArgAction::Set)
/// .long("config"))
/// .try_get_matches_from(vec![
/// "prog", "--config", "file.conf",
/// ]);
///
/// assert!(res.is_ok());
/// ```
///
/// Setting required and then *not* supplying that argument at runtime is an error.
///
/// ```rust
/// # use clap_builder as clap;
/// # use clap::{Command, Arg, error::ErrorKind, ArgAction};
/// let res = Command::new("prog")
/// .arg(Arg::new("cfg")
/// .required(true)
/// .action(ArgAction::Set)
/// .long("config"))
/// .try_get_matches_from(vec![
/// "prog"
/// ]);
///
/// assert!(res.is_err());
/// assert_eq!(res.unwrap_err().kind(), ErrorKind::MissingRequiredArgument);
/// ```
#[inline]
#[must_use]
pub fn required(self, yes: bool) -> Self {
if yes {
self.setting(ArgSettings::Required)
} else {
self.unset_setting(ArgSettings::Required)
}
}
/// Sets an argument that is required when this one is present
///
/// i.e. when using this argument, the following argument *must* be present.
///
/// **NOTE:** [Conflicting] rules and [override] rules take precedence over being required
///
/// # Examples
///
/// ```rust
/// # use clap_builder as clap;
/// # use clap::Arg;
/// Arg::new("config")
/// .requires("input")
/// # ;
/// ```
///
/// Setting [`Arg::requires(name)`] requires that the argument be used at runtime if the
/// defining argument is used. If the defining argument isn't used, the other argument isn't
/// required
///
/// ```rust
/// # use clap_builder as clap;
/// # use clap::{Command, Arg, ArgAction};
/// let res = Command::new("prog")
/// .arg(Arg::new("cfg")
/// .action(ArgAction::Set)
/// .requires("input")
/// .long("config"))
/// .arg(Arg::new("input"))
/// .try_get_matches_from(vec![
/// "prog"
/// ]);
///
/// assert!(res.is_ok()); // We didn't use cfg, so input wasn't required
/// ```
///
/// Setting [`Arg::requires(name)`] and *not* supplying that argument is an error.
///
/// ```rust
/// # use clap_builder as clap;
/// # use clap::{Command, Arg, error::ErrorKind, ArgAction};
/// let res = Command::new("prog")
/// .arg(Arg::new("cfg")
/// .action(ArgAction::Set)
/// .requires("input")
/// .long("config"))
/// .arg(Arg::new("input"))
/// .try_get_matches_from(vec![
/// "prog", "--config", "file.conf"
/// ]);
///
/// assert!(res.is_err());
/// assert_eq!(res.unwrap_err().kind(), ErrorKind::MissingRequiredArgument);
/// ```
/// [`Arg::requires(name)`]: Arg::requires()
/// [Conflicting]: Arg::conflicts_with()
/// [override]: Arg::overrides_with()
#[must_use]
pub fn requires(mut self, arg_id: impl IntoResettable<Id>) -> Self {
if let Some(arg_id) = arg_id.into_resettable().into_option() {
self.requires.push((ArgPredicate::IsPresent, arg_id));
} else {
self.requires.clear();
}
self
}
/// This argument must be passed alone; it conflicts with all other arguments.
///
/// # Examples
///
/// ```rust
/// # use clap_builder as clap;
/// # use clap::Arg;
/// Arg::new("config")
/// .exclusive(true)
/// # ;
/// ```
///
/// Setting an exclusive argument and having any other arguments present at runtime
/// is an error.
///
/// ```rust
/// # use clap_builder as clap;
/// # use clap::{Command, Arg, error::ErrorKind, ArgAction};
/// let res = Command::new("prog")
/// .arg(Arg::new("exclusive")
/// .action(ArgAction::Set)
/// .exclusive(true)
/// .long("exclusive"))
/// .arg(Arg::new("debug")
/// .long("debug"))
/// .arg(Arg::new("input"))
/// .try_get_matches_from(vec![
/// "prog", "--exclusive", "file.conf", "file.txt"
/// ]);
///
/// assert!(res.is_err());
/// assert_eq!(res.unwrap_err().kind(), ErrorKind::ArgumentConflict);
/// ```
#[inline]
#[must_use]
pub fn exclusive(self, yes: bool) -> Self {
if yes {
self.setting(ArgSettings::Exclusive)
} else {
self.unset_setting(ArgSettings::Exclusive)
}
}
/// Specifies that an argument can be matched to all child [`Subcommand`]s.
///
/// **NOTE:** Global arguments *only* propagate down, **not** up (to parent commands), however
/// their values once a user uses them will be propagated back up to parents. In effect, this
/// means one should *define* all global arguments at the top level, however it doesn't matter
/// where the user *uses* the global argument.
///
/// # Examples
///
/// Assume an application with two subcommands, and you'd like to define a
/// `--verbose` flag that can be called on any of the subcommands and parent, but you don't
/// want to clutter the source with three duplicate [`Arg`] definitions.
///
/// ```rust
/// # use clap_builder as clap;
/// # use clap::{Command, Arg, ArgAction};
/// let m = Command::new("prog")
/// .arg(Arg::new("verb")
/// .long("verbose")
/// .short('v')
/// .action(ArgAction::SetTrue)
/// .global(true))
/// .subcommand(Command::new("test"))
/// .subcommand(Command::new("do-stuff"))
/// .get_matches_from(vec![
/// "prog", "do-stuff", "--verbose"
/// ]);
///
/// assert_eq!(m.subcommand_name(), Some("do-stuff"));
/// let sub_m = m.subcommand_matches("do-stuff").unwrap();
/// assert_eq!(sub_m.get_flag("verb"), true);
/// ```
///
/// [`Subcommand`]: crate::Subcommand
#[inline]
#[must_use]
pub fn global(self, yes: bool) -> Self {
if yes {
self.setting(ArgSettings::Global)
} else {
self.unset_setting(ArgSettings::Global)
}
}
#[inline]
pub(crate) fn is_set(&self, s: ArgSettings) -> bool {
self.settings.is_set(s)
}
#[inline]
#[must_use]
pub(crate) fn setting(mut self, setting: ArgSettings) -> Self {
self.settings.set(setting);
self
}
#[inline]
#[must_use]
pub(crate) fn unset_setting(mut self, setting: ArgSettings) -> Self {
self.settings.unset(setting);
self
}
/// Extend [`Arg`] with [`ArgExt`] data
#[cfg(feature = "unstable-ext")]
#[allow(clippy::should_implement_trait)]
pub fn add<T: ArgExt + Extension>(mut self, tagged: T) -> Self {
self.ext.set(tagged);
self
}
}
/// # Value Handling
impl Arg {
/// Specify how to react to an argument when parsing it.
///
/// [`ArgAction`] controls things like
/// - Overwriting previous values with new ones
/// - Appending new values to all previous ones
/// - Counting how many times a flag occurs
///
/// The default action is `ArgAction::Set`
///
/// # Examples
///
/// ```rust
/// # use clap_builder as clap;
/// # use clap::Command;
/// # use clap::Arg;
/// let cmd = Command::new("mycmd")
/// .arg(
/// Arg::new("flag")
/// .long("flag")
/// .action(clap::ArgAction::Append)
/// );
///
/// let matches = cmd.try_get_matches_from(["mycmd", "--flag", "value"]).unwrap();
/// assert!(matches.contains_id("flag"));
/// assert_eq!(
/// matches.get_many::<String>("flag").unwrap_or_default().map(|v| v.as_str()).collect::<Vec<_>>(),
/// vec!["value"]
/// );
/// ```
#[inline]
#[must_use]
pub fn action(mut self, action: impl IntoResettable<ArgAction>) -> Self {
self.action = action.into_resettable().into_option();
self
}
/// Specify the typed behavior of the argument.
///
/// This allows parsing and validating a value before storing it into
/// [`ArgMatches`][crate::ArgMatches] as the given type.
///
/// Possible value parsers include:
/// - [`value_parser!(T)`][crate::value_parser!] for auto-selecting a value parser for a given type
/// - Or [range expressions like `0..=1`][std::ops::RangeBounds] as a shorthand for [`RangedI64ValueParser`][crate::builder::RangedI64ValueParser]
/// - `Fn(&str) -> Result<T, E>`
/// - `[&str]` and [`PossibleValuesParser`][crate::builder::PossibleValuesParser] for static enumerated values
/// - [`BoolishValueParser`][crate::builder::BoolishValueParser], and [`FalseyValueParser`][crate::builder::FalseyValueParser] for alternative `bool` implementations
/// - [`NonEmptyStringValueParser`][crate::builder::NonEmptyStringValueParser] for basic validation for strings
/// - or any other [`TypedValueParser`][crate::builder::TypedValueParser] implementation
///
/// The default value is [`ValueParser::string`][crate::builder::ValueParser::string].
///
/// ```rust
/// # use clap_builder as clap;
/// # use clap::ArgAction;
/// let mut cmd = clap::Command::new("raw")
/// .arg(
/// clap::Arg::new("color")
/// .long("color")
/// .value_parser(["always", "auto", "never"])
/// .default_value("auto")
/// )
/// .arg(
/// clap::Arg::new("hostname")
/// .long("hostname")
/// .value_parser(clap::builder::NonEmptyStringValueParser::new())
/// .action(ArgAction::Set)
/// .required(true)
/// )
/// .arg(
/// clap::Arg::new("port")
/// .long("port")
/// .value_parser(clap::value_parser!(u16).range(3000..))
/// .action(ArgAction::Set)
/// .required(true)
/// );
///
/// let m = cmd.try_get_matches_from_mut(
/// ["cmd", "--hostname", "rust-lang.org", "--port", "3001"]
/// ).unwrap();
///
/// let color: &String = m.get_one("color")
/// .expect("default");
/// assert_eq!(color, "auto");
///
/// let hostname: &String = m.get_one("hostname")
/// .expect("required");
/// assert_eq!(hostname, "rust-lang.org");
///
/// let port: u16 = *m.get_one("port")
/// .expect("required");
/// assert_eq!(port, 3001);
/// ```
pub fn value_parser(mut self, parser: impl IntoResettable<super::ValueParser>) -> Self {
self.value_parser = parser.into_resettable().into_option();
self
}
/// Specifies the number of arguments parsed per occurrence
///
/// For example, if you had a `-f <file>` argument where you wanted exactly 3 'files' you would
/// set `.num_args(3)`, and this argument wouldn't be satisfied unless the user
/// provided 3 and only 3 values.
///
/// Users may specify values for arguments in any of the following methods
///
/// - Using a space such as `-o value` or `--option value`
/// - Using an equals and no space such as `-o=value` or `--option=value`
/// - Use a short and no space such as `-ovalue`
///
/// **WARNING:**
///
/// Setting a variable number of values (e.g. `1..=10`) for an argument without
/// other details can be dangerous in some circumstances. Because multiple values are
/// allowed, `--option val1 val2 val3` is perfectly valid. Be careful when designing a CLI
/// where **positional arguments** or **subcommands** are *also* expected as `clap` will continue
/// parsing *values* until one of the following happens:
///
/// - It reaches the maximum number of values
/// - It reaches a specific number of values
/// - It finds another flag or option (i.e. something that starts with a `-`)
/// - It reaches the [`Arg::value_terminator`] if set
///
/// Alternatively,
/// - Use a delimiter between values with [`Arg::value_delimiter`]
/// - Require a flag occurrence per value with [`ArgAction::Append`]
/// - Require positional arguments to appear after `--` with [`Arg::last`]
///
/// # Examples
///
/// Option:
/// ```rust
/// # use clap_builder as clap;
/// # use clap::{Command, Arg};
/// let m = Command::new("prog")
/// .arg(Arg::new("mode")
/// .long("mode")
/// .num_args(1))
/// .get_matches_from(vec![
/// "prog", "--mode", "fast"
/// ]);
///
/// assert_eq!(m.get_one::<String>("mode").unwrap(), "fast");
/// ```
///
/// Flag/option hybrid (see also [`default_missing_value`][Arg::default_missing_value])
/// ```rust
/// # use clap_builder as clap;
/// # use clap::{Command, Arg, error::ErrorKind, ArgAction};
/// let cmd = Command::new("prog")
/// .arg(Arg::new("mode")
/// .long("mode")
/// .default_missing_value("slow")
/// .default_value("plaid")
/// .num_args(0..=1));
///
/// let m = cmd.clone()
/// .get_matches_from(vec![
/// "prog", "--mode", "fast"
/// ]);
/// assert_eq!(m.get_one::<String>("mode").unwrap(), "fast");
///
/// let m = cmd.clone()
/// .get_matches_from(vec![
/// "prog", "--mode",
/// ]);
/// assert_eq!(m.get_one::<String>("mode").unwrap(), "slow");
///
/// let m = cmd.clone()
/// .get_matches_from(vec![
/// "prog",
/// ]);
/// assert_eq!(m.get_one::<String>("mode").unwrap(), "plaid");
/// ```
///
/// Tuples
/// ```rust
/// # use clap_builder as clap;
/// # use clap::{Command, Arg, error::ErrorKind, ArgAction};
/// let cmd = Command::new("prog")
/// .arg(Arg::new("file")
/// .action(ArgAction::Set)
/// .num_args(2)
/// .short('F'));
///
/// let m = cmd.clone()
/// .get_matches_from(vec![
/// "prog", "-F", "in-file", "out-file"
/// ]);
/// assert_eq!(
/// m.get_many::<String>("file").unwrap_or_default().map(|v| v.as_str()).collect::<Vec<_>>(),
/// vec!["in-file", "out-file"]
/// );
///
/// let res = cmd.clone()
/// .try_get_matches_from(vec![
/// "prog", "-F", "file1"
/// ]);
/// assert_eq!(res.unwrap_err().kind(), ErrorKind::WrongNumberOfValues);
/// ```
///
/// A common mistake is to define an option which allows multiple values and a positional
/// argument.
/// ```rust
/// # use clap_builder as clap;
/// # use clap::{Command, Arg, ArgAction};
/// let cmd = Command::new("prog")
/// .arg(Arg::new("file")
/// .action(ArgAction::Set)
/// .num_args(0..)
/// .short('F'))
/// .arg(Arg::new("word"));
///
/// let m = cmd.clone().get_matches_from(vec![
/// "prog", "-F", "file1", "file2", "file3", "word"
/// ]);
/// let files: Vec<_> = m.get_many::<String>("file").unwrap().collect();
/// assert_eq!(files, ["file1", "file2", "file3", "word"]); // wait...what?!
/// assert!(!m.contains_id("word")); // but we clearly used word!
///
/// // but this works
/// let m = cmd.clone().get_matches_from(vec![
/// "prog", "word", "-F", "file1", "file2", "file3",
/// ]);
/// let files: Vec<_> = m.get_many::<String>("file").unwrap().collect();
/// assert_eq!(files, ["file1", "file2", "file3"]);
/// assert_eq!(m.get_one::<String>("word").unwrap(), "word");
/// ```
/// The problem is `clap` doesn't know when to stop parsing values for "file".
///
/// A solution for the example above is to limit how many values with a maximum, or specific
/// number, or to say [`ArgAction::Append`] is ok, but multiple values are not.
/// ```rust
/// # use clap_builder as clap;
/// # use clap::{Command, Arg, ArgAction};
/// let m = Command::new("prog")
/// .arg(Arg::new("file")
/// .action(ArgAction::Append)
/// .short('F'))
/// .arg(Arg::new("word"))
/// .get_matches_from(vec![
/// "prog", "-F", "file1", "-F", "file2", "-F", "file3", "word"
/// ]);
///
/// let files: Vec<_> = m.get_many::<String>("file").unwrap().collect();
/// assert_eq!(files, ["file1", "file2", "file3"]);
/// assert_eq!(m.get_one::<String>("word").unwrap(), "word");
/// ```
#[inline]
#[must_use]
pub fn num_args(mut self, qty: impl IntoResettable<ValueRange>) -> Self {
self.num_vals = qty.into_resettable().into_option();
self
}
#[doc(hidden)]
#[cfg_attr(
feature = "deprecated",
deprecated(since = "4.0.0", note = "Replaced with `Arg::num_args`")
)]
pub fn number_of_values(self, qty: usize) -> Self {
self.num_args(qty)
}
/// Placeholder for the argument's value in the help message / usage.
///
/// This name is cosmetic only; the name is **not** used to access arguments.
/// This setting can be very helpful when describing the type of input the user should be
/// using, such as `FILE`, `INTERFACE`, etc. Although not required, it's somewhat convention to
/// use all capital letters for the value name.
///
/// **NOTE:** implicitly sets [`Arg::action(ArgAction::Set)`]
///
/// # Examples
///
/// ```rust
/// # use clap_builder as clap;
/// # use clap::{Command, Arg};
/// Arg::new("cfg")
/// .long("config")
/// .value_name("FILE")
/// # ;
/// ```
///
/// ```rust
/// # use clap_builder as clap;
/// # #[cfg(feature = "help")] {
/// # use clap::{Command, Arg};
/// let m = Command::new("prog")
/// .arg(Arg::new("config")
/// .long("config")
/// .value_name("FILE")
/// .help("Some help text"))
/// .get_matches_from(vec![
/// "prog", "--help"
/// ]);
/// # }
/// ```
/// Running the above program produces the following output
///
/// ```text
/// valnames
///
/// Usage: valnames [OPTIONS]
///
/// Options:
/// --config <FILE> Some help text
/// -h, --help Print help information
/// -V, --version Print version information
/// ```
/// [positional]: Arg::index()
/// [`Arg::action(ArgAction::Set)`]: Arg::action()
#[inline]
#[must_use]
pub fn value_name(mut self, name: impl IntoResettable<Str>) -> Self {
if let Some(name) = name.into_resettable().into_option() {
self.value_names([name])
} else {
self.val_names.clear();
self
}
}
/// Placeholders for the argument's values in the help message / usage.
///
/// These names are cosmetic only, used for help and usage strings only. The names are **not**
/// used to access arguments. The values of the arguments are accessed in numeric order (i.e.
/// if you specify two names `one` and `two` `one` will be the first matched value, `two` will
/// be the second).
///
/// This setting can be very helpful when describing the type of input the user should be
/// using, such as `FILE`, `INTERFACE`, etc. Although not required, it's somewhat convention to
/// use all capital letters for the value name.
///
/// **Pro Tip:** It may help to use [`Arg::next_line_help(true)`] if there are long, or
/// multiple value names in order to not throw off the help text alignment of all options.
///
/// **NOTE:** implicitly sets [`Arg::action(ArgAction::Set)`] and [`Arg::num_args(1..)`].
///
/// # Examples
///
/// ```rust
/// # use clap_builder as clap;
/// # use clap::{Command, Arg};
/// Arg::new("speed")
/// .short('s')
/// .value_names(["fast", "slow"]);
/// ```
///
/// ```rust
/// # use clap_builder as clap;
/// # #[cfg(feature = "help")] {
/// # use clap::{Command, Arg};
/// let m = Command::new("prog")
/// .arg(Arg::new("io")
/// .long("io-files")
/// .value_names(["INFILE", "OUTFILE"]))
/// .get_matches_from(vec![
/// "prog", "--help"
/// ]);
/// # }
/// ```
///
/// Running the above program produces the following output
///
/// ```text
/// valnames
///
/// Usage: valnames [OPTIONS]
///
/// Options:
/// -h, --help Print help information
/// --io-files <INFILE> <OUTFILE> Some help text
/// -V, --version Print version information
/// ```
/// [`Arg::next_line_help(true)`]: Arg::next_line_help()
/// [`Arg::num_args`]: Arg::num_args()
/// [`Arg::action(ArgAction::Set)`]: Arg::action()
/// [`Arg::num_args(1..)`]: Arg::num_args()
#[must_use]
pub fn value_names(mut self, names: impl IntoIterator<Item = impl Into<Str>>) -> Self {
self.val_names = names.into_iter().map(|s| s.into()).collect();
self
}
/// Provide the shell a hint about how to complete this argument.
///
/// See [`ValueHint`] for more information.
///
/// **NOTE:** implicitly sets [`Arg::action(ArgAction::Set)`].
///
/// For example, to take a username as argument:
///
/// ```rust
/// # use clap_builder as clap;
/// # use clap::{Arg, ValueHint};
/// Arg::new("user")
/// .short('u')
/// .long("user")
/// .value_hint(ValueHint::Username);
/// ```
///
/// To take a full command line and its arguments (for example, when writing a command wrapper):
///
/// ```rust
/// # use clap_builder as clap;
/// # use clap::{Command, Arg, ValueHint, ArgAction};
/// Command::new("prog")
/// .trailing_var_arg(true)
/// .arg(
/// Arg::new("command")
/// .action(ArgAction::Set)
/// .num_args(1..)
/// .value_hint(ValueHint::CommandWithArguments)
/// );
/// ```
#[must_use]
pub fn value_hint(mut self, value_hint: impl IntoResettable<ValueHint>) -> Self {
// HACK: we should use `Self::add` and `Self::remove` to type-check that `ArgExt` is used
match value_hint.into_resettable().into_option() {
Some(value_hint) => {
self.ext.set(value_hint);
}
None => {
self.ext.remove::<ValueHint>();
}
}
self
}
/// Match values against [`PossibleValuesParser`][crate::builder::PossibleValuesParser] without matching case.
///
/// When other arguments are conditionally required based on the
/// value of a case-insensitive argument, the equality check done
/// by [`Arg::required_if_eq`], [`Arg::required_if_eq_any`], or
/// [`Arg::required_if_eq_all`] is case-insensitive.
///
///
/// **NOTE:** Setting this requires [taking values][Arg::num_args]
///
/// **NOTE:** To do unicode case folding, enable the `unicode` feature flag.
///
/// # Examples
///
/// ```rust
/// # use clap_builder as clap;
/// # use clap::{Command, Arg, ArgAction};
/// let m = Command::new("pv")
/// .arg(Arg::new("option")
/// .long("option")
/// .action(ArgAction::Set)
/// .ignore_case(true)
/// .value_parser(["test123"]))
/// .get_matches_from(vec![
/// "pv", "--option", "TeSt123",
/// ]);
///
/// assert!(m.get_one::<String>("option").unwrap().eq_ignore_ascii_case("test123"));
/// ```
///
/// This setting also works when multiple values can be defined:
///
/// ```rust
/// # use clap_builder as clap;
/// # use clap::{Command, Arg, ArgAction};
/// let m = Command::new("pv")
/// .arg(Arg::new("option")
/// .short('o')
/// .long("option")
/// .action(ArgAction::Set)
/// .ignore_case(true)
/// .num_args(1..)
/// .value_parser(["test123", "test321"]))
/// .get_matches_from(vec![
/// "pv", "--option", "TeSt123", "teST123", "tESt321"
/// ]);
///
/// let matched_vals = m.get_many::<String>("option").unwrap().collect::<Vec<_>>();
/// assert_eq!(&*matched_vals, &["TeSt123", "teST123", "tESt321"]);
/// ```
#[inline]
#[must_use]
pub fn ignore_case(self, yes: bool) -> Self {
if yes {
self.setting(ArgSettings::IgnoreCase)
} else {
self.unset_setting(ArgSettings::IgnoreCase)
}
}
/// Allows values which start with a leading hyphen (`-`)
///
/// To limit values to just numbers, see
/// [`allow_negative_numbers`][Arg::allow_negative_numbers].
///
/// See also [`trailing_var_arg`][Arg::trailing_var_arg].
///
/// **NOTE:** Setting this requires [taking values][Arg::num_args]
///
/// **WARNING:** Prior arguments with `allow_hyphen_values(true)` get precedence over known
/// flags but known flags get precedence over the next possible positional argument with
/// `allow_hyphen_values(true)`. When combined with [`Arg::num_args(..)`],
/// [`Arg::value_terminator`] is one way to ensure processing stops.
///
/// **WARNING**: Take caution when using this setting combined with another argument using
/// [`Arg::num_args`], as this becomes ambiguous `$ prog --arg -- -- val`. All
/// three `--, --, val` will be values when the user may have thought the second `--` would
/// constitute the normal, "Only positional args follow" idiom.
///
/// # Examples
///
/// ```rust
/// # use clap_builder as clap;
/// # use clap::{Command, Arg, ArgAction};
/// let m = Command::new("prog")
/// .arg(Arg::new("pat")
/// .action(ArgAction::Set)
/// .allow_hyphen_values(true)
/// .long("pattern"))
/// .get_matches_from(vec![
/// "prog", "--pattern", "-file"
/// ]);
///
/// assert_eq!(m.get_one::<String>("pat").unwrap(), "-file");
/// ```
///
/// Not setting `Arg::allow_hyphen_values(true)` and supplying a value which starts with a
/// hyphen is an error.
///
/// ```rust
/// # use clap_builder as clap;
/// # use clap::{Command, Arg, error::ErrorKind, ArgAction};
/// let res = Command::new("prog")
/// .arg(Arg::new("pat")
/// .action(ArgAction::Set)
/// .long("pattern"))
/// .try_get_matches_from(vec![
/// "prog", "--pattern", "-file"
/// ]);
///
/// assert!(res.is_err());
/// assert_eq!(res.unwrap_err().kind(), ErrorKind::UnknownArgument);
/// ```
/// [`Arg::num_args(1)`]: Arg::num_args()
#[inline]
#[must_use]
pub fn allow_hyphen_values(self, yes: bool) -> Self {
if yes {
self.setting(ArgSettings::AllowHyphenValues)
} else {
self.unset_setting(ArgSettings::AllowHyphenValues)
}
}
/// Allows negative numbers to pass as values.
///
/// This is similar to [`Arg::allow_hyphen_values`] except that it only allows numbers,
/// all other undefined leading hyphens will fail to parse.
///
/// **NOTE:** Setting this requires [taking values][Arg::num_args]
///
/// # Examples
///
/// ```rust
/// # use clap_builder as clap;
/// # use clap::{Command, Arg};
/// let res = Command::new("myprog")
/// .arg(Arg::new("num").allow_negative_numbers(true))
/// .try_get_matches_from(vec![
/// "myprog", "-20"
/// ]);
/// assert!(res.is_ok());
/// let m = res.unwrap();
/// assert_eq!(m.get_one::<String>("num").unwrap(), "-20");
/// ```
#[inline]
pub fn allow_negative_numbers(self, yes: bool) -> Self {
if yes {
self.setting(ArgSettings::AllowNegativeNumbers)
} else {
self.unset_setting(ArgSettings::AllowNegativeNumbers)
}
}
/// Requires that options use the `--option=val` syntax
///
/// i.e. an equals between the option and associated value.
///
/// **NOTE:** Setting this requires [taking values][Arg::num_args]
///
/// # Examples
///
/// Setting `require_equals` requires that the option have an equals sign between
/// it and the associated value.
///
/// ```rust
/// # use clap_builder as clap;
/// # use clap::{Command, Arg, ArgAction};
/// let res = Command::new("prog")
/// .arg(Arg::new("cfg")
/// .action(ArgAction::Set)
/// .require_equals(true)
/// .long("config"))
/// .try_get_matches_from(vec![
/// "prog", "--config=file.conf"
/// ]);
///
/// assert!(res.is_ok());
/// ```
///
/// Setting `require_equals` and *not* supplying the equals will cause an
/// error.
///
/// ```rust
/// # use clap_builder as clap;
/// # use clap::{Command, Arg, error::ErrorKind, ArgAction};
/// let res = Command::new("prog")
/// .arg(Arg::new("cfg")
/// .action(ArgAction::Set)
/// .require_equals(true)
/// .long("config"))
/// .try_get_matches_from(vec![
/// "prog", "--config", "file.conf"
/// ]);
///
/// assert!(res.is_err());
/// assert_eq!(res.unwrap_err().kind(), ErrorKind::NoEquals);
/// ```
#[inline]
#[must_use]
pub fn require_equals(self, yes: bool) -> Self {
if yes {
self.setting(ArgSettings::RequireEquals)
} else {
self.unset_setting(ArgSettings::RequireEquals)
}
}
#[doc(hidden)]
#[cfg_attr(
feature = "deprecated",
deprecated(since = "4.0.0", note = "Replaced with `Arg::value_delimiter`")
)]
pub fn use_value_delimiter(mut self, yes: bool) -> Self {
if yes {
self.val_delim.get_or_insert(',');
} else {
self.val_delim = None;
}
self
}
/// Allow grouping of multiple values via a delimiter.
///
/// i.e. allow values (`val1,val2,val3`) to be parsed as three values (`val1`, `val2`,
/// and `val3`) instead of one value (`val1,val2,val3`).
///
/// # Examples
///
/// ```rust
/// # use clap_builder as clap;
/// # use clap::{Command, Arg};
/// let m = Command::new("prog")
/// .arg(Arg::new("config")
/// .short('c')
/// .long("config")
/// .value_delimiter(','))
/// .get_matches_from(vec![
/// "prog", "--config=val1,val2,val3"
/// ]);
///
/// assert_eq!(m.get_many::<String>("config").unwrap().collect::<Vec<_>>(), ["val1", "val2", "val3"])
/// ```
/// [`Arg::value_delimiter(',')`]: Arg::value_delimiter()
/// [`Arg::action(ArgAction::Set)`]: Arg::action()
#[inline]
#[must_use]
pub fn value_delimiter(mut self, d: impl IntoResettable<char>) -> Self {
self.val_delim = d.into_resettable().into_option();
self
}
/// Sentinel to **stop** parsing multiple values of a given argument.
///
/// By default when
/// one sets [`num_args(1..)`] on an argument, clap will continue parsing values for that
/// argument until it reaches another valid argument, or one of the other more specific settings
/// for multiple values is used (such as [`num_args`]).
///
/// **NOTE:** This setting only applies to [options] and [positional arguments]
///
/// **NOTE:** When the terminator is passed in on the command line, it is **not** stored as one
/// of the values
///
/// # Examples
///
/// ```rust
/// # use clap_builder as clap;
/// # use clap::{Command, Arg, ArgAction};
/// Arg::new("vals")
/// .action(ArgAction::Set)
/// .num_args(1..)
/// .value_terminator(";")
/// # ;
/// ```
///
/// The following example uses two arguments, a sequence of commands, and the location in which
/// to perform them
///
/// ```rust
/// # use clap_builder as clap;
/// # use clap::{Command, Arg, ArgAction};
/// let m = Command::new("prog")
/// .arg(Arg::new("cmds")
/// .action(ArgAction::Set)
/// .num_args(1..)
/// .allow_hyphen_values(true)
/// .value_terminator(";"))
/// .arg(Arg::new("location"))
/// .get_matches_from(vec![
/// "prog", "find", "-type", "f", "-name", "special", ";", "/home/clap"
/// ]);
/// let cmds: Vec<_> = m.get_many::<String>("cmds").unwrap().collect();
/// assert_eq!(&cmds, &["find", "-type", "f", "-name", "special"]);
/// assert_eq!(m.get_one::<String>("location").unwrap(), "/home/clap");
/// ```
/// [options]: Arg::action
/// [positional arguments]: Arg::index()
/// [`num_args(1..)`]: Arg::num_args()
/// [`num_args`]: Arg::num_args()
#[inline]
#[must_use]
pub fn value_terminator(mut self, term: impl IntoResettable<Str>) -> Self {
self.terminator = term.into_resettable().into_option();
self
}
/// Consume all following arguments.
///
/// Do not be parse them individually, but rather pass them in entirety.
///
/// It is worth noting that setting this requires all values to come after a `--` to indicate
/// they should all be captured. For example:
///
/// ```text
/// --foo something -- -v -v -v -b -b -b --baz -q -u -x
/// ```
///
/// Will result in everything after `--` to be considered one raw argument. This behavior
/// may not be exactly what you are expecting and using [`Arg::trailing_var_arg`]
/// may be more appropriate.
///
/// **NOTE:** Implicitly sets [`Arg::action(ArgAction::Set)`] [`Arg::num_args(1..)`],
/// [`Arg::allow_hyphen_values(true)`], and [`Arg::last(true)`] when set to `true`.
///
/// [`Arg::action(ArgAction::Set)`]: Arg::action()
/// [`Arg::num_args(1..)`]: Arg::num_args()
/// [`Arg::allow_hyphen_values(true)`]: Arg::allow_hyphen_values()
/// [`Arg::last(true)`]: Arg::last()
#[inline]
#[must_use]
pub fn raw(mut self, yes: bool) -> Self {
if yes {
self.num_vals.get_or_insert_with(|| (1..).into());
}
self.allow_hyphen_values(yes).last(yes)
}
/// Value for the argument when not present.
///
/// **NOTE:** If the user *does not* use this argument at runtime [`ArgMatches::contains_id`] will
/// still return `true`. If you wish to determine whether the argument was used at runtime or
/// not, consider [`ArgMatches::value_source`][crate::ArgMatches::value_source].
///
/// **NOTE:** This setting is perfectly compatible with [`Arg::default_value_if`] but slightly
/// different. `Arg::default_value` *only* takes effect when the user has not provided this arg
/// at runtime. `Arg::default_value_if` however only takes effect when the user has not provided
/// a value at runtime **and** these other conditions are met as well. If you have set
/// `Arg::default_value` and `Arg::default_value_if`, and the user **did not** provide this arg
/// at runtime, nor were the conditions met for `Arg::default_value_if`, the `Arg::default_value`
/// will be applied.
///
/// Like with command-line values, this will be split by [`Arg::value_delimiter`].
///
/// # Examples
///
/// First we use the default value without providing any value at runtime.
///
/// ```rust
/// # use clap_builder as clap;
/// # use clap::{Command, Arg, parser::ValueSource};
/// let m = Command::new("prog")
/// .arg(Arg::new("opt")
/// .long("myopt")
/// .default_value("myval"))
/// .get_matches_from(vec![
/// "prog"
/// ]);
///
/// assert_eq!(m.get_one::<String>("opt").unwrap(), "myval");
/// assert!(m.contains_id("opt"));
/// assert_eq!(m.value_source("opt"), Some(ValueSource::DefaultValue));
/// ```
///
/// Next we provide a value at runtime to override the default.
///
/// ```rust
/// # use clap_builder as clap;
/// # use clap::{Command, Arg, parser::ValueSource};
/// let m = Command::new("prog")
/// .arg(Arg::new("opt")
/// .long("myopt")
/// .default_value("myval"))
/// .get_matches_from(vec![
/// "prog", "--myopt=non_default"
/// ]);
///
/// assert_eq!(m.get_one::<String>("opt").unwrap(), "non_default");
/// assert!(m.contains_id("opt"));
/// assert_eq!(m.value_source("opt"), Some(ValueSource::CommandLine));
/// ```
/// [`Arg::action(ArgAction::Set)`]: Arg::action()
/// [`ArgMatches::contains_id`]: crate::ArgMatches::contains_id()
/// [`Arg::default_value_if`]: Arg::default_value_if()
#[inline]
#[must_use]
pub fn default_value(mut self, val: impl IntoResettable<OsStr>) -> Self {
if let Some(val) = val.into_resettable().into_option() {
self.default_values([val])
} else {
self.default_vals.clear();
self
}
}
#[inline]
#[must_use]
#[doc(hidden)]
#[cfg_attr(
feature = "deprecated",
deprecated(since = "4.0.0", note = "Replaced with `Arg::default_value`")
)]
pub fn default_value_os(self, val: impl Into<OsStr>) -> Self {
self.default_values([val])
}
/// Value for the argument when not present.
///
/// See [`Arg::default_value`].
///
/// [`Arg::default_value`]: Arg::default_value()
#[inline]
#[must_use]
pub fn default_values(mut self, vals: impl IntoIterator<Item = impl Into<OsStr>>) -> Self {
self.default_vals = vals.into_iter().map(|s| s.into()).collect();
self
}
#[inline]
#[must_use]
#[doc(hidden)]
#[cfg_attr(
feature = "deprecated",
deprecated(since = "4.0.0", note = "Replaced with `Arg::default_values`")
)]
pub fn default_values_os(self, vals: impl IntoIterator<Item = impl Into<OsStr>>) -> Self {
self.default_values(vals)
}
/// Value for the argument when the flag is present but no value is specified.
///
/// This configuration option is often used to give the user a shortcut and allow them to
/// efficiently specify an option argument without requiring an explicitly value. The `--color`
/// argument is a common example. By supplying a default, such as `default_missing_value("always")`,
/// the user can quickly just add `--color` to the command line to produce the desired color output.
///
/// **NOTE:** using this configuration option requires the use of the
/// [`.num_args(0..N)`][Arg::num_args] and the
/// [`.require_equals(true)`][Arg::require_equals] configuration option. These are required in
/// order to unambiguously determine what, if any, value was supplied for the argument.
///
/// Like with command-line values, this will be split by [`Arg::value_delimiter`].
///
/// # Examples
///
/// For POSIX style `--color`:
/// ```rust
/// # use clap_builder as clap;
/// # use clap::{Command, Arg, parser::ValueSource};
/// fn cli() -> Command {
/// Command::new("prog")
/// .arg(Arg::new("color").long("color")
/// .value_name("WHEN")
/// .value_parser(["always", "auto", "never"])
/// .default_value("auto")
/// .num_args(0..=1)
/// .require_equals(true)
/// .default_missing_value("always")
/// .help("Specify WHEN to colorize output.")
/// )
/// }
///
/// // first, we'll provide no arguments
/// let m = cli().get_matches_from(vec![
/// "prog"
/// ]);
/// assert_eq!(m.get_one::<String>("color").unwrap(), "auto");
/// assert_eq!(m.value_source("color"), Some(ValueSource::DefaultValue));
///
/// // next, we'll provide a runtime value to override the default (as usually done).
/// let m = cli().get_matches_from(vec![
/// "prog", "--color=never"
/// ]);
--> --------------------
--> maximum size reached
--> --------------------
