contrib/completion/git-completion.bash

   1 # bash/zsh completion support for core Git.
   2 #
   3 # Copyright (C) 2006,2007 Shawn O. Pearce <spearce@spearce.org>
   4 # Conceptually based on gitcompletion (http://gitweb.hawaga.org.uk/).
   5 # Distributed under the GNU General Public License, version 2.0.
   6 #
   7 # The contained completion routines provide support for completing:
   8 #
   9 #    *) local and remote branch names
  10 #    *) local and remote tag names
  11 #    *) .git/remotes file names
  12 #    *) git 'subcommands'
  13 #    *) git email aliases for git-send-email
  14 #    *) tree paths within 'ref:path/to/file' expressions
  15 #    *) file paths within current working directory and index
  16 #    *) common --long-options
  17 #
  18 # To use these routines:
  19 #
  20 #    1) Copy this file to somewhere (e.g. ~/.git-completion.bash).
  21 #    2) Add the following line to your .bashrc/.zshrc:
  22 #        source ~/.git-completion.bash
  23 #    3) Consider changing your PS1 to also show the current branch,
  24 #       see git-prompt.sh for details.
  25 #
  26 # If you use complex aliases of form '!f() { ... }; f', you can use the null
  27 # command ':' as the first command in the function body to declare the desired
  28 # completion style.  For example '!f() { : git commit ; ... }; f' will
  29 # tell the completion to use commit completion.  This also works with aliases
  30 # of form "!sh -c '...'".  For example, "!sh -c ': git commit ; ... '".
  31 #
  32 # Compatible with bash 3.2.57.
  33 #
  34 # You can set the following environment variables to influence the behavior of
  35 # the completion routines:
  36 #
  37 #   GIT_COMPLETION_CHECKOUT_NO_GUESS
  38 #
  39 #     When set to "1", do not include "DWIM" suggestions in git-checkout
  40 #     completion (e.g., completing "foo" when "origin/foo" exists).
  41
  42 case "$COMP_WORDBREAKS" in
  43 *:*) : great ;;
  44 *)   COMP_WORDBREAKS="$COMP_WORDBREAKS:"
  45 esac
  46
  47 # Discovers the path to the git repository taking any '--git-dir=<path>' and
  48 # '-C <path>' options into account and stores it in the $__git_repo_path
  49 # variable.
  50 __git_find_repo_path ()
  51 {
  52         if [ -n "$__git_repo_path" ]; then
  53                 # we already know where it is
  54                 return
  55         fi
  56
  57         if [ -n "${__git_C_args-}" ]; then
  58                 __git_repo_path="$(git "${__git_C_args[@]}" \
  59                         ${__git_dir:+--git-dir="$__git_dir"} \
  60                         rev-parse --absolute-git-dir 2>/dev/null)"
  61         elif [ -n "${__git_dir-}" ]; then
  62                 test -d "$__git_dir" &&
  63                 __git_repo_path="$__git_dir"
  64         elif [ -n "${GIT_DIR-}" ]; then
  65                 test -d "${GIT_DIR-}" &&
  66                 __git_repo_path="$GIT_DIR"
  67         elif [ -d .git ]; then
  68                 __git_repo_path=.git
  69         else
  70                 __git_repo_path="$(git rev-parse --git-dir 2>/dev/null)"
  71         fi
  72 }
  73
  74 # Deprecated: use __git_find_repo_path() and $__git_repo_path instead
  75 # __gitdir accepts 0 or 1 arguments (i.e., location)
  76 # returns location of .git repo
  77 __gitdir ()
  78 {
  79         if [ -z "${1-}" ]; then
  80                 __git_find_repo_path || return 1
  81                 echo "$__git_repo_path"
  82         elif [ -d "$1/.git" ]; then
  83                 echo "$1/.git"
  84         else
  85                 echo "$1"
  86         fi
  87 }
  88
  89 # Runs git with all the options given as argument, respecting any
  90 # '--git-dir=<path>' and '-C <path>' options present on the command line
  91 __git ()
  92 {
  93         git ${__git_C_args:+"${__git_C_args[@]}"} \
  94                 ${__git_dir:+--git-dir="$__git_dir"} "$@" 2>/dev/null
  95 }
  96
  97 # Removes backslash escaping, single quotes and double quotes from a word,
  98 # stores the result in the variable $dequoted_word.
  99 # 1: The word to dequote.
 100 __git_dequote ()
 101 {
 102         local rest="$1" len ch
 103
 104         dequoted_word=""
 105
 106         while test -n "$rest"; do
 107                 len=${#dequoted_word}
 108                 dequoted_word="$dequoted_word${rest%%[\\\'\"]*}"
 109                 rest="${rest:$((${#dequoted_word}-$len))}"
 110
 111                 case "${rest:0:1}" in
 112                 \\)
 113                         ch="${rest:1:1}"
 114                         case "$ch" in
 115                         $'\n')
 116                                 ;;
 117                         *)
 118                                 dequoted_word="$dequoted_word$ch"
 119                                 ;;
 120                         esac
 121                         rest="${rest:2}"
 122                         ;;
 123                 \')
 124                         rest="${rest:1}"
 125                         len=${#dequoted_word}
 126                         dequoted_word="$dequoted_word${rest%%\'*}"
 127                         rest="${rest:$((${#dequoted_word}-$len+1))}"
 128                         ;;
 129                 \")
 130                         rest="${rest:1}"
 131                         while test -n "$rest" ; do
 132                                 len=${#dequoted_word}
 133                                 dequoted_word="$dequoted_word${rest%%[\\\"]*}"
 134                                 rest="${rest:$((${#dequoted_word}-$len))}"
 135                                 case "${rest:0:1}" in
 136                                 \\)
 137                                         ch="${rest:1:1}"
 138                                         case "$ch" in
 139                                         \"|\\|\$|\`)
 140                                                 dequoted_word="$dequoted_word$ch"
 141                                                 ;;
 142                                         $'\n')
 143                                                 ;;
 144                                         *)
 145                                                 dequoted_word="$dequoted_word\\$ch"
 146                                                 ;;
 147                                         esac
 148                                         rest="${rest:2}"
 149                                         ;;
 150                                 \")
 151                                         rest="${rest:1}"
 152                                         break
 153                                         ;;
 154                                 esac
 155                         done
 156                         ;;
 157                 esac
 158         done
 159 }
 160
 161 # The following function is based on code from:
 162 #
 163 #   bash_completion - programmable completion functions for bash 3.2+
 164 #
 165 #   Copyright © 2006-2008, Ian Macdonald <ian@caliban.org>
 166 #             © 2009-2010, Bash Completion Maintainers
 167 #                     <bash-completion-devel@lists.alioth.debian.org>
 168 #
 169 #   This program is free software; you can redistribute it and/or modify
 170 #   it under the terms of the GNU General Public License as published by
 171 #   the Free Software Foundation; either version 2, or (at your option)
 172 #   any later version.
 173 #
 174 #   This program is distributed in the hope that it will be useful,
 175 #   but WITHOUT ANY WARRANTY; without even the implied warranty of
 176 #   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 177 #   GNU General Public License for more details.
 178 #
 179 #   You should have received a copy of the GNU General Public License
 180 #   along with this program; if not, see <http://www.gnu.org/licenses/>.
 181 #
 182 #   The latest version of this software can be obtained here:
 183 #
 184 #   http://bash-completion.alioth.debian.org/
 185 #
 186 #   RELEASE: 2.x
 187
 188 # This function can be used to access a tokenized list of words
 189 # on the command line:
 190 #
 191 #       __git_reassemble_comp_words_by_ref '=:'
 192 #       if test "${words_[cword_-1]}" = -w
 193 #       then
 194 #               ...
 195 #       fi
 196 #
 197 # The argument should be a collection of characters from the list of
 198 # word completion separators (COMP_WORDBREAKS) to treat as ordinary
 199 # characters.
 200 #
 201 # This is roughly equivalent to going back in time and setting
 202 # COMP_WORDBREAKS to exclude those characters.  The intent is to
 203 # make option types like --date=<type> and <rev>:<path> easy to
 204 # recognize by treating each shell word as a single token.
 205 #
 206 # It is best not to set COMP_WORDBREAKS directly because the value is
 207 # shared with other completion scripts.  By the time the completion
 208 # function gets called, COMP_WORDS has already been populated so local
 209 # changes to COMP_WORDBREAKS have no effect.
 210 #
 211 # Output: words_, cword_, cur_.
 212
 213 __git_reassemble_comp_words_by_ref()
 214 {
 215         local exclude i j first
 216         # Which word separators to exclude?
 217         exclude="${1//[^$COMP_WORDBREAKS]}"
 218         cword_=$COMP_CWORD
 219         if [ -z "$exclude" ]; then
 220                 words_=("${COMP_WORDS[@]}")
 221                 return
 222         fi
 223         # List of word completion separators has shrunk;
 224         # re-assemble words to complete.
 225         for ((i=0, j=0; i < ${#COMP_WORDS[@]}; i++, j++)); do
 226                 # Append each nonempty word consisting of just
 227                 # word separator characters to the current word.
 228                 first=t
 229                 while
 230                         [ $i -gt 0 ] &&
 231                         [ -n "${COMP_WORDS[$i]}" ] &&
 232                         # word consists of excluded word separators
 233                         [ "${COMP_WORDS[$i]//[^$exclude]}" = "${COMP_WORDS[$i]}" ]
 234                 do
 235                         # Attach to the previous token,
 236                         # unless the previous token is the command name.
 237                         if [ $j -ge 2 ] && [ -n "$first" ]; then
 238                                 ((j--))
 239                         fi
 240                         first=
 241                         words_[$j]=${words_[j]}${COMP_WORDS[i]}
 242                         if [ $i = $COMP_CWORD ]; then
 243                                 cword_=$j
 244                         fi
 245                         if (($i < ${#COMP_WORDS[@]} - 1)); then
 246                                 ((i++))
 247                         else
 248                                 # Done.
 249                                 return
 250                         fi
 251                 done
 252                 words_[$j]=${words_[j]}${COMP_WORDS[i]}
 253                 if [ $i = $COMP_CWORD ]; then
 254                         cword_=$j
 255                 fi
 256         done
 257 }
 258
 259 if ! type _get_comp_words_by_ref >/dev/null 2>&1; then
 260 _get_comp_words_by_ref ()
 261 {
 262         local exclude cur_ words_ cword_
 263         if [ "$1" = "-n" ]; then
 264                 exclude=$2
 265                 shift 2
 266         fi
 267         __git_reassemble_comp_words_by_ref "$exclude"
 268         cur_=${words_[cword_]}
 269         while [ $# -gt 0 ]; do
 270                 case "$1" in
 271                 cur)
 272                         cur=$cur_
 273                         ;;
 274                 prev)
 275                         prev=${words_[$cword_-1]}
 276                         ;;
 277                 words)
 278                         words=("${words_[@]}")
 279                         ;;
 280                 cword)
 281                         cword=$cword_
 282                         ;;
 283                 esac
 284                 shift
 285         done
 286 }
 287 fi
 288
 289 # Fills the COMPREPLY array with prefiltered words without any additional
 290 # processing.
 291 # Callers must take care of providing only words that match the current word
 292 # to be completed and adding any prefix and/or suffix (trailing space!), if
 293 # necessary.
 294 # 1: List of newline-separated matching completion words, complete with
 295 #    prefix and suffix.
 296 __gitcomp_direct ()
 297 {
 298         local IFS=$'\n'
 299
 300         COMPREPLY=($1)
 301 }
 302
 303 __gitcompappend ()
 304 {
 305         local x i=${#COMPREPLY[@]}
 306         for x in $1; do
 307                 if [[ "$x" == "$3"* ]]; then
 308                         COMPREPLY[i++]="$2$x$4"
 309                 fi
 310         done
 311 }
 312
 313 __gitcompadd ()
 314 {
 315         COMPREPLY=()
 316         __gitcompappend "$@"
 317 }
 318
 319 # Generates completion reply, appending a space to possible completion words,
 320 # if necessary.
 321 # It accepts 1 to 4 arguments:
 322 # 1: List of possible completion words.
 323 # 2: A prefix to be added to each possible completion word (optional).
 324 # 3: Generate possible completion matches for this word (optional).
 325 # 4: A suffix to be appended to each possible completion word (optional).
 326 __gitcomp ()
 327 {
 328         local cur_="${3-$cur}"
 329
 330         case "$cur_" in
 331         --*=)
 332                 ;;
 333         *)
 334                 local c i=0 IFS=$' \t\n'
 335                 for c in $1; do
 336                         c="$c${4-}"
 337                         if [[ $c == "$cur_"* ]]; then
 338                                 case $c in
 339                                 --*=*|*.) ;;
 340                                 *) c="$c " ;;
 341                                 esac
 342                                 COMPREPLY[i++]="${2-}$c"
 343                         fi
 344                 done
 345                 ;;
 346         esac
 347 }
 348
 349 # Clear the variables caching builtins' options when (re-)sourcing
 350 # the completion script.
 351 if [[ -n ${ZSH_VERSION-} ]]; then
 352         unset $(set |sed -ne 's/^\(__gitcomp_builtin_[a-zA-Z0-9_][a-zA-Z0-9_]*\)=.*/\1/p') 2>/dev/null
 353 else
 354         unset $(compgen -v __gitcomp_builtin_)
 355 fi
 356
 357 # This function is equivalent to
 358 #
 359 #    __gitcomp "$(git xxx --git-completion-helper) ..."
 360 #
 361 # except that the output is cached. Accept 1-3 arguments:
 362 # 1: the git command to execute, this is also the cache key
 363 # 2: extra options to be added on top (e.g. negative forms)
 364 # 3: options to be excluded
 365 __gitcomp_builtin ()
 366 {
 367         # spaces must be replaced with underscore for multi-word
 368         # commands, e.g. "git remote add" becomes remote_add.
 369         local cmd="$1"
 370         local incl="$2"
 371         local excl="$3"
 372
 373         local var=__gitcomp_builtin_"${cmd/-/_}"
 374         local options
 375         eval "options=\$$var"
 376
 377         if [ -z "$options" ]; then
 378                 # leading and trailing spaces are significant to make
 379                 # option removal work correctly.
 380                 options=" $(__git ${cmd/_/ } --git-completion-helper) $incl "
 381                 for i in $excl; do
 382                         options="${options/ $i / }"
 383                 done
 384                 eval "$var=\"$options\""
 385         fi
 386
 387         __gitcomp "$options"
 388 }
 389
 390 # Variation of __gitcomp_nl () that appends to the existing list of
 391 # completion candidates, COMPREPLY.
 392 __gitcomp_nl_append ()
 393 {
 394         local IFS=$'\n'
 395         __gitcompappend "$1" "${2-}" "${3-$cur}" "${4- }"
 396 }
 397
 398 # Generates completion reply from newline-separated possible completion words
 399 # by appending a space to all of them.
 400 # It accepts 1 to 4 arguments:
 401 # 1: List of possible completion words, separated by a single newline.
 402 # 2: A prefix to be added to each possible completion word (optional).
 403 # 3: Generate possible completion matches for this word (optional).
 404 # 4: A suffix to be appended to each possible completion word instead of
 405 #    the default space (optional).  If specified but empty, nothing is
 406 #    appended.
 407 __gitcomp_nl ()
 408 {
 409         COMPREPLY=()
 410         __gitcomp_nl_append "$@"
 411 }
 412
 413 # Fills the COMPREPLY array with prefiltered paths without any additional
 414 # processing.
 415 # Callers must take care of providing only paths that match the current path
 416 # to be completed and adding any prefix path components, if necessary.
 417 # 1: List of newline-separated matching paths, complete with all prefix
 418 #    path componens.
 419 __gitcomp_file_direct ()
 420 {
 421         local IFS=$'\n'
 422
 423         COMPREPLY=($1)
 424
 425         # use a hack to enable file mode in bash < 4
 426         compopt -o filenames +o nospace 2>/dev/null ||
 427         compgen -f /non-existing-dir/ >/dev/null ||
 428         true
 429 }
 430
 431 # Generates completion reply with compgen from newline-separated possible
 432 # completion filenames.
 433 # It accepts 1 to 3 arguments:
 434 # 1: List of possible completion filenames, separated by a single newline.
 435 # 2: A directory prefix to be added to each possible completion filename
 436 #    (optional).
 437 # 3: Generate possible completion matches for this word (optional).
 438 __gitcomp_file ()
 439 {
 440         local IFS=$'\n'
 441
 442         # XXX does not work when the directory prefix contains a tilde,
 443         # since tilde expansion is not applied.
 444         # This means that COMPREPLY will be empty and Bash default
 445         # completion will be used.
 446         __gitcompadd "$1" "${2-}" "${3-$cur}" ""
 447
 448         # use a hack to enable file mode in bash < 4
 449         compopt -o filenames +o nospace 2>/dev/null ||
 450         compgen -f /non-existing-dir/ >/dev/null ||
 451         true
 452 }
 453
 454 # Execute 'git ls-files', unless the --committable option is specified, in
 455 # which case it runs 'git diff-index' to find out the files that can be
 456 # committed.  It return paths relative to the directory specified in the first
 457 # argument, and using the options specified in the second argument.
 458 __git_ls_files_helper ()
 459 {
 460         if [ "$2" == "--committable" ]; then
 461                 __git -C "$1" -c core.quotePath=false diff-index \
 462                         --name-only --relative HEAD -- "${3//\\/\\\\}*"
 463         else
 464                 # NOTE: $2 is not quoted in order to support multiple options
 465                 __git -C "$1" -c core.quotePath=false ls-files \
 466                         --exclude-standard $2 -- "${3//\\/\\\\}*"
 467         fi
 468 }
 469
 470
 471 # __git_index_files accepts 1 or 2 arguments:
 472 # 1: Options to pass to ls-files (required).
 473 # 2: A directory path (optional).
 474 #    If provided, only files within the specified directory are listed.
 475 #    Sub directories are never recursed.  Path must have a trailing
 476 #    slash.
 477 # 3: List only paths matching this path component (optional).
 478 __git_index_files ()
 479 {
 480         local root="$2" match="$3"
 481
 482         __git_ls_files_helper "$root" "$1" "$match" |
 483         awk -F / -v pfx="${2//\\/\\\\}" '{
 484                 paths[$1] = 1
 485         }
 486         END {
 487                 for (p in paths) {
 488                         if (substr(p, 1, 1) != "\"") {
 489                                 # No special characters, easy!
 490                                 print pfx p
 491                                 continue
 492                         }
 493
 494                         # The path is quoted.
 495                         p = dequote(p)
 496                         if (p == "")
 497                                 continue
 498
 499                         # Even when a directory name itself does not contain
 500                         # any special characters, it will still be quoted if
 501                         # any of its (stripped) trailing path components do.
 502                         # Because of this we may have seen the same direcory
 503                         # both quoted and unquoted.
 504                         if (p in paths)
 505                                 # We have seen the same directory unquoted,
 506                                 # skip it.
 507                                 continue
 508                         else
 509                                 print pfx p
 510                 }
 511         }
 512         function dequote(p,    bs_idx, out, esc, esc_idx, dec) {
 513                 # Skip opening double quote.
 514                 p = substr(p, 2)
 515
 516                 # Interpret backslash escape sequences.
 517                 while ((bs_idx = index(p, "\\")) != 0) {
 518                         out = out substr(p, 1, bs_idx - 1)
 519                         esc = substr(p, bs_idx + 1, 1)
 520                         p = substr(p, bs_idx + 2)
 521
 522                         if ((esc_idx = index("abtvfr\"\\", esc)) != 0) {
 523                                 # C-style one-character escape sequence.
 524                                 out = out substr("\a\b\t\v\f\r\"\\",
 525                                                  esc_idx, 1)
 526                         } else if (esc == "n") {
 527                                 # Uh-oh, a newline character.
 528                                 # We cant reliably put a pathname
 529                                 # containing a newline into COMPREPLY,
 530                                 # and the newline would create a mess.
 531                                 # Skip this path.
 532                                 return ""
 533                         } else {
 534                                 # Must be a \nnn octal value, then.
 535                                 dec = esc             * 64 + \
 536                                       substr(p, 1, 1) * 8  + \
 537                                       substr(p, 2, 1)
 538                                 out = out sprintf("%c", dec)
 539                                 p = substr(p, 3)
 540                         }
 541                 }
 542                 # Drop closing double quote, if there is one.
 543                 # (There isnt any if this is a directory, as it was
 544                 # already stripped with the trailing path components.)
 545                 if (substr(p, length(p), 1) == "\"")
 546                         out = out substr(p, 1, length(p) - 1)
 547                 else
 548                         out = out p
 549
 550                 return out
 551         }'
 552 }
 553
 554 # __git_complete_index_file requires 1 argument:
 555 # 1: the options to pass to ls-file
 556 #
 557 # The exception is --committable, which finds the files appropriate commit.
 558 __git_complete_index_file ()
 559 {
 560         local dequoted_word pfx="" cur_
 561
 562         __git_dequote "$cur"
 563
 564         case "$dequoted_word" in
 565         ?*/*)
 566                 pfx="${dequoted_word%/*}/"
 567                 cur_="${dequoted_word##*/}"
 568                 ;;
 569         *)
 570                 cur_="$dequoted_word"
 571         esac
 572
 573         __gitcomp_file_direct "$(__git_index_files "$1" "$pfx" "$cur_")"
 574 }
 575
 576 # Lists branches from the local repository.
 577 # 1: A prefix to be added to each listed branch (optional).
 578 # 2: List only branches matching this word (optional; list all branches if
 579 #    unset or empty).
 580 # 3: A suffix to be appended to each listed branch (optional).
 581 __git_heads ()
 582 {
 583         local pfx="${1-}" cur_="${2-}" sfx="${3-}"
 584
 585         __git for-each-ref --format="${pfx//\%/%%}%(refname:strip=2)$sfx" \
 586                         "refs/heads/$cur_*" "refs/heads/$cur_*/**"
 587 }
 588
 589 # Lists tags from the local repository.
 590 # Accepts the same positional parameters as __git_heads() above.
 591 __git_tags ()
 592 {
 593         local pfx="${1-}" cur_="${2-}" sfx="${3-}"
 594
 595         __git for-each-ref --format="${pfx//\%/%%}%(refname:strip=2)$sfx" \
 596                         "refs/tags/$cur_*" "refs/tags/$cur_*/**"
 597 }
 598
 599 # Lists refs from the local (by default) or from a remote repository.
 600 # It accepts 0, 1 or 2 arguments:
 601 # 1: The remote to list refs from (optional; ignored, if set but empty).
 602 #    Can be the name of a configured remote, a path, or a URL.
 603 # 2: In addition to local refs, list unique branches from refs/remotes/ for
 604 #    'git checkout's tracking DWIMery (optional; ignored, if set but empty).
 605 # 3: A prefix to be added to each listed ref (optional).
 606 # 4: List only refs matching this word (optional; list all refs if unset or
 607 #    empty).
 608 # 5: A suffix to be appended to each listed ref (optional; ignored, if set
 609 #    but empty).
 610 #
 611 # Use __git_complete_refs() instead.
 612 __git_refs ()
 613 {
 614         local i hash dir track="${2-}"
 615         local list_refs_from=path remote="${1-}"
 616         local format refs
 617         local pfx="${3-}" cur_="${4-$cur}" sfx="${5-}"
 618         local match="${4-}"
 619         local fer_pfx="${pfx//\%/%%}" # "escape" for-each-ref format specifiers
 620
 621         __git_find_repo_path
 622         dir="$__git_repo_path"
 623
 624         if [ -z "$remote" ]; then
 625                 if [ -z "$dir" ]; then
 626                         return
 627                 fi
 628         else
 629                 if __git_is_configured_remote "$remote"; then
 630                         # configured remote takes precedence over a
 631                         # local directory with the same name
 632                         list_refs_from=remote
 633                 elif [ -d "$remote/.git" ]; then
 634                         dir="$remote/.git"
 635                 elif [ -d "$remote" ]; then
 636                         dir="$remote"
 637                 else
 638                         list_refs_from=url
 639                 fi
 640         fi
 641
 642         if [ "$list_refs_from" = path ]; then
 643                 if [[ "$cur_" == ^* ]]; then
 644                         pfx="$pfx^"
 645                         fer_pfx="$fer_pfx^"
 646                         cur_=${cur_#^}
 647                         match=${match#^}
 648                 fi
 649                 case "$cur_" in
 650                 refs|refs/*)
 651                         format="refname"
 652                         refs=("$match*" "$match*/**")
 653                         track=""
 654                         ;;
 655                 *)
 656                         for i in HEAD FETCH_HEAD ORIG_HEAD MERGE_HEAD REBASE_HEAD; do
 657                                 case "$i" in
 658                                 $match*)
 659                                         if [ -e "$dir/$i" ]; then
 660                                                 echo "$pfx$i$sfx"
 661                                         fi
 662                                         ;;
 663                                 esac
 664                         done
 665                         format="refname:strip=2"
 666                         refs=("refs/tags/$match*" "refs/tags/$match*/**"
 667                                 "refs/heads/$match*" "refs/heads/$match*/**"
 668                                 "refs/remotes/$match*" "refs/remotes/$match*/**")
 669                         ;;
 670                 esac
 671                 __git_dir="$dir" __git for-each-ref --format="$fer_pfx%($format)$sfx" \
 672                         "${refs[@]}"
 673                 if [ -n "$track" ]; then
 674                         # employ the heuristic used by git checkout
 675                         # Try to find a remote branch that matches the completion word
 676                         # but only output if the branch name is unique
 677                         __git for-each-ref --format="$fer_pfx%(refname:strip=3)$sfx" \
 678                                 --sort="refname:strip=3" \
 679                                 "refs/remotes/*/$match*" "refs/remotes/*/$match*/**" | \
 680                         uniq -u
 681                 fi
 682                 return
 683         fi
 684         case "$cur_" in
 685         refs|refs/*)
 686                 __git ls-remote "$remote" "$match*" | \
 687                 while read -r hash i; do
 688                         case "$i" in
 689                         *^{}) ;;
 690                         *) echo "$pfx$i$sfx" ;;
 691                         esac
 692                 done
 693                 ;;
 694         *)
 695                 if [ "$list_refs_from" = remote ]; then
 696                         case "HEAD" in
 697                         $match*)        echo "${pfx}HEAD$sfx" ;;
 698                         esac
 699                         __git for-each-ref --format="$fer_pfx%(refname:strip=3)$sfx" \
 700                                 "refs/remotes/$remote/$match*" \
 701                                 "refs/remotes/$remote/$match*/**"
 702                 else
 703                         local query_symref
 704                         case "HEAD" in
 705                         $match*)        query_symref="HEAD" ;;
 706                         esac
 707                         __git ls-remote "$remote" $query_symref \
 708                                 "refs/tags/$match*" "refs/heads/$match*" \
 709                                 "refs/remotes/$match*" |
 710                         while read -r hash i; do
 711                                 case "$i" in
 712                                 *^{})   ;;
 713                                 refs/*) echo "$pfx${i#refs/*/}$sfx" ;;
 714                                 *)      echo "$pfx$i$sfx" ;;  # symbolic refs
 715                                 esac
 716                         done
 717                 fi
 718                 ;;
 719         esac
 720 }
 721
 722 # Completes refs, short and long, local and remote, symbolic and pseudo.
 723 #
 724 # Usage: __git_complete_refs [<option>]...
 725 # --remote=<remote>: The remote to list refs from, can be the name of a
 726 #                    configured remote, a path, or a URL.
 727 # --track: List unique remote branches for 'git checkout's tracking DWIMery.
 728 # --pfx=<prefix>: A prefix to be added to each ref.
 729 # --cur=<word>: The current ref to be completed.  Defaults to the current
 730 #               word to be completed.
 731 # --sfx=<suffix>: A suffix to be appended to each ref instead of the default
 732 #                 space.
 733 __git_complete_refs ()
 734 {
 735         local remote track pfx cur_="$cur" sfx=" "
 736
 737         while test $# != 0; do
 738                 case "$1" in
 739                 --remote=*)     remote="${1##--remote=}" ;;
 740                 --track)        track="yes" ;;
 741                 --pfx=*)        pfx="${1##--pfx=}" ;;
 742                 --cur=*)        cur_="${1##--cur=}" ;;
 743                 --sfx=*)        sfx="${1##--sfx=}" ;;
 744                 *)              return 1 ;;
 745                 esac
 746                 shift
 747         done
 748
 749         __gitcomp_direct "$(__git_refs "$remote" "$track" "$pfx" "$cur_" "$sfx")"
 750 }
 751
 752 # __git_refs2 requires 1 argument (to pass to __git_refs)
 753 # Deprecated: use __git_complete_fetch_refspecs() instead.
 754 __git_refs2 ()
 755 {
 756         local i
 757         for i in $(__git_refs "$1"); do
 758                 echo "$i:$i"
 759         done
 760 }
 761
 762 # Completes refspecs for fetching from a remote repository.
 763 # 1: The remote repository.
 764 # 2: A prefix to be added to each listed refspec (optional).
 765 # 3: The ref to be completed as a refspec instead of the current word to be
 766 #    completed (optional)
 767 # 4: A suffix to be appended to each listed refspec instead of the default
 768 #    space (optional).
 769 __git_complete_fetch_refspecs ()
 770 {
 771         local i remote="$1" pfx="${2-}" cur_="${3-$cur}" sfx="${4- }"
 772
 773         __gitcomp_direct "$(
 774                 for i in $(__git_refs "$remote" "" "" "$cur_") ; do
 775                         echo "$pfx$i:$i$sfx"
 776                 done
 777                 )"
 778 }
 779
 780 # __git_refs_remotes requires 1 argument (to pass to ls-remote)
 781 __git_refs_remotes ()
 782 {
 783         local i hash
 784         __git ls-remote "$1" 'refs/heads/*' | \
 785         while read -r hash i; do
 786                 echo "$i:refs/remotes/$1/${i#refs/heads/}"
 787         done
 788 }
 789
 790 __git_remotes ()
 791 {
 792         __git_find_repo_path
 793         test -d "$__git_repo_path/remotes" && ls -1 "$__git_repo_path/remotes"
 794         __git remote
 795 }
 796
 797 # Returns true if $1 matches the name of a configured remote, false otherwise.
 798 __git_is_configured_remote ()
 799 {
 800         local remote
 801         for remote in $(__git_remotes); do
 802                 if [ "$remote" = "$1" ]; then
 803                         return 0
 804                 fi
 805         done
 806         return 1
 807 }
 808
 809 __git_list_merge_strategies ()
 810 {
 811         LANG=C LC_ALL=C git merge -s help 2>&1 |
 812         sed -n -e '/[Aa]vailable strategies are: /,/^$/{
 813                 s/\.$//
 814                 s/.*://
 815                 s/^[    ]*//
 816                 s/[     ]*$//
 817                 p
 818         }'
 819 }
 820
 821 __git_merge_strategies=
 822 # 'git merge -s help' (and thus detection of the merge strategy
 823 # list) fails, unfortunately, if run outside of any git working
 824 # tree.  __git_merge_strategies is set to the empty string in
 825 # that case, and the detection will be repeated the next time it
 826 # is needed.
 827 __git_compute_merge_strategies ()
 828 {
 829         test -n "$__git_merge_strategies" ||
 830         __git_merge_strategies=$(__git_list_merge_strategies)
 831 }
 832
 833 __git_complete_revlist_file ()
 834 {
 835         local pfx ls ref cur_="$cur"
 836         case "$cur_" in
 837         *..?*:*)
 838                 return
 839                 ;;
 840         ?*:*)
 841                 ref="${cur_%%:*}"
 842                 cur_="${cur_#*:}"
 843                 case "$cur_" in
 844                 ?*/*)
 845                         pfx="${cur_%/*}"
 846                         cur_="${cur_##*/}"
 847                         ls="$ref:$pfx"
 848                         pfx="$pfx/"
 849                         ;;
 850                 *)
 851                         ls="$ref"
 852                         ;;
 853                 esac
 854
 855                 case "$COMP_WORDBREAKS" in
 856                 *:*) : great ;;
 857                 *)   pfx="$ref:$pfx" ;;
 858                 esac
 859
 860                 __gitcomp_nl "$(__git ls-tree "$ls" \
 861                                 | sed '/^100... blob /{
 862                                            s,^.*        ,,
 863                                            s,$, ,
 864                                        }
 865                                        /^120000 blob /{
 866                                            s,^.*        ,,
 867                                            s,$, ,
 868                                        }
 869                                        /^040000 tree /{
 870                                            s,^.*        ,,
 871                                            s,$,/,
 872                                        }
 873                                        s/^.*    //')" \
 874                         "$pfx" "$cur_" ""
 875                 ;;
 876         *...*)
 877                 pfx="${cur_%...*}..."
 878                 cur_="${cur_#*...}"
 879                 __git_complete_refs --pfx="$pfx" --cur="$cur_"
 880                 ;;
 881         *..*)
 882                 pfx="${cur_%..*}.."
 883                 cur_="${cur_#*..}"
 884                 __git_complete_refs --pfx="$pfx" --cur="$cur_"
 885                 ;;
 886         *)
 887                 __git_complete_refs
 888                 ;;
 889         esac
 890 }
 891
 892 __git_complete_file ()
 893 {
 894         __git_complete_revlist_file
 895 }
 896
 897 __git_complete_revlist ()
 898 {
 899         __git_complete_revlist_file
 900 }
 901
 902 __git_complete_remote_or_refspec ()
 903 {
 904         local cur_="$cur" cmd="${words[1]}"
 905         local i c=2 remote="" pfx="" lhs=1 no_complete_refspec=0
 906         if [ "$cmd" = "remote" ]; then
 907                 ((c++))
 908         fi
 909         while [ $c -lt $cword ]; do
 910                 i="${words[c]}"
 911                 case "$i" in
 912                 --mirror) [ "$cmd" = "push" ] && no_complete_refspec=1 ;;
 913                 -d|--delete) [ "$cmd" = "push" ] && lhs=0 ;;
 914                 --all)
 915                         case "$cmd" in
 916                         push) no_complete_refspec=1 ;;
 917                         fetch)
 918                                 return
 919                                 ;;
 920                         *) ;;
 921                         esac
 922                         ;;
 923                 -*) ;;
 924                 *) remote="$i"; break ;;
 925                 esac
 926                 ((c++))
 927         done
 928         if [ -z "$remote" ]; then
 929                 __gitcomp_nl "$(__git_remotes)"
 930                 return
 931         fi
 932         if [ $no_complete_refspec = 1 ]; then
 933                 return
 934         fi
 935         [ "$remote" = "." ] && remote=
 936         case "$cur_" in
 937         *:*)
 938                 case "$COMP_WORDBREAKS" in
 939                 *:*) : great ;;
 940                 *)   pfx="${cur_%%:*}:" ;;
 941                 esac
 942                 cur_="${cur_#*:}"
 943                 lhs=0
 944                 ;;
 945         +*)
 946                 pfx="+"
 947                 cur_="${cur_#+}"
 948                 ;;
 949         esac
 950         case "$cmd" in
 951         fetch)
 952                 if [ $lhs = 1 ]; then
 953                         __git_complete_fetch_refspecs "$remote" "$pfx" "$cur_"
 954                 else
 955                         __git_complete_refs --pfx="$pfx" --cur="$cur_"
 956                 fi
 957                 ;;
 958         pull|remote)
 959                 if [ $lhs = 1 ]; then
 960                         __git_complete_refs --remote="$remote" --pfx="$pfx" --cur="$cur_"
 961                 else
 962                         __git_complete_refs --pfx="$pfx" --cur="$cur_"
 963                 fi
 964                 ;;
 965         push)
 966                 if [ $lhs = 1 ]; then
 967                         __git_complete_refs --pfx="$pfx" --cur="$cur_"
 968                 else
 969                         __git_complete_refs --remote="$remote" --pfx="$pfx" --cur="$cur_"
 970                 fi
 971                 ;;
 972         esac
 973 }
 974
 975 __git_complete_strategy ()
 976 {
 977         __git_compute_merge_strategies
 978         case "$prev" in
 979         -s|--strategy)
 980                 __gitcomp "$__git_merge_strategies"
 981                 return 0
 982         esac
 983         case "$cur" in
 984         --strategy=*)
 985                 __gitcomp "$__git_merge_strategies" "" "${cur##--strategy=}"
 986                 return 0
 987                 ;;
 988         esac
 989         return 1
 990 }
 991
 992 __git_all_commands=
 993 __git_compute_all_commands ()
 994 {
 995         test -n "$__git_all_commands" ||
 996         __git_all_commands=$(git --list-cmds=main,others,alias,nohelpers)
 997 }
 998
 999 # Lists all set config variables starting with the given section prefix,
1000 # with the prefix removed.
1001 __git_get_config_variables ()
1002 {
1003         local section="$1" i IFS=$'\n'
1004         for i in $(__git config --name-only --get-regexp "^$section\..*"); do
1005                 echo "${i#$section.}"
1006         done
1007 }
1008
1009 __git_pretty_aliases ()
1010 {
1011         __git_get_config_variables "pretty"
1012 }
1013
1014 # __git_aliased_command requires 1 argument
1015 __git_aliased_command ()
1016 {
1017         local word cmdline=$(__git config --get "alias.$1")
1018         for word in $cmdline; do
1019                 case "$word" in
1020                 \!gitk|gitk)
1021                         echo "gitk"
1022                         return
1023                         ;;
1024                 \!*)    : shell command alias ;;
1025                 -*)     : option ;;
1026                 *=*)    : setting env ;;
1027                 git)    : git itself ;;
1028                 \(\))   : skip parens of shell function definition ;;
1029                 {)      : skip start of shell helper function ;;
1030                 :)      : skip null command ;;
1031                 \'*)    : skip opening quote after sh -c ;;
1032                 *)
1033                         echo "$word"
1034                         return
1035                 esac
1036         done
1037 }
1038
1039 # __git_find_on_cmdline requires 1 argument
1040 __git_find_on_cmdline ()
1041 {
1042         local word subcommand c=1
1043         while [ $c -lt $cword ]; do
1044                 word="${words[c]}"
1045                 for subcommand in $1; do
1046                         if [ "$subcommand" = "$word" ]; then
1047                                 echo "$subcommand"
1048                                 return
1049                         fi
1050                 done
1051                 ((c++))
1052         done
1053 }
1054
1055 # Echo the value of an option set on the command line or config
1056 #
1057 # $1: short option name
1058 # $2: long option name including =
1059 # $3: list of possible values
1060 # $4: config string (optional)
1061 #
1062 # example:
1063 # result="$(__git_get_option_value "-d" "--do-something=" \
1064 #     "yes no" "core.doSomething")"
1065 #
1066 # result is then either empty (no option set) or "yes" or "no"
1067 #
1068 # __git_get_option_value requires 3 arguments
1069 __git_get_option_value ()
1070 {
1071         local c short_opt long_opt val
1072         local result= values config_key word
1073
1074         short_opt="$1"
1075         long_opt="$2"
1076         values="$3"
1077         config_key="$4"
1078
1079         ((c = $cword - 1))
1080         while [ $c -ge 0 ]; do
1081                 word="${words[c]}"
1082                 for val in $values; do
1083                         if [ "$short_opt$val" = "$word" ] ||
1084                            [ "$long_opt$val"  = "$word" ]; then
1085                                 result="$val"
1086                                 break 2
1087                         fi
1088                 done
1089                 ((c--))
1090         done
1091
1092         if [ -n "$config_key" ] && [ -z "$result" ]; then
1093                 result="$(__git config "$config_key")"
1094         fi
1095
1096         echo "$result"
1097 }
1098
1099 __git_has_doubledash ()
1100 {
1101         local c=1
1102         while [ $c -lt $cword ]; do
1103                 if [ "--" = "${words[c]}" ]; then
1104                         return 0
1105                 fi
1106                 ((c++))
1107         done
1108         return 1
1109 }
1110
1111 # Try to count non option arguments passed on the command line for the
1112 # specified git command.
1113 # When options are used, it is necessary to use the special -- option to
1114 # tell the implementation were non option arguments begin.
1115 # XXX this can not be improved, since options can appear everywhere, as
1116 # an example:
1117 #       git mv x -n y
1118 #
1119 # __git_count_arguments requires 1 argument: the git command executed.
1120 __git_count_arguments ()
1121 {
1122         local word i c=0
1123
1124         # Skip "git" (first argument)
1125         for ((i=1; i < ${#words[@]}; i++)); do
1126                 word="${words[i]}"
1127
1128                 case "$word" in
1129                         --)
1130                                 # Good; we can assume that the following are only non
1131                                 # option arguments.
1132                                 ((c = 0))
1133                                 ;;
1134                         "$1")
1135                                 # Skip the specified git command and discard git
1136                                 # main options
1137                                 ((c = 0))
1138                                 ;;
1139                         ?*)
1140                                 ((c++))
1141                                 ;;
1142                 esac
1143         done
1144
1145         printf "%d" $c
1146 }
1147
1148 __git_whitespacelist="nowarn warn error error-all fix"
1149 __git_am_inprogress_options="--skip --continue --resolved --abort --quit --show-current-patch"
1150
1151 _git_am ()
1152 {
1153         __git_find_repo_path
1154         if [ -d "$__git_repo_path"/rebase-apply ]; then
1155                 __gitcomp "$__git_am_inprogress_options"
1156                 return
1157         fi
1158         case "$cur" in
1159         --whitespace=*)
1160                 __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
1161                 return
1162                 ;;
1163         --*)
1164                 __gitcomp_builtin am "--no-utf8" \
1165                         "$__git_am_inprogress_options"
1166                 return
1167         esac
1168 }
1169
1170 _git_apply ()
1171 {
1172         case "$cur" in
1173         --whitespace=*)
1174                 __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
1175                 return
1176                 ;;
1177         --*)
1178                 __gitcomp_builtin apply
1179                 return
1180         esac
1181 }
1182
1183 _git_add ()
1184 {
1185         case "$cur" in
1186         --*)
1187                 __gitcomp_builtin add
1188                 return
1189         esac
1190
1191         local complete_opt="--others --modified --directory --no-empty-directory"
1192         if test -n "$(__git_find_on_cmdline "-u --update")"
1193         then
1194                 complete_opt="--modified"
1195         fi
1196         __git_complete_index_file "$complete_opt"
1197 }
1198
1199 _git_archive ()
1200 {
1201         case "$cur" in
1202         --format=*)
1203                 __gitcomp "$(git archive --list)" "" "${cur##--format=}"
1204                 return
1205                 ;;
1206         --remote=*)
1207                 __gitcomp_nl "$(__git_remotes)" "" "${cur##--remote=}"
1208                 return
1209                 ;;
1210         --*)
1211                 __gitcomp "
1212                         --format= --list --verbose
1213                         --prefix= --remote= --exec= --output
1214                         "
1215                 return
1216                 ;;
1217         esac
1218         __git_complete_file
1219 }
1220
1221 _git_bisect ()
1222 {
1223         __git_has_doubledash && return
1224
1225         local subcommands="start bad good skip reset visualize replay log run"
1226         local subcommand="$(__git_find_on_cmdline "$subcommands")"
1227         if [ -z "$subcommand" ]; then
1228                 __git_find_repo_path
1229                 if [ -f "$__git_repo_path"/BISECT_START ]; then
1230                         __gitcomp "$subcommands"
1231                 else
1232                         __gitcomp "replay start"
1233                 fi
1234                 return
1235         fi
1236
1237         case "$subcommand" in
1238         bad|good|reset|skip|start)
1239                 __git_complete_refs
1240                 ;;
1241         *)
1242                 ;;
1243         esac
1244 }
1245
1246 _git_branch ()
1247 {
1248         local i c=1 only_local_ref="n" has_r="n"
1249
1250         while [ $c -lt $cword ]; do
1251                 i="${words[c]}"
1252                 case "$i" in
1253                 -d|--delete|-m|--move)  only_local_ref="y" ;;
1254                 -r|--remotes)           has_r="y" ;;
1255                 esac
1256                 ((c++))
1257         done
1258
1259         case "$cur" in
1260         --set-upstream-to=*)
1261                 __git_complete_refs --cur="${cur##--set-upstream-to=}"
1262                 ;;
1263         --*)
1264                 __gitcomp_builtin branch "--no-color --no-abbrev
1265                         --no-track --no-column
1266                         "
1267                 ;;
1268         *)
1269                 if [ $only_local_ref = "y" -a $has_r = "n" ]; then
1270                         __gitcomp_direct "$(__git_heads "" "$cur" " ")"
1271                 else
1272                         __git_complete_refs
1273                 fi
1274                 ;;
1275         esac
1276 }
1277
1278 _git_bundle ()
1279 {
1280         local cmd="${words[2]}"
1281         case "$cword" in
1282         2)
1283                 __gitcomp "create list-heads verify unbundle"
1284                 ;;
1285         3)
1286                 # looking for a file
1287                 ;;
1288         *)
1289                 case "$cmd" in
1290                         create)
1291                                 __git_complete_revlist
1292                         ;;
1293                 esac
1294                 ;;
1295         esac
1296 }
1297
1298 _git_checkout ()
1299 {
1300         __git_has_doubledash && return
1301
1302         case "$cur" in
1303         --conflict=*)
1304                 __gitcomp "diff3 merge" "" "${cur##--conflict=}"
1305                 ;;
1306         --*)
1307                 __gitcomp_builtin checkout "--no-track --no-recurse-submodules"
1308                 ;;
1309         *)
1310                 # check if --track, --no-track, or --no-guess was specified
1311                 # if so, disable DWIM mode
1312                 local flags="--track --no-track --no-guess" track_opt="--track"
1313                 if [ "$GIT_COMPLETION_CHECKOUT_NO_GUESS" = "1" ] ||
1314                    [ -n "$(__git_find_on_cmdline "$flags")" ]; then
1315                         track_opt=''
1316                 fi
1317                 __git_complete_refs $track_opt
1318                 ;;
1319         esac
1320 }
1321
1322 _git_cherry ()
1323 {
1324         case "$cur" in
1325         --*)
1326                 __gitcomp_builtin cherry
1327                 return
1328         esac
1329
1330         __git_complete_refs
1331 }
1332
1333 __git_cherry_pick_inprogress_options="--continue --quit --abort"
1334
1335 _git_cherry_pick ()
1336 {
1337         __git_find_repo_path
1338         if [ -f "$__git_repo_path"/CHERRY_PICK_HEAD ]; then
1339                 __gitcomp "$__git_cherry_pick_inprogress_options"
1340                 return
1341         fi
1342         case "$cur" in
1343         --*)
1344                 __gitcomp_builtin cherry-pick "" \
1345                         "$__git_cherry_pick_inprogress_options"
1346                 ;;
1347         *)
1348                 __git_complete_refs
1349                 ;;
1350         esac
1351 }
1352
1353 _git_clean ()
1354 {
1355         case "$cur" in
1356         --*)
1357                 __gitcomp_builtin clean
1358                 return
1359                 ;;
1360         esac
1361
1362         # XXX should we check for -x option ?
1363         __git_complete_index_file "--others --directory"
1364 }
1365
1366 _git_clone ()
1367 {
1368         case "$cur" in
1369         --*)
1370                 __gitcomp_builtin clone "--no-single-branch"
1371                 return
1372                 ;;
1373         esac
1374 }
1375
1376 __git_untracked_file_modes="all no normal"
1377
1378 _git_commit ()
1379 {
1380         case "$prev" in
1381         -c|-C)
1382                 __git_complete_refs
1383                 return
1384                 ;;
1385         esac
1386
1387         case "$cur" in
1388         --cleanup=*)
1389                 __gitcomp "default scissors strip verbatim whitespace
1390                         " "" "${cur##--cleanup=}"
1391                 return
1392                 ;;
1393         --reuse-message=*|--reedit-message=*|\
1394         --fixup=*|--squash=*)
1395                 __git_complete_refs --cur="${cur#*=}"
1396                 return
1397                 ;;
1398         --untracked-files=*)
1399                 __gitcomp "$__git_untracked_file_modes" "" "${cur##--untracked-files=}"
1400                 return
1401                 ;;
1402         --*)
1403                 __gitcomp_builtin commit "--no-edit --verify"
1404                 return
1405         esac
1406
1407         if __git rev-parse --verify --quiet HEAD >/dev/null; then
1408                 __git_complete_index_file "--committable"
1409         else
1410                 # This is the first commit
1411                 __git_complete_index_file "--cached"
1412         fi
1413 }
1414
1415 _git_describe ()
1416 {
1417         case "$cur" in
1418         --*)
1419                 __gitcomp_builtin describe
1420                 return
1421         esac
1422         __git_complete_refs
1423 }
1424
1425 __git_diff_algorithms="myers minimal patience histogram"
1426
1427 __git_diff_submodule_formats="diff log short"
1428
1429 __git_diff_common_options="--stat --numstat --shortstat --summary
1430                         --patch-with-stat --name-only --name-status --color
1431                         --no-color --color-words --no-renames --check
1432                         --full-index --binary --abbrev --diff-filter=
1433                         --find-copies-harder --ignore-cr-at-eol
1434                         --text --ignore-space-at-eol --ignore-space-change
1435                         --ignore-all-space --ignore-blank-lines --exit-code
1436                         --quiet --ext-diff --no-ext-diff
1437                         --no-prefix --src-prefix= --dst-prefix=
1438                         --inter-hunk-context=
1439                         --patience --histogram --minimal
1440                         --raw --word-diff --word-diff-regex=
1441                         --dirstat --dirstat= --dirstat-by-file
1442                         --dirstat-by-file= --cumulative
1443                         --diff-algorithm=
1444                         --submodule --submodule= --ignore-submodules
1445 "
1446
1447 _git_diff ()
1448 {
1449         __git_has_doubledash && return
1450
1451         case "$cur" in
1452         --diff-algorithm=*)
1453                 __gitcomp "$__git_diff_algorithms" "" "${cur##--diff-algorithm=}"
1454                 return
1455                 ;;
1456         --submodule=*)
1457                 __gitcomp "$__git_diff_submodule_formats" "" "${cur##--submodule=}"
1458                 return
1459                 ;;
1460         --*)
1461                 __gitcomp "--cached --staged --pickaxe-all --pickaxe-regex
1462                         --base --ours --theirs --no-index
1463                         $__git_diff_common_options
1464                         "
1465                 return
1466                 ;;
1467         esac
1468         __git_complete_revlist_file
1469 }
1470
1471 __git_mergetools_common="diffuse diffmerge ecmerge emerge kdiff3 meld opendiff
1472                         tkdiff vimdiff gvimdiff xxdiff araxis p4merge bc codecompare
1473 "
1474
1475 _git_difftool ()
1476 {
1477         __git_has_doubledash && return
1478
1479         case "$cur" in
1480         --tool=*)
1481                 __gitcomp "$__git_mergetools_common kompare" "" "${cur##--tool=}"
1482                 return
1483                 ;;
1484         --*)
1485                 __gitcomp_builtin difftool "$__git_diff_common_options
1486                                         --base --cached --ours --theirs
1487                                         --pickaxe-all --pickaxe-regex
1488                                         --relative --staged
1489                                         "
1490                 return
1491                 ;;
1492         esac
1493         __git_complete_revlist_file
1494 }
1495
1496 __git_fetch_recurse_submodules="yes on-demand no"
1497
1498 _git_fetch ()
1499 {
1500         case "$cur" in
1501         --recurse-submodules=*)
1502                 __gitcomp "$__git_fetch_recurse_submodules" "" "${cur##--recurse-submodules=}"
1503                 return
1504                 ;;
1505         --*)
1506                 __gitcomp_builtin fetch "--no-tags"
1507                 return
1508                 ;;
1509         esac
1510         __git_complete_remote_or_refspec
1511 }
1512
1513 __git_format_patch_options="
1514         --stdout --attach --no-attach --thread --thread= --no-thread
1515         --numbered --start-number --numbered-files --keep-subject --signoff
1516         --signature --no-signature --in-reply-to= --cc= --full-index --binary
1517         --not --all --cover-letter --no-prefix --src-prefix= --dst-prefix=
1518         --inline --suffix= --ignore-if-in-upstream --subject-prefix=
1519         --output-directory --reroll-count --to= --quiet --notes
1520 "
1521
1522 _git_format_patch ()
1523 {
1524         case "$cur" in
1525         --thread=*)
1526                 __gitcomp "
1527                         deep shallow
1528                         " "" "${cur##--thread=}"
1529                 return
1530                 ;;
1531         --*)
1532                 __gitcomp "$__git_format_patch_options"
1533                 return
1534                 ;;
1535         esac
1536         __git_complete_revlist
1537 }
1538
1539 _git_fsck ()
1540 {
1541         case "$cur" in
1542         --*)
1543                 __gitcomp_builtin fsck "--no-reflogs"
1544                 return
1545                 ;;
1546         esac
1547 }
1548
1549 _git_gitk ()
1550 {
1551         _gitk
1552 }
1553
1554 # Lists matching symbol names from a tag (as in ctags) file.
1555 # 1: List symbol names matching this word.
1556 # 2: The tag file to list symbol names from.
1557 # 3: A prefix to be added to each listed symbol name (optional).
1558 # 4: A suffix to be appended to each listed symbol name (optional).
1559 __git_match_ctag () {
1560         awk -v pfx="${3-}" -v sfx="${4-}" "
1561                 /^${1//\//\\/}/ { print pfx \$1 sfx }
1562                 " "$2"
1563 }
1564
1565 # Complete symbol names from a tag file.
1566 # Usage: __git_complete_symbol [<option>]...
1567 # --tags=<file>: The tag file to list symbol names from instead of the
1568 #                default "tags".
1569 # --pfx=<prefix>: A prefix to be added to each symbol name.
1570 # --cur=<word>: The current symbol name to be completed.  Defaults to
1571 #               the current word to be completed.
1572 # --sfx=<suffix>: A suffix to be appended to each symbol name instead
1573 #                 of the default space.
1574 __git_complete_symbol () {
1575         local tags=tags pfx="" cur_="${cur-}" sfx=" "
1576
1577         while test $# != 0; do
1578                 case "$1" in
1579                 --tags=*)       tags="${1##--tags=}" ;;
1580                 --pfx=*)        pfx="${1##--pfx=}" ;;
1581                 --cur=*)        cur_="${1##--cur=}" ;;
1582                 --sfx=*)        sfx="${1##--sfx=}" ;;
1583                 *)              return 1 ;;
1584                 esac
1585                 shift
1586         done
1587
1588         if test -r "$tags"; then
1589                 __gitcomp_direct "$(__git_match_ctag "$cur_" "$tags" "$pfx" "$sfx")"
1590         fi
1591 }
1592
1593 _git_grep ()
1594 {
1595         __git_has_doubledash && return
1596
1597         case "$cur" in
1598         --*)
1599                 __gitcomp_builtin grep
1600                 return
1601                 ;;
1602         esac
1603
1604         case "$cword,$prev" in
1605         2,*|*,-*)
1606                 __git_complete_symbol && return
1607                 ;;
1608         esac
1609
1610         __git_complete_refs
1611 }
1612
1613 _git_help ()
1614 {
1615         case "$cur" in
1616         --*)
1617                 __gitcomp_builtin help
1618                 return
1619                 ;;
1620         esac
1621         if test -n "$GIT_TESTING_ALL_COMMAND_LIST"
1622         then
1623                 __gitcomp "$GIT_TESTING_ALL_COMMAND_LIST $(git --list-cmds=alias,list-guide) gitk"
1624         else
1625                 __gitcomp "$(git --list-cmds=main,nohelpers,alias,list-guide) gitk"
1626         fi
1627 }
1628
1629 _git_init ()
1630 {
1631         case "$cur" in
1632         --shared=*)
1633                 __gitcomp "
1634                         false true umask group all world everybody
1635                         " "" "${cur##--shared=}"
1636                 return
1637                 ;;
1638         --*)
1639                 __gitcomp_builtin init
1640                 return
1641                 ;;
1642         esac
1643 }
1644
1645 _git_ls_files ()
1646 {
1647         case "$cur" in
1648         --*)
1649                 __gitcomp_builtin ls-files "--no-empty-directory"
1650                 return
1651                 ;;
1652         esac
1653
1654         # XXX ignore options like --modified and always suggest all cached
1655         # files.
1656         __git_complete_index_file "--cached"
1657 }
1658
1659 _git_ls_remote ()
1660 {
1661         case "$cur" in
1662         --*)
1663                 __gitcomp_builtin ls-remote
1664                 return
1665                 ;;
1666         esac
1667         __gitcomp_nl "$(__git_remotes)"
1668 }
1669
1670 _git_ls_tree ()
1671 {
1672         case "$cur" in
1673         --*)
1674                 __gitcomp_builtin ls-tree
1675                 return
1676                 ;;
1677         esac
1678
1679         __git_complete_file
1680 }
1681
1682 # Options that go well for log, shortlog and gitk
1683 __git_log_common_options="
1684         --not --all
1685         --branches --tags --remotes
1686         --first-parent --merges --no-merges
1687         --max-count=
1688         --max-age= --since= --after=
1689         --min-age= --until= --before=
1690         --min-parents= --max-parents=
1691         --no-min-parents --no-max-parents
1692 "
1693 # Options that go well for log and gitk (not shortlog)
1694 __git_log_gitk_options="
1695         --dense --sparse --full-history
1696         --simplify-merges --simplify-by-decoration
1697         --left-right --notes --no-notes
1698 "
1699 # Options that go well for log and shortlog (not gitk)
1700 __git_log_shortlog_options="
1701         --author= --committer= --grep=
1702         --all-match --invert-grep
1703 "
1704
1705 __git_log_pretty_formats="oneline short medium full fuller email raw format:"
1706 __git_log_date_formats="relative iso8601 rfc2822 short local default raw"
1707
1708 _git_log ()
1709 {
1710         __git_has_doubledash && return
1711         __git_find_repo_path
1712
1713         local merge=""
1714         if [ -f "$__git_repo_path/MERGE_HEAD" ]; then
1715                 merge="--merge"
1716         fi
1717         case "$prev,$cur" in
1718         -L,:*:*)
1719                 return  # fall back to Bash filename completion
1720                 ;;
1721         -L,:*)
1722                 __git_complete_symbol --cur="${cur#:}" --sfx=":"
1723                 return
1724                 ;;
1725         -G,*|-S,*)
1726                 __git_complete_symbol
1727                 return
1728                 ;;
1729         esac
1730         case "$cur" in
1731         --pretty=*|--format=*)
1732                 __gitcomp "$__git_log_pretty_formats $(__git_pretty_aliases)
1733                         " "" "${cur#*=}"
1734                 return
1735                 ;;
1736         --date=*)
1737                 __gitcomp "$__git_log_date_formats" "" "${cur##--date=}"
1738                 return
1739                 ;;
1740         --decorate=*)
1741                 __gitcomp "full short no" "" "${cur##--decorate=}"
1742                 return
1743                 ;;
1744         --diff-algorithm=*)
1745                 __gitcomp "$__git_diff_algorithms" "" "${cur##--diff-algorithm=}"
1746                 return
1747                 ;;
1748         --submodule=*)
1749                 __gitcomp "$__git_diff_submodule_formats" "" "${cur##--submodule=}"
1750                 return
1751                 ;;
1752         --*)
1753                 __gitcomp "
1754                         $__git_log_common_options
1755                         $__git_log_shortlog_options
1756                         $__git_log_gitk_options
1757                         --root --topo-order --date-order --reverse
1758                         --follow --full-diff
1759                         --abbrev-commit --abbrev=
1760                         --relative-date --date=
1761                         --pretty= --format= --oneline
1762                         --show-signature
1763                         --cherry-mark
1764                         --cherry-pick
1765                         --graph
1766                         --decorate --decorate=
1767                         --walk-reflogs
1768                         --parents --children
1769                         $merge
1770                         $__git_diff_common_options
1771                         --pickaxe-all --pickaxe-regex
1772                         "
1773                 return
1774                 ;;
1775         -L:*:*)
1776                 return  # fall back to Bash filename completion
1777                 ;;
1778         -L:*)
1779                 __git_complete_symbol --cur="${cur#-L:}" --sfx=":"
1780                 return
1781                 ;;
1782         -G*)
1783                 __git_complete_symbol --pfx="-G" --cur="${cur#-G}"
1784                 return
1785                 ;;
1786         -S*)
1787                 __git_complete_symbol --pfx="-S" --cur="${cur#-S}"
1788                 return
1789                 ;;
1790         esac
1791         __git_complete_revlist
1792 }
1793
1794 _git_merge ()
1795 {
1796         __git_complete_strategy && return
1797
1798         case "$cur" in
1799         --*)
1800                 __gitcomp_builtin merge "--no-rerere-autoupdate
1801                                 --no-commit --no-edit --no-ff
1802                                 --no-log --no-progress
1803                                 --no-squash --no-stat
1804                                 --no-verify-signatures
1805                                 "
1806                 return
1807         esac
1808         __git_complete_refs
1809 }
1810
1811 _git_mergetool ()
1812 {
1813         case "$cur" in
1814         --tool=*)
1815                 __gitcomp "$__git_mergetools_common tortoisemerge" "" "${cur##--tool=}"
1816                 return
1817                 ;;
1818         --*)
1819                 __gitcomp "--tool= --prompt --no-prompt"
1820                 return
1821                 ;;
1822         esac
1823 }
1824
1825 _git_merge_base ()
1826 {
1827         case "$cur" in
1828         --*)
1829                 __gitcomp_builtin merge-base
1830                 return
1831                 ;;
1832         esac
1833         __git_complete_refs
1834 }
1835
1836 _git_mv ()
1837 {
1838         case "$cur" in
1839         --*)
1840                 __gitcomp_builtin mv
1841                 return
1842                 ;;
1843         esac
1844
1845         if [ $(__git_count_arguments "mv") -gt 0 ]; then
1846                 # We need to show both cached and untracked files (including
1847                 # empty directories) since this may not be the last argument.
1848                 __git_complete_index_file "--cached --others --directory"
1849         else
1850                 __git_complete_index_file "--cached"
1851         fi
1852 }
1853
1854 _git_notes ()
1855 {
1856         local subcommands='add append copy edit get-ref list merge prune remove show'
1857         local subcommand="$(__git_find_on_cmdline "$subcommands")"
1858
1859         case "$subcommand,$cur" in
1860         ,--*)
1861                 __gitcomp_builtin notes
1862                 ;;
1863         ,*)
1864                 case "$prev" in
1865                 --ref)
1866                         __git_complete_refs
1867                         ;;
1868                 *)
1869                         __gitcomp "$subcommands --ref"
1870                         ;;
1871                 esac
1872                 ;;
1873         *,--reuse-message=*|*,--reedit-message=*)
1874                 __git_complete_refs --cur="${cur#*=}"
1875                 ;;
1876         *,--*)
1877                 __gitcomp_builtin notes_$subcommand
1878                 ;;
1879         prune,*|get-ref,*)
1880                 # this command does not take a ref, do not complete it
1881                 ;;
1882         *)
1883                 case "$prev" in
1884                 -m|-F)
1885                         ;;
1886                 *)
1887                         __git_complete_refs
1888                         ;;
1889                 esac
1890                 ;;
1891         esac
1892 }
1893
1894 _git_pull ()
1895 {
1896         __git_complete_strategy && return
1897
1898         case "$cur" in
1899         --recurse-submodules=*)
1900                 __gitcomp "$__git_fetch_recurse_submodules" "" "${cur##--recurse-submodules=}"
1901                 return
1902                 ;;
1903         --*)
1904                 __gitcomp_builtin pull "--no-autostash --no-commit --no-edit
1905                                         --no-ff --no-log --no-progress --no-rebase
1906                                         --no-squash --no-stat --no-tags
1907                                         --no-verify-signatures"
1908
1909                 return
1910                 ;;
1911         esac
1912         __git_complete_remote_or_refspec
1913 }
1914
1915 __git_push_recurse_submodules="check on-demand only"
1916
1917 __git_complete_force_with_lease ()
1918 {
1919         local cur_=$1
1920
1921         case "$cur_" in
1922         --*=)
1923                 ;;
1924         *:*)
1925                 __git_complete_refs --cur="${cur_#*:}"
1926                 ;;
1927         *)
1928                 __git_complete_refs --cur="$cur_"
1929                 ;;
1930         esac
1931 }
1932
1933 _git_push ()
1934 {
1935         case "$prev" in
1936         --repo)
1937                 __gitcomp_nl "$(__git_remotes)"
1938                 return
1939                 ;;
1940         --recurse-submodules)
1941                 __gitcomp "$__git_push_recurse_submodules"
1942                 return
1943                 ;;
1944         esac
1945         case "$cur" in
1946         --repo=*)
1947                 __gitcomp_nl "$(__git_remotes)" "" "${cur##--repo=}"
1948                 return
1949                 ;;
1950         --recurse-submodules=*)
1951                 __gitcomp "$__git_push_recurse_submodules" "" "${cur##--recurse-submodules=}"
1952                 return
1953                 ;;
1954         --force-with-lease=*)
1955                 __git_complete_force_with_lease "${cur##--force-with-lease=}"
1956                 return
1957                 ;;
1958         --*)
1959                 __gitcomp_builtin push
1960                 return
1961                 ;;
1962         esac
1963         __git_complete_remote_or_refspec
1964 }
1965
1966 _git_rebase ()
1967 {
1968         __git_find_repo_path
1969         if [ -f "$__git_repo_path"/rebase-merge/interactive ]; then
1970                 __gitcomp "--continue --skip --abort --quit --edit-todo --show-current-patch"
1971                 return
1972         elif [ -d "$__git_repo_path"/rebase-apply ] || \
1973              [ -d "$__git_repo_path"/rebase-merge ]; then
1974                 __gitcomp "--continue --skip --abort --quit --show-current-patch"
1975                 return
1976         fi
1977         __git_complete_strategy && return
1978         case "$cur" in
1979         --whitespace=*)
1980                 __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
1981                 return
1982                 ;;
1983         --*)
1984                 __gitcomp "
1985                         --onto --merge --strategy --interactive
1986                         --rebase-merges --preserve-merges --stat --no-stat
1987                         --committer-date-is-author-date --ignore-date
1988                         --ignore-whitespace --whitespace=
1989                         --autosquash --no-autosquash
1990                         --fork-point --no-fork-point
1991                         --autostash --no-autostash
1992                         --verify --no-verify
1993                         --keep-empty --root --force-rebase --no-ff
1994                         --rerere-autoupdate
1995                         --exec
1996                         "
1997
1998                 return
1999         esac
2000         __git_complete_refs
2001 }
2002
2003 _git_reflog ()
2004 {
2005         local subcommands="show delete expire"
2006         local subcommand="$(__git_find_on_cmdline "$subcommands")"
2007
2008         if [ -z "$subcommand" ]; then
2009                 __gitcomp "$subcommands"
2010         else
2011                 __git_complete_refs
2012         fi
2013 }
2014
2015 __git_send_email_confirm_options="always never auto cc compose"
2016 __git_send_email_suppresscc_options="author self cc bodycc sob cccmd body all"
2017
2018 _git_send_email ()
2019 {
2020         case "$prev" in
2021         --to|--cc|--bcc|--from)
2022                 __gitcomp "$(__git send-email --dump-aliases)"
2023                 return
2024                 ;;
2025         esac
2026
2027         case "$cur" in
2028         --confirm=*)
2029                 __gitcomp "
2030                         $__git_send_email_confirm_options
2031                         " "" "${cur##--confirm=}"
2032                 return
2033                 ;;
2034         --suppress-cc=*)
2035                 __gitcomp "
2036                         $__git_send_email_suppresscc_options
2037                         " "" "${cur##--suppress-cc=}"
2038
2039                 return
2040                 ;;
2041         --smtp-encryption=*)
2042                 __gitcomp "ssl tls" "" "${cur##--smtp-encryption=}"
2043                 return
2044                 ;;
2045         --thread=*)
2046                 __gitcomp "
2047                         deep shallow
2048                         " "" "${cur##--thread=}"
2049                 return
2050                 ;;
2051         --to=*|--cc=*|--bcc=*|--from=*)
2052                 __gitcomp "$(__git send-email --dump-aliases)" "" "${cur#--*=}"
2053                 return
2054                 ;;
2055         --*)
2056                 __gitcomp "--annotate --bcc --cc --cc-cmd --chain-reply-to
2057                         --compose --confirm= --dry-run --envelope-sender
2058                         --from --identity
2059                         --in-reply-to --no-chain-reply-to --no-signed-off-by-cc
2060                         --no-suppress-from --no-thread --quiet --reply-to
2061                         --signed-off-by-cc --smtp-pass --smtp-server
2062                         --smtp-server-port --smtp-encryption= --smtp-user
2063                         --subject --suppress-cc= --suppress-from --thread --to
2064                         --validate --no-validate
2065                         $__git_format_patch_options"
2066                 return
2067                 ;;
2068         esac
2069         __git_complete_revlist
2070 }
2071
2072 _git_stage ()
2073 {
2074         _git_add
2075 }
2076
2077 _git_status ()
2078 {
2079         local complete_opt
2080         local untracked_state
2081
2082         case "$cur" in
2083         --ignore-submodules=*)
2084                 __gitcomp "none untracked dirty all" "" "${cur##--ignore-submodules=}"
2085                 return
2086                 ;;
2087         --untracked-files=*)
2088                 __gitcomp "$__git_untracked_file_modes" "" "${cur##--untracked-files=}"
2089                 return
2090                 ;;
2091         --column=*)
2092                 __gitcomp "
2093                         always never auto column row plain dense nodense
2094                         " "" "${cur##--column=}"
2095                 return
2096                 ;;
2097         --*)
2098                 __gitcomp_builtin status "--no-column"
2099                 return
2100                 ;;
2101         esac
2102
2103         untracked_state="$(__git_get_option_value "-u" "--untracked-files=" \
2104                 "$__git_untracked_file_modes" "status.showUntrackedFiles")"
2105
2106         case "$untracked_state" in
2107         no)
2108                 # --ignored option does not matter
2109                 complete_opt=
2110                 ;;
2111         all|normal|*)
2112                 complete_opt="--cached --directory --no-empty-directory --others"
2113
2114                 if [ -n "$(__git_find_on_cmdline "--ignored")" ]; then
2115                         complete_opt="$complete_opt --ignored --exclude=*"
2116                 fi
2117                 ;;
2118         esac
2119
2120         __git_complete_index_file "$complete_opt"
2121 }
2122
2123 __git_config_get_set_variables ()
2124 {
2125         local prevword word config_file= c=$cword
2126         while [ $c -gt 1 ]; do
2127                 word="${words[c]}"
2128                 case "$word" in
2129                 --system|--global|--local|--file=*)
2130                         config_file="$word"
2131                         break
2132                         ;;
2133                 -f|--file)
2134                         config_file="$word $prevword"
2135                         break
2136                         ;;
2137                 esac
2138                 prevword=$word
2139                 c=$((--c))
2140         done
2141
2142         __git config $config_file --name-only --list
2143 }
2144
2145 _git_config ()
2146 {
2147         case "$prev" in
2148         branch.*.remote|branch.*.pushremote)
2149                 __gitcomp_nl "$(__git_remotes)"
2150                 return
2151                 ;;
2152         branch.*.merge)
2153                 __git_complete_refs
2154                 return
2155                 ;;
2156         branch.*.rebase)
2157                 __gitcomp "false true merges preserve interactive"
2158                 return
2159                 ;;
2160         remote.pushdefault)
2161                 __gitcomp_nl "$(__git_remotes)"
2162                 return
2163                 ;;
2164         remote.*.fetch)
2165                 local remote="${prev#remote.}"
2166                 remote="${remote%.fetch}"
2167                 if [ -z "$cur" ]; then
2168                         __gitcomp_nl "refs/heads/" "" "" ""
2169                         return
2170                 fi
2171                 __gitcomp_nl "$(__git_refs_remotes "$remote")"
2172                 return
2173                 ;;
2174         remote.*.push)
2175                 local remote="${prev#remote.}"
2176                 remote="${remote%.push}"
2177                 __gitcomp_nl "$(__git for-each-ref \
2178                         --format='%(refname):%(refname)' refs/heads)"
2179                 return
2180                 ;;
2181         pull.twohead|pull.octopus)
2182                 __git_compute_merge_strategies
2183                 __gitcomp "$__git_merge_strategies"
2184                 return
2185                 ;;
2186         color.branch|color.diff|color.interactive|\
2187         color.showbranch|color.status|color.ui)
2188                 __gitcomp "always never auto"
2189                 return
2190                 ;;
2191         color.pager)
2192                 __gitcomp "false true"
2193                 return
2194                 ;;
2195         color.*.*)
2196                 __gitcomp "
2197                         normal black red green yellow blue magenta cyan white
2198                         bold dim ul blink reverse
2199                         "
2200                 return
2201                 ;;
2202         diff.submodule)
2203                 __gitcomp "log short"
2204                 return
2205                 ;;
2206         help.format)
2207                 __gitcomp "man info web html"
2208                 return
2209                 ;;
2210         log.date)
2211                 __gitcomp "$__git_log_date_formats"
2212                 return
2213                 ;;
2214         sendemail.aliasfiletype)
2215                 __gitcomp "mutt mailrc pine elm gnus"
2216                 return
2217                 ;;
2218         sendemail.confirm)
2219                 __gitcomp "$__git_send_email_confirm_options"
2220                 return
2221                 ;;
2222         sendemail.suppresscc)
2223                 __gitcomp "$__git_send_email_suppresscc_options"
2224                 return
2225                 ;;
2226         sendemail.transferencoding)
2227                 __gitcomp "7bit 8bit quoted-printable base64"
2228                 return
2229                 ;;
2230         --get|--get-all|--unset|--unset-all)
2231                 __gitcomp_nl "$(__git_config_get_set_variables)"
2232                 return
2233                 ;;
2234         *.*)
2235                 return
2236                 ;;
2237         esac
2238         case "$cur" in
2239         --*)
2240                 __gitcomp_builtin config
2241                 return
2242                 ;;
2243         branch.*.*)
2244                 local pfx="${cur%.*}." cur_="${cur##*.}"
2245                 __gitcomp "remote pushremote merge mergeoptions rebase" "$pfx" "$cur_"
2246                 return
2247                 ;;
2248         branch.*)
2249                 local pfx="${cur%.*}." cur_="${cur#*.}"
2250                 __gitcomp_direct "$(__git_heads "$pfx" "$cur_" ".")"
2251                 __gitcomp_nl_append $'autosetupmerge\nautosetuprebase\n' "$pfx" "$cur_"
2252                 return
2253                 ;;
2254         guitool.*.*)
2255                 local pfx="${cur%.*}." cur_="${cur##*.}"
2256                 __gitcomp "
2257                         argprompt cmd confirm needsfile noconsole norescan
2258                         prompt revprompt revunmerged title
2259                         " "$pfx" "$cur_"
2260                 return
2261                 ;;
2262         difftool.*.*)
2263                 local pfx="${cur%.*}." cur_="${cur##*.}"
2264                 __gitcomp "cmd path" "$pfx" "$cur_"
2265                 return
2266                 ;;
2267         man.*.*)
2268                 local pfx="${cur%.*}." cur_="${cur##*.}"
2269                 __gitcomp "cmd path" "$pfx" "$cur_"
2270                 return
2271                 ;;
2272         mergetool.*.*)
2273                 local pfx="${cur%.*}." cur_="${cur##*.}"
2274                 __gitcomp "cmd path trustExitCode" "$pfx" "$cur_"
2275                 return
2276                 ;;
2277         pager.*)
2278                 local pfx="${cur%.*}." cur_="${cur#*.}"
2279                 __git_compute_all_commands
2280                 __gitcomp_nl "$__git_all_commands" "$pfx" "$cur_"
2281                 return
2282                 ;;
2283         remote.*.*)
2284                 local pfx="${cur%.*}." cur_="${cur##*.}"
2285                 __gitcomp "
2286                         url proxy fetch push mirror skipDefaultUpdate
2287                         receivepack uploadpack tagopt pushurl
2288                         " "$pfx" "$cur_"
2289                 return
2290                 ;;
2291         remote.*)
2292                 local pfx="${cur%.*}." cur_="${cur#*.}"
2293                 __gitcomp_nl "$(__git_remotes)" "$pfx" "$cur_" "."
2294                 __gitcomp_nl_append "pushdefault" "$pfx" "$cur_"
2295                 return
2296                 ;;
2297         url.*.*)
2298                 local pfx="${cur%.*}." cur_="${cur##*.}"
2299                 __gitcomp "insteadOf pushInsteadOf" "$pfx" "$cur_"
2300                 return
2301                 ;;
2302         esac
2303         __gitcomp "
2304                 add.ignoreErrors
2305                 advice.amWorkDir
2306                 advice.commitBeforeMerge
2307                 advice.detachedHead
2308                 advice.implicitIdentity
2309                 advice.pushAlreadyExists
2310                 advice.pushFetchFirst
2311                 advice.pushNeedsForce
2312                 advice.pushNonFFCurrent
2313                 advice.pushNonFFMatching
2314                 advice.pushUpdateRejected
2315                 advice.resolveConflict
2316                 advice.rmHints
2317                 advice.statusHints
2318                 advice.statusUoption
2319                 advice.ignoredHook
2320                 alias.
2321                 am.keepcr
2322                 am.threeWay
2323                 apply.ignorewhitespace
2324                 apply.whitespace
2325                 branch.autosetupmerge
2326                 branch.autosetuprebase
2327                 browser.
2328                 clean.requireForce
2329                 color.branch
2330                 color.branch.current
2331                 color.branch.local
2332                 color.branch.plain
2333                 color.branch.remote
2334                 color.decorate.HEAD
2335                 color.decorate.branch
2336                 color.decorate.remoteBranch
2337                 color.decorate.stash
2338                 color.decorate.tag
2339                 color.diff
2340                 color.diff.commit
2341                 color.diff.frag
2342                 color.diff.func
2343                 color.diff.meta
2344                 color.diff.new
2345                 color.diff.old
2346                 color.diff.plain
2347                 color.diff.whitespace
2348                 color.grep
2349                 color.grep.context
2350                 color.grep.filename
2351                 color.grep.function
2352                 color.grep.linenumber
2353                 color.grep.match
2354                 color.grep.selected
2355                 color.grep.separator
2356                 color.interactive
2357                 color.interactive.error
2358                 color.interactive.header
2359                 color.interactive.help
2360                 color.interactive.prompt
2361                 color.pager
2362                 color.showbranch
2363                 color.status
2364                 color.status.added
2365                 color.status.changed
2366                 color.status.header
2367                 color.status.localBranch
2368                 color.status.nobranch
2369                 color.status.remoteBranch
2370                 color.status.unmerged
2371                 color.status.untracked
2372                 color.status.updated
2373                 color.ui
2374                 commit.cleanup
2375                 commit.gpgSign
2376                 commit.status
2377                 commit.template
2378                 commit.verbose
2379                 core.abbrev
2380                 core.askpass
2381                 core.attributesfile
2382                 core.autocrlf
2383                 core.bare
2384                 core.bigFileThreshold
2385                 core.checkStat
2386                 core.commentChar
2387                 core.commitGraph
2388                 core.compression
2389                 core.createObject
2390                 core.deltaBaseCacheLimit
2391                 core.editor
2392                 core.eol
2393                 core.excludesfile
2394                 core.fileMode
2395                 core.fsyncobjectfiles
2396                 core.gitProxy
2397                 core.hideDotFiles
2398                 core.hooksPath
2399                 core.ignoreStat
2400                 core.ignorecase
2401                 core.logAllRefUpdates
2402                 core.loosecompression
2403                 core.notesRef
2404                 core.packedGitLimit
2405                 core.packedGitWindowSize
2406                 core.packedRefsTimeout
2407                 core.pager
2408                 core.precomposeUnicode
2409                 core.preferSymlinkRefs
2410                 core.preloadindex
2411                 core.protectHFS
2412                 core.protectNTFS
2413                 core.quotepath
2414                 core.repositoryFormatVersion
2415                 core.safecrlf
2416                 core.sharedRepository
2417                 core.sparseCheckout
2418                 core.splitIndex
2419                 core.sshCommand
2420                 core.symlinks
2421                 core.trustctime
2422                 core.untrackedCache
2423                 core.warnAmbiguousRefs
2424                 core.whitespace
2425                 core.worktree
2426                 credential.helper
2427                 credential.useHttpPath
2428                 credential.username
2429                 credentialCache.ignoreSIGHUP
2430                 diff.autorefreshindex
2431                 diff.external
2432                 diff.ignoreSubmodules
2433                 diff.mnemonicprefix
2434                 diff.noprefix
2435                 diff.renameLimit
2436                 diff.renames
2437                 diff.statGraphWidth
2438                 diff.submodule
2439                 diff.suppressBlankEmpty
2440                 diff.tool
2441                 diff.wordRegex
2442                 diff.algorithm
2443                 difftool.
2444                 difftool.prompt
2445                 fetch.recurseSubmodules
2446                 fetch.unpackLimit
2447                 format.attach
2448                 format.cc
2449                 format.coverLetter
2450                 format.from
2451                 format.headers
2452                 format.numbered
2453                 format.pretty
2454                 format.signature
2455                 format.signoff
2456                 format.subjectprefix
2457                 format.suffix
2458                 format.thread
2459                 format.to
2460                 gc.
2461                 gc.aggressiveDepth
2462                 gc.aggressiveWindow
2463                 gc.auto
2464                 gc.autoDetach
2465                 gc.autopacklimit
2466                 gc.logExpiry
2467                 gc.packrefs
2468                 gc.pruneexpire
2469                 gc.reflogexpire
2470                 gc.reflogexpireunreachable
2471                 gc.rerereresolved
2472                 gc.rerereunresolved
2473                 gc.worktreePruneExpire
2474                 gitcvs.allbinary
2475                 gitcvs.commitmsgannotation
2476                 gitcvs.dbTableNamePrefix
2477                 gitcvs.dbdriver
2478                 gitcvs.dbname
2479                 gitcvs.dbpass
2480                 gitcvs.dbuser
2481                 gitcvs.enabled
2482                 gitcvs.logfile
2483                 gitcvs.usecrlfattr
2484                 guitool.
2485                 gui.blamehistoryctx
2486                 gui.commitmsgwidth
2487                 gui.copyblamethreshold
2488                 gui.diffcontext
2489                 gui.encoding
2490                 gui.fastcopyblame
2491                 gui.matchtrackingbranch
2492                 gui.newbranchtemplate
2493                 gui.pruneduringfetch
2494                 gui.spellingdictionary
2495                 gui.trustmtime
2496                 help.autocorrect
2497                 help.browser
2498                 help.format
2499                 http.lowSpeedLimit
2500                 http.lowSpeedTime
2501                 http.maxRequests
2502                 http.minSessions
2503                 http.noEPSV
2504                 http.postBuffer
2505                 http.proxy
2506                 http.sslCipherList
2507                 http.sslVersion
2508                 http.sslCAInfo
2509                 http.sslCAPath
2510                 http.sslCert
2511                 http.sslCertPasswordProtected
2512                 http.sslKey
2513                 http.sslVerify
2514                 http.useragent
2515                 i18n.commitEncoding
2516                 i18n.logOutputEncoding
2517                 imap.authMethod
2518                 imap.folder
2519                 imap.host
2520                 imap.pass
2521                 imap.port
2522                 imap.preformattedHTML
2523                 imap.sslverify
2524                 imap.tunnel
2525                 imap.user
2526                 init.templatedir
2527                 instaweb.browser
2528                 instaweb.httpd
2529                 instaweb.local
2530                 instaweb.modulepath
2531                 instaweb.port
2532                 interactive.singlekey
2533                 log.date
2534                 log.decorate
2535                 log.showroot
2536                 mailmap.file
2537                 man.
2538                 man.viewer
2539                 merge.
2540                 merge.conflictstyle
2541                 merge.log
2542                 merge.renameLimit
2543                 merge.renormalize
2544                 merge.stat
2545                 merge.tool
2546                 merge.verbosity
2547                 mergetool.
2548                 mergetool.keepBackup
2549                 mergetool.keepTemporaries
2550                 mergetool.prompt
2551                 notes.displayRef
2552                 notes.rewrite.
2553                 notes.rewrite.amend
2554                 notes.rewrite.rebase
2555                 notes.rewriteMode
2556                 notes.rewriteRef
2557                 pack.compression
2558                 pack.deltaCacheLimit
2559                 pack.deltaCacheSize
2560                 pack.depth
2561                 pack.indexVersion
2562                 pack.packSizeLimit
2563                 pack.threads
2564                 pack.window
2565                 pack.windowMemory
2566                 pager.
2567                 pretty.
2568                 pull.octopus
2569                 pull.twohead
2570                 push.default
2571                 push.followTags
2572                 rebase.autosquash
2573                 rebase.stat
2574                 receive.autogc
2575                 receive.denyCurrentBranch
2576                 receive.denyDeleteCurrent
2577                 receive.denyDeletes
2578                 receive.denyNonFastForwards
2579                 receive.fsckObjects
2580                 receive.unpackLimit
2581                 receive.updateserverinfo
2582                 remote.pushdefault
2583                 remotes.
2584                 repack.usedeltabaseoffset
2585                 rerere.autoupdate
2586                 rerere.enabled
2587                 sendemail.
2588                 sendemail.aliasesfile
2589                 sendemail.aliasfiletype
2590                 sendemail.bcc
2591                 sendemail.cc
2592                 sendemail.cccmd
2593                 sendemail.chainreplyto
2594                 sendemail.confirm
2595                 sendemail.envelopesender
2596                 sendemail.from
2597                 sendemail.identity
2598                 sendemail.multiedit
2599                 sendemail.signedoffbycc
2600                 sendemail.smtpdomain
2601                 sendemail.smtpencryption
2602                 sendemail.smtppass
2603                 sendemail.smtpserver
2604                 sendemail.smtpserveroption
2605                 sendemail.smtpserverport
2606                 sendemail.smtpuser
2607                 sendemail.suppresscc
2608                 sendemail.suppressfrom
2609                 sendemail.thread
2610                 sendemail.to
2611                 sendemail.tocmd
2612                 sendemail.validate
2613                 sendemail.smtpbatchsize
2614                 sendemail.smtprelogindelay
2615                 showbranch.default
2616                 status.relativePaths
2617                 status.showUntrackedFiles
2618                 status.submodulesummary
2619                 submodule.
2620                 tar.umask
2621                 transfer.unpackLimit
2622                 url.
2623                 user.email
2624                 user.name
2625                 user.signingkey
2626                 web.browser
2627                 branch. remote.
2628         "
2629 }
2630
2631 _git_remote ()
2632 {
2633         local subcommands="
2634                 add rename remove set-head set-branches
2635                 get-url set-url show prune update
2636                 "
2637         local subcommand="$(__git_find_on_cmdline "$subcommands")"
2638         if [ -z "$subcommand" ]; then
2639                 case "$cur" in
2640                 --*)
2641                         __gitcomp_builtin remote
2642                         ;;
2643                 *)
2644                         __gitcomp "$subcommands"
2645                         ;;
2646                 esac
2647                 return
2648         fi
2649
2650         case "$subcommand,$cur" in
2651         add,--*)
2652                 __gitcomp_builtin remote_add "--no-tags"
2653                 ;;
2654         add,*)
2655                 ;;
2656         set-head,--*)
2657                 __gitcomp_builtin remote_set-head
2658                 ;;
2659         set-branches,--*)
2660                 __gitcomp_builtin remote_set-branches
2661                 ;;
2662         set-head,*|set-branches,*)
2663                 __git_complete_remote_or_refspec
2664                 ;;
2665         update,--*)
2666                 __gitcomp_builtin remote_update
2667                 ;;
2668         update,*)
2669                 __gitcomp "$(__git_get_config_variables "remotes")"
2670                 ;;
2671         set-url,--*)
2672                 __gitcomp_builtin remote_set-url
2673                 ;;
2674         get-url,--*)
2675                 __gitcomp_builtin remote_get-url
2676                 ;;
2677         prune,--*)
2678                 __gitcomp_builtin remote_prune
2679                 ;;
2680         *)
2681                 __gitcomp_nl "$(__git_remotes)"
2682                 ;;
2683         esac
2684 }
2685
2686 _git_replace ()
2687 {
2688         case "$cur" in
2689         --*)
2690                 __gitcomp_builtin replace
2691                 return
2692                 ;;
2693         esac
2694         __git_complete_refs
2695 }
2696
2697 _git_rerere ()
2698 {
2699         local subcommands="clear forget diff remaining status gc"
2700         local subcommand="$(__git_find_on_cmdline "$subcommands")"
2701         if test -z "$subcommand"
2702         then
2703                 __gitcomp "$subcommands"
2704                 return
2705         fi
2706 }
2707
2708 _git_reset ()
2709 {
2710         __git_has_doubledash && return
2711
2712         case "$cur" in
2713         --*)
2714                 __gitcomp_builtin reset
2715                 return
2716                 ;;
2717         esac
2718         __git_complete_refs
2719 }
2720
2721 __git_revert_inprogress_options="--continue --quit --abort"
2722
2723 _git_revert ()
2724 {
2725         __git_find_repo_path
2726         if [ -f "$__git_repo_path"/REVERT_HEAD ]; then
2727                 __gitcomp "$__git_revert_inprogress_options"
2728                 return
2729         fi
2730         case "$cur" in
2731         --*)
2732                 __gitcomp_builtin revert "--no-edit" \
2733                         "$__git_revert_inprogress_options"
2734                 return
2735                 ;;
2736         esac
2737         __git_complete_refs
2738 }
2739
2740 _git_rm ()
2741 {
2742         case "$cur" in
2743         --*)
2744                 __gitcomp_builtin rm
2745                 return
2746                 ;;
2747         esac
2748
2749         __git_complete_index_file "--cached"
2750 }
2751
2752 _git_shortlog ()
2753 {
2754         __git_has_doubledash && return
2755
2756         case "$cur" in
2757         --*)
2758                 __gitcomp "
2759                         $__git_log_common_options
2760                         $__git_log_shortlog_options
2761                         --numbered --summary --email
2762                         "
2763                 return
2764                 ;;
2765         esac
2766         __git_complete_revlist
2767 }
2768
2769 _git_show ()
2770 {
2771         __git_has_doubledash && return
2772
2773         case "$cur" in
2774         --pretty=*|--format=*)
2775                 __gitcomp "$__git_log_pretty_formats $(__git_pretty_aliases)
2776                         " "" "${cur#*=}"
2777                 return
2778                 ;;
2779         --diff-algorithm=*)
2780                 __gitcomp "$__git_diff_algorithms" "" "${cur##--diff-algorithm=}"
2781                 return
2782                 ;;
2783         --submodule=*)
2784                 __gitcomp "$__git_diff_submodule_formats" "" "${cur##--submodule=}"
2785                 return
2786                 ;;
2787         --*)
2788                 __gitcomp "--pretty= --format= --abbrev-commit --oneline
2789                         --show-signature
2790                         $__git_diff_common_options
2791                         "
2792                 return
2793                 ;;
2794         esac
2795         __git_complete_revlist_file
2796 }
2797
2798 _git_show_branch ()
2799 {
2800         case "$cur" in
2801         --*)
2802                 __gitcomp_builtin show-branch "--no-color"
2803                 return
2804                 ;;
2805         esac
2806         __git_complete_revlist
2807 }
2808
2809 _git_stash ()
2810 {
2811         local save_opts='--all --keep-index --no-keep-index --quiet --patch --include-untracked'
2812         local subcommands='push list show apply clear drop pop create branch'
2813         local subcommand="$(__git_find_on_cmdline "$subcommands save")"
2814         if [ -n "$(__git_find_on_cmdline "-p")" ]; then
2815                 subcommand="push"
2816         fi
2817         if [ -z "$subcommand" ]; then
2818                 case "$cur" in
2819                 --*)
2820                         __gitcomp "$save_opts"
2821                         ;;
2822                 sa*)
2823                         if [ -z "$(__git_find_on_cmdline "$save_opts")" ]; then
2824                                 __gitcomp "save"
2825                         fi
2826                         ;;
2827                 *)
2828                         if [ -z "$(__git_find_on_cmdline "$save_opts")" ]; then
2829                                 __gitcomp "$subcommands"
2830                         fi
2831                         ;;
2832                 esac
2833         else
2834                 case "$subcommand,$cur" in
2835                 push,--*)
2836                         __gitcomp "$save_opts --message"
2837                         ;;
2838                 save,--*)
2839                         __gitcomp "$save_opts"
2840                         ;;
2841                 apply,--*|pop,--*)
2842                         __gitcomp "--index --quiet"
2843                         ;;
2844                 drop,--*)
2845                         __gitcomp "--quiet"
2846                         ;;
2847                 show,--*|branch,--*)
2848                         ;;
2849                 branch,*)
2850                         if [ $cword -eq 3 ]; then
2851                                 __git_complete_refs
2852                         else
2853                                 __gitcomp_nl "$(__git stash list \
2854                                                 | sed -n -e 's/:.*//p')"
2855                         fi
2856                         ;;
2857                 show,*|apply,*|drop,*|pop,*)
2858                         __gitcomp_nl "$(__git stash list \
2859                                         | sed -n -e 's/:.*//p')"
2860                         ;;
2861                 *)
2862                         ;;
2863                 esac
2864         fi
2865 }
2866
2867 _git_submodule ()
2868 {
2869         __git_has_doubledash && return
2870
2871         local subcommands="add status init deinit update summary foreach sync"
2872         local subcommand="$(__git_find_on_cmdline "$subcommands")"
2873         if [ -z "$subcommand" ]; then
2874                 case "$cur" in
2875                 --*)
2876                         __gitcomp "--quiet"
2877                         ;;
2878                 *)
2879                         __gitcomp "$subcommands"
2880                         ;;
2881                 esac
2882                 return
2883         fi
2884
2885         case "$subcommand,$cur" in
2886         add,--*)
2887                 __gitcomp "--branch --force --name --reference --depth"
2888                 ;;
2889         status,--*)
2890                 __gitcomp "--cached --recursive"
2891                 ;;
2892         deinit,--*)
2893                 __gitcomp "--force --all"
2894                 ;;
2895         update,--*)
2896                 __gitcomp "
2897                         --init --remote --no-fetch
2898                         --recommend-shallow --no-recommend-shallow
2899                         --force --rebase --merge --reference --depth --recursive --jobs
2900                 "
2901                 ;;
2902         summary,--*)
2903                 __gitcomp "--cached --files --summary-limit"
2904                 ;;
2905         foreach,--*|sync,--*)
2906                 __gitcomp "--recursive"
2907                 ;;
2908         *)
2909                 ;;
2910         esac
2911 }
2912
2913 _git_svn ()
2914 {
2915         local subcommands="
2916                 init fetch clone rebase dcommit log find-rev
2917                 set-tree commit-diff info create-ignore propget
2918                 proplist show-ignore show-externals branch tag blame
2919                 migrate mkdirs reset gc
2920                 "
2921         local subcommand="$(__git_find_on_cmdline "$subcommands")"
2922         if [ -z "$subcommand" ]; then
2923                 __gitcomp "$subcommands"
2924         else
2925                 local remote_opts="--username= --config-dir= --no-auth-cache"
2926                 local fc_opts="
2927                         --follow-parent --authors-file= --repack=
2928                         --no-metadata --use-svm-props --use-svnsync-props
2929                         --log-window-size= --no-checkout --quiet
2930                         --repack-flags --use-log-author --localtime
2931                         --add-author-from
2932                         --ignore-paths= --include-paths= $remote_opts
2933                         "
2934                 local init_opts="
2935                         --template= --shared= --trunk= --tags=
2936                         --branches= --stdlayout --minimize-url
2937                         --no-metadata --use-svm-props --use-svnsync-props
2938                         --rewrite-root= --prefix= $remote_opts
2939                         "
2940                 local cmt_opts="
2941                         --edit --rmdir --find-copies-harder --copy-similarity=
2942                         "
2943
2944                 case "$subcommand,$cur" in
2945                 fetch,--*)
2946                         __gitcomp "--revision= --fetch-all $fc_opts"
2947                         ;;
2948                 clone,--*)
2949                         __gitcomp "--revision= $fc_opts $init_opts"
2950                         ;;
2951                 init,--*)
2952                         __gitcomp "$init_opts"
2953                         ;;
2954                 dcommit,--*)
2955                         __gitcomp "
2956                                 --merge --strategy= --verbose --dry-run
2957                                 --fetch-all --no-rebase --commit-url
2958                                 --revision --interactive $cmt_opts $fc_opts
2959                                 "
2960                         ;;
2961                 set-tree,--*)
2962                         __gitcomp "--stdin $cmt_opts $fc_opts"
2963                         ;;
2964                 create-ignore,--*|propget,--*|proplist,--*|show-ignore,--*|\
2965                 show-externals,--*|mkdirs,--*)
2966                         __gitcomp "--revision="
2967                         ;;
2968                 log,--*)
2969                         __gitcomp "
2970                                 --limit= --revision= --verbose --incremental
2971                                 --oneline --show-commit --non-recursive
2972                                 --authors-file= --color
2973                                 "
2974                         ;;
2975                 rebase,--*)
2976                         __gitcomp "
2977                                 --merge --verbose --strategy= --local
2978                                 --fetch-all --dry-run $fc_opts
2979                                 "
2980                         ;;
2981                 commit-diff,--*)
2982                         __gitcomp "--message= --file= --revision= $cmt_opts"
2983                         ;;
2984                 info,--*)
2985                         __gitcomp "--url"
2986                         ;;
2987                 branch,--*)
2988                         __gitcomp "--dry-run --message --tag"
2989                         ;;
2990                 tag,--*)
2991                         __gitcomp "--dry-run --message"
2992                         ;;
2993                 blame,--*)
2994                         __gitcomp "--git-format"
2995                         ;;
2996                 migrate,--*)
2997                         __gitcomp "
2998                                 --config-dir= --ignore-paths= --minimize
2999                                 --no-auth-cache --username=
3000                                 "
3001                         ;;
3002                 reset,--*)
3003                         __gitcomp "--revision= --parent"
3004                         ;;
3005                 *)
3006                         ;;
3007                 esac
3008         fi
3009 }
3010
3011 _git_tag ()
3012 {
3013         local i c=1 f=0
3014         while [ $c -lt $cword ]; do
3015                 i="${words[c]}"
3016                 case "$i" in
3017                 -d|--delete|-v|--verify)
3018                         __gitcomp_direct "$(__git_tags "" "$cur" " ")"
3019                         return
3020                         ;;
3021                 -f)
3022                         f=1
3023                         ;;
3024                 esac
3025                 ((c++))
3026         done
3027
3028         case "$prev" in
3029         -m|-F)
3030                 ;;
3031         -*|tag)
3032                 if [ $f = 1 ]; then
3033                         __gitcomp_direct "$(__git_tags "" "$cur" " ")"
3034                 fi
3035                 ;;
3036         *)
3037                 __git_complete_refs
3038                 ;;
3039         esac
3040
3041         case "$cur" in
3042         --*)
3043                 __gitcomp_builtin tag
3044                 ;;
3045         esac
3046 }
3047
3048 _git_whatchanged ()
3049 {
3050         _git_log
3051 }
3052
3053 _git_worktree ()
3054 {
3055         local subcommands="add list lock move prune remove unlock"
3056         local subcommand="$(__git_find_on_cmdline "$subcommands")"
3057         if [ -z "$subcommand" ]; then
3058                 __gitcomp "$subcommands"
3059         else
3060                 case "$subcommand,$cur" in
3061                 add,--*)
3062                         __gitcomp_builtin worktree_add
3063                         ;;
3064                 list,--*)
3065                         __gitcomp_builtin worktree_list
3066                         ;;
3067                 lock,--*)
3068                         __gitcomp_builtin worktree_lock
3069                         ;;
3070                 prune,--*)
3071                         __gitcomp_builtin worktree_prune
3072                         ;;
3073                 remove,--*)
3074                         __gitcomp "--force"
3075                         ;;
3076                 *)
3077                         ;;
3078                 esac
3079         fi
3080 }
3081
3082 __git_complete_common () {
3083         local command="$1"
3084
3085         case "$cur" in
3086         --*)
3087                 __gitcomp_builtin "$command"
3088                 ;;
3089         esac
3090 }
3091
3092 __git_cmds_with_parseopt_helper=
3093 __git_support_parseopt_helper () {
3094         test -n "$__git_cmds_with_parseopt_helper" ||
3095                 __git_cmds_with_parseopt_helper="$(__git --list-cmds=parseopt)"
3096
3097         case " $__git_cmds_with_parseopt_helper " in
3098         *" $1 "*)
3099                 return 0
3100                 ;;
3101         *)
3102                 return 1
3103                 ;;
3104         esac
3105 }
3106
3107 __git_complete_command () {
3108         local command="$1"
3109         local completion_func="_git_${command//-/_}"
3110         if ! declare -f $completion_func >/dev/null 2>/dev/null &&
3111                 declare -f _completion_loader >/dev/null 2>/dev/null
3112         then
3113                 _completion_loader "git-$command"
3114         fi
3115         if declare -f $completion_func >/dev/null 2>/dev/null
3116         then
3117                 $completion_func
3118                 return 0
3119         elif __git_support_parseopt_helper "$command"
3120         then
3121                 __git_complete_common "$command"
3122                 return 0
3123         else
3124                 return 1
3125         fi
3126 }
3127
3128 __git_main ()
3129 {
3130         local i c=1 command __git_dir __git_repo_path
3131         local __git_C_args C_args_count=0
3132
3133         while [ $c -lt $cword ]; do
3134                 i="${words[c]}"
3135                 case "$i" in
3136                 --git-dir=*) __git_dir="${i#--git-dir=}" ;;
3137                 --git-dir)   ((c++)) ; __git_dir="${words[c]}" ;;
3138                 --bare)      __git_dir="." ;;
3139                 --help) command="help"; break ;;
3140                 -c|--work-tree|--namespace) ((c++)) ;;
3141                 -C)     __git_C_args[C_args_count++]=-C
3142                         ((c++))
3143                         __git_C_args[C_args_count++]="${words[c]}"
3144                         ;;
3145                 -*) ;;
3146                 *) command="$i"; break ;;
3147                 esac
3148                 ((c++))
3149         done
3150
3151         if [ -z "$command" ]; then
3152                 case "$prev" in
3153                 --git-dir|-C|--work-tree)
3154                         # these need a path argument, let's fall back to
3155                         # Bash filename completion
3156                         return
3157                         ;;
3158                 -c|--namespace)
3159                         # we don't support completing these options' arguments
3160                         return
3161                         ;;
3162                 esac
3163                 case "$cur" in
3164                 --*)   __gitcomp "
3165                         --paginate
3166                         --no-pager
3167                         --git-dir=
3168                         --bare
3169                         --version
3170                         --exec-path
3171                         --exec-path=
3172                         --html-path
3173                         --man-path
3174                         --info-path
3175                         --work-tree=
3176                         --namespace=
3177                         --no-replace-objects
3178                         --help
3179                         "
3180                         ;;
3181                 *)
3182                         if test -n "$GIT_TESTING_PORCELAIN_COMMAND_LIST"
3183                         then
3184                                 __gitcomp "$GIT_TESTING_PORCELAIN_COMMAND_LIST"
3185                         else
3186                                 __gitcomp "$(git --list-cmds=list-mainporcelain,others,nohelpers,alias,list-complete,config)"
3187                         fi
3188                         ;;
3189                 esac
3190                 return
3191         fi
3192
3193         __git_complete_command "$command" && return
3194
3195         local expansion=$(__git_aliased_command "$command")
3196         if [ -n "$expansion" ]; then
3197                 words[1]=$expansion
3198                 __git_complete_command "$expansion"
3199         fi
3200 }
3201
3202 __gitk_main ()
3203 {
3204         __git_has_doubledash && return
3205
3206         local __git_repo_path
3207         __git_find_repo_path
3208
3209         local merge=""
3210         if [ -f "$__git_repo_path/MERGE_HEAD" ]; then
3211                 merge="--merge"
3212         fi
3213         case "$cur" in
3214         --*)
3215                 __gitcomp "
3216                         $__git_log_common_options
3217                         $__git_log_gitk_options
3218                         $merge
3219                         "
3220                 return
3221                 ;;
3222         esac
3223         __git_complete_revlist
3224 }
3225
3226 if [[ -n ${ZSH_VERSION-} ]] &&
3227    # Don't define these functions when sourced from 'git-completion.zsh',
3228    # it has its own implementations.
3229    [[ -z ${GIT_SOURCING_ZSH_COMPLETION-} ]]; then
3230         echo "WARNING: this script is deprecated, please see git-completion.zsh" 1>&2
3231
3232         autoload -U +X compinit && compinit
3233
3234         __gitcomp ()
3235         {
3236                 emulate -L zsh
3237
3238                 local cur_="${3-$cur}"
3239
3240                 case "$cur_" in
3241                 --*=)
3242                         ;;
3243                 *)
3244                         local c IFS=$' \t\n'
3245                         local -a array
3246                         for c in ${=1}; do
3247                                 c="$c${4-}"
3248                                 case $c in
3249                                 --*=*|*.) ;;
3250                                 *) c="$c " ;;
3251                                 esac
3252                                 array[${#array[@]}+1]="$c"
3253                         done
3254                         compset -P '*[=:]'
3255                         compadd -Q -S '' -p "${2-}" -a -- array && _ret=0
3256                         ;;
3257                 esac
3258         }
3259
3260         __gitcomp_direct ()
3261         {
3262                 emulate -L zsh
3263
3264                 local IFS=$'\n'
3265                 compset -P '*[=:]'
3266                 compadd -Q -- ${=1} && _ret=0
3267         }
3268
3269         __gitcomp_nl ()
3270         {
3271                 emulate -L zsh
3272
3273                 local IFS=$'\n'
3274                 compset -P '*[=:]'
3275                 compadd -Q -S "${4- }" -p "${2-}" -- ${=1} && _ret=0
3276         }
3277
3278         __gitcomp_file_direct ()
3279         {
3280                 emulate -L zsh
3281
3282                 local IFS=$'\n'
3283                 compset -P '*[=:]'
3284                 compadd -Q -f -- ${=1} && _ret=0
3285         }
3286
3287         __gitcomp_file ()
3288         {
3289                 emulate -L zsh
3290
3291                 local IFS=$'\n'
3292                 compset -P '*[=:]'
3293                 compadd -Q -p "${2-}" -f -- ${=1} && _ret=0
3294         }
3295
3296         _git ()
3297         {
3298                 local _ret=1 cur cword prev
3299                 cur=${words[CURRENT]}
3300                 prev=${words[CURRENT-1]}
3301                 let cword=CURRENT-1
3302                 emulate ksh -c __${service}_main
3303                 let _ret && _default && _ret=0
3304                 return _ret
3305         }
3306
3307         compdef _git git gitk
3308         return
3309 fi
3310
3311 __git_func_wrap ()
3312 {
3313         local cur words cword prev
3314         _get_comp_words_by_ref -n =: cur words cword prev
3315         $1
3316 }
3317
3318 # Setup completion for certain functions defined above by setting common
3319 # variables and workarounds.
3320 # This is NOT a public function; use at your own risk.
3321 __git_complete ()
3322 {
3323         local wrapper="__git_wrap${2}"
3324         eval "$wrapper () { __git_func_wrap $2 ; }"
3325         complete -o bashdefault -o default -o nospace -F $wrapper $1 2>/dev/null \
3326                 || complete -o default -o nospace -F $wrapper $1
3327 }
3328
3329 # wrapper for backwards compatibility
3330 _git ()
3331 {
3332         __git_wrap__git_main
3333 }
3334
3335 # wrapper for backwards compatibility
3336 _gitk ()
3337 {
3338         __git_wrap__gitk_main
3339 }
3340
3341 __git_complete git __git_main
3342 __git_complete gitk __gitk_main
3343
3344 # The following are necessary only for Cygwin, and only are needed
3345 # when the user has tab-completed the executable name and consequently
3346 # included the '.exe' suffix.
3347 #
3348 if [ Cygwin = "$(uname -o 2>/dev/null)" ]; then
3349 __git_complete git.exe __git_main
3350 fi