clap 4.0 equivalent of possible_values with strumVARIANTS?

[repi]

Hi with clap v3.0 we have a lot of enum arguments that used possible_values like this:

    #[clap(long, default_value_t, ignore_case = true, possible_values = OutputFormat::VARIANTS)]
    pub output_format: OutputFormat,

where the VARIANTS is from the strum::EnumVariantNames derive macro and is just a plain static string array.

In clap v4 rc1-3 possible_values = has been replaced with value_parser = , so looks like this should work:

    #[arg(long, default_value_t, ignore_case = true, value_parser = clap::builder::PossibleValuesParser::new(OutputFormat::VARIANTS))]
    pub output_format: OutputFormat,

And while that builds, if one doesn't specify such an argument when parsing a command-line it panics on this instead of using the default type:

thread 'main' panicked at 'Mismatch between definition and access of `auth`. Could not downcast to ark_auth::auth_flow::ExternalAuthProvider, need to downcast to alloc::string::String

So must be something more missing in the translation of command definitions here from clap v3 to v4?

We don't want to switch to clap::ArgEnum as these enums not just arguments but more shared types in libraries and shouldn't depend on our command-line argument system of choice in the application.

On a related minor note, is there a way to enable case insensitive argument matching by default instead of specifying it on every argument?

[epage]

And while that builds, if one doesn't specify such an argument when parsing a command-line it panics on this instead of using the default type:

All the value parser knows is possible string values; you also need to set the appropriate type for it.

    #[arg(long, default_value_t, ignore_case = true, value_parser = clap::builder::PossibleValuesParser::new(OutputFormat::VARIANTS).map(|s| s.parse::<OutputFormat>().unwrap())]
    pub output_format: OutputFormat,

See also #3855

On a related minor note, is there a way to enable case insensitive argument matching by default instead of specifying it on every argument?

Not at the moment. That is an interesting thought though, if someone wants it on one arg, they probably want it on all args. I generally ignore that setting as I prefer to be case sensitive.

[repi]

thanks that does work! should have searched better for previous threads, but thought this was something fully new in 4.0 rc.

gets even more verbose, though I can probably do a utility function locally that is compatible with the strum trait we are using

[epage]

Value parsers were new in 3.2.0. TypedValueParser::map didn't come until about 3.2.22. Part of it was a matter of understanding the scale of the problem (I didn't realize how many people relied on mixing possible values with FromStr like this).

If people have thoughts on how to streamline this further, I would be open to it.

[repi]

did do a small macro for it in our codebase that assumes the enum uses strum::EnumVariantNames, seems to work ok.

#[macro_export]
macro_rules! clap_enum_variants {
    ($e: ty) => {{
        use clap::builder::TypedValueParser;
        clap::builder::PossibleValuesParser::new(<$e>::VARIANTS).map(|s| s.parse::<$e>().unwrap())
    }};
}

so original code becomes this in clap v4:

    #[arg(long, default_value_t, ignore_case = true, value_parser = clap_enum_variants!(OutputFormat))]
    pub output_format: OutputFormat,

[devklick]

Nice solution! I was using this for a while, but after moving around some code, I couldnt figure out why I was getting the error:

clap::builder::PossibleValuesParser::new(<$e>::VARIANTS).map(|s| s.parse::<$e>().unwrap())
//                                            ^^^^^^^^ variant or associated item not found in `MyEnum`

The problem was that I had moved the macro to a different file than where enum is defined (and different to where strum::VariantNames; was imported and used). The solution was to import strum::VariantNames within this macro, i.e:

#[macro_export]
macro_rules! clap_enum_variants {
    ($e: ty) => {{
        use clap::builder::TypedValueParser;
        use strum::VariantNames; // <-- added 
        clap::builder::PossibleValuesParser::new(<$e>::VARIANTS).map(|s| s.parse::<$e>().unwrap())
    }};
}

Importing strum::VariantNames; outside of the macro doesnt seem to work:

use strum::VariantNames; // <-- ignored

#[macro_export]
macro_rules! clap_enum_variants {
    ($e: ty) => {{
        use clap::builder::TypedValueParser;
        clap::builder::PossibleValuesParser::new(<$e>::VARIANTS).map(|s| s.parse::<$e>().unwrap())
    }};
}

This might be pretty obvious to a lot of experienced rust devs, but I was scratching my head for hours over this!