Using pattern matching to generate dynamic completions

[daelvn]

Would it be possible to use the patterns from every YAML section for more dynamic completions? For example, let's say I have a command taskrunner that loads its tasks as commands from a file. So you do taskrunner task1 or taskrunner task2. Right now this completion is possible with the following:

taskrunner:
- $(taskrunner --read-tasks-for-autocompletion)

Now, say that each task could have its own arguments, like taskrunner task1 --file f.txt or taskrunner task2 --version. Since I cannot write the tasks statically in the YAML, I have to do taskrunner *:. I can get the argument information from the taskrunner like so: taskrunner --get-arguments-for-task task1. Is there a way I could do the following?

taskrunner [task]:
- $(taskrunner --get-arguments-for-task [task])

If not, it would be a nice feature to have.

[DannyBen]

I can see the value, but not sure it can be implemented while allowing the full breadth of needed functionality and keeping the configuration file simple.

For example, with this command :

taskrunner task1 --file f.txt

If you were to write in the standard completely syntax, you would probably do something like this:

taskrunner task1:
- --file

taskrunner task1*--file:
- <file>

so this already breaks outside the mold of "one completely configuration per dynamic task"

Am I wrong?

[daelvn]

That is true, yes. The only solution I can currently think of is that taskrunner passes back a code string to be integrated into the Bash completion function to manually patch it. Or maybe, something parseable like --file[Description]:<file> (kind of similar to how Zsh does it). The first would delegate the complexity to the program being implemented, and the second would allow for more flexibility. Is it something to consider?

[DannyBen]

Yeah, well - this will not work well I think. This sounds like a very specific solution.

I was thinking in a slightly different direction:

• Completely is a simple lists-to-completion converter.
• You wish to create these lists dynamically by using an external source
• Then you need to generate the completely.yaml file using an external script.

It will be relatively easy to generate the YAML file from all the lists that your taskrunner returns. It will certainly be easier to create the completely.yaml than to create a bash completion script, I think.

When I thought about this approach, I had Kojo in mind - this is a command line tool for creating and manipulating data with templates. Of course, it can be done without it.

The code logic would be something like:

for each <pattern> in <the list of patterns>:
    completions = the output of the command that returns the list of completions
    print "{pattern}:"
    for each <comlpetion> in <completions>:
        print "- {completion}"

then you run this and pipe it to "completely.yaml" and run completely.