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