<%
# 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 generate-man-completions`.
%>
# 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
