How to prevent recursive calls to fzf in custom bash completion?

[solisoares]

I'm writing my own tiny completion framework for a project of mine, and sourcing ~/.bashrc twice is breaking completion.

In my ~/.bashrc I setup fzf's path completion for foo:

# ~/.bashrc
...
_fzf_setup_completion path foo

I decide that foo should have a flag --bar and define it in the file ~/foo_completion.sh. To preserve existent fzf's completion (or any other it might be) I parse the current completion function, call it, and update COMPREPLY with --bar.

# ~/foo_completion.sh
__orig_foo_completion="$(complete -p foo 2>/dev/null)"
__orig_foo_completion_func="$(echo "$__orig_foo_completion" | sed -r 's/.*\s+-F\s+([a-zA-Z_]+)\s+[a-zA-Z_]+/\1/')"

_foo_comp() {
    "$__orig_foo_completion_func"
    COMPREPLY+=($(compgen -W '--bar'))
}

complete -F _foo_comp foo

For this to take effect I update my ~/.bashrc to source this file after the fzf's completion.

# ~/.bashrc
_fzf_setup_completion path foo
source ~/foo_completion.sh

It works, now I have access to both completions.

---

The problem is, when I source ~/.bashrc again, an attempt to complete foo makes what looks like a recursive call that crashes the session.

# Start session: ~/.bashrc has been sourced

# Test fzf completion: shows fzf completion
foo **[tab]

# Test custom completion: shows `--bar`
foo[tab]

# Now resource ~/.bashrc: crash
source ~/.bashrc
foo[tab]

---

Is this the correct approach?
Also tried inverting the order to first source my completion file and then fzf's, but the problem persists.

[pratikrath126]

The recursion happens because sourcing .bashrc again runs fzf s setup which overwrites the original completion function, but your wrapper still calls that name, now pointing to fzf s wrapper again. Fix: guard your wrapper so it only installs once. In ~/foo_completion.sh:

if [ -z "$__foo_orig" ]; then
_foo_orig="$(complete -p foo | sed -E s/.*-F\ +([a-zA-Z]+).*/\1/)"
if [ -n "$__foo_orig" ]; then
eval "_orig${__foo_orig}() $(declare -f $__foo_orig | tail -n +2)"
_foo_comp() {
COMPREPLY=( $(eval "_orig${__foo_orig}") )
COMPREPLY+=( $(compgen -W "--bar" -- "$2") )
}
complete -F _foo_comp foo
fi
fi

Also in .bashrc, guard fzf sourcing:

if ! declare -f _fzf_setup_completion >/dev/null; then
source ~/.fzf.bash
fi

These prevent double-wrapping and recursion.

[solisoares]

I'm sorry, but this answer looks like AI generated. Did you test it? Also, the rendered markdown is broken.

[ShreeChaturvedi]

Drop the complete -p parsing. _fzf_setup_completion already preserves whatever completion foo has and calls it when you don't type the ** trigger. Register yours first and let fzf wrap it.

# ~/foo_completion.sh
_foo_comp() {
    COMPREPLY=($(compgen -W '--bar' -- "$2"))
}
complete -F _foo_comp foo

# ~/.bashrc
source ~/foo_completion.sh
_fzf_setup_completion path foo

The crash is the two wrappers calling each other. On the second source your sed picks up _fzf_path_completion, while fzf has recorded _foo_comp as the original in _fzf_orig_completion_foo.