clap_derive

Parse command line argument by defining a struct. It combines structopt and clap into a single experience. This crate is used by clap, and not meant to be used directly by consumers.

Documentation

Find it on Docs.rs. You can also check the examples and the changelog.

Example

Add clap to your dependencies of your Cargo.toml:

toml [dependencies] clap = "3"

And then, in your rust file: ```rust use std::path::PathBuf; use clap::Clap;

/// A basic example

[derive(Clap, Debug)]

[clap(name = "basic")]

struct Opt { // A flag, true if used in the command line. Note doc comment will // be used for the help message of the flag. The name of the // argument will be, by default, based on the name of the field. /// Activate debug mode #[clap(short, long)] debug: bool,

// The number of occurrences of the `v/verbose` flag
/// Verbose mode (-v, -vv, -vvv, etc.)
#[clap(short, long, parse(from_occurrences))]
verbose: u8,

/// Set speed
#[clap(short, long, default_value = "42")]
speed: f64,

/// Output file
#[clap(short, long, parse(from_os_str), value_hint = ValueHint::FilePath)]
output: PathBuf,

// the long option will be translated by default to kebab case,
// i.e. `--nb-cars`.
/// Number of cars
#[clap(short = "c", long)]
nb_cars: Option<i32>,

/// admin_level to consider
#[clap(short, long)]
level: Vec<String>,

/// Files to process
#[clap(name = "FILE", parse(from_os_str), value_hint = ValueHint::AnyPath)]
files: Vec<PathBuf>,

}

fn main() { let opt = Opt::parse(); println!("{:#?}", opt); } ```

Using this example: ``` $ ./basic error: The following required arguments were not provided: --output

USAGE: basic --output --speed

For more information try --help $ ./basic --help basic 0.3.0 Guillaume Pinot texitoi@texitoi.eu, others A basic example

USAGE: basic [FLAGS] [OPTIONS] --output [--] [file]...

ARGS: ... Files to process

FLAGS: -d, --debug Activate debug mode -h, --help Print help information -V, --version Print version information -v, --verbose Verbose mode (-v, -vv, -vvv, etc.)

OPTIONS: -l, --level ... admin_level to consider -c, --nb-cars Number of cars -o, --output Output file -s, --speed Set speed [default: 42]

ARGS: ... Files to process $ ./basic -o foo.txt Opt { debug: false, verbose: 0, speed: 42.0, output: "foo.txt", nbcars: None, level: [], files: [], } $ ./basic -o foo.txt -dvvvs 1337 -l alice -l bob --nb-cars 4 bar.txt baz.txt Opt { debug: true, verbose: 3, speed: 1337.0, output: "foo.txt", nbcars: Some( 4, ), level: [ "alice", "bob", ], files: [ "bar.txt", "baz.txt", ], } ```

clap_derive rustc version policy

Why

I've (@TeXitoi) used docopt for a long time (pre rust 1.0). I really like the fact that you have a structure with the parsed argument: no need to convert String to f64, no useless unwrap. But on the other hand, I don't like to write by hand the usage string. That's like going back to the golden age of WYSIWYG editors. Field naming is also a bit artificial.

Today, the new standard to read command line arguments in Rust is clap. This library is so feature full! But I think there is one downside: even if you can validate argument and expressing that an argument is required, you still need to transform something looking like a hashmap of string vectors to something useful for your application.

Now, there is stable custom derive. Thus I can add to clap the automatic conversion that I miss. Here is the result.

License

Licensed under either of

at your option.

Contribution

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.