brew/Library/Homebrew/completions/bash.erb

<%
# To make changes to the completions:
#
# - For changes to a command under `COMMANDS` or `DEVELOPER COMMANDS` sections):
#   - Find the source file in `Library/Homebrew/[dev-]cmd/<command>.{rb,sh}`.
#   - For `.rb` files, edit the `<command>_args` method.
#   - For `.sh` files, edit the top comment, being sure to use the line prefix
#     `#:` for the comments to be recognized as documentation. If in doubt,
#     compare with already documented commands.
# - For other changes: Edit this file.
#
# When done, regenerate the completions by running `brew man`.
%>
# Bash completion script for brew(1)

__brewcomp_words_include() {
  local i=1
  while [[ "$i" -lt "$COMP_CWORD" ]]
  do
    if [[ "${COMP_WORDS[i]}" = "$1" ]]
    then
      return 0
    fi
    (( 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-- ))
    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"
  while read -r line; do COMPREPLY+=("$line"); done < <(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 formulae
  formulae="$(brew formulae)"
  while read -r line; do COMPREPLY+=("$line"); done < <(compgen -W "$formulae" -- "$cur")
}

__brew_complete_casks() {
  local cur="${COMP_WORDS[COMP_CWORD]}"
  local casks
  casks="$(brew casks)"
  while read -r line; do COMPREPLY+=("$line"); done < <(compgen -W "$casks" -- "$cur")
}

__brew_complete_installed_formulae() {
  local cur="${COMP_WORDS[COMP_CWORD]}"
  local installed_formulae
  installed_formulae="$(command ls "$(brew --cellar)" 2>/dev/null)"
  while read -r line; do COMPREPLY+=("$line"); done < <(compgen -W "$installed_formulae" -- "$cur")
}

__brew_complete_installed_casks() {
  local cur="${COMP_WORDS[COMP_CWORD]}"
  local installed_casks
  installed_casks="$(command ls "$(brew --caskroom)" 2>/dev/null)"
  while read -r line; do COMPREPLY+=("$line"); done < <(compgen -W "$installed_casks" -- "$cur")
}

__brew_complete_outdated_formulae() {
  local cur="${COMP_WORDS[COMP_CWORD]}"
  local outdated_formulae
  outdated_formulae="$(brew outdated --formula --quiet)"
  while read -r line; do COMPREPLY+=("$line"); done < <(compgen -W "$outdated_formulae" -- "$cur")
}

__brew_complete_outdated_casks() {
  local cur="${COMP_WORDS[COMP_CWORD]}"
  local outdated_casks
  outdated_casks="$(brew outdated --cask --quiet)"
  while read -r line; do COMPREPLY+=("$line"); done < <(compgen -W "$outdated_casks" -- "$cur")
}

__brew_complete_tapped() {
  local dir taps taplib
  taplib="$(brew --repository)/Library/Taps"

  for dir in "$taplib"/*/*
  do
    [[ -d "$dir" ]] || continue
    dir="${dir#${taplib}/}"
    dir="${dir/homebrew-/}"
    taps="$taps $dir"
  done
  __brewcomp "$taps"
}

__brew_complete_commands() {
  local cur="${COMP_WORDS[COMP_CWORD]}"
  local cmds
  HOMEBREW_CACHE=$(brew --cache)
  HOMEBREW_REPOSITORY=$(brew --repo)
  # Do not auto-complete "*instal" or "*uninstal" aliases for "*install" commands.
  if [[ -f "$HOMEBREW_CACHE/all_commands_list.txt" ]]
  then
    cmds="$(< "$HOMEBREW_CACHE/all_commands_list.txt" \grep -v instal$)"
  else
    cmds="$(< "$HOMEBREW_REPOSITORY/completions/internal_commands_list.txt" \grep -v instal$)"
  fi
  while read -r line; do COMPREPLY+=("$line"); done < <(compgen -W "$cmds" -- "$cur")
}

# compopt is only available in newer versions of bash
__brew_complete_files() {
  command -v compopt &> /dev/null && compopt -o default
}

<%= completion_functions.join("\n") %>

_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++ ))
  done

  if [[ "$i" -eq "$COMP_CWORD" ]]
  then
    __brew_complete_commands
    return
  fi

  # subcommands have their own completion functions
  case "$cmd" in
    <%= function_mappings.join("\n    ").concat("\n") %>
    *) ;;
  esac
}

# keep around for compatibility
_brew_to_completion() {
  _brew
}

complete -o bashdefault -o default -F _brew brew