git.oblomov.eu Git - git/blob - 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-ref-format) : plumbing;;
 652                 checkout-index)   : plumbing;;
 653                 commit-tree)      : plumbing;;
 654                 count-objects)    : infrequent;;
 655                 credential-cache) : credentials helper;;
 656                 credential-store) : credentials helper;;
 657                 cvsexportcommit)  : export;;
 658                 cvsimport)        : import;;
 659                 cvsserver)        : daemon;;
 660                 daemon)           : daemon;;
 661                 diff-files)       : plumbing;;
 662                 diff-index)       : plumbing;;
 663                 diff-tree)        : plumbing;;
 664                 fast-import)      : import;;
 665                 fast-export)      : export;;
 666                 fsck-objects)     : plumbing;;
 667                 fetch-pack)       : plumbing;;
 668                 fmt-merge-msg)    : plumbing;;
 669                 for-each-ref)     : plumbing;;
 670                 hash-object)      : plumbing;;
 671                 http-*)           : transport;;
 672                 index-pack)       : plumbing;;
 673                 init-db)          : deprecated;;
 674                 local-fetch)      : plumbing;;
 675                 lost-found)       : infrequent;;
 676                 ls-files)         : plumbing;;
 677                 ls-remote)        : plumbing;;
 678                 ls-tree)          : plumbing;;
 679                 mailinfo)         : plumbing;;
 680                 mailsplit)        : plumbing;;
 681                 merge-*)          : plumbing;;
 682                 mktree)           : plumbing;;
 683                 mktag)            : plumbing;;
 684                 pack-objects)     : plumbing;;
 685                 pack-redundant)   : plumbing;;
 686                 pack-refs)        : plumbing;;
 687                 parse-remote)     : plumbing;;
 688                 patch-id)         : plumbing;;
 689                 peek-remote)      : plumbing;;
 690                 prune)            : plumbing;;
 691                 prune-packed)     : plumbing;;
 692                 quiltimport)      : import;;
 693                 read-tree)        : plumbing;;
 694                 receive-pack)     : plumbing;;
 695                 remote-*)         : transport;;
 696                 repo-config)      : deprecated;;
 697                 rerere)           : plumbing;;
 698                 rev-list)         : plumbing;;
 699                 rev-parse)        : plumbing;;
 700                 runstatus)        : plumbing;;
 701                 sh-setup)         : internal;;
 702                 shell)            : daemon;;
 703                 show-ref)         : plumbing;;
 704                 send-pack)        : plumbing;;
 705                 show-index)       : plumbing;;
 706                 ssh-*)            : transport;;
 707                 stripspace)       : plumbing;;
 708                 symbolic-ref)     : plumbing;;
 709                 tar-tree)         : deprecated;;
 710                 unpack-file)      : plumbing;;
 711                 unpack-objects)   : plumbing;;
 712                 update-index)     : plumbing;;
 713                 update-ref)       : plumbing;;
 714                 update-server-info) : daemon;;
 715                 upload-archive)   : plumbing;;
 716                 upload-pack)      : plumbing;;
 717                 write-tree)       : plumbing;;
 718                 var)              : infrequent;;
 719                 verify-pack)      : infrequent;;
 720                 verify-tag)       : plumbing;;
 721                 *) echo $i;;
 722                 esac
 723         done
 724 }
 725
 726 __git_porcelain_commands=
 727 __git_compute_porcelain_commands ()
 728 {
 729         __git_compute_all_commands
 730         test -n "$__git_porcelain_commands" ||
 731         __git_porcelain_commands=$(__git_list_porcelain_commands)
 732 }
 733
 734 __git_pretty_aliases ()
 735 {
 736         local i IFS=$'\n'
 737         for i in $(git --git-dir="$(__gitdir)" config --get-regexp "pretty\..*" 2>/dev/null); do
 738                 case "$i" in
 739                 pretty.*)
 740                         i="${i#pretty.}"
 741                         echo "${i/ */}"
 742                         ;;
 743                 esac
 744         done
 745 }
 746
 747 __git_aliases ()
 748 {
 749         local i IFS=$'\n'
 750         for i in $(git --git-dir="$(__gitdir)" config --get-regexp "alias\..*" 2>/dev/null); do
 751                 case "$i" in
 752                 alias.*)
 753                         i="${i#alias.}"
 754                         echo "${i/ */}"
 755                         ;;
 756                 esac
 757         done
 758 }
 759
 760 # __git_aliased_command requires 1 argument
 761 __git_aliased_command ()
 762 {
 763         local word cmdline=$(git --git-dir="$(__gitdir)" \
 764                 config --get "alias.$1")
 765         for word in $cmdline; do
 766                 case "$word" in
 767                 \!gitk|gitk)
 768                         echo "gitk"
 769                         return
 770                         ;;
 771                 \!*)    : shell command alias ;;
 772                 -*)     : option ;;
 773                 *=*)    : setting env ;;
 774                 git)    : git itself ;;
 775                 *)
 776                         echo "$word"
 777                         return
 778                 esac
 779         done
 780 }
 781
 782 # __git_find_on_cmdline requires 1 argument
 783 __git_find_on_cmdline ()
 784 {
 785         local word subcommand c=1
 786         while [ $c -lt $cword ]; do
 787                 word="${words[c]}"
 788                 for subcommand in $1; do
 789                         if [ "$subcommand" = "$word" ]; then
 790                                 echo "$subcommand"
 791                                 return
 792                         fi
 793                 done
 794                 ((c++))
 795         done
 796 }
 797
 798 __git_has_doubledash ()
 799 {
 800         local c=1
 801         while [ $c -lt $cword ]; do
 802                 if [ "--" = "${words[c]}" ]; then
 803                         return 0
 804                 fi
 805                 ((c++))
 806         done
 807         return 1
 808 }
 809
 810 # Try to count non option arguments passed on the command line for the
 811 # specified git command.
 812 # When options are used, it is necessary to use the special -- option to
 813 # tell the implementation were non option arguments begin.
 814 # XXX this can not be improved, since options can appear everywhere, as
 815 # an example:
 816 #       git mv x -n y
 817 #
 818 # __git_count_arguments requires 1 argument: the git command executed.
 819 __git_count_arguments ()
 820 {
 821         local word i c=0
 822
 823         # Skip "git" (first argument)
 824         for ((i=1; i < ${#words[@]}; i++)); do
 825                 word="${words[i]}"
 826
 827                 case "$word" in
 828                         --)
 829                                 # Good; we can assume that the following are only non
 830                                 # option arguments.
 831                                 ((c = 0))
 832                                 ;;
 833                         "$1")
 834                                 # Skip the specified git command and discard git
 835                                 # main options
 836                                 ((c = 0))
 837                                 ;;
 838                         ?*)
 839                                 ((c++))
 840                                 ;;
 841                 esac
 842         done
 843
 844         printf "%d" $c
 845 }
 846
 847 __git_whitespacelist="nowarn warn error error-all fix"
 848
 849 _git_am ()
 850 {
 851         local dir="$(__gitdir)"
 852         if [ -d "$dir"/rebase-apply ]; then
 853                 __gitcomp "--skip --continue --resolved --abort"
 854                 return
 855         fi
 856         case "$cur" in
 857         --whitespace=*)
 858                 __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
 859                 return
 860                 ;;
 861         --*)
 862                 __gitcomp "
 863                         --3way --committer-date-is-author-date --ignore-date
 864                         --ignore-whitespace --ignore-space-change
 865                         --interactive --keep --no-utf8 --signoff --utf8
 866                         --whitespace= --scissors
 867                         "
 868                 return
 869         esac
 870 }
 871
 872 _git_apply ()
 873 {
 874         case "$cur" in
 875         --whitespace=*)
 876                 __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
 877                 return
 878                 ;;
 879         --*)
 880                 __gitcomp "
 881                         --stat --numstat --summary --check --index
 882                         --cached --index-info --reverse --reject --unidiff-zero
 883                         --apply --no-add --exclude=
 884                         --ignore-whitespace --ignore-space-change
 885                         --whitespace= --inaccurate-eof --verbose
 886                         "
 887                 return
 888         esac
 889 }
 890
 891 _git_add ()
 892 {
 893         case "$cur" in
 894         --*)
 895                 __gitcomp "
 896                         --interactive --refresh --patch --update --dry-run
 897                         --ignore-errors --intent-to-add
 898                         "
 899                 return
 900         esac
 901
 902         # XXX should we check for --update and --all options ?
 903         __git_complete_index_file "--others --modified"
 904 }
 905
 906 _git_archive ()
 907 {
 908         case "$cur" in
 909         --format=*)
 910                 __gitcomp "$(git archive --list)" "" "${cur##--format=}"
 911                 return
 912                 ;;
 913         --remote=*)
 914                 __gitcomp_nl "$(__git_remotes)" "" "${cur##--remote=}"
 915                 return
 916                 ;;
 917         --*)
 918                 __gitcomp "
 919                         --format= --list --verbose
 920                         --prefix= --remote= --exec=
 921                         "
 922                 return
 923                 ;;
 924         esac
 925         __git_complete_file
 926 }
 927
 928 _git_bisect ()
 929 {
 930         __git_has_doubledash && return
 931
 932         local subcommands="start bad good skip reset visualize replay log run"
 933         local subcommand="$(__git_find_on_cmdline "$subcommands")"
 934         if [ -z "$subcommand" ]; then
 935                 if [ -f "$(__gitdir)"/BISECT_START ]; then
 936                         __gitcomp "$subcommands"
 937                 else
 938                         __gitcomp "replay start"
 939                 fi
 940                 return
 941         fi
 942
 943         case "$subcommand" in
 944         bad|good|reset|skip|start)
 945                 __gitcomp_nl "$(__git_refs)"
 946                 ;;
 947         *)
 948                 ;;
 949         esac
 950 }
 951
 952 _git_branch ()
 953 {
 954         local i c=1 only_local_ref="n" has_r="n"
 955
 956         while [ $c -lt $cword ]; do
 957                 i="${words[c]}"
 958                 case "$i" in
 959                 -d|-m)  only_local_ref="y" ;;
 960                 -r)     has_r="y" ;;
 961                 esac
 962                 ((c++))
 963         done
 964
 965         case "$cur" in
 966         --set-upstream-to=*)
 967                 __gitcomp "$(__git_refs)" "" "${cur##--set-upstream-to=}"
 968                 ;;
 969         --*)
 970                 __gitcomp "
 971                         --color --no-color --verbose --abbrev= --no-abbrev
 972                         --track --no-track --contains --merged --no-merged
 973                         --set-upstream-to= --edit-description --list
 974                         --unset-upstream
 975                         "
 976                 ;;
 977         *)
 978                 if [ $only_local_ref = "y" -a $has_r = "n" ]; then
 979                         __gitcomp_nl "$(__git_heads)"
 980                 else
 981                         __gitcomp_nl "$(__git_refs)"
 982                 fi
 983                 ;;
 984         esac
 985 }
 986
 987 _git_bundle ()
 988 {
 989         local cmd="${words[2]}"
 990         case "$cword" in
 991         2)
 992                 __gitcomp "create list-heads verify unbundle"
 993                 ;;
 994         3)
 995                 # looking for a file
 996                 ;;
 997         *)
 998                 case "$cmd" in
 999                         create)
1000                                 __git_complete_revlist
1001                         ;;
1002                 esac
1003                 ;;
1004         esac
1005 }
1006
1007 _git_checkout ()
1008 {
1009         __git_has_doubledash && return
1010
1011         case "$cur" in
1012         --conflict=*)
1013                 __gitcomp "diff3 merge" "" "${cur##--conflict=}"
1014                 ;;
1015         --*)
1016                 __gitcomp "
1017                         --quiet --ours --theirs --track --no-track --merge
1018                         --conflict= --orphan --patch
1019                         "
1020                 ;;
1021         *)
1022                 # check if --track, --no-track, or --no-guess was specified
1023                 # if so, disable DWIM mode
1024                 local flags="--track --no-track --no-guess" track=1
1025                 if [ -n "$(__git_find_on_cmdline "$flags")" ]; then
1026                         track=''
1027                 fi
1028                 __gitcomp_nl "$(__git_refs '' $track)"
1029                 ;;
1030         esac
1031 }
1032
1033 _git_cherry ()
1034 {
1035         __gitcomp "$(__git_refs)"
1036 }
1037
1038 _git_cherry_pick ()
1039 {
1040         local dir="$(__gitdir)"
1041         if [ -f "$dir"/CHERRY_PICK_HEAD ]; then
1042                 __gitcomp "--continue --quit --abort"
1043                 return
1044         fi
1045         case "$cur" in
1046         --*)
1047                 __gitcomp "--edit --no-commit --signoff --strategy= --mainline"
1048                 ;;
1049         *)
1050                 __gitcomp_nl "$(__git_refs)"
1051                 ;;
1052         esac
1053 }
1054
1055 _git_clean ()
1056 {
1057         case "$cur" in
1058         --*)
1059                 __gitcomp "--dry-run --quiet"
1060                 return
1061                 ;;
1062         esac
1063
1064         # XXX should we check for -x option ?
1065         __git_complete_index_file "--others"
1066 }
1067
1068 _git_clone ()
1069 {
1070         case "$cur" in
1071         --*)
1072                 __gitcomp "
1073                         --local
1074                         --no-hardlinks
1075                         --shared
1076                         --reference
1077                         --quiet
1078                         --no-checkout
1079                         --bare
1080                         --mirror
1081                         --origin
1082                         --upload-pack
1083                         --template=
1084                         --depth
1085                         --single-branch
1086                         --branch
1087                         "
1088                 return
1089                 ;;
1090         esac
1091 }
1092
1093 _git_commit ()
1094 {
1095         case "$prev" in
1096         -c|-C)
1097                 __gitcomp_nl "$(__git_refs)" "" "${cur}"
1098                 return
1099                 ;;
1100         esac
1101
1102         case "$cur" in
1103         --cleanup=*)
1104                 __gitcomp "default strip verbatim whitespace
1105                         " "" "${cur##--cleanup=}"
1106                 return
1107                 ;;
1108         --reuse-message=*|--reedit-message=*|\
1109         --fixup=*|--squash=*)
1110                 __gitcomp_nl "$(__git_refs)" "" "${cur#*=}"
1111                 return
1112                 ;;
1113         --untracked-files=*)
1114                 __gitcomp "all no normal" "" "${cur##--untracked-files=}"
1115                 return
1116                 ;;
1117         --*)
1118                 __gitcomp "
1119                         --all --author= --signoff --verify --no-verify
1120                         --edit --no-edit
1121                         --amend --include --only --interactive
1122                         --dry-run --reuse-message= --reedit-message=
1123                         --reset-author --file= --message= --template=
1124                         --cleanup= --untracked-files --untracked-files=
1125                         --verbose --quiet --fixup= --squash=
1126                         "
1127                 return
1128         esac
1129
1130         if git rev-parse --verify --quiet HEAD >/dev/null; then
1131                 __git_complete_index_file "--committable"
1132         else
1133                 # This is the first commit
1134                 __git_complete_index_file "--cached"
1135         fi
1136 }
1137
1138 _git_describe ()
1139 {
1140         case "$cur" in
1141         --*)
1142                 __gitcomp "
1143                         --all --tags --contains --abbrev= --candidates=
1144                         --exact-match --debug --long --match --always
1145                         "
1146                 return
1147         esac
1148         __gitcomp_nl "$(__git_refs)"
1149 }
1150
1151 __git_diff_algorithms="myers minimal patience histogram"
1152
1153 __git_diff_common_options="--stat --numstat --shortstat --summary
1154                         --patch-with-stat --name-only --name-status --color
1155                         --no-color --color-words --no-renames --check
1156                         --full-index --binary --abbrev --diff-filter=
1157                         --find-copies-harder
1158                         --text --ignore-space-at-eol --ignore-space-change
1159                         --ignore-all-space --exit-code --quiet --ext-diff
1160                         --no-ext-diff
1161                         --no-prefix --src-prefix= --dst-prefix=
1162                         --inter-hunk-context=
1163                         --patience --histogram --minimal
1164                         --raw --word-diff
1165                         --dirstat --dirstat= --dirstat-by-file
1166                         --dirstat-by-file= --cumulative
1167                         --diff-algorithm=
1168 "
1169
1170 _git_diff ()
1171 {
1172         __git_has_doubledash && return
1173
1174         case "$cur" in
1175         --diff-algorithm=*)
1176                 __gitcomp "$__git_diff_algorithms" "" "${cur##--diff-algorithm=}"
1177                 return
1178                 ;;
1179         --*)
1180                 __gitcomp "--cached --staged --pickaxe-all --pickaxe-regex
1181                         --base --ours --theirs --no-index
1182                         $__git_diff_common_options
1183                         "
1184                 return
1185                 ;;
1186         esac
1187         __git_complete_revlist_file
1188 }
1189
1190 __git_mergetools_common="diffuse ecmerge emerge kdiff3 meld opendiff
1191                         tkdiff vimdiff gvimdiff xxdiff araxis p4merge bc3 codecompare
1192 "
1193
1194 _git_difftool ()
1195 {
1196         __git_has_doubledash && return
1197
1198         case "$cur" in
1199         --tool=*)
1200                 __gitcomp "$__git_mergetools_common kompare" "" "${cur##--tool=}"
1201                 return
1202                 ;;
1203         --*)
1204                 __gitcomp "--cached --staged --pickaxe-all --pickaxe-regex
1205                         --base --ours --theirs
1206                         --no-renames --diff-filter= --find-copies-harder
1207                         --relative --ignore-submodules
1208                         --tool="
1209                 return
1210                 ;;
1211         esac
1212         __git_complete_revlist_file
1213 }
1214
1215 __git_fetch_options="
1216         --quiet --verbose --append --upload-pack --force --keep --depth=
1217         --tags --no-tags --all --prune --dry-run
1218 "
1219
1220 _git_fetch ()
1221 {
1222         case "$cur" in
1223         --*)
1224                 __gitcomp "$__git_fetch_options"
1225                 return
1226                 ;;
1227         esac
1228         __git_complete_remote_or_refspec
1229 }
1230
1231 __git_format_patch_options="
1232         --stdout --attach --no-attach --thread --thread= --no-thread
1233         --numbered --start-number --numbered-files --keep-subject --signoff
1234         --signature --no-signature --in-reply-to= --cc= --full-index --binary
1235         --not --all --cover-letter --no-prefix --src-prefix= --dst-prefix=
1236         --inline --suffix= --ignore-if-in-upstream --subject-prefix=
1237         --output-directory --reroll-count --to= --quiet --notes
1238 "
1239
1240 _git_format_patch ()
1241 {
1242         case "$cur" in
1243         --thread=*)
1244                 __gitcomp "
1245                         deep shallow
1246                         " "" "${cur##--thread=}"
1247                 return
1248                 ;;
1249         --*)
1250                 __gitcomp "$__git_format_patch_options"
1251                 return
1252                 ;;
1253         esac
1254         __git_complete_revlist
1255 }
1256
1257 _git_fsck ()
1258 {
1259         case "$cur" in
1260         --*)
1261                 __gitcomp "
1262                         --tags --root --unreachable --cache --no-reflogs --full
1263                         --strict --verbose --lost-found
1264                         "
1265                 return
1266                 ;;
1267         esac
1268 }
1269
1270 _git_gc ()
1271 {
1272         case "$cur" in
1273         --*)
1274                 __gitcomp "--prune --aggressive"
1275                 return
1276                 ;;
1277         esac
1278 }
1279
1280 _git_gitk ()
1281 {
1282         _gitk
1283 }
1284
1285 __git_match_ctag() {
1286         awk "/^${1////\\/}/ { print \$1 }" "$2"
1287 }
1288
1289 _git_grep ()
1290 {
1291         __git_has_doubledash && return
1292
1293         case "$cur" in
1294         --*)
1295                 __gitcomp "
1296                         --cached
1297                         --text --ignore-case --word-regexp --invert-match
1298                         --full-name --line-number
1299                         --extended-regexp --basic-regexp --fixed-strings
1300                         --perl-regexp
1301                         --files-with-matches --name-only
1302                         --files-without-match
1303                         --max-depth
1304                         --count
1305                         --and --or --not --all-match
1306                         "
1307                 return
1308                 ;;
1309         esac
1310
1311         case "$cword,$prev" in
1312         2,*|*,-*)
1313                 if test -r tags; then
1314                         __gitcomp_nl "$(__git_match_ctag "$cur" tags)"
1315                         return
1316                 fi
1317                 ;;
1318         esac
1319
1320         __gitcomp_nl "$(__git_refs)"
1321 }
1322
1323 _git_help ()
1324 {
1325         case "$cur" in
1326         --*)
1327                 __gitcomp "--all --info --man --web"
1328                 return
1329                 ;;
1330         esac
1331         __git_compute_all_commands
1332         __gitcomp "$__git_all_commands $(__git_aliases)
1333                 attributes cli core-tutorial cvs-migration
1334                 diffcore gitk glossary hooks ignore modules
1335                 namespaces repository-layout tutorial tutorial-2
1336                 workflows
1337                 "
1338 }
1339
1340 _git_init ()
1341 {
1342         case "$cur" in
1343         --shared=*)
1344                 __gitcomp "
1345                         false true umask group all world everybody
1346                         " "" "${cur##--shared=}"
1347                 return
1348                 ;;
1349         --*)
1350                 __gitcomp "--quiet --bare --template= --shared --shared="
1351                 return
1352                 ;;
1353         esac
1354 }
1355
1356 _git_ls_files ()
1357 {
1358         case "$cur" in
1359         --*)
1360                 __gitcomp "--cached --deleted --modified --others --ignored
1361                         --stage --directory --no-empty-directory --unmerged
1362                         --killed --exclude= --exclude-from=
1363                         --exclude-per-directory= --exclude-standard
1364                         --error-unmatch --with-tree= --full-name
1365                         --abbrev --ignored --exclude-per-directory
1366                         "
1367                 return
1368                 ;;
1369         esac
1370
1371         # XXX ignore options like --modified and always suggest all cached
1372         # files.
1373         __git_complete_index_file "--cached"
1374 }
1375
1376 _git_ls_remote ()
1377 {
1378         __gitcomp_nl "$(__git_remotes)"
1379 }
1380
1381 _git_ls_tree ()
1382 {
1383         __git_complete_file
1384 }
1385
1386 # Options that go well for log, shortlog and gitk
1387 __git_log_common_options="
1388         --not --all
1389         --branches --tags --remotes
1390         --first-parent --merges --no-merges
1391         --max-count=
1392         --max-age= --since= --after=
1393         --min-age= --until= --before=
1394         --min-parents= --max-parents=
1395         --no-min-parents --no-max-parents
1396 "
1397 # Options that go well for log and gitk (not shortlog)
1398 __git_log_gitk_options="
1399         --dense --sparse --full-history
1400         --simplify-merges --simplify-by-decoration
1401         --left-right --notes --no-notes
1402 "
1403 # Options that go well for log and shortlog (not gitk)
1404 __git_log_shortlog_options="
1405         --author= --committer= --grep=
1406         --all-match
1407 "
1408
1409 __git_log_pretty_formats="oneline short medium full fuller email raw format:"
1410 __git_log_date_formats="relative iso8601 rfc2822 short local default raw"
1411
1412 _git_log ()
1413 {
1414         __git_has_doubledash && return
1415
1416         local g="$(git rev-parse --git-dir 2>/dev/null)"
1417         local merge=""
1418         if [ -f "$g/MERGE_HEAD" ]; then
1419                 merge="--merge"
1420         fi
1421         case "$cur" in
1422         --pretty=*|--format=*)
1423                 __gitcomp "$__git_log_pretty_formats $(__git_pretty_aliases)
1424                         " "" "${cur#*=}"
1425                 return
1426                 ;;
1427         --date=*)
1428                 __gitcomp "$__git_log_date_formats" "" "${cur##--date=}"
1429                 return
1430                 ;;
1431         --decorate=*)
1432                 __gitcomp "long short" "" "${cur##--decorate=}"
1433                 return
1434                 ;;
1435         --*)
1436                 __gitcomp "
1437                         $__git_log_common_options
1438                         $__git_log_shortlog_options
1439                         $__git_log_gitk_options
1440                         --root --topo-order --date-order --reverse
1441                         --follow --full-diff
1442                         --abbrev-commit --abbrev=
1443                         --relative-date --date=
1444                         --pretty= --format= --oneline
1445                         --cherry-pick
1446                         --graph
1447                         --decorate --decorate=
1448                         --walk-reflogs
1449                         --parents --children
1450                         $merge
1451                         $__git_diff_common_options
1452                         --pickaxe-all --pickaxe-regex
1453                         "
1454                 return
1455                 ;;
1456         esac
1457         __git_complete_revlist
1458 }
1459
1460 __git_merge_options="
1461         --no-commit --no-stat --log --no-log --squash --strategy
1462         --commit --stat --no-squash --ff --no-ff --ff-only --edit --no-edit
1463 "
1464
1465 _git_merge ()
1466 {
1467         __git_complete_strategy && return
1468
1469         case "$cur" in
1470         --*)
1471                 __gitcomp "$__git_merge_options"
1472                 return
1473         esac
1474         __gitcomp_nl "$(__git_refs)"
1475 }
1476
1477 _git_mergetool ()
1478 {
1479         case "$cur" in
1480         --tool=*)
1481                 __gitcomp "$__git_mergetools_common tortoisemerge" "" "${cur##--tool=}"
1482                 return
1483                 ;;
1484         --*)
1485                 __gitcomp "--tool="
1486                 return
1487                 ;;
1488         esac
1489 }
1490
1491 _git_merge_base ()
1492 {
1493         __gitcomp_nl "$(__git_refs)"
1494 }
1495
1496 _git_mv ()
1497 {
1498         case "$cur" in
1499         --*)
1500                 __gitcomp "--dry-run"
1501                 return
1502                 ;;
1503         esac
1504
1505         if [ $(__git_count_arguments "mv") -gt 0 ]; then
1506                 # We need to show both cached and untracked files (including
1507                 # empty directories) since this may not be the last argument.
1508                 __git_complete_index_file "--cached --others --directory"
1509         else
1510                 __git_complete_index_file "--cached"
1511         fi
1512 }
1513
1514 _git_name_rev ()
1515 {
1516         __gitcomp "--tags --all --stdin"
1517 }
1518
1519 _git_notes ()
1520 {
1521         local subcommands='add append copy edit list prune remove show'
1522         local subcommand="$(__git_find_on_cmdline "$subcommands")"
1523
1524         case "$subcommand,$cur" in
1525         ,--*)
1526                 __gitcomp '--ref'
1527                 ;;
1528         ,*)
1529                 case "$prev" in
1530                 --ref)
1531                         __gitcomp_nl "$(__git_refs)"
1532                         ;;
1533                 *)
1534                         __gitcomp "$subcommands --ref"
1535                         ;;
1536                 esac
1537                 ;;
1538         add,--reuse-message=*|append,--reuse-message=*|\
1539         add,--reedit-message=*|append,--reedit-message=*)
1540                 __gitcomp_nl "$(__git_refs)" "" "${cur#*=}"
1541                 ;;
1542         add,--*|append,--*)
1543                 __gitcomp '--file= --message= --reedit-message=
1544                                 --reuse-message='
1545                 ;;
1546         copy,--*)
1547                 __gitcomp '--stdin'
1548                 ;;
1549         prune,--*)
1550                 __gitcomp '--dry-run --verbose'
1551                 ;;
1552         prune,*)
1553                 ;;
1554         *)
1555                 case "$prev" in
1556                 -m|-F)
1557                         ;;
1558                 *)
1559                         __gitcomp_nl "$(__git_refs)"
1560                         ;;
1561                 esac
1562                 ;;
1563         esac
1564 }
1565
1566 _git_pull ()
1567 {
1568         __git_complete_strategy && return
1569
1570         case "$cur" in
1571         --*)
1572                 __gitcomp "
1573                         --rebase --no-rebase
1574                         $__git_merge_options
1575                         $__git_fetch_options
1576                 "
1577                 return
1578                 ;;
1579         esac
1580         __git_complete_remote_or_refspec
1581 }
1582
1583 _git_push ()
1584 {
1585         case "$prev" in
1586         --repo)
1587                 __gitcomp_nl "$(__git_remotes)"
1588                 return
1589         esac
1590         case "$cur" in
1591         --repo=*)
1592                 __gitcomp_nl "$(__git_remotes)" "" "${cur##--repo=}"
1593                 return
1594                 ;;
1595         --*)
1596                 __gitcomp "
1597                         --all --mirror --tags --dry-run --force --verbose
1598                         --receive-pack= --repo= --set-upstream
1599                 "
1600                 return
1601                 ;;
1602         esac
1603         __git_complete_remote_or_refspec
1604 }
1605
1606 _git_rebase ()
1607 {
1608         local dir="$(__gitdir)"
1609         if [ -d "$dir"/rebase-apply ] || [ -d "$dir"/rebase-merge ]; then
1610                 __gitcomp "--continue --skip --abort"
1611                 return
1612         fi
1613         __git_complete_strategy && return
1614         case "$cur" in
1615         --whitespace=*)
1616                 __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
1617                 return
1618                 ;;
1619         --*)
1620                 __gitcomp "
1621                         --onto --merge --strategy --interactive
1622                         --preserve-merges --stat --no-stat
1623                         --committer-date-is-author-date --ignore-date
1624                         --ignore-whitespace --whitespace=
1625                         --autosquash
1626                         "
1627
1628                 return
1629         esac
1630         __gitcomp_nl "$(__git_refs)"
1631 }
1632
1633 _git_reflog ()
1634 {
1635         local subcommands="show delete expire"
1636         local subcommand="$(__git_find_on_cmdline "$subcommands")"
1637
1638         if [ -z "$subcommand" ]; then
1639                 __gitcomp "$subcommands"
1640         else
1641                 __gitcomp_nl "$(__git_refs)"
1642         fi
1643 }
1644
1645 __git_send_email_confirm_options="always never auto cc compose"
1646 __git_send_email_suppresscc_options="author self cc bodycc sob cccmd body all"
1647
1648 _git_send_email ()
1649 {
1650         case "$cur" in
1651         --confirm=*)
1652                 __gitcomp "
1653                         $__git_send_email_confirm_options
1654                         " "" "${cur##--confirm=}"
1655                 return
1656                 ;;
1657         --suppress-cc=*)
1658                 __gitcomp "
1659                         $__git_send_email_suppresscc_options
1660                         " "" "${cur##--suppress-cc=}"
1661
1662                 return
1663                 ;;
1664         --smtp-encryption=*)
1665                 __gitcomp "ssl tls" "" "${cur##--smtp-encryption=}"
1666                 return
1667                 ;;
1668         --thread=*)
1669                 __gitcomp "
1670                         deep shallow
1671                         " "" "${cur##--thread=}"
1672                 return
1673                 ;;
1674         --*)
1675                 __gitcomp "--annotate --bcc --cc --cc-cmd --chain-reply-to
1676                         --compose --confirm= --dry-run --envelope-sender
1677                         --from --identity
1678                         --in-reply-to --no-chain-reply-to --no-signed-off-by-cc
1679                         --no-suppress-from --no-thread --quiet
1680                         --signed-off-by-cc --smtp-pass --smtp-server
1681                         --smtp-server-port --smtp-encryption= --smtp-user
1682                         --subject --suppress-cc= --suppress-from --thread --to
1683                         --validate --no-validate
1684                         $__git_format_patch_options"
1685                 return
1686                 ;;
1687         esac
1688         __git_complete_revlist
1689 }
1690
1691 _git_stage ()
1692 {
1693         _git_add
1694 }
1695
1696 __git_config_get_set_variables ()
1697 {
1698         local prevword word config_file= c=$cword
1699         while [ $c -gt 1 ]; do
1700                 word="${words[c]}"
1701                 case "$word" in
1702                 --system|--global|--local|--file=*)
1703                         config_file="$word"
1704                         break
1705                         ;;
1706                 -f|--file)
1707                         config_file="$word $prevword"
1708                         break
1709                         ;;
1710                 esac
1711                 prevword=$word
1712                 c=$((--c))
1713         done
1714
1715         git --git-dir="$(__gitdir)" config $config_file --list 2>/dev/null |
1716         while read -r line
1717         do
1718                 case "$line" in
1719                 *.*=*)
1720                         echo "${line/=*/}"
1721                         ;;
1722                 esac
1723         done
1724 }
1725
1726 _git_config ()
1727 {
1728         case "$prev" in
1729         branch.*.remote|branch.*.pushremote)
1730                 __gitcomp_nl "$(__git_remotes)"
1731                 return
1732                 ;;
1733         branch.*.merge)
1734                 __gitcomp_nl "$(__git_refs)"
1735                 return
1736                 ;;
1737         branch.*.rebase)
1738                 __gitcomp "false true"
1739                 return
1740                 ;;
1741         remote.pushdefault)
1742                 __gitcomp_nl "$(__git_remotes)"
1743                 return
1744                 ;;
1745         remote.*.fetch)
1746                 local remote="${prev#remote.}"
1747                 remote="${remote%.fetch}"
1748                 if [ -z "$cur" ]; then
1749                         __gitcomp_nl "refs/heads/" "" "" ""
1750                         return
1751                 fi
1752                 __gitcomp_nl "$(__git_refs_remotes "$remote")"
1753                 return
1754                 ;;
1755         remote.*.push)
1756                 local remote="${prev#remote.}"
1757                 remote="${remote%.push}"
1758                 __gitcomp_nl "$(git --git-dir="$(__gitdir)" \
1759                         for-each-ref --format='%(refname):%(refname)' \
1760                         refs/heads)"
1761                 return
1762                 ;;
1763         pull.twohead|pull.octopus)
1764                 __git_compute_merge_strategies
1765                 __gitcomp "$__git_merge_strategies"
1766                 return
1767                 ;;
1768         color.branch|color.diff|color.interactive|\
1769         color.showbranch|color.status|color.ui)
1770                 __gitcomp "always never auto"
1771                 return
1772                 ;;
1773         color.pager)
1774                 __gitcomp "false true"
1775                 return
1776                 ;;
1777         color.*.*)
1778                 __gitcomp "
1779                         normal black red green yellow blue magenta cyan white
1780                         bold dim ul blink reverse
1781                         "
1782                 return
1783                 ;;
1784         diff.submodule)
1785                 __gitcomp "log short"
1786                 return
1787                 ;;
1788         help.format)
1789                 __gitcomp "man info web html"
1790                 return
1791                 ;;
1792         log.date)
1793                 __gitcomp "$__git_log_date_formats"
1794                 return
1795                 ;;
1796         sendemail.aliasesfiletype)
1797                 __gitcomp "mutt mailrc pine elm gnus"
1798                 return
1799                 ;;
1800         sendemail.confirm)
1801                 __gitcomp "$__git_send_email_confirm_options"
1802                 return
1803                 ;;
1804         sendemail.suppresscc)
1805                 __gitcomp "$__git_send_email_suppresscc_options"
1806                 return
1807                 ;;
1808         --get|--get-all|--unset|--unset-all)
1809                 __gitcomp_nl "$(__git_config_get_set_variables)"
1810                 return
1811                 ;;
1812         *.*)
1813                 return
1814                 ;;
1815         esac
1816         case "$cur" in
1817         --*)
1818                 __gitcomp "
1819                         --system --global --local --file=
1820                         --list --replace-all
1821                         --get --get-all --get-regexp
1822                         --add --unset --unset-all
1823                         --remove-section --rename-section
1824                         "
1825                 return
1826                 ;;
1827         branch.*.*)
1828                 local pfx="${cur%.*}." cur_="${cur##*.}"
1829                 __gitcomp "remote pushremote merge mergeoptions rebase" "$pfx" "$cur_"
1830                 return
1831                 ;;
1832         branch.*)
1833                 local pfx="${cur%.*}." cur_="${cur#*.}"
1834                 __gitcomp_nl "$(__git_heads)" "$pfx" "$cur_" "."
1835                 return
1836                 ;;
1837         guitool.*.*)
1838                 local pfx="${cur%.*}." cur_="${cur##*.}"
1839                 __gitcomp "
1840                         argprompt cmd confirm needsfile noconsole norescan
1841                         prompt revprompt revunmerged title
1842                         " "$pfx" "$cur_"
1843                 return
1844                 ;;
1845         difftool.*.*)
1846                 local pfx="${cur%.*}." cur_="${cur##*.}"
1847                 __gitcomp "cmd path" "$pfx" "$cur_"
1848                 return
1849                 ;;
1850         man.*.*)
1851                 local pfx="${cur%.*}." cur_="${cur##*.}"
1852                 __gitcomp "cmd path" "$pfx" "$cur_"
1853                 return
1854                 ;;
1855         mergetool.*.*)
1856                 local pfx="${cur%.*}." cur_="${cur##*.}"
1857                 __gitcomp "cmd path trustExitCode" "$pfx" "$cur_"
1858                 return
1859                 ;;
1860         pager.*)
1861                 local pfx="${cur%.*}." cur_="${cur#*.}"
1862                 __git_compute_all_commands
1863                 __gitcomp_nl "$__git_all_commands" "$pfx" "$cur_"
1864                 return
1865                 ;;
1866         remote.*.*)
1867                 local pfx="${cur%.*}." cur_="${cur##*.}"
1868                 __gitcomp "
1869                         url proxy fetch push mirror skipDefaultUpdate
1870                         receivepack uploadpack tagopt pushurl
1871                         " "$pfx" "$cur_"
1872                 return
1873                 ;;
1874         remote.*)
1875                 local pfx="${cur%.*}." cur_="${cur#*.}"
1876                 __gitcomp_nl "$(__git_remotes)" "$pfx" "$cur_" "."
1877                 return
1878                 ;;
1879         url.*.*)
1880                 local pfx="${cur%.*}." cur_="${cur##*.}"
1881                 __gitcomp "insteadOf pushInsteadOf" "$pfx" "$cur_"
1882                 return
1883                 ;;
1884         esac
1885         __gitcomp "
1886                 add.ignoreErrors
1887                 advice.commitBeforeMerge
1888                 advice.detachedHead
1889                 advice.implicitIdentity
1890                 advice.pushNonFastForward
1891                 advice.resolveConflict
1892                 advice.statusHints
1893                 alias.
1894                 am.keepcr
1895                 apply.ignorewhitespace
1896                 apply.whitespace
1897                 branch.autosetupmerge
1898                 branch.autosetuprebase
1899                 browser.
1900                 clean.requireForce
1901                 color.branch
1902                 color.branch.current
1903                 color.branch.local
1904                 color.branch.plain
1905                 color.branch.remote
1906                 color.decorate.HEAD
1907                 color.decorate.branch
1908                 color.decorate.remoteBranch
1909                 color.decorate.stash
1910                 color.decorate.tag
1911                 color.diff
1912                 color.diff.commit
1913                 color.diff.frag
1914                 color.diff.func
1915                 color.diff.meta
1916                 color.diff.new
1917                 color.diff.old
1918                 color.diff.plain
1919                 color.diff.whitespace
1920                 color.grep
1921                 color.grep.context
1922                 color.grep.filename
1923                 color.grep.function
1924                 color.grep.linenumber
1925                 color.grep.match
1926                 color.grep.selected
1927                 color.grep.separator
1928                 color.interactive
1929                 color.interactive.error
1930                 color.interactive.header
1931                 color.interactive.help
1932                 color.interactive.prompt
1933                 color.pager
1934                 color.showbranch
1935                 color.status
1936                 color.status.added
1937                 color.status.changed
1938                 color.status.header
1939                 color.status.nobranch
1940                 color.status.untracked
1941                 color.status.updated
1942                 color.ui
1943                 commit.status
1944                 commit.template
1945                 core.abbrev
1946                 core.askpass
1947                 core.attributesfile
1948                 core.autocrlf
1949                 core.bare
1950                 core.bigFileThreshold
1951                 core.compression
1952                 core.createObject
1953                 core.deltaBaseCacheLimit
1954                 core.editor
1955                 core.eol
1956                 core.excludesfile
1957                 core.fileMode
1958                 core.fsyncobjectfiles
1959                 core.gitProxy
1960                 core.ignoreCygwinFSTricks
1961                 core.ignoreStat
1962                 core.ignorecase
1963                 core.logAllRefUpdates
1964                 core.loosecompression
1965                 core.notesRef
1966                 core.packedGitLimit
1967                 core.packedGitWindowSize
1968                 core.pager
1969                 core.preferSymlinkRefs
1970                 core.preloadindex
1971                 core.quotepath
1972                 core.repositoryFormatVersion
1973                 core.safecrlf
1974                 core.sharedRepository
1975                 core.sparseCheckout
1976                 core.symlinks
1977                 core.trustctime
1978                 core.warnAmbiguousRefs
1979                 core.whitespace
1980                 core.worktree
1981                 diff.autorefreshindex
1982                 diff.external
1983                 diff.ignoreSubmodules
1984                 diff.mnemonicprefix
1985                 diff.noprefix
1986                 diff.renameLimit
1987                 diff.renames
1988                 diff.statGraphWidth
1989                 diff.submodule
1990                 diff.suppressBlankEmpty
1991                 diff.tool
1992                 diff.wordRegex
1993                 diff.algorithm
1994                 difftool.
1995                 difftool.prompt
1996                 fetch.recurseSubmodules
1997                 fetch.unpackLimit
1998                 format.attach
1999                 format.cc
2000                 format.headers
2001                 format.numbered
2002                 format.pretty
2003                 format.signature
2004                 format.signoff
2005                 format.subjectprefix
2006                 format.suffix
2007                 format.thread
2008                 format.to
2009                 gc.
2010                 gc.aggressiveWindow
2011                 gc.auto
2012                 gc.autopacklimit
2013                 gc.packrefs
2014                 gc.pruneexpire
2015                 gc.reflogexpire
2016                 gc.reflogexpireunreachable
2017                 gc.rerereresolved
2018                 gc.rerereunresolved
2019                 gitcvs.allbinary
2020                 gitcvs.commitmsgannotation
2021                 gitcvs.dbTableNamePrefix
2022                 gitcvs.dbdriver
2023                 gitcvs.dbname
2024                 gitcvs.dbpass
2025                 gitcvs.dbuser
2026                 gitcvs.enabled
2027                 gitcvs.logfile
2028                 gitcvs.usecrlfattr
2029                 guitool.
2030                 gui.blamehistoryctx
2031                 gui.commitmsgwidth
2032                 gui.copyblamethreshold
2033                 gui.diffcontext
2034                 gui.encoding
2035                 gui.fastcopyblame
2036                 gui.matchtrackingbranch
2037                 gui.newbranchtemplate
2038                 gui.pruneduringfetch
2039                 gui.spellingdictionary
2040                 gui.trustmtime
2041                 help.autocorrect
2042                 help.browser
2043                 help.format
2044                 http.lowSpeedLimit
2045                 http.lowSpeedTime
2046                 http.maxRequests
2047                 http.minSessions
2048                 http.noEPSV
2049                 http.postBuffer
2050                 http.proxy
2051                 http.sslCAInfo
2052                 http.sslCAPath
2053                 http.sslCert
2054                 http.sslCertPasswordProtected
2055                 http.sslKey
2056                 http.sslVerify
2057                 http.useragent
2058                 i18n.commitEncoding
2059                 i18n.logOutputEncoding
2060                 imap.authMethod
2061                 imap.folder
2062                 imap.host
2063                 imap.pass
2064                 imap.port
2065                 imap.preformattedHTML
2066                 imap.sslverify
2067                 imap.tunnel
2068                 imap.user
2069                 init.templatedir
2070                 instaweb.browser
2071                 instaweb.httpd
2072                 instaweb.local
2073                 instaweb.modulepath
2074                 instaweb.port
2075                 interactive.singlekey
2076                 log.date
2077                 log.decorate
2078                 log.showroot
2079                 mailmap.file
2080                 man.
2081                 man.viewer
2082                 merge.
2083                 merge.conflictstyle
2084                 merge.log
2085                 merge.renameLimit
2086                 merge.renormalize
2087                 merge.stat
2088                 merge.tool
2089                 merge.verbosity
2090                 mergetool.
2091                 mergetool.keepBackup
2092                 mergetool.keepTemporaries
2093                 mergetool.prompt
2094                 notes.displayRef
2095                 notes.rewrite.
2096                 notes.rewrite.amend
2097                 notes.rewrite.rebase
2098                 notes.rewriteMode
2099                 notes.rewriteRef
2100                 pack.compression
2101                 pack.deltaCacheLimit
2102                 pack.deltaCacheSize
2103                 pack.depth
2104                 pack.indexVersion
2105                 pack.packSizeLimit
2106                 pack.threads
2107                 pack.window
2108                 pack.windowMemory
2109                 pager.
2110                 pretty.
2111                 pull.octopus
2112                 pull.twohead
2113                 push.default
2114                 rebase.autosquash
2115                 rebase.stat
2116                 receive.autogc
2117                 receive.denyCurrentBranch
2118                 receive.denyDeleteCurrent
2119                 receive.denyDeletes
2120                 receive.denyNonFastForwards
2121                 receive.fsckObjects
2122                 receive.unpackLimit
2123                 receive.updateserverinfo
2124                 remote.pushdefault
2125                 remotes.
2126                 repack.usedeltabaseoffset
2127                 rerere.autoupdate
2128                 rerere.enabled
2129                 sendemail.
2130                 sendemail.aliasesfile
2131                 sendemail.aliasfiletype
2132                 sendemail.bcc
2133                 sendemail.cc
2134                 sendemail.cccmd
2135                 sendemail.chainreplyto
2136                 sendemail.confirm
2137                 sendemail.envelopesender
2138                 sendemail.from
2139                 sendemail.identity
2140                 sendemail.multiedit
2141                 sendemail.signedoffbycc
2142                 sendemail.smtpdomain
2143                 sendemail.smtpencryption
2144                 sendemail.smtppass
2145                 sendemail.smtpserver
2146                 sendemail.smtpserveroption
2147                 sendemail.smtpserverport
2148                 sendemail.smtpuser
2149                 sendemail.suppresscc
2150                 sendemail.suppressfrom
2151                 sendemail.thread
2152                 sendemail.to
2153                 sendemail.validate
2154                 showbranch.default
2155                 status.relativePaths
2156                 status.showUntrackedFiles
2157                 status.submodulesummary
2158                 submodule.
2159                 tar.umask
2160                 transfer.unpackLimit
2161                 url.
2162                 user.email
2163                 user.name
2164                 user.signingkey
2165                 web.browser
2166                 branch. remote.
2167         "
2168 }
2169
2170 _git_remote ()
2171 {
2172         local subcommands="add rename remove set-head set-branches set-url show prune update"
2173         local subcommand="$(__git_find_on_cmdline "$subcommands")"
2174         if [ -z "$subcommand" ]; then
2175                 __gitcomp "$subcommands"
2176                 return
2177         fi
2178
2179         case "$subcommand" in
2180         rename|remove|set-url|show|prune)
2181                 __gitcomp_nl "$(__git_remotes)"
2182                 ;;
2183         set-head|set-branches)
2184                 __git_complete_remote_or_refspec
2185                 ;;
2186         update)
2187                 local i c='' IFS=$'\n'
2188                 for i in $(git --git-dir="$(__gitdir)" config --get-regexp "remotes\..*" 2>/dev/null); do
2189                         i="${i#remotes.}"
2190                         c="$c ${i/ */}"
2191                 done
2192                 __gitcomp "$c"
2193                 ;;
2194         *)
2195                 ;;
2196         esac
2197 }
2198
2199 _git_replace ()
2200 {
2201         __gitcomp_nl "$(__git_refs)"
2202 }
2203
2204 _git_reset ()
2205 {
2206         __git_has_doubledash && return
2207
2208         case "$cur" in
2209         --*)
2210                 __gitcomp "--merge --mixed --hard --soft --patch"
2211                 return
2212                 ;;
2213         esac
2214         __gitcomp_nl "$(__git_refs)"
2215 }
2216
2217 _git_revert ()
2218 {
2219         case "$cur" in
2220         --*)
2221                 __gitcomp "--edit --mainline --no-edit --no-commit --signoff"
2222                 return
2223                 ;;
2224         esac
2225         __gitcomp_nl "$(__git_refs)"
2226 }
2227
2228 _git_rm ()
2229 {
2230         case "$cur" in
2231         --*)
2232                 __gitcomp "--cached --dry-run --ignore-unmatch --quiet"
2233                 return
2234                 ;;
2235         esac
2236
2237         __git_complete_index_file "--cached"
2238 }
2239
2240 _git_shortlog ()
2241 {
2242         __git_has_doubledash && return
2243
2244         case "$cur" in
2245         --*)
2246                 __gitcomp "
2247                         $__git_log_common_options
2248                         $__git_log_shortlog_options
2249                         --numbered --summary
2250                         "
2251                 return
2252                 ;;
2253         esac
2254         __git_complete_revlist
2255 }
2256
2257 _git_show ()
2258 {
2259         __git_has_doubledash && return
2260
2261         case "$cur" in
2262         --pretty=*|--format=*)
2263                 __gitcomp "$__git_log_pretty_formats $(__git_pretty_aliases)
2264                         " "" "${cur#*=}"
2265                 return
2266                 ;;
2267         --diff-algorithm=*)
2268                 __gitcomp "$__git_diff_algorithms" "" "${cur##--diff-algorithm=}"
2269                 return
2270                 ;;
2271         --*)
2272                 __gitcomp "--pretty= --format= --abbrev-commit --oneline
2273                         $__git_diff_common_options
2274                         "
2275                 return
2276                 ;;
2277         esac
2278         __git_complete_revlist_file
2279 }
2280
2281 _git_show_branch ()
2282 {
2283         case "$cur" in
2284         --*)
2285                 __gitcomp "
2286                         --all --remotes --topo-order --current --more=
2287                         --list --independent --merge-base --no-name
2288                         --color --no-color
2289                         --sha1-name --sparse --topics --reflog
2290                         "
2291                 return
2292                 ;;
2293         esac
2294         __git_complete_revlist
2295 }
2296
2297 _git_stash ()
2298 {
2299         local save_opts='--keep-index --no-keep-index --quiet --patch'
2300         local subcommands='save list show apply clear drop pop create branch'
2301         local subcommand="$(__git_find_on_cmdline "$subcommands")"
2302         if [ -z "$subcommand" ]; then
2303                 case "$cur" in
2304                 --*)
2305                         __gitcomp "$save_opts"
2306                         ;;
2307                 *)
2308                         if [ -z "$(__git_find_on_cmdline "$save_opts")" ]; then
2309                                 __gitcomp "$subcommands"
2310                         fi
2311                         ;;
2312                 esac
2313         else
2314                 case "$subcommand,$cur" in
2315                 save,--*)
2316                         __gitcomp "$save_opts"
2317                         ;;
2318                 apply,--*|pop,--*)
2319                         __gitcomp "--index --quiet"
2320                         ;;
2321                 show,--*|drop,--*|branch,--*)
2322                         ;;
2323                 show,*|apply,*|drop,*|pop,*|branch,*)
2324                         __gitcomp_nl "$(git --git-dir="$(__gitdir)" stash list \
2325                                         | sed -n -e 's/:.*//p')"
2326                         ;;
2327                 *)
2328                         ;;
2329                 esac
2330         fi
2331 }
2332
2333 _git_submodule ()
2334 {
2335         __git_has_doubledash && return
2336
2337         local subcommands="add status init deinit update summary foreach sync"
2338         if [ -z "$(__git_find_on_cmdline "$subcommands")" ]; then
2339                 case "$cur" in
2340                 --*)
2341                         __gitcomp "--quiet --cached"
2342                         ;;
2343                 *)
2344                         __gitcomp "$subcommands"
2345                         ;;
2346                 esac
2347                 return
2348         fi
2349 }
2350
2351 _git_svn ()
2352 {
2353         local subcommands="
2354                 init fetch clone rebase dcommit log find-rev
2355                 set-tree commit-diff info create-ignore propget
2356                 proplist show-ignore show-externals branch tag blame
2357                 migrate mkdirs reset gc
2358                 "
2359         local subcommand="$(__git_find_on_cmdline "$subcommands")"
2360         if [ -z "$subcommand" ]; then
2361                 __gitcomp "$subcommands"
2362         else
2363                 local remote_opts="--username= --config-dir= --no-auth-cache"
2364                 local fc_opts="
2365                         --follow-parent --authors-file= --repack=
2366                         --no-metadata --use-svm-props --use-svnsync-props
2367                         --log-window-size= --no-checkout --quiet
2368                         --repack-flags --use-log-author --localtime
2369                         --ignore-paths= --include-paths= $remote_opts
2370                         "
2371                 local init_opts="
2372                         --template= --shared= --trunk= --tags=
2373                         --branches= --stdlayout --minimize-url
2374                         --no-metadata --use-svm-props --use-svnsync-props
2375                         --rewrite-root= --prefix= --use-log-author
2376                         --add-author-from $remote_opts
2377                         "
2378                 local cmt_opts="
2379                         --edit --rmdir --find-copies-harder --copy-similarity=
2380                         "
2381
2382                 case "$subcommand,$cur" in
2383                 fetch,--*)
2384                         __gitcomp "--revision= --fetch-all $fc_opts"
2385                         ;;
2386                 clone,--*)
2387                         __gitcomp "--revision= $fc_opts $init_opts"
2388                         ;;
2389                 init,--*)
2390                         __gitcomp "$init_opts"
2391                         ;;
2392                 dcommit,--*)
2393                         __gitcomp "
2394                                 --merge --strategy= --verbose --dry-run
2395                                 --fetch-all --no-rebase --commit-url
2396                                 --revision --interactive $cmt_opts $fc_opts
2397                                 "
2398                         ;;
2399                 set-tree,--*)
2400                         __gitcomp "--stdin $cmt_opts $fc_opts"
2401                         ;;
2402                 create-ignore,--*|propget,--*|proplist,--*|show-ignore,--*|\
2403                 show-externals,--*|mkdirs,--*)
2404                         __gitcomp "--revision="
2405                         ;;
2406                 log,--*)
2407                         __gitcomp "
2408                                 --limit= --revision= --verbose --incremental
2409                                 --oneline --show-commit --non-recursive
2410                                 --authors-file= --color
2411                                 "
2412                         ;;
2413                 rebase,--*)
2414                         __gitcomp "
2415                                 --merge --verbose --strategy= --local
2416                                 --fetch-all --dry-run $fc_opts
2417                                 "
2418                         ;;
2419                 commit-diff,--*)
2420                         __gitcomp "--message= --file= --revision= $cmt_opts"
2421                         ;;
2422                 info,--*)
2423                         __gitcomp "--url"
2424                         ;;
2425                 branch,--*)
2426                         __gitcomp "--dry-run --message --tag"
2427                         ;;
2428                 tag,--*)
2429                         __gitcomp "--dry-run --message"
2430                         ;;
2431                 blame,--*)
2432                         __gitcomp "--git-format"
2433                         ;;
2434                 migrate,--*)
2435                         __gitcomp "
2436                                 --config-dir= --ignore-paths= --minimize
2437                                 --no-auth-cache --username=
2438                                 "
2439                         ;;
2440                 reset,--*)
2441                         __gitcomp "--revision= --parent"
2442                         ;;
2443                 *)
2444                         ;;
2445                 esac
2446         fi
2447 }
2448
2449 _git_tag ()
2450 {
2451         local i c=1 f=0
2452         while [ $c -lt $cword ]; do
2453                 i="${words[c]}"
2454                 case "$i" in
2455                 -d|-v)
2456                         __gitcomp_nl "$(__git_tags)"
2457                         return
2458                         ;;
2459                 -f)
2460                         f=1
2461                         ;;
2462                 esac
2463                 ((c++))
2464         done
2465
2466         case "$prev" in
2467         -m|-F)
2468                 ;;
2469         -*|tag)
2470                 if [ $f = 1 ]; then
2471                         __gitcomp_nl "$(__git_tags)"
2472                 fi
2473                 ;;
2474         *)
2475                 __gitcomp_nl "$(__git_refs)"
2476                 ;;
2477         esac
2478 }
2479
2480 _git_whatchanged ()
2481 {
2482         _git_log
2483 }
2484
2485 __git_main ()
2486 {
2487         local i c=1 command __git_dir
2488
2489         while [ $c -lt $cword ]; do
2490                 i="${words[c]}"
2491                 case "$i" in
2492                 --git-dir=*) __git_dir="${i#--git-dir=}" ;;
2493                 --bare)      __git_dir="." ;;
2494                 --help) command="help"; break ;;
2495                 -c) c=$((++c)) ;;
2496                 -*) ;;
2497                 *) command="$i"; break ;;
2498                 esac
2499                 ((c++))
2500         done
2501
2502         if [ -z "$command" ]; then
2503                 case "$cur" in
2504                 --*)   __gitcomp "
2505                         --paginate
2506                         --no-pager
2507                         --git-dir=
2508                         --bare
2509                         --version
2510                         --exec-path
2511                         --exec-path=
2512                         --html-path
2513                         --info-path
2514                         --work-tree=
2515                         --namespace=
2516                         --no-replace-objects
2517                         --help
2518                         "
2519                         ;;
2520                 *)     __git_compute_porcelain_commands
2521                        __gitcomp "$__git_porcelain_commands $(__git_aliases)" ;;
2522                 esac
2523                 return
2524         fi
2525
2526         local completion_func="_git_${command//-/_}"
2527         declare -f $completion_func >/dev/null && $completion_func && return
2528
2529         local expansion=$(__git_aliased_command "$command")
2530         if [ -n "$expansion" ]; then
2531                 completion_func="_git_${expansion//-/_}"
2532                 declare -f $completion_func >/dev/null && $completion_func
2533         fi
2534 }
2535
2536 __gitk_main ()
2537 {
2538         __git_has_doubledash && return
2539
2540         local g="$(__gitdir)"
2541         local merge=""
2542         if [ -f "$g/MERGE_HEAD" ]; then
2543                 merge="--merge"
2544         fi
2545         case "$cur" in
2546         --*)
2547                 __gitcomp "
2548                         $__git_log_common_options
2549                         $__git_log_gitk_options
2550                         $merge
2551                         "
2552                 return
2553                 ;;
2554         esac
2555         __git_complete_revlist
2556 }
2557
2558 if [[ -n ${ZSH_VERSION-} ]]; then
2559         echo "WARNING: this script is deprecated, please see git-completion.zsh" 1>&2
2560
2561         autoload -U +X compinit && compinit
2562
2563         __gitcomp ()
2564         {
2565                 emulate -L zsh
2566
2567                 local cur_="${3-$cur}"
2568
2569                 case "$cur_" in
2570                 --*=)
2571                         ;;
2572                 *)
2573                         local c IFS=$' \t\n'
2574                         local -a array
2575                         for c in ${=1}; do
2576                                 c="$c${4-}"
2577                                 case $c in
2578                                 --*=*|*.) ;;
2579                                 *) c="$c " ;;
2580                                 esac
2581                                 array+=("$c")
2582                         done
2583                         compset -P '*[=:]'
2584                         compadd -Q -S '' -p "${2-}" -a -- array && _ret=0
2585                         ;;
2586                 esac
2587         }
2588
2589         __gitcomp_nl ()
2590         {
2591                 emulate -L zsh
2592
2593                 local IFS=$'\n'
2594                 compset -P '*[=:]'
2595                 compadd -Q -S "${4- }" -p "${2-}" -- ${=1} && _ret=0
2596         }
2597
2598         __gitcomp_file ()
2599         {
2600                 emulate -L zsh
2601
2602                 local IFS=$'\n'
2603                 compset -P '*[=:]'
2604                 compadd -Q -p "${2-}" -f -- ${=1} && _ret=0
2605         }
2606
2607         _git ()
2608         {
2609                 local _ret=1 cur cword prev
2610                 cur=${words[CURRENT]}
2611                 prev=${words[CURRENT-1]}
2612                 let cword=CURRENT-1
2613                 emulate ksh -c __${service}_main
2614                 let _ret && _default && _ret=0
2615                 return _ret
2616         }
2617
2618         compdef _git git gitk
2619         return
2620 fi
2621
2622 __git_func_wrap ()
2623 {
2624         local cur words cword prev
2625         _get_comp_words_by_ref -n =: cur words cword prev
2626         $1
2627 }
2628
2629 # Setup completion for certain functions defined above by setting common
2630 # variables and workarounds.
2631 # This is NOT a public function; use at your own risk.
2632 __git_complete ()
2633 {
2634         local wrapper="__git_wrap${2}"
2635         eval "$wrapper () { __git_func_wrap $2 ; }"
2636         complete -o bashdefault -o default -o nospace -F $wrapper $1 2>/dev/null \
2637                 || complete -o default -o nospace -F $wrapper $1
2638 }
2639
2640 # wrapper for backwards compatibility
2641 _git ()
2642 {
2643         __git_wrap__git_main
2644 }
2645
2646 # wrapper for backwards compatibility
2647 _gitk ()
2648 {
2649         __git_wrap__gitk_main
2650 }
2651
2652 __git_complete git __git_main
2653 __git_complete gitk __gitk_main
2654
2655 # The following are necessary only for Cygwin, and only are needed
2656 # when the user has tab-completed the executable name and consequently
2657 # included the '.exe' suffix.
2658 #
2659 if [ Cygwin = "$(uname -o 2>/dev/null)" ]; then
2660 __git_complete git.exe __git_main
2661 fi