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 #    *) tree paths within 'ref:path/to/file' expressions
  14 #    *) file paths within current working directory and index
  15 #    *) common --long-options
  16 #
  17 # To use these routines:
  18 #
  19 #    1) Copy this file to somewhere (e.g. ~/.git-completion.sh).
  20 #    2) Add the following line to your .bashrc/.zshrc:
  21 #        source ~/.git-completion.sh
  22 #    3) Consider changing your PS1 to also show the current branch,
  23 #       see git-prompt.sh for details.
  24 #
  25 # If you use complex aliases of form '!f() { ... }; f', you can use the null
  26 # command ':' as the first command in the function body to declare the desired
  27 # completion style.  For example '!f() { : git commit ; ... }; f' will
  28 # tell the completion to use commit completion.  This also works with aliases
  29 # of form "!sh -c '...'".  For example, "!sh -c ': git commit ; ... '".
  30
  31 case "$COMP_WORDBREAKS" in
  32 *:*) : great ;;
  33 *)   COMP_WORDBREAKS="$COMP_WORDBREAKS:"
  34 esac
  35
  36 # __gitdir accepts 0 or 1 arguments (i.e., location)
  37 # returns location of .git repo
  38 __gitdir ()
  39 {
  40         if [ -z "${1-}" ]; then
  41                 if [ -n "${__git_dir-}" ]; then
  42                         echo "$__git_dir"
  43                 elif [ -n "${GIT_DIR-}" ]; then
  44                         test -d "${GIT_DIR-}" || return 1
  45                         echo "$GIT_DIR"
  46                 elif [ -d .git ]; then
  47                         echo .git
  48                 else
  49                         git rev-parse --git-dir 2>/dev/null
  50                 fi
  51         elif [ -d "$1/.git" ]; then
  52                 echo "$1/.git"
  53         else
  54                 echo "$1"
  55         fi
  56 }
  57
  58 # The following function is based on code from:
  59 #
  60 #   bash_completion - programmable completion functions for bash 3.2+
  61 #
  62 #   Copyright © 2006-2008, Ian Macdonald <ian@caliban.org>
  63 #             © 2009-2010, Bash Completion Maintainers
  64 #                     <bash-completion-devel@lists.alioth.debian.org>
  65 #
  66 #   This program is free software; you can redistribute it and/or modify
  67 #   it under the terms of the GNU General Public License as published by
  68 #   the Free Software Foundation; either version 2, or (at your option)
  69 #   any later version.
  70 #
  71 #   This program is distributed in the hope that it will be useful,
  72 #   but WITHOUT ANY WARRANTY; without even the implied warranty of
  73 #   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  74 #   GNU General Public License for more details.
  75 #
  76 #   You should have received a copy of the GNU General Public License
  77 #   along with this program; if not, write to the Free Software Foundation,
  78 #   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  79 #
  80 #   The latest version of this software can be obtained here:
  81 #
  82 #   http://bash-completion.alioth.debian.org/
  83 #
  84 #   RELEASE: 2.x
  85
  86 # This function can be used to access a tokenized list of words
  87 # on the command line:
  88 #
  89 #       __git_reassemble_comp_words_by_ref '=:'
  90 #       if test "${words_[cword_-1]}" = -w
  91 #       then
  92 #               ...
  93 #       fi
  94 #
  95 # The argument should be a collection of characters from the list of
  96 # word completion separators (COMP_WORDBREAKS) to treat as ordinary
  97 # characters.
  98 #
  99 # This is roughly equivalent to going back in time and setting
 100 # COMP_WORDBREAKS to exclude those characters.  The intent is to
 101 # make option types like --date=<type> and <rev>:<path> easy to
 102 # recognize by treating each shell word as a single token.
 103 #
 104 # It is best not to set COMP_WORDBREAKS directly because the value is
 105 # shared with other completion scripts.  By the time the completion
 106 # function gets called, COMP_WORDS has already been populated so local
 107 # changes to COMP_WORDBREAKS have no effect.
 108 #
 109 # Output: words_, cword_, cur_.
 110
 111 __git_reassemble_comp_words_by_ref()
 112 {
 113         local exclude i j first
 114         # Which word separators to exclude?
 115         exclude="${1//[^$COMP_WORDBREAKS]}"
 116         cword_=$COMP_CWORD
 117         if [ -z "$exclude" ]; then
 118                 words_=("${COMP_WORDS[@]}")
 119                 return
 120         fi
 121         # List of word completion separators has shrunk;
 122         # re-assemble words to complete.
 123         for ((i=0, j=0; i < ${#COMP_WORDS[@]}; i++, j++)); do
 124                 # Append each nonempty word consisting of just
 125                 # word separator characters to the current word.
 126                 first=t
 127                 while
 128                         [ $i -gt 0 ] &&
 129                         [ -n "${COMP_WORDS[$i]}" ] &&
 130                         # word consists of excluded word separators
 131                         [ "${COMP_WORDS[$i]//[^$exclude]}" = "${COMP_WORDS[$i]}" ]
 132                 do
 133                         # Attach to the previous token,
 134                         # unless the previous token is the command name.
 135                         if [ $j -ge 2 ] && [ -n "$first" ]; then
 136                                 ((j--))
 137                         fi
 138                         first=
 139                         words_[$j]=${words_[j]}${COMP_WORDS[i]}
 140                         if [ $i = $COMP_CWORD ]; then
 141                                 cword_=$j
 142                         fi
 143                         if (($i < ${#COMP_WORDS[@]} - 1)); then
 144                                 ((i++))
 145                         else
 146                                 # Done.
 147                                 return
 148                         fi
 149                 done
 150                 words_[$j]=${words_[j]}${COMP_WORDS[i]}
 151                 if [ $i = $COMP_CWORD ]; then
 152                         cword_=$j
 153                 fi
 154         done
 155 }
 156
 157 if ! type _get_comp_words_by_ref >/dev/null 2>&1; then
 158 _get_comp_words_by_ref ()
 159 {
 160         local exclude cur_ words_ cword_
 161         if [ "$1" = "-n" ]; then
 162                 exclude=$2
 163                 shift 2
 164         fi
 165         __git_reassemble_comp_words_by_ref "$exclude"
 166         cur_=${words_[cword_]}
 167         while [ $# -gt 0 ]; do
 168                 case "$1" in
 169                 cur)
 170                         cur=$cur_
 171                         ;;
 172                 prev)
 173                         prev=${words_[$cword_-1]}
 174                         ;;
 175                 words)
 176                         words=("${words_[@]}")
 177                         ;;
 178                 cword)
 179                         cword=$cword_
 180                         ;;
 181                 esac
 182                 shift
 183         done
 184 }
 185 fi
 186
 187 __gitcompappend ()
 188 {
 189         local i=${#COMPREPLY[@]}
 190         for x in $1; do
 191                 if [[ "$x" == "$3"* ]]; then
 192                         COMPREPLY[i++]="$2$x$4"
 193                 fi
 194         done
 195 }
 196
 197 __gitcompadd ()
 198 {
 199         COMPREPLY=()
 200         __gitcompappend "$@"
 201 }
 202
 203 # Generates completion reply, appending a space to possible completion words,
 204 # if necessary.
 205 # It accepts 1 to 4 arguments:
 206 # 1: List of possible completion words.
 207 # 2: A prefix to be added to each possible completion word (optional).
 208 # 3: Generate possible completion matches for this word (optional).
 209 # 4: A suffix to be appended to each possible completion word (optional).
 210 __gitcomp ()
 211 {
 212         local cur_="${3-$cur}"
 213
 214         case "$cur_" in
 215         --*=)
 216                 ;;
 217         *)
 218                 local c i=0 IFS=$' \t\n'
 219                 for c in $1; do
 220                         c="$c${4-}"
 221                         if [[ $c == "$cur_"* ]]; then
 222                                 case $c in
 223                                 --*=*|*.) ;;
 224                                 *) c="$c " ;;
 225                                 esac
 226                                 COMPREPLY[i++]="${2-}$c"
 227                         fi
 228                 done
 229                 ;;
 230         esac
 231 }
 232
 233 # Variation of __gitcomp_nl () that appends to the existing list of
 234 # completion candidates, COMPREPLY.
 235 __gitcomp_nl_append ()
 236 {
 237         local IFS=$'\n'
 238         __gitcompappend "$1" "${2-}" "${3-$cur}" "${4- }"
 239 }
 240
 241 # Generates completion reply from newline-separated possible completion words
 242 # by appending a space to all of them.
 243 # It accepts 1 to 4 arguments:
 244 # 1: List of possible completion words, separated by a single newline.
 245 # 2: A prefix to be added to each possible completion word (optional).
 246 # 3: Generate possible completion matches for this word (optional).
 247 # 4: A suffix to be appended to each possible completion word instead of
 248 #    the default space (optional).  If specified but empty, nothing is
 249 #    appended.
 250 __gitcomp_nl ()
 251 {
 252         COMPREPLY=()
 253         __gitcomp_nl_append "$@"
 254 }
 255
 256 # Generates completion reply with compgen from newline-separated possible
 257 # completion filenames.
 258 # It accepts 1 to 3 arguments:
 259 # 1: List of possible completion filenames, separated by a single newline.
 260 # 2: A directory prefix to be added to each possible completion filename
 261 #    (optional).
 262 # 3: Generate possible completion matches for this word (optional).
 263 __gitcomp_file ()
 264 {
 265         local IFS=$'\n'
 266
 267         # XXX does not work when the directory prefix contains a tilde,
 268         # since tilde expansion is not applied.
 269         # This means that COMPREPLY will be empty and Bash default
 270         # completion will be used.
 271         __gitcompadd "$1" "${2-}" "${3-$cur}" ""
 272
 273         # use a hack to enable file mode in bash < 4
 274         compopt -o filenames +o nospace 2>/dev/null ||
 275         compgen -f /non-existing-dir/ > /dev/null
 276 }
 277
 278 # Execute 'git ls-files', unless the --committable option is specified, in
 279 # which case it runs 'git diff-index' to find out the files that can be
 280 # committed.  It return paths relative to the directory specified in the first
 281 # argument, and using the options specified in the second argument.
 282 __git_ls_files_helper ()
 283 {
 284         (
 285                 test -n "${CDPATH+set}" && unset CDPATH
 286                 cd "$1"
 287                 if [ "$2" == "--committable" ]; then
 288                         git diff-index --name-only --relative HEAD
 289                 else
 290                         # NOTE: $2 is not quoted in order to support multiple options
 291                         git ls-files --exclude-standard $2
 292                 fi
 293         ) 2>/dev/null
 294 }
 295
 296
 297 # __git_index_files accepts 1 or 2 arguments:
 298 # 1: Options to pass to ls-files (required).
 299 # 2: A directory path (optional).
 300 #    If provided, only files within the specified directory are listed.
 301 #    Sub directories are never recursed.  Path must have a trailing
 302 #    slash.
 303 __git_index_files ()
 304 {
 305         local dir="$(__gitdir)" root="${2-.}" file
 306
 307         if [ -d "$dir" ]; then
 308                 __git_ls_files_helper "$root" "$1" |
 309                 while read -r file; do
 310                         case "$file" in
 311                         ?*/*) echo "${file%%/*}" ;;
 312                         *) echo "$file" ;;
 313                         esac
 314                 done | sort | uniq
 315         fi
 316 }
 317
 318 __git_heads ()
 319 {
 320         local dir="$(__gitdir)"
 321         if [ -d "$dir" ]; then
 322                 git --git-dir="$dir" for-each-ref --format='%(refname:short)' \
 323                         refs/heads
 324                 return
 325         fi
 326 }
 327
 328 __git_tags ()
 329 {
 330         local dir="$(__gitdir)"
 331         if [ -d "$dir" ]; then
 332                 git --git-dir="$dir" for-each-ref --format='%(refname:short)' \
 333                         refs/tags
 334                 return
 335         fi
 336 }
 337
 338 # __git_refs accepts 0, 1 (to pass to __gitdir), or 2 arguments
 339 # presence of 2nd argument means use the guess heuristic employed
 340 # by checkout for tracking branches
 341 __git_refs ()
 342 {
 343         local i hash dir="$(__gitdir "${1-}")" track="${2-}"
 344         local format refs
 345         if [ -d "$dir" ]; then
 346                 case "$cur" in
 347                 refs|refs/*)
 348                         format="refname"
 349                         refs="${cur%/*}"
 350                         track=""
 351                         ;;
 352                 *)
 353                         for i in HEAD FETCH_HEAD ORIG_HEAD MERGE_HEAD; do
 354                                 if [ -e "$dir/$i" ]; then echo $i; fi
 355                         done
 356                         format="refname:short"
 357                         refs="refs/tags refs/heads refs/remotes"
 358                         ;;
 359                 esac
 360                 git --git-dir="$dir" for-each-ref --format="%($format)" \
 361                         $refs
 362                 if [ -n "$track" ]; then
 363                         # employ the heuristic used by git checkout
 364                         # Try to find a remote branch that matches the completion word
 365                         # but only output if the branch name is unique
 366                         local ref entry
 367                         git --git-dir="$dir" for-each-ref --shell --format="ref=%(refname:short)" \
 368                                 "refs/remotes/" | \
 369                         while read -r entry; do
 370                                 eval "$entry"
 371                                 ref="${ref#*/}"
 372                                 if [[ "$ref" == "$cur"* ]]; then
 373                                         echo "$ref"
 374                                 fi
 375                         done | sort | uniq -u
 376                 fi
 377                 return
 378         fi
 379         case "$cur" in
 380         refs|refs/*)
 381                 git ls-remote "$dir" "$cur*" 2>/dev/null | \
 382                 while read -r hash i; do
 383                         case "$i" in
 384                         *^{}) ;;
 385                         *) echo "$i" ;;
 386                         esac
 387                 done
 388                 ;;
 389         *)
 390                 echo "HEAD"
 391                 git for-each-ref --format="%(refname:short)" -- "refs/remotes/$dir/" | sed -e "s#^$dir/##"
 392                 ;;
 393         esac
 394 }
 395
 396 # __git_refs2 requires 1 argument (to pass to __git_refs)
 397 __git_refs2 ()
 398 {
 399         local i
 400         for i in $(__git_refs "$1"); do
 401                 echo "$i:$i"
 402         done
 403 }
 404
 405 # __git_refs_remotes requires 1 argument (to pass to ls-remote)
 406 __git_refs_remotes ()
 407 {
 408         local i hash
 409         git ls-remote "$1" 'refs/heads/*' 2>/dev/null | \
 410         while read -r hash i; do
 411                 echo "$i:refs/remotes/$1/${i#refs/heads/}"
 412         done
 413 }
 414
 415 __git_remotes ()
 416 {
 417         local i IFS=$'\n' d="$(__gitdir)"
 418         test -d "$d/remotes" && ls -1 "$d/remotes"
 419         for i in $(git --git-dir="$d" config --get-regexp 'remote\..*\.url' 2>/dev/null); do
 420                 i="${i#remote.}"
 421                 echo "${i/.url*/}"
 422         done
 423 }
 424
 425 __git_list_merge_strategies ()
 426 {
 427         git merge -s help 2>&1 |
 428         sed -n -e '/[Aa]vailable strategies are: /,/^$/{
 429                 s/\.$//
 430                 s/.*://
 431                 s/^[    ]*//
 432                 s/[     ]*$//
 433                 p
 434         }'
 435 }
 436
 437 __git_merge_strategies=
 438 # 'git merge -s help' (and thus detection of the merge strategy
 439 # list) fails, unfortunately, if run outside of any git working
 440 # tree.  __git_merge_strategies is set to the empty string in
 441 # that case, and the detection will be repeated the next time it
 442 # is needed.
 443 __git_compute_merge_strategies ()
 444 {
 445         test -n "$__git_merge_strategies" ||
 446         __git_merge_strategies=$(__git_list_merge_strategies)
 447 }
 448
 449 __git_complete_revlist_file ()
 450 {
 451         local pfx ls ref cur_="$cur"
 452         case "$cur_" in
 453         *..?*:*)
 454                 return
 455                 ;;
 456         ?*:*)
 457                 ref="${cur_%%:*}"
 458                 cur_="${cur_#*:}"
 459                 case "$cur_" in
 460                 ?*/*)
 461                         pfx="${cur_%/*}"
 462                         cur_="${cur_##*/}"
 463                         ls="$ref:$pfx"
 464                         pfx="$pfx/"
 465                         ;;
 466                 *)
 467                         ls="$ref"
 468                         ;;
 469                 esac
 470
 471                 case "$COMP_WORDBREAKS" in
 472                 *:*) : great ;;
 473                 *)   pfx="$ref:$pfx" ;;
 474                 esac
 475
 476                 __gitcomp_nl "$(git --git-dir="$(__gitdir)" ls-tree "$ls" 2>/dev/null \
 477                                 | sed '/^100... blob /{
 478                                            s,^.*        ,,
 479                                            s,$, ,
 480                                        }
 481                                        /^120000 blob /{
 482                                            s,^.*        ,,
 483                                            s,$, ,
 484                                        }
 485                                        /^040000 tree /{
 486                                            s,^.*        ,,
 487                                            s,$,/,
 488                                        }
 489                                        s/^.*    //')" \
 490                         "$pfx" "$cur_" ""
 491                 ;;
 492         *...*)
 493                 pfx="${cur_%...*}..."
 494                 cur_="${cur_#*...}"
 495                 __gitcomp_nl "$(__git_refs)" "$pfx" "$cur_"
 496                 ;;
 497         *..*)
 498                 pfx="${cur_%..*}.."
 499                 cur_="${cur_#*..}"
 500                 __gitcomp_nl "$(__git_refs)" "$pfx" "$cur_"
 501                 ;;
 502         *)
 503                 __gitcomp_nl "$(__git_refs)"
 504                 ;;
 505         esac
 506 }
 507
 508
 509 # __git_complete_index_file requires 1 argument:
 510 # 1: the options to pass to ls-file
 511 #
 512 # The exception is --committable, which finds the files appropriate commit.
 513 __git_complete_index_file ()
 514 {
 515         local pfx="" cur_="$cur"
 516
 517         case "$cur_" in
 518         ?*/*)
 519                 pfx="${cur_%/*}"
 520                 cur_="${cur_##*/}"
 521                 pfx="${pfx}/"
 522                 ;;
 523         esac
 524
 525         __gitcomp_file "$(__git_index_files "$1" "$pfx")" "$pfx" "$cur_"
 526 }
 527
 528 __git_complete_file ()
 529 {
 530         __git_complete_revlist_file
 531 }
 532
 533 __git_complete_revlist ()
 534 {
 535         __git_complete_revlist_file
 536 }
 537
 538 __git_complete_remote_or_refspec ()
 539 {
 540         local cur_="$cur" cmd="${words[1]}"
 541         local i c=2 remote="" pfx="" lhs=1 no_complete_refspec=0
 542         if [ "$cmd" = "remote" ]; then
 543                 ((c++))
 544         fi
 545         while [ $c -lt $cword ]; do
 546                 i="${words[c]}"
 547                 case "$i" in
 548                 --mirror) [ "$cmd" = "push" ] && no_complete_refspec=1 ;;
 549                 --all)
 550                         case "$cmd" in
 551                         push) no_complete_refspec=1 ;;
 552                         fetch)
 553                                 return
 554                                 ;;
 555                         *) ;;
 556                         esac
 557                         ;;
 558                 -*) ;;
 559                 *) remote="$i"; break ;;
 560                 esac
 561                 ((c++))
 562         done
 563         if [ -z "$remote" ]; then
 564                 __gitcomp_nl "$(__git_remotes)"
 565                 return
 566         fi
 567         if [ $no_complete_refspec = 1 ]; then
 568                 return
 569         fi
 570         [ "$remote" = "." ] && remote=
 571         case "$cur_" in
 572         *:*)
 573                 case "$COMP_WORDBREAKS" in
 574                 *:*) : great ;;
 575                 *)   pfx="${cur_%%:*}:" ;;
 576                 esac
 577                 cur_="${cur_#*:}"
 578                 lhs=0
 579                 ;;
 580         +*)
 581                 pfx="+"
 582                 cur_="${cur_#+}"
 583                 ;;
 584         esac
 585         case "$cmd" in
 586         fetch)
 587                 if [ $lhs = 1 ]; then
 588                         __gitcomp_nl "$(__git_refs2 "$remote")" "$pfx" "$cur_"
 589                 else
 590                         __gitcomp_nl "$(__git_refs)" "$pfx" "$cur_"
 591                 fi
 592                 ;;
 593         pull|remote)
 594                 if [ $lhs = 1 ]; then
 595                         __gitcomp_nl "$(__git_refs "$remote")" "$pfx" "$cur_"
 596                 else
 597                         __gitcomp_nl "$(__git_refs)" "$pfx" "$cur_"
 598                 fi
 599                 ;;
 600         push)
 601                 if [ $lhs = 1 ]; then
 602                         __gitcomp_nl "$(__git_refs)" "$pfx" "$cur_"
 603                 else
 604                         __gitcomp_nl "$(__git_refs "$remote")" "$pfx" "$cur_"
 605                 fi
 606                 ;;
 607         esac
 608 }
 609
 610 __git_complete_strategy ()
 611 {
 612         __git_compute_merge_strategies
 613         case "$prev" in
 614         -s|--strategy)
 615                 __gitcomp "$__git_merge_strategies"
 616                 return 0
 617         esac
 618         case "$cur" in
 619         --strategy=*)
 620                 __gitcomp "$__git_merge_strategies" "" "${cur##--strategy=}"
 621                 return 0
 622                 ;;
 623         esac
 624         return 1
 625 }
 626
 627 __git_commands () {
 628         if test -n "${GIT_TESTING_COMMAND_COMPLETION:-}"
 629         then
 630                 printf "%s" "${GIT_TESTING_COMMAND_COMPLETION}"
 631         else
 632                 git help -a|egrep '^  [a-zA-Z0-9]'
 633         fi
 634 }
 635
 636 __git_list_all_commands ()
 637 {
 638         local i IFS=" "$'\n'
 639         for i in $(__git_commands)
 640         do
 641                 case $i in
 642                 *--*)             : helper pattern;;
 643                 *) echo $i;;
 644                 esac
 645         done
 646 }
 647
 648 __git_all_commands=
 649 __git_compute_all_commands ()
 650 {
 651         test -n "$__git_all_commands" ||
 652         __git_all_commands=$(__git_list_all_commands)
 653 }
 654
 655 __git_list_porcelain_commands ()
 656 {
 657         local i IFS=" "$'\n'
 658         __git_compute_all_commands
 659         for i in $__git_all_commands
 660         do
 661                 case $i in
 662                 *--*)             : helper pattern;;
 663                 applymbox)        : ask gittus;;
 664                 applypatch)       : ask gittus;;
 665                 archimport)       : import;;
 666                 cat-file)         : plumbing;;
 667                 check-attr)       : plumbing;;
 668                 check-ignore)     : plumbing;;
 669                 check-mailmap)    : plumbing;;
 670                 check-ref-format) : plumbing;;
 671                 checkout-index)   : plumbing;;
 672                 commit-tree)      : plumbing;;
 673                 count-objects)    : infrequent;;
 674                 credential-cache) : credentials helper;;
 675                 credential-store) : credentials helper;;
 676                 cvsexportcommit)  : export;;
 677                 cvsimport)        : import;;
 678                 cvsserver)        : daemon;;
 679                 daemon)           : daemon;;
 680                 diff-files)       : plumbing;;
 681                 diff-index)       : plumbing;;
 682                 diff-tree)        : plumbing;;
 683                 fast-import)      : import;;
 684                 fast-export)      : export;;
 685                 fsck-objects)     : plumbing;;
 686                 fetch-pack)       : plumbing;;
 687                 fmt-merge-msg)    : plumbing;;
 688                 for-each-ref)     : plumbing;;
 689                 hash-object)      : plumbing;;
 690                 http-*)           : transport;;
 691                 index-pack)       : plumbing;;
 692                 init-db)          : deprecated;;
 693                 local-fetch)      : plumbing;;
 694                 ls-files)         : plumbing;;
 695                 ls-remote)        : plumbing;;
 696                 ls-tree)          : plumbing;;
 697                 mailinfo)         : plumbing;;
 698                 mailsplit)        : plumbing;;
 699                 merge-*)          : plumbing;;
 700                 mktree)           : plumbing;;
 701                 mktag)            : plumbing;;
 702                 pack-objects)     : plumbing;;
 703                 pack-redundant)   : plumbing;;
 704                 pack-refs)        : plumbing;;
 705                 parse-remote)     : plumbing;;
 706                 patch-id)         : plumbing;;
 707                 prune)            : plumbing;;
 708                 prune-packed)     : plumbing;;
 709                 quiltimport)      : import;;
 710                 read-tree)        : plumbing;;
 711                 receive-pack)     : plumbing;;
 712                 remote-*)         : transport;;
 713                 rerere)           : plumbing;;
 714                 rev-list)         : plumbing;;
 715                 rev-parse)        : plumbing;;
 716                 runstatus)        : plumbing;;
 717                 sh-setup)         : internal;;
 718                 shell)            : daemon;;
 719                 show-ref)         : plumbing;;
 720                 send-pack)        : plumbing;;
 721                 show-index)       : plumbing;;
 722                 ssh-*)            : transport;;
 723                 stripspace)       : plumbing;;
 724                 symbolic-ref)     : plumbing;;
 725                 unpack-file)      : plumbing;;
 726                 unpack-objects)   : plumbing;;
 727                 update-index)     : plumbing;;
 728                 update-ref)       : plumbing;;
 729                 update-server-info) : daemon;;
 730                 upload-archive)   : plumbing;;
 731                 upload-pack)      : plumbing;;
 732                 write-tree)       : plumbing;;
 733                 var)              : infrequent;;
 734                 verify-pack)      : infrequent;;
 735                 verify-tag)       : plumbing;;
 736                 *) echo $i;;
 737                 esac
 738         done
 739 }
 740
 741 __git_porcelain_commands=
 742 __git_compute_porcelain_commands ()
 743 {
 744         __git_compute_all_commands
 745         test -n "$__git_porcelain_commands" ||
 746         __git_porcelain_commands=$(__git_list_porcelain_commands)
 747 }
 748
 749 __git_pretty_aliases ()
 750 {
 751         local i IFS=$'\n'
 752         for i in $(git --git-dir="$(__gitdir)" config --get-regexp "pretty\..*" 2>/dev/null); do
 753                 case "$i" in
 754                 pretty.*)
 755                         i="${i#pretty.}"
 756                         echo "${i/ */}"
 757                         ;;
 758                 esac
 759         done
 760 }
 761
 762 __git_aliases ()
 763 {
 764         local i IFS=$'\n'
 765         for i in $(git --git-dir="$(__gitdir)" config --get-regexp "alias\..*" 2>/dev/null); do
 766                 case "$i" in
 767                 alias.*)
 768                         i="${i#alias.}"
 769                         echo "${i/ */}"
 770                         ;;
 771                 esac
 772         done
 773 }
 774
 775 # __git_aliased_command requires 1 argument
 776 __git_aliased_command ()
 777 {
 778         local word cmdline=$(git --git-dir="$(__gitdir)" \
 779                 config --get "alias.$1")
 780         for word in $cmdline; do
 781                 case "$word" in
 782                 \!gitk|gitk)
 783                         echo "gitk"
 784                         return
 785                         ;;
 786                 \!*)    : shell command alias ;;
 787                 -*)     : option ;;
 788                 *=*)    : setting env ;;
 789                 git)    : git itself ;;
 790                 \(\))   : skip parens of shell function definition ;;
 791                 {)      : skip start of shell helper function ;;
 792                 :)      : skip null command ;;
 793                 \'*)    : skip opening quote after sh -c ;;
 794                 *)
 795                         echo "$word"
 796                         return
 797                 esac
 798         done
 799 }
 800
 801 # __git_find_on_cmdline requires 1 argument
 802 __git_find_on_cmdline ()
 803 {
 804         local word subcommand c=1
 805         while [ $c -lt $cword ]; do
 806                 word="${words[c]}"
 807                 for subcommand in $1; do
 808                         if [ "$subcommand" = "$word" ]; then
 809                                 echo "$subcommand"
 810                                 return
 811                         fi
 812                 done
 813                 ((c++))
 814         done
 815 }
 816
 817 __git_has_doubledash ()
 818 {
 819         local c=1
 820         while [ $c -lt $cword ]; do
 821                 if [ "--" = "${words[c]}" ]; then
 822                         return 0
 823                 fi
 824                 ((c++))
 825         done
 826         return 1
 827 }
 828
 829 # Try to count non option arguments passed on the command line for the
 830 # specified git command.
 831 # When options are used, it is necessary to use the special -- option to
 832 # tell the implementation were non option arguments begin.
 833 # XXX this can not be improved, since options can appear everywhere, as
 834 # an example:
 835 #       git mv x -n y
 836 #
 837 # __git_count_arguments requires 1 argument: the git command executed.
 838 __git_count_arguments ()
 839 {
 840         local word i c=0
 841
 842         # Skip "git" (first argument)
 843         for ((i=1; i < ${#words[@]}; i++)); do
 844                 word="${words[i]}"
 845
 846                 case "$word" in
 847                         --)
 848                                 # Good; we can assume that the following are only non
 849                                 # option arguments.
 850                                 ((c = 0))
 851                                 ;;
 852                         "$1")
 853                                 # Skip the specified git command and discard git
 854                                 # main options
 855                                 ((c = 0))
 856                                 ;;
 857                         ?*)
 858                                 ((c++))
 859                                 ;;
 860                 esac
 861         done
 862
 863         printf "%d" $c
 864 }
 865
 866 __git_whitespacelist="nowarn warn error error-all fix"
 867
 868 _git_am ()
 869 {
 870         local dir="$(__gitdir)"
 871         if [ -d "$dir"/rebase-apply ]; then
 872                 __gitcomp "--skip --continue --resolved --abort"
 873                 return
 874         fi
 875         case "$cur" in
 876         --whitespace=*)
 877                 __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
 878                 return
 879                 ;;
 880         --*)
 881                 __gitcomp "
 882                         --3way --committer-date-is-author-date --ignore-date
 883                         --ignore-whitespace --ignore-space-change
 884                         --interactive --keep --no-utf8 --signoff --utf8
 885                         --whitespace= --scissors
 886                         "
 887                 return
 888         esac
 889 }
 890
 891 _git_apply ()
 892 {
 893         case "$cur" in
 894         --whitespace=*)
 895                 __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
 896                 return
 897                 ;;
 898         --*)
 899                 __gitcomp "
 900                         --stat --numstat --summary --check --index
 901                         --cached --index-info --reverse --reject --unidiff-zero
 902                         --apply --no-add --exclude=
 903                         --ignore-whitespace --ignore-space-change
 904                         --whitespace= --inaccurate-eof --verbose
 905                         "
 906                 return
 907         esac
 908 }
 909
 910 _git_add ()
 911 {
 912         case "$cur" in
 913         --*)
 914                 __gitcomp "
 915                         --interactive --refresh --patch --update --dry-run
 916                         --ignore-errors --intent-to-add
 917                         "
 918                 return
 919         esac
 920
 921         # XXX should we check for --update and --all options ?
 922         __git_complete_index_file "--others --modified --directory --no-empty-directory"
 923 }
 924
 925 _git_archive ()
 926 {
 927         case "$cur" in
 928         --format=*)
 929                 __gitcomp "$(git archive --list)" "" "${cur##--format=}"
 930                 return
 931                 ;;
 932         --remote=*)
 933                 __gitcomp_nl "$(__git_remotes)" "" "${cur##--remote=}"
 934                 return
 935                 ;;
 936         --*)
 937                 __gitcomp "
 938                         --format= --list --verbose
 939                         --prefix= --remote= --exec=
 940                         "
 941                 return
 942                 ;;
 943         esac
 944         __git_complete_file
 945 }
 946
 947 _git_bisect ()
 948 {
 949         __git_has_doubledash && return
 950
 951         local subcommands="start bad good skip reset visualize replay log run"
 952         local subcommand="$(__git_find_on_cmdline "$subcommands")"
 953         if [ -z "$subcommand" ]; then
 954                 if [ -f "$(__gitdir)"/BISECT_START ]; then
 955                         __gitcomp "$subcommands"
 956                 else
 957                         __gitcomp "replay start"
 958                 fi
 959                 return
 960         fi
 961
 962         case "$subcommand" in
 963         bad|good|reset|skip|start)
 964                 __gitcomp_nl "$(__git_refs)"
 965                 ;;
 966         *)
 967                 ;;
 968         esac
 969 }
 970
 971 _git_branch ()
 972 {
 973         local i c=1 only_local_ref="n" has_r="n"
 974
 975         while [ $c -lt $cword ]; do
 976                 i="${words[c]}"
 977                 case "$i" in
 978                 -d|-m)  only_local_ref="y" ;;
 979                 -r)     has_r="y" ;;
 980                 esac
 981                 ((c++))
 982         done
 983
 984         case "$cur" in
 985         --set-upstream-to=*)
 986                 __gitcomp "$(__git_refs)" "" "${cur##--set-upstream-to=}"
 987                 ;;
 988         --*)
 989                 __gitcomp "
 990                         --color --no-color --verbose --abbrev= --no-abbrev
 991                         --track --no-track --contains --merged --no-merged
 992                         --set-upstream-to= --edit-description --list
 993                         --unset-upstream
 994                         "
 995                 ;;
 996         *)
 997                 if [ $only_local_ref = "y" -a $has_r = "n" ]; then
 998                         __gitcomp_nl "$(__git_heads)"
 999                 else
1000                         __gitcomp_nl "$(__git_refs)"
1001                 fi
1002                 ;;
1003         esac
1004 }
1005
1006 _git_bundle ()
1007 {
1008         local cmd="${words[2]}"
1009         case "$cword" in
1010         2)
1011                 __gitcomp "create list-heads verify unbundle"
1012                 ;;
1013         3)
1014                 # looking for a file
1015                 ;;
1016         *)
1017                 case "$cmd" in
1018                         create)
1019                                 __git_complete_revlist
1020                         ;;
1021                 esac
1022                 ;;
1023         esac
1024 }
1025
1026 _git_checkout ()
1027 {
1028         __git_has_doubledash && return
1029
1030         case "$cur" in
1031         --conflict=*)
1032                 __gitcomp "diff3 merge" "" "${cur##--conflict=}"
1033                 ;;
1034         --*)
1035                 __gitcomp "
1036                         --quiet --ours --theirs --track --no-track --merge
1037                         --conflict= --orphan --patch
1038                         "
1039                 ;;
1040         *)
1041                 # check if --track, --no-track, or --no-guess was specified
1042                 # if so, disable DWIM mode
1043                 local flags="--track --no-track --no-guess" track=1
1044                 if [ -n "$(__git_find_on_cmdline "$flags")" ]; then
1045                         track=''
1046                 fi
1047                 __gitcomp_nl "$(__git_refs '' $track)"
1048                 ;;
1049         esac
1050 }
1051
1052 _git_cherry ()
1053 {
1054         __gitcomp "$(__git_refs)"
1055 }
1056
1057 _git_cherry_pick ()
1058 {
1059         local dir="$(__gitdir)"
1060         if [ -f "$dir"/CHERRY_PICK_HEAD ]; then
1061                 __gitcomp "--continue --quit --abort"
1062                 return
1063         fi
1064         case "$cur" in
1065         --*)
1066                 __gitcomp "--edit --no-commit --signoff --strategy= --mainline"
1067                 ;;
1068         *)
1069                 __gitcomp_nl "$(__git_refs)"
1070                 ;;
1071         esac
1072 }
1073
1074 _git_clean ()
1075 {
1076         case "$cur" in
1077         --*)
1078                 __gitcomp "--dry-run --quiet"
1079                 return
1080                 ;;
1081         esac
1082
1083         # XXX should we check for -x option ?
1084         __git_complete_index_file "--others --directory"
1085 }
1086
1087 _git_clone ()
1088 {
1089         case "$cur" in
1090         --*)
1091                 __gitcomp "
1092                         --local
1093                         --no-hardlinks
1094                         --shared
1095                         --reference
1096                         --quiet
1097                         --no-checkout
1098                         --bare
1099                         --mirror
1100                         --origin
1101                         --upload-pack
1102                         --template=
1103                         --depth
1104                         --single-branch
1105                         --branch
1106                         "
1107                 return
1108                 ;;
1109         esac
1110 }
1111
1112 _git_commit ()
1113 {
1114         case "$prev" in
1115         -c|-C)
1116                 __gitcomp_nl "$(__git_refs)" "" "${cur}"
1117                 return
1118                 ;;
1119         esac
1120
1121         case "$cur" in
1122         --cleanup=*)
1123                 __gitcomp "default strip verbatim whitespace
1124                         " "" "${cur##--cleanup=}"
1125                 return
1126                 ;;
1127         --reuse-message=*|--reedit-message=*|\
1128         --fixup=*|--squash=*)
1129                 __gitcomp_nl "$(__git_refs)" "" "${cur#*=}"
1130                 return
1131                 ;;
1132         --untracked-files=*)
1133                 __gitcomp "all no normal" "" "${cur##--untracked-files=}"
1134                 return
1135                 ;;
1136         --*)
1137                 __gitcomp "
1138                         --all --author= --signoff --verify --no-verify
1139                         --edit --no-edit
1140                         --amend --include --only --interactive
1141                         --dry-run --reuse-message= --reedit-message=
1142                         --reset-author --file= --message= --template=
1143                         --cleanup= --untracked-files --untracked-files=
1144                         --verbose --quiet --fixup= --squash=
1145                         "
1146                 return
1147         esac
1148
1149         if git rev-parse --verify --quiet HEAD >/dev/null; then
1150                 __git_complete_index_file "--committable"
1151         else
1152                 # This is the first commit
1153                 __git_complete_index_file "--cached"
1154         fi
1155 }
1156
1157 _git_describe ()
1158 {
1159         case "$cur" in
1160         --*)
1161                 __gitcomp "
1162                         --all --tags --contains --abbrev= --candidates=
1163                         --exact-match --debug --long --match --always
1164                         "
1165                 return
1166         esac
1167         __gitcomp_nl "$(__git_refs)"
1168 }
1169
1170 __git_diff_algorithms="myers minimal patience histogram"
1171
1172 __git_diff_common_options="--stat --numstat --shortstat --summary
1173                         --patch-with-stat --name-only --name-status --color
1174                         --no-color --color-words --no-renames --check
1175                         --full-index --binary --abbrev --diff-filter=
1176                         --find-copies-harder
1177                         --text --ignore-space-at-eol --ignore-space-change
1178                         --ignore-all-space --exit-code --quiet --ext-diff
1179                         --no-ext-diff
1180                         --no-prefix --src-prefix= --dst-prefix=
1181                         --inter-hunk-context=
1182                         --patience --histogram --minimal
1183                         --raw --word-diff
1184                         --dirstat --dirstat= --dirstat-by-file
1185                         --dirstat-by-file= --cumulative
1186                         --diff-algorithm=
1187 "
1188
1189 _git_diff ()
1190 {
1191         __git_has_doubledash && return
1192
1193         case "$cur" in
1194         --diff-algorithm=*)
1195                 __gitcomp "$__git_diff_algorithms" "" "${cur##--diff-algorithm=}"
1196                 return
1197                 ;;
1198         --*)
1199                 __gitcomp "--cached --staged --pickaxe-all --pickaxe-regex
1200                         --base --ours --theirs --no-index
1201                         $__git_diff_common_options
1202                         "
1203                 return
1204                 ;;
1205         esac
1206         __git_complete_revlist_file
1207 }
1208
1209 __git_mergetools_common="diffuse diffmerge ecmerge emerge kdiff3 meld opendiff
1210                         tkdiff vimdiff gvimdiff xxdiff araxis p4merge bc3 codecompare
1211 "
1212
1213 _git_difftool ()
1214 {
1215         __git_has_doubledash && return
1216
1217         case "$cur" in
1218         --tool=*)
1219                 __gitcomp "$__git_mergetools_common kompare" "" "${cur##--tool=}"
1220                 return
1221                 ;;
1222         --*)
1223                 __gitcomp "--cached --staged --pickaxe-all --pickaxe-regex
1224                         --base --ours --theirs
1225                         --no-renames --diff-filter= --find-copies-harder
1226                         --relative --ignore-submodules
1227                         --tool="
1228                 return
1229                 ;;
1230         esac
1231         __git_complete_revlist_file
1232 }
1233
1234 __git_fetch_recurse_submodules="yes on-demand no"
1235
1236 __git_fetch_options="
1237         --quiet --verbose --append --upload-pack --force --keep --depth=
1238         --tags --no-tags --all --prune --dry-run --recurse-submodules=
1239 "
1240
1241 _git_fetch ()
1242 {
1243         case "$cur" in
1244         --recurse-submodules=*)
1245                 __gitcomp "$__git_fetch_recurse_submodules" "" "${cur##--recurse-submodules=}"
1246                 return
1247                 ;;
1248         --*)
1249                 __gitcomp "$__git_fetch_options"
1250                 return
1251                 ;;
1252         esac
1253         __git_complete_remote_or_refspec
1254 }
1255
1256 __git_format_patch_options="
1257         --stdout --attach --no-attach --thread --thread= --no-thread
1258         --numbered --start-number --numbered-files --keep-subject --signoff
1259         --signature --no-signature --in-reply-to= --cc= --full-index --binary
1260         --not --all --cover-letter --no-prefix --src-prefix= --dst-prefix=
1261         --inline --suffix= --ignore-if-in-upstream --subject-prefix=
1262         --output-directory --reroll-count --to= --quiet --notes
1263 "
1264
1265 _git_format_patch ()
1266 {
1267         case "$cur" in
1268         --thread=*)
1269                 __gitcomp "
1270                         deep shallow
1271                         " "" "${cur##--thread=}"
1272                 return
1273                 ;;
1274         --*)
1275                 __gitcomp "$__git_format_patch_options"
1276                 return
1277                 ;;
1278         esac
1279         __git_complete_revlist
1280 }
1281
1282 _git_fsck ()
1283 {
1284         case "$cur" in
1285         --*)
1286                 __gitcomp "
1287                         --tags --root --unreachable --cache --no-reflogs --full
1288                         --strict --verbose --lost-found
1289                         "
1290                 return
1291                 ;;
1292         esac
1293 }
1294
1295 _git_gc ()
1296 {
1297         case "$cur" in
1298         --*)
1299                 __gitcomp "--prune --aggressive"
1300                 return
1301                 ;;
1302         esac
1303 }
1304
1305 _git_gitk ()
1306 {
1307         _gitk
1308 }
1309
1310 __git_match_ctag() {
1311         awk "/^${1////\\/}/ { print \$1 }" "$2"
1312 }
1313
1314 _git_grep ()
1315 {
1316         __git_has_doubledash && return
1317
1318         case "$cur" in
1319         --*)
1320                 __gitcomp "
1321                         --cached
1322                         --text --ignore-case --word-regexp --invert-match
1323                         --full-name --line-number
1324                         --extended-regexp --basic-regexp --fixed-strings
1325                         --perl-regexp
1326                         --files-with-matches --name-only
1327                         --files-without-match
1328                         --max-depth
1329                         --count
1330                         --and --or --not --all-match
1331                         "
1332                 return
1333                 ;;
1334         esac
1335
1336         case "$cword,$prev" in
1337         2,*|*,-*)
1338                 if test -r tags; then
1339                         __gitcomp_nl "$(__git_match_ctag "$cur" tags)"
1340                         return
1341                 fi
1342                 ;;
1343         esac
1344
1345         __gitcomp_nl "$(__git_refs)"
1346 }
1347
1348 _git_help ()
1349 {
1350         case "$cur" in
1351         --*)
1352                 __gitcomp "--all --info --man --web"
1353                 return
1354                 ;;
1355         esac
1356         __git_compute_all_commands
1357         __gitcomp "$__git_all_commands $(__git_aliases)
1358                 attributes cli core-tutorial cvs-migration
1359                 diffcore gitk glossary hooks ignore modules
1360                 namespaces repository-layout tutorial tutorial-2
1361                 workflows
1362                 "
1363 }
1364
1365 _git_init ()
1366 {
1367         case "$cur" in
1368         --shared=*)
1369                 __gitcomp "
1370                         false true umask group all world everybody
1371                         " "" "${cur##--shared=}"
1372                 return
1373                 ;;
1374         --*)
1375                 __gitcomp "--quiet --bare --template= --shared --shared="
1376                 return
1377                 ;;
1378         esac
1379 }
1380
1381 _git_ls_files ()
1382 {
1383         case "$cur" in
1384         --*)
1385                 __gitcomp "--cached --deleted --modified --others --ignored
1386                         --stage --directory --no-empty-directory --unmerged
1387                         --killed --exclude= --exclude-from=
1388                         --exclude-per-directory= --exclude-standard
1389                         --error-unmatch --with-tree= --full-name
1390                         --abbrev --ignored --exclude-per-directory
1391                         "
1392                 return
1393                 ;;
1394         esac
1395
1396         # XXX ignore options like --modified and always suggest all cached
1397         # files.
1398         __git_complete_index_file "--cached"
1399 }
1400
1401 _git_ls_remote ()
1402 {
1403         __gitcomp_nl "$(__git_remotes)"
1404 }
1405
1406 _git_ls_tree ()
1407 {
1408         __git_complete_file
1409 }
1410
1411 # Options that go well for log, shortlog and gitk
1412 __git_log_common_options="
1413         --not --all
1414         --branches --tags --remotes
1415         --first-parent --merges --no-merges
1416         --max-count=
1417         --max-age= --since= --after=
1418         --min-age= --until= --before=
1419         --min-parents= --max-parents=
1420         --no-min-parents --no-max-parents
1421 "
1422 # Options that go well for log and gitk (not shortlog)
1423 __git_log_gitk_options="
1424         --dense --sparse --full-history
1425         --simplify-merges --simplify-by-decoration
1426         --left-right --notes --no-notes
1427 "
1428 # Options that go well for log and shortlog (not gitk)
1429 __git_log_shortlog_options="
1430         --author= --committer= --grep=
1431         --all-match
1432 "
1433
1434 __git_log_pretty_formats="oneline short medium full fuller email raw format:"
1435 __git_log_date_formats="relative iso8601 rfc2822 short local default raw"
1436
1437 _git_log ()
1438 {
1439         __git_has_doubledash && return
1440
1441         local g="$(git rev-parse --git-dir 2>/dev/null)"
1442         local merge=""
1443         if [ -f "$g/MERGE_HEAD" ]; then
1444                 merge="--merge"
1445         fi
1446         case "$cur" in
1447         --pretty=*|--format=*)
1448                 __gitcomp "$__git_log_pretty_formats $(__git_pretty_aliases)
1449                         " "" "${cur#*=}"
1450                 return
1451                 ;;
1452         --date=*)
1453                 __gitcomp "$__git_log_date_formats" "" "${cur##--date=}"
1454                 return
1455                 ;;
1456         --decorate=*)
1457                 __gitcomp "long short" "" "${cur##--decorate=}"
1458                 return
1459                 ;;
1460         --*)
1461                 __gitcomp "
1462                         $__git_log_common_options
1463                         $__git_log_shortlog_options
1464                         $__git_log_gitk_options
1465                         --root --topo-order --date-order --reverse
1466                         --follow --full-diff
1467                         --abbrev-commit --abbrev=
1468                         --relative-date --date=
1469                         --pretty= --format= --oneline
1470                         --cherry-pick
1471                         --graph
1472                         --decorate --decorate=
1473                         --walk-reflogs
1474                         --parents --children
1475                         $merge
1476                         $__git_diff_common_options
1477                         --pickaxe-all --pickaxe-regex
1478                         "
1479                 return
1480                 ;;
1481         esac
1482         __git_complete_revlist
1483 }
1484
1485 # Common merge options shared by git-merge(1) and git-pull(1).
1486 __git_merge_options="
1487         --no-commit --no-stat --log --no-log --squash --strategy
1488         --commit --stat --no-squash --ff --no-ff --ff-only --edit --no-edit
1489         --verify-signatures --no-verify-signatures --gpg-sign
1490         --quiet --verbose --progress --no-progress
1491 "
1492
1493 _git_merge ()
1494 {
1495         __git_complete_strategy && return
1496
1497         case "$cur" in
1498         --*)
1499                 __gitcomp "$__git_merge_options
1500                         --rerere-autoupdate --no-rerere-autoupdate --abort"
1501                 return
1502         esac
1503         __gitcomp_nl "$(__git_refs)"
1504 }
1505
1506 _git_mergetool ()
1507 {
1508         case "$cur" in
1509         --tool=*)
1510                 __gitcomp "$__git_mergetools_common tortoisemerge" "" "${cur##--tool=}"
1511                 return
1512                 ;;
1513         --*)
1514                 __gitcomp "--tool="
1515                 return
1516                 ;;
1517         esac
1518 }
1519
1520 _git_merge_base ()
1521 {
1522         case "$cur" in
1523         --*)
1524                 __gitcomp "--octopus --independent --is-ancestor --fork-point"
1525                 return
1526                 ;;
1527         esac
1528         __gitcomp_nl "$(__git_refs)"
1529 }
1530
1531 _git_mv ()
1532 {
1533         case "$cur" in
1534         --*)
1535                 __gitcomp "--dry-run"
1536                 return
1537                 ;;
1538         esac
1539
1540         if [ $(__git_count_arguments "mv") -gt 0 ]; then
1541                 # We need to show both cached and untracked files (including
1542                 # empty directories) since this may not be the last argument.
1543                 __git_complete_index_file "--cached --others --directory"
1544         else
1545                 __git_complete_index_file "--cached"
1546         fi
1547 }
1548
1549 _git_name_rev ()
1550 {
1551         __gitcomp "--tags --all --stdin"
1552 }
1553
1554 _git_notes ()
1555 {
1556         local subcommands='add append copy edit list prune remove show'
1557         local subcommand="$(__git_find_on_cmdline "$subcommands")"
1558
1559         case "$subcommand,$cur" in
1560         ,--*)
1561                 __gitcomp '--ref'
1562                 ;;
1563         ,*)
1564                 case "$prev" in
1565                 --ref)
1566                         __gitcomp_nl "$(__git_refs)"
1567                         ;;
1568                 *)
1569                         __gitcomp "$subcommands --ref"
1570                         ;;
1571                 esac
1572                 ;;
1573         add,--reuse-message=*|append,--reuse-message=*|\
1574         add,--reedit-message=*|append,--reedit-message=*)
1575                 __gitcomp_nl "$(__git_refs)" "" "${cur#*=}"
1576                 ;;
1577         add,--*|append,--*)
1578                 __gitcomp '--file= --message= --reedit-message=
1579                                 --reuse-message='
1580                 ;;
1581         copy,--*)
1582                 __gitcomp '--stdin'
1583                 ;;
1584         prune,--*)
1585                 __gitcomp '--dry-run --verbose'
1586                 ;;
1587         prune,*)
1588                 ;;
1589         *)
1590                 case "$prev" in
1591                 -m|-F)
1592                         ;;
1593                 *)
1594                         __gitcomp_nl "$(__git_refs)"
1595                         ;;
1596                 esac
1597                 ;;
1598         esac
1599 }
1600
1601 _git_pull ()
1602 {
1603         __git_complete_strategy && return
1604
1605         case "$cur" in
1606         --recurse-submodules=*)
1607                 __gitcomp "$__git_fetch_recurse_submodules" "" "${cur##--recurse-submodules=}"
1608                 return
1609                 ;;
1610         --*)
1611                 __gitcomp "
1612                         --rebase --no-rebase
1613                         $__git_merge_options
1614                         $__git_fetch_options
1615                 "
1616                 return
1617                 ;;
1618         esac
1619         __git_complete_remote_or_refspec
1620 }
1621
1622 __git_push_recurse_submodules="check on-demand"
1623
1624 _git_push ()
1625 {
1626         case "$prev" in
1627         --repo)
1628                 __gitcomp_nl "$(__git_remotes)"
1629                 return
1630         esac
1631         case "$cur" in
1632         --repo=*)
1633                 __gitcomp_nl "$(__git_remotes)" "" "${cur##--repo=}"
1634                 return
1635                 ;;
1636         --recurse-submodules=*)
1637                 __gitcomp "$__git_push_recurse_submodules" "" "${cur##--recurse-submodules=}"
1638                 return
1639                 ;;
1640         --*)
1641                 __gitcomp "
1642                         --all --mirror --tags --dry-run --force --verbose
1643                         --receive-pack= --repo= --set-upstream
1644                         --recurse-submodules=
1645                 "
1646                 return
1647                 ;;
1648         esac
1649         __git_complete_remote_or_refspec
1650 }
1651
1652 _git_rebase ()
1653 {
1654         local dir="$(__gitdir)"
1655         if [ -d "$dir"/rebase-apply ] || [ -d "$dir"/rebase-merge ]; then
1656                 __gitcomp "--continue --skip --abort"
1657                 return
1658         fi
1659         __git_complete_strategy && return
1660         case "$cur" in
1661         --whitespace=*)
1662                 __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
1663                 return
1664                 ;;
1665         --*)
1666                 __gitcomp "
1667                         --onto --merge --strategy --interactive
1668                         --preserve-merges --stat --no-stat
1669                         --committer-date-is-author-date --ignore-date
1670                         --ignore-whitespace --whitespace=
1671                         --autosquash --fork-point --no-fork-point
1672                         "
1673
1674                 return
1675         esac
1676         __gitcomp_nl "$(__git_refs)"
1677 }
1678
1679 _git_reflog ()
1680 {
1681         local subcommands="show delete expire"
1682         local subcommand="$(__git_find_on_cmdline "$subcommands")"
1683
1684         if [ -z "$subcommand" ]; then
1685                 __gitcomp "$subcommands"
1686         else
1687                 __gitcomp_nl "$(__git_refs)"
1688         fi
1689 }
1690
1691 __git_send_email_confirm_options="always never auto cc compose"
1692 __git_send_email_suppresscc_options="author self cc bodycc sob cccmd body all"
1693
1694 _git_send_email ()
1695 {
1696         case "$cur" in
1697         --confirm=*)
1698                 __gitcomp "
1699                         $__git_send_email_confirm_options
1700                         " "" "${cur##--confirm=}"
1701                 return
1702                 ;;
1703         --suppress-cc=*)
1704                 __gitcomp "
1705                         $__git_send_email_suppresscc_options
1706                         " "" "${cur##--suppress-cc=}"
1707
1708                 return
1709                 ;;
1710         --smtp-encryption=*)
1711                 __gitcomp "ssl tls" "" "${cur##--smtp-encryption=}"
1712                 return
1713                 ;;
1714         --thread=*)
1715                 __gitcomp "
1716                         deep shallow
1717                         " "" "${cur##--thread=}"
1718                 return
1719                 ;;
1720         --*)
1721                 __gitcomp "--annotate --bcc --cc --cc-cmd --chain-reply-to
1722                         --compose --confirm= --dry-run --envelope-sender
1723                         --from --identity
1724                         --in-reply-to --no-chain-reply-to --no-signed-off-by-cc
1725                         --no-suppress-from --no-thread --quiet
1726                         --signed-off-by-cc --smtp-pass --smtp-server
1727                         --smtp-server-port --smtp-encryption= --smtp-user
1728                         --subject --suppress-cc= --suppress-from --thread --to
1729                         --validate --no-validate
1730                         $__git_format_patch_options"
1731                 return
1732                 ;;
1733         esac
1734         __git_complete_revlist
1735 }
1736
1737 _git_stage ()
1738 {
1739         _git_add
1740 }
1741
1742 __git_config_get_set_variables ()
1743 {
1744         local prevword word config_file= c=$cword
1745         while [ $c -gt 1 ]; do
1746                 word="${words[c]}"
1747                 case "$word" in
1748                 --system|--global|--local|--file=*)
1749                         config_file="$word"
1750                         break
1751                         ;;
1752                 -f|--file)
1753                         config_file="$word $prevword"
1754                         break
1755                         ;;
1756                 esac
1757                 prevword=$word
1758                 c=$((--c))
1759         done
1760
1761         git --git-dir="$(__gitdir)" config $config_file --list 2>/dev/null |
1762         while read -r line
1763         do
1764                 case "$line" in
1765                 *.*=*)
1766                         echo "${line/=*/}"
1767                         ;;
1768                 esac
1769         done
1770 }
1771
1772 _git_config ()
1773 {
1774         case "$prev" in
1775         branch.*.remote|branch.*.pushremote)
1776                 __gitcomp_nl "$(__git_remotes)"
1777                 return
1778                 ;;
1779         branch.*.merge)
1780                 __gitcomp_nl "$(__git_refs)"
1781                 return
1782                 ;;
1783         branch.*.rebase)
1784                 __gitcomp "false true"
1785                 return
1786                 ;;
1787         remote.pushdefault)
1788                 __gitcomp_nl "$(__git_remotes)"
1789                 return
1790                 ;;
1791         remote.*.fetch)
1792                 local remote="${prev#remote.}"
1793                 remote="${remote%.fetch}"
1794                 if [ -z "$cur" ]; then
1795                         __gitcomp_nl "refs/heads/" "" "" ""
1796                         return
1797                 fi
1798                 __gitcomp_nl "$(__git_refs_remotes "$remote")"
1799                 return
1800                 ;;
1801         remote.*.push)
1802                 local remote="${prev#remote.}"
1803                 remote="${remote%.push}"
1804                 __gitcomp_nl "$(git --git-dir="$(__gitdir)" \
1805                         for-each-ref --format='%(refname):%(refname)' \
1806                         refs/heads)"
1807                 return
1808                 ;;
1809         pull.twohead|pull.octopus)
1810                 __git_compute_merge_strategies
1811                 __gitcomp "$__git_merge_strategies"
1812                 return
1813                 ;;
1814         color.branch|color.diff|color.interactive|\
1815         color.showbranch|color.status|color.ui)
1816                 __gitcomp "always never auto"
1817                 return
1818                 ;;
1819         color.pager)
1820                 __gitcomp "false true"
1821                 return
1822                 ;;
1823         color.*.*)
1824                 __gitcomp "
1825                         normal black red green yellow blue magenta cyan white
1826                         bold dim ul blink reverse
1827                         "
1828                 return
1829                 ;;
1830         diff.submodule)
1831                 __gitcomp "log short"
1832                 return
1833                 ;;
1834         help.format)
1835                 __gitcomp "man info web html"
1836                 return
1837                 ;;
1838         log.date)
1839                 __gitcomp "$__git_log_date_formats"
1840                 return
1841                 ;;
1842         sendemail.aliasesfiletype)
1843                 __gitcomp "mutt mailrc pine elm gnus"
1844                 return
1845                 ;;
1846         sendemail.confirm)
1847                 __gitcomp "$__git_send_email_confirm_options"
1848                 return
1849                 ;;
1850         sendemail.suppresscc)
1851                 __gitcomp "$__git_send_email_suppresscc_options"
1852                 return
1853                 ;;
1854         --get|--get-all|--unset|--unset-all)
1855                 __gitcomp_nl "$(__git_config_get_set_variables)"
1856                 return
1857                 ;;
1858         *.*)
1859                 return
1860                 ;;
1861         esac
1862         case "$cur" in
1863         --*)
1864                 __gitcomp "
1865                         --system --global --local --file=
1866                         --list --replace-all
1867                         --get --get-all --get-regexp
1868                         --add --unset --unset-all
1869                         --remove-section --rename-section
1870                         "
1871                 return
1872                 ;;
1873         branch.*.*)
1874                 local pfx="${cur%.*}." cur_="${cur##*.}"
1875                 __gitcomp "remote pushremote merge mergeoptions rebase" "$pfx" "$cur_"
1876                 return
1877                 ;;
1878         branch.*)
1879                 local pfx="${cur%.*}." cur_="${cur#*.}"
1880                 __gitcomp_nl "$(__git_heads)" "$pfx" "$cur_" "."
1881                 __gitcomp_nl_append $'autosetupmerge\nautosetuprebase\n' "$pfx" "$cur_"
1882                 return
1883                 ;;
1884         guitool.*.*)
1885                 local pfx="${cur%.*}." cur_="${cur##*.}"
1886                 __gitcomp "
1887                         argprompt cmd confirm needsfile noconsole norescan
1888                         prompt revprompt revunmerged title
1889                         " "$pfx" "$cur_"
1890                 return
1891                 ;;
1892         difftool.*.*)
1893                 local pfx="${cur%.*}." cur_="${cur##*.}"
1894                 __gitcomp "cmd path" "$pfx" "$cur_"
1895                 return
1896                 ;;
1897         man.*.*)
1898                 local pfx="${cur%.*}." cur_="${cur##*.}"
1899                 __gitcomp "cmd path" "$pfx" "$cur_"
1900                 return
1901                 ;;
1902         mergetool.*.*)
1903                 local pfx="${cur%.*}." cur_="${cur##*.}"
1904                 __gitcomp "cmd path trustExitCode" "$pfx" "$cur_"
1905                 return
1906                 ;;
1907         pager.*)
1908                 local pfx="${cur%.*}." cur_="${cur#*.}"
1909                 __git_compute_all_commands
1910                 __gitcomp_nl "$__git_all_commands" "$pfx" "$cur_"
1911                 return
1912                 ;;
1913         remote.*.*)
1914                 local pfx="${cur%.*}." cur_="${cur##*.}"
1915                 __gitcomp "
1916                         url proxy fetch push mirror skipDefaultUpdate
1917                         receivepack uploadpack tagopt pushurl
1918                         " "$pfx" "$cur_"
1919                 return
1920                 ;;
1921         remote.*)
1922                 local pfx="${cur%.*}." cur_="${cur#*.}"
1923                 __gitcomp_nl "$(__git_remotes)" "$pfx" "$cur_" "."
1924                 __gitcomp_nl_append "pushdefault" "$pfx" "$cur_"
1925                 return
1926                 ;;
1927         url.*.*)
1928                 local pfx="${cur%.*}." cur_="${cur##*.}"
1929                 __gitcomp "insteadOf pushInsteadOf" "$pfx" "$cur_"
1930                 return
1931                 ;;
1932         esac
1933         __gitcomp "
1934                 add.ignoreErrors
1935                 advice.commitBeforeMerge
1936                 advice.detachedHead
1937                 advice.implicitIdentity
1938                 advice.pushNonFastForward
1939                 advice.resolveConflict
1940                 advice.statusHints
1941                 alias.
1942                 am.keepcr
1943                 apply.ignorewhitespace
1944                 apply.whitespace
1945                 branch.autosetupmerge
1946                 branch.autosetuprebase
1947                 browser.
1948                 clean.requireForce
1949                 color.branch
1950                 color.branch.current
1951                 color.branch.local
1952                 color.branch.plain
1953                 color.branch.remote
1954                 color.decorate.HEAD
1955                 color.decorate.branch
1956                 color.decorate.remoteBranch
1957                 color.decorate.stash
1958                 color.decorate.tag
1959                 color.diff
1960                 color.diff.commit
1961                 color.diff.frag
1962                 color.diff.func
1963                 color.diff.meta
1964                 color.diff.new
1965                 color.diff.old
1966                 color.diff.plain
1967                 color.diff.whitespace
1968                 color.grep
1969                 color.grep.context
1970                 color.grep.filename
1971                 color.grep.function
1972                 color.grep.linenumber
1973                 color.grep.match
1974                 color.grep.selected
1975                 color.grep.separator
1976                 color.interactive
1977                 color.interactive.error
1978                 color.interactive.header
1979                 color.interactive.help
1980                 color.interactive.prompt
1981                 color.pager
1982                 color.showbranch
1983                 color.status
1984                 color.status.added
1985                 color.status.changed
1986                 color.status.header
1987                 color.status.nobranch
1988                 color.status.untracked
1989                 color.status.updated
1990                 color.ui
1991                 commit.status
1992                 commit.template
1993                 core.abbrev
1994                 core.askpass
1995                 core.attributesfile
1996                 core.autocrlf
1997                 core.bare
1998                 core.bigFileThreshold
1999                 core.compression
2000                 core.createObject
2001                 core.deltaBaseCacheLimit
2002                 core.editor
2003                 core.eol
2004                 core.excludesfile
2005                 core.fileMode
2006                 core.fsyncobjectfiles
2007                 core.gitProxy
2008                 core.ignoreStat
2009                 core.ignorecase
2010                 core.logAllRefUpdates
2011                 core.loosecompression
2012                 core.notesRef
2013                 core.packedGitLimit
2014                 core.packedGitWindowSize
2015                 core.pager
2016                 core.preferSymlinkRefs
2017                 core.preloadindex
2018                 core.quotepath
2019                 core.repositoryFormatVersion
2020                 core.safecrlf
2021                 core.sharedRepository
2022                 core.sparseCheckout
2023                 core.symlinks
2024                 core.trustctime
2025                 core.warnAmbiguousRefs
2026                 core.whitespace
2027                 core.worktree
2028                 diff.autorefreshindex
2029                 diff.external
2030                 diff.ignoreSubmodules
2031                 diff.mnemonicprefix
2032                 diff.noprefix
2033                 diff.renameLimit
2034                 diff.renames
2035                 diff.statGraphWidth
2036                 diff.submodule
2037                 diff.suppressBlankEmpty
2038                 diff.tool
2039                 diff.wordRegex
2040                 diff.algorithm
2041                 difftool.
2042                 difftool.prompt
2043                 fetch.recurseSubmodules
2044                 fetch.unpackLimit
2045                 format.attach
2046                 format.cc
2047                 format.coverLetter
2048                 format.headers
2049                 format.numbered
2050                 format.pretty
2051                 format.signature
2052                 format.signoff
2053                 format.subjectprefix
2054                 format.suffix
2055                 format.thread
2056                 format.to
2057                 gc.
2058                 gc.aggressiveWindow
2059                 gc.auto
2060                 gc.autopacklimit
2061                 gc.packrefs
2062                 gc.pruneexpire
2063                 gc.reflogexpire
2064                 gc.reflogexpireunreachable
2065                 gc.rerereresolved
2066                 gc.rerereunresolved
2067                 gitcvs.allbinary
2068                 gitcvs.commitmsgannotation
2069                 gitcvs.dbTableNamePrefix
2070                 gitcvs.dbdriver
2071                 gitcvs.dbname
2072                 gitcvs.dbpass
2073                 gitcvs.dbuser
2074                 gitcvs.enabled
2075                 gitcvs.logfile
2076                 gitcvs.usecrlfattr
2077                 guitool.
2078                 gui.blamehistoryctx
2079                 gui.commitmsgwidth
2080                 gui.copyblamethreshold
2081                 gui.diffcontext
2082                 gui.encoding
2083                 gui.fastcopyblame
2084                 gui.matchtrackingbranch
2085                 gui.newbranchtemplate
2086                 gui.pruneduringfetch
2087                 gui.spellingdictionary
2088                 gui.trustmtime
2089                 help.autocorrect
2090                 help.browser
2091                 help.format
2092                 http.lowSpeedLimit
2093                 http.lowSpeedTime
2094                 http.maxRequests
2095                 http.minSessions
2096                 http.noEPSV
2097                 http.postBuffer
2098                 http.proxy
2099                 http.sslCAInfo
2100                 http.sslCAPath
2101                 http.sslCert
2102                 http.sslCertPasswordProtected
2103                 http.sslKey
2104                 http.sslVerify
2105                 http.useragent
2106                 i18n.commitEncoding
2107                 i18n.logOutputEncoding
2108                 imap.authMethod
2109                 imap.folder
2110                 imap.host
2111                 imap.pass
2112                 imap.port
2113                 imap.preformattedHTML
2114                 imap.sslverify
2115                 imap.tunnel
2116                 imap.user
2117                 init.templatedir
2118                 instaweb.browser
2119                 instaweb.httpd
2120                 instaweb.local
2121                 instaweb.modulepath
2122                 instaweb.port
2123                 interactive.singlekey
2124                 log.date
2125                 log.decorate
2126                 log.showroot
2127                 mailmap.file
2128                 man.
2129                 man.viewer
2130                 merge.
2131                 merge.conflictstyle
2132                 merge.log
2133                 merge.renameLimit
2134                 merge.renormalize
2135                 merge.stat
2136                 merge.tool
2137                 merge.verbosity
2138                 mergetool.
2139                 mergetool.keepBackup
2140                 mergetool.keepTemporaries
2141                 mergetool.prompt
2142                 notes.displayRef
2143                 notes.rewrite.
2144                 notes.rewrite.amend
2145                 notes.rewrite.rebase
2146                 notes.rewriteMode
2147                 notes.rewriteRef
2148                 pack.compression
2149                 pack.deltaCacheLimit
2150                 pack.deltaCacheSize
2151                 pack.depth
2152                 pack.indexVersion
2153                 pack.packSizeLimit
2154                 pack.threads
2155                 pack.window
2156                 pack.windowMemory
2157                 pager.
2158                 pretty.
2159                 pull.octopus
2160                 pull.twohead
2161                 push.default
2162                 rebase.autosquash
2163                 rebase.stat
2164                 receive.autogc
2165                 receive.denyCurrentBranch
2166                 receive.denyDeleteCurrent
2167                 receive.denyDeletes
2168                 receive.denyNonFastForwards
2169                 receive.fsckObjects
2170                 receive.unpackLimit
2171                 receive.updateserverinfo
2172                 remote.pushdefault
2173                 remotes.
2174                 repack.usedeltabaseoffset
2175                 rerere.autoupdate
2176                 rerere.enabled
2177                 sendemail.
2178                 sendemail.aliasesfile
2179                 sendemail.aliasfiletype
2180                 sendemail.bcc
2181                 sendemail.cc
2182                 sendemail.cccmd
2183                 sendemail.chainreplyto
2184                 sendemail.confirm
2185                 sendemail.envelopesender
2186                 sendemail.from
2187                 sendemail.identity
2188                 sendemail.multiedit
2189                 sendemail.signedoffbycc
2190                 sendemail.smtpdomain
2191                 sendemail.smtpencryption
2192                 sendemail.smtppass
2193                 sendemail.smtpserver
2194                 sendemail.smtpserveroption
2195                 sendemail.smtpserverport
2196                 sendemail.smtpuser
2197                 sendemail.suppresscc
2198                 sendemail.suppressfrom
2199                 sendemail.thread
2200                 sendemail.to
2201                 sendemail.validate
2202                 showbranch.default
2203                 status.relativePaths
2204                 status.showUntrackedFiles
2205                 status.submodulesummary
2206                 submodule.
2207                 tar.umask
2208                 transfer.unpackLimit
2209                 url.
2210                 user.email
2211                 user.name
2212                 user.signingkey
2213                 web.browser
2214                 branch. remote.
2215         "
2216 }
2217
2218 _git_remote ()
2219 {
2220         local subcommands="add rename remove set-head set-branches set-url show prune update"
2221         local subcommand="$(__git_find_on_cmdline "$subcommands")"
2222         if [ -z "$subcommand" ]; then
2223                 __gitcomp "$subcommands"
2224                 return
2225         fi
2226
2227         case "$subcommand" in
2228         rename|remove|set-url|show|prune)
2229                 __gitcomp_nl "$(__git_remotes)"
2230                 ;;
2231         set-head|set-branches)
2232                 __git_complete_remote_or_refspec
2233                 ;;
2234         update)
2235                 local i c='' IFS=$'\n'
2236                 for i in $(git --git-dir="$(__gitdir)" config --get-regexp "remotes\..*" 2>/dev/null); do
2237                         i="${i#remotes.}"
2238                         c="$c ${i/ */}"
2239                 done
2240                 __gitcomp "$c"
2241                 ;;
2242         *)
2243                 ;;
2244         esac
2245 }
2246
2247 _git_replace ()
2248 {
2249         __gitcomp_nl "$(__git_refs)"
2250 }
2251
2252 _git_reset ()
2253 {
2254         __git_has_doubledash && return
2255
2256         case "$cur" in
2257         --*)
2258                 __gitcomp "--merge --mixed --hard --soft --patch"
2259                 return
2260                 ;;
2261         esac
2262         __gitcomp_nl "$(__git_refs)"
2263 }
2264
2265 _git_revert ()
2266 {
2267         case "$cur" in
2268         --*)
2269                 __gitcomp "--edit --mainline --no-edit --no-commit --signoff"
2270                 return
2271                 ;;
2272         esac
2273         __gitcomp_nl "$(__git_refs)"
2274 }
2275
2276 _git_rm ()
2277 {
2278         case "$cur" in
2279         --*)
2280                 __gitcomp "--cached --dry-run --ignore-unmatch --quiet"
2281                 return
2282                 ;;
2283         esac
2284
2285         __git_complete_index_file "--cached"
2286 }
2287
2288 _git_shortlog ()
2289 {
2290         __git_has_doubledash && return
2291
2292         case "$cur" in
2293         --*)
2294                 __gitcomp "
2295                         $__git_log_common_options
2296                         $__git_log_shortlog_options
2297                         --numbered --summary
2298                         "
2299                 return
2300                 ;;
2301         esac
2302         __git_complete_revlist
2303 }
2304
2305 _git_show ()
2306 {
2307         __git_has_doubledash && return
2308
2309         case "$cur" in
2310         --pretty=*|--format=*)
2311                 __gitcomp "$__git_log_pretty_formats $(__git_pretty_aliases)
2312                         " "" "${cur#*=}"
2313                 return
2314                 ;;
2315         --diff-algorithm=*)
2316                 __gitcomp "$__git_diff_algorithms" "" "${cur##--diff-algorithm=}"
2317                 return
2318                 ;;
2319         --*)
2320                 __gitcomp "--pretty= --format= --abbrev-commit --oneline
2321                         $__git_diff_common_options
2322                         "
2323                 return
2324                 ;;
2325         esac
2326         __git_complete_revlist_file
2327 }
2328
2329 _git_show_branch ()
2330 {
2331         case "$cur" in
2332         --*)
2333                 __gitcomp "
2334                         --all --remotes --topo-order --current --more=
2335                         --list --independent --merge-base --no-name
2336                         --color --no-color
2337                         --sha1-name --sparse --topics --reflog
2338                         "
2339                 return
2340                 ;;
2341         esac
2342         __git_complete_revlist
2343 }
2344
2345 _git_stash ()
2346 {
2347         local save_opts='--keep-index --no-keep-index --quiet --patch'
2348         local subcommands='save list show apply clear drop pop create branch'
2349         local subcommand="$(__git_find_on_cmdline "$subcommands")"
2350         if [ -z "$subcommand" ]; then
2351                 case "$cur" in
2352                 --*)
2353                         __gitcomp "$save_opts"
2354                         ;;
2355                 *)
2356                         if [ -z "$(__git_find_on_cmdline "$save_opts")" ]; then
2357                                 __gitcomp "$subcommands"
2358                         fi
2359                         ;;
2360                 esac
2361         else
2362                 case "$subcommand,$cur" in
2363                 save,--*)
2364                         __gitcomp "$save_opts"
2365                         ;;
2366                 apply,--*|pop,--*)
2367                         __gitcomp "--index --quiet"
2368                         ;;
2369                 show,--*|drop,--*|branch,--*)
2370                         ;;
2371                 show,*|apply,*|drop,*|pop,*|branch,*)
2372                         __gitcomp_nl "$(git --git-dir="$(__gitdir)" stash list \
2373                                         | sed -n -e 's/:.*//p')"
2374                         ;;
2375                 *)
2376                         ;;
2377                 esac
2378         fi
2379 }
2380
2381 _git_submodule ()
2382 {
2383         __git_has_doubledash && return
2384
2385         local subcommands="add status init deinit update summary foreach sync"
2386         if [ -z "$(__git_find_on_cmdline "$subcommands")" ]; then
2387                 case "$cur" in
2388                 --*)
2389                         __gitcomp "--quiet --cached"
2390                         ;;
2391                 *)
2392                         __gitcomp "$subcommands"
2393                         ;;
2394                 esac
2395                 return
2396         fi
2397 }
2398
2399 _git_svn ()
2400 {
2401         local subcommands="
2402                 init fetch clone rebase dcommit log find-rev
2403                 set-tree commit-diff info create-ignore propget
2404                 proplist show-ignore show-externals branch tag blame
2405                 migrate mkdirs reset gc
2406                 "
2407         local subcommand="$(__git_find_on_cmdline "$subcommands")"
2408         if [ -z "$subcommand" ]; then
2409                 __gitcomp "$subcommands"
2410         else
2411                 local remote_opts="--username= --config-dir= --no-auth-cache"
2412                 local fc_opts="
2413                         --follow-parent --authors-file= --repack=
2414                         --no-metadata --use-svm-props --use-svnsync-props
2415                         --log-window-size= --no-checkout --quiet
2416                         --repack-flags --use-log-author --localtime
2417                         --ignore-paths= --include-paths= $remote_opts
2418                         "
2419                 local init_opts="
2420                         --template= --shared= --trunk= --tags=
2421                         --branches= --stdlayout --minimize-url
2422                         --no-metadata --use-svm-props --use-svnsync-props
2423                         --rewrite-root= --prefix= --use-log-author
2424                         --add-author-from $remote_opts
2425                         "
2426                 local cmt_opts="
2427                         --edit --rmdir --find-copies-harder --copy-similarity=
2428                         "
2429
2430                 case "$subcommand,$cur" in
2431                 fetch,--*)
2432                         __gitcomp "--revision= --fetch-all $fc_opts"
2433                         ;;
2434                 clone,--*)
2435                         __gitcomp "--revision= $fc_opts $init_opts"
2436                         ;;
2437                 init,--*)
2438                         __gitcomp "$init_opts"
2439                         ;;
2440                 dcommit,--*)
2441                         __gitcomp "
2442                                 --merge --strategy= --verbose --dry-run
2443                                 --fetch-all --no-rebase --commit-url
2444                                 --revision --interactive $cmt_opts $fc_opts
2445                                 "
2446                         ;;
2447                 set-tree,--*)
2448                         __gitcomp "--stdin $cmt_opts $fc_opts"
2449                         ;;
2450                 create-ignore,--*|propget,--*|proplist,--*|show-ignore,--*|\
2451                 show-externals,--*|mkdirs,--*)
2452                         __gitcomp "--revision="
2453                         ;;
2454                 log,--*)
2455                         __gitcomp "
2456                                 --limit= --revision= --verbose --incremental
2457                                 --oneline --show-commit --non-recursive
2458                                 --authors-file= --color
2459                                 "
2460                         ;;
2461                 rebase,--*)
2462                         __gitcomp "
2463                                 --merge --verbose --strategy= --local
2464                                 --fetch-all --dry-run $fc_opts
2465                                 "
2466                         ;;
2467                 commit-diff,--*)
2468                         __gitcomp "--message= --file= --revision= $cmt_opts"
2469                         ;;
2470                 info,--*)
2471                         __gitcomp "--url"
2472                         ;;
2473                 branch,--*)
2474                         __gitcomp "--dry-run --message --tag"
2475                         ;;
2476                 tag,--*)
2477                         __gitcomp "--dry-run --message"
2478                         ;;
2479                 blame,--*)
2480                         __gitcomp "--git-format"
2481                         ;;
2482                 migrate,--*)
2483                         __gitcomp "
2484                                 --config-dir= --ignore-paths= --minimize
2485                                 --no-auth-cache --username=
2486                                 "
2487                         ;;
2488                 reset,--*)
2489                         __gitcomp "--revision= --parent"
2490                         ;;
2491                 *)
2492                         ;;
2493                 esac
2494         fi
2495 }
2496
2497 _git_tag ()
2498 {
2499         local i c=1 f=0
2500         while [ $c -lt $cword ]; do
2501                 i="${words[c]}"
2502                 case "$i" in
2503                 -d|-v)
2504                         __gitcomp_nl "$(__git_tags)"
2505                         return
2506                         ;;
2507                 -f)
2508                         f=1
2509                         ;;
2510                 esac
2511                 ((c++))
2512         done
2513
2514         case "$prev" in
2515         -m|-F)
2516                 ;;
2517         -*|tag)
2518                 if [ $f = 1 ]; then
2519                         __gitcomp_nl "$(__git_tags)"
2520                 fi
2521                 ;;
2522         *)
2523                 __gitcomp_nl "$(__git_refs)"
2524                 ;;
2525         esac
2526 }
2527
2528 _git_whatchanged ()
2529 {
2530         _git_log
2531 }
2532
2533 __git_main ()
2534 {
2535         local i c=1 command __git_dir
2536
2537         while [ $c -lt $cword ]; do
2538                 i="${words[c]}"
2539                 case "$i" in
2540                 --git-dir=*) __git_dir="${i#--git-dir=}" ;;
2541                 --git-dir)   ((c++)) ; __git_dir="${words[c]}" ;;
2542                 --bare)      __git_dir="." ;;
2543                 --help) command="help"; break ;;
2544                 -c|--work-tree|--namespace) ((c++)) ;;
2545                 -*) ;;
2546                 *) command="$i"; break ;;
2547                 esac
2548                 ((c++))
2549         done
2550
2551         if [ -z "$command" ]; then
2552                 case "$cur" in
2553                 --*)   __gitcomp "
2554                         --paginate
2555                         --no-pager
2556                         --git-dir=
2557                         --bare
2558                         --version
2559                         --exec-path
2560                         --exec-path=
2561                         --html-path
2562                         --man-path
2563                         --info-path
2564                         --work-tree=
2565                         --namespace=
2566                         --no-replace-objects
2567                         --help
2568                         "
2569                         ;;
2570                 *)     __git_compute_porcelain_commands
2571                        __gitcomp "$__git_porcelain_commands $(__git_aliases)" ;;
2572                 esac
2573                 return
2574         fi
2575
2576         local completion_func="_git_${command//-/_}"
2577         declare -f $completion_func >/dev/null && $completion_func && return
2578
2579         local expansion=$(__git_aliased_command "$command")
2580         if [ -n "$expansion" ]; then
2581                 words[1]=$expansion
2582                 completion_func="_git_${expansion//-/_}"
2583                 declare -f $completion_func >/dev/null && $completion_func
2584         fi
2585 }
2586
2587 __gitk_main ()
2588 {
2589         __git_has_doubledash && return
2590
2591         local g="$(__gitdir)"
2592         local merge=""
2593         if [ -f "$g/MERGE_HEAD" ]; then
2594                 merge="--merge"
2595         fi
2596         case "$cur" in
2597         --*)
2598                 __gitcomp "
2599                         $__git_log_common_options
2600                         $__git_log_gitk_options
2601                         $merge
2602                         "
2603                 return
2604                 ;;
2605         esac
2606         __git_complete_revlist
2607 }
2608
2609 if [[ -n ${ZSH_VERSION-} ]]; then
2610         echo "WARNING: this script is deprecated, please see git-completion.zsh" 1>&2
2611
2612         autoload -U +X compinit && compinit
2613
2614         __gitcomp ()
2615         {
2616                 emulate -L zsh
2617
2618                 local cur_="${3-$cur}"
2619
2620                 case "$cur_" in
2621                 --*=)
2622                         ;;
2623                 *)
2624                         local c IFS=$' \t\n'
2625                         local -a array
2626                         for c in ${=1}; do
2627                                 c="$c${4-}"
2628                                 case $c in
2629                                 --*=*|*.) ;;
2630                                 *) c="$c " ;;
2631                                 esac
2632                                 array[${#array[@]}+1]="$c"
2633                         done
2634                         compset -P '*[=:]'
2635                         compadd -Q -S '' -p "${2-}" -a -- array && _ret=0
2636                         ;;
2637                 esac
2638         }
2639
2640         __gitcomp_nl ()
2641         {
2642                 emulate -L zsh
2643
2644                 local IFS=$'\n'
2645                 compset -P '*[=:]'
2646                 compadd -Q -S "${4- }" -p "${2-}" -- ${=1} && _ret=0
2647         }
2648
2649         __gitcomp_file ()
2650         {
2651                 emulate -L zsh
2652
2653                 local IFS=$'\n'
2654                 compset -P '*[=:]'
2655                 compadd -Q -p "${2-}" -f -- ${=1} && _ret=0
2656         }
2657
2658         _git ()
2659         {
2660                 local _ret=1 cur cword prev
2661                 cur=${words[CURRENT]}
2662                 prev=${words[CURRENT-1]}
2663                 let cword=CURRENT-1
2664                 emulate ksh -c __${service}_main
2665                 let _ret && _default && _ret=0
2666                 return _ret
2667         }
2668
2669         compdef _git git gitk
2670         return
2671 fi
2672
2673 __git_func_wrap ()
2674 {
2675         local cur words cword prev
2676         _get_comp_words_by_ref -n =: cur words cword prev
2677         $1
2678 }
2679
2680 # Setup completion for certain functions defined above by setting common
2681 # variables and workarounds.
2682 # This is NOT a public function; use at your own risk.
2683 __git_complete ()
2684 {
2685         local wrapper="__git_wrap${2}"
2686         eval "$wrapper () { __git_func_wrap $2 ; }"
2687         complete -o bashdefault -o default -o nospace -F $wrapper $1 2>/dev/null \
2688                 || complete -o default -o nospace -F $wrapper $1
2689 }
2690
2691 # wrapper for backwards compatibility
2692 _git ()
2693 {
2694         __git_wrap__git_main
2695 }
2696
2697 # wrapper for backwards compatibility
2698 _gitk ()
2699 {
2700         __git_wrap__gitk_main
2701 }
2702
2703 __git_complete git __git_main
2704 __git_complete gitk __gitk_main
2705
2706 # The following are necessary only for Cygwin, and only are needed
2707 # when the user has tab-completed the executable name and consequently
2708 # included the '.exe' suffix.
2709 #
2710 if [ Cygwin = "$(uname -o 2>/dev/null)" ]; then
2711 __git_complete git.exe __git_main
2712 fi