Can a bash script include its own auto-completions?

Question

There are many resources available (1, 2, 3) that explain how to make use of bash's ability to auto-complete commands and arguments, but all of these resources require the addition of code to a user's ~/.bash_profile or /etc/bash_completion.d/* but is there a way to make a script and its available completions self-contained? As a crude and incomplete example:

~/bin/script-with-integrated-autocomplete.sh:

#!/usr/bin/env bash

function _completions {
  complete ...
}

if [ "$1" == "completions" ]; then
  _completions
  exit 0
fi

# (Whatever the script really does goes here.)
# ...
# ...

The deal-breaker (in the context of this question) is that the above example still requires you to add something like ~/bin/script-with-integrated-autocomplete.sh completions to your .profile to engage the completions.

Is there a way for a single bash script (file) to declare its own completions and have bash recognize them at the time of invocation (ideally with no additional system or environment setup)?

Answer 1

As stated in comments to your question, Bash cannot complete the command line for a command without any previous configuration and without changing the current environment. Bash does not peek into files, nor it tries to interpret them unless you explicitly execute or source them.

My read on the subject is that such a feature is unlikely to make its way into Bash anytime soon, because of compatibility and resources concerns—as a shell, it is meant to reliably run on a variety of different systems, with a variety of purposes and adapting to the preferences of a variety of users; and it has only one person as developer and maintainer¹.

While Bash provides the tools to implement autocompletion, completion generators seem to be by design intended as external facilities. And indeed what you are looking for can be easily implemented with the existing tools and a small amount of work.

Given the sample script foo:

#!/bin/bash

# Setting up completion for foo. Only if the script is sourced
if [ "$0" != "$BASH_SOURCE" ]; then
    _foo() {
        local cur
        COMPREPLY=()
        cur="${COMP_WORDS[COMP_CWORD]}"
        COMPREPLY=( $(compgen -W 'bar baz' -- "$cur") )
        return 0
    }
    complete -F "_foo" "foo"
    return
fi

# The body of foo -- what it does when executed
echo foo "$*"
# ...

using bash-completion, self-contained autocompletion can be enabled by adding a symbolic link to foo to the directory that stores dynamically loaded user completions:

ln -s /path/to/foo ~/.local/share/bash-completion/completions/

The exact path may vary, you can refer to bash-completion's FAQ for how to check its value on your system.

Without bash-completion, one approach could be to define a default completion function that sources (files corresponding to) commands if they meet certain conditions; here we are using an associative array as a whitelist (to avoid blindly sourcing every command on the system). This code has to be added to your .bashrc (or equivalent, i.e. a file that is sourced in the current environment every time an interactive shell is started):

_default_completion () {
    # Do nothing when completion is invoked for an empty command
    if [ "$1" = "" ]; then
        return 1
    fi
    # Get the command path, exit with failure if it can't be found
    cmd=$(type -p "$1") || return 1
    if [ "${_compwhitelist["${cmd##*/}"]}" = y ]; then
        # Source the file corresponding to the command; on success,
        # return 124 to trigger a new autocompletion attempt
        source "$cmd" && return 124
    fi
}
complete -D -F _default_completion -o bashdefault -o default

# The list of commands with embedded completion
declare -A _compwhitelist
_compwhitelist[foo]=y

I know, you asked for a solution that didn't require to edit configuration files, but please note that a certain amount of configuration is always required. A substantial part of it is done by distribution/package maintainers, even if users may never come to realize it.

¹ _{Reference: the Bash home page on Chet Ramey's website and point "A1" in the related Bash FAQ.}

Answer 2

Yes, it can. All you need to do is to check if the environment variable COMP_LINE is set and then simply echo out all the auto-complete options that should be available. One line per option and then exit the script. The script does not even need to be a shell script. Can be anything, Python, PHP, Golang whatever.

Pseudo-code:

if COMP_LINE {
  echo "Foo"
  echo "Bar"
  Exit 0
}

//Rest of the script here

Then simply add your script to the shells auto-complete rules with:

complete -C /usr/bin/the_script.sh the_script.sh

Now, after typing "the_script.sh <tab> <tab>", it will show the "foo, bar" options.

Answer 3

Open your shell and type asdfasdf Tab you will see that it autocompletes with a list of files in the $CWD.

If you can find the "default completion" that is called for that and make a wrapper for it, a single modification would work for all scripts.

The wrapper could do a check for embedded completion, then fallback to the original completion. All scripts would have to follow whatever standard you come up with. I think responding to COMP_LINE or COMP_WORDS env vars would be a pretty good choice.

Seems like this should have already been done by someone. I never assume my ideas are groundbreaking.