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