# bash/zsh completion support for core Git.

#

# Copyright (C) 2006,2007 Shawn O. Pearce <spearce@spearce.org>

# Conceptually based on gitcompletion (http://gitweb.hawaga.org.uk/).

# Distributed under the GNU General Public License, version 2.0.

#

# The contained completion routines provide support for completing:

#

# *) local and remote branch names

# *) local and remote tag names

# *) .git/remotes file names

# *) git 'subcommands'

# *) git email aliases for git-send-email

# *) tree paths within 'ref:path/to/file' expressions

# *) file paths within current working directory and index

# *) common --long-options

#

# To use these routines:

#

# 1) Copy this file to somewhere (e.g. ~/.git-completion.bash).

# 2) Add the following line to your .bashrc/.zshrc:

# source ~/.git-completion.bash

# 3) Consider changing your PS1 to also show the current branch,

# see git-prompt.sh for details.

#

# If you use complex aliases of form '!f() { ... }; f', you can use the null

# command ':' as the first command in the function body to declare the desired

# completion style. For example '!f() { : git commit ; ... }; f' will

# tell the completion to use commit completion. This also works with aliases

# of form "!sh -c '...'". For example, "!sh -c ': git commit ; ... '".

# Note that "git" is optional --- '!f() { : commit; ...}; f' would complete

# just like the 'git commit' command.

#

# To add completion for git subcommands that are implemented in external

# scripts, define a function of the form '_git_${subcommand}' while replacing

# all dashes with underscores, and the main git completion will make use of it.

# For example, to add completion for 'git do-stuff' (which could e.g. live

# in /usr/bin/git-do-stuff), name the completion function '_git_do_stuff'.

# See _git_show, _git_bisect etc. below for more examples.

#

# If you have a shell command that is not part of git (and is not called as a

# git subcommand), but you would still like git-style completion for it, use

# __git_complete. For example, to use the same completion as for 'git log' also

# for the 'gl' command:

#

# __git_complete gl git_log

#

# Or if the 'gk' command should be completed the same as 'gitk':

#

# __git_complete gk gitk

#

# The second parameter of __git_complete gives the completion function; it is

# resolved as a function named "$2", or "__$2_main", or "_$2" in that order.

# In the examples above, the actual functions used for completion will be

# _git_log and __gitk_main.

#

# Compatible with bash 3.2.57.

#

# You can set the following environment variables to influence the behavior of

# the completion routines:

#

# GIT_COMPLETION_CHECKOUT_NO_GUESS

#

# When set to "1", do not include "DWIM" suggestions in git-checkout

# and git-switch completion (e.g., completing "foo" when "origin/foo"

# exists).

#

# GIT_COMPLETION_SHOW_ALL_COMMANDS

#

# When set to "1" suggest all commands, including plumbing commands

# which are hidden by default (e.g. "cat-file" on "git ca<TAB>").

#

# GIT_COMPLETION_SHOW_ALL

#

# When set to "1" suggest all options, including options which are

# typically hidden (e.g. '--allow-empty' for 'git commit').

#

# GIT_COMPLETION_IGNORE_CASE

#

# When set, uses for-each-ref '--ignore-case' to find refs that match

# case insensitively, even on systems with case sensitive file systems

# (e.g., completing tag name "FOO" on "git checkout f<TAB>").

case "$COMP_WORDBREAKS" in

*:*) : great ;;

*) COMP_WORDBREAKS="$COMP_WORDBREAKS:"

esac

# Discovers the path to the git repository taking any '--git-dir=<path>' and

# '-C <path>' options into account and stores it in the $__git_repo_path

# variable.

__git_find_repo_path ()

{

if [ -n "${__git_repo_path-}" ]; then

# we already know where it is

return

fi

if [ -n "${__git_C_args-}" ]; then

__git_repo_path="$(git "${__git_C_args[@]}" \

${__git_dir:+--git-dir="$__git_dir"} \

rev-parse --absolute-git-dir 2>/dev/null)"

elif [ -n "${__git_dir-}" ]; then

test -d "$__git_dir" &&

__git_repo_path="$__git_dir"

elif [ -n "${GIT_DIR-}" ]; then

test -d "$GIT_DIR" &&

__git_repo_path="$GIT_DIR"

elif [ -d .git ]; then

__git_repo_path=.git

else

__git_repo_path="$(git rev-parse --git-dir 2>/dev/null)"

fi

}

# Deprecated: use __git_find_repo_path() and $__git_repo_path instead

# __gitdir accepts 0 or 1 arguments (i.e., location)

# returns location of .git repo

__gitdir ()

{

if [ -z "${1-}" ]; then

__git_find_repo_path || return 1

echo "$__git_repo_path"

elif [ -d "$1/.git" ]; then

echo "$1/.git"

else

echo "$1"

fi

}

# Runs git with all the options given as argument, respecting any

# '--git-dir=<path>' and '-C <path>' options present on the command line

__git ()

{

git ${__git_C_args:+"${__git_C_args[@]}"} \

${__git_dir:+--git-dir="$__git_dir"} "$@" 2>/dev/null

}

# Helper function to read the first line of a file into a variable.

# __git_eread requires 2 arguments, the file path and the name of the

# variable, in that order.

#

# This is taken from git-prompt.sh.

__git_eread ()

{

test -r "$1" && IFS=$'\r\n' read -r "$2" <"$1"

}

# Runs git in $__git_repo_path to determine whether a pseudoref exists.

# 1: The pseudo-ref to search

__git_pseudoref_exists ()

{

local ref=$1

local head

__git_find_repo_path

# If the reftable is in use, we have to shell out to 'git rev-parse'

# to determine whether the ref exists instead of looking directly in

# the filesystem to determine whether the ref exists. Otherwise, use

# Bash builtins since executing Git commands are expensive on some

# platforms.

if __git_eread "$__git_repo_path/HEAD" head; then

if [ "$head" == "ref: refs/heads/.invalid" ]; then

__git show-ref --exists "$ref"

return $?

fi

fi

[ -f "$__git_repo_path/$ref" ]

}

# Removes backslash escaping, single quotes and double quotes from a word,

# stores the result in the variable $dequoted_word.

# 1: The word to dequote.

__git_dequote ()

{

local rest="$1" len ch

dequoted_word=""

while test -n "$rest"; do

len=${#dequoted_word}

dequoted_word="$dequoted_word${rest%%[\\\'\"]*}"

rest="${rest:$((${#dequoted_word}-$len))}"

case "${rest:0:1}" in

\\)

ch="${rest:1:1}"

case "$ch" in

$'\n')

;;

*)

dequoted_word="$dequoted_word$ch"

;;

esac

rest="${rest:2}"

;;

\')

rest="${rest:1}"

len=${#dequoted_word}

dequoted_word="$dequoted_word${rest%%\'*}"

rest="${rest:$((${#dequoted_word}-$len+1))}"

;;

\")

rest="${rest:1}"

while test -n "$rest" ; do

len=${#dequoted_word}

dequoted_word="$dequoted_word${rest%%[\\\"]*}"

rest="${rest:$((${#dequoted_word}-$len))}"

case "${rest:0:1}" in

\\)

ch="${rest:1:1}"

case "$ch" in

\"|\\|\$|\`)

dequoted_word="$dequoted_word$ch"

;;

$'\n')

;;

*)

dequoted_word="$dequoted_word\\$ch"

;;

esac

rest="${rest:2}"

;;

\")

rest="${rest:1}"

break

;;

esac

done

;;

esac

done

}

# Prints the number of slash-separated components in a path.

# 1: Path to count components of.

__git_count_path_components ()

{

local path="$1"

local relative="${path#/}"

relative="${relative%/}"

local slashes="/${relative//[^\/]}"

echo "${#slashes}"

}

# The following function is based on code from:

#

# bash_completion - programmable completion functions for bash 3.2+

#

# Copyright © 2006-2008, Ian Macdonald <ian@caliban.org>

# © 2009-2010, Bash Completion Maintainers

# <bash-completion-devel@lists.alioth.debian.org>

#

# This program is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation; either version 2, or (at your option)

# any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, see <http://www.gnu.org/licenses/>.

#

# The latest version of this software can be obtained here:

#

# http://bash-completion.alioth.debian.org/

#

# RELEASE: 2.x

# This function can be used to access a tokenized list of words

# on the command line:

#

# __git_reassemble_comp_words_by_ref '=:'

# if test "${words_[cword_-1]}" = -w

# then

# ...

# fi

#

# The argument should be a collection of characters from the list of

# word completion separators (COMP_WORDBREAKS) to treat as ordinary

# characters.

#

# This is roughly equivalent to going back in time and setting

# COMP_WORDBREAKS to exclude those characters. The intent is to

# make option types like --date=<type> and <rev>:<path> easy to

# recognize by treating each shell word as a single token.

#

# It is best not to set COMP_WORDBREAKS directly because the value is

# shared with other completion scripts. By the time the completion

# function gets called, COMP_WORDS has already been populated so local

# changes to COMP_WORDBREAKS have no effect.

#

# Output: words_, cword_, cur_.

__git_reassemble_comp_words_by_ref()

{

local exclude i j first

# Which word separators to exclude?

exclude="${1//[^$COMP_WORDBREAKS]}"

cword_=$COMP_CWORD

if [ -z "$exclude" ]; then

words_=("${COMP_WORDS[@]}")

return

fi

# List of word completion separators has shrunk;

# re-assemble words to complete.

for ((i=0, j=0; i < ${#COMP_WORDS[@]}; i++, j++)); do

# Append each nonempty word consisting of just

# word separator characters to the current word.

first=t

while

[ $i -gt 0 ] &&

[ -n "${COMP_WORDS[$i]}" ] &&

# word consists of excluded word separators

[ "${COMP_WORDS[$i]//[^$exclude]}" = "${COMP_WORDS[$i]}" ]

do

# Attach to the previous token,

# unless the previous token is the command name.

if [ $j -ge 2 ] && [ -n "$first" ]; then

((j--))

fi

first=

words_[$j]=${words_[j]}${COMP_WORDS[i]}

if [ $i = $COMP_CWORD ]; then

cword_=$j

fi

if (($i < ${#COMP_WORDS[@]} - 1)); then

((i++))

else

# Done.

return

fi

done

words_[$j]=${words_[j]}${COMP_WORDS[i]}

if [ $i = $COMP_CWORD ]; then

cword_=$j

fi

done

}

if ! type _get_comp_words_by_ref >/dev/null 2>&1; then

_get_comp_words_by_ref ()

{

local exclude cur_ words_ cword_

if [ "$1" = "-n" ]; then

exclude=$2

shift 2

fi

__git_reassemble_comp_words_by_ref "$exclude"

cur_=${words_[cword_]}

while [ $# -gt 0 ]; do

case "$1" in

cur)

cur=$cur_

;;

prev)

prev=${words_[$cword_-1]}

;;

words)

words=("${words_[@]}")

;;

cword)

cword=$cword_

;;

esac

shift

done

}

fi

# Fills the COMPREPLY array with prefiltered words without any additional

# processing.

# Callers must take care of providing only words that match the current word

# to be completed and adding any prefix and/or suffix (trailing space!), if

# necessary.

# 1: List of newline-separated matching completion words, complete with

# prefix and suffix.

__gitcomp_direct ()

{

local IFS=$'\n'

COMPREPLY=($1)

}

# Similar to __gitcomp_direct, but appends to COMPREPLY instead.

# Callers must take care of providing only words that match the current word

# to be completed and adding any prefix and/or suffix (trailing space!), if

# necessary.

# 1: List of newline-separated matching completion words, complete with

# prefix and suffix.

__gitcomp_direct_append ()

{

local IFS=$'\n'

COMPREPLY+=($1)

}

__gitcompappend ()

{

local x i=${#COMPREPLY[@]}

for x in $1; do

if [[ "$x" == "$3"* ]]; then

COMPREPLY[i++]="$2$x$4"

fi

done

}

__gitcompadd ()

{

COMPREPLY=()

__gitcompappend "$@"

}

# Generates completion reply, appending a space to possible completion words,

# if necessary.

# It accepts 1 to 4 arguments:

# 1: List of possible completion words.

# 2: A prefix to be added to each possible completion word (optional).

# 3: Generate possible completion matches for this word (optional).

# 4: A suffix to be appended to each possible completion word (optional).

__gitcomp ()

{

local cur_="${3-$cur}"

case "$cur_" in

*=)

;;

--no-*)

local c i=0 IFS=$' \t\n'

for c in $1; do

if [[ $c == "--" ]]; then

continue

fi

c="$c${4-}"

if [[ $c == "$cur_"* ]]; then

case $c in

--*=|*.) ;;

*) c="$c " ;;

esac

COMPREPLY[i++]="${2-}$c"

fi

done

;;

*)

local c i=0 IFS=$' \t\n'

for c in $1; do

if [[ $c == "--" ]]; then

c="--no-...${4-}"

if [[ $c == "$cur_"* ]]; then

COMPREPLY[i++]="${2-}$c "

fi

break

fi

c="$c${4-}"

if [[ $c == "$cur_"* ]]; then

case $c in

*=|*.) ;;

*) c="$c " ;;

esac

COMPREPLY[i++]="${2-}$c"

fi

done

;;

esac

}

# Clear the variables caching builtins' options when (re-)sourcing

# the completion script.

if [[ -n ${ZSH_VERSION-} ]]; then

unset ${(M)${(k)parameters[@]}:#__gitcomp_builtin_*} 2>/dev/null

else

unset $(compgen -v __gitcomp_builtin_)

fi

# This function is equivalent to

#

# ___git_resolved_builtins=$(git xxx --git-completion-helper)

#

# except that the result of the execution is cached.

#

# Accept 1-3 arguments:

# 1: the git command to execute, this is also the cache key

# (use "_" when the command contains spaces, e.g. "remote add"

# becomes "remote_add")

# 2: extra options to be added on top (e.g. negative forms)

# 3: options to be excluded

__git_resolve_builtins ()

{

local cmd="$1"

local incl="${2-}"

local excl="${3-}"

local var=__gitcomp_builtin_"${cmd//-/_}"

local options

eval "options=\${$var-}"

if [ -z "$options" ]; then

local completion_helper

if [ "${GIT_COMPLETION_SHOW_ALL-}" = "1" ]; then

completion_helper="--git-completion-helper-all"

else

completion_helper="--git-completion-helper"

fi

# leading and trailing spaces are significant to make

# option removal work correctly.

options=" $incl $(__git ${cmd/_/ } $completion_helper) " || return

for i in $excl; do

options="${options/ $i / }"

done

eval "$var=\"$options\""

fi

___git_resolved_builtins="$options"

}

# This function is equivalent to

#

# __gitcomp "$(git xxx --git-completion-helper) ..."

#

# except that the output is cached. Accept 1-3 arguments:

# 1: the git command to execute, this is also the cache key

# (use "_" when the command contains spaces, e.g. "remote add"

# becomes "remote_add")

# 2: extra options to be added on top (e.g. negative forms)

# 3: options to be excluded

__gitcomp_builtin ()

{

__git_resolve_builtins "$1" "$2" "$3"

__gitcomp "$___git_resolved_builtins"

}

# Variation of __gitcomp_nl () that appends to the existing list of

# completion candidates, COMPREPLY.

__gitcomp_nl_append ()

{

local IFS=$'\n'

__gitcompappend "$1" "${2-}" "${3-$cur}" "${4- }"

}

# Generates completion reply from newline-separated possible completion words

# by appending a space to all of them.

# It accepts 1 to 4 arguments:

# 1: List of possible completion words, separated by a single newline.

# 2: A prefix to be added to each possible completion word (optional).

# 3: Generate possible completion matches for this word (optional).

# 4: A suffix to be appended to each possible completion word instead of

# the default space (optional). If specified but empty, nothing is

# appended.

__gitcomp_nl ()

{

COMPREPLY=()

__gitcomp_nl_append "$@"

}

# Fills the COMPREPLY array with prefiltered paths without any additional

# processing.

# Callers must take care of providing only paths that match the current path

# to be completed and adding any prefix path components, if necessary.

# 1: List of newline-separated matching paths, complete with all prefix

# path components.

__gitcomp_file_direct ()

{

local IFS=$'\n'

COMPREPLY=($1)

# use a hack to enable file mode in bash < 4

compopt -o filenames +o nospace 2>/dev/null ||

compgen -f /non-existing-dir/ >/dev/null ||

true

}

# Generates completion reply with compgen from newline-separated possible

# completion filenames.

# It accepts 1 to 3 arguments:

# 1: List of possible completion filenames, separated by a single newline.

# 2: A directory prefix to be added to each possible completion filename

# (optional).

# 3: Generate possible completion matches for this word (optional).

__gitcomp_file ()

{

local IFS=$'\n'

# XXX does not work when the directory prefix contains a tilde,

# since tilde expansion is not applied.

# This means that COMPREPLY will be empty and Bash default

# completion will be used.

__gitcompadd "$1" "${2-}" "${3-$cur}" ""

# use a hack to enable file mode in bash < 4

compopt -o filenames +o nospace 2>/dev/null ||

compgen -f /non-existing-dir/ >/dev/null ||

true

}

# Find the current subcommand for commands that follow the syntax:

#

# git <command> <subcommand>

#

# 1: List of possible subcommands.

# 2: Optional subcommand to return when none is found.

__git_find_subcommand ()

{

local subcommand subcommands="$1" default_subcommand="$2"

for subcommand in $subcommands; do

if [ "$subcommand" = "${words[__git_cmd_idx+1]}" ]; then

echo $subcommand

return

fi

done

echo $default_subcommand

}

# Execute 'git ls-files', unless the --committable option is specified, in

# which case it runs 'git diff-index' to find out the files that can be

# committed. It return paths relative to the directory specified in the first

# argument, and using the options specified in the second argument.

__git_ls_files_helper ()

{

if [ "$2" = "--committable" ]; then

__git -C "$1" -c core.quotePath=false diff-index \

--name-only --relative HEAD -- "${3//\\/\\\\}*"

else

# NOTE: $2 is not quoted in order to support multiple options

__git -C "$1" -c core.quotePath=false ls-files \

--exclude-standard $2 -- "${3//\\/\\\\}*"

fi

}

# __git_index_files accepts 1 or 2 arguments:

# 1: Options to pass to ls-files (required).

# 2: A directory path (optional).

# If provided, only files within the specified directory are listed.

# Sub directories are never recursed. Path must have a trailing

# slash.

# 3: List only paths matching this path component (optional).

__git_index_files ()

{

local root="$2" match="$3"

__git_ls_files_helper "$root" "$1" "${match:-?}" |

awk -F / -v pfx="${2//\\/\\\\}" '{

paths[$1] = 1

}

END {

for (p in paths) {

if (substr(p, 1, 1) != "\"") {

# No special characters, easy!

print pfx p

continue

}

# The path is quoted.

p = dequote(p)

if (p == "")

continue

# Even when a directory name itself does not contain

# any special characters, it will still be quoted if

# any of its (stripped) trailing path components do.

# Because of this we may have seen the same directory

# both quoted and unquoted.

if (p in paths)

# We have seen the same directory unquoted,

# skip it.

continue

else

print pfx p

}

}

function dequote(p, bs_idx, out, esc, esc_idx, dec) {

# Skip opening double quote.

p = substr(p, 2)

# Interpret backslash escape sequences.

while ((bs_idx = index(p, "\\")) != 0) {

out = out substr(p, 1, bs_idx - 1)

esc = substr(p, bs_idx + 1, 1)

p = substr(p, bs_idx + 2)

if ((esc_idx = index("abtvfr\"\\", esc)) != 0) {

# C-style one-character escape sequence.

out = out substr("\a\b\t\v\f\r\"\\",

esc_idx, 1)

} else if (esc == "n") {

# Uh-oh, a newline character.

# We cannot reliably put a pathname

# containing a newline into COMPREPLY,

# and the newline would create a mess.

# Skip this path.

return ""

} else {

# Must be a \nnn octal value, then.

dec = esc * 64 + \

substr(p, 1, 1) * 8 + \

substr(p, 2, 1)

out = out sprintf("%c", dec)

p = substr(p, 3)

}

}

# Drop closing double quote, if there is one.

# (There is not any if this is a directory, as it was

# already stripped with the trailing path components.)

if (substr(p, length(p), 1) == "\"")

out = out substr(p, 1, length(p) - 1)

else

out = out p

return out

}'

}

# __git_complete_index_file requires 1 argument:

# 1: the options to pass to ls-file

#

# The exception is --committable, which finds the files appropriate commit.

__git_complete_index_file ()

{

local dequoted_word pfx="" cur_

__git_dequote "$cur"

case "$dequoted_word" in

?*/*)

pfx="${dequoted_word%/*}/"

cur_="${dequoted_word##*/}"

;;

*)

cur_="$dequoted_word"

esac

__gitcomp_file_direct "$(__git_index_files "$1" "$pfx" "$cur_")"

}

# Lists branches from the local repository.

# 1: A prefix to be added to each listed branch (optional).

# 2: List only branches matching this word (optional; list all branches if

# unset or empty).

# 3: A suffix to be appended to each listed branch (optional).

__git_heads ()

{

local pfx="${1-}" cur_="${2-}" sfx="${3-}"

__git for-each-ref --format="${pfx//\%/%%}%(refname:strip=2)$sfx" \

${GIT_COMPLETION_IGNORE_CASE+--ignore-case} \

"refs/heads/$cur_*" "refs/heads/$cur_*/**"

}

# Lists branches from remote repositories.

# 1: A prefix to be added to each listed branch (optional).

# 2: List only branches matching this word (optional; list all branches if

# unset or empty).

# 3: A suffix to be appended to each listed branch (optional).

__git_remote_heads ()

{

local pfx="${1-}" cur_="${2-}" sfx="${3-}"

__git for-each-ref --format="${pfx//\%/%%}%(refname:strip=2)$sfx" \

${GIT_COMPLETION_IGNORE_CASE+--ignore-case} \

"refs/remotes/$cur_*" "refs/remotes/$cur_*/**"

}

# Lists tags from the local repository.

# Accepts the same positional parameters as __git_heads() above.

__git_tags ()

{

local pfx="${1-}" cur_="${2-}" sfx="${3-}"

__git for-each-ref --format="${pfx//\%/%%}%(refname:strip=2)$sfx" \

${GIT_COMPLETION_IGNORE_CASE+--ignore-case} \

"refs/tags/$cur_*" "refs/tags/$cur_*/**"

}

# List unique branches from refs/remotes used for 'git checkout' and 'git

# switch' tracking DWIMery.

# 1: A prefix to be added to each listed branch (optional)

# 2: List only branches matching this word (optional; list all branches if

# unset or empty).

# 3: A suffix to be appended to each listed branch (optional).

__git_dwim_remote_heads ()

{

local pfx="${1-}" cur_="${2-}" sfx="${3-}"

# employ the heuristic used by git checkout and git switch

# Try to find a remote branch that cur_es the completion word

# but only output if the branch name is unique

local awk_script='

function casemap(s) {

if (ENVIRON["IGNORE_CASE"])

return tolower(s)

else

return s

}

BEGIN {

split(ENVIRON["REMOTES"], remotes, /\n/)

for (i in remotes)

remotes[i] = "refs/remotes/" casemap(remotes[i])

cur_ = casemap(ENVIRON["CUR_"])

}

{

ref_case = casemap($0)

for (i in remotes) {

if (index(ref_case, remotes[i] "/" cur_) == 1) {

branch = substr($0, length(remotes[i] "/") + 1)

print ENVIRON["PFX"] branch ENVIRON["SFX"]

break

}

}

}

'

__git for-each-ref --format='%(refname)' refs/remotes/ |

PFX="$pfx" SFX="$sfx" CUR_="$cur_" \

IGNORE_CASE=${GIT_COMPLETION_IGNORE_CASE+1} \

REMOTES="$(__git_remotes | sort -r)" awk "$awk_script" |

sort | uniq -u

}

# Lists refs from the local (by default) or from a remote repository.

# It accepts 0, 1 or 2 arguments:

# 1: The remote to list refs from (optional; ignored, if set but empty).

# Can be the name of a configured remote, a path, or a URL.

# 2: In addition to local refs, list unique branches from refs/remotes/ for

# 'git checkout's tracking DWIMery (optional; ignored, if set but empty).

# 3: A prefix to be added to each listed ref (optional).

# 4: List only refs matching this word (optional; list all refs if unset or

# empty).

# 5: A suffix to be appended to each listed ref (optional; ignored, if set

# but empty).

#

# Use __git_complete_refs() instead.

__git_refs ()

{

local i hash dir track="${2-}"

local list_refs_from=path remote="${1-}"

local format refs

local pfx="${3-}" cur_="${4-$cur}" sfx="${5-}"

local match="${4-}"

local umatch="${4-}"

local fer_pfx="${pfx//\%/%%}" # "escape" for-each-ref format specifiers

__git_find_repo_path

dir="$__git_repo_path"

if [ -z "$remote" ]; then

if [ -z "$dir" ]; then

return

fi

else

if __git_is_configured_remote "$remote"; then

# configured remote takes precedence over a

# local directory with the same name

list_refs_from=remote

elif [ -d "$remote/.git" ]; then

dir="$remote/.git"

elif [ -d "$remote" ]; then

dir="$remote"

else

list_refs_from=url

fi

fi

if test "${GIT_COMPLETION_IGNORE_CASE:+1}" = "1"

then

# uppercase with tr instead of ${match,^^} for bash 3.2 compatibility

umatch=$(echo "$match" | tr a-z A-Z 2>/dev/null || echo "$match")

fi

if [ "$list_refs_from" = path ]; then

if [[ "$cur_" == ^* ]]; then

pfx="$pfx^"

fer_pfx="$fer_pfx^"

cur_=${cur_#^}

match=${match#^}

umatch=${umatch#^}

fi

case "$cur_" in

refs|refs/*)

format="refname"

refs=("$match*" "$match*/**")

track=""

;;

*)

for i in HEAD FETCH_HEAD ORIG_HEAD MERGE_HEAD REBASE_HEAD CHERRY_PICK_HEAD REVERT_HEAD BISECT_HEAD AUTO_MERGE; do

case "$i" in

$match*|$umatch*)

if [ -e "$dir/$i" ]; then

echo "$pfx$i$sfx"

fi

;;

esac

done

format="refname:strip=2"

refs=("refs/tags/$match*" "refs/tags/$match*/**"

"refs/heads/$match*" "refs/heads/$match*/**"

"refs/remotes/$match*" "refs/remotes/$match*/**")

;;

esac

__git_dir="$dir" __git for-each-ref --format="$fer_pfx%($format)$sfx" \

${GIT_COMPLETION_IGNORE_CASE+--ignore-case} \

"${refs[@]}"

if [ -n "$track" ]; then

__git_dwim_remote_heads "$pfx" "$match" "$sfx"

fi

return

fi

case "$cur_" in

refs|refs/*)

__git ls-remote "$remote" "$match*" | \

while read -r hash i; do

case "$i" in

*^{}) ;;

*) echo "$pfx$i$sfx" ;;

esac

done

;;

*)

if [ "$list_refs_from" = remote ]; then

case "HEAD" in

$match*|$umatch*) echo "${pfx}HEAD$sfx" ;;

esac

local strip="$(__git_count_path_components "refs/remotes/$remote")"

__git for-each-ref --format="$fer_pfx%(refname:strip=$strip)$sfx" \

${GIT_COMPLETION_IGNORE_CASE+--ignore-case} \

"refs/remotes/$remote/$match*" \

"refs/remotes/$remote/$match*/**"

else

local query_symref

case "HEAD" in

$match*|$umatch*) query_symref="HEAD" ;;

esac

__git ls-remote "$remote" $query_symref \

"refs/tags/$match*" "refs/heads/$match*" \

"refs/remotes/$match*" |

while read -r hash i; do

case "$i" in

*^{}) ;;

refs/*) echo "$pfx${i#refs/*/}$sfx" ;;

*) echo "$pfx$i$sfx" ;; # symbolic refs

esac

done

fi

;;

esac

}

# Completes refs, short and long, local and remote, symbolic and pseudo.

#

# Usage: __git_complete_refs [<option>]...

# --remote=<remote>: The remote to list refs from, can be the name of a

# configured remote, a path, or a URL.

# --dwim: List unique remote branches for 'git switch's tracking DWIMery.

# --pfx=<prefix>: A prefix to be added to each ref.

# --cur=<word>: The current ref to be completed. Defaults to the current

# word to be completed.

# --sfx=<suffix>: A suffix to be appended to each ref instead of the default

# space.

# --mode=<mode>: What set of refs to complete, one of 'refs' (the default) to

# complete all refs, 'heads' to complete only branches, or

# 'remote-heads' to complete only remote branches. Note that

# --remote is only compatible with --mode=refs.

__git_complete_refs ()

{

local remote= dwim= pfx= cur_="$cur" sfx=" " mode="refs"

while test $# != 0; do

case "$1" in

--remote=*) remote="${1##--remote=}" ;;

--dwim) dwim="yes" ;;

# --track is an old spelling of --dwim

--track) dwim="yes" ;;

--pfx=*) pfx="${1##--pfx=}" ;;

--cur=*) cur_="${1##--cur=}" ;;

--sfx=*) sfx="${1##--sfx=}" ;;

--mode=*) mode="${1##--mode=}" ;;

*) return 1 ;;

esac

shift

done

# complete references based on the specified mode

case "$mode" in

refs)

__gitcomp_direct "$(__git_refs "$remote" "" "$pfx" "$cur_" "$sfx")" ;;

heads)

__gitcomp_direct "$(__git_heads "$pfx" "$cur_" "$sfx")" ;;

remote-heads)

__gitcomp_direct "$(__git_remote_heads "$pfx" "$cur_" "$sfx")" ;;

*)

return 1 ;;

esac