contrib/completion/git-completion.bash

   1 #!bash
   2 #
   3 # bash 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 #    *) common --long-options
  17 #
  18 # To use these routines:
  19 #
  20 #    1) Copy this file to somewhere (e.g. ~/.git-completion.sh).
  21 #    2) Added the following line to your .bashrc:
  22 #        source ~/.git-completion.sh
  23 #
  24 #    3) You may want to make sure the git executable is available
  25 #       in your PATH before this script is sourced, as some caching
  26 #       is performed while the script loads.  If git isn't found
  27 #       at source time then all lookups will be done on demand,
  28 #       which may be slightly slower.
  29 #
  30 #    4) Consider changing your PS1 to also show the current branch:
  31 #        PS1='[\u@\h \W$(__git_ps1 " (%s)")]\$ '
  32 #
  33 #       The argument to __git_ps1 will be displayed only if you
  34 #       are currently in a git repository.  The %s token will be
  35 #       the name of the current branch.
  36 #
  37 #       In addition, if you set GIT_PS1_SHOWDIRTYSTATE to a nonempty
  38 #       value, unstaged (*) and staged (+) changes will be shown next
  39 #       to the branch name.  You can configure this per-repository
  40 #       with the bash.showDirtyState variable, which defaults to true
  41 #       once GIT_PS1_SHOWDIRTYSTATE is enabled.
  42 #
  43 # To submit patches:
  44 #
  45 #    *) Read Documentation/SubmittingPatches
  46 #    *) Send all patches to the current maintainer:
  47 #
  48 #       "Shawn O. Pearce" <spearce@spearce.org>
  49 #
  50 #    *) Always CC the Git mailing list:
  51 #
  52 #       git@vger.kernel.org
  53 #
  54
  55 case "$COMP_WORDBREAKS" in
  56 *:*) : great ;;
  57 *)   COMP_WORDBREAKS="$COMP_WORDBREAKS:"
  58 esac
  59
  60 # __gitdir accepts 0 or 1 arguments (i.e., location)
  61 # returns location of .git repo
  62 __gitdir ()
  63 {
  64         if [ -z "${1-}" ]; then
  65                 if [ -n "${__git_dir-}" ]; then
  66                         echo "$__git_dir"
  67                 elif [ -d .git ]; then
  68                         echo .git
  69                 else
  70                         git rev-parse --git-dir 2>/dev/null
  71                 fi
  72         elif [ -d "$1/.git" ]; then
  73                 echo "$1/.git"
  74         else
  75                 echo "$1"
  76         fi
  77 }
  78
  79 # __git_ps1 accepts 0 or 1 arguments (i.e., format string)
  80 # returns text to add to bash PS1 prompt (includes branch name)
  81 __git_ps1 ()
  82 {
  83         local g="$(__gitdir)"
  84         if [ -n "$g" ]; then
  85                 local r
  86                 local b
  87                 if [ -d "$g/rebase-apply" ]; then
  88                         if [ -f "$g/rebase-apply/rebasing" ]; then
  89                                 r="|REBASE"
  90                 elif [ -f "$g/rebase-apply/applying" ]; then
  91                                 r="|AM"
  92                         else
  93                                 r="|AM/REBASE"
  94                         fi
  95                         b="$(git symbolic-ref HEAD 2>/dev/null)"
  96                 elif [ -f "$g/rebase-merge/interactive" ]; then
  97                         r="|REBASE-i"
  98                         b="$(cat "$g/rebase-merge/head-name")"
  99                 elif [ -d "$g/rebase-merge" ]; then
 100                         r="|REBASE-m"
 101                         b="$(cat "$g/rebase-merge/head-name")"
 102                 else
 103                         if [ -f "$g/MERGE_HEAD" ]; then
 104                                 r="|MERGING"
 105                         fi
 106                         if [ -f "$g/BISECT_LOG" ]; then
 107                                 r="|BISECTING"
 108                         fi
 109
 110                         b="$(git symbolic-ref HEAD 2>/dev/null)" || {
 111
 112                                 b="$(
 113                                 case "${GIT_PS1_DESCRIBE_STYLE-}" in
 114                                 (contains)
 115                                         git describe --contains HEAD ;;
 116                                 (branch)
 117                                         git describe --contains --all HEAD ;;
 118                                 (describe)
 119                                         git describe HEAD ;;
 120                                 (* | default)
 121                                         git describe --exact-match HEAD ;;
 122                                 esac 2>/dev/null)" ||
 123
 124                                 b="$(cut -c1-7 "$g/HEAD" 2>/dev/null)..." ||
 125                                 b="unknown"
 126                                 b="($b)"
 127                         }
 128                 fi
 129
 130                 local w
 131                 local i
 132                 local c
 133
 134                 if [ "true" = "$(git rev-parse --is-inside-git-dir 2>/dev/null)" ]; then
 135                         if [ "true" = "$(git rev-parse --is-bare-repository 2>/dev/null)" ]; then
 136                                 c="BARE:"
 137                         else
 138                                 b="GIT_DIR!"
 139                         fi
 140                 elif [ "true" = "$(git rev-parse --is-inside-work-tree 2>/dev/null)" ]; then
 141                         if [ -n "${GIT_PS1_SHOWDIRTYSTATE-}" ]; then
 142                                 if [ "$(git config --bool bash.showDirtyState)" != "false" ]; then
 143                                         git diff --no-ext-diff --ignore-submodules \
 144                                                 --quiet --exit-code || w="*"
 145                                         if git rev-parse --quiet --verify HEAD >/dev/null; then
 146                                                 git diff-index --cached --quiet \
 147                                                         --ignore-submodules HEAD -- || i="+"
 148                                         else
 149                                                 i="#"
 150                                         fi
 151                                 fi
 152                         fi
 153                 fi
 154
 155                 if [ -n "$b" ]; then
 156                         if [ -n "${1-}" ]; then
 157                                 printf "$1" "$c${b##refs/heads/}$w$i$r"
 158                         else
 159                                 printf " (%s)" "$c${b##refs/heads/}$w$i$r"
 160                         fi
 161                 fi
 162         fi
 163 }
 164
 165 # __gitcomp_1 requires 2 arguments
 166 __gitcomp_1 ()
 167 {
 168         local c IFS=' '$'\t'$'\n'
 169         for c in $1; do
 170                 case "$c$2" in
 171                 --*=*) printf %s$'\n' "$c$2" ;;
 172                 *.)    printf %s$'\n' "$c$2" ;;
 173                 *)     printf %s$'\n' "$c$2 " ;;
 174                 esac
 175         done
 176 }
 177
 178 # __gitcomp accepts 1, 2, 3, or 4 arguments
 179 # generates completion reply with compgen
 180 __gitcomp ()
 181 {
 182         local cur="${COMP_WORDS[COMP_CWORD]}"
 183         if [ $# -gt 2 ]; then
 184                 cur="$3"
 185         fi
 186         case "$cur" in
 187         --*=)
 188                 COMPREPLY=()
 189                 ;;
 190         *)
 191                 local IFS=$'\n'
 192                 COMPREPLY=($(compgen -P "${2-}" \
 193                         -W "$(__gitcomp_1 "${1-}" "${4-}")" \
 194                         -- "$cur"))
 195                 ;;
 196         esac
 197 }
 198
 199 # __git_heads accepts 0 or 1 arguments (to pass to __gitdir)
 200 __git_heads ()
 201 {
 202         local cmd i is_hash=y dir="$(__gitdir "${1-}")"
 203         if [ -d "$dir" ]; then
 204                 git --git-dir="$dir" for-each-ref --format='%(refname:short)' \
 205                         refs/heads
 206                 return
 207         fi
 208         for i in $(git ls-remote "${1-}" 2>/dev/null); do
 209                 case "$is_hash,$i" in
 210                 y,*) is_hash=n ;;
 211                 n,*^{}) is_hash=y ;;
 212                 n,refs/heads/*) is_hash=y; echo "${i#refs/heads/}" ;;
 213                 n,*) is_hash=y; echo "$i" ;;
 214                 esac
 215         done
 216 }
 217
 218 # __git_tags accepts 0 or 1 arguments (to pass to __gitdir)
 219 __git_tags ()
 220 {
 221         local cmd i is_hash=y dir="$(__gitdir "${1-}")"
 222         if [ -d "$dir" ]; then
 223                 git --git-dir="$dir" for-each-ref --format='%(refname:short)' \
 224                         refs/tags
 225                 return
 226         fi
 227         for i in $(git ls-remote "${1-}" 2>/dev/null); do
 228                 case "$is_hash,$i" in
 229                 y,*) is_hash=n ;;
 230                 n,*^{}) is_hash=y ;;
 231                 n,refs/tags/*) is_hash=y; echo "${i#refs/tags/}" ;;
 232                 n,*) is_hash=y; echo "$i" ;;
 233                 esac
 234         done
 235 }
 236
 237 # __git_refs accepts 0 or 1 arguments (to pass to __gitdir)
 238 __git_refs ()
 239 {
 240         local i is_hash=y dir="$(__gitdir "${1-}")"
 241         local cur="${COMP_WORDS[COMP_CWORD]}" format refs
 242         if [ -d "$dir" ]; then
 243                 case "$cur" in
 244                 refs|refs/*)
 245                         format="refname"
 246                         refs="${cur%/*}"
 247                         ;;
 248                 *)
 249                         if [ -e "$dir/HEAD" ]; then echo HEAD; fi
 250                         format="refname:short"
 251                         refs="refs/tags refs/heads refs/remotes"
 252                         ;;
 253                 esac
 254                 git --git-dir="$dir" for-each-ref --format="%($format)" \
 255                         $refs
 256                 return
 257         fi
 258         for i in $(git ls-remote "$dir" 2>/dev/null); do
 259                 case "$is_hash,$i" in
 260                 y,*) is_hash=n ;;
 261                 n,*^{}) is_hash=y ;;
 262                 n,refs/tags/*) is_hash=y; echo "${i#refs/tags/}" ;;
 263                 n,refs/heads/*) is_hash=y; echo "${i#refs/heads/}" ;;
 264                 n,refs/remotes/*) is_hash=y; echo "${i#refs/remotes/}" ;;
 265                 n,*) is_hash=y; echo "$i" ;;
 266                 esac
 267         done
 268 }
 269
 270 # __git_refs2 requires 1 argument (to pass to __git_refs)
 271 __git_refs2 ()
 272 {
 273         local i
 274         for i in $(__git_refs "$1"); do
 275                 echo "$i:$i"
 276         done
 277 }
 278
 279 # __git_refs_remotes requires 1 argument (to pass to ls-remote)
 280 __git_refs_remotes ()
 281 {
 282         local cmd i is_hash=y
 283         for i in $(git ls-remote "$1" 2>/dev/null); do
 284                 case "$is_hash,$i" in
 285                 n,refs/heads/*)
 286                         is_hash=y
 287                         echo "$i:refs/remotes/$1/${i#refs/heads/}"
 288                         ;;
 289                 y,*) is_hash=n ;;
 290                 n,*^{}) is_hash=y ;;
 291                 n,refs/tags/*) is_hash=y;;
 292                 n,*) is_hash=y; ;;
 293                 esac
 294         done
 295 }
 296
 297 __git_remotes ()
 298 {
 299         local i ngoff IFS=$'\n' d="$(__gitdir)"
 300         shopt -q nullglob || ngoff=1
 301         shopt -s nullglob
 302         for i in "$d/remotes"/*; do
 303                 echo ${i#$d/remotes/}
 304         done
 305         [ "$ngoff" ] && shopt -u nullglob
 306         for i in $(git --git-dir="$d" config --list); do
 307                 case "$i" in
 308                 remote.*.url=*)
 309                         i="${i#remote.}"
 310                         echo "${i/.url=*/}"
 311                         ;;
 312                 esac
 313         done
 314 }
 315
 316 __git_merge_strategies ()
 317 {
 318         if [ -n "${__git_merge_strategylist-}" ]; then
 319                 echo "$__git_merge_strategylist"
 320                 return
 321         fi
 322         git merge -s help 2>&1 |
 323         sed -n -e '/[Aa]vailable strategies are: /,/^$/{
 324                 s/\.$//
 325                 s/.*://
 326                 s/^[    ]*//
 327                 s/[     ]*$//
 328                 p
 329         }'
 330 }
 331 __git_merge_strategylist=
 332 __git_merge_strategylist=$(__git_merge_strategies 2>/dev/null)
 333
 334 __git_complete_file ()
 335 {
 336         local pfx ls ref cur="${COMP_WORDS[COMP_CWORD]}"
 337         case "$cur" in
 338         ?*:*)
 339                 ref="${cur%%:*}"
 340                 cur="${cur#*:}"
 341                 case "$cur" in
 342                 ?*/*)
 343                         pfx="${cur%/*}"
 344                         cur="${cur##*/}"
 345                         ls="$ref:$pfx"
 346                         pfx="$pfx/"
 347                         ;;
 348                 *)
 349                         ls="$ref"
 350                         ;;
 351             esac
 352
 353                 case "$COMP_WORDBREAKS" in
 354                 *:*) : great ;;
 355                 *)   pfx="$ref:$pfx" ;;
 356                 esac
 357
 358                 local IFS=$'\n'
 359                 COMPREPLY=($(compgen -P "$pfx" \
 360                         -W "$(git --git-dir="$(__gitdir)" ls-tree "$ls" \
 361                                 | sed '/^100... blob /{
 362                                            s,^.*        ,,
 363                                            s,$, ,
 364                                        }
 365                                        /^120000 blob /{
 366                                            s,^.*        ,,
 367                                            s,$, ,
 368                                        }
 369                                        /^040000 tree /{
 370                                            s,^.*        ,,
 371                                            s,$,/,
 372                                        }
 373                                        s/^.*    //')" \
 374                         -- "$cur"))
 375                 ;;
 376         *)
 377                 __gitcomp "$(__git_refs)"
 378                 ;;
 379         esac
 380 }
 381
 382 __git_complete_revlist ()
 383 {
 384         local pfx cur="${COMP_WORDS[COMP_CWORD]}"
 385         case "$cur" in
 386         *...*)
 387                 pfx="${cur%...*}..."
 388                 cur="${cur#*...}"
 389                 __gitcomp "$(__git_refs)" "$pfx" "$cur"
 390                 ;;
 391         *..*)
 392                 pfx="${cur%..*}.."
 393                 cur="${cur#*..}"
 394                 __gitcomp "$(__git_refs)" "$pfx" "$cur"
 395                 ;;
 396         *)
 397                 __gitcomp "$(__git_refs)"
 398                 ;;
 399         esac
 400 }
 401
 402 __git_complete_remote_or_refspec ()
 403 {
 404         local cmd="${COMP_WORDS[1]}"
 405         local cur="${COMP_WORDS[COMP_CWORD]}"
 406         local i c=2 remote="" pfx="" lhs=1 no_complete_refspec=0
 407         while [ $c -lt $COMP_CWORD ]; do
 408                 i="${COMP_WORDS[c]}"
 409                 case "$i" in
 410                 --all|--mirror) [ "$cmd" = "push" ] && no_complete_refspec=1 ;;
 411                 -*) ;;
 412                 *) remote="$i"; break ;;
 413                 esac
 414                 c=$((++c))
 415         done
 416         if [ -z "$remote" ]; then
 417                 __gitcomp "$(__git_remotes)"
 418                 return
 419         fi
 420         if [ $no_complete_refspec = 1 ]; then
 421                 COMPREPLY=()
 422                 return
 423         fi
 424         [ "$remote" = "." ] && remote=
 425         case "$cur" in
 426         *:*)
 427                 case "$COMP_WORDBREAKS" in
 428                 *:*) : great ;;
 429                 *)   pfx="${cur%%:*}:" ;;
 430                 esac
 431                 cur="${cur#*:}"
 432                 lhs=0
 433                 ;;
 434         +*)
 435                 pfx="+"
 436                 cur="${cur#+}"
 437                 ;;
 438         esac
 439         case "$cmd" in
 440         fetch)
 441                 if [ $lhs = 1 ]; then
 442                         __gitcomp "$(__git_refs2 "$remote")" "$pfx" "$cur"
 443                 else
 444                         __gitcomp "$(__git_refs)" "$pfx" "$cur"
 445                 fi
 446                 ;;
 447         pull)
 448                 if [ $lhs = 1 ]; then
 449                         __gitcomp "$(__git_refs "$remote")" "$pfx" "$cur"
 450                 else
 451                         __gitcomp "$(__git_refs)" "$pfx" "$cur"
 452                 fi
 453                 ;;
 454         push)
 455                 if [ $lhs = 1 ]; then
 456                         __gitcomp "$(__git_refs)" "$pfx" "$cur"
 457                 else
 458                         __gitcomp "$(__git_refs "$remote")" "$pfx" "$cur"
 459                 fi
 460                 ;;
 461         esac
 462 }
 463
 464 __git_complete_strategy ()
 465 {
 466         case "${COMP_WORDS[COMP_CWORD-1]}" in
 467         -s|--strategy)
 468                 __gitcomp "$(__git_merge_strategies)"
 469                 return 0
 470         esac
 471         local cur="${COMP_WORDS[COMP_CWORD]}"
 472         case "$cur" in
 473         --strategy=*)
 474                 __gitcomp "$(__git_merge_strategies)" "" "${cur##--strategy=}"
 475                 return 0
 476                 ;;
 477         esac
 478         return 1
 479 }
 480
 481 __git_all_commands ()
 482 {
 483         if [ -n "${__git_all_commandlist-}" ]; then
 484                 echo "$__git_all_commandlist"
 485                 return
 486         fi
 487         local i IFS=" "$'\n'
 488         for i in $(git help -a|egrep '^ ')
 489         do
 490                 case $i in
 491                 *--*)             : helper pattern;;
 492                 *) echo $i;;
 493                 esac
 494         done
 495 }
 496 __git_all_commandlist=
 497 __git_all_commandlist="$(__git_all_commands 2>/dev/null)"
 498
 499 __git_porcelain_commands ()
 500 {
 501         if [ -n "${__git_porcelain_commandlist-}" ]; then
 502                 echo "$__git_porcelain_commandlist"
 503                 return
 504         fi
 505         local i IFS=" "$'\n'
 506         for i in "help" $(__git_all_commands)
 507         do
 508                 case $i in
 509                 *--*)             : helper pattern;;
 510                 applymbox)        : ask gittus;;
 511                 applypatch)       : ask gittus;;
 512                 archimport)       : import;;
 513                 cat-file)         : plumbing;;
 514                 check-attr)       : plumbing;;
 515                 check-ref-format) : plumbing;;
 516                 checkout-index)   : plumbing;;
 517                 commit-tree)      : plumbing;;
 518                 count-objects)    : infrequent;;
 519                 cvsexportcommit)  : export;;
 520                 cvsimport)        : import;;
 521                 cvsserver)        : daemon;;
 522                 daemon)           : daemon;;
 523                 diff-files)       : plumbing;;
 524                 diff-index)       : plumbing;;
 525                 diff-tree)        : plumbing;;
 526                 fast-import)      : import;;
 527                 fast-export)      : export;;
 528                 fsck-objects)     : plumbing;;
 529                 fetch-pack)       : plumbing;;
 530                 fmt-merge-msg)    : plumbing;;
 531                 for-each-ref)     : plumbing;;
 532                 hash-object)      : plumbing;;
 533                 http-*)           : transport;;
 534                 index-pack)       : plumbing;;
 535                 init-db)          : deprecated;;
 536                 local-fetch)      : plumbing;;
 537                 lost-found)       : infrequent;;
 538                 ls-files)         : plumbing;;
 539                 ls-remote)        : plumbing;;
 540                 ls-tree)          : plumbing;;
 541                 mailinfo)         : plumbing;;
 542                 mailsplit)        : plumbing;;
 543                 merge-*)          : plumbing;;
 544                 mktree)           : plumbing;;
 545                 mktag)            : plumbing;;
 546                 pack-objects)     : plumbing;;
 547                 pack-redundant)   : plumbing;;
 548                 pack-refs)        : plumbing;;
 549                 parse-remote)     : plumbing;;
 550                 patch-id)         : plumbing;;
 551                 peek-remote)      : plumbing;;
 552                 prune)            : plumbing;;
 553                 prune-packed)     : plumbing;;
 554                 quiltimport)      : import;;
 555                 read-tree)        : plumbing;;
 556                 receive-pack)     : plumbing;;
 557                 reflog)           : plumbing;;
 558                 repo-config)      : deprecated;;
 559                 rerere)           : plumbing;;
 560                 rev-list)         : plumbing;;
 561                 rev-parse)        : plumbing;;
 562                 runstatus)        : plumbing;;
 563                 sh-setup)         : internal;;
 564                 shell)            : daemon;;
 565                 show-ref)         : plumbing;;
 566                 send-pack)        : plumbing;;
 567                 show-index)       : plumbing;;
 568                 ssh-*)            : transport;;
 569                 stripspace)       : plumbing;;
 570                 symbolic-ref)     : plumbing;;
 571                 tar-tree)         : deprecated;;
 572                 unpack-file)      : plumbing;;
 573                 unpack-objects)   : plumbing;;
 574                 update-index)     : plumbing;;
 575                 update-ref)       : plumbing;;
 576                 update-server-info) : daemon;;
 577                 upload-archive)   : plumbing;;
 578                 upload-pack)      : plumbing;;
 579                 write-tree)       : plumbing;;
 580                 var)              : infrequent;;
 581                 verify-pack)      : infrequent;;
 582                 verify-tag)       : plumbing;;
 583                 *) echo $i;;
 584                 esac
 585         done
 586 }
 587 __git_porcelain_commandlist=
 588 __git_porcelain_commandlist="$(__git_porcelain_commands 2>/dev/null)"
 589
 590 __git_aliases ()
 591 {
 592         local i IFS=$'\n'
 593         for i in $(git --git-dir="$(__gitdir)" config --list); do
 594                 case "$i" in
 595                 alias.*)
 596                         i="${i#alias.}"
 597                         echo "${i/=*/}"
 598                         ;;
 599                 esac
 600         done
 601 }
 602
 603 # __git_aliased_command requires 1 argument
 604 __git_aliased_command ()
 605 {
 606         local word cmdline=$(git --git-dir="$(__gitdir)" \
 607                 config --get "alias.$1")
 608         for word in $cmdline; do
 609                 if [ "${word##-*}" ]; then
 610                         echo $word
 611                         return
 612                 fi
 613         done
 614 }
 615
 616 # __git_find_subcommand requires 1 argument
 617 __git_find_subcommand ()
 618 {
 619         local word subcommand c=1
 620
 621         while [ $c -lt $COMP_CWORD ]; do
 622                 word="${COMP_WORDS[c]}"
 623                 for subcommand in $1; do
 624                         if [ "$subcommand" = "$word" ]; then
 625                                 echo "$subcommand"
 626                                 return
 627                         fi
 628                 done
 629                 c=$((++c))
 630         done
 631 }
 632
 633 __git_has_doubledash ()
 634 {
 635         local c=1
 636         while [ $c -lt $COMP_CWORD ]; do
 637                 if [ "--" = "${COMP_WORDS[c]}" ]; then
 638                         return 0
 639                 fi
 640                 c=$((++c))
 641         done
 642         return 1
 643 }
 644
 645 __git_whitespacelist="nowarn warn error error-all fix"
 646
 647 _git_am ()
 648 {
 649         local cur="${COMP_WORDS[COMP_CWORD]}" dir="$(__gitdir)"
 650         if [ -d "$dir"/rebase-apply ]; then
 651                 __gitcomp "--skip --resolved --abort"
 652                 return
 653         fi
 654         case "$cur" in
 655         --whitespace=*)
 656                 __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
 657                 return
 658                 ;;
 659         --*)
 660                 __gitcomp "
 661                         --3way --committer-date-is-author-date --ignore-date
 662                         --interactive --keep --no-utf8 --signoff --utf8
 663                         --whitespace=
 664                         "
 665                 return
 666         esac
 667         COMPREPLY=()
 668 }
 669
 670 _git_apply ()
 671 {
 672         local cur="${COMP_WORDS[COMP_CWORD]}"
 673         case "$cur" in
 674         --whitespace=*)
 675                 __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
 676                 return
 677                 ;;
 678         --*)
 679                 __gitcomp "
 680                         --stat --numstat --summary --check --index
 681                         --cached --index-info --reverse --reject --unidiff-zero
 682                         --apply --no-add --exclude=
 683                         --whitespace= --inaccurate-eof --verbose
 684                         "
 685                 return
 686         esac
 687         COMPREPLY=()
 688 }
 689
 690 _git_add ()
 691 {
 692         __git_has_doubledash && return
 693
 694         local cur="${COMP_WORDS[COMP_CWORD]}"
 695         case "$cur" in
 696         --*)
 697                 __gitcomp "
 698                         --interactive --refresh --patch --update --dry-run
 699                         --ignore-errors --intent-to-add
 700                         "
 701                 return
 702         esac
 703         COMPREPLY=()
 704 }
 705
 706 _git_archive ()
 707 {
 708         local cur="${COMP_WORDS[COMP_CWORD]}"
 709         case "$cur" in
 710         --format=*)
 711                 __gitcomp "$(git archive --list)" "" "${cur##--format=}"
 712                 return
 713                 ;;
 714         --remote=*)
 715                 __gitcomp "$(__git_remotes)" "" "${cur##--remote=}"
 716                 return
 717                 ;;
 718         --*)
 719                 __gitcomp "
 720                         --format= --list --verbose
 721                         --prefix= --remote= --exec=
 722                         "
 723                 return
 724                 ;;
 725         esac
 726         __git_complete_file
 727 }
 728
 729 _git_bisect ()
 730 {
 731         __git_has_doubledash && return
 732
 733         local subcommands="start bad good skip reset visualize replay log run"
 734         local subcommand="$(__git_find_subcommand "$subcommands")"
 735         if [ -z "$subcommand" ]; then
 736                 __gitcomp "$subcommands"
 737                 return
 738         fi
 739
 740         case "$subcommand" in
 741         bad|good|reset|skip)
 742                 __gitcomp "$(__git_refs)"
 743                 ;;
 744         *)
 745                 COMPREPLY=()
 746                 ;;
 747         esac
 748 }
 749
 750 _git_branch ()
 751 {
 752         local i c=1 only_local_ref="n" has_r="n"
 753
 754         while [ $c -lt $COMP_CWORD ]; do
 755                 i="${COMP_WORDS[c]}"
 756                 case "$i" in
 757                 -d|-m)  only_local_ref="y" ;;
 758                 -r)     has_r="y" ;;
 759                 esac
 760                 c=$((++c))
 761         done
 762
 763         case "${COMP_WORDS[COMP_CWORD]}" in
 764         --*)
 765                 __gitcomp "
 766                         --color --no-color --verbose --abbrev= --no-abbrev
 767                         --track --no-track --contains --merged --no-merged
 768                         "
 769                 ;;
 770         *)
 771                 if [ $only_local_ref = "y" -a $has_r = "n" ]; then
 772                         __gitcomp "$(__git_heads)"
 773                 else
 774                         __gitcomp "$(__git_refs)"
 775                 fi
 776                 ;;
 777         esac
 778 }
 779
 780 _git_bundle ()
 781 {
 782         local cmd="${COMP_WORDS[2]}"
 783         case "$COMP_CWORD" in
 784         2)
 785                 __gitcomp "create list-heads verify unbundle"
 786                 ;;
 787         3)
 788                 # looking for a file
 789                 ;;
 790         *)
 791                 case "$cmd" in
 792                         create)
 793                                 __git_complete_revlist
 794                         ;;
 795                 esac
 796                 ;;
 797         esac
 798 }
 799
 800 _git_checkout ()
 801 {
 802         __git_has_doubledash && return
 803
 804         __gitcomp "$(__git_refs)"
 805 }
 806
 807 _git_cherry ()
 808 {
 809         __gitcomp "$(__git_refs)"
 810 }
 811
 812 _git_cherry_pick ()
 813 {
 814         local cur="${COMP_WORDS[COMP_CWORD]}"
 815         case "$cur" in
 816         --*)
 817                 __gitcomp "--edit --no-commit"
 818                 ;;
 819         *)
 820                 __gitcomp "$(__git_refs)"
 821                 ;;
 822         esac
 823 }
 824
 825 _git_clean ()
 826 {
 827         __git_has_doubledash && return
 828
 829         local cur="${COMP_WORDS[COMP_CWORD]}"
 830         case "$cur" in
 831         --*)
 832                 __gitcomp "--dry-run --quiet"
 833                 return
 834                 ;;
 835         esac
 836         COMPREPLY=()
 837 }
 838
 839 _git_clone ()
 840 {
 841         local cur="${COMP_WORDS[COMP_CWORD]}"
 842         case "$cur" in
 843         --*)
 844                 __gitcomp "
 845                         --local
 846                         --no-hardlinks
 847                         --shared
 848                         --reference
 849                         --quiet
 850                         --no-checkout
 851                         --bare
 852                         --mirror
 853                         --origin
 854                         --upload-pack
 855                         --template=
 856                         --depth
 857                         "
 858                 return
 859                 ;;
 860         esac
 861         COMPREPLY=()
 862 }
 863
 864 _git_commit ()
 865 {
 866         __git_has_doubledash && return
 867
 868         local cur="${COMP_WORDS[COMP_CWORD]}"
 869         case "$cur" in
 870         --*)
 871                 __gitcomp "
 872                         --all --author= --signoff --verify --no-verify
 873                         --edit --amend --include --only --interactive
 874                         "
 875                 return
 876         esac
 877         COMPREPLY=()
 878 }
 879
 880 _git_describe ()
 881 {
 882         local cur="${COMP_WORDS[COMP_CWORD]}"
 883         case "$cur" in
 884         --*)
 885                 __gitcomp "
 886                         --all --tags --contains --abbrev= --candidates=
 887                         --exact-match --debug --long --match --always
 888                         "
 889                 return
 890         esac
 891         __gitcomp "$(__git_refs)"
 892 }
 893
 894 __git_diff_common_options="--stat --numstat --shortstat --summary
 895                         --patch-with-stat --name-only --name-status --color
 896                         --no-color --color-words --no-renames --check
 897                         --full-index --binary --abbrev --diff-filter=
 898                         --find-copies-harder
 899                         --text --ignore-space-at-eol --ignore-space-change
 900                         --ignore-all-space --exit-code --quiet --ext-diff
 901                         --no-ext-diff
 902                         --no-prefix --src-prefix= --dst-prefix=
 903                         --inter-hunk-context=
 904                         --patience
 905                         --raw
 906 "
 907
 908 _git_diff ()
 909 {
 910         __git_has_doubledash && return
 911
 912         local cur="${COMP_WORDS[COMP_CWORD]}"
 913         case "$cur" in
 914         --*)
 915                 __gitcomp "--cached --staged --pickaxe-all --pickaxe-regex
 916                         --base --ours --theirs
 917                         $__git_diff_common_options
 918                         "
 919                 return
 920                 ;;
 921         esac
 922         __git_complete_file
 923 }
 924
 925 __git_mergetools_common="diffuse ecmerge emerge kdiff3 meld opendiff
 926                         tkdiff vimdiff gvimdiff xxdiff
 927 "
 928
 929 _git_difftool ()
 930 {
 931         local cur="${COMP_WORDS[COMP_CWORD]}"
 932         case "$cur" in
 933         --tool=*)
 934                 __gitcomp "$__git_mergetools_common kompare" "" "${cur##--tool=}"
 935                 return
 936                 ;;
 937         --*)
 938                 __gitcomp "--tool="
 939                 return
 940                 ;;
 941         esac
 942         COMPREPLY=()
 943 }
 944
 945 __git_fetch_options="
 946         --quiet --verbose --append --upload-pack --force --keep --depth=
 947         --tags --no-tags
 948 "
 949
 950 _git_fetch ()
 951 {
 952         local cur="${COMP_WORDS[COMP_CWORD]}"
 953         case "$cur" in
 954         --*)
 955                 __gitcomp "$__git_fetch_options"
 956                 return
 957                 ;;
 958         esac
 959         __git_complete_remote_or_refspec
 960 }
 961
 962 _git_format_patch ()
 963 {
 964         local cur="${COMP_WORDS[COMP_CWORD]}"
 965         case "$cur" in
 966         --thread=*)
 967                 __gitcomp "
 968                         deep shallow
 969                         " "" "${cur##--thread=}"
 970                 return
 971                 ;;
 972         --*)
 973                 __gitcomp "
 974                         --stdout --attach --no-attach --thread --thread=
 975                         --output-directory
 976                         --numbered --start-number
 977                         --numbered-files
 978                         --keep-subject
 979                         --signoff
 980                         --in-reply-to= --cc=
 981                         --full-index --binary
 982                         --not --all
 983                         --cover-letter
 984                         --no-prefix --src-prefix= --dst-prefix=
 985                         --inline --suffix= --ignore-if-in-upstream
 986                         --subject-prefix=
 987                         "
 988                 return
 989                 ;;
 990         esac
 991         __git_complete_revlist
 992 }
 993
 994 _git_fsck ()
 995 {
 996         local cur="${COMP_WORDS[COMP_CWORD]}"
 997         case "$cur" in
 998         --*)
 999                 __gitcomp "
1000                         --tags --root --unreachable --cache --no-reflogs --full
1001                         --strict --verbose --lost-found
1002                         "
1003                 return
1004                 ;;
1005         esac
1006         COMPREPLY=()
1007 }
1008
1009 _git_gc ()
1010 {
1011         local cur="${COMP_WORDS[COMP_CWORD]}"
1012         case "$cur" in
1013         --*)
1014                 __gitcomp "--prune --aggressive"
1015                 return
1016                 ;;
1017         esac
1018         COMPREPLY=()
1019 }
1020
1021 _git_grep ()
1022 {
1023         __git_has_doubledash && return
1024
1025         local cur="${COMP_WORDS[COMP_CWORD]}"
1026         case "$cur" in
1027         --*)
1028                 __gitcomp "
1029                         --cached
1030                         --text --ignore-case --word-regexp --invert-match
1031                         --full-name
1032                         --extended-regexp --basic-regexp --fixed-strings
1033                         --files-with-matches --name-only
1034                         --files-without-match
1035                         --count
1036                         --and --or --not --all-match
1037                         "
1038                 return
1039                 ;;
1040         esac
1041         COMPREPLY=()
1042 }
1043
1044 _git_help ()
1045 {
1046         local cur="${COMP_WORDS[COMP_CWORD]}"
1047         case "$cur" in
1048         --*)
1049                 __gitcomp "--all --info --man --web"
1050                 return
1051                 ;;
1052         esac
1053         __gitcomp "$(__git_all_commands)
1054                 attributes cli core-tutorial cvs-migration
1055                 diffcore gitk glossary hooks ignore modules
1056                 repository-layout tutorial tutorial-2
1057                 workflows
1058                 "
1059 }
1060
1061 _git_init ()
1062 {
1063         local cur="${COMP_WORDS[COMP_CWORD]}"
1064         case "$cur" in
1065         --shared=*)
1066                 __gitcomp "
1067                         false true umask group all world everybody
1068                         " "" "${cur##--shared=}"
1069                 return
1070                 ;;
1071         --*)
1072                 __gitcomp "--quiet --bare --template= --shared --shared="
1073                 return
1074                 ;;
1075         esac
1076         COMPREPLY=()
1077 }
1078
1079 _git_ls_files ()
1080 {
1081         __git_has_doubledash && return
1082
1083         local cur="${COMP_WORDS[COMP_CWORD]}"
1084         case "$cur" in
1085         --*)
1086                 __gitcomp "--cached --deleted --modified --others --ignored
1087                         --stage --directory --no-empty-directory --unmerged
1088                         --killed --exclude= --exclude-from=
1089                         --exclude-per-directory= --exclude-standard
1090                         --error-unmatch --with-tree= --full-name
1091                         --abbrev --ignored --exclude-per-directory
1092                         "
1093                 return
1094                 ;;
1095         esac
1096         COMPREPLY=()
1097 }
1098
1099 _git_ls_remote ()
1100 {
1101         __gitcomp "$(__git_remotes)"
1102 }
1103
1104 _git_ls_tree ()
1105 {
1106         __git_complete_file
1107 }
1108
1109 # Options that go well for log, shortlog and gitk
1110 __git_log_common_options="
1111         --not --all
1112         --branches --tags --remotes
1113         --first-parent --no-merges
1114         --max-count=
1115         --max-age= --since= --after=
1116         --min-age= --until= --before=
1117 "
1118 # Options that go well for log and gitk (not shortlog)
1119 __git_log_gitk_options="
1120         --dense --sparse --full-history
1121         --simplify-merges --simplify-by-decoration
1122         --left-right
1123 "
1124 # Options that go well for log and shortlog (not gitk)
1125 __git_log_shortlog_options="
1126         --author= --committer= --grep=
1127         --all-match
1128 "
1129
1130 __git_log_pretty_formats="oneline short medium full fuller email raw format:"
1131 __git_log_date_formats="relative iso8601 rfc2822 short local default raw"
1132
1133 _git_log ()
1134 {
1135         __git_has_doubledash && return
1136
1137         local cur="${COMP_WORDS[COMP_CWORD]}"
1138         local g="$(git rev-parse --git-dir 2>/dev/null)"
1139         local merge=""
1140         if [ -f "$g/MERGE_HEAD" ]; then
1141                 merge="--merge"
1142         fi
1143         case "$cur" in
1144         --pretty=*)
1145                 __gitcomp "$__git_log_pretty_formats
1146                         " "" "${cur##--pretty=}"
1147                 return
1148                 ;;
1149         --format=*)
1150                 __gitcomp "$__git_log_pretty_formats
1151                         " "" "${cur##--format=}"
1152                 return
1153                 ;;
1154         --date=*)
1155                 __gitcomp "$__git_log_date_formats" "" "${cur##--date=}"
1156                 return
1157                 ;;
1158         --*)
1159                 __gitcomp "
1160                         $__git_log_common_options
1161                         $__git_log_shortlog_options
1162                         $__git_log_gitk_options
1163                         --root --topo-order --date-order --reverse
1164                         --follow
1165                         --abbrev-commit --abbrev=
1166                         --relative-date --date=
1167                         --pretty= --format= --oneline
1168                         --cherry-pick
1169                         --graph
1170                         --decorate
1171                         --walk-reflogs
1172                         --parents --children
1173                         $merge
1174                         $__git_diff_common_options
1175                         --pickaxe-all --pickaxe-regex
1176                         "
1177                 return
1178                 ;;
1179         esac
1180         __git_complete_revlist
1181 }
1182
1183 __git_merge_options="
1184         --no-commit --no-stat --log --no-log --squash --strategy
1185         --commit --stat --no-squash --ff --no-ff
1186 "
1187
1188 _git_merge ()
1189 {
1190         __git_complete_strategy && return
1191
1192         local cur="${COMP_WORDS[COMP_CWORD]}"
1193         case "$cur" in
1194         --*)
1195                 __gitcomp "$__git_merge_options"
1196                 return
1197         esac
1198         __gitcomp "$(__git_refs)"
1199 }
1200
1201 _git_mergetool ()
1202 {
1203         local cur="${COMP_WORDS[COMP_CWORD]}"
1204         case "$cur" in
1205         --tool=*)
1206                 __gitcomp "$__git_mergetools_common tortoisemerge" "" "${cur##--tool=}"
1207                 return
1208                 ;;
1209         --*)
1210                 __gitcomp "--tool="
1211                 return
1212                 ;;
1213         esac
1214         COMPREPLY=()
1215 }
1216
1217 _git_merge_base ()
1218 {
1219         __gitcomp "$(__git_refs)"
1220 }
1221
1222 _git_mv ()
1223 {
1224         local cur="${COMP_WORDS[COMP_CWORD]}"
1225         case "$cur" in
1226         --*)
1227                 __gitcomp "--dry-run"
1228                 return
1229                 ;;
1230         esac
1231         COMPREPLY=()
1232 }
1233
1234 _git_name_rev ()
1235 {
1236         __gitcomp "--tags --all --stdin"
1237 }
1238
1239 _git_pull ()
1240 {
1241         __git_complete_strategy && return
1242
1243         local cur="${COMP_WORDS[COMP_CWORD]}"
1244         case "$cur" in
1245         --*)
1246                 __gitcomp "
1247                         --rebase --no-rebase
1248                         $__git_merge_options
1249                         $__git_fetch_options
1250                 "
1251                 return
1252                 ;;
1253         esac
1254         __git_complete_remote_or_refspec
1255 }
1256
1257 _git_push ()
1258 {
1259         local cur="${COMP_WORDS[COMP_CWORD]}"
1260         case "${COMP_WORDS[COMP_CWORD-1]}" in
1261         --repo)
1262                 __gitcomp "$(__git_remotes)"
1263                 return
1264         esac
1265         case "$cur" in
1266         --repo=*)
1267                 __gitcomp "$(__git_remotes)" "" "${cur##--repo=}"
1268                 return
1269                 ;;
1270         --*)
1271                 __gitcomp "
1272                         --all --mirror --tags --dry-run --force --verbose
1273                         --receive-pack= --repo=
1274                 "
1275                 return
1276                 ;;
1277         esac
1278         __git_complete_remote_or_refspec
1279 }
1280
1281 _git_rebase ()
1282 {
1283         local cur="${COMP_WORDS[COMP_CWORD]}" dir="$(__gitdir)"
1284         if [ -d "$dir"/rebase-apply ] || [ -d "$dir"/rebase-merge ]; then
1285                 __gitcomp "--continue --skip --abort"
1286                 return
1287         fi
1288         __git_complete_strategy && return
1289         case "$cur" in
1290         --*)
1291                 __gitcomp "--onto --merge --strategy --interactive"
1292                 return
1293         esac
1294         __gitcomp "$(__git_refs)"
1295 }
1296
1297 __git_send_email_confirm_options="always never auto cc compose"
1298 __git_send_email_suppresscc_options="author self cc ccbody sob cccmd body all"
1299
1300 _git_send_email ()
1301 {
1302         local cur="${COMP_WORDS[COMP_CWORD]}"
1303         case "$cur" in
1304         --confirm=*)
1305                 __gitcomp "
1306                         $__git_send_email_confirm_options
1307                         " "" "${cur##--confirm=}"
1308                 return
1309                 ;;
1310         --suppress-cc=*)
1311                 __gitcomp "
1312                         $__git_send_email_suppresscc_options
1313                         " "" "${cur##--suppress-cc=}"
1314
1315                 return
1316                 ;;
1317         --smtp-encryption=*)
1318                 __gitcomp "ssl tls" "" "${cur##--smtp-encryption=}"
1319                 return
1320                 ;;
1321         --*)
1322                 __gitcomp "--annotate --bcc --cc --cc-cmd --chain-reply-to
1323                         --compose --confirm= --dry-run --envelope-sender
1324                         --from --identity
1325                         --in-reply-to --no-chain-reply-to --no-signed-off-by-cc
1326                         --no-suppress-from --no-thread --quiet
1327                         --signed-off-by-cc --smtp-pass --smtp-server
1328                         --smtp-server-port --smtp-encryption= --smtp-user
1329                         --subject --suppress-cc= --suppress-from --thread --to
1330                         --validate --no-validate"
1331                 return
1332                 ;;
1333         esac
1334         COMPREPLY=()
1335 }
1336
1337 __git_config_get_set_variables ()
1338 {
1339         local prevword word config_file= c=$COMP_CWORD
1340         while [ $c -gt 1 ]; do
1341                 word="${COMP_WORDS[c]}"
1342                 case "$word" in
1343                 --global|--system|--file=*)
1344                         config_file="$word"
1345                         break
1346                         ;;
1347                 -f|--file)
1348                         config_file="$word $prevword"
1349                         break
1350                         ;;
1351                 esac
1352                 prevword=$word
1353                 c=$((--c))
1354         done
1355
1356         for i in $(git --git-dir="$(__gitdir)" config $config_file --list \
1357                         2>/dev/null); do
1358                 case "$i" in
1359                 *.*)
1360                         echo "${i/=*/}"
1361                         ;;
1362                 esac
1363         done
1364 }
1365
1366 _git_config ()
1367 {
1368         local cur="${COMP_WORDS[COMP_CWORD]}"
1369         local prv="${COMP_WORDS[COMP_CWORD-1]}"
1370         case "$prv" in
1371         branch.*.remote)
1372                 __gitcomp "$(__git_remotes)"
1373                 return
1374                 ;;
1375         branch.*.merge)
1376                 __gitcomp "$(__git_refs)"
1377                 return
1378                 ;;
1379         remote.*.fetch)
1380                 local remote="${prv#remote.}"
1381                 remote="${remote%.fetch}"
1382                 __gitcomp "$(__git_refs_remotes "$remote")"
1383                 return
1384                 ;;
1385         remote.*.push)
1386                 local remote="${prv#remote.}"
1387                 remote="${remote%.push}"
1388                 __gitcomp "$(git --git-dir="$(__gitdir)" \
1389                         for-each-ref --format='%(refname):%(refname)' \
1390                         refs/heads)"
1391                 return
1392                 ;;
1393         pull.twohead|pull.octopus)
1394                 __gitcomp "$(__git_merge_strategies)"
1395                 return
1396                 ;;
1397         color.branch|color.diff|color.interactive|\
1398         color.showbranch|color.status|color.ui)
1399                 __gitcomp "always never auto"
1400                 return
1401                 ;;
1402         color.pager)
1403                 __gitcomp "false true"
1404                 return
1405                 ;;
1406         color.*.*)
1407                 __gitcomp "
1408                         normal black red green yellow blue magenta cyan white
1409                         bold dim ul blink reverse
1410                         "
1411                 return
1412                 ;;
1413         help.format)
1414                 __gitcomp "man info web html"
1415                 return
1416                 ;;
1417         log.date)
1418                 __gitcomp "$__git_log_date_formats"
1419                 return
1420                 ;;
1421         sendemail.aliasesfiletype)
1422                 __gitcomp "mutt mailrc pine elm gnus"
1423                 return
1424                 ;;
1425         sendemail.confirm)
1426                 __gitcomp "$__git_send_email_confirm_options"
1427                 return
1428                 ;;
1429         sendemail.suppresscc)
1430                 __gitcomp "$__git_send_email_suppresscc_options"
1431                 return
1432                 ;;
1433         --get|--get-all|--unset|--unset-all)
1434                 __gitcomp "$(__git_config_get_set_variables)"
1435                 return
1436                 ;;
1437         *.*)
1438                 COMPREPLY=()
1439                 return
1440                 ;;
1441         esac
1442         case "$cur" in
1443         --*)
1444                 __gitcomp "
1445                         --global --system --file=
1446                         --list --replace-all
1447                         --get --get-all --get-regexp
1448                         --add --unset --unset-all
1449                         --remove-section --rename-section
1450                         "
1451                 return
1452                 ;;
1453         branch.*.*)
1454                 local pfx="${cur%.*}."
1455                 cur="${cur##*.}"
1456                 __gitcomp "remote merge mergeoptions" "$pfx" "$cur"
1457                 return
1458                 ;;
1459         branch.*)
1460                 local pfx="${cur%.*}."
1461                 cur="${cur#*.}"
1462                 __gitcomp "$(__git_heads)" "$pfx" "$cur" "."
1463                 return
1464                 ;;
1465         guitool.*.*)
1466                 local pfx="${cur%.*}."
1467                 cur="${cur##*.}"
1468                 __gitcomp "
1469                         argprompt cmd confirm needsfile noconsole norescan
1470                         prompt revprompt revunmerged title
1471                         " "$pfx" "$cur"
1472                 return
1473                 ;;
1474         difftool.*.*)
1475                 local pfx="${cur%.*}."
1476                 cur="${cur##*.}"
1477                 __gitcomp "cmd path" "$pfx" "$cur"
1478                 return
1479                 ;;
1480         man.*.*)
1481                 local pfx="${cur%.*}."
1482                 cur="${cur##*.}"
1483                 __gitcomp "cmd path" "$pfx" "$cur"
1484                 return
1485                 ;;
1486         mergetool.*.*)
1487                 local pfx="${cur%.*}."
1488                 cur="${cur##*.}"
1489                 __gitcomp "cmd path trustExitCode" "$pfx" "$cur"
1490                 return
1491                 ;;
1492         pager.*)
1493                 local pfx="${cur%.*}."
1494                 cur="${cur#*.}"
1495                 __gitcomp "$(__git_all_commands)" "$pfx" "$cur"
1496                 return
1497                 ;;
1498         remote.*.*)
1499                 local pfx="${cur%.*}."
1500                 cur="${cur##*.}"
1501                 __gitcomp "
1502                         url proxy fetch push mirror skipDefaultUpdate
1503                         receivepack uploadpack tagopt
1504                         " "$pfx" "$cur"
1505                 return
1506                 ;;
1507         remote.*)
1508                 local pfx="${cur%.*}."
1509                 cur="${cur#*.}"
1510                 __gitcomp "$(__git_remotes)" "$pfx" "$cur" "."
1511                 return
1512                 ;;
1513         url.*.*)
1514                 local pfx="${cur%.*}."
1515                 cur="${cur##*.}"
1516                 __gitcomp "insteadof" "$pfx" "$cur"
1517                 return
1518                 ;;
1519         esac
1520         __gitcomp "
1521                 alias.
1522                 apply.whitespace
1523                 branch.autosetupmerge
1524                 branch.autosetuprebase
1525                 clean.requireForce
1526                 color.branch
1527                 color.branch.current
1528                 color.branch.local
1529                 color.branch.plain
1530                 color.branch.remote
1531                 color.diff
1532                 color.diff.commit
1533                 color.diff.frag
1534                 color.diff.meta
1535                 color.diff.new
1536                 color.diff.old
1537                 color.diff.plain
1538                 color.diff.whitespace
1539                 color.grep
1540                 color.grep.external
1541                 color.grep.match
1542                 color.interactive
1543                 color.interactive.header
1544                 color.interactive.help
1545                 color.interactive.prompt
1546                 color.pager
1547                 color.showbranch
1548                 color.status
1549                 color.status.added
1550                 color.status.changed
1551                 color.status.header
1552                 color.status.nobranch
1553                 color.status.untracked
1554                 color.status.updated
1555                 color.ui
1556                 commit.template
1557                 core.autocrlf
1558                 core.bare
1559                 core.compression
1560                 core.createObject
1561                 core.deltaBaseCacheLimit
1562                 core.editor
1563                 core.excludesfile
1564                 core.fileMode
1565                 core.fsyncobjectfiles
1566                 core.gitProxy
1567                 core.ignoreCygwinFSTricks
1568                 core.ignoreStat
1569                 core.logAllRefUpdates
1570                 core.loosecompression
1571                 core.packedGitLimit
1572                 core.packedGitWindowSize
1573                 core.pager
1574                 core.preferSymlinkRefs
1575                 core.preloadindex
1576                 core.quotepath
1577                 core.repositoryFormatVersion
1578                 core.safecrlf
1579                 core.sharedRepository
1580                 core.symlinks
1581                 core.trustctime
1582                 core.warnAmbiguousRefs
1583                 core.whitespace
1584                 core.worktree
1585                 diff.autorefreshindex
1586                 diff.external
1587                 diff.mnemonicprefix
1588                 diff.renameLimit
1589                 diff.renameLimit.
1590                 diff.renames
1591                 diff.suppressBlankEmpty
1592                 diff.tool
1593                 diff.wordRegex
1594                 difftool.
1595                 difftool.prompt
1596                 fetch.unpackLimit
1597                 format.attach
1598                 format.cc
1599                 format.headers
1600                 format.numbered
1601                 format.pretty
1602                 format.signoff
1603                 format.subjectprefix
1604                 format.suffix
1605                 format.thread
1606                 gc.aggressiveWindow
1607                 gc.auto
1608                 gc.autopacklimit
1609                 gc.packrefs
1610                 gc.pruneexpire
1611                 gc.reflogexpire
1612                 gc.reflogexpireunreachable
1613                 gc.rerereresolved
1614                 gc.rerereunresolved
1615                 gitcvs.allbinary
1616                 gitcvs.commitmsgannotation
1617                 gitcvs.dbTableNamePrefix
1618                 gitcvs.dbdriver
1619                 gitcvs.dbname
1620                 gitcvs.dbpass
1621                 gitcvs.dbuser
1622                 gitcvs.enabled
1623                 gitcvs.logfile
1624                 gitcvs.usecrlfattr
1625                 guitool.
1626                 gui.blamehistoryctx
1627                 gui.commitmsgwidth
1628                 gui.copyblamethreshold
1629                 gui.diffcontext
1630                 gui.encoding
1631                 gui.fastcopyblame
1632                 gui.matchtrackingbranch
1633                 gui.newbranchtemplate
1634                 gui.pruneduringfetch
1635                 gui.spellingdictionary
1636                 gui.trustmtime
1637                 help.autocorrect
1638                 help.browser
1639                 help.format
1640                 http.lowSpeedLimit
1641                 http.lowSpeedTime
1642                 http.maxRequests
1643                 http.noEPSV
1644                 http.proxy
1645                 http.sslCAInfo
1646                 http.sslCAPath
1647                 http.sslCert
1648                 http.sslKey
1649                 http.sslVerify
1650                 i18n.commitEncoding
1651                 i18n.logOutputEncoding
1652                 imap.folder
1653                 imap.host
1654                 imap.pass
1655                 imap.port
1656                 imap.preformattedHTML
1657                 imap.sslverify
1658                 imap.tunnel
1659                 imap.user
1660                 instaweb.browser
1661                 instaweb.httpd
1662                 instaweb.local
1663                 instaweb.modulepath
1664                 instaweb.port
1665                 interactive.singlekey
1666                 log.date
1667                 log.showroot
1668                 mailmap.file
1669                 man.
1670                 man.viewer
1671                 merge.conflictstyle
1672                 merge.log
1673                 merge.renameLimit
1674                 merge.stat
1675                 merge.tool
1676                 merge.verbosity
1677                 mergetool.
1678                 mergetool.keepBackup
1679                 mergetool.prompt
1680                 pack.compression
1681                 pack.deltaCacheLimit
1682                 pack.deltaCacheSize
1683                 pack.depth
1684                 pack.indexVersion
1685                 pack.packSizeLimit
1686                 pack.threads
1687                 pack.window
1688                 pack.windowMemory
1689                 pager.
1690                 pull.octopus
1691                 pull.twohead
1692                 push.default
1693                 rebase.stat
1694                 receive.denyCurrentBranch
1695                 receive.denyDeletes
1696                 receive.denyNonFastForwards
1697                 receive.fsckObjects
1698                 receive.unpackLimit
1699                 repack.usedeltabaseoffset
1700                 rerere.autoupdate
1701                 rerere.enabled
1702                 sendemail.aliasesfile
1703                 sendemail.aliasesfiletype
1704                 sendemail.bcc
1705                 sendemail.cc
1706                 sendemail.cccmd
1707                 sendemail.chainreplyto
1708                 sendemail.confirm
1709                 sendemail.envelopesender
1710                 sendemail.multiedit
1711                 sendemail.signedoffbycc
1712                 sendemail.smtpencryption
1713                 sendemail.smtppass
1714                 sendemail.smtpserver
1715                 sendemail.smtpserverport
1716                 sendemail.smtpuser
1717                 sendemail.suppresscc
1718                 sendemail.suppressfrom
1719                 sendemail.thread
1720                 sendemail.to
1721                 sendemail.validate
1722                 showbranch.default
1723                 status.relativePaths
1724                 status.showUntrackedFiles
1725                 tar.umask
1726                 transfer.unpackLimit
1727                 url.
1728                 user.email
1729                 user.name
1730                 user.signingkey
1731                 web.browser
1732                 branch. remote.
1733         "
1734 }
1735
1736 _git_remote ()
1737 {
1738         local subcommands="add rename rm show prune update set-head"
1739         local subcommand="$(__git_find_subcommand "$subcommands")"
1740         if [ -z "$subcommand" ]; then
1741                 __gitcomp "$subcommands"
1742                 return
1743         fi
1744
1745         case "$subcommand" in
1746         rename|rm|show|prune)
1747                 __gitcomp "$(__git_remotes)"
1748                 ;;
1749         update)
1750                 local i c='' IFS=$'\n'
1751                 for i in $(git --git-dir="$(__gitdir)" config --list); do
1752                         case "$i" in
1753                         remotes.*)
1754                                 i="${i#remotes.}"
1755                                 c="$c ${i/=*/}"
1756                                 ;;
1757                         esac
1758                 done
1759                 __gitcomp "$c"
1760                 ;;
1761         *)
1762                 COMPREPLY=()
1763                 ;;
1764         esac
1765 }
1766
1767 _git_reset ()
1768 {
1769         __git_has_doubledash && return
1770
1771         local cur="${COMP_WORDS[COMP_CWORD]}"
1772         case "$cur" in
1773         --*)
1774                 __gitcomp "--merge --mixed --hard --soft"
1775                 return
1776                 ;;
1777         esac
1778         __gitcomp "$(__git_refs)"
1779 }
1780
1781 _git_revert ()
1782 {
1783         local cur="${COMP_WORDS[COMP_CWORD]}"
1784         case "$cur" in
1785         --*)
1786                 __gitcomp "--edit --mainline --no-edit --no-commit --signoff"
1787                 return
1788                 ;;
1789         esac
1790         __gitcomp "$(__git_refs)"
1791 }
1792
1793 _git_rm ()
1794 {
1795         __git_has_doubledash && return
1796
1797         local cur="${COMP_WORDS[COMP_CWORD]}"
1798         case "$cur" in
1799         --*)
1800                 __gitcomp "--cached --dry-run --ignore-unmatch --quiet"
1801                 return
1802                 ;;
1803         esac
1804         COMPREPLY=()
1805 }
1806
1807 _git_shortlog ()
1808 {
1809         __git_has_doubledash && return
1810
1811         local cur="${COMP_WORDS[COMP_CWORD]}"
1812         case "$cur" in
1813         --*)
1814                 __gitcomp "
1815                         $__git_log_common_options
1816                         $__git_log_shortlog_options
1817                         --numbered --summary
1818                         "
1819                 return
1820                 ;;
1821         esac
1822         __git_complete_revlist
1823 }
1824
1825 _git_show ()
1826 {
1827         __git_has_doubledash && return
1828
1829         local cur="${COMP_WORDS[COMP_CWORD]}"
1830         case "$cur" in
1831         --pretty=*)
1832                 __gitcomp "$__git_log_pretty_formats
1833                         " "" "${cur##--pretty=}"
1834                 return
1835                 ;;
1836         --format=*)
1837                 __gitcomp "$__git_log_pretty_formats
1838                         " "" "${cur##--format=}"
1839                 return
1840                 ;;
1841         --*)
1842                 __gitcomp "--pretty= --format= --abbrev-commit --oneline
1843                         $__git_diff_common_options
1844                         "
1845                 return
1846                 ;;
1847         esac
1848         __git_complete_file
1849 }
1850
1851 _git_show_branch ()
1852 {
1853         local cur="${COMP_WORDS[COMP_CWORD]}"
1854         case "$cur" in
1855         --*)
1856                 __gitcomp "
1857                         --all --remotes --topo-order --current --more=
1858                         --list --independent --merge-base --no-name
1859                         --color --no-color
1860                         --sha1-name --sparse --topics --reflog
1861                         "
1862                 return
1863                 ;;
1864         esac
1865         __git_complete_revlist
1866 }
1867
1868 _git_stash ()
1869 {
1870         local subcommands='save list show apply clear drop pop create branch'
1871         local subcommand="$(__git_find_subcommand "$subcommands")"
1872         if [ -z "$subcommand" ]; then
1873                 __gitcomp "$subcommands"
1874         else
1875                 local cur="${COMP_WORDS[COMP_CWORD]}"
1876                 case "$subcommand,$cur" in
1877                 save,--*)
1878                         __gitcomp "--keep-index"
1879                         ;;
1880                 apply,--*)
1881                         __gitcomp "--index"
1882                         ;;
1883                 show,--*|drop,--*|pop,--*|branch,--*)
1884                         COMPREPLY=()
1885                         ;;
1886                 show,*|apply,*|drop,*|pop,*|branch,*)
1887                         __gitcomp "$(git --git-dir="$(__gitdir)" stash list \
1888                                         | sed -n -e 's/:.*//p')"
1889                         ;;
1890                 *)
1891                         COMPREPLY=()
1892                         ;;
1893                 esac
1894         fi
1895 }
1896
1897 _git_submodule ()
1898 {
1899         __git_has_doubledash && return
1900
1901         local subcommands="add status init update summary foreach sync"
1902         if [ -z "$(__git_find_subcommand "$subcommands")" ]; then
1903                 local cur="${COMP_WORDS[COMP_CWORD]}"
1904                 case "$cur" in
1905                 --*)
1906                         __gitcomp "--quiet --cached"
1907                         ;;
1908                 *)
1909                         __gitcomp "$subcommands"
1910                         ;;
1911                 esac
1912                 return
1913         fi
1914 }
1915
1916 _git_svn ()
1917 {
1918         local subcommands="
1919                 init fetch clone rebase dcommit log find-rev
1920                 set-tree commit-diff info create-ignore propget
1921                 proplist show-ignore show-externals branch tag blame
1922                 migrate
1923                 "
1924         local subcommand="$(__git_find_subcommand "$subcommands")"
1925         if [ -z "$subcommand" ]; then
1926                 __gitcomp "$subcommands"
1927         else
1928                 local remote_opts="--username= --config-dir= --no-auth-cache"
1929                 local fc_opts="
1930                         --follow-parent --authors-file= --repack=
1931                         --no-metadata --use-svm-props --use-svnsync-props
1932                         --log-window-size= --no-checkout --quiet
1933                         --repack-flags --use-log-author --localtime
1934                         --ignore-paths= $remote_opts
1935                         "
1936                 local init_opts="
1937                         --template= --shared= --trunk= --tags=
1938                         --branches= --stdlayout --minimize-url
1939                         --no-metadata --use-svm-props --use-svnsync-props
1940                         --rewrite-root= --prefix= --use-log-author
1941                         --add-author-from $remote_opts
1942                         "
1943                 local cmt_opts="
1944                         --edit --rmdir --find-copies-harder --copy-similarity=
1945                         "
1946
1947                 local cur="${COMP_WORDS[COMP_CWORD]}"
1948                 case "$subcommand,$cur" in
1949                 fetch,--*)
1950                         __gitcomp "--revision= --fetch-all $fc_opts"
1951                         ;;
1952                 clone,--*)
1953                         __gitcomp "--revision= $fc_opts $init_opts"
1954                         ;;
1955                 init,--*)
1956                         __gitcomp "$init_opts"
1957                         ;;
1958                 dcommit,--*)
1959                         __gitcomp "
1960                                 --merge --strategy= --verbose --dry-run
1961                                 --fetch-all --no-rebase --commit-url
1962                                 --revision $cmt_opts $fc_opts
1963                                 "
1964                         ;;
1965                 set-tree,--*)
1966                         __gitcomp "--stdin $cmt_opts $fc_opts"
1967                         ;;
1968                 create-ignore,--*|propget,--*|proplist,--*|show-ignore,--*|\
1969                 show-externals,--*)
1970                         __gitcomp "--revision="
1971                         ;;
1972                 log,--*)
1973                         __gitcomp "
1974                                 --limit= --revision= --verbose --incremental
1975                                 --oneline --show-commit --non-recursive
1976                                 --authors-file= --color
1977                                 "
1978                         ;;
1979                 rebase,--*)
1980                         __gitcomp "
1981                                 --merge --verbose --strategy= --local
1982                                 --fetch-all --dry-run $fc_opts
1983                                 "
1984                         ;;
1985                 commit-diff,--*)
1986                         __gitcomp "--message= --file= --revision= $cmt_opts"
1987                         ;;
1988                 info,--*)
1989                         __gitcomp "--url"
1990                         ;;
1991                 branch,--*)
1992                         __gitcomp "--dry-run --message --tag"
1993                         ;;
1994                 tag,--*)
1995                         __gitcomp "--dry-run --message"
1996                         ;;
1997                 blame,--*)
1998                         __gitcomp "--git-format"
1999                         ;;
2000                 migrate,--*)
2001                         __gitcomp "
2002                                 --config-dir= --ignore-paths= --minimize
2003                                 --no-auth-cache --username=
2004                                 "
2005                         ;;
2006                 *)
2007                         COMPREPLY=()
2008                         ;;
2009                 esac
2010         fi
2011 }
2012
2013 _git_tag ()
2014 {
2015         local i c=1 f=0
2016         while [ $c -lt $COMP_CWORD ]; do
2017                 i="${COMP_WORDS[c]}"
2018                 case "$i" in
2019                 -d|-v)
2020                         __gitcomp "$(__git_tags)"
2021                         return
2022                         ;;
2023                 -f)
2024                         f=1
2025                         ;;
2026                 esac
2027                 c=$((++c))
2028         done
2029
2030         case "${COMP_WORDS[COMP_CWORD-1]}" in
2031         -m|-F)
2032                 COMPREPLY=()
2033                 ;;
2034         -*|tag)
2035                 if [ $f = 1 ]; then
2036                         __gitcomp "$(__git_tags)"
2037                 else
2038                         COMPREPLY=()
2039                 fi
2040                 ;;
2041         *)
2042                 __gitcomp "$(__git_refs)"
2043                 ;;
2044         esac
2045 }
2046
2047 _git ()
2048 {
2049         local i c=1 command __git_dir
2050
2051         while [ $c -lt $COMP_CWORD ]; do
2052                 i="${COMP_WORDS[c]}"
2053                 case "$i" in
2054                 --git-dir=*) __git_dir="${i#--git-dir=}" ;;
2055                 --bare)      __git_dir="." ;;
2056                 --version|-p|--paginate) ;;
2057                 --help) command="help"; break ;;
2058                 *) command="$i"; break ;;
2059                 esac
2060                 c=$((++c))
2061         done
2062
2063         if [ -z "$command" ]; then
2064                 case "${COMP_WORDS[COMP_CWORD]}" in
2065                 --*)   __gitcomp "
2066                         --paginate
2067                         --no-pager
2068                         --git-dir=
2069                         --bare
2070                         --version
2071                         --exec-path
2072                         --html-path
2073                         --work-tree=
2074                         --help
2075                         "
2076                         ;;
2077                 *)     __gitcomp "$(__git_porcelain_commands) $(__git_aliases)" ;;
2078                 esac
2079                 return
2080         fi
2081
2082         local expansion=$(__git_aliased_command "$command")
2083         [ "$expansion" ] && command="$expansion"
2084
2085         case "$command" in
2086         am)          _git_am ;;
2087         add)         _git_add ;;
2088         apply)       _git_apply ;;
2089         archive)     _git_archive ;;
2090         bisect)      _git_bisect ;;
2091         bundle)      _git_bundle ;;
2092         branch)      _git_branch ;;
2093         checkout)    _git_checkout ;;
2094         cherry)      _git_cherry ;;
2095         cherry-pick) _git_cherry_pick ;;
2096         clean)       _git_clean ;;
2097         clone)       _git_clone ;;
2098         commit)      _git_commit ;;
2099         config)      _git_config ;;
2100         describe)    _git_describe ;;
2101         diff)        _git_diff ;;
2102         difftool)    _git_difftool ;;
2103         fetch)       _git_fetch ;;
2104         format-patch) _git_format_patch ;;
2105         fsck)        _git_fsck ;;
2106         gc)          _git_gc ;;
2107         grep)        _git_grep ;;
2108         help)        _git_help ;;
2109         init)        _git_init ;;
2110         log)         _git_log ;;
2111         ls-files)    _git_ls_files ;;
2112         ls-remote)   _git_ls_remote ;;
2113         ls-tree)     _git_ls_tree ;;
2114         merge)       _git_merge;;
2115         mergetool)   _git_mergetool;;
2116         merge-base)  _git_merge_base ;;
2117         mv)          _git_mv ;;
2118         name-rev)    _git_name_rev ;;
2119         pull)        _git_pull ;;
2120         push)        _git_push ;;
2121         rebase)      _git_rebase ;;
2122         remote)      _git_remote ;;
2123         reset)       _git_reset ;;
2124         revert)      _git_revert ;;
2125         rm)          _git_rm ;;
2126         send-email)  _git_send_email ;;
2127         shortlog)    _git_shortlog ;;
2128         show)        _git_show ;;
2129         show-branch) _git_show_branch ;;
2130         stash)       _git_stash ;;
2131         stage)       _git_add ;;
2132         submodule)   _git_submodule ;;
2133         svn)         _git_svn ;;
2134         tag)         _git_tag ;;
2135         whatchanged) _git_log ;;
2136         *)           COMPREPLY=() ;;
2137         esac
2138 }
2139
2140 _gitk ()
2141 {
2142         __git_has_doubledash && return
2143
2144         local cur="${COMP_WORDS[COMP_CWORD]}"
2145         local g="$(__gitdir)"
2146         local merge=""
2147         if [ -f "$g/MERGE_HEAD" ]; then
2148                 merge="--merge"
2149         fi
2150         case "$cur" in
2151         --*)
2152                 __gitcomp "
2153                         $__git_log_common_options
2154                         $__git_log_gitk_options
2155                         $merge
2156                         "
2157                 return
2158                 ;;
2159         esac
2160         __git_complete_revlist
2161 }
2162
2163 complete -o bashdefault -o default -o nospace -F _git git 2>/dev/null \
2164         || complete -o default -o nospace -F _git git
2165 complete -o bashdefault -o default -o nospace -F _gitk gitk 2>/dev/null \
2166         || complete -o default -o nospace -F _gitk gitk
2167
2168 # The following are necessary only for Cygwin, and only are needed
2169 # when the user has tab-completed the executable name and consequently
2170 # included the '.exe' suffix.
2171 #
2172 if [ Cygwin = "$(uname -o 2>/dev/null)" ]; then
2173 complete -o bashdefault -o default -o nospace -F _git git.exe 2>/dev/null \
2174         || complete -o default -o nospace -F _git git.exe
2175 fi