contrib/completion/git-completion.bash

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