Bash – Tmux bash completion code walk-through

autocompletebash

if [[ $COMP_CWORD -le $cmd_index ]]; then
        # The user has not specified a command yet
        local all_commands="$(tmux -q list-commands | cut -f 1 -d ' ')"
        COMPREPLY=( ${COMPREPLY[@]:-} $(compgen -W "${all_commands}" -- "${cur}") )

I am trying to understand above code snippet for tmux bash autocompletion

compgen's W argument takes a word-list. But why does it taken an extra option -- with the current word, ${cur} as argument?

What does :- inside flower brackets mean?${COMPREPLY[@]:-}

When i do, tmux<tab>
the completion list displayed is same as $(tmux -q list-commands | cut -f 1 -d ' ').
So, why do we need ${COMPREPLY[@]:-} in the array beginning?

Best Answer

compgen -W "${all_commands}" -- "${cur}" runs compgen, passing it:

the option -W with one argument, the value of the variable all_commands;
one non-option argument, the value of the variable cur.

The -- argument marks the end of options. Even if the value of cur begins with a dash, it won't be interpreted as an option. This is an extremely common convention for command line option parsing.

${COMPREPLY[@]:-} is a weird one. It uses the parameter expansion construct ${VARIABLE:-TEXT}, which expands to the value of VARIABLE if set and non-empty and to TEXT otherwise, in a mostly pointless way. It takes the elements of the array COMPREPLY, except that if the array is empty or undefined, it results in an empty string. Then the result is split into words and each word is interpreted as a glob pattern. This is exactly equivalent to ${COMPREPLY[@]} except when COMPREPLY is not defined and set -u is in effect: under set -u, ${COMPREPLY[@]} would trigger an error if COMPREPLY is not defined. Note in particular that this instruction does not append to the COMPREPLY array, it mangles it. To append to the array, the right code would be

COMPREPLY+=($(compgen -W "${all_commands}" -- "${cur}") )

assuming that the output of compgen contains a whitespace-delimited list of glob patterns.

Related Solutions

Add arguments from previous command to zsh completion

You can add your completer to the list of completers used by default:

zstyle ':completion:*' completer _last_command_args _complete

Bash – Custom autocomplete: deal with spaces in filenames

Believe it might be better to use compgen instead of find in this case.

You probably already have a completion script with system. Try e.g.

locate bash_completion

On Debian variants this is probably:

/usr/share/bash-completion/bash_completion

where you find e.g. _filedir. So the simplest way then would be something in the direction of:

*)
    pushd "/some/path" >/dev/null
    _filedir
    popd >/dev/null

If that is not an option this could be a starter:

_comp_by_path()
{
    local opt cur dir
    local IFS=$'\n' x tmp
    local -a tokens

    opt="$1"
    cur="$2"
    dir="$3"

    # Enter target directory
    pushd "$dir" >/dev/null

    # Get directories, filtered against current
    [[ "$opt" != "-f" ]] && \
    x=$( compgen -d -- "$cur" ) &&
    while read -r tmp; do
        tokens+=( "$tmp" )
    done <<< "$x"

    # Get files, filtered against current
    [[ "$opt" != "-d" ]] && \
    x=$( compgen -f -- "$cur" ) &&
    while read -r tmp; do
        tokens+=( "$tmp" )
    done <<< "$x"

    # If anything found
    if [[ ${#tokens[@]} -ne 0 ]]; then
        # Make sure escaping is OK
        compopt -o filenames 2>/dev/null
        COMPREPLY+=( "${tokens[@]}" )
    fi

    # Go back
    popd >/dev/null
}

_GetOptMyCommand()
{
    local cur

    COMPREPLY=()
    cur="${COMP_WORDS[COMP_CWORD]}"

    case "$cur" in
    -*)
        COMPREPLY=( $( compgen -W "-h -l --help --list --" -- "$cur" ) );;
    *)
        _comp_by_path "any" "$cur" "/some/path"
    esac
}

complete -F _GetOptMyCommand my_command

A variant using find could be something in direction of this:

_zaso()
{
    local dir="$1"

    pushd "$dir" >/dev/null
    find * -maxdepth 0 2>/dev/null
    popd >/dev/null
}

_comp_with_find()
{
    local cur dir      
    local IFS=$'\n'

    cur="$1"
    dir="$2"

    compopt -o filenames 2>/dev/null
    COMPREPLY=( $( compgen -W "$(_zaso "$dir")" -- "$cur" ) );
}

Also note that printf in Bash has a %q option. So to generate quoted strings this is an option to play with:

find * -maxdepth 0 2>/dev/null && \
while read -r tmp; do
    printf "%q\n" "$tmp"
done <<< "$x"

Also not that file names can have newline characters in which a lot of this will break. Have not found a way to use \0 with compgen.

Best Answer

Related Solutions

Add arguments from previous command to zsh completion

Bash – Custom autocomplete: deal with spaces in filenames

Related Question