Macro structopt::clap::clap_app

macro_rules! clap_app {
    (@ app ($ builder : expr)) => { ... };
    (@ app ($ builder : expr) (@ arg ($ name : expr) : $ ($ tail : tt) *) $
 ($ tt : tt) *) => { ... };
    (@ app ($ builder : expr) (@ arg $ name : ident : $ ($ tail : tt) *) $
 ($ tt : tt) *) => { ... };
    (@ app ($ builder : expr) (@ setting $ setting : ident) $ ($ tt : tt) *) => { ... };
    (@ app ($ builder : expr) (@ attributes $ ($ attr : tt) *) $ ($ tt : tt) *) => { ... };
    (@ app ($ builder : expr) (@ group $ name : ident => $ ($ tail : tt) *) $
 ($ tt : tt) *) => { ... };
    (@ app ($ builder : expr)
 (@ group $ name : ident ! $ ident : ident => $ ($ tail : tt) *) $ ($ tt : tt)
 *) => { ... };
    (@ app ($ builder : expr)
 (@ group $ name : ident + $ ident : ident => $ ($ tail : tt) *) $ ($ tt : tt)
 *) => { ... };
    (@ app ($ builder : expr) (@ subcommand $ name : ident => $ ($ tail : tt) *) $
 ($ tt : tt) *) => { ... };
    (@ app ($ builder : expr) ($ ident : ident : $ ($ v : expr), *) $ ($ tt : tt)
 *) => { ... };
    (@ group ($ builder : expr, $ group : expr)) => { ... };
    (@ group ($ builder : expr, $ group : expr) (@ attributes $ ($ attr : tt) *) $
 ($ tt : tt) *) => { ... };
    (@ group ($ builder : expr, $ group : expr)
 (@ arg $ name : ident : $ ($ tail : tt) *) $ ($ tt : tt) *) => { ... };
    (@ arg ($ arg : expr) $ modes : tt) => { ... };
    (@ arg ($ arg : expr) $ modes : tt - - ($ long : expr) $ ($ tail : tt) *) => { ... };
    (@ arg ($ arg : expr) $ modes : tt - - $ long : ident $ ($ tail : tt) *) => { ... };
    (@ arg ($ arg : expr) $ modes : tt - $ short : ident $ ($ tail : tt) *) => { ... };
    (@ arg ($ arg : expr) (-) < $ var : ident > $ ($ tail : tt) *) => { ... };
    (@ arg ($ arg : expr) (+) < $ var : ident > $ ($ tail : tt) *) => { ... };
    (@ arg ($ arg : expr) (-) [$ var : ident] $ ($ tail : tt) *) => { ... };
    (@ arg ($ arg : expr) (+) [$ var : ident] $ ($ tail : tt) *) => { ... };
    (@ arg ($ arg : expr) $ modes : tt ... $ ($ tail : tt) *) => { ... };
    (@ arg ($ arg : expr) $ modes : tt # { $ n : expr, $ m : expr } $
 ($ tail : tt) *) => { ... };
    (@ arg ($ arg : expr) $ modes : tt * $ ($ tail : tt) *) => { ... };
    (@ arg ($ arg : expr) $ modes : tt ! $ ident : ident $ ($ tail : tt) *) => { ... };
    (@ arg ($ arg : expr) $ modes : tt + $ ident : ident $ ($ tail : tt) *) => { ... };
    (@ arg ($ arg : expr) $ modes : tt { $ fn_ : expr } $ ($ tail : tt) *) => { ... };
    (@ as_expr $ expr : expr) => { ... };
    (@ arg ($ arg : expr) $ modes : tt $ desc : tt) => { ... };
    (@ arg ($ arg : expr) $ modes : tt $ ident : ident [$ ($ target : ident) *] $
 ($ tail : tt) *) => { ... };
    (@ arg ($ arg : expr) $ modes : tt $ ident : ident ($ ($ expr : expr), *) $
 ($ tail : tt) *) => { ... };
    (@ arg ($ arg : expr) $ modes : tt $ ident : ident ($ ($ expr : expr,) *) $
 ($ tail : tt) *) => { ... };
    (@ subcommand $ name : ident => $ ($ tail : tt) *) => { ... };
    (($ name : expr) => $ ($ tail : tt) *) => { ... };
    ($ name : ident => $ ($ tail : tt) *) => { ... };
}

Build App, Args, SubCommands and Groups with Usage-string like input but without the associated parsing runtime cost.

clap_app! also supports several shorthand syntaxes.

Examples

let matches = clap_app!(myapp =>
    (version: "1.0")
    (author: "Kevin K. <kbknapp@gmail.com>")
    (about: "Does awesome things")
    (@arg CONFIG: -c --config +takes_value "Sets a custom config file")
    (@arg INPUT: +required "Sets the input file to use")
    (@arg debug: -d ... "Sets the level of debugging information")
    (@group difficulty =>
        (@arg hard: -h --hard "Sets hard mode")
        (@arg normal: -n --normal "Sets normal mode")
        (@arg easy: -e --easy "Sets easy mode")
    )
    (@subcommand test =>
        (about: "controls testing features")
        (version: "1.3")
        (author: "Someone E. <someone_else@other.com>")
        (@arg verbose: -v --verbose "Print test information verbosely")
    )
)
.get_matches();

Shorthand Syntax for Args

• 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
  • 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.
• Three dots (...) sets Arg::multiple(true)
• 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 Arg::required(true)
• 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 Arg::required(false)
• There are short hand syntaxes for Arg methods that accept booleans
  • 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)
• 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 Arg::conflicts_with("FOO"), Arg::conflicts_with("BAR"), and Arg::conflicts_with("BAZ") (note the lack of quotes around the values in the macro)

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)