Tab completion for command arguments fail in Cygwin due to `.exe` extension

bashcommand linecygwin;readlinetab completion

Is there a configuration option in Cygwin so that when Bash completes the name of the command, the filename’s .exe suffix is ignored (not included)?

Explanation of the problem

When using tab completion in Bash on a Cygwin system to complete the name of a command, the .exe extension is appended to the command name, e.g, typing opens and pressing Tab completes the command to openssl.exe.

The command runs fine (with MS Windows the .exe extension is optional when running a command) but the problem is that the _openssl() completion function provided by the bash-completion package is only configured to provide completions of arguments for openssl – not openssl.exe. For example:

$ complete -p openssl openssl.exe
complete -o default -F _openssl openssl
bash: complete: openssl.exe: no completion specification

The same issue exists when trying to complete arguments for all executable commands.

I currently use Bash with Emacs mode configured for Readline editing so I can press Esc followed by two Backspace presses to remove the .exe suffix before I start to type the arguments for the command. Ideally, I’d like to avoid having to do this every time I run a command.

What I’ve tried/researched

I figured that is probably not possible without modifying the source code of the Cygwin DLL or of Bash’s command completion (pcomplete.c). However, I notice that the Bash builtins, type and command automatically strip the .exe suffix from the names of executable files, e.g.,

$ type -a openssl
openssl is /usr/bin/openssl

$ command -v openssl
/usr/bin/openssl

It seems that Bash running in Cygwin has some mechanism for providing the bare command name (without the .exe extension). However, I’ve been at a loss as to how – or if – this can be used to omit the file extension when completing commands.

Best Answer

It turns out that there is a configuration option in Cygwin that configures Bash to not include a filename’s .exe extension when it completes the name of a command.

Enabling the completion_strip_exe option (specific to the Cygwin port of Bash) does what I want:

shopt -s completion_strip_exe

This feature is not very obviously documented: it gets a cursory mention in the Pathname Expansion section of the Cygwin man page for Bash (it is not included in the upstream source code so is not documented in the official man page or documentation for Bash). I came across it while perusing /usr/share/doc/Cygwin/bash.README (some 4 months after asking this question):

7b. using 'shopt -s completion_strip_exe' makes completion strip .exe suffixes.

It seems that this option has been available in Cygwin Bash for over 5 years:

----- version 4.1.9-1 -- 2010-12-29 -----
Add EXECIGNORE and completion_strip_exe patches from Dan Colascione.

Further research shows that the patch for this feature was submitted by Dan Colascione back in November 2010 with the following description:

completion_strip_exe is a new shell option. When enabled, bash tries to use the short name of a program instead of its longer ".-exe"-suffixed one. With this on, pin completes to "ping".

Many thanks to Dan Colascione (I've just sent him a personal email to thank him personally) for this feature and the Bash maintainers for providing such a great shell.

AllApplications

$ AllApplications -h

Created 03 March 2011 by Hank McShane
version 0.1
requires Mac OS X 10.4 or higher

Use this command line tool to get the path to all applications that can open a file from Launch Services.

Usage: AllApplications -path path/to/file

$ ext=png; f=/tmp/allapps.$ext; touch $f; AllApplications -path $f; rm $f
/Applications/Preview.app
/2/copies/Safari.app
/Applications/TeX/LaTeXiT.app
/Applications/WebKit.app
/Applications/Sequential.app
/Applications/ImageOptim.app
/Applications/Acorn.app
/Developer/Applications/Graphics Tools/Core Image Fun House.app
/2/copies/Preview.app
/Developer/Applications/Dashcode.app
/Applications/GraphicConverter.app
/Applications/Google Chrome.app
/Applications/Adobe Photoshop CS5/Adobe Photoshop CS5.app
/Applications/Utilities/QuickTime Player 7.app
/Applications/Utilities/ColorSync Utility.app
/Applications/Safari.app
/Applications/Adobe Device Central CS5/Adobe Device Central CS5.app
/Applications/Firefox.app

duti

$ duti -d public.png
com.apple.Preview
$ duti -l public.png
com.SequentialX.Sequential
com.flyingmeat.Acorn
net.pornel.ImageOptim
com.apple.system-library
com.apple.ColorSyncUtility
com.apple.Preview

(It's missing some apps that are displayed in the open with menu though.)

How to get bash to perform tab-completion for the aliases

The following code, adapted from this Stack Overflow answer and this Ubuntu Forums discussion thread will add completions for all your defined aliases:

# Automatically add completion for all aliases to commands having completion functions
function alias_completion {
    local namespace="alias_completion"

    # parse function based completion definitions, where capture group 2 => function and 3 => trigger
    local compl_regex='complete( +[^ ]+)* -F ([^ ]+) ("[^"]+"|[^ ]+)'
    # parse alias definitions, where capture group 1 => trigger, 2 => command, 3 => command arguments
    local alias_regex="alias ([^=]+)='(\"[^\"]+\"|[^ ]+)(( +[^ ]+)*)'"

    # create array of function completion triggers, keeping multi-word triggers together
    eval "local completions=($(complete -p | sed -Ene "/$compl_regex/s//'\3'/p"))"
    (( ${#completions[@]} == 0 )) && return 0

    # create temporary file for wrapper functions and completions
    rm -f "/tmp/${namespace}-*.tmp" # preliminary cleanup
    local tmp_file; tmp_file="$(mktemp "/tmp/${namespace}-${RANDOM}XXX.tmp")" || return 1

    local completion_loader; completion_loader="$(complete -p -D 2>/dev/null | sed -Ene 's/.* -F ([^ ]*).*/\1/p')"

    # read in "<alias> '<aliased command>' '<command args>'" lines from defined aliases
    local line; while read line; do
        eval "local alias_tokens; alias_tokens=($line)" 2>/dev/null || continue # some alias arg patterns cause an eval parse error
        local alias_name="${alias_tokens[0]}" alias_cmd="${alias_tokens[1]}" alias_args="${alias_tokens[2]# }"

        # skip aliases to pipes, boolean control structures and other command lists
        # (leveraging that eval errs out if $alias_args contains unquoted shell metacharacters)
        eval "local alias_arg_words; alias_arg_words=($alias_args)" 2>/dev/null || continue
        # avoid expanding wildcards
        read -a alias_arg_words <<< "$alias_args"

        # skip alias if there is no completion function triggered by the aliased command
        if [[ ! " ${completions[*]} " =~ " $alias_cmd " ]]; then
            if [[ -n "$completion_loader" ]]; then
                # force loading of completions for the aliased command
                eval "$completion_loader $alias_cmd"
                # 124 means completion loader was successful
                [[ $? -eq 124 ]] || continue
                completions+=($alias_cmd)
            else
                continue
            fi
        fi
        local new_completion="$(complete -p "$alias_cmd")"

        # create a wrapper inserting the alias arguments if any
        if [[ -n $alias_args ]]; then
            local compl_func="${new_completion/#* -F /}"; compl_func="${compl_func%% *}"
            # avoid recursive call loops by ignoring our own functions
            if [[ "${compl_func#_$namespace::}" == $compl_func ]]; then
                local compl_wrapper="_${namespace}::${alias_name}"
                    echo "function $compl_wrapper {
                        (( COMP_CWORD += ${#alias_arg_words[@]} ))
                        COMP_WORDS=($alias_cmd $alias_args \${COMP_WORDS[@]:1})
                        (( COMP_POINT -= \${#COMP_LINE} ))
                        COMP_LINE=\${COMP_LINE/$alias_name/$alias_cmd $alias_args}
                        (( COMP_POINT += \${#COMP_LINE} ))
                        $compl_func
                    }" >> "$tmp_file"
                    new_completion="${new_completion/ -F $compl_func / -F $compl_wrapper }"
            fi
        fi

        # replace completion trigger by alias
        new_completion="${new_completion% *} $alias_name"
        echo "$new_completion" >> "$tmp_file"
    done < <(alias -p | sed -Ene "s/$alias_regex/\1 '\2' '\3'/p")
    source "$tmp_file" && rm -f "$tmp_file"
}; alias_completion

For simple (command only, no arguments) aliases it will assign the original completion function to the alias; for aliases with arguments, it creates a wrapper function that inserts the extra arguments into the original completion function.

Unlike the scripts it has evolved from, the function respects quotes both for the alias command and its arguments (but the former have to be matched by the completion command, and cannot be nested), and it should reliably filter out aliases to command lists and pipes (which are skipped, as it is impossible to find out what to complete in them without re-creating the complete shell command line parsing logic).

Usage

Either save the code as a shell script file and source that in, or copy the function wholesale into, .bashrc (or your pertinent dot file). The important thing is to call the function after both bash completion and alias definitions have been set up (the code above calls the function right after its definition, in a “source and forget” spirit, but you can move the call anywhere downstream if that suits you better). If you don’t want the function in your environment after it exits, you can add unset -f alias_completion after calling it.

Notes

If you are using bash 4.1 or above and use dynamically-loaded completions, the script will attempt to load completions for all of your aliased commands so that it can build the wrapper functions for your aliases.