2016-06-24 10:23:08 +00:00
|
|
|
/// A convenience macro for loading the YAML file at compile time (relative to the current file,
|
2016-01-26 19:02:10 +00:00
|
|
|
/// like modules work). That YAML object can then be passed to this function.
|
|
|
|
///
|
|
|
|
/// # Panics
|
|
|
|
///
|
|
|
|
/// The YAML file must be properly formatted or this function will panic!(). A good way to
|
|
|
|
/// ensure this doesn't happen is to run your program with the `--help` switch. If this passes
|
|
|
|
/// without error, you needn't worry because the YAML is properly formatted.
|
|
|
|
///
|
|
|
|
/// # Examples
|
|
|
|
///
|
2018-03-19 20:53:19 +00:00
|
|
|
/// The following example shows how to load a properly formatted YAML file to build an instance
|
2016-01-26 19:02:10 +00:00
|
|
|
/// of an `App` struct.
|
|
|
|
///
|
|
|
|
/// ```ignore
|
2016-10-05 09:28:59 +00:00
|
|
|
/// # #[macro_use]
|
|
|
|
/// # extern crate clap;
|
2016-01-26 19:02:10 +00:00
|
|
|
/// # use clap::App;
|
2016-10-05 09:28:59 +00:00
|
|
|
/// # fn main() {
|
2016-01-26 19:02:10 +00:00
|
|
|
/// let yml = load_yaml!("app.yml");
|
|
|
|
/// let app = App::from_yaml(yml);
|
|
|
|
///
|
|
|
|
/// // continued logic goes here, such as `app.get_matches()` etc.
|
2016-10-05 09:28:59 +00:00
|
|
|
/// # }
|
2016-01-26 19:02:10 +00:00
|
|
|
/// ```
|
2015-08-31 03:26:17 +00:00
|
|
|
#[cfg(feature = "yaml")]
|
|
|
|
#[macro_export]
|
|
|
|
macro_rules! load_yaml {
|
2018-08-02 03:13:51 +00:00
|
|
|
($yml:expr) => {
|
2019-10-24 04:45:32 +00:00
|
|
|
&$crate::YamlLoader::load_from_str(include_str!($yml)).expect("failed to load YAML file")[0]
|
2018-08-02 03:13:51 +00:00
|
|
|
};
|
2015-08-31 03:26:17 +00:00
|
|
|
}
|
|
|
|
|
2016-05-14 20:25:00 +00:00
|
|
|
/// Convenience macro getting a typed value `T` where `T` implements [`std::str::FromStr`] from an
|
2016-01-26 19:02:10 +00:00
|
|
|
/// argument value. This macro returns a `Result<T,String>` which allows you as the developer to
|
|
|
|
/// decide what you'd like to do on a failed parse. There are two types of errors, parse failures
|
|
|
|
/// and those where the argument wasn't present (such as a non-required argument). You can use
|
2016-05-14 20:25:00 +00:00
|
|
|
/// it to get a single value, or a iterator as with the [`ArgMatches::values_of`]
|
2015-04-14 19:02:50 +00:00
|
|
|
///
|
2016-01-21 06:48:30 +00:00
|
|
|
/// # Examples
|
2015-04-14 19:02:50 +00:00
|
|
|
///
|
|
|
|
/// ```no_run
|
|
|
|
/// # #[macro_use]
|
|
|
|
/// # extern crate clap;
|
|
|
|
/// # use clap::App;
|
|
|
|
/// # fn main() {
|
|
|
|
/// let matches = App::new("myapp")
|
2018-10-19 20:42:13 +00:00
|
|
|
/// .arg("[length] 'Set the length to use as a pos whole num, i.e. 20'")
|
2015-05-01 18:38:27 +00:00
|
|
|
/// .get_matches();
|
2016-01-22 04:18:52 +00:00
|
|
|
///
|
|
|
|
/// let len = value_t!(matches.value_of("length"), u32).unwrap_or_else(|e| e.exit());
|
|
|
|
/// let also_len = value_t!(matches, "length", u32).unwrap_or_else(|e| e.exit());
|
2015-04-14 19:02:50 +00:00
|
|
|
///
|
|
|
|
/// println!("{} + 2: {}", len, len + 2);
|
|
|
|
/// # }
|
|
|
|
/// ```
|
2016-05-14 20:25:00 +00:00
|
|
|
/// [`std::str::FromStr`]: https://doc.rust-lang.org/std/str/trait.FromStr.html
|
|
|
|
/// [`ArgMatches::values_of`]: ./struct.ArgMatches.html#method.values_of
|
|
|
|
/// [`Result<T,String>`]: https://doc.rust-lang.org/std/result/enum.Result.html
|
2016-01-21 06:48:30 +00:00
|
|
|
#[macro_export]
|
|
|
|
macro_rules! value_t {
|
|
|
|
($m:ident, $v:expr, $t:ty) => {
|
2019-10-24 04:45:32 +00:00
|
|
|
$crate::value_t!($m.value_of($v), $t)
|
2016-01-21 06:48:30 +00:00
|
|
|
};
|
|
|
|
($m:ident.value_of($v:expr), $t:ty) => {
|
|
|
|
if let Some(v) = $m.value_of($v) {
|
|
|
|
match v.parse::<$t>() {
|
|
|
|
Ok(val) => Ok(val),
|
2019-10-24 04:45:32 +00:00
|
|
|
Err(_) => Err($crate::Error::value_validation_auto(&format!(
|
2018-08-02 03:13:51 +00:00
|
|
|
"The argument '{}' isn't a valid value",
|
|
|
|
v
|
|
|
|
))),
|
2016-01-21 06:48:30 +00:00
|
|
|
}
|
|
|
|
} else {
|
2019-10-24 04:45:32 +00:00
|
|
|
Err($crate::Error::argument_not_found_auto($v))
|
2016-01-22 04:18:52 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2016-05-14 20:25:00 +00:00
|
|
|
/// Convenience macro getting a typed value `T` where `T` implements [`std::str::FromStr`] or
|
|
|
|
/// exiting upon error, instead of returning a [`Result`] type.
|
2016-01-22 04:18:52 +00:00
|
|
|
///
|
|
|
|
/// **NOTE:** This macro is for backwards compatibility sake. Prefer
|
2016-05-14 20:25:00 +00:00
|
|
|
/// [`value_t!(/* ... */).unwrap_or_else(|e| e.exit())`]
|
2016-01-22 04:18:52 +00:00
|
|
|
///
|
|
|
|
/// # Examples
|
|
|
|
///
|
|
|
|
/// ```no_run
|
|
|
|
/// # #[macro_use]
|
|
|
|
/// # extern crate clap;
|
|
|
|
/// # use clap::App;
|
|
|
|
/// # fn main() {
|
|
|
|
/// let matches = App::new("myapp")
|
2018-10-19 20:42:13 +00:00
|
|
|
/// .arg("[length] 'Set the length to use as a pos whole num, i.e. 20'")
|
2016-01-22 04:18:52 +00:00
|
|
|
/// .get_matches();
|
|
|
|
///
|
|
|
|
/// let len = value_t_or_exit!(matches.value_of("length"), u32);
|
|
|
|
/// let also_len = value_t_or_exit!(matches, "length", u32);
|
|
|
|
///
|
|
|
|
/// println!("{} + 2: {}", len, len + 2);
|
|
|
|
/// # }
|
|
|
|
/// ```
|
2016-05-14 20:25:00 +00:00
|
|
|
/// [`std::str::FromStr`]: https://doc.rust-lang.org/std/str/trait.FromStr.html
|
|
|
|
/// [`Result`]: https://doc.rust-lang.org/std/result/enum.Result.html
|
|
|
|
/// [`value_t!(/* ... */).unwrap_or_else(|e| e.exit())`]: ./macro.value_t!.html
|
2016-01-22 04:18:52 +00:00
|
|
|
#[macro_export]
|
|
|
|
macro_rules! value_t_or_exit {
|
|
|
|
($m:ident, $v:expr, $t:ty) => {
|
2019-10-24 04:45:32 +00:00
|
|
|
$crate::value_t_or_exit!($m.value_of($v), $t)
|
2016-01-22 04:18:52 +00:00
|
|
|
};
|
|
|
|
($m:ident.value_of($v:expr), $t:ty) => {
|
|
|
|
if let Some(v) = $m.value_of($v) {
|
|
|
|
match v.parse::<$t>() {
|
|
|
|
Ok(val) => val,
|
2019-10-24 04:45:32 +00:00
|
|
|
Err(_) => $crate::Error::value_validation_auto(&format!(
|
2018-08-02 03:13:51 +00:00
|
|
|
"The argument '{}' isn't a valid value",
|
|
|
|
v
|
2018-11-14 17:05:06 +00:00
|
|
|
))
|
|
|
|
.exit(),
|
2016-01-22 04:18:52 +00:00
|
|
|
}
|
|
|
|
} else {
|
2019-10-24 04:45:32 +00:00
|
|
|
$crate::Error::argument_not_found_auto($v).exit()
|
2016-01-21 06:48:30 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2016-05-14 20:25:00 +00:00
|
|
|
/// Convenience macro getting a typed value [`Vec<T>`] where `T` implements [`std::str::FromStr`]
|
|
|
|
/// This macro returns a [`clap::Result<Vec<T>>`] which allows you as the developer to decide
|
|
|
|
/// what you'd like to do on a failed parse.
|
2015-04-14 19:02:50 +00:00
|
|
|
///
|
2016-01-21 06:48:30 +00:00
|
|
|
/// # Examples
|
2015-04-14 19:02:50 +00:00
|
|
|
///
|
|
|
|
/// ```no_run
|
|
|
|
/// # #[macro_use]
|
|
|
|
/// # extern crate clap;
|
|
|
|
/// # use clap::App;
|
|
|
|
/// # fn main() {
|
|
|
|
/// let matches = App::new("myapp")
|
2018-10-19 20:42:13 +00:00
|
|
|
/// .arg("[seq]... 'A sequence of pos whole nums, i.e. 20 45'")
|
2015-05-01 18:38:27 +00:00
|
|
|
/// .get_matches();
|
2016-01-22 04:18:52 +00:00
|
|
|
///
|
|
|
|
/// let vals = values_t!(matches.values_of("seq"), u32).unwrap_or_else(|e| e.exit());
|
|
|
|
/// for v in &vals {
|
|
|
|
/// println!("{} + 2: {}", v, v + 2);
|
|
|
|
/// }
|
|
|
|
///
|
|
|
|
/// let vals = values_t!(matches, "seq", u32).unwrap_or_else(|e| e.exit());
|
|
|
|
/// for v in &vals {
|
2015-05-01 18:38:27 +00:00
|
|
|
/// println!("{} + 2: {}", v, v + 2);
|
|
|
|
/// }
|
2015-04-14 19:02:50 +00:00
|
|
|
/// # }
|
|
|
|
/// ```
|
2016-05-14 20:25:00 +00:00
|
|
|
/// [`std::str::FromStr`]: https://doc.rust-lang.org/std/str/trait.FromStr.html
|
|
|
|
/// [`Vec<T>`]: https://doc.rust-lang.org/std/vec/struct.Vec.html
|
|
|
|
/// [`clap::Result<Vec<T>>`]: ./type.Result.html
|
2016-01-21 05:18:53 +00:00
|
|
|
#[macro_export]
|
|
|
|
macro_rules! values_t {
|
2016-01-22 04:18:52 +00:00
|
|
|
($m:ident, $v:expr, $t:ty) => {
|
2019-10-24 04:45:32 +00:00
|
|
|
$crate::values_t!($m.values_of($v), $t)
|
2015-05-01 18:38:27 +00:00
|
|
|
};
|
2016-01-21 06:48:30 +00:00
|
|
|
($m:ident.values_of($v:expr), $t:ty) => {
|
2016-01-22 04:18:52 +00:00
|
|
|
if let Some(vals) = $m.values_of($v) {
|
|
|
|
let mut tmp = vec![];
|
|
|
|
let mut err = None;
|
|
|
|
for pv in vals {
|
|
|
|
match pv.parse::<$t>() {
|
|
|
|
Ok(rv) => tmp.push(rv),
|
|
|
|
Err(..) => {
|
2019-10-24 04:45:32 +00:00
|
|
|
err = Some($crate::Error::value_validation_auto(&format!(
|
2018-08-02 03:13:51 +00:00
|
|
|
"The argument '{}' isn't a valid value",
|
|
|
|
pv
|
|
|
|
)));
|
|
|
|
break;
|
2016-01-22 04:18:52 +00:00
|
|
|
}
|
2015-05-15 19:34:41 +00:00
|
|
|
}
|
|
|
|
}
|
2016-01-22 04:18:52 +00:00
|
|
|
match err {
|
|
|
|
Some(e) => Err(e),
|
|
|
|
None => Ok(tmp),
|
|
|
|
}
|
|
|
|
} else {
|
2019-10-24 04:45:32 +00:00
|
|
|
Err($crate::Error::argument_not_found_auto($v))
|
2015-05-15 20:41:39 +00:00
|
|
|
}
|
2015-05-01 18:38:27 +00:00
|
|
|
};
|
2015-04-17 14:20:56 +00:00
|
|
|
}
|
|
|
|
|
2016-05-14 20:25:00 +00:00
|
|
|
/// Convenience macro getting a typed value [`Vec<T>`] where `T` implements [`std::str::FromStr`]
|
|
|
|
/// or exiting upon error.
|
2016-01-22 04:18:52 +00:00
|
|
|
///
|
|
|
|
/// **NOTE:** This macro is for backwards compatibility sake. Prefer
|
2016-05-14 20:25:00 +00:00
|
|
|
/// [`values_t!(/* ... */).unwrap_or_else(|e| e.exit())`]
|
2016-01-22 04:18:52 +00:00
|
|
|
///
|
|
|
|
/// # Examples
|
|
|
|
///
|
|
|
|
/// ```no_run
|
|
|
|
/// # #[macro_use]
|
|
|
|
/// # extern crate clap;
|
|
|
|
/// # use clap::App;
|
|
|
|
/// # fn main() {
|
|
|
|
/// let matches = App::new("myapp")
|
2018-10-19 20:42:13 +00:00
|
|
|
/// .arg("[seq]... 'A sequence of pos whole nums, i.e. 20 45'")
|
2016-01-22 04:18:52 +00:00
|
|
|
/// .get_matches();
|
|
|
|
///
|
|
|
|
/// let vals = values_t_or_exit!(matches.values_of("seq"), u32);
|
|
|
|
/// for v in &vals {
|
|
|
|
/// println!("{} + 2: {}", v, v + 2);
|
|
|
|
/// }
|
|
|
|
///
|
|
|
|
/// // type for example only
|
|
|
|
/// let vals: Vec<u32> = values_t_or_exit!(matches, "seq", u32);
|
|
|
|
/// for v in &vals {
|
|
|
|
/// println!("{} + 2: {}", v, v + 2);
|
|
|
|
/// }
|
|
|
|
/// # }
|
|
|
|
/// ```
|
2016-05-14 20:25:00 +00:00
|
|
|
/// [`values_t!(/* ... */).unwrap_or_else(|e| e.exit())`]: ./macro.values_t!.html
|
|
|
|
/// [`std::str::FromStr`]: https://doc.rust-lang.org/std/str/trait.FromStr.html
|
|
|
|
/// [`Vec<T>`]: https://doc.rust-lang.org/std/vec/struct.Vec.html
|
2016-01-22 04:18:52 +00:00
|
|
|
#[macro_export]
|
|
|
|
macro_rules! values_t_or_exit {
|
|
|
|
($m:ident, $v:expr, $t:ty) => {
|
2019-10-24 04:45:32 +00:00
|
|
|
$crate::values_t_or_exit!($m.values_of($v), $t)
|
2016-01-22 04:18:52 +00:00
|
|
|
};
|
|
|
|
($m:ident.values_of($v:expr), $t:ty) => {
|
|
|
|
if let Some(vals) = $m.values_of($v) {
|
2018-08-02 03:13:51 +00:00
|
|
|
vals.map(|v| {
|
|
|
|
v.parse::<$t>().unwrap_or_else(|_| {
|
2019-10-24 04:45:32 +00:00
|
|
|
$crate::Error::value_validation_auto(&format!(
|
2018-08-02 03:13:51 +00:00
|
|
|
"One or more arguments aren't valid values"
|
2018-11-14 17:05:06 +00:00
|
|
|
))
|
|
|
|
.exit()
|
2018-08-02 03:13:51 +00:00
|
|
|
})
|
2018-11-14 17:05:06 +00:00
|
|
|
})
|
|
|
|
.collect::<Vec<$t>>()
|
2016-01-22 04:18:52 +00:00
|
|
|
} else {
|
2019-10-24 04:45:32 +00:00
|
|
|
$crate::Error::argument_not_found_auto($v).exit()
|
2016-01-22 04:18:52 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
2016-01-21 06:48:30 +00:00
|
|
|
|
2016-01-31 13:03:09 +00:00
|
|
|
// _clap_count_exprs! is derived from https://github.com/DanielKeep/rust-grabbag
|
|
|
|
// commit: 82a35ca5d9a04c3b920622d542104e3310ee5b07
|
|
|
|
// License: MIT
|
|
|
|
// Copyright ⓒ 2015 grabbag contributors.
|
|
|
|
// Licensed under the MIT license (see LICENSE or <http://opensource.org
|
|
|
|
// /licenses/MIT>) or the Apache License, Version 2.0 (see LICENSE of
|
|
|
|
// <http://www.apache.org/licenses/LICENSE-2.0>), at your option. All
|
|
|
|
// files in the project carrying such notice may not be copied, modified,
|
|
|
|
// or distributed except according to those terms.
|
|
|
|
//
|
|
|
|
/// Counts the number of comma-delimited expressions passed to it. The result is a compile-time
|
|
|
|
/// evaluable expression, suitable for use as a static array size, or the value of a `const`.
|
|
|
|
///
|
|
|
|
/// # Examples
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// # #[macro_use] extern crate clap;
|
|
|
|
/// # fn main() {
|
|
|
|
/// const COUNT: usize = _clap_count_exprs!(a, 5+1, "hi there!".into_string());
|
|
|
|
/// assert_eq!(COUNT, 3);
|
|
|
|
/// # }
|
|
|
|
/// ```
|
|
|
|
#[macro_export]
|
|
|
|
macro_rules! _clap_count_exprs {
|
|
|
|
() => { 0 };
|
|
|
|
($e:expr) => { 1 };
|
2018-12-18 23:02:27 +00:00
|
|
|
($e:expr, $($es:expr),+) => { 1 + $crate::_clap_count_exprs!($($es),*) };
|
2016-01-31 13:03:09 +00:00
|
|
|
}
|
|
|
|
|
2015-05-01 18:38:27 +00:00
|
|
|
/// Convenience macro to generate more complete enums with variants to be used as a type when
|
2016-01-26 19:02:10 +00:00
|
|
|
/// parsing arguments. This enum also provides a `variants()` function which can be used to
|
2016-05-14 20:25:00 +00:00
|
|
|
/// retrieve a `Vec<&'static str>` of the variant names, as well as implementing [`FromStr`] and
|
|
|
|
/// [`Display`] automatically.
|
2015-04-17 14:20:56 +00:00
|
|
|
///
|
api: Adds Arg::case_insensitive(bool) which allows matching Arg::possible_values without worrying about ASCII case
When used with `Arg::possible_values` it allows the argument value to pass validation even if
the case differs from that of the specified `possible_value`.
```rust
let m = App::new("pv")
.arg(Arg::with_name("option")
.long("--option")
.takes_value(true)
.possible_value("test123")
.case_insensitive(true))
.get_matches_from(vec![
"pv", "--option", "TeSt123",
]);
assert!(m.value_of("option").unwrap().eq_ignore_ascii_case("test123"));
```
This setting also works when multiple values can be defined:
```rust
let m = App::new("pv")
.arg(Arg::with_name("option")
.short("-o")
.long("--option")
.takes_value(true)
.possible_value("test123")
.possible_value("test321")
.multiple(true)
.case_insensitive(true))
.get_matches_from(vec![
"pv", "--option", "TeSt123", "teST123", "tESt321"
]);
let matched_vals = m.values_of("option").unwrap().collect::<Vec<_>>();
assert_eq!(&*matched_vals, &["TeSt123", "teST123", "tESt321"]);
```
Closes #1118
2017-11-28 11:41:43 +00:00
|
|
|
/// **NOTE:** Case insensitivity is supported for ASCII characters only. It's highly recommended to
|
|
|
|
/// use [`Arg::case_insensitive(true)`] for args that will be used with these enums
|
2015-05-05 16:33:02 +00:00
|
|
|
///
|
2016-05-14 20:25:00 +00:00
|
|
|
/// **NOTE:** This macro automatically implements [`std::str::FromStr`] and [`std::fmt::Display`]
|
2015-05-15 19:34:41 +00:00
|
|
|
///
|
2018-06-30 23:33:34 +00:00
|
|
|
/// **NOTE:** These enums support pub (or not) and uses of the `#[derive()]` traits
|
2015-04-17 14:20:56 +00:00
|
|
|
///
|
2015-09-22 02:06:15 +00:00
|
|
|
/// # Examples
|
2015-04-17 14:20:56 +00:00
|
|
|
///
|
api: Adds Arg::case_insensitive(bool) which allows matching Arg::possible_values without worrying about ASCII case
When used with `Arg::possible_values` it allows the argument value to pass validation even if
the case differs from that of the specified `possible_value`.
```rust
let m = App::new("pv")
.arg(Arg::with_name("option")
.long("--option")
.takes_value(true)
.possible_value("test123")
.case_insensitive(true))
.get_matches_from(vec![
"pv", "--option", "TeSt123",
]);
assert!(m.value_of("option").unwrap().eq_ignore_ascii_case("test123"));
```
This setting also works when multiple values can be defined:
```rust
let m = App::new("pv")
.arg(Arg::with_name("option")
.short("-o")
.long("--option")
.takes_value(true)
.possible_value("test123")
.possible_value("test321")
.multiple(true)
.case_insensitive(true))
.get_matches_from(vec![
"pv", "--option", "TeSt123", "teST123", "tESt321"
]);
let matched_vals = m.values_of("option").unwrap().collect::<Vec<_>>();
assert_eq!(&*matched_vals, &["TeSt123", "teST123", "tESt321"]);
```
Closes #1118
2017-11-28 11:41:43 +00:00
|
|
|
/// ```rust
|
2015-04-17 14:20:56 +00:00
|
|
|
/// # #[macro_use]
|
|
|
|
/// # extern crate clap;
|
|
|
|
/// # use clap::{App, Arg};
|
|
|
|
/// arg_enum!{
|
api: Adds Arg::case_insensitive(bool) which allows matching Arg::possible_values without worrying about ASCII case
When used with `Arg::possible_values` it allows the argument value to pass validation even if
the case differs from that of the specified `possible_value`.
```rust
let m = App::new("pv")
.arg(Arg::with_name("option")
.long("--option")
.takes_value(true)
.possible_value("test123")
.case_insensitive(true))
.get_matches_from(vec![
"pv", "--option", "TeSt123",
]);
assert!(m.value_of("option").unwrap().eq_ignore_ascii_case("test123"));
```
This setting also works when multiple values can be defined:
```rust
let m = App::new("pv")
.arg(Arg::with_name("option")
.short("-o")
.long("--option")
.takes_value(true)
.possible_value("test123")
.possible_value("test321")
.multiple(true)
.case_insensitive(true))
.get_matches_from(vec![
"pv", "--option", "TeSt123", "teST123", "tESt321"
]);
let matched_vals = m.values_of("option").unwrap().collect::<Vec<_>>();
assert_eq!(&*matched_vals, &["TeSt123", "teST123", "tESt321"]);
```
Closes #1118
2017-11-28 11:41:43 +00:00
|
|
|
/// #[derive(PartialEq, Debug)]
|
2015-05-01 18:38:27 +00:00
|
|
|
/// pub enum Foo {
|
|
|
|
/// Bar,
|
|
|
|
/// Baz,
|
|
|
|
/// Qux
|
|
|
|
/// }
|
2015-04-17 14:20:56 +00:00
|
|
|
/// }
|
|
|
|
/// // Foo enum can now be used via Foo::Bar, or Foo::Baz, etc
|
|
|
|
/// // and implements std::str::FromStr to use with the value_t! macros
|
|
|
|
/// fn main() {
|
2015-05-01 18:38:27 +00:00
|
|
|
/// let m = App::new("app")
|
2018-04-21 18:59:19 +00:00
|
|
|
/// .arg(Arg::from("<foo> 'the foo'")
|
api: Adds Arg::case_insensitive(bool) which allows matching Arg::possible_values without worrying about ASCII case
When used with `Arg::possible_values` it allows the argument value to pass validation even if
the case differs from that of the specified `possible_value`.
```rust
let m = App::new("pv")
.arg(Arg::with_name("option")
.long("--option")
.takes_value(true)
.possible_value("test123")
.case_insensitive(true))
.get_matches_from(vec![
"pv", "--option", "TeSt123",
]);
assert!(m.value_of("option").unwrap().eq_ignore_ascii_case("test123"));
```
This setting also works when multiple values can be defined:
```rust
let m = App::new("pv")
.arg(Arg::with_name("option")
.short("-o")
.long("--option")
.takes_value(true)
.possible_value("test123")
.possible_value("test321")
.multiple(true)
.case_insensitive(true))
.get_matches_from(vec![
"pv", "--option", "TeSt123", "teST123", "tESt321"
]);
let matched_vals = m.values_of("option").unwrap().collect::<Vec<_>>();
assert_eq!(&*matched_vals, &["TeSt123", "teST123", "tESt321"]);
```
Closes #1118
2017-11-28 11:41:43 +00:00
|
|
|
/// .possible_values(&Foo::variants())
|
|
|
|
/// .case_insensitive(true))
|
|
|
|
/// .get_matches_from(vec![
|
|
|
|
/// "app", "baz"
|
|
|
|
/// ]);
|
2016-01-22 04:18:52 +00:00
|
|
|
/// let f = value_t!(m, "foo", Foo).unwrap_or_else(|e| e.exit());
|
2015-04-17 14:20:56 +00:00
|
|
|
///
|
api: Adds Arg::case_insensitive(bool) which allows matching Arg::possible_values without worrying about ASCII case
When used with `Arg::possible_values` it allows the argument value to pass validation even if
the case differs from that of the specified `possible_value`.
```rust
let m = App::new("pv")
.arg(Arg::with_name("option")
.long("--option")
.takes_value(true)
.possible_value("test123")
.case_insensitive(true))
.get_matches_from(vec![
"pv", "--option", "TeSt123",
]);
assert!(m.value_of("option").unwrap().eq_ignore_ascii_case("test123"));
```
This setting also works when multiple values can be defined:
```rust
let m = App::new("pv")
.arg(Arg::with_name("option")
.short("-o")
.long("--option")
.takes_value(true)
.possible_value("test123")
.possible_value("test321")
.multiple(true)
.case_insensitive(true))
.get_matches_from(vec![
"pv", "--option", "TeSt123", "teST123", "tESt321"
]);
let matched_vals = m.values_of("option").unwrap().collect::<Vec<_>>();
assert_eq!(&*matched_vals, &["TeSt123", "teST123", "tESt321"]);
```
Closes #1118
2017-11-28 11:41:43 +00:00
|
|
|
/// assert_eq!(f, Foo::Baz);
|
2015-04-17 14:20:56 +00:00
|
|
|
/// }
|
|
|
|
/// ```
|
2016-05-14 20:25:00 +00:00
|
|
|
/// [`FromStr`]: https://doc.rust-lang.org/std/str/trait.FromStr.html
|
|
|
|
/// [`std::str::FromStr`]: https://doc.rust-lang.org/std/str/trait.FromStr.html
|
|
|
|
/// [`Display`]: https://doc.rust-lang.org/std/fmt/trait.Display.html
|
|
|
|
/// [`std::fmt::Display`]: https://doc.rust-lang.org/std/fmt/trait.Display.html
|
api: Adds Arg::case_insensitive(bool) which allows matching Arg::possible_values without worrying about ASCII case
When used with `Arg::possible_values` it allows the argument value to pass validation even if
the case differs from that of the specified `possible_value`.
```rust
let m = App::new("pv")
.arg(Arg::with_name("option")
.long("--option")
.takes_value(true)
.possible_value("test123")
.case_insensitive(true))
.get_matches_from(vec![
"pv", "--option", "TeSt123",
]);
assert!(m.value_of("option").unwrap().eq_ignore_ascii_case("test123"));
```
This setting also works when multiple values can be defined:
```rust
let m = App::new("pv")
.arg(Arg::with_name("option")
.short("-o")
.long("--option")
.takes_value(true)
.possible_value("test123")
.possible_value("test321")
.multiple(true)
.case_insensitive(true))
.get_matches_from(vec![
"pv", "--option", "TeSt123", "teST123", "tESt321"
]);
let matched_vals = m.values_of("option").unwrap().collect::<Vec<_>>();
assert_eq!(&*matched_vals, &["TeSt123", "teST123", "tESt321"]);
```
Closes #1118
2017-11-28 11:41:43 +00:00
|
|
|
/// [`Arg::case_insensitive(true)`]: ./struct.Arg.html#method.case_insensitive
|
2015-04-17 14:20:56 +00:00
|
|
|
#[macro_export]
|
|
|
|
macro_rules! arg_enum {
|
2016-01-21 06:48:30 +00:00
|
|
|
(@as_item $($i:item)*) => ($($i)*);
|
|
|
|
(@impls ( $($tts:tt)* ) -> ($e:ident, $($v:ident),+)) => {
|
2019-10-24 04:45:32 +00:00
|
|
|
$crate::arg_enum!(@as_item
|
2016-01-21 06:48:30 +00:00
|
|
|
$($tts)*
|
2015-04-17 14:20:56 +00:00
|
|
|
|
2015-05-01 18:38:27 +00:00
|
|
|
impl ::std::str::FromStr for $e {
|
|
|
|
type Err = String;
|
2015-04-17 14:20:56 +00:00
|
|
|
|
2016-04-01 20:03:29 +00:00
|
|
|
fn from_str(s: &str) -> ::std::result::Result<Self,Self::Err> {
|
2015-05-01 18:38:27 +00:00
|
|
|
match s {
|
2015-05-05 08:33:27 +00:00
|
|
|
$(stringify!($v) |
|
2016-01-21 06:48:30 +00:00
|
|
|
_ if s.eq_ignore_ascii_case(stringify!($v)) => Ok($e::$v)),+,
|
|
|
|
_ => Err({
|
|
|
|
let v = vec![
|
|
|
|
$(stringify!($v),)+
|
|
|
|
];
|
2016-02-02 10:05:54 +00:00
|
|
|
format!("valid values: {}",
|
|
|
|
v.join(" ,"))
|
2016-01-21 06:48:30 +00:00
|
|
|
}),
|
2015-05-01 18:38:27 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2015-05-15 19:34:41 +00:00
|
|
|
impl ::std::fmt::Display for $e {
|
|
|
|
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
|
|
|
|
match *self {
|
|
|
|
$($e::$v => write!(f, stringify!($v)),)+
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2015-05-15 20:41:39 +00:00
|
|
|
impl $e {
|
2015-07-08 00:06:15 +00:00
|
|
|
#[allow(dead_code)]
|
2018-12-18 23:02:27 +00:00
|
|
|
pub fn variants() -> [&'static str; $crate::_clap_count_exprs!($(stringify!($v)),+)] {
|
2016-01-31 13:03:09 +00:00
|
|
|
[
|
2015-05-15 20:41:39 +00:00
|
|
|
$(stringify!($v),)+
|
|
|
|
]
|
|
|
|
}
|
2016-01-21 06:48:30 +00:00
|
|
|
});
|
2015-05-01 18:38:27 +00:00
|
|
|
};
|
2017-12-07 00:53:55 +00:00
|
|
|
($(#[$($m:meta),+])+ pub enum $e:ident { $($v:ident $(=$val:expr)*,)+ } ) => {
|
2019-10-24 04:45:32 +00:00
|
|
|
$crate::arg_enum!(@impls
|
2017-12-07 00:53:55 +00:00
|
|
|
($(#[$($m),+])+
|
|
|
|
pub enum $e {
|
|
|
|
$($v$(=$val)*),+
|
|
|
|
}) -> ($e, $($v),+)
|
|
|
|
);
|
|
|
|
};
|
2016-06-28 04:09:25 +00:00
|
|
|
($(#[$($m:meta),+])+ pub enum $e:ident { $($v:ident $(=$val:expr)*),+ } ) => {
|
2019-10-24 04:45:32 +00:00
|
|
|
$crate::arg_enum!(@impls
|
2016-06-28 04:09:25 +00:00
|
|
|
($(#[$($m),+])+
|
2016-01-21 06:48:30 +00:00
|
|
|
pub enum $e {
|
2016-06-28 04:09:25 +00:00
|
|
|
$($v$(=$val)*),+
|
2016-01-21 06:48:30 +00:00
|
|
|
}) -> ($e, $($v),+)
|
|
|
|
);
|
2015-05-01 18:38:27 +00:00
|
|
|
};
|
2017-12-07 00:53:55 +00:00
|
|
|
($(#[$($m:meta),+])+ enum $e:ident { $($v:ident $(=$val:expr)*,)+ } ) => {
|
2019-10-24 04:45:32 +00:00
|
|
|
$crate::arg_enum!($(#[$($m:meta),+])+
|
2017-12-07 00:53:55 +00:00
|
|
|
enum $e:ident {
|
|
|
|
$($v:ident $(=$val:expr)*),+
|
|
|
|
}
|
|
|
|
);
|
|
|
|
};
|
|
|
|
($(#[$($m:meta),+])+ enum $e:ident { $($v:ident $(=$val:expr)*),+ } ) => {
|
2019-10-24 04:45:32 +00:00
|
|
|
$crate::arg_enum!(@impls
|
2016-06-28 04:09:25 +00:00
|
|
|
($(#[$($m),+])+
|
2016-01-21 06:48:30 +00:00
|
|
|
enum $e {
|
2016-06-28 04:09:25 +00:00
|
|
|
$($v$(=$val)*),+
|
2016-01-21 06:48:30 +00:00
|
|
|
}) -> ($e, $($v),+)
|
|
|
|
);
|
|
|
|
};
|
2017-12-07 00:53:55 +00:00
|
|
|
(pub enum $e:ident { $($v:ident $(=$val:expr)*,)+ } ) => {
|
2019-10-24 04:45:32 +00:00
|
|
|
$crate::arg_enum!(pub enum $e:ident {
|
2017-12-07 00:53:55 +00:00
|
|
|
$($v:ident $(=$val:expr)*),+
|
|
|
|
});
|
|
|
|
};
|
2016-06-28 04:09:25 +00:00
|
|
|
(pub enum $e:ident { $($v:ident $(=$val:expr)*),+ } ) => {
|
2019-10-24 04:45:32 +00:00
|
|
|
$crate::arg_enum!(@impls
|
2016-01-21 06:48:30 +00:00
|
|
|
(pub enum $e {
|
2016-06-28 04:09:25 +00:00
|
|
|
$($v$(=$val)*),+
|
2016-01-21 06:48:30 +00:00
|
|
|
}) -> ($e, $($v),+)
|
|
|
|
);
|
|
|
|
};
|
2017-12-07 00:53:55 +00:00
|
|
|
(enum $e:ident { $($v:ident $(=$val:expr)*,)+ } ) => {
|
2019-10-24 04:45:32 +00:00
|
|
|
$crate::arg_enum!(enum $e:ident {
|
2017-12-07 00:53:55 +00:00
|
|
|
$($v:ident $(=$val:expr)*),+
|
|
|
|
});
|
|
|
|
};
|
2016-06-28 04:09:25 +00:00
|
|
|
(enum $e:ident { $($v:ident $(=$val:expr)*),+ } ) => {
|
2019-10-24 04:45:32 +00:00
|
|
|
$crate::arg_enum!(@impls
|
2016-01-21 06:48:30 +00:00
|
|
|
(enum $e {
|
2016-06-28 04:09:25 +00:00
|
|
|
$($v$(=$val)*),+
|
2016-01-21 06:48:30 +00:00
|
|
|
}) -> ($e, $($v),+)
|
|
|
|
);
|
2015-05-01 18:38:27 +00:00
|
|
|
};
|
2015-04-19 02:20:43 +00:00
|
|
|
}
|
2015-04-19 18:06:08 +00:00
|
|
|
|
2016-04-12 05:37:36 +00:00
|
|
|
/// Allows you to pull the version from your Cargo.toml at compile time as
|
2017-06-08 18:42:10 +00:00
|
|
|
/// `MAJOR.MINOR.PATCH_PKGVERSION_PRE`
|
2015-04-19 18:06:08 +00:00
|
|
|
///
|
2015-09-22 02:06:15 +00:00
|
|
|
/// # Examples
|
2016-01-26 19:02:10 +00:00
|
|
|
///
|
2015-04-19 18:06:08 +00:00
|
|
|
/// ```no_run
|
|
|
|
/// # #[macro_use]
|
|
|
|
/// # extern crate clap;
|
|
|
|
/// # use clap::App;
|
|
|
|
/// # fn main() {
|
2016-12-31 13:17:07 +00:00
|
|
|
/// let m = App::new("app")
|
|
|
|
/// .version(crate_version!())
|
|
|
|
/// .get_matches();
|
2015-04-19 18:06:08 +00:00
|
|
|
/// # }
|
|
|
|
/// ```
|
2017-11-28 12:30:06 +00:00
|
|
|
#[cfg(not(feature = "no_cargo"))]
|
2015-04-19 18:06:08 +00:00
|
|
|
#[macro_export]
|
|
|
|
macro_rules! crate_version {
|
2015-05-01 18:38:27 +00:00
|
|
|
() => {
|
2016-01-21 06:48:30 +00:00
|
|
|
env!("CARGO_PKG_VERSION")
|
|
|
|
};
|
2015-04-19 18:06:08 +00:00
|
|
|
}
|
2015-09-08 12:53:31 +00:00
|
|
|
|
2016-05-06 21:35:53 +00:00
|
|
|
/// Allows you to pull the authors for the app from your Cargo.toml at
|
2016-12-18 21:43:43 +00:00
|
|
|
/// compile time in the form:
|
|
|
|
/// `"author1 lastname <author1@example.com>:author2 lastname <author2@example.com>"`
|
|
|
|
///
|
|
|
|
/// You can replace the colons with a custom separator by supplying a
|
|
|
|
/// replacement string, so, for example,
|
|
|
|
/// `crate_authors!(",\n")` would become
|
|
|
|
/// `"author1 lastname <author1@example.com>,\nauthor2 lastname <author2@example.com>,\nauthor3 lastname <author3@example.com>"`
|
2016-04-11 23:17:44 +00:00
|
|
|
///
|
|
|
|
/// # Examples
|
|
|
|
///
|
|
|
|
/// ```no_run
|
|
|
|
/// # #[macro_use]
|
|
|
|
/// # extern crate clap;
|
|
|
|
/// # use clap::App;
|
|
|
|
/// # fn main() {
|
2016-12-18 21:43:43 +00:00
|
|
|
/// let m = App::new("app")
|
|
|
|
/// .author(crate_authors!("\n"))
|
|
|
|
/// .get_matches();
|
2016-04-11 23:17:44 +00:00
|
|
|
/// # }
|
|
|
|
/// ```
|
2017-11-28 12:30:06 +00:00
|
|
|
#[cfg(not(feature = "no_cargo"))]
|
2016-07-23 22:56:42 +00:00
|
|
|
#[macro_export]
|
2016-04-11 23:17:44 +00:00
|
|
|
macro_rules! crate_authors {
|
2016-12-18 20:56:44 +00:00
|
|
|
($sep:expr) => {{
|
2016-12-18 12:17:34 +00:00
|
|
|
use std::ops::Deref;
|
2019-11-02 18:48:16 +00:00
|
|
|
use std::boxed::Box;
|
2019-11-02 19:18:57 +00:00
|
|
|
use std::cell::Cell;
|
2016-12-18 12:17:34 +00:00
|
|
|
|
|
|
|
#[allow(missing_copy_implementations)]
|
|
|
|
#[allow(dead_code)]
|
2018-08-02 03:13:51 +00:00
|
|
|
struct CargoAuthors {
|
2019-11-02 19:18:57 +00:00
|
|
|
authors: Cell<Option<&'static str>>,
|
2018-08-02 03:13:51 +00:00
|
|
|
__private_field: (),
|
|
|
|
};
|
2018-11-14 17:05:06 +00:00
|
|
|
|
2017-10-04 22:09:18 +00:00
|
|
|
impl Deref for CargoAuthors {
|
|
|
|
type Target = str;
|
2016-12-18 12:17:34 +00:00
|
|
|
|
2017-10-04 22:09:18 +00:00
|
|
|
fn deref(&self) -> &'static str {
|
2019-11-02 19:18:57 +00:00
|
|
|
let authors = self.authors.take();
|
|
|
|
if authors.is_some() {
|
|
|
|
let unwrapped_authors = authors.unwrap();
|
|
|
|
self.authors.replace(Some(unwrapped_authors));
|
|
|
|
unwrapped_authors
|
|
|
|
} else {
|
2019-11-02 20:03:35 +00:00
|
|
|
// This caches the result for subsequent invocations of the same instance of the macro
|
|
|
|
// to avoid performing one memory allocation per call.
|
|
|
|
// If performance ever becomes a problem for this code, it should be moved to build.rs
|
2019-11-02 19:18:57 +00:00
|
|
|
let s: Box<String> = Box::new(env!("CARGO_PKG_AUTHORS").replace(':', $sep));
|
|
|
|
let static_string = Box::leak(s);
|
|
|
|
self.authors.replace(Some(&*static_string));
|
|
|
|
&*static_string // weird but compiler-suggested way to turn a String into &str
|
|
|
|
}
|
2016-12-18 12:17:34 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-08-02 03:13:51 +00:00
|
|
|
&*CargoAuthors {
|
2019-11-02 19:18:57 +00:00
|
|
|
authors: std::cell::Cell::new(Option::None),
|
2018-08-02 03:13:51 +00:00
|
|
|
__private_field: (),
|
|
|
|
}
|
2016-12-18 12:17:34 +00:00
|
|
|
}};
|
2016-12-18 20:56:44 +00:00
|
|
|
() => {
|
|
|
|
env!("CARGO_PKG_AUTHORS")
|
|
|
|
};
|
2016-04-11 23:17:44 +00:00
|
|
|
}
|
|
|
|
|
2016-12-31 13:17:07 +00:00
|
|
|
/// Allows you to pull the description from your Cargo.toml at compile time.
|
|
|
|
///
|
|
|
|
/// # Examples
|
|
|
|
///
|
|
|
|
/// ```no_run
|
|
|
|
/// # #[macro_use]
|
|
|
|
/// # extern crate clap;
|
|
|
|
/// # use clap::App;
|
|
|
|
/// # fn main() {
|
|
|
|
/// let m = App::new("app")
|
|
|
|
/// .about(crate_description!())
|
|
|
|
/// .get_matches();
|
|
|
|
/// # }
|
|
|
|
/// ```
|
2017-11-28 12:30:06 +00:00
|
|
|
#[cfg(not(feature = "no_cargo"))]
|
2016-12-31 13:17:07 +00:00
|
|
|
#[macro_export]
|
|
|
|
macro_rules! crate_description {
|
|
|
|
() => {
|
|
|
|
env!("CARGO_PKG_DESCRIPTION")
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Allows you to pull the name from your Cargo.toml at compile time.
|
|
|
|
///
|
|
|
|
/// # Examples
|
|
|
|
///
|
|
|
|
/// ```no_run
|
|
|
|
/// # #[macro_use]
|
|
|
|
/// # extern crate clap;
|
|
|
|
/// # use clap::App;
|
|
|
|
/// # fn main() {
|
|
|
|
/// let m = App::new(crate_name!())
|
|
|
|
/// .get_matches();
|
|
|
|
/// # }
|
|
|
|
/// ```
|
2017-11-28 12:30:06 +00:00
|
|
|
#[cfg(not(feature = "no_cargo"))]
|
2016-12-31 13:17:07 +00:00
|
|
|
#[macro_export]
|
|
|
|
macro_rules! crate_name {
|
|
|
|
() => {
|
|
|
|
env!("CARGO_PKG_NAME")
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Allows you to build the `App` instance from your Cargo.toml at compile time.
|
|
|
|
///
|
|
|
|
/// Equivalent to using the `crate_*!` macros with their respective fields.
|
|
|
|
///
|
2017-01-30 02:13:34 +00:00
|
|
|
/// Provided separator is for the [`crate_authors!`](macro.crate_authors.html) macro,
|
2016-12-31 13:17:07 +00:00
|
|
|
/// refer to the documentation therefor.
|
|
|
|
///
|
2017-02-21 04:51:20 +00:00
|
|
|
/// **NOTE:** Changing the values in your `Cargo.toml` does not trigger a re-build automatically,
|
2017-02-03 22:43:49 +00:00
|
|
|
/// and therefore won't change the generated output until you recompile.
|
|
|
|
///
|
|
|
|
/// **Pro Tip:** In some cases you can "trick" the compiler into triggering a rebuild when your
|
2017-02-21 04:51:20 +00:00
|
|
|
/// `Cargo.toml` is changed by including this in your `src/main.rs` file
|
2017-02-03 22:43:49 +00:00
|
|
|
/// `include_str!("../Cargo.toml");`
|
|
|
|
///
|
2016-12-31 13:17:07 +00:00
|
|
|
/// # Examples
|
|
|
|
///
|
|
|
|
/// ```no_run
|
|
|
|
/// # #[macro_use]
|
|
|
|
/// # extern crate clap;
|
|
|
|
/// # fn main() {
|
|
|
|
/// let m = app_from_crate!().get_matches();
|
|
|
|
/// # }
|
|
|
|
/// ```
|
2017-11-28 12:30:06 +00:00
|
|
|
#[cfg(not(feature = "no_cargo"))]
|
2016-12-31 13:17:07 +00:00
|
|
|
#[macro_export]
|
|
|
|
macro_rules! app_from_crate {
|
|
|
|
() => {
|
2019-10-24 04:45:32 +00:00
|
|
|
$crate::App::new($crate::crate_name!())
|
|
|
|
.version($crate::crate_version!())
|
|
|
|
.author($crate::crate_authors!())
|
|
|
|
.about($crate::crate_description!())
|
2016-12-31 13:17:07 +00:00
|
|
|
};
|
|
|
|
($sep:expr) => {
|
2019-10-24 04:45:32 +00:00
|
|
|
$crate::App::new($crate::crate_name!())
|
|
|
|
.version($crate::crate_version!())
|
|
|
|
.author($crate::crate_authors!($sep))
|
|
|
|
.about($crate::crate_description!())
|
2016-12-31 13:17:07 +00:00
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2018-10-19 20:42:13 +00:00
|
|
|
/// Build `App`, `Arg`s, ``s and `Group`s with Usage-string like input
|
2017-02-16 14:44:44 +00:00
|
|
|
/// but without the associated parsing runtime cost.
|
|
|
|
///
|
|
|
|
/// `clap_app!` also supports several shorthand syntaxes.
|
|
|
|
///
|
|
|
|
/// # Examples
|
|
|
|
///
|
|
|
|
/// ```no_run
|
|
|
|
/// # #[macro_use]
|
|
|
|
/// # extern crate clap;
|
|
|
|
/// # fn main() {
|
2017-02-21 04:51:20 +00:00
|
|
|
/// let matches = clap_app!(myapp =>
|
|
|
|
/// (version: "1.0")
|
|
|
|
/// (author: "Kevin K. <kbknapp@gmail.com>")
|
|
|
|
/// (about: "Does awesome things")
|
2017-02-16 14:44:44 +00:00
|
|
|
/// (@arg CONFIG: -c --config +takes_value "Sets a custom config file")
|
2017-02-21 04:51:20 +00:00
|
|
|
/// (@arg INPUT: +required "Sets the input file to use")
|
|
|
|
/// (@arg debug: -d ... "Sets the level of debugging information")
|
2017-05-15 22:34:10 +00:00
|
|
|
/// (@group difficulty =>
|
|
|
|
/// (@arg hard: -h --hard "Sets hard mode")
|
|
|
|
/// (@arg normal: -n --normal "Sets normal mode")
|
|
|
|
/// (@arg easy: -e --easy "Sets easy mode")
|
|
|
|
/// )
|
2017-02-21 04:51:20 +00:00
|
|
|
/// (@subcommand test =>
|
|
|
|
/// (about: "controls testing features")
|
|
|
|
/// (version: "1.3")
|
|
|
|
/// (author: "Someone E. <someone_else@other.com>")
|
2017-02-16 14:44:44 +00:00
|
|
|
/// (@arg verbose: -v --verbose "Print test information verbosely")
|
2017-02-21 04:51:20 +00:00
|
|
|
/// )
|
2017-02-16 17:48:34 +00:00
|
|
|
/// );
|
2017-02-21 04:51:20 +00:00
|
|
|
/// # }
|
2017-02-16 14:44:44 +00:00
|
|
|
/// ```
|
|
|
|
/// # Shorthand Syntax for Args
|
2017-02-21 04:51:20 +00:00
|
|
|
///
|
2017-02-16 14:44:44 +00:00
|
|
|
/// * A single hyphen followed by a character (such as `-c`) sets the [`Arg::short`]
|
|
|
|
/// * A double hyphen followed by a character or word (such as `--config`) sets [`Arg::long`]
|
2017-04-05 04:47:19 +00:00
|
|
|
/// * If one wishes to use a [`Arg::long`] with a hyphen inside (i.e. `--config-file`), you
|
|
|
|
/// must use `--("config-file")` due to limitations of the Rust macro system.
|
2017-02-16 14:44:44 +00:00
|
|
|
/// * Three dots (`...`) sets [`Arg::multiple(true)`]
|
2017-02-21 04:51:20 +00:00
|
|
|
/// * Angled brackets after either a short or long will set [`Arg::value_name`] and
|
|
|
|
/// `Arg::required(true)` such as `--config <FILE>` = `Arg::value_name("FILE")` and
|
2018-03-19 20:53:19 +00:00
|
|
|
/// `Arg::required(true)`
|
2017-02-21 04:51:20 +00:00
|
|
|
/// * Square brackets after either a short or long will set [`Arg::value_name`] and
|
|
|
|
/// `Arg::required(false)` such as `--config [FILE]` = `Arg::value_name("FILE")` and
|
2018-03-19 20:53:19 +00:00
|
|
|
/// `Arg::required(false)`
|
2017-02-21 04:51:20 +00:00
|
|
|
/// * There are short hand syntaxes for Arg methods that accept booleans
|
2017-02-16 14:44:44 +00:00
|
|
|
/// * A plus sign will set that method to `true` such as `+required` = `Arg::required(true)`
|
|
|
|
/// * An exclamation will set that method to `false` such as `!required` = `Arg::required(false)`
|
|
|
|
/// * A `#{min, max}` will set [`Arg::min_values(min)`] and [`Arg::max_values(max)`]
|
|
|
|
/// * An asterisk (`*`) will set `Arg::required(true)`
|
|
|
|
/// * Curly brackets around a `fn` will set [`Arg::validator`] as in `{fn}` = `Arg::validator(fn)`
|
2017-02-21 04:51:20 +00:00
|
|
|
/// * An Arg method that accepts a string followed by square brackets will set that method such as
|
|
|
|
/// `conflicts_with[FOO]` will set `Arg::conflicts_with("FOO")` (note the lack of quotes around
|
|
|
|
/// `FOO` in the macro)
|
|
|
|
/// * An Arg method that takes a string and can be set multiple times (such as
|
|
|
|
/// [`Arg::conflicts_with`]) followed by square brackets and a list of values separated by spaces
|
|
|
|
/// will set that method such as `conflicts_with[FOO BAR BAZ]` will set
|
2017-02-16 14:44:44 +00:00
|
|
|
/// `Arg::conflicts_with("FOO")`, `Arg::conflicts_with("BAR")`, and `Arg::conflicts_with("BAZ")`
|
2017-02-21 04:51:20 +00:00
|
|
|
/// (note the lack of quotes around the values in the macro)
|
2017-02-16 14:44:44 +00:00
|
|
|
///
|
2018-03-30 20:49:49 +00:00
|
|
|
/// # Shorthand Syntax for Groups
|
|
|
|
///
|
|
|
|
/// * There are short hand syntaxes for `ArgGroup` methods that accept booleans
|
|
|
|
/// * A plus sign will set that method to `true` such as `+required` = `ArgGroup::required(true)`
|
|
|
|
/// * An exclamation will set that method to `false` such as `!required` = `ArgGroup::required(false)`
|
2020-01-11 18:15:46 +00:00
|
|
|
///
|
2019-07-20 23:39:30 +00:00
|
|
|
/// # Alternative form for non-ident values
|
2020-01-11 18:15:46 +00:00
|
|
|
///
|
2019-07-20 23:39:30 +00:00
|
|
|
/// Certain places that normally accept an `ident`, will optionally accept an alternative of `("expr enclosed by parens")`
|
|
|
|
/// * `(@arg something: --something)` could also be `(@arg ("something-else"): --("something-else"))`
|
|
|
|
/// * `(@subcommand something => ...)` could also be `(@subcommand ("something-else") => ...)`
|
2018-03-30 20:49:49 +00:00
|
|
|
///
|
2017-02-16 14:44:44 +00:00
|
|
|
/// [`Arg::short`]: ./struct.Arg.html#method.short
|
|
|
|
/// [`Arg::long`]: ./struct.Arg.html#method.long
|
|
|
|
/// [`Arg::multiple(true)`]: ./struct.Arg.html#method.multiple
|
|
|
|
/// [`Arg::value_name`]: ./struct.Arg.html#method.value_name
|
|
|
|
/// [`Arg::min_values(min)`]: ./struct.Arg.html#method.min_values
|
|
|
|
/// [`Arg::max_values(max)`]: ./struct.Arg.html#method.max_values
|
|
|
|
/// [`Arg::validator`]: ./struct.Arg.html#method.validator
|
|
|
|
/// [`Arg::conflicts_with`]: ./struct.Arg.html#method.conflicts_with
|
2016-10-15 21:37:59 +00:00
|
|
|
#[macro_export]
|
2015-09-08 12:53:31 +00:00
|
|
|
macro_rules! clap_app {
|
|
|
|
(@app ($builder:expr)) => { $builder };
|
2017-04-05 04:57:47 +00:00
|
|
|
(@app ($builder:expr) (@arg ($name:expr): $($tail:tt)*) $($tt:tt)*) => {
|
2019-10-24 04:45:32 +00:00
|
|
|
$crate::clap_app!{ @app
|
2017-04-05 04:57:47 +00:00
|
|
|
($builder.arg(
|
2019-10-24 04:45:32 +00:00
|
|
|
$crate::clap_app!{ @arg ($crate::Arg::with_name($name)) (-) $($tail)* }))
|
2017-04-05 04:57:47 +00:00
|
|
|
$($tt)*
|
|
|
|
}
|
|
|
|
};
|
2015-09-08 12:53:31 +00:00
|
|
|
(@app ($builder:expr) (@arg $name:ident: $($tail:tt)*) $($tt:tt)*) => {
|
2019-10-24 04:45:32 +00:00
|
|
|
$crate::clap_app!{ @app
|
2016-05-06 21:35:53 +00:00
|
|
|
($builder.arg(
|
2019-10-24 04:45:32 +00:00
|
|
|
$crate::clap_app!{ @arg ($crate::Arg::with_name(stringify!($name))) (-) $($tail)* }))
|
2015-09-08 12:53:31 +00:00
|
|
|
$($tt)*
|
|
|
|
}
|
|
|
|
};
|
|
|
|
(@app ($builder:expr) (@setting $setting:ident) $($tt:tt)*) => {
|
2019-10-24 04:45:32 +00:00
|
|
|
$crate::clap_app!{ @app
|
2015-09-08 12:53:31 +00:00
|
|
|
($builder.setting($crate::AppSettings::$setting))
|
|
|
|
$($tt)*
|
|
|
|
}
|
|
|
|
};
|
2018-03-30 20:49:49 +00:00
|
|
|
// Treat the application builder as an argument to set its attributes
|
2015-09-08 12:53:31 +00:00
|
|
|
(@app ($builder:expr) (@attributes $($attr:tt)*) $($tt:tt)*) => {
|
2019-10-24 04:45:32 +00:00
|
|
|
$crate::clap_app!{ @app ($crate::clap_app!{ @arg ($builder) $($attr)* }) $($tt)* }
|
2015-09-08 12:53:31 +00:00
|
|
|
};
|
|
|
|
(@app ($builder:expr) (@group $name:ident => $($tail:tt)*) $($tt:tt)*) => {
|
2019-10-24 04:45:32 +00:00
|
|
|
$crate::clap_app!{ @app
|
|
|
|
($crate::clap_app!{ @group ($builder, $crate::ArgGroup::with_name(stringify!($name))) $($tail)* })
|
2015-09-08 12:53:31 +00:00
|
|
|
$($tt)*
|
|
|
|
}
|
|
|
|
};
|
2018-03-30 20:49:49 +00:00
|
|
|
(@app ($builder:expr) (@group $name:ident !$ident:ident => $($tail:tt)*) $($tt:tt)*) => {
|
2019-10-24 04:45:32 +00:00
|
|
|
$crate::clap_app!{ @app
|
|
|
|
($crate::clap_app!{ @group ($builder, $crate::ArgGroup::with_name(stringify!($name)).$ident(false)) $($tail)* })
|
2018-03-30 20:49:49 +00:00
|
|
|
$($tt)*
|
|
|
|
}
|
|
|
|
};
|
|
|
|
(@app ($builder:expr) (@group $name:ident +$ident:ident => $($tail:tt)*) $($tt:tt)*) => {
|
2019-10-24 04:45:32 +00:00
|
|
|
$crate::clap_app!{ @app
|
|
|
|
($crate::clap_app!{ @group ($builder, $crate::ArgGroup::with_name(stringify!($name)).$ident(true)) $($tail)* })
|
2018-03-30 20:49:49 +00:00
|
|
|
$($tt)*
|
|
|
|
}
|
|
|
|
};
|
2016-05-06 21:35:53 +00:00
|
|
|
// Handle subcommand creation
|
2015-09-08 12:53:31 +00:00
|
|
|
(@app ($builder:expr) (@subcommand $name:ident => $($tail:tt)*) $($tt:tt)*) => {
|
2019-10-24 04:45:32 +00:00
|
|
|
$crate::clap_app!{ @app
|
2015-09-08 12:53:31 +00:00
|
|
|
($builder.subcommand(
|
2019-10-24 04:45:32 +00:00
|
|
|
$crate::clap_app!{ @app ($crate::App::new(stringify!($name))) $($tail)* }
|
2015-09-08 12:53:31 +00:00
|
|
|
))
|
|
|
|
$($tt)*
|
|
|
|
}
|
|
|
|
};
|
2019-07-20 23:39:30 +00:00
|
|
|
(@app ($builder:expr) (@subcommand ($name:expr) => $($tail:tt)*) $($tt:tt)*) => {
|
|
|
|
clap_app!{ @app
|
|
|
|
($builder.subcommand(
|
|
|
|
$crate::clap_app!{ @app ($crate::App::new($name)) $($tail)* }
|
|
|
|
))
|
|
|
|
$($tt)*
|
|
|
|
}
|
|
|
|
};
|
2016-05-06 21:35:53 +00:00
|
|
|
// Yaml like function calls - used for setting various meta directly against the app
|
2015-09-08 12:53:31 +00:00
|
|
|
(@app ($builder:expr) ($ident:ident: $($v:expr),*) $($tt:tt)*) => {
|
2016-05-06 21:35:53 +00:00
|
|
|
// clap_app!{ @app ($builder.$ident($($v),*)) $($tt)* }
|
2019-10-24 04:45:32 +00:00
|
|
|
$crate::clap_app!{ @app
|
2015-09-09 04:00:17 +00:00
|
|
|
($builder.$ident($($v),*))
|
|
|
|
$($tt)*
|
|
|
|
}
|
2015-09-08 12:53:31 +00:00
|
|
|
};
|
|
|
|
|
2016-05-06 21:35:53 +00:00
|
|
|
// Add members to group and continue argument handling with the parent builder
|
2016-01-21 05:18:53 +00:00
|
|
|
(@group ($builder:expr, $group:expr)) => { $builder.group($group) };
|
2018-03-30 20:49:49 +00:00
|
|
|
// Treat the group builder as an argument to set its attributes
|
2015-09-08 12:53:31 +00:00
|
|
|
(@group ($builder:expr, $group:expr) (@attributes $($attr:tt)*) $($tt:tt)*) => {
|
2019-10-24 04:45:32 +00:00
|
|
|
$crate::clap_app!{ @group ($builder, $crate::clap_app!{ @arg ($group) (-) $($attr)* }) $($tt)* }
|
2015-09-08 12:53:31 +00:00
|
|
|
};
|
|
|
|
(@group ($builder:expr, $group:expr) (@arg $name:ident: $($tail:tt)*) $($tt:tt)*) => {
|
2019-10-24 04:45:32 +00:00
|
|
|
$crate::clap_app!{ @group
|
|
|
|
($crate::clap_app!{ @app ($builder) (@arg $name: $($tail)*) },
|
2016-01-21 05:18:53 +00:00
|
|
|
$group.arg(stringify!($name)))
|
2015-09-08 12:53:31 +00:00
|
|
|
$($tt)*
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2016-05-06 21:35:53 +00:00
|
|
|
// No more tokens to munch
|
2015-09-08 12:53:31 +00:00
|
|
|
(@arg ($arg:expr) $modes:tt) => { $arg };
|
2016-05-06 21:35:53 +00:00
|
|
|
// Shorthand tokens influenced by the usage_string
|
2016-12-13 06:42:11 +00:00
|
|
|
(@arg ($arg:expr) $modes:tt --($long:expr) $($tail:tt)*) => {
|
2019-10-24 04:45:32 +00:00
|
|
|
$crate::clap_app!{ @arg ($arg.long($long)) $modes $($tail)* }
|
2016-12-13 06:42:11 +00:00
|
|
|
};
|
2015-09-08 12:53:31 +00:00
|
|
|
(@arg ($arg:expr) $modes:tt --$long:ident $($tail:tt)*) => {
|
2019-10-24 04:45:32 +00:00
|
|
|
$crate::clap_app!{ @arg ($arg.long(stringify!($long))) $modes $($tail)* }
|
2015-09-08 12:53:31 +00:00
|
|
|
};
|
|
|
|
(@arg ($arg:expr) $modes:tt -$short:ident $($tail:tt)*) => {
|
2019-10-24 04:45:32 +00:00
|
|
|
$crate::clap_app!{ @arg ($arg.short(stringify!($short).chars().nth(0).unwrap())) $modes $($tail)* }
|
2015-09-08 12:53:31 +00:00
|
|
|
};
|
|
|
|
(@arg ($arg:expr) (-) <$var:ident> $($tail:tt)*) => {
|
2019-10-24 04:45:32 +00:00
|
|
|
$crate::clap_app!{ @arg ($arg.value_name(stringify!($var))) (+) +takes_value +required $($tail)* }
|
2015-09-08 12:53:31 +00:00
|
|
|
};
|
|
|
|
(@arg ($arg:expr) (+) <$var:ident> $($tail:tt)*) => {
|
2019-10-24 04:45:32 +00:00
|
|
|
$crate::clap_app!{ @arg ($arg.value_name(stringify!($var))) (+) $($tail)* }
|
2015-09-08 12:53:31 +00:00
|
|
|
};
|
|
|
|
(@arg ($arg:expr) (-) [$var:ident] $($tail:tt)*) => {
|
2019-10-24 04:45:32 +00:00
|
|
|
$crate::clap_app!{ @arg ($arg.value_name(stringify!($var))) (+) +takes_value $($tail)* }
|
2015-09-08 12:53:31 +00:00
|
|
|
};
|
|
|
|
(@arg ($arg:expr) (+) [$var:ident] $($tail:tt)*) => {
|
2019-10-24 04:45:32 +00:00
|
|
|
$crate::clap_app!{ @arg ($arg.value_name(stringify!($var))) (+) $($tail)* }
|
2015-09-08 12:53:31 +00:00
|
|
|
};
|
|
|
|
(@arg ($arg:expr) $modes:tt ... $($tail:tt)*) => {
|
2019-10-24 04:45:32 +00:00
|
|
|
$crate::clap_app!{ @arg ($arg) $modes +multiple $($tail)* }
|
2015-09-08 12:53:31 +00:00
|
|
|
};
|
2016-05-06 21:35:53 +00:00
|
|
|
// Shorthand magic
|
2015-09-08 12:53:31 +00:00
|
|
|
(@arg ($arg:expr) $modes:tt #{$n:expr, $m:expr} $($tail:tt)*) => {
|
2019-10-24 04:45:32 +00:00
|
|
|
$crate::clap_app!{ @arg ($arg) $modes min_values($n) max_values($m) $($tail)* }
|
2015-09-08 12:53:31 +00:00
|
|
|
};
|
|
|
|
(@arg ($arg:expr) $modes:tt * $($tail:tt)*) => {
|
2019-10-24 04:45:32 +00:00
|
|
|
$crate::clap_app!{ @arg ($arg) $modes +required $($tail)* }
|
2015-09-08 12:53:31 +00:00
|
|
|
};
|
2016-05-06 21:35:53 +00:00
|
|
|
// !foo -> .foo(false)
|
2017-02-18 10:03:41 +00:00
|
|
|
(@arg ($arg:expr) $modes:tt !$ident:ident $($tail:tt)*) => {
|
2019-10-24 04:45:32 +00:00
|
|
|
$crate::clap_app!{ @arg ($arg.$ident(false)) $modes $($tail)* }
|
2015-09-08 12:53:31 +00:00
|
|
|
};
|
2017-02-16 14:44:44 +00:00
|
|
|
// +foo -> .foo(true)
|
2015-09-08 12:53:31 +00:00
|
|
|
(@arg ($arg:expr) $modes:tt +$ident:ident $($tail:tt)*) => {
|
2019-10-24 04:45:32 +00:00
|
|
|
$crate::clap_app!{ @arg ($arg.$ident(true)) $modes $($tail)* }
|
2015-09-08 12:53:31 +00:00
|
|
|
};
|
2016-05-06 21:35:53 +00:00
|
|
|
// Validator
|
2015-09-08 12:53:31 +00:00
|
|
|
(@arg ($arg:expr) $modes:tt {$fn_:expr} $($tail:tt)*) => {
|
2019-10-24 04:45:32 +00:00
|
|
|
$crate::clap_app!{ @arg ($arg.validator($fn_)) $modes $($tail)* }
|
2015-09-08 12:53:31 +00:00
|
|
|
};
|
|
|
|
(@as_expr $expr:expr) => { $expr };
|
2016-05-06 21:35:53 +00:00
|
|
|
// Help
|
2015-09-08 12:53:31 +00:00
|
|
|
(@arg ($arg:expr) $modes:tt $desc:tt) => { $arg.help(clap_app!{ @as_expr $desc }) };
|
2016-05-06 21:35:53 +00:00
|
|
|
// Handle functions that need to be called multiple times for each argument
|
2015-09-08 12:53:31 +00:00
|
|
|
(@arg ($arg:expr) $modes:tt $ident:ident[$($target:ident)*] $($tail:tt)*) => {
|
2019-10-24 04:45:32 +00:00
|
|
|
$crate::clap_app!{ @arg ($arg $( .$ident(stringify!($target)) )*) $modes $($tail)* }
|
2015-09-08 12:53:31 +00:00
|
|
|
};
|
2016-05-06 21:35:53 +00:00
|
|
|
// Inherit builder's functions
|
2015-09-08 12:53:31 +00:00
|
|
|
(@arg ($arg:expr) $modes:tt $ident:ident($($expr:expr)*) $($tail:tt)*) => {
|
2019-10-24 04:45:32 +00:00
|
|
|
$crate::clap_app!{ @arg ($arg.$ident($($expr)*)) $modes $($tail)* }
|
2015-09-08 12:53:31 +00:00
|
|
|
};
|
|
|
|
|
2016-05-06 21:35:53 +00:00
|
|
|
// Build a subcommand outside of an app.
|
2015-09-08 12:53:31 +00:00
|
|
|
(@subcommand $name:ident => $($tail:tt)*) => {
|
2019-10-24 04:45:32 +00:00
|
|
|
$crate::clap_app!{ @app ($crate::App::new(stringify!($name))) $($tail)* }
|
2015-09-08 12:53:31 +00:00
|
|
|
};
|
2019-07-20 23:39:30 +00:00
|
|
|
(@subcommand ($name:expr) => $($tail:tt)*) => {
|
|
|
|
$crate::clap_app!{ @app ($crate::App::new($name)) $($tail)* }
|
|
|
|
};
|
2016-05-06 21:35:53 +00:00
|
|
|
// Start the magic
|
2016-12-13 06:42:11 +00:00
|
|
|
(($name:expr) => $($tail:tt)*) => {{
|
2019-10-24 04:45:32 +00:00
|
|
|
$crate::clap_app!{ @app ($crate::App::new($name)) $($tail)*}
|
2016-12-13 06:42:11 +00:00
|
|
|
}};
|
|
|
|
|
2015-09-08 12:53:31 +00:00
|
|
|
($name:ident => $($tail:tt)*) => {{
|
2019-10-24 04:45:32 +00:00
|
|
|
$crate::clap_app!{ @app ($crate::App::new(stringify!($name))) $($tail)*}
|
2015-09-08 12:53:31 +00:00
|
|
|
}};
|
|
|
|
}
|
2016-01-26 19:02:10 +00:00
|
|
|
|
|
|
|
macro_rules! impl_settings {
|
2020-02-04 16:02:08 +00:00
|
|
|
($settings:ident, $flags:ident,
|
|
|
|
$( $setting:ident($str:expr) => $flag:path ),+
|
|
|
|
) => {
|
|
|
|
impl $flags {
|
|
|
|
pub fn set(&mut self, s: $settings) {
|
|
|
|
match s {
|
|
|
|
$($settings::$setting => self.0.insert($flag)),*
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn unset(&mut self, s: $settings) {
|
|
|
|
match s {
|
|
|
|
$($settings::$setting => self.0.remove($flag)),*
|
|
|
|
}
|
2016-01-26 19:02:10 +00:00
|
|
|
}
|
|
|
|
|
2020-02-04 16:02:08 +00:00
|
|
|
pub fn is_set(&self, s: $settings) -> bool {
|
|
|
|
match s {
|
|
|
|
$($settings::$setting => self.0.contains($flag)),*
|
|
|
|
}
|
2016-01-26 19:02:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-02-04 16:02:08 +00:00
|
|
|
impl FromStr for $settings {
|
|
|
|
type Err = String;
|
|
|
|
fn from_str(s: &str) -> Result<Self, <Self as FromStr>::Err> {
|
|
|
|
match &*s.to_ascii_lowercase() {
|
|
|
|
$( $str => $settings::$setting, )*
|
|
|
|
_ => Err(format!("unknown AppSetting: `{}`", s)),
|
|
|
|
}
|
2016-01-26 19:02:10 +00:00
|
|
|
}
|
|
|
|
}
|
2020-02-04 16:02:08 +00:00
|
|
|
}
|
2016-01-26 19:02:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Convenience for writing to stderr thanks to https://github.com/BurntSushi
|
|
|
|
macro_rules! wlnerr(
|
|
|
|
($($arg:tt)*) => ({
|
|
|
|
use std::io::{Write, stderr};
|
|
|
|
writeln!(&mut stderr(), $($arg)*).ok();
|
|
|
|
})
|
|
|
|
);
|
|
|
|
|
|
|
|
#[cfg(feature = "debug")]
|
|
|
|
#[cfg_attr(feature = "debug", macro_use)]
|
2017-11-13 22:01:09 +00:00
|
|
|
#[cfg_attr(feature = "debug", allow(unused_macros))]
|
2016-01-26 19:02:10 +00:00
|
|
|
mod debug_macros {
|
|
|
|
macro_rules! debugln {
|
2016-12-29 19:07:04 +00:00
|
|
|
($fmt:expr) => (println!(concat!("DEBUG:clap:", $fmt)));
|
|
|
|
($fmt:expr, $($arg:tt)*) => (println!(concat!("DEBUG:clap:",$fmt), $($arg)*));
|
2016-01-26 19:02:10 +00:00
|
|
|
}
|
|
|
|
macro_rules! sdebugln {
|
|
|
|
($fmt:expr) => (println!($fmt));
|
|
|
|
($fmt:expr, $($arg:tt)*) => (println!($fmt, $($arg)*));
|
|
|
|
}
|
|
|
|
macro_rules! debug {
|
2016-12-29 19:07:04 +00:00
|
|
|
($fmt:expr) => (print!(concat!("DEBUG:clap:", $fmt)));
|
|
|
|
($fmt:expr, $($arg:tt)*) => (print!(concat!("DEBUG:clap:",$fmt), $($arg)*));
|
2016-01-26 19:02:10 +00:00
|
|
|
}
|
|
|
|
macro_rules! sdebug {
|
|
|
|
($fmt:expr) => (print!($fmt));
|
|
|
|
($fmt:expr, $($arg:tt)*) => (print!($fmt, $($arg)*));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[cfg(not(feature = "debug"))]
|
|
|
|
#[cfg_attr(not(feature = "debug"), macro_use)]
|
|
|
|
mod debug_macros {
|
|
|
|
macro_rules! debugln {
|
2018-08-02 03:13:51 +00:00
|
|
|
($fmt:expr) => {};
|
|
|
|
($fmt:expr, $($arg:tt)*) => {};
|
2016-01-26 19:02:10 +00:00
|
|
|
}
|
|
|
|
macro_rules! sdebugln {
|
2018-08-02 03:13:51 +00:00
|
|
|
($fmt:expr) => {};
|
|
|
|
($fmt:expr, $($arg:tt)*) => {};
|
2016-01-26 19:02:10 +00:00
|
|
|
}
|
|
|
|
macro_rules! debug {
|
2018-08-02 03:13:51 +00:00
|
|
|
($fmt:expr) => {};
|
|
|
|
($fmt:expr, $($arg:tt)*) => {};
|
2016-01-26 19:02:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-04-03 04:06:37 +00:00
|
|
|
// Helper/deduplication macro for printing the correct number of spaces in help messages
|
|
|
|
// used in:
|
|
|
|
// src/args/arg_builder/*.rs
|
|
|
|
// src/app/mod.rs
|
|
|
|
macro_rules! write_nspaces {
|
2018-08-02 03:13:51 +00:00
|
|
|
($dst:expr, $num:expr) => {{
|
2016-12-29 19:07:04 +00:00
|
|
|
debugln!("write_spaces!: num={}", $num);
|
2016-04-03 04:06:37 +00:00
|
|
|
for _ in 0..$num {
|
2017-07-29 18:29:22 +00:00
|
|
|
$dst.write_all(b" ")?;
|
2016-04-03 04:06:37 +00:00
|
|
|
}
|
2018-08-02 03:13:51 +00:00
|
|
|
}};
|
2016-04-03 04:06:37 +00:00
|
|
|
}
|
|
|
|
|
2018-01-22 23:19:53 +00:00
|
|
|
macro_rules! flags {
|
2018-07-24 16:48:24 +00:00
|
|
|
($app:expr, $how:ident) => {{
|
2018-08-02 03:13:51 +00:00
|
|
|
$app.args
|
2018-11-14 00:44:43 +00:00
|
|
|
.args
|
2018-08-02 03:13:51 +00:00
|
|
|
.$how()
|
2019-04-05 19:51:22 +00:00
|
|
|
.filter(|a| {
|
|
|
|
!a.settings.is_set(crate::build::ArgSettings::TakesValue) && a.index.is_none()
|
|
|
|
})
|
2018-04-04 03:27:57 +00:00
|
|
|
.filter(|a| !a.help_heading.is_some())
|
2018-07-24 16:48:24 +00:00
|
|
|
}};
|
2018-01-22 23:19:53 +00:00
|
|
|
($app:expr) => {
|
|
|
|
flags!($app, iter)
|
2018-08-02 03:13:51 +00:00
|
|
|
};
|
2018-01-22 23:19:53 +00:00
|
|
|
}
|
|
|
|
|
2018-01-25 21:22:49 +00:00
|
|
|
#[allow(unused_macros)]
|
2018-01-22 23:19:53 +00:00
|
|
|
macro_rules! flags_mut {
|
|
|
|
($app:expr) => {
|
2019-10-24 04:45:32 +00:00
|
|
|
$crate::flags!($app, iter_mut)
|
2018-08-02 03:13:51 +00:00
|
|
|
};
|
2018-01-22 23:19:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
macro_rules! opts {
|
2018-07-24 16:48:24 +00:00
|
|
|
($app:expr, $how:ident) => {{
|
2018-08-02 03:13:51 +00:00
|
|
|
$app.args
|
2018-11-14 00:44:43 +00:00
|
|
|
.args
|
2018-08-02 03:13:51 +00:00
|
|
|
.$how()
|
2019-04-05 19:51:22 +00:00
|
|
|
.filter(|a| {
|
|
|
|
a.settings.is_set(crate::build::ArgSettings::TakesValue) && a.index.is_none()
|
|
|
|
})
|
2018-04-04 03:27:57 +00:00
|
|
|
.filter(|a| !a.help_heading.is_some())
|
2018-07-24 16:48:24 +00:00
|
|
|
}};
|
2018-01-22 23:19:53 +00:00
|
|
|
($app:expr) => {
|
|
|
|
opts!($app, iter)
|
2018-08-02 03:13:51 +00:00
|
|
|
};
|
2018-01-22 23:19:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#[allow(unused_macros)]
|
|
|
|
macro_rules! opts_mut {
|
|
|
|
($app:expr) => {
|
2018-01-24 17:00:58 +00:00
|
|
|
opts!($app, iter_mut)
|
2018-08-02 03:13:51 +00:00
|
|
|
};
|
2018-01-22 23:19:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
macro_rules! positionals {
|
2018-07-24 16:48:24 +00:00
|
|
|
($app:expr) => {
|
2018-08-02 03:13:51 +00:00
|
|
|
$app.args
|
2018-11-14 00:44:43 +00:00
|
|
|
.args
|
|
|
|
.iter()
|
2018-04-04 03:27:57 +00:00
|
|
|
.filter(|a| !(a.short.is_some() || a.long.is_some()))
|
2018-01-22 23:19:53 +00:00
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
#[allow(unused_macros)]
|
|
|
|
macro_rules! positionals_mut {
|
|
|
|
($app:expr) => {
|
2018-07-24 16:48:24 +00:00
|
|
|
$app.args
|
|
|
|
.values_mut()
|
|
|
|
.filter(|a| !(a.short.is_some() || a.long.is_some()))
|
2018-08-02 03:13:51 +00:00
|
|
|
};
|
2018-01-22 23:19:53 +00:00
|
|
|
}
|
|
|
|
|
2018-04-04 03:27:57 +00:00
|
|
|
#[allow(unused_macros)]
|
|
|
|
macro_rules! custom_headings_mut {
|
|
|
|
($app:expr) => {
|
2018-07-24 16:48:24 +00:00
|
|
|
custom_headings!($app, values_mut)
|
2018-08-02 03:13:51 +00:00
|
|
|
};
|
2018-04-04 03:27:57 +00:00
|
|
|
}
|
|
|
|
|
2018-01-24 17:00:58 +00:00
|
|
|
macro_rules! subcommands_cloned {
|
|
|
|
($app:expr, $how:ident) => {
|
|
|
|
$app.subcommands.$how().cloned()
|
|
|
|
};
|
|
|
|
($app:expr) => {
|
|
|
|
subcommands_cloned!($app, iter)
|
2018-08-02 03:13:51 +00:00
|
|
|
};
|
2018-01-24 17:00:58 +00:00
|
|
|
}
|
|
|
|
|
2018-01-22 23:19:53 +00:00
|
|
|
macro_rules! subcommands {
|
|
|
|
($app:expr, $how:ident) => {
|
|
|
|
$app.subcommands.$how()
|
|
|
|
};
|
|
|
|
($app:expr) => {
|
|
|
|
subcommands!($app, iter)
|
2018-08-02 03:13:51 +00:00
|
|
|
};
|
2018-01-22 23:19:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
macro_rules! subcommands_mut {
|
|
|
|
($app:expr) => {
|
|
|
|
subcommands!($app, iter_mut)
|
2018-07-24 16:48:24 +00:00
|
|
|
};
|
2018-07-19 12:50:47 +00:00
|
|
|
}
|
|
|
|
|
2018-07-25 18:46:28 +00:00
|
|
|
macro_rules! groups_for_arg {
|
|
|
|
($app:expr, $grp:expr) => {{
|
|
|
|
debugln!("Parser::groups_for_arg: name={}", $grp);
|
|
|
|
$app.groups
|
|
|
|
.iter()
|
2019-04-05 02:06:23 +00:00
|
|
|
.filter(|grp| grp.args.iter().any(|&a| a == $grp))
|
|
|
|
.map(|grp| grp.id)
|
2018-08-02 03:13:51 +00:00
|
|
|
}};
|
2018-01-22 23:19:53 +00:00
|
|
|
}
|
|
|
|
|
2018-01-24 17:00:58 +00:00
|
|
|
macro_rules! find_subcmd_cloned {
|
2017-02-21 04:51:20 +00:00
|
|
|
($_self:expr, $sc:expr) => {{
|
2018-11-14 17:05:06 +00:00
|
|
|
subcommands_cloned!($_self).find(|a| match_alias!(a, $sc, &*a.name))
|
2018-01-24 17:00:58 +00:00
|
|
|
}};
|
|
|
|
}
|
|
|
|
|
|
|
|
macro_rules! find_subcmd {
|
|
|
|
($app:expr, $sc:expr) => {{
|
2018-11-14 17:05:06 +00:00
|
|
|
subcommands!($app).find(|a| match_alias!(a, $sc, &*a.name))
|
2017-02-21 04:51:20 +00:00
|
|
|
}};
|
|
|
|
}
|
|
|
|
|
|
|
|
macro_rules! longs {
|
2018-07-24 16:48:24 +00:00
|
|
|
($app:expr) => {{
|
2019-04-05 19:49:32 +00:00
|
|
|
use crate::mkeymap::KeyType;
|
2018-11-14 00:44:43 +00:00
|
|
|
$app.args.keys.iter().map(|x| &x.key).filter_map(|a| {
|
2018-07-24 16:48:24 +00:00
|
|
|
if let KeyType::Long(v) = a {
|
|
|
|
Some(v)
|
|
|
|
} else {
|
|
|
|
None
|
|
|
|
}
|
|
|
|
})
|
|
|
|
}};
|
2017-02-21 04:51:20 +00:00
|
|
|
}
|
|
|
|
|
2017-03-02 15:58:06 +00:00
|
|
|
macro_rules! _names {
|
2018-01-22 23:19:53 +00:00
|
|
|
(@args $app:expr) => {{
|
2018-11-14 00:44:43 +00:00
|
|
|
$app.args.args.iter().map(|a| &*a.name)
|
2017-02-21 04:51:20 +00:00
|
|
|
}};
|
2018-01-22 23:19:53 +00:00
|
|
|
(@sc $app:expr) => {{
|
2018-07-24 16:48:24 +00:00
|
|
|
$app.subcommands.iter().map(|s| &*s.name).chain(
|
|
|
|
$app.subcommands
|
|
|
|
.iter()
|
|
|
|
.filter(|s| s.aliases.is_some())
|
|
|
|
.flat_map(|s| s.aliases.as_ref().unwrap().iter().map(|&(n, _)| n)),
|
|
|
|
)
|
|
|
|
}};
|
2017-02-21 04:51:20 +00:00
|
|
|
}
|
2018-01-22 23:19:53 +00:00
|
|
|
|
|
|
|
macro_rules! sc_names {
|
|
|
|
($app:expr) => {{
|
|
|
|
_names!(@sc $app)
|
|
|
|
}};
|
2018-01-24 17:00:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
macro_rules! match_alias {
|
|
|
|
($a:expr, $to:expr, $what:expr) => {{
|
2018-08-02 03:13:51 +00:00
|
|
|
$what == $to
|
|
|
|
|| ($a.aliases.is_some()
|
|
|
|
&& $a
|
|
|
|
.aliases
|
|
|
|
.as_ref()
|
|
|
|
.unwrap()
|
|
|
|
.iter()
|
|
|
|
.any(|alias| alias.0 == $to))
|
|
|
|
}};
|
2018-01-25 04:05:05 +00:00
|
|
|
}
|