Bash – set -x: tab completion results in messy output when working in debug mode

autocompletebashdebuggingoutputUbuntu

I understand that set -x gets a Bash user into debug mode and I feel that working full time in debug mode will help me handle possible problems better in Bash.

I experience a problem when working with set -x:

When I try to use the native tab completion of my distro (Ubuntu 16.04) to complete a directory's name, I get a very long, messy output.

For example, $PWD is /var/www/html/ and I run either of these:

cd ~/u[tab completion to complete u to ulcwe]

cd ~ && cd u[tab completion to complete u to ulcwe]

In both examples I'll get a very long and messy output:

+ return 0
+ local -a toks
+ local quoted x tmp
+ _quote_readline_by_ref '~/u' quoted
+ '[' -z '~/u' ']'
+ [[ ~/u == \'* ]]
+ [[ ~/u == \~* ]]
+ printf -v quoted '~%q' /u
+ [[ ~/u == *\\* ]]
+ [[ ~/u == \$* ]]
++ compgen -d -- '~/u'
+ x='~/ulcwe'
+ read -r tmp
+ toks+=("$tmp")
+ read -r tmp
+ [[ -d != -d ]]
+ [[ -n '' ]]
+ [[ 1 -ne 0 ]]
+ compopt -o filenames
+ COMPREPLY+=("${toks[@]}")
+ return 0
lcwe/

Note the lcwe in the end.

The above output is just part of a much larger output.

How could I keep working in debug mode full time (set -x) but without all that output when performing tab completion?

Best Answer

This is due to the programmable completion feature of the shell that you are using.

If you're happy with basic tab completion for commands and filenames in bash, then running

complete -r

in your ~/.bashrc will remove any "fancy" (programmable) completion that involves calling functions etc. in the current shell's environment.

Basic filename completion (like what you're doing in the examples in your question) will still work after turning off programmable completion.

Programmable completion is available in some shells and allows one to hook up callback functions that examine the state of the command line etc. to figure out what the possible strings that the user might want to insert next might be. For example, typing ssh and then Space and Tab may invoke a function that parses your ~/.ssh/config file for possible hostnames to connect to, or typing git checkout and then Space and Tab may cause a function to run a git command to figure out what branches are available in the current repository.

Some users rely on programmable completions for speed and/or productivity reasons, but yes, if you have set -x active in the interactive shell session, these actions would produce trace output in the terminal.

I've never been a friend of programmable completion in any shell as I don't want a simple Tab press to do "magic behind my back" in all sorts of interesting ways. I also think it's a bit lazy, but that's definitely only my personal opinion.

Related Solutions

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.

Bash – Force Bash normal tab completion if intelligent completion fails

The following should turn on normal bash completion after all 'intelligent' completions have failed for the programs tar, vim and emacs:

compopt -o bashdefault tar vim emacs

see also the relevant page in the online bash manual.

Caveat: you get the normal behavior for the type of completion (commands/filenames/usernames etc.) defined by the intelligent completion for the command at hand, for example, the completion for service will not complete filenames even if you call complete -o bashdefault service.

In this and other cases where the intelligent autocompletion fails, you can always press Alt-/ (or M-/ in the bash manual's notation) to complete filenames almost in the same way that TAB works if intelligent completion is disabled (almost the same way in the sense that M-/ does not complete patterns like *.txt). See here for key sequences for other types of completions such as command and usernames.

Best Answer

Related Solutions

Bash – Custom autocomplete: deal with spaces in filenames

Bash – Force Bash normal tab completion if intelligent completion fails

Related Question