2015-04-14 02:18:50 +00:00
|
|
|
// De-duplication macro used in src/app.rs
|
2015-04-10 15:40:08 +00:00
|
|
|
macro_rules! get_help {
|
|
|
|
($opt:ident) => {
|
|
|
|
if let Some(h) = $opt.help {
|
|
|
|
format!("{}{}", h,
|
|
|
|
if let Some(ref pv) = $opt.possible_vals {
|
|
|
|
let mut pv_s = pv.iter().fold(String::with_capacity(50), |acc, name| acc + &format!(" {}",name)[..]);
|
|
|
|
pv_s.shrink_to_fit();
|
|
|
|
format!(" [values:{}]", &pv_s[..])
|
|
|
|
}else{"".to_owned()})
|
|
|
|
} else {
|
|
|
|
" ".to_owned()
|
|
|
|
}
|
|
|
|
};
|
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 {
|
|
|
|
($me:ident, $arg:ident) => {
|
|
|
|
for ag in $me.groups.values() {
|
|
|
|
let mut found = false;
|
|
|
|
for name in ag.args.iter() {
|
|
|
|
if name == &$arg.name {
|
|
|
|
$me.required.remove(ag.name);
|
|
|
|
if let Some(ref reqs) = ag.requires {
|
|
|
|
for r in reqs {
|
|
|
|
$me.required.insert(r);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if let Some(ref bl) = ag.conflicts {
|
|
|
|
for b in bl {
|
|
|
|
$me.blacklist.insert(b);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
found = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if found {
|
|
|
|
for name in ag.args.iter() {
|
|
|
|
if name == &$arg.name { continue }
|
|
|
|
$me.required.remove(name);
|
|
|
|
$me.blacklist.insert(name);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2015-04-27 04:35:56 +00:00
|
|
|
// De-duplication macro used in src/app.rs
|
|
|
|
macro_rules! validate_reqs {
|
|
|
|
($me:ident, $t:ident, $m:ident, $n:ident) => {
|
|
|
|
if let Some(a) = $me.$t.get($n) {
|
|
|
|
if let Some(ref bl) = a.blacklist {
|
|
|
|
for n in bl.iter() {
|
|
|
|
if $m.args.contains_key(n) {
|
|
|
|
return false
|
|
|
|
} else if $me.groups.contains_key(n) {
|
|
|
|
let grp = $me.groups.get(n).unwrap();
|
|
|
|
for an in grp.args.iter() {
|
|
|
|
if $m.args.contains_key(an) {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2015-04-13 04:37:59 +00:00
|
|
|
// Thanks to bluss and flan3002 in #rust IRC
|
2015-04-14 02:18:50 +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 {
|
|
|
|
($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
|
|
|
|
/// and those where the argument wasn't present (such as a non-required argument).
|
|
|
|
///
|
|
|
|
/// You can use it to get a single value, or a `Vec<T>` with the `values_of()`
|
|
|
|
///
|
|
|
|
/// **NOTE:** Be cautious, as since this a macro invocation it's not exactly like
|
|
|
|
/// standard syntax.
|
|
|
|
///
|
|
|
|
///
|
|
|
|
/// # Example single value
|
|
|
|
///
|
|
|
|
/// ```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'")
|
|
|
|
/// .get_matches();
|
|
|
|
/// let len = value_t!(matches.value_of("length"), u32)
|
|
|
|
/// .unwrap_or_else(|e|{
|
|
|
|
/// println!("{}",e);
|
|
|
|
/// std::process::exit(1)
|
|
|
|
/// });
|
2015-04-14 19:02:50 +00:00
|
|
|
///
|
|
|
|
/// println!("{} + 2: {}", len, len + 2);
|
|
|
|
/// # }
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
///
|
|
|
|
/// # Example multiple values
|
|
|
|
///
|
|
|
|
/// ```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'")
|
|
|
|
/// .get_matches();
|
|
|
|
/// for v in value_t!(matches.values_of("seq"), u32)
|
|
|
|
/// .unwrap_or_else(|e|{
|
|
|
|
/// println!("{}",e);
|
|
|
|
/// std::process::exit(1)
|
|
|
|
/// }) {
|
2015-04-14 19:02:50 +00:00
|
|
|
/// println!("{} + 2: {}", v, v + 2);
|
|
|
|
/// }
|
|
|
|
/// # }
|
|
|
|
/// ```
|
2015-04-14 16:06:15 +00:00
|
|
|
#[macro_export]
|
|
|
|
macro_rules! value_t {
|
|
|
|
($m:ident.value_of($v:expr), $t:ty) => {
|
|
|
|
match $m.value_of($v) {
|
|
|
|
Some(v) => {
|
|
|
|
match v.parse::<$t>() {
|
|
|
|
Ok(val) => Ok(val),
|
|
|
|
Err(_) => Err(format!("{} isn't a valid {}",v,stringify!($t))),
|
|
|
|
}
|
|
|
|
},
|
2015-04-14 17:56:53 +00:00
|
|
|
None => Err(format!("Argument \"{}\" not found", $v))
|
|
|
|
}
|
|
|
|
};
|
|
|
|
($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),
|
2015-04-17 14:20:56 +00:00
|
|
|
Err(e) => {
|
|
|
|
err = Some(format!("{} isn't a valid {}\n{}",pv,stringify!($t),e));
|
2015-04-14 17:56:53 +00:00
|
|
|
break
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
match err {
|
|
|
|
Some(e) => Err(e),
|
|
|
|
None => Ok(tmp)
|
|
|
|
}
|
|
|
|
},
|
|
|
|
None => Err(format!("Argument \"{}\" not found", $v))
|
2015-04-14 16:06:15 +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
|
|
|
|
/// removes some of the boiler plate to handle failures from value_t! above.
|
|
|
|
///
|
|
|
|
/// You can use it to get a single value `T`, or a `Vec<T>` with the `values_of()`
|
|
|
|
///
|
|
|
|
/// **NOTE:** This should only be used on required arguments, as it can be confusing to the user
|
|
|
|
/// why they are getting error messages when it appears they're entering all required argumetns.
|
|
|
|
///
|
|
|
|
/// **NOTE:** Be cautious, as since this a macro invocation it's not exactly like
|
|
|
|
/// standard syntax.
|
|
|
|
///
|
|
|
|
///
|
|
|
|
/// # Example single value
|
|
|
|
///
|
|
|
|
/// ```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'")
|
|
|
|
/// .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);
|
|
|
|
/// # }
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
///
|
|
|
|
/// # Example multiple values
|
|
|
|
///
|
|
|
|
/// ```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-04-14 19:02:50 +00:00
|
|
|
/// .get_matches();
|
|
|
|
/// for v in value_t_or_exit!(matches.values_of("seq"), u32) {
|
|
|
|
/// println!("{} + 2: {}", v, v + 2);
|
|
|
|
/// }
|
|
|
|
/// # }
|
|
|
|
/// ```
|
2015-04-14 16:30:53 +00:00
|
|
|
#[macro_export]
|
|
|
|
macro_rules! value_t_or_exit {
|
|
|
|
($m:ident.value_of($v:expr), $t:ty) => {
|
|
|
|
match $m.value_of($v) {
|
|
|
|
Some(v) => {
|
|
|
|
match v.parse::<$t>() {
|
|
|
|
Ok(val) => val,
|
2015-04-17 14:20:56 +00:00
|
|
|
Err(e) => {
|
|
|
|
println!("{} isn't a valid {}\n{}\n{}\nPlease re-run with --help for more information",
|
2015-04-14 20:10:47 +00:00
|
|
|
v,
|
|
|
|
stringify!($t),
|
2015-04-17 14:20:56 +00:00
|
|
|
e,
|
2015-04-14 20:10:47 +00:00
|
|
|
$m.usage());
|
2015-04-14 16:30:53 +00:00
|
|
|
::std::process::exit(1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
},
|
|
|
|
None => {
|
2015-04-14 20:10:47 +00:00
|
|
|
println!("Argument \"{}\" not found or is not valid\n{}\nPlease re-run with --help for more information",
|
|
|
|
$v,
|
|
|
|
$m.usage());
|
2015-04-14 16:30:53 +00:00
|
|
|
::std::process::exit(1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
2015-04-14 18:11:29 +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());
|
|
|
|
for pv in v {
|
|
|
|
match pv.parse::<$t>() {
|
|
|
|
Ok(rv) => tmp.push(rv),
|
|
|
|
Err(_) => {
|
2015-04-14 20:10:47 +00:00
|
|
|
println!("{} isn't a valid {}\n{}\nPlease re-run with --help for more information",
|
|
|
|
pv,
|
|
|
|
stringify!($t),
|
|
|
|
$m.usage());
|
2015-04-14 18:11:29 +00:00
|
|
|
::std::process::exit(1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
tmp
|
|
|
|
},
|
|
|
|
None => {
|
2015-04-14 20:10:47 +00:00
|
|
|
println!("Argument \"{}\" not found or is not valid\n{}\nPlease re-run with --help for more information",
|
|
|
|
$v,
|
|
|
|
$m.usage());
|
2015-04-14 18:11:29 +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
|
|
|
|
/// arguments.
|
|
|
|
///
|
|
|
|
/// # Example
|
|
|
|
///
|
|
|
|
/// ```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-04-29 17:32:00 +00:00
|
|
|
/// let enum_vals = ["Bar", "Baz", "Qux"];
|
2015-04-16 17:41:20 +00:00
|
|
|
/// let m = App::new("app")
|
|
|
|
/// .arg(Arg::from_usage("<foo> 'the foo'")
|
2015-04-29 17:32:00 +00:00
|
|
|
/// .possible_values(&enum_vals))
|
2015-04-16 17:41:20 +00:00
|
|
|
/// .get_matches();
|
|
|
|
/// let f = value_t_or_exit!(m.value_of("foo"), Foo);
|
|
|
|
///
|
|
|
|
/// // Use f like any other Foo variant...
|
|
|
|
/// }
|
|
|
|
/// ```
|
|
|
|
#[macro_export]
|
|
|
|
macro_rules! simple_enum {
|
|
|
|
($e:ident => $($v:ident),+) => {
|
|
|
|
enum $e {
|
|
|
|
$($v),+
|
|
|
|
}
|
|
|
|
|
2015-04-19 02:23:18 +00:00
|
|
|
impl ::std::str::FromStr for $e {
|
2015-04-17 14:20:56 +00:00
|
|
|
type Err = String;
|
2015-04-16 17:41:20 +00:00
|
|
|
|
2015-04-19 02:20:43 +00:00
|
|
|
fn from_str(s: &str) -> Result<Self,Self::Err> {
|
2015-04-16 17:41:20 +00:00
|
|
|
match s {
|
|
|
|
$(stringify!($v) => Ok($e::$v),)+
|
2015-04-17 14:20:56 +00:00
|
|
|
_ => Err({
|
|
|
|
let v = vec![
|
|
|
|
$(stringify!($v),)+
|
|
|
|
];
|
|
|
|
format!("valid:{}", v.iter().fold(String::new(),|a, i| a + &format!(" {}", i)[..]))
|
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Convenience macro to generate more complete enums with variants to be used as a type when parsing
|
|
|
|
/// arguments.
|
|
|
|
///
|
|
|
|
/// These enums support pub (or not) and use of the #[derive()] traits
|
|
|
|
///
|
|
|
|
///
|
|
|
|
/// # Example
|
|
|
|
///
|
|
|
|
/// ```no_run
|
|
|
|
/// # #[macro_use]
|
|
|
|
/// # extern crate clap;
|
|
|
|
/// # use clap::{App, Arg};
|
|
|
|
/// arg_enum!{
|
|
|
|
/// #[derive(Debug)]
|
|
|
|
/// pub 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() {
|
|
|
|
/// let m = App::new("app")
|
|
|
|
/// .arg_from_usage("<foo> 'the foo'")
|
|
|
|
/// .get_matches();
|
|
|
|
/// let f = value_t_or_exit!(m.value_of("foo"), Foo);
|
|
|
|
///
|
|
|
|
/// // Use f like any other Foo variant...
|
|
|
|
/// }
|
|
|
|
/// ```
|
|
|
|
#[macro_export]
|
|
|
|
macro_rules! arg_enum {
|
|
|
|
(enum $e:ident { $($v:ident),+ } ) => {
|
|
|
|
enum $e {
|
|
|
|
$($v),+
|
|
|
|
}
|
|
|
|
|
2015-04-19 02:23:18 +00:00
|
|
|
impl ::std::str::FromStr for $e {
|
2015-04-17 14:20:56 +00:00
|
|
|
type Err = String;
|
|
|
|
|
2015-04-19 02:20:43 +00:00
|
|
|
fn from_str(s: &str) -> Result<Self,Self::Err> {
|
2015-04-17 14:20:56 +00:00
|
|
|
match s {
|
|
|
|
$(stringify!($v) => Ok($e::$v),)+
|
|
|
|
_ => Err({
|
|
|
|
let v = vec![
|
|
|
|
$(stringify!($v),)+
|
|
|
|
];
|
|
|
|
format!("valid:{}", v.iter().fold(String::new(),|a, i| a + &format!(" {}", i)[..]))
|
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
(pub enum $e:ident { $($v:ident),+ } ) => {
|
|
|
|
pub enum $e {
|
|
|
|
$($v),+
|
|
|
|
}
|
|
|
|
|
2015-04-19 02:23:18 +00:00
|
|
|
impl ::std::str::FromStr for $e {
|
2015-04-17 14:20:56 +00:00
|
|
|
type Err = String;
|
|
|
|
|
2015-04-19 02:20:43 +00:00
|
|
|
fn from_str(s: &str) -> Result<Self,Self::Err> {
|
2015-04-17 14:20:56 +00:00
|
|
|
match s {
|
|
|
|
$(stringify!($v) => Ok($e::$v),)+
|
|
|
|
_ => Err({
|
|
|
|
let v = vec![
|
|
|
|
$(stringify!($v),)+
|
|
|
|
];
|
|
|
|
format!("valid:{}", v.iter().fold(String::new(),|a, i| a + &format!(" {}", i)[..]))
|
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
(#[derive($($d:ident),+)] enum $e:ident { $($v:ident),+ } ) => {
|
|
|
|
#[derive($($d,)+)]
|
|
|
|
enum $e {
|
|
|
|
$($v),+
|
|
|
|
}
|
|
|
|
|
2015-04-19 02:23:18 +00:00
|
|
|
impl ::std::str::FromStr for $e {
|
2015-04-17 14:20:56 +00:00
|
|
|
type Err = String;
|
|
|
|
|
2015-04-19 02:20:43 +00:00
|
|
|
fn from_str(s: &str) -> Result<Self,Self::Err> {
|
2015-04-17 14:20:56 +00:00
|
|
|
match s {
|
|
|
|
$(stringify!($v) => Ok($e::$v),)+
|
|
|
|
_ => Err({
|
|
|
|
let v = vec![
|
|
|
|
$(stringify!($v),)+
|
|
|
|
];
|
|
|
|
format!("valid:{}", v.iter().fold(String::new(),|a, i| a + &format!(" {}", i)[..]))
|
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
(#[derive($($d:ident),+)] pub enum $e:ident { $($v:ident),+ } ) => {
|
|
|
|
#[derive($($d,)+)]
|
|
|
|
pub enum $e {
|
|
|
|
$($v),+
|
|
|
|
}
|
|
|
|
|
2015-04-19 02:23:18 +00:00
|
|
|
impl ::std::str::FromStr for $e {
|
2015-04-17 14:20:56 +00:00
|
|
|
type Err = String;
|
|
|
|
|
2015-04-19 02:20:43 +00:00
|
|
|
fn from_str(s: &str) -> Result<Self,Self::Err> {
|
2015-04-17 14:20:56 +00:00
|
|
|
match s {
|
|
|
|
$(stringify!($v) => Ok($e::$v),)+
|
|
|
|
_ => Err({
|
|
|
|
let v = vec![
|
|
|
|
$(stringify!($v),)+
|
|
|
|
];
|
|
|
|
format!("valid:{}", v.iter().fold(String::new(),|a, i| a + &format!(" {}", i)[..]))
|
|
|
|
})
|
2015-04-16 17:41:20 +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
|
|
|
|
///
|
|
|
|
/// # Example
|
|
|
|
/// ```no_run
|
|
|
|
/// # #[macro_use]
|
|
|
|
/// # extern crate clap;
|
|
|
|
/// # use clap::App;
|
|
|
|
/// # fn main() {
|
|
|
|
/// let m = App::new("app")
|
|
|
|
/// .version(crate_version!())
|
|
|
|
/// .get_matches();
|
|
|
|
/// # }
|
|
|
|
/// ```
|
|
|
|
#[macro_export]
|
|
|
|
macro_rules! crate_version {
|
|
|
|
() => {
|
|
|
|
format!("{}.{}.{}{}",
|
|
|
|
env!("CARGO_PKG_VERSION_MAJOR"),
|
|
|
|
env!("CARGO_PKG_VERSION_MINOR"),
|
|
|
|
env!("CARGO_PKG_VERSION_PATCH"),
|
|
|
|
option_env!("CARGO_PKG_VERSION_PRE").unwrap_or(""))
|
|
|
|
}
|
|
|
|
}
|