brew/Library/Contributions/brew_bash_completion.sh

# Bash completion script for brew(1)
#
# To use, add the following to your .bashrc:
#
#    . $(brew --repository)/Library/Contributions/brew_bash_completion.sh
#
# Alternatively, if you have installed the bash-completion package,
# you can create a symlink to this file in one of the following directories:
#
#    $(brew --prefix)/etc/bash_completion.d
#    $(brew --prefix)/share/bash-completion/completions
#
# and bash-completion will source it automatically.
#
# The __brew_ps1() function can be used to annotate your PS1 with
# Homebrew debugging information; it behaves similarly to the __git_ps1()
# function provided by the git's bash completion script.
#
# For example, the prompt string
#
#     PS1='\u@\h \W $(__brew_ps1 "(%s)") $'
#
# would result in a prompt like
#
#    user@hostname cwd $
#
# but if you are currently engaged in an interactive or debug install,
# (i.e., you invoked `brew install` with either '-i' or '-d'), then the
# prompt would look like
#
#     user@hostname cwd (<formula_name>|DEBUG) $
#
# You can customize the output string, e.g. $(__brew_ps1 "[%s]") would
# output "[<formula_name>|DEBUG]". The default (if you do not provide a
# format argument) is to print "(<formula_name>|DEBUG)" prefixed with a
# single space.

__brewcomp_words_include ()
{
    local i=1
    while [[ $i -lt $COMP_CWORD ]]; do
        if [[ "${COMP_WORDS[i]}" = "$1" ]]; then
            return 0
        fi
        i=$((++i))
    done
    return 1
}

# Find the previous non-switch word
__brewcomp_prev ()
{
    local idx=$((COMP_CWORD - 1))
    local prv="${COMP_WORDS[idx]}"
    while [[ $prv == -* ]]; do
        idx=$((--idx))
        prv="${COMP_WORDS[idx]}"
    done
    echo "$prv"
}

__brewcomp ()
{
    # break $1 on space, tab, and newline characters,
    # and turn it into a newline separated list of words
    local list s sep=$'\n' IFS=$' '$'\t'$'\n'
    local cur="${COMP_WORDS[COMP_CWORD]}"

    for s in $1; do
        __brewcomp_words_include "$s" && continue
        list="$list$s$sep"
    done

    IFS=$sep
    COMPREPLY=($(compgen -W "$list" -- "$cur"))
}

# Don't use __brewcomp() in any of the __brew_complete_foo functions, as
# it is too slow and is not worth it just for duplicate elimination.
__brew_complete_formulae ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local ff=$(\ls $(brew --repository)/Library/Formula 2>/dev/null | sed 's/\.rb//g')
    local af=$(\ls $(brew --repository)/Library/Aliases 2>/dev/null | sed 's/\.rb//g')
    local tf tap

    for dir in $(\ls $(brew --repository)/Library/Taps 2>/dev/null); do
        tap="$(echo "$dir" | sed 's|-|/|g')"
        tf="$tf $(\ls -1R "$(brew --repository)/Library/Taps/$dir" 2>/dev/null |
                  grep '.\+.rb' | sed -E 's|(.+)\.rb|'"${tap}"'/\1|g')"
    done

    COMPREPLY=($(compgen -W "$ff $af $tf" -- "$cur"))
}

__brew_complete_installed ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local inst=$(\ls $(brew --cellar))
    COMPREPLY=($(compgen -W "$inst" -- "$cur"))
}

__brew_complete_outdated ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local od=$(brew outdated --quiet)
    COMPREPLY=($(compgen -W "$od" -- "$cur"))
}

__brew_complete_tapped ()
{
    __brewcomp "$(\ls $(brew --repository)/Library/Taps 2>/dev/null | sed 's/-/\//g')"
}

__brew_complete_taps ()
{
    if [[ -z "$__brew_cached_taps" ]]; then
        __brew_cached_taps="$(/usr/bin/ruby -e '
            require "open-uri"
            require "yaml"

            begin
              uri = URI.parse("http://github.com/api/v2/yaml/repos/search/homebrew")

              open uri do |f|
                YAML::load(f.read)["repositories"].each do |repo|
                  if repo[:name] =~ /^homebrew-(\w+)$/
                    puts tap = if repo[:username] == "Homebrew"
                      "homebrew/#{$1}"
                    else
                      repo[:username]+"/"+$1
                    end
                  end
                end
              end
            rescue
              nil
            end
        ' 2>/dev/null)"
    fi

    __brewcomp "$__brew_cached_taps"
}

_brew_cleanup ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    case "$cur" in
    --*)
        __brewcomp "--force"
        return
        ;;
    esac
    __brew_complete_installed
}

_brew_create ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    case "$cur" in
    --*)
        __brewcomp "--autotools --cmake --no-fetch"
        return
        ;;
    esac
}

_brew_deps ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    case "$cur" in
    --*)
        __brewcomp "--1 --all --tree"
        return
        ;;
    esac
    __brew_complete_formulae
}

_brew_diy ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    case "$cur" in
    --*)
        __brewcomp "--set-name --set-version"
        return
        ;;
    esac
}

_brew_fetch ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    case "$cur" in
    --*)
        __brewcomp "--deps --force --HEAD"
        return
        ;;
    esac
    __brew_complete_formulae
}

_brew_info ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    case "$cur" in
    --*)
        __brewcomp "--all --github"
        return
        ;;
    esac
    __brew_complete_formulae
}

_brew_install ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    local prv=$(__brewcomp_prev)

    case "$cur" in
    --*)
        if __brewcomp_words_include "--interactive"; then
            __brewcomp "
                --devel
                --force
                --git
                --HEAD
                --use-clang
                --use-gcc
                --use-llvm
                "
        else
            __brewcomp "
                --build-from-source
                --debug
                --devel
                --force
                --fresh
                --HEAD
                --ignore-dependencies
                --interactive
                --use-clang
                --use-gcc
                --use-llvm
                --verbose
                $(brew options --compact "$prv")
                "
        fi
        return
        ;;
    esac
    __brew_complete_formulae
}

_brew_list ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    case "$cur" in
    --*)
        # options to brew-list are mutually exclusive
        if __brewcomp_words_include "--unbrewed"; then
            return
        elif __brewcomp_words_include "--verbose"; then
            return
        elif __brewcomp_words_include "--versions"; then
            return
        else
            __brewcomp "--unbrewed --verbose --versions"
            return
        fi
        ;;
    esac
    __brew_complete_installed
}

_brew_log ()
{
    # if git-completion is loaded, then we complete git-log options
    declare -F _git_log >/dev/null || return
    local cur="${COMP_WORDS[COMP_CWORD]}"
    case "$cur" in
    --*)
        __brewcomp "
            $__git_log_common_options
            $__git_log_shortlog_options
            $__git_log_gitk_options
            $__git_diff_common_options
            --walk-reflogs --graph --decorate
            --abbrev-commit --oneline --reverse
            "
        return
        ;;
    esac
    __brew_complete_formulae
}

_brew_options ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    case "$cur" in
    --*)
        __brewcomp "--all --compact --installed"
        return
        ;;
    esac
    __brew_complete_formulae
}

_brew_outdated ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    case "$cur" in
    --*)
        __brewcomp "--quiet"
        return
        ;;
    esac
}

_brew_search ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    case "$cur" in
    --*)
        __brewcomp "--fink --macports"
        return
        ;;
    esac
}

_brew_uninstall ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    case "$cur" in
    --*)
        __brewcomp "--force"
        return
        ;;
    esac
    __brew_complete_installed
}

_brew_update ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    case "$cur" in
    --*)
        __brewcomp "--rebase --verbose"
        return
        ;;
    esac
}

_brew_uses ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    case "$cur" in
    --*)
        __brewcomp "--installed"
        return
        ;;
    esac
    __brew_complete_formulae
}

_brew_versions ()
{
    local cur="${COMP_WORDS[COMP_CWORD]}"
    case "$cur" in
    --*)
        __brewcomp "--compact"
        return
        ;;
    esac
    __brew_complete_formulae
}

__brew_ps1 ()
{
    [[ -n $HOMEBREW_DEBUG_INSTALL ]] &&
    printf "${1:- (%s)}" "$HOMEBREW_DEBUG_INSTALL|DEBUG"
}

_brew ()
{
    local i=1 cmd

    # find the subcommand
    while [[ $i -lt $COMP_CWORD ]]; do
        local s="${COMP_WORDS[i]}"
        case "$s" in
        --*)
            cmd="$s"
            break
            ;;
        -*)
            ;;
        *)
            cmd="$s"
            break
            ;;
        esac
        i=$((++i))
    done

    if [[ $i -eq $COMP_CWORD ]]; then
        local ext=$(\ls $(brew --repository)/Library/Contributions/cmds \
                2>/dev/null | sed -e "s/\.rb//g" -e "s/brew-//g")
        __brewcomp "
            --cache --cellar --config
            --env --prefix --repository
            audit
            cat
            cleanup
            create
            deps
            diy configure
            doctor
            edit
            fetch
            help
            home
            info abv
            install
            link ln
            list ls
            log
            options
            outdated
            prune
            search
            tap
            test
            uninstall remove rm
            unlink
            untap
            update
            upgrade
            uses
            versions
            $ext
            "
        return
    fi

    # subcommands have their own completion functions
    case "$cmd" in
    --cache|--cellar|--prefix)  __brew_complete_formulae ;;
    audit|cat|edit|home)        __brew_complete_formulae ;;
    link|ln|test|unlink)        __brew_complete_installed ;;
    upgrade)                    __brew_complete_outdated ;;
    cleanup)                    _brew_cleanup ;;
    create)                     _brew_create ;;
    deps)                       _brew_deps ;;
    diy|configure)              _brew_diy ;;
    fetch)                      _brew_fetch ;;
    info|abv)                   _brew_info ;;
    install)                    _brew_install ;;
    list|ls)                    _brew_list ;;
    log)                        _brew_log ;;
    options)                    _brew_options ;;
    outdated)                   _brew_outdated ;;
    search|-S)                  _brew_search ;;
    tap)                        __brew_complete_taps ;;
    uninstall|remove|rm)        _brew_uninstall ;;
    untap)                      __brew_complete_tapped ;;
    update)                     _brew_update ;;
    uses)                       _brew_uses ;;
    versions)                   _brew_versions ;;
    *)                          ;;
    esac
}

# keep around for compatibility
_brew_to_completion ()
{
    _brew
}

complete -o bashdefault -o default -F _brew brew