2015-07-09 23:35:28 +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();
|
|
|
|
})
|
|
|
|
);
|
|
|
|
macro_rules! werr(
|
|
|
|
($($arg:tt)*) => ({
|
|
|
|
use std::io::{Write, stderr};
|
|
|
|
write!(&mut stderr(), $($arg)*).ok();
|
|
|
|
})
|
|
|
|
);
|
|
|
|
|
|
|
|
#[cfg(feature = "debug")]
|
|
|
|
macro_rules! debugln {
|
|
|
|
($fmt:expr) => (println!(concat!("**DEBUG** ", $fmt)));
|
|
|
|
($fmt:expr, $($arg:tt)*) => (println!(concat!("**DEBUG** ",$fmt), $($arg)*));
|
|
|
|
}
|
|
|
|
|
|
|
|
#[cfg(feature = "debug")]
|
|
|
|
macro_rules! debug {
|
|
|
|
($fmt:expr) => (print!(concat!("**DEBUG** ", $fmt)));
|
|
|
|
($fmt:expr, $($arg:tt)*) => (println!(concat!("**DEBUG** ",$fmt), $($arg)*));
|
|
|
|
}
|
|
|
|
|
|
|
|
#[cfg(not(feature = "debug"))]
|
|
|
|
macro_rules! debugln {
|
|
|
|
($fmt:expr) => ();
|
|
|
|
($fmt:expr, $($arg:tt)*) => ();
|
|
|
|
}
|
|
|
|
|
|
|
|
#[cfg(not(feature = "debug"))]
|
|
|
|
macro_rules! debug {
|
|
|
|
($fmt:expr) => ();
|
|
|
|
($fmt:expr, $($arg:tt)*) => ();
|
|
|
|
}
|
|
|
|
|
2015-08-31 03:26:17 +00:00
|
|
|
#[cfg(feature = "yaml")]
|
|
|
|
#[macro_export]
|
|
|
|
macro_rules! load_yaml {
|
|
|
|
($yml:expr) => (
|
|
|
|
&::clap::YamlLoader::load_from_str(include_str!($yml)).ok().expect("failed to load YAML file")[0]
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2015-10-06 00:36:30 +00:00
|
|
|
macro_rules! write_spaces {
|
|
|
|
($num:expr, $w:ident) => ({
|
2015-10-28 13:57:47 +00:00
|
|
|
for _ in 0..$num {
|
2015-10-06 00:36:30 +00:00
|
|
|
try!(write!($w, " "));
|
|
|
|
}
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
2015-11-01 14:02:37 +00:00
|
|
|
// convenience macro for remove an item from a vec
|
2015-08-18 23:39:02 +00:00
|
|
|
macro_rules! vec_remove {
|
|
|
|
($vec:expr, $to_rem:ident) => {
|
|
|
|
{
|
|
|
|
let mut ix = None;
|
2015-10-28 08:54:24 +00:00
|
|
|
$vec.dedup();
|
2015-08-18 23:39:02 +00:00
|
|
|
for (i, val) in $vec.iter().enumerate() {
|
2015-11-08 06:50:12 +00:00
|
|
|
if &val == &$to_rem {
|
2015-08-18 23:39:02 +00:00
|
|
|
ix = Some(i);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if let Some(i) = ix {
|
|
|
|
$vec.remove(i);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-10-28 08:54:24 +00:00
|
|
|
macro_rules! remove_overriden {
|
2015-08-19 03:59:04 +00:00
|
|
|
($me:ident, $name:expr) => ({
|
2015-11-08 07:21:36 +00:00
|
|
|
if let Some(ref o) = $me.opts.iter().filter(|o| &o.name == $name).next() {
|
2015-08-19 03:59:04 +00:00
|
|
|
if let Some(ref ora) = o.requires {
|
|
|
|
for a in ora {
|
|
|
|
vec_remove!($me.required, a);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if let Some(ref ora) = o.blacklist {
|
|
|
|
for a in ora {
|
|
|
|
vec_remove!($me.blacklist, a);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if let Some(ref ora) = o.overrides {
|
|
|
|
for a in ora {
|
|
|
|
vec_remove!($me.overrides, a);
|
|
|
|
}
|
|
|
|
}
|
2015-11-08 06:50:12 +00:00
|
|
|
} else if let Some(ref o) = $me.flags.iter().filter(|f| &f.name == $name).next() {
|
2015-08-19 03:59:04 +00:00
|
|
|
if let Some(ref ora) = o.requires {
|
|
|
|
for a in ora {
|
|
|
|
vec_remove!($me.required, a);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if let Some(ref ora) = o.blacklist {
|
|
|
|
for a in ora {
|
|
|
|
vec_remove!($me.blacklist, a);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if let Some(ref ora) = o.overrides {
|
|
|
|
for a in ora {
|
|
|
|
vec_remove!($me.overrides, a);
|
|
|
|
}
|
|
|
|
}
|
2015-11-08 05:58:44 +00:00
|
|
|
} else if let Some(p) = $me.positionals.values().filter(|p| &&p.name == &$name).next() {
|
|
|
|
if let Some(ref ora) = p.requires {
|
|
|
|
for a in ora {
|
|
|
|
vec_remove!($me.required, a);
|
2015-08-19 03:59:04 +00:00
|
|
|
}
|
2015-11-08 05:58:44 +00:00
|
|
|
}
|
|
|
|
if let Some(ref ora) = p.blacklist {
|
|
|
|
for a in ora {
|
|
|
|
vec_remove!($me.blacklist, a);
|
2015-08-19 03:59:04 +00:00
|
|
|
}
|
2015-11-08 05:58:44 +00:00
|
|
|
}
|
|
|
|
if let Some(ref ora) = p.overrides {
|
|
|
|
for a in ora {
|
|
|
|
vec_remove!($me.overrides, a);
|
2015-08-19 03:59:04 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
2015-04-14 02:18:50 +00:00
|
|
|
// De-duplication macro used in src/app.rs
|
2015-07-16 04:26:59 +00:00
|
|
|
macro_rules! print_opt_help {
|
2015-10-06 00:36:30 +00:00
|
|
|
($opt:ident, $spc:expr, $w:ident) => {
|
2015-05-01 18:38:27 +00:00
|
|
|
if let Some(h) = $opt.help {
|
2015-07-16 05:24:00 +00:00
|
|
|
if h.contains("{n}") {
|
|
|
|
let mut hel = h.split("{n}");
|
2015-07-17 02:16:50 +00:00
|
|
|
if let Some(part) = hel.next() {
|
2015-09-09 02:38:07 +00:00
|
|
|
try!(write!($w, "{}", part));
|
2015-07-17 02:16:50 +00:00
|
|
|
}
|
2015-11-07 05:08:15 +00:00
|
|
|
for part in hel {
|
2015-09-09 02:38:07 +00:00
|
|
|
try!(write!($w, "\n"));
|
2015-10-06 00:36:30 +00:00
|
|
|
write_spaces!($spc, $w);
|
2015-09-09 02:38:07 +00:00
|
|
|
try!(write!($w, "{}", part));
|
2015-07-16 05:24:00 +00:00
|
|
|
}
|
|
|
|
} else {
|
2015-09-09 02:38:07 +00:00
|
|
|
try!(write!($w, "{}", h));
|
2015-07-16 05:24:00 +00:00
|
|
|
}
|
2015-07-16 04:26:59 +00:00
|
|
|
if let Some(ref pv) = $opt.possible_vals {
|
2015-09-09 02:38:07 +00:00
|
|
|
try!(write!($w, " [values:"));
|
2015-07-16 04:26:59 +00:00
|
|
|
for pv_s in pv.iter() {
|
2015-09-09 02:38:07 +00:00
|
|
|
try!(write!($w, " {}", pv_s));
|
2015-07-16 04:26:59 +00:00
|
|
|
}
|
2015-09-09 02:38:07 +00:00
|
|
|
try!(write!($w, "]"));
|
2015-07-16 04:26:59 +00:00
|
|
|
}
|
2015-08-14 04:04:02 +00:00
|
|
|
}
|
2015-05-01 18:38:27 +00:00
|
|
|
};
|
2015-04-13 04:37:59 +00:00
|
|
|
}
|
|
|
|
|
2015-04-27 02:03:11 +00:00
|
|
|
// De-duplication macro used in src/app.rs
|
|
|
|
macro_rules! parse_group_reqs {
|
2015-05-01 18:38:27 +00:00
|
|
|
($me:ident, $arg:ident) => {
|
|
|
|
for ag in $me.groups.values() {
|
|
|
|
let mut found = false;
|
|
|
|
for name in ag.args.iter() {
|
|
|
|
if name == &$arg.name {
|
2015-10-28 08:54:24 +00:00
|
|
|
vec_remove!($me.required, name);
|
2015-05-01 18:38:27 +00:00
|
|
|
if let Some(ref reqs) = ag.requires {
|
|
|
|
for r in reqs {
|
2015-08-18 23:39:02 +00:00
|
|
|
$me.required.push(r);
|
2015-05-01 18:38:27 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if let Some(ref bl) = ag.conflicts {
|
|
|
|
for b in bl {
|
2015-08-18 23:39:02 +00:00
|
|
|
$me.blacklist.push(b);
|
2015-05-01 18:38:27 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
found = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if found {
|
|
|
|
for name in ag.args.iter() {
|
|
|
|
if name == &$arg.name { continue }
|
2015-10-28 08:54:24 +00:00
|
|
|
vec_remove!($me.required, name);
|
2015-08-18 23:39:02 +00:00
|
|
|
|
|
|
|
$me.blacklist.push(name);
|
2015-05-01 18:38:27 +00:00
|
|
|
}
|
2015-05-01 18:44:20 +00:00
|
|
|
}
|
2015-05-01 18:38:27 +00:00
|
|
|
}
|
2015-04-27 02:03:11 +00:00
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2015-04-13 04:37:59 +00:00
|
|
|
// Thanks to bluss and flan3002 in #rust IRC
|
2015-04-14 02:18:50 +00:00
|
|
|
//
|
2015-10-28 14:23:59 +00:00
|
|
|
// Helps with rightward drift when iterating over something and matching each
|
|
|
|
// item.
|
2015-04-13 04:37:59 +00:00
|
|
|
macro_rules! for_match {
|
2015-05-01 18:38:27 +00:00
|
|
|
($it:ident, $($p:pat => $($e:expr);+),*) => {
|
|
|
|
for i in $it {
|
|
|
|
match i {
|
|
|
|
$(
|
|
|
|
$p => { $($e)+ }
|
|
|
|
)*
|
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
2015-04-14 16:06:15 +00:00
|
|
|
}
|
|
|
|
|
2015-04-16 16:53:05 +00:00
|
|
|
/// Convenience macro getting a typed value `T` where `T` implements `std::str::FromStr`
|
2015-04-14 19:02:50 +00:00
|
|
|
/// 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
|
2015-05-01 18:44:20 +00:00
|
|
|
/// and those where the argument wasn't present (such as a non-required argument).
|
2015-04-14 19:02:50 +00:00
|
|
|
///
|
|
|
|
/// You can use it to get a single value, or a `Vec<T>` with the `values_of()`
|
2015-05-01 18:44:20 +00:00
|
|
|
///
|
2015-04-14 19:02:50 +00:00
|
|
|
/// **NOTE:** Be cautious, as since this a macro invocation it's not exactly like
|
|
|
|
/// standard syntax.
|
|
|
|
///
|
|
|
|
///
|
2015-09-22 02:06:15 +00:00
|
|
|
/// # Examples single value
|
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")
|
2015-04-14 20:10:47 +00:00
|
|
|
/// .arg_from_usage("[length] 'Set the length to use as a pos whole num, i.e. 20'")
|
2015-05-01 18:38:27 +00:00
|
|
|
/// .get_matches();
|
2015-04-14 20:10:47 +00:00
|
|
|
/// let len = value_t!(matches.value_of("length"), u32)
|
2015-05-01 18:38:27 +00:00
|
|
|
/// .unwrap_or_else(|e|{
|
2015-05-01 18:44:20 +00:00
|
|
|
/// println!("{}",e);
|
2015-05-01 18:38:27 +00:00
|
|
|
/// std::process::exit(1)
|
|
|
|
/// });
|
2015-04-14 19:02:50 +00:00
|
|
|
///
|
|
|
|
/// println!("{} + 2: {}", len, len + 2);
|
|
|
|
/// # }
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
///
|
2015-09-22 02:06:15 +00:00
|
|
|
/// # Examples multiple values
|
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")
|
2015-04-14 20:10:47 +00:00
|
|
|
/// .arg_from_usage("[seq]... 'A sequence of pos whole nums, i.e. 20 45'")
|
2015-05-01 18:38:27 +00:00
|
|
|
/// .get_matches();
|
2015-04-14 20:10:47 +00:00
|
|
|
/// for v in value_t!(matches.values_of("seq"), u32)
|
2015-05-01 18:38:27 +00:00
|
|
|
/// .unwrap_or_else(|e|{
|
2015-05-01 18:44:20 +00:00
|
|
|
/// println!("{}",e);
|
2015-05-01 18:38:27 +00:00
|
|
|
/// std::process::exit(1)
|
|
|
|
/// }) {
|
|
|
|
/// println!("{} + 2: {}", v, v + 2);
|
|
|
|
/// }
|
2015-04-14 19:02:50 +00:00
|
|
|
/// # }
|
|
|
|
/// ```
|
2015-04-14 16:06:15 +00:00
|
|
|
#[macro_export]
|
|
|
|
macro_rules! value_t {
|
2015-05-01 18:38:27 +00:00
|
|
|
($m:ident.value_of($v:expr), $t:ty) => {
|
|
|
|
match $m.value_of($v) {
|
|
|
|
Some(v) => {
|
|
|
|
match v.parse::<$t>() {
|
|
|
|
Ok(val) => Ok(val),
|
2015-05-22 22:17:57 +00:00
|
|
|
Err(_) => Err(format!("'{}' isn't a valid value", ::clap::Format::Warning(v))),
|
2015-05-01 18:38:27 +00:00
|
|
|
}
|
|
|
|
},
|
2015-05-22 22:17:57 +00:00
|
|
|
None => Err(format!("The argument '{}' not found", ::clap::Format::Warning($v)))
|
2015-05-01 18:38:27 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
($m:ident.values_of($v:expr), $t:ty) => {
|
|
|
|
match $m.values_of($v) {
|
|
|
|
Some(ref v) => {
|
|
|
|
let mut tmp = Vec::with_capacity(v.len());
|
|
|
|
let mut err = None;
|
|
|
|
for pv in v {
|
|
|
|
match pv.parse::<$t>() {
|
|
|
|
Ok(rv) => tmp.push(rv),
|
|
|
|
Err(e) => {
|
2015-05-22 22:17:57 +00:00
|
|
|
err = Some(format!("'{}' isn't a valid value\n\t{}", ::clap::Format::Warning(pv),e));
|
2015-05-01 18:38:27 +00:00
|
|
|
break
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
match err {
|
|
|
|
Some(e) => Err(e),
|
|
|
|
None => Ok(tmp)
|
|
|
|
}
|
|
|
|
},
|
2015-05-22 22:17:57 +00:00
|
|
|
None => Err(format!("The argument '{}' was not found", ::clap::Format::Warning($v)))
|
2015-05-01 18:38:27 +00:00
|
|
|
}
|
|
|
|
};
|
2015-04-14 16:30:53 +00:00
|
|
|
}
|
|
|
|
|
2015-04-16 16:53:05 +00:00
|
|
|
/// Convenience macro getting a typed value `T` where `T` implements `std::str::FromStr`
|
2015-04-14 19:02:50 +00:00
|
|
|
/// This macro returns a `T` or `Vec<T>` or exits with a usage string upon failure. This
|
2015-05-01 18:44:20 +00:00
|
|
|
/// removes some of the boiler plate to handle failures from value_t! above.
|
2015-04-14 19:02:50 +00:00
|
|
|
///
|
|
|
|
/// You can use it to get a single value `T`, or a `Vec<T>` with the `values_of()`
|
2015-05-01 18:44:20 +00:00
|
|
|
///
|
2015-04-14 19:02:50 +00:00
|
|
|
/// **NOTE:** This should only be used on required arguments, as it can be confusing to the user
|
2015-11-01 14:02:37 +00:00
|
|
|
/// why they are getting error messages when it appears they're entering all required arguments.
|
2015-04-14 19:02:50 +00:00
|
|
|
///
|
|
|
|
/// **NOTE:** Be cautious, as since this a macro invocation it's not exactly like
|
|
|
|
/// standard syntax.
|
|
|
|
///
|
|
|
|
///
|
2015-09-22 02:06:15 +00:00
|
|
|
/// # Examples single value
|
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")
|
2015-04-14 20:10:47 +00:00
|
|
|
/// .arg_from_usage("[length] 'Set the length to use as a pos whole num, i.e. 20'")
|
2015-05-01 18:38:27 +00:00
|
|
|
/// .get_matches();
|
2015-04-14 19:02:50 +00:00
|
|
|
/// let len = value_t_or_exit!(matches.value_of("length"), u32);
|
|
|
|
///
|
|
|
|
/// println!("{} + 2: {}", len, len + 2);
|
|
|
|
/// # }
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
///
|
2015-09-22 02:06:15 +00:00
|
|
|
/// # Examples multiple values
|
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")
|
2015-04-14 20:10:47 +00:00
|
|
|
/// .arg_from_usage("[seq]... 'A sequence of pos whole nums, i.e. 20 45'")
|
2015-05-01 18:38:27 +00:00
|
|
|
/// .get_matches();
|
2015-04-14 19:02:50 +00:00
|
|
|
/// for v in value_t_or_exit!(matches.values_of("seq"), u32) {
|
2015-05-01 18:38:27 +00:00
|
|
|
/// println!("{} + 2: {}", v, v + 2);
|
|
|
|
/// }
|
2015-04-14 19:02:50 +00:00
|
|
|
/// # }
|
|
|
|
/// ```
|
2015-04-14 16:30:53 +00:00
|
|
|
#[macro_export]
|
|
|
|
macro_rules! value_t_or_exit {
|
2015-05-01 18:38:27 +00:00
|
|
|
($m:ident.value_of($v:expr), $t:ty) => {
|
|
|
|
match $m.value_of($v) {
|
|
|
|
Some(v) => {
|
|
|
|
match v.parse::<$t>() {
|
|
|
|
Ok(val) => val,
|
2015-07-20 01:51:51 +00:00
|
|
|
Err(..) => {
|
|
|
|
println!("{} '{}' isn't a valid value\n\n{}\n\nPlease re-run with {} for \
|
2015-05-01 18:38:27 +00:00
|
|
|
more information",
|
2015-05-22 22:17:57 +00:00
|
|
|
::clap::Format::Error("error:"),
|
|
|
|
::clap::Format::Warning(v.to_string()),
|
|
|
|
$m.usage(),
|
|
|
|
::clap::Format::Good("--help"));
|
2015-05-01 18:38:27 +00:00
|
|
|
::std::process::exit(1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
},
|
|
|
|
None => {
|
2015-05-22 22:17:57 +00:00
|
|
|
println!("{} The argument '{}' was not found or is not valid\n\n{}\n\nPlease re-run with \
|
|
|
|
{} for more information",
|
|
|
|
::clap::Format::Error("error:"),
|
|
|
|
::clap::Format::Warning($v.to_string()),
|
|
|
|
$m.usage(),
|
|
|
|
::clap::Format::Good("--help"));
|
2015-05-01 18:38:27 +00:00
|
|
|
::std::process::exit(1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
($m:ident.values_of($v:expr), $t:ty) => {
|
|
|
|
match $m.values_of($v) {
|
|
|
|
Some(ref v) => {
|
|
|
|
let mut tmp = Vec::with_capacity(v.len());
|
|
|
|
for pv in v {
|
|
|
|
match pv.parse::<$t>() {
|
|
|
|
Ok(rv) => tmp.push(rv),
|
|
|
|
Err(_) => {
|
2015-07-20 01:51:51 +00:00
|
|
|
println!("{} '{}' isn't a valid value\n\n{}\n\nPlease re-run with {} for more \
|
2015-05-01 18:38:27 +00:00
|
|
|
information",
|
2015-05-22 22:17:57 +00:00
|
|
|
::clap::Format::Error("error:"),
|
|
|
|
::clap::Format::Warning(pv),
|
|
|
|
$m.usage(),
|
|
|
|
::clap::Format::Good("--help"));
|
2015-05-01 18:38:27 +00:00
|
|
|
::std::process::exit(1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
tmp
|
|
|
|
},
|
|
|
|
None => {
|
2015-05-22 22:17:57 +00:00
|
|
|
println!("{} The argument '{}' not found or is not valid\n\n{}\n\nPlease re-run with \
|
|
|
|
{} for more information",
|
|
|
|
::clap::Format::Error("error:"),
|
|
|
|
::clap::Format::Warning($v.to_string()),
|
|
|
|
$m.usage(),
|
|
|
|
::clap::Format::Good("--help"));
|
2015-05-01 18:38:27 +00:00
|
|
|
::std::process::exit(1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
2015-04-16 16:53:05 +00:00
|
|
|
}
|
2015-04-16 17:41:20 +00:00
|
|
|
|
|
|
|
/// Convenience macro generated a simple enum with variants to be used as a type when parsing
|
2015-05-15 20:41:39 +00:00
|
|
|
/// arguments. This enum also provides a `variants()` function which can be used to retrieve a
|
|
|
|
/// `Vec<&'static str>` of the variant names.
|
2015-04-16 17:41:20 +00:00
|
|
|
///
|
2015-11-01 14:02:37 +00:00
|
|
|
/// **NOTE:** This macro automatically implements std::str::FromStr and std::fmt::Display
|
2015-05-15 19:34:41 +00:00
|
|
|
///
|
2015-09-22 02:06:15 +00:00
|
|
|
/// # Examples
|
2015-04-16 17:41:20 +00:00
|
|
|
///
|
|
|
|
/// ```no_run
|
|
|
|
/// # #[macro_use]
|
|
|
|
/// # extern crate clap;
|
|
|
|
/// # use clap::{App, Arg};
|
|
|
|
/// simple_enum!{Foo => Bar, Baz, Qux}
|
|
|
|
/// // 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 enum_vals = ["Bar", "Baz", "Qux"];
|
|
|
|
/// let m = App::new("app")
|
|
|
|
/// .arg(Arg::from_usage("<foo> 'the foo'")
|
|
|
|
/// .possible_values(&enum_vals))
|
|
|
|
/// .get_matches();
|
|
|
|
/// let f = value_t_or_exit!(m.value_of("foo"), Foo);
|
2015-04-16 17:41:20 +00:00
|
|
|
///
|
2015-05-01 18:38:27 +00:00
|
|
|
/// // Use f like any other Foo variant...
|
2015-04-16 17:41:20 +00:00
|
|
|
/// }
|
|
|
|
/// ```
|
|
|
|
#[macro_export]
|
|
|
|
macro_rules! simple_enum {
|
2015-05-01 18:38:27 +00:00
|
|
|
($e:ident => $($v:ident),+) => {
|
|
|
|
enum $e {
|
|
|
|
$($v),+
|
|
|
|
}
|
2015-04-16 17:41:20 +00:00
|
|
|
|
2015-05-01 18:38:27 +00:00
|
|
|
impl ::std::str::FromStr for $e {
|
2015-05-01 18:44:20 +00:00
|
|
|
type Err = String;
|
2015-04-16 17:41:20 +00:00
|
|
|
|
2015-05-01 18:38:27 +00:00
|
|
|
fn from_str(s: &str) -> Result<Self,Self::Err> {
|
|
|
|
match s {
|
|
|
|
$(stringify!($v) => Ok($e::$v),)+
|
|
|
|
_ => Err({
|
|
|
|
let v = vec![
|
|
|
|
$(stringify!($v),)+
|
|
|
|
];
|
2015-07-20 02:03:59 +00:00
|
|
|
format!("valid values:{}",
|
2015-05-01 18:38:27 +00:00
|
|
|
v.iter().fold(String::new(), |a, i| {
|
|
|
|
a + &format!(" {}", i)[..]
|
|
|
|
}))
|
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
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)]
|
2015-05-15 20:41:39 +00:00
|
|
|
pub fn variants() -> Vec<&'static str> {
|
|
|
|
vec![
|
|
|
|
$(stringify!($v),)+
|
|
|
|
]
|
|
|
|
}
|
|
|
|
}
|
2015-05-01 18:38:27 +00:00
|
|
|
};
|
2015-04-17 14:20:56 +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
|
2015-05-15 20:41:39 +00:00
|
|
|
/// parsing arguments. This enum also provides a `variants()` function which can be used to retrieve a
|
|
|
|
/// `Vec<&'static str>` of the variant names.
|
2015-04-17 14:20:56 +00:00
|
|
|
///
|
2015-05-05 16:33:02 +00:00
|
|
|
/// **NOTE:** Case insensitivity is supported for ASCII characters
|
|
|
|
///
|
2015-11-01 14:02:37 +00:00
|
|
|
/// **NOTE:** This macro automatically implements std::str::FromStr and std::fmt::Display
|
2015-05-15 19:34:41 +00:00
|
|
|
///
|
2015-04-17 14:20:56 +00:00
|
|
|
/// These enums support pub (or not) and use of the #[derive()] traits
|
|
|
|
///
|
|
|
|
///
|
2015-09-22 02:06:15 +00:00
|
|
|
/// # Examples
|
2015-04-17 14:20:56 +00:00
|
|
|
///
|
|
|
|
/// ```no_run
|
|
|
|
/// # #[macro_use]
|
|
|
|
/// # extern crate clap;
|
|
|
|
/// # use clap::{App, Arg};
|
|
|
|
/// arg_enum!{
|
2015-05-01 18:38:27 +00:00
|
|
|
/// #[derive(Debug)]
|
|
|
|
/// 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")
|
|
|
|
/// .arg_from_usage("<foo> 'the foo'")
|
|
|
|
/// .get_matches();
|
|
|
|
/// let f = value_t_or_exit!(m.value_of("foo"), Foo);
|
2015-04-17 14:20:56 +00:00
|
|
|
///
|
2015-05-01 18:38:27 +00:00
|
|
|
/// // Use f like any other Foo variant...
|
2015-04-17 14:20:56 +00:00
|
|
|
/// }
|
|
|
|
/// ```
|
|
|
|
#[macro_export]
|
|
|
|
macro_rules! arg_enum {
|
2015-05-01 18:38:27 +00:00
|
|
|
(enum $e:ident { $($v:ident),+ } ) => {
|
|
|
|
enum $e {
|
|
|
|
$($v),+
|
|
|
|
}
|
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
|
|
|
|
2015-05-01 18:38:27 +00:00
|
|
|
fn from_str(s: &str) -> Result<Self,Self::Err> {
|
2015-05-05 16:33:02 +00:00
|
|
|
use ::std::ascii::AsciiExt;
|
2015-05-01 18:38:27 +00:00
|
|
|
match s {
|
2015-05-05 16:33:02 +00:00
|
|
|
$(stringify!($v) |
|
|
|
|
_ if s.eq_ignore_ascii_case(stringify!($v)) => Ok($e::$v),)+
|
2015-05-01 18:38:27 +00:00
|
|
|
_ => Err({
|
|
|
|
let v = vec![
|
|
|
|
$(stringify!($v),)+
|
|
|
|
];
|
2015-05-05 16:33:02 +00:00
|
|
|
format!("valid values:{}",
|
2015-05-01 18:38:27 +00:00
|
|
|
v.iter().fold(String::new(), |a, i| {
|
|
|
|
a + &format!(" {}", i)[..]
|
|
|
|
}))
|
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
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)]
|
2015-05-15 20:41:39 +00:00
|
|
|
fn variants() -> Vec<&'static str> {
|
|
|
|
vec![
|
|
|
|
$(stringify!($v),)+
|
|
|
|
]
|
|
|
|
}
|
|
|
|
}
|
2015-05-01 18:38:27 +00:00
|
|
|
};
|
|
|
|
(pub enum $e:ident { $($v:ident),+ } ) => {
|
|
|
|
pub enum $e {
|
|
|
|
$($v),+
|
|
|
|
}
|
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
|
|
|
|
2015-05-01 18:38:27 +00:00
|
|
|
fn from_str(s: &str) -> Result<Self,Self::Err> {
|
2015-05-05 08:33:27 +00:00
|
|
|
use ::std::ascii::AsciiExt;
|
2015-05-01 18:38:27 +00:00
|
|
|
match s {
|
2015-05-05 08:33:27 +00:00
|
|
|
$(stringify!($v) |
|
|
|
|
_ if s.eq_ignore_ascii_case(stringify!($v)) => Ok($e::$v),)+
|
2015-05-01 18:38:27 +00:00
|
|
|
_ => Err({
|
|
|
|
let v = vec![
|
|
|
|
$(stringify!($v),)+
|
|
|
|
];
|
2015-05-05 08:33:27 +00:00
|
|
|
format!("valid values:{}",
|
2015-05-01 18:38:27 +00:00
|
|
|
v.iter().fold(String::new(), |a, i| {
|
|
|
|
a + &format!(" {}", i)[..]
|
|
|
|
}))
|
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
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)]
|
2015-05-15 20:41:39 +00:00
|
|
|
pub fn variants() -> Vec<&'static str> {
|
|
|
|
vec![
|
|
|
|
$(stringify!($v),)+
|
|
|
|
]
|
|
|
|
}
|
|
|
|
}
|
2015-05-01 18:38:27 +00:00
|
|
|
};
|
|
|
|
(#[derive($($d:ident),+)] enum $e:ident { $($v:ident),+ } ) => {
|
|
|
|
#[derive($($d,)+)]
|
|
|
|
enum $e {
|
|
|
|
$($v),+
|
|
|
|
}
|
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
|
|
|
|
2015-05-01 18:38:27 +00:00
|
|
|
fn from_str(s: &str) -> Result<Self,Self::Err> {
|
2015-05-05 08:33:27 +00:00
|
|
|
use ::std::ascii::AsciiExt;
|
2015-05-01 18:38:27 +00:00
|
|
|
match s {
|
2015-05-05 08:33:27 +00:00
|
|
|
$(stringify!($v) |
|
|
|
|
_ if s.eq_ignore_ascii_case(stringify!($v)) => Ok($e::$v),)+
|
2015-05-01 18:38:27 +00:00
|
|
|
_ => Err({
|
|
|
|
let v = vec![
|
|
|
|
$(stringify!($v),)+
|
|
|
|
];
|
2015-05-05 08:33:27 +00:00
|
|
|
format!("valid values:{}",
|
2015-05-01 18:38:27 +00:00
|
|
|
v.iter().fold(String::new(), |a, i| {
|
|
|
|
a + &format!(" {}", i)[..]
|
|
|
|
}))
|
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
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)]
|
2015-05-15 20:41:39 +00:00
|
|
|
pub fn variants() -> Vec<&'static str> {
|
|
|
|
vec![
|
|
|
|
$(stringify!($v),)+
|
|
|
|
]
|
|
|
|
}
|
|
|
|
}
|
2015-05-01 18:38:27 +00:00
|
|
|
};
|
|
|
|
(#[derive($($d:ident),+)] pub enum $e:ident { $($v:ident),+ } ) => {
|
|
|
|
#[derive($($d,)+)]
|
|
|
|
pub enum $e {
|
|
|
|
$($v),+
|
|
|
|
}
|
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
|
|
|
|
2015-05-01 18:38:27 +00:00
|
|
|
fn from_str(s: &str) -> Result<Self,Self::Err> {
|
2015-05-05 08:33:27 +00:00
|
|
|
use ::std::ascii::AsciiExt;
|
2015-05-01 18:38:27 +00:00
|
|
|
match s {
|
2015-05-05 08:33:27 +00:00
|
|
|
$(stringify!($v) |
|
|
|
|
_ if s.eq_ignore_ascii_case(stringify!($v)) => Ok($e::$v),)+
|
2015-05-01 18:38:27 +00:00
|
|
|
_ => Err({
|
|
|
|
let v = vec![
|
|
|
|
$(stringify!($v),)+
|
|
|
|
];
|
2015-05-05 08:33:27 +00:00
|
|
|
format!("valid values:{}",
|
2015-05-01 18:38:27 +00:00
|
|
|
v.iter().fold(String::new(), |a, i| {
|
|
|
|
a + &format!(" {}", i)[..]
|
|
|
|
}))
|
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
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)]
|
2015-05-15 20:41:39 +00:00
|
|
|
pub fn variants() -> Vec<&'static str> {
|
|
|
|
vec![
|
|
|
|
$(stringify!($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
|
|
|
|
|
|
|
/// Allows you pull the version for an from your Cargo.toml as MAJOR.MINOR.PATCH_PKGVERSION_PRE
|
|
|
|
///
|
2015-09-22 02:06:15 +00:00
|
|
|
/// # Examples
|
2015-04-19 18:06:08 +00:00
|
|
|
/// ```no_run
|
|
|
|
/// # #[macro_use]
|
|
|
|
/// # extern crate clap;
|
|
|
|
/// # use clap::App;
|
|
|
|
/// # fn main() {
|
2015-05-01 18:38:27 +00:00
|
|
|
/// let m = App::new("app")
|
2015-05-01 18:50:28 +00:00
|
|
|
/// .version(&crate_version!()[..])
|
2015-05-01 18:38:27 +00:00
|
|
|
/// .get_matches();
|
2015-04-19 18:06:08 +00:00
|
|
|
/// # }
|
|
|
|
/// ```
|
|
|
|
#[macro_export]
|
|
|
|
macro_rules! crate_version {
|
2015-05-01 18:38:27 +00:00
|
|
|
() => {
|
2015-09-13 03:22:01 +00:00
|
|
|
env!("CARGO_PKG_VERSION").to_owned()
|
2015-05-01 18:38:27 +00:00
|
|
|
}
|
2015-04-19 18:06:08 +00:00
|
|
|
}
|
2015-09-08 12:53:31 +00:00
|
|
|
|
|
|
|
/// App, Arg, SubCommand and Group builder macro (Usage-string like input)
|
|
|
|
#[macro_export]
|
|
|
|
macro_rules! clap_app {
|
|
|
|
(@app ($builder:expr)) => { $builder };
|
|
|
|
(@app ($builder:expr) (@arg $name:ident: $($tail:tt)*) $($tt:tt)*) => {
|
|
|
|
clap_app!{ @app
|
|
|
|
($builder.arg(clap_app!{ @arg ($crate::Arg::with_name(stringify!($name))) (-) $($tail)* }))
|
|
|
|
$($tt)*
|
|
|
|
}
|
|
|
|
};
|
|
|
|
(@app ($builder:expr) (@setting $setting:ident) $($tt:tt)*) => {
|
|
|
|
clap_app!{ @app
|
|
|
|
($builder.setting($crate::AppSettings::$setting))
|
|
|
|
$($tt)*
|
|
|
|
}
|
|
|
|
};
|
|
|
|
// Treat the application builder as an argument to set it's attributes
|
|
|
|
(@app ($builder:expr) (@attributes $($attr:tt)*) $($tt:tt)*) => {
|
|
|
|
clap_app!{ @app (clap_app!{ @arg ($builder) $($attr)* }) $($tt)* }
|
|
|
|
};
|
|
|
|
(@app ($builder:expr) (@group $name:ident => $($tail:tt)*) $($tt:tt)*) => {
|
|
|
|
clap_app!{ @app
|
|
|
|
(clap_app!{ @group ($builder, $crate::ArgGroup::with_name(stringify!($name))) $($tail)* })
|
|
|
|
$($tt)*
|
|
|
|
}
|
|
|
|
};
|
|
|
|
// Handle subcommand creation
|
|
|
|
(@app ($builder:expr) (@subcommand $name:ident => $($tail:tt)*) $($tt:tt)*) => {
|
|
|
|
clap_app!{ @app
|
|
|
|
($builder.subcommand(
|
|
|
|
clap_app!{ @app ($crate::SubCommand::with_name(stringify!($name))) $($tail)* }
|
|
|
|
))
|
|
|
|
$($tt)*
|
|
|
|
}
|
|
|
|
};
|
2015-11-01 14:02:37 +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)*) => {
|
2015-09-09 04:00:17 +00:00
|
|
|
// clap_app!{ @app ($builder.$ident($($v),*)) $($tt)* }
|
|
|
|
clap_app!{ @app
|
|
|
|
($builder.$ident($($v),*))
|
|
|
|
$($tt)*
|
|
|
|
}
|
2015-09-08 12:53:31 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
// Add members to group and continue argument handling with the parent builder
|
|
|
|
(@group ($builder:expr, $group:expr)) => { $builder.arg_group($group) };
|
|
|
|
(@group ($builder:expr, $group:expr) (@attributes $($attr:tt)*) $($tt:tt)*) => {
|
|
|
|
clap_app!{ @group ($builder, clap_app!{ @arg ($group) (-) $($attr)* }) $($tt)* }
|
|
|
|
};
|
|
|
|
(@group ($builder:expr, $group:expr) (@arg $name:ident: $($tail:tt)*) $($tt:tt)*) => {
|
|
|
|
clap_app!{ @group
|
|
|
|
(clap_app!{ @app ($builder) (@arg $name: $($tail)*) },
|
|
|
|
$group.add(stringify!($name)))
|
|
|
|
$($tt)*
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
// No more tokens to munch
|
|
|
|
(@arg ($arg:expr) $modes:tt) => { $arg };
|
|
|
|
// Shorthand tokens influenced by the usage_string
|
|
|
|
(@arg ($arg:expr) $modes:tt --$long:ident $($tail:tt)*) => {
|
|
|
|
clap_app!{ @arg ($arg.long(stringify!($long))) $modes $($tail)* }
|
|
|
|
};
|
|
|
|
(@arg ($arg:expr) $modes:tt -$short:ident $($tail:tt)*) => {
|
|
|
|
clap_app!{ @arg ($arg.short(stringify!($short))) $modes $($tail)* }
|
|
|
|
};
|
|
|
|
(@arg ($arg:expr) (-) <$var:ident> $($tail:tt)*) => {
|
|
|
|
clap_app!{ @arg ($arg.value_name(stringify!($var))) (+) +takes_value +required $($tail)* }
|
|
|
|
};
|
|
|
|
(@arg ($arg:expr) (+) <$var:ident> $($tail:tt)*) => {
|
|
|
|
clap_app!{ @arg ($arg.value_name(stringify!($var))) (+) $($tail)* }
|
|
|
|
};
|
|
|
|
(@arg ($arg:expr) (-) [$var:ident] $($tail:tt)*) => {
|
2015-09-10 12:23:58 +00:00
|
|
|
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)*) => {
|
|
|
|
clap_app!{ @arg ($arg.value_name(stringify!($var))) (+) $($tail)* }
|
|
|
|
};
|
|
|
|
(@arg ($arg:expr) $modes:tt ... $($tail:tt)*) => {
|
|
|
|
clap_app!{ @arg ($arg) $modes +multiple $($tail)* }
|
|
|
|
};
|
|
|
|
// Shorthand magic
|
|
|
|
(@arg ($arg:expr) $modes:tt #{$n:expr, $m:expr} $($tail:tt)*) => {
|
|
|
|
clap_app!{ @arg ($arg) $modes min_values($n) max_values($m) $($tail)* }
|
|
|
|
};
|
|
|
|
(@arg ($arg:expr) $modes:tt * $($tail:tt)*) => {
|
|
|
|
clap_app!{ @arg ($arg) $modes +required $($tail)* }
|
|
|
|
};
|
|
|
|
// !foo -> .foo(false)
|
|
|
|
(@arg ($arg:expr) $modes:tt !$ident $($tail:tt)*) => {
|
|
|
|
clap_app!{ @arg ($arg.$ident(false)) $modes $($tail)* }
|
|
|
|
};
|
|
|
|
// foo -> .foo(true)
|
|
|
|
(@arg ($arg:expr) $modes:tt +$ident:ident $($tail:tt)*) => {
|
|
|
|
clap_app!{ @arg ($arg.$ident(true)) $modes $($tail)* }
|
|
|
|
};
|
|
|
|
// Validator
|
|
|
|
(@arg ($arg:expr) $modes:tt {$fn_:expr} $($tail:tt)*) => {
|
|
|
|
clap_app!{ @arg ($arg.validator($fn_)) $modes $($tail)* }
|
|
|
|
};
|
|
|
|
(@as_expr $expr:expr) => { $expr };
|
|
|
|
// Help
|
|
|
|
(@arg ($arg:expr) $modes:tt $desc:tt) => { $arg.help(clap_app!{ @as_expr $desc }) };
|
|
|
|
// Handle functions that need to be called multiple times for each argument
|
|
|
|
(@arg ($arg:expr) $modes:tt $ident:ident[$($target:ident)*] $($tail:tt)*) => {
|
|
|
|
clap_app!{ @arg ($arg $( .$ident(stringify!($target)) )*) $modes $($tail)* }
|
|
|
|
};
|
|
|
|
// Inherit builder's functions
|
|
|
|
(@arg ($arg:expr) $modes:tt $ident:ident($($expr:expr)*) $($tail:tt)*) => {
|
|
|
|
clap_app!{ @arg ($arg.$ident($($expr)*)) $modes $($tail)* }
|
|
|
|
};
|
|
|
|
|
|
|
|
// Build a subcommand outside of an app.
|
|
|
|
(@subcommand $name:ident => $($tail:tt)*) => {
|
|
|
|
clap_app!{ @app ($crate::SubCommand::with_name(stringify!($name))) $($tail)* }
|
|
|
|
};
|
|
|
|
// Start the magic
|
|
|
|
($name:ident => $($tail:tt)*) => {{
|
|
|
|
clap_app!{ @app ($crate::App::new(stringify!($name))) $($tail)*}
|
|
|
|
}};
|
|
|
|
}
|