Flag takes optional value

[richard-uk1]

There are times when it is necessary to interpret an option as a flag when it has no value, so for example in cargo:

$ cargo run --example my_example

should run an example, whereas

$ cargo run --example

should print available examples.

This could be achieved if clap allowed specifying that the value part of the option was optional. It could be signalled by value_of returning None, and is_present returning true.

[crumblingstatue]

I have a very similar use case in my own application.

I want myapp -r to run the default binary (which can be set in a configuration file), and myapp -r foo to run the binary foo.

Running myapp without -r should just build the targets, but not run them.

The first thing that came to mind is a value_required(bool) option.

In the meantime, I switched my project to getopts, using HasArg::Maybe.

[AntonGepting]

It would be nice to have this "optional option" feature.

Same example of usage:

• Run application to use the default configuration file placed in the home directory ~/.config/application/config.cfg or if not exists in /etc/application/config.cfg
• Run application -c to use configuration file placed in the current directory with the default file name config.cfg
• Run application -c ../custom_config.cfg to use user specified location with the custom configuration file name

[CreepySkeleton]

This is supported via:

• Check is_present, if false - no option were passed
• Then check value_of
  • --example val will be mapped to Some(val)
  • --example will be mapped to None

[AntonGepting]

Hello, thank you for your answer,

Maybe I'm missing something or understanding it not completely, but let's look at
the following small example to illustrate the problem:

use clap::{App, Arg};

fn main() {
    const CONFIG_ARG: &str = "config";

    // create and setup some cli app
    let app = App::new("app").arg(
        // ...
        Arg::with_name(CONFIG_ARG)
            .short("-c")
            .long("--config")
            .value_name("CONFIG")
            .takes_value(true),
        // ...
    );
    let matches = app.get_matches();

    // ...
    // checking argument, something like you were suggesting:
    let cfg = if matches.is_present(CONFIG_ARG) {
        if let Some(custom) = matches.value_of(CONFIG_ARG) {
            // if some custom user specified config was given use it (option: -c custom.conf)
            custom
        } else {
            // if no parameter was given, use the config in current directory (flag: -c)
            "app.conf"
        }
        // or just
        //matches.value_of(CONFIG_ARG).unwrap_or("app.conf")
    } else {
        // if nothing was given use just standard user config (no -c option and no -c flag)
        "/home/user/.config/app/app.conf"
    };
    // ...

    println!("config file name: {:?}", cfg);
}

How was I trying to solve this:

• .takes_value(true) - needs to be defined or we are getting error:
  error: Found argument 'config.conf' which wasn't expected, or isn't valid in this context

• if we define the argument as an option, but using it as a flag we are getting error:
  error: The argument '--config <CONFIG>' requires a value but none was supplied

• we can't just add another synonym argument with same name (one stays as a flag,
  another one is an option). We are getting error:
  thread 'main' panicked at 'Argument long must be unique
thread 'main' panicked at 'Argument short must be unique

I was meaning and looking for something like .optional_value(true), so the argument can be either just
a flag (-c) or an option (-c config.conf).

Could you please give me an advice, how can it be solved?
Is it even possible in the current implementation?

Thank you in advance.

[pksunkara]

https://docs.rs/clap/3.0.0-beta.2/clap/struct.Arg.html#method.default_missing_value