Dynamic completion with argument

[vdesabou]

Hello !

I've followed recommendations from #181 where I have setup a private command:

- name: get-examples-list-with-fzf
  help: Return some completion for examples list
  private: true
  args:
  - name: file
    required: false
    help: current

Script get_examples_list_with_fzf_command.sh:

file="${args[file]}"
get_examples_list_with_fzf "$file"

where function is doing:

find $dir2 -name \*.sh  | fzf --query "$1" --delimiter / --with-nth '-3,-2,-1' --preview 'cat {}'

Which I call like this:

  flags:
  - long: --file
    short: -f
    required: true
    validate: file_exists
    arg: file
    completions:
      - $(playground get-examples-list-with-fzf "$cur")
    help: |-
      Example file to run.

My private command works fine, i.e when I call it, it find the right file using find and fzf and using the argument as query

playground get-examples-list-with-fzf "test jdbc"

Now If I run it with my real command:

playground run -f jdbc

It will show the fzf selection 3 times and in the end it does not select the file I want, see:

Any idea why ?

In my completion bash, it generates:

    'run'*'-f')
      while read -r; do COMPREPLY+=( "$REPLY" ); done < <( compgen -W "$(_playground_completions_filter "$(playground get-examples-list-with-fzf "$cur")")" -- "$cur" )
      ;;

[DannyBen]

I am not sure. There are too many variables in play here, most of which are outside the scope of what bashly and completely were designed to do.

I think you should simplify. Why not remove the private completions command and simply do something like this:

name: cli
help: Sample application

commands:
- name: run
  flags:
  - long: --file
    short: -f
    required: true
    arg: file
    completions:
      - $(fzf --query "$cur")
    help: |-
      Example file to run.

Also, you can use completely itself to easily test different commands.
You can convert your bashly yaml to completely.yaml by running bashly add completions_yaml and then renaming the file to completely.yaml.

See this completely.yaml as an example:

---
cli:
- run
cli run:
- "--file"
- "-f"
cli run*--file: &1
- $(fzf --query "$cur")
cli run*-f: *1

then you can test commands with

$ completely test "cli run -f "   # note the trailing space
$ completely test "cli run -f src"

Note that these commands run directly on the completely.yaml file, without the need to regenerate anything.

[vdesabou]

Many thanks @DannyBen for your help !

I've tried your suggestion testing with completely directly, so I have:

playground run*--file: &1
- $(find /Users/vsaboulin/Documents/github/kafka-docker-playground -name \*.sh | fzf --query "$cur")

If I run the test with space I get correct results:

completely test "playground run -f "    
$ playground run -f <tab>
/Users/vsaboulin/Documents/github/kafka-docker-playground/docs-examples/connect-connect-aws-s3-sink/stop.sh

But if I run with a string, I get empty results, even though I'm able to see my files with fzf and select result file I want:

 completely test "playground run -f jdbc"
$ playground run -f jdbc<tab>

Running with debug, I see that cur is correctly set:

compline: 'run -f'
cur:      'jdbc'

Maybe it's not supported to use argument $cur like this ?

[vdesabou]

If I simplify even more:

playground run*--file: &1
- $(find /Users/vsaboulin/Documents/github/kafka-docker-playground -name azure-blob-storage-source-proxy-backup-and-restore.sh)

where find /Users/vsaboulin/Documents/github/kafka-docker-playground -name azure-blob-storage-source-proxy-backup-and-restore.sh returns one file

it works:

completely test "playground run -f "  
$ playground run -f <tab>
/Users/vsaboulin/Documents/github/kafka-docker-playground/connect/connect-azure-blob-storage-source/azure-blob-storage-source-proxy-backup-and-restore.sh

but as soon as I test with some argument (which is not used), it returns nothing:

completely test "playground run -f abc"
$ playground run -f abc<tab>

[DannyBen]

Well - I am not sure if fzf can be used for completions in the way you attempt to use it.

If the word being completed ($cur) is abc, then bash completion will only complete it if the returned completion starts with abc. At least this is the behavior I see in my shell, but I could be wrong.

You can test it with my original $(fzf --query "$cur"), and run this:

$ completely test "cli run -f compl"

then choose completely.yaml in the fzf dialog. It will be completed as expected. But if you choose anything else that does not start with compl, it will not.

In any case - I suggest you simplify the your use case even further, and preferably, using a setup that can be reproduced by others (me), so I can maybe help further (assuming the issue I described above is not the issue you are facing).

The last case you mentioned (without fzf) suffers from the same issue - this is a completion issue, not sure there is anything I can do in the generated completion script to alleviate it.

[vdesabou]

If the word being completed ($cur) is abc, then bash completion will only complete it if the returned completion starts with abc. At least this is the behavior I see in my shell, but I could be wrong.

No you are totally right !

I managed to get my use case working by doing this trick:

- $(res=$(fzf --query "$cur");echo "$cur|$res")

So I echo $cur and then the result of my fzf command. Then I remove $cur further in my logic.
Ugly but that does the trick !

Thanks for you invaluable help ! Your project rocks !

[DannyBen]

That is an interesting trick! I will try it, and see if it is worth creating an example with this approach.
I wonder if fzf has some more native way to handle completions - I could not find any, but I admit I did just a shallow search.

[vdesabou]

There is a --print-query that can print query in fzf but I think same kind of trick is required anyway