Support for Vec<T> Subcommands

[ewoolsey]

Please complete the following tasks

• I have searched the discussions
• I have searched the open and rejected issues

Clap Version

4.0.18

Describe your use case

I would like to parse a vector of subcommands like so:

#[derive(Parser)]
#[clap(rename_all = "snake_case")]
pub enum MyCli {
    GetPrices {
        #[command(subcommand)]
        assets: Vec<AssetInfo>,
    },
}

#[derive(Subcommand)]
#[clap(rename_all = "snake_case")]
pub enum AssetInfo {

    #[command(subcommand)]
    Base(BaseExecuteMsg),

    SetConfig {
        #[command(flatten)]
        set_config_msg: SetConfigMsg,
    },

    AddAsset {
        #[command(flatten)]
        asset_info_type: AddAssetType,
    },

    RemoveAsset {
        #[command(subcommand)]
        asset_info: RemoveAssetType,
    },

    UpdatePrice {
        #[command(subcommand)]
        asset_info: PriceType,
    },

    UpdatePrices {
        #[arg(value_parser=tuple_parser::<PriceType, Decimal256>)]
        assets: Vec<(PriceType, Decimal256)>,
    },
}

Describe the solution you'd like

I'm not sure what the best internal solution is here.

[epage]

I would like to parse a vector of subcommands like so:

What do you mean by this? Could you provide a complete program (e.g. AssetInfo is missing) and example runs of the program to help clarify the point?

[ewoolsey]

@epage The above is sort of a toy example as my actual use case has dozens of nested subcommands. I realize the workaround is probably to use a value parser, but that doesn't work for me since 1: its insanely clunky, 2: I'm also parsing and that would break the interactivity. For my specific use case I cannot change the structure of the enum since it is part of an external API.

[epage]

Could you provide example runs of the program to clarify what the semantics of this feature would be?

[ewoolsey]

Sure, as an example lets create something simpler and complete.

#[derive(Parser)]
#[clap(rename_all = "snake_case")]
pub enum MyCli {
    GetPrices {
        #[command(subcommand)]
        assets: Vec<AssetInfo>,
    },
}

#[derive(Subcommand)]
#[clap(rename_all = "snake_case")]
pub enum AssetInfo {
    Token {
        /// <string>, "atom3h6lk23h6"
        contract_addr: String
    },
    NativeToken {
        /// <string>, "uatom"
        denom: String
    },
}

This is a much simpler case then I have in reality, but useful for examining how this could work. An example run of the program could look like:

my-cli get_prices token atom3h6lk23h6 native_token uatom 

Ideally this should be implemented for any type that is IntoIterator<Item = T>. When these example args are parsed it would result in:

MyCli::GetPrices{
    assets: vec![
        AssetInfo::Token { contract_addr: atom3h6lk23h6 },
        AssetInfo::NativeToken { denom: uatom }
    ]
}

[epage]

Sounds like this is a duplicate of #2222. Do I have that correct?

[ewoolsey]

Sounds like this is a duplicate of #2222. Do I have that correct?

I think depending on how it is implemented it could possibly be a duplicate. You mention in that thread disabling subcommands though, which would sort of defeat the purpose of what I'm going for no?

[epage]

I'd prefer issues to focus on the requirements and not implementation. As both of these are about command chaining, let's continue the conversation over there. If you need sub-subcommands for your chained commands, I'd recommend posting in there with the reasons why its needed and a proposal for what the semantics would be (e.g. do we stop chaining when entering a sub-sub-command or do we back out to the parent chained command?)