How to use requires_if in derive?

[yift]

I'm trying to use requires_if with derive and it seems to ignore the condition (but test that the name is valid).

Code example:

use clap::Parser;

#[derive(Parser, Debug)]
#[command(author, version, about, long_about = None)]
/// blas ccc
struct Cli {
    /// one
    #[arg(short, long, default_value = "no")]
    one: String,

    /// test
    #[arg(short, long, requires_if("yes", "one"))]
    two: Option<String>,
}
fn parse_and_print(args: Vec<&str>) {
    println!("Parsing: {:?}", &args);
    let cli = Cli::parse_from(args);
    println!("\t we get {:?}", cli);
}
fn main() {
    parse_and_print(vec![""]);
    parse_and_print(vec!["", "--one", "test1"]);
    parse_and_print(vec!["", "--one", "test2"]);
    parse_and_print(vec!["", "--two", "test1"]);
    parse_and_print(vec!["", "--two", "test2"]);
    parse_and_print(vec!["", "--one", "test1", "--two", "test2"]);
    parse_and_print(vec!["", "--one", "yes", "--two", "OK?"]);
}

What am I doing wrong?

[epage]

As a cargo script

#!/usr/bin/env nargo
---
[dependencies]
clap = { version = "4", features = ["derive"] }
---

use clap::Parser;

#[derive(Parser, Debug)]
#[command(author, version, about, long_about = None)]
/// blas ccc
struct Cli {
    /// one
    #[arg(short, long, default_value = "no")]
    one: String,

    /// test
    #[arg(short, long, requires_if("yes", "one"))]
    two: Option<String>,
}
fn parse_and_print(args: Vec<&str>) {
    println!("Parsing: {:?}", &args);
    let cli = Cli::parse_from(args);
    println!("\t we get {:?}", cli);
}
fn main() {
    parse_and_print(vec![""]);
    parse_and_print(vec!["", "--one", "test1"]);
    parse_and_print(vec!["", "--one", "test2"]);
    parse_and_print(vec!["", "--two", "test1"]);
    parse_and_print(vec!["", "--two", "test2"]);
    parse_and_print(vec!["", "--one", "test1", "--two", "test2"]);
    parse_and_print(vec!["", "--one", "yes", "--two", "OK?"]);
}

and output:

Parsing: [""]
         we get Cli { one: "no", two: None }
Parsing: ["", "--one", "test1"]
         we get Cli { one: "test1", two: None }
Parsing: ["", "--one", "test2"]
         we get Cli { one: "test2", two: None }
Parsing: ["", "--two", "test1"]
         we get Cli { one: "no", two: Some("test1") }
Parsing: ["", "--two", "test2"]
         we get Cli { one: "no", two: Some("test2") }
Parsing: ["", "--one", "test1", "--two", "test2"]
         we get Cli { one: "test1", two: Some("test2") }
Parsing: ["", "--one", "yes", "--two", "OK?"]
         we get Cli { one: "yes", two: Some("OK?") }

[epage]

@yift to make sure we are on the same page about what you are trying to accomplish, can you describe which cases are expected, which are unexpected, and what you expect instead?

[yift]

Hi, I want to have two arguments, when the second one is optional but only valid if the first one have a specific value.

For example, I have an enum output type that can be either raw text or JSON, and another argument which is the JSON style (hence, only valid if the output type is JSON).

Is there a better way to do it?

[epage]

Next time, I'd recommend

• Making the example a little less generic so its easier to talk about the cases
• Specifying what and why for unexpected

If I'm understanding what you are talking about, you are looking at

#!/usr/bin/env nargo
---
[dependencies]
clap = { path = "../clap", features = ["derive"] }
---

use clap::Parser;

#[derive(Parser, Debug)]
#[command(author, version, about, long_about = None)]
/// blas ccc
struct Cli {
    /// one
    #[arg(short, long, value_parser = ["raw", "json"])]
    format: String,

    /// test
    #[arg(short, long, value_parser = ["short", "pretty"])]
    json_style: Option<String>,
}
fn parse_and_print(args: Vec<&str>) {
    println!("Parsing: {:?}", &args);
    match Cli::try_parse_from(args) {
        Ok(cli) => println!("\t we get {:?}", cli),
        Err(_) => println!("\t failure"),
    }
}
fn main() {
    parse_and_print(vec![""]);  // Invalid
    parse_and_print(vec!["", "--format", "raw"]);  // Valid
    parse_and_print(vec!["", "--format", "json"]);  // Valid
    parse_and_print(vec!["", "--json-style", "short"]);  // Invalid
    parse_and_print(vec!["", "--json-style", "pretty"]);  // Invalid
    parse_and_print(vec!["", "--format", "raw", "--json-style", "short"]);  // Valid
    parse_and_print(vec!["", "--format", "json", "--json-style", "short"]);  // Valid
}

We have

• requires_if: if an argument (current) has a certain value, then a different argument (specified) becomes required
• required_if_eq: if an argument (specified) has a certain value, then a different argument (current) becomes required

(yes, these are the same thing but but allow you to place on either argument)

I believe what you are looking for is "if an argument is used, then it requires another argument to have a certain value

This is not directly supported and would need to be handled within your application. I am hesitant to add new forms of complex validation logic like this because a lot of cases tend to be fairly specialized and the harder-to-discover API, longer build times, and larger binary sizes are paid for by all.

[yift]

Oh, so going back to my first example, I would need to do something like:

use clap::Parser;

#[derive(Parser, Debug)]
#[command(author, version, about, long_about = None)]
/// blas ccc
struct Cli {
    /// one
    #[arg(short, long, default_value = "no", requires_if("yes", "two"))]
    one: String,

    /// test
    #[arg(short, long)]
    two: Option<String>,
}
fn parse_and_print(args: Vec<&str>) {
    println!("Parsing: {:?}", &args);
    let cli = Cli::try_parse_from(args);
    println!("\t we get {:?}", cli);
}
fn main() {
    parse_and_print(vec![""]);
    parse_and_print(vec!["", "--one", "test1"]);
    parse_and_print(vec!["", "--one", "test2"]);
    parse_and_print(vec!["", "--two", "test1"]);
    parse_and_print(vec!["", "--two", "test2"]);
    parse_and_print(vec!["", "--one", "test1", "--two", "test2"]);
    parse_and_print(vec!["", "--one", "yes", "--two", "OK?"]);
    parse_and_print(vec!["", "--one", "yes"]);
}

To make the argument two required if argument one is yes.

Thanks.

[epage]

I can't say because this is too abstract but I don't think either of the features we provide will work for you.