How to define a flag with a way to check if the flag was provided on the command line?

[donatello]

For example:

#[derive(Debug, Args, Clone, Default, PartialEq, Eq)]
pub struct Config {
    #[clap(
        short = 'k', long, env = "APP_INSECURE",
    )]
    pub insecure: Option<bool>
}

Here, I want to be able to invoke as:

# Set with explicit value.
$ app -k true
$ app -k false

# Set via flag presence:

# Set insecure = Some(true)
$ app -k
# Set insecure = None (flag is absent)
$ app

The reason for having ability to set None is to implement layered configs. (For example, environment + yaml file)

I could not find any way to do this. Asking community for help.

[epage]

Something like this can be done. I'm going to step through the principles behind it.

The derive reference states that any builder method can be used as an attribute. If we look at how basic flags are turned into builder methods, we see SetTrue. The [documentation for SetTrue says

No value is allowed. To optionally accept a value, see Arg::default_missing_value

Looking at default_missing_value, we see a bool literal example that behaves like you are asking.

However, keep in mind the note

NOTE: using this configuration option requires the use of the .num_args(0..N) and the .require_equals(true) configuration option. These are required in order to unambiguously determine what, if any, value was supplied for the argument.

To be fair, if you will never accept a positional value, a subcommand, or the flag doesn't accept a hyphenated value, this could possibly be skipped. num_args goes into more detail

So the end result would look something like

#[derive(Debug, Args, Clone, Default, PartialEq, Eq)]
pub struct Config {
    #[clap(
        short = 'k', long, env = "APP_INSECURE",
        num_args = 0..=1, default_missing_value = "true", require_equals = true
    )]
    pub insecure: Option<bool>
}
```rust

[donatello]

Thank you so much! This works as you explained. However, the require_equals option is not ideal. The problem is that this flag is one among other optional arguments, and my command line accepts a variable number of positional argument as well. Because this the only flag that requires an equals, if the user forgets to use it:

$ app -k false -C file.data folder1 folder2

is interpreted as [false, folder1, folder2] being the positional args.

Is it possible to have the command line option -k not accept any value, and only accept an explicit value via the environment variable? Basically:

# should set insecure=Some(true)
$ app -k -C file.data f1 f2

# should set insecure=None
$ app -C file.data f1 f2

# should interpret environment variable, and set insecure=Some(true) or insecure=Some(false)
$ APP_INSECURE=true app -C file.data f1
$ APP_INSECURE=false app -C file.data f1

# following should fail:
$ app -k=true -C file.data f1

# this is valid - Sets insecure=Some(true) and interprets "false" as first positional argument
$ app -k false -C file.data f1

```

Thank you for your help in advance!

[donatello]

Oh wow, I was able to get this to work with:

    #[arg(short = 'k', long, env = "APP_INSECURE", num_args=0..=0, default_missing_value="true")]
    pub insecure: Option<bool>,

Would this be the recommended way? Thanks a lot for your input!

[epage]

If you don't care about None but ok with false, you can do

    #[arg(short = 'k', long, env = "APP_INSECURE")]
    pub insecure: bool,

If you really need None, then that is the way to do it. The one change I would make is I would do num_args=0