contrib/completion/git-completion.bash

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