[−][src]Macro clap_conf::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)