Option to manually hook up dynamic autocomplete

[DanCardin]

Essentially, I was routed to bpaf because clap does not support dynamic autocomplete. And my 5min test confirms that it does what I minimally need it to do(!), but I'm not especially a fan of the --bpaf-complete-style-fish style of argments for producing the behavior.

My particular command already has/needs a cmd --shell zsh option, so I'd prefer to encode the shell selection with that arg. And additionally, I dont especially love that it hardcodes the name bpaf into the shape of my cli.

What I'd ideally love to do is define my own subcommand cmd --shell zsh shell completion for example, that I could either annotate to indicate to the autocomplete feature (which seems more challenging...), or otherwise programmatically/manually call from my own code into the appropriate api

[pacak]

--bpaf-complete-style-fish and 3 other arguments for other supported shells are only there to produce an autocomplete script, users needs to do it only once (or when I decide to make breaking changes to that part). You can produce the same script by cmd --shell zsh completion if you like or even put it into your documentation and ask users to copy-paste.

Second API endpoint is --bpaf-complete-rev=xxx, where xxx corresponds to the shell. All that bpaf does internally when it sees it is extracting the revision, collecting the remaining arguments, making Args out of that, setting the revision with Args::set_comp and running as usual. You can do the same.

        // prepare arguments here, easiest is probably to read them directly from OS
        //  and check if it starts with `cmd --shell zsh shell completion`.
        // if it is - you make `Args` from leftovers and set the revision
        // if not - you make `Args` from all of them minus the name
        // then you run it like that
        match your_parser().run_inner(args) {
            Ok(t) => t,
            Err(err) => std::process::exit(err.exit_code()),
        }

[DanCardin]

So taking some super duper simple example cli:

use bpaf::Bpaf;

fn options(_: &String) -> Vec<(String, Option<String>)> {
    vec![("one".to_string(), Some("one".to_string()))]
}

#[derive(Clone, Debug, Bpaf)]
#[bpaf(options, version)]
struct Args {
    #[bpaf(positional, complete(options))]
    option: String,

    shell: Option<String>
}

fn main() {
    let args = args().run();
    println!("Options: {:?}", args);
}

it's not obvious to me what exactly I need to do to replicate the behavior of those options.

You can produce the same script by cmd --shell zsh completion if you like ...

Am i correct in thinking you just mean printing these? https://github.com/pacak/bpaf/blob/master/src/complete_run.rs. If so, it'd be ideal if these functions (or an api to invoke them) was public, so I wasn't forced to copy-paste them.

And to your latter commend about the -rev option and the code blob...I'm sorry, I'm just not sure I follow what that's supposed to do and what I'm meant to do internally to apply the same api. I see some things you're doing with args_scanner in arg.rs that seems related, but it's unclear what'd be relevant to my request or not.

[pacak]

There are two types of completion endpoints:

• --bpaf-complete-style-(fish|zsh|bash|elvish) - they generate completion script you can call them user facing, user needs to call it just once.
• --bpaf-complete-rev=xxx - this endpoint generates the completion itself. script generated above will call it. I wouldn't call them user facing.

Which one do you want to change?

[DanCardin]

So if I were to manually copy-paste your shell code in https://github.com/pacak/bpaf/blob/master/src/complete_run.rs (and execute, on my own command), which call out to the (un-help-message'd) option --bpaf-complete-rev=, then it'd "just work"(?)

Is there a public-api way for me to invoke that from a subcommand without copying them? they're currently all private, i see. And I'm not sure that ArgScanner gets me where i'd need to be.

--bpaf-complete-rev=xxx - this endpoint generates the completion itself. script generated above will call it. I wouldn't call them user facing.

Even if the above works, it's still not ideal, imo. because it ends up writing this bpaf-(version)-specific cli shell option to disk. I just dont love it because it couples my CLI to both bpaf, but also the name/behavior you happen to give it on this specific version, which is outside my control.

[pacak]

So if I were to manually copy-paste your shell code in https://github.com/pacak/bpaf/blob/master/src/complete_run.rs (and execute, on my own command), which call out to the (un-help-message'd) option --bpaf-complete-rev=, then it'd "just work"(?)

That is correct.

Is there a public-api way for me to invoke that from a subcommand without copying them?

Sort of. You can call your own executable with --bpaf-complete-style-zsh or similar option and capture the output. Users will have to do it at most once so it should be fine. Alternatively you can call this flag as part of your test suite, store the output somewhere and produce it when user calls the command you want. Or put those snippets in the documentation.

Currently there's no public API for those methods apart from calling the application.

because it ends up writing this bpaf-(version)-specific cli shell option to disk.

Revision is there mostly to pick the right shell so revision 7 corresponds to zsh and the generated script simply runs whatever parser produces to generate completion list. While the output might change in later versions - it should still be compatible with the old ones.

[DanCardin]

Alright. I mean, I can leave it at this as I have enough to go on that I can get most of the behavior I want.

But i'll register a vote that for future api changes, i think it'd be ideal if I could hook up this functionality without references to options/commands that I dont control