How to generate mutually exlusive options that works with "many"?

[VorpalBlade]

New to this crate and somewhat relatively new to rust in general (though I have been programming in C++ and Python for a long time, and did Erlang many years ago).

My goal is to get a command line API that accepts any one of the following forms:

$ my-command single-file
$ my-command -s at least one file
$ my-command -a at least one file

So far I have the following, which appears to generate the correct --help output, but doesn't actually do the right thing. What am I doing wrong here:

    #[derive(Debug, Clone, Bpaf)]
    #[bpaf(options, version)]
    pub(super) enum Mode {
        /// Process a single file
        Default(PathBuf),
        Add {
            /// Add a file to be tracked by chezmoi_mm
            #[bpaf(short('a'), long("add"))]
            files: Vec<PathBuf>,
        },
        Smart {
            /// Smartly add a file to either chezmoi or chezmoi_mm
            #[bpaf(short('s'), long("smart"))]
            files: Vec<PathBuf>,
        },
    }

$ my-command
Usage: (<ARG> | -a ARG... | -s ARG...)

Available options:
    -a, --add <ARG>    Add a file to be tracked by chezmoi_mm
    -s, --smart <ARG>  Smartly add a file to either chezmoi or chezmoi_mm
    -h, --help         Prints help information
    -V, --version      Prints version information

$ my-command -a a b
No such command: `b`, did you mean `-s`?

It seems the multiple args part is just ignored? Is this a bug or am I using the library wrong?

[pacak]

So Mode can be one of Default, Add or Smart where Default takes a single argument and both Add and Smart take multiple. Usage looks what we expect.

Now you are trying to pass both Default value (b) and Add value (-a a) which Mode can't represent.

If the idea to have multiple Mode items - you can nest them in some other structure and have a Vec of them.

Error message is a bit confusing, I'll see if it can be improved.

[pacak]

That is if you want it to behave like a flag that can go anywhere. Alternatively if you want it to be regular positional arguments with required flag -a or -s so both $ my-command -a a b c and $ my-command a b c -a work - you can try something much simplier:

    #[derive(Debug, Clone, Bpaf)]
    #[bpaf(options, version)]
    pub(super) enum Mode {
        /// Process a single file
        Default(PathBuf),
        Add {
           /// Add a file to be tracked by chezmoi_mm
           #[bpaf(short('a'), long("add"))]
           a: (),
           #[bpaf(positional)]
           files: Vec<PathBuf>,
        },
        Smart {
           /// Smartly add a file to either chezmoi or chezmoi_mm
           #[bpaf(short('s'), long("smart"))]
           a: (),
           #[bpaf(positional)]
           files: Vec<PathBuf>,
        },
    }

[VorpalBlade]

Thanks! I was about to post that your first suggestion didn't work:

• "anywhere" gives the compiler error: Unexpected attribute.
• If I removed that I got a different error: error: unnamed fields needs to have a name specified, on the line Smart(#[bpaf(external)] Smart).

I'm fine with -a/-s only working at the beginning, and this second solution compiles (maybe the first one depended on something unreleased?).

[pacak]

Yea, first one should be compiling with master branch but it's not yet published. Trying to get it out soon-ish. If second solution works - it's probably easiest to use.

You can make -a/-s into subcommands so usage looks like

$ my-app add a b c
$ my-app smart a b c

    #[derive(Debug, Clone, Bpaf)]
    #[bpaf(options, version)]
    pub(super) enum Mode {
        /// Process a single file
        Default(PathBuf),
        #[bpaf(command)]
        Add {
            /// Add a file to be tracked by chezmoi_mm
            #[bpaf(positional)]
            files: Vec<PathBuf>,
        },
        #[bpaf(command)]
        Smart {
            /// Smartly add a file to either chezmoi or chezmoi_mm
            #[bpaf(positional)]
            files: Vec<PathBuf>,
        },
    }

[VorpalBlade]

While the sub command would be cleaner (for sure), I'm converting a python script of mine that turned out to be too slow. I need to stick to the command line API it provides, since I don't want to break existing scripts.

Anyway it is possible to view what I do as sub-commands with flag style names, similar to what the system package manager pacman on Arch Linux does. This is apparently something clap can handle (they have an example showing this off). Would this be an alternative way to handle this in bpaf, or is that not supported?

[pacak]

It is possible to replicate the behavior with anywhere and adjacent but until I release a new version this is only available as part of combinatoric API.