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         --*)
1327                 __gitcomp "--onto --merge --strategy --interactive"
1328                 return
1329         esac
1330         __gitcomp "$(__git_refs)"
1331 }
1332
1333 __git_send_email_confirm_options="always never auto cc compose"
1334 __git_send_email_suppresscc_options="author self cc bodycc sob cccmd body all"
1335
1336 _git_send_email ()
1337 {
1338         local cur="${COMP_WORDS[COMP_CWORD]}"
1339         case "$cur" in
1340         --confirm=*)
1341                 __gitcomp "
1342                         $__git_send_email_confirm_options
1343                         " "" "${cur##--confirm=}"
1344                 return
1345                 ;;
1346         --suppress-cc=*)
1347                 __gitcomp "
1348                         $__git_send_email_suppresscc_options
1349                         " "" "${cur##--suppress-cc=}"
1350
1351                 return
1352                 ;;
1353         --smtp-encryption=*)
1354                 __gitcomp "ssl tls" "" "${cur##--smtp-encryption=}"
1355                 return
1356                 ;;
1357         --*)
1358                 __gitcomp "--annotate --bcc --cc --cc-cmd --chain-reply-to
1359                         --compose --confirm= --dry-run --envelope-sender
1360                         --from --identity
1361                         --in-reply-to --no-chain-reply-to --no-signed-off-by-cc
1362                         --no-suppress-from --no-thread --quiet
1363                         --signed-off-by-cc --smtp-pass --smtp-server
1364                         --smtp-server-port --smtp-encryption= --smtp-user
1365                         --subject --suppress-cc= --suppress-from --thread --to
1366                         --validate --no-validate"
1367                 return
1368                 ;;
1369         esac
1370         COMPREPLY=()
1371 }
1372
1373 __git_config_get_set_variables ()
1374 {
1375         local prevword word config_file= c=$COMP_CWORD
1376         while [ $c -gt 1 ]; do
1377                 word="${COMP_WORDS[c]}"
1378                 case "$word" in
1379                 --global|--system|--file=*)
1380                         config_file="$word"
1381                         break
1382                         ;;
1383                 -f|--file)
1384                         config_file="$word $prevword"
1385                         break
1386                         ;;
1387                 esac
1388                 prevword=$word
1389                 c=$((--c))
1390         done
1391
1392         git --git-dir="$(__gitdir)" config $config_file --list 2>/dev/null |
1393         while read line
1394         do
1395                 case "$line" in
1396                 *.*=*)
1397                         echo "${line/=*/}"
1398                         ;;
1399                 esac
1400         done
1401 }
1402
1403 _git_config ()
1404 {
1405         local cur="${COMP_WORDS[COMP_CWORD]}"
1406         local prv="${COMP_WORDS[COMP_CWORD-1]}"
1407         case "$prv" in
1408         branch.*.remote)
1409                 __gitcomp "$(__git_remotes)"
1410                 return
1411                 ;;
1412         branch.*.merge)
1413                 __gitcomp "$(__git_refs)"
1414                 return
1415                 ;;
1416         remote.*.fetch)
1417                 local remote="${prv#remote.}"
1418                 remote="${remote%.fetch}"
1419                 __gitcomp "$(__git_refs_remotes "$remote")"
1420                 return
1421                 ;;
1422         remote.*.push)
1423                 local remote="${prv#remote.}"
1424                 remote="${remote%.push}"
1425                 __gitcomp "$(git --git-dir="$(__gitdir)" \
1426                         for-each-ref --format='%(refname):%(refname)' \
1427                         refs/heads)"
1428                 return
1429                 ;;
1430         pull.twohead|pull.octopus)
1431                 __gitcomp "$(__git_merge_strategies)"
1432                 return
1433                 ;;
1434         color.branch|color.diff|color.interactive|\
1435         color.showbranch|color.status|color.ui)
1436                 __gitcomp "always never auto"
1437                 return
1438                 ;;
1439         color.pager)
1440                 __gitcomp "false true"
1441                 return
1442                 ;;
1443         color.*.*)
1444                 __gitcomp "
1445                         normal black red green yellow blue magenta cyan white
1446                         bold dim ul blink reverse
1447                         "
1448                 return
1449                 ;;
1450         help.format)
1451                 __gitcomp "man info web html"
1452                 return
1453                 ;;
1454         log.date)
1455                 __gitcomp "$__git_log_date_formats"
1456                 return
1457                 ;;
1458         sendemail.aliasesfiletype)
1459                 __gitcomp "mutt mailrc pine elm gnus"
1460                 return
1461                 ;;
1462         sendemail.confirm)
1463                 __gitcomp "$__git_send_email_confirm_options"
1464                 return
1465                 ;;
1466         sendemail.suppresscc)
1467                 __gitcomp "$__git_send_email_suppresscc_options"
1468                 return
1469                 ;;
1470         --get|--get-all|--unset|--unset-all)
1471                 __gitcomp "$(__git_config_get_set_variables)"
1472                 return
1473                 ;;
1474         *.*)
1475                 COMPREPLY=()
1476                 return
1477                 ;;
1478         esac
1479         case "$cur" in
1480         --*)
1481                 __gitcomp "
1482                         --global --system --file=
1483                         --list --replace-all
1484                         --get --get-all --get-regexp
1485                         --add --unset --unset-all
1486                         --remove-section --rename-section
1487                         "
1488                 return
1489                 ;;
1490         branch.*.*)
1491                 local pfx="${cur%.*}."
1492                 cur="${cur##*.}"
1493                 __gitcomp "remote merge mergeoptions rebase" "$pfx" "$cur"
1494                 return
1495                 ;;
1496         branch.*)
1497                 local pfx="${cur%.*}."
1498                 cur="${cur#*.}"
1499                 __gitcomp "$(__git_heads)" "$pfx" "$cur" "."
1500                 return
1501                 ;;
1502         guitool.*.*)
1503                 local pfx="${cur%.*}."
1504                 cur="${cur##*.}"
1505                 __gitcomp "
1506                         argprompt cmd confirm needsfile noconsole norescan
1507                         prompt revprompt revunmerged title
1508                         " "$pfx" "$cur"
1509                 return
1510                 ;;
1511         difftool.*.*)
1512                 local pfx="${cur%.*}."
1513                 cur="${cur##*.}"
1514                 __gitcomp "cmd path" "$pfx" "$cur"
1515                 return
1516                 ;;
1517         man.*.*)
1518                 local pfx="${cur%.*}."
1519                 cur="${cur##*.}"
1520                 __gitcomp "cmd path" "$pfx" "$cur"
1521                 return
1522                 ;;
1523         mergetool.*.*)
1524                 local pfx="${cur%.*}."
1525                 cur="${cur##*.}"
1526                 __gitcomp "cmd path trustExitCode" "$pfx" "$cur"
1527                 return
1528                 ;;
1529         pager.*)
1530                 local pfx="${cur%.*}."
1531                 cur="${cur#*.}"
1532                 __gitcomp "$(__git_all_commands)" "$pfx" "$cur"
1533                 return
1534                 ;;
1535         remote.*.*)
1536                 local pfx="${cur%.*}."
1537                 cur="${cur##*.}"
1538                 __gitcomp "
1539                         url proxy fetch push mirror skipDefaultUpdate
1540                         receivepack uploadpack tagopt pushurl
1541                         " "$pfx" "$cur"
1542                 return
1543                 ;;
1544         remote.*)
1545                 local pfx="${cur%.*}."
1546                 cur="${cur#*.}"
1547                 __gitcomp "$(__git_remotes)" "$pfx" "$cur" "."
1548                 return
1549                 ;;
1550         url.*.*)
1551                 local pfx="${cur%.*}."
1552                 cur="${cur##*.}"
1553                 __gitcomp "insteadOf pushInsteadOf" "$pfx" "$cur"
1554                 return
1555                 ;;
1556         esac
1557         __gitcomp "
1558                 add.ignore-errors
1559                 alias.
1560                 apply.ignorewhitespace
1561                 apply.whitespace
1562                 branch.autosetupmerge
1563                 branch.autosetuprebase
1564                 clean.requireForce
1565                 color.branch
1566                 color.branch.current
1567                 color.branch.local
1568                 color.branch.plain
1569                 color.branch.remote
1570                 color.diff
1571                 color.diff.commit
1572                 color.diff.frag
1573                 color.diff.meta
1574                 color.diff.new
1575                 color.diff.old
1576                 color.diff.plain
1577                 color.diff.whitespace
1578                 color.grep
1579                 color.grep.external
1580                 color.grep.match
1581                 color.interactive
1582                 color.interactive.header
1583                 color.interactive.help
1584                 color.interactive.prompt
1585                 color.pager
1586                 color.showbranch
1587                 color.status
1588                 color.status.added
1589                 color.status.changed
1590                 color.status.header
1591                 color.status.nobranch
1592                 color.status.untracked
1593                 color.status.updated
1594                 color.ui
1595                 commit.template
1596                 core.autocrlf
1597                 core.bare
1598                 core.compression
1599                 core.createObject
1600                 core.deltaBaseCacheLimit
1601                 core.editor
1602                 core.excludesfile
1603                 core.fileMode
1604                 core.fsyncobjectfiles
1605                 core.gitProxy
1606                 core.ignoreCygwinFSTricks
1607                 core.ignoreStat
1608                 core.logAllRefUpdates
1609                 core.loosecompression
1610                 core.packedGitLimit
1611                 core.packedGitWindowSize
1612                 core.pager
1613                 core.preferSymlinkRefs
1614                 core.preloadindex
1615                 core.quotepath
1616                 core.repositoryFormatVersion
1617                 core.safecrlf
1618                 core.sharedRepository
1619                 core.symlinks
1620                 core.trustctime
1621                 core.warnAmbiguousRefs
1622                 core.whitespace
1623                 core.worktree
1624                 diff.autorefreshindex
1625                 diff.external
1626                 diff.mnemonicprefix
1627                 diff.renameLimit
1628                 diff.renameLimit.
1629                 diff.renames
1630                 diff.suppressBlankEmpty
1631                 diff.tool
1632                 diff.wordRegex
1633                 difftool.
1634                 difftool.prompt
1635                 fetch.unpackLimit
1636                 format.attach
1637                 format.cc
1638                 format.headers
1639                 format.numbered
1640                 format.pretty
1641                 format.signoff
1642                 format.subjectprefix
1643                 format.suffix
1644                 format.thread
1645                 gc.aggressiveWindow
1646                 gc.auto
1647                 gc.autopacklimit
1648                 gc.packrefs
1649                 gc.pruneexpire
1650                 gc.reflogexpire
1651                 gc.reflogexpireunreachable
1652                 gc.rerereresolved
1653                 gc.rerereunresolved
1654                 gitcvs.allbinary
1655                 gitcvs.commitmsgannotation
1656                 gitcvs.dbTableNamePrefix
1657                 gitcvs.dbdriver
1658                 gitcvs.dbname
1659                 gitcvs.dbpass
1660                 gitcvs.dbuser
1661                 gitcvs.enabled
1662                 gitcvs.logfile
1663                 gitcvs.usecrlfattr
1664                 guitool.
1665                 gui.blamehistoryctx
1666                 gui.commitmsgwidth
1667                 gui.copyblamethreshold
1668                 gui.diffcontext
1669                 gui.encoding
1670                 gui.fastcopyblame
1671                 gui.matchtrackingbranch
1672                 gui.newbranchtemplate
1673                 gui.pruneduringfetch
1674                 gui.spellingdictionary
1675                 gui.trustmtime
1676                 help.autocorrect
1677                 help.browser
1678                 help.format
1679                 http.lowSpeedLimit
1680                 http.lowSpeedTime
1681                 http.maxRequests
1682                 http.noEPSV
1683                 http.proxy
1684                 http.sslCAInfo
1685                 http.sslCAPath
1686                 http.sslCert
1687                 http.sslKey
1688                 http.sslVerify
1689                 i18n.commitEncoding
1690                 i18n.logOutputEncoding
1691                 imap.folder
1692                 imap.host
1693                 imap.pass
1694                 imap.port
1695                 imap.preformattedHTML
1696                 imap.sslverify
1697                 imap.tunnel
1698                 imap.user
1699                 instaweb.browser
1700                 instaweb.httpd
1701                 instaweb.local
1702                 instaweb.modulepath
1703                 instaweb.port
1704                 interactive.singlekey
1705                 log.date
1706                 log.showroot
1707                 mailmap.file
1708                 man.
1709                 man.viewer
1710                 merge.conflictstyle
1711                 merge.log
1712                 merge.renameLimit
1713                 merge.stat
1714                 merge.tool
1715                 merge.verbosity
1716                 mergetool.
1717                 mergetool.keepBackup
1718                 mergetool.prompt
1719                 pack.compression
1720                 pack.deltaCacheLimit
1721                 pack.deltaCacheSize
1722                 pack.depth
1723                 pack.indexVersion
1724                 pack.packSizeLimit
1725                 pack.threads
1726                 pack.window
1727                 pack.windowMemory
1728                 pager.
1729                 pull.octopus
1730                 pull.twohead
1731                 push.default
1732                 rebase.stat
1733                 receive.denyCurrentBranch
1734                 receive.denyDeletes
1735                 receive.denyNonFastForwards
1736                 receive.fsckObjects
1737                 receive.unpackLimit
1738                 repack.usedeltabaseoffset
1739                 rerere.autoupdate
1740                 rerere.enabled
1741                 sendemail.aliasesfile
1742                 sendemail.aliasesfiletype
1743                 sendemail.bcc
1744                 sendemail.cc
1745                 sendemail.cccmd
1746                 sendemail.chainreplyto
1747                 sendemail.confirm
1748                 sendemail.envelopesender
1749                 sendemail.multiedit
1750                 sendemail.signedoffbycc
1751                 sendemail.smtpencryption
1752                 sendemail.smtppass
1753                 sendemail.smtpserver
1754                 sendemail.smtpserverport
1755                 sendemail.smtpuser
1756                 sendemail.suppresscc
1757                 sendemail.suppressfrom
1758                 sendemail.thread
1759                 sendemail.to
1760                 sendemail.validate
1761                 showbranch.default
1762                 status.relativePaths
1763                 status.showUntrackedFiles
1764                 tar.umask
1765                 transfer.unpackLimit
1766                 url.
1767                 user.email
1768                 user.name
1769                 user.signingkey
1770                 web.browser
1771                 branch. remote.
1772         "
1773 }
1774
1775 _git_remote ()
1776 {
1777         local subcommands="add rename rm show prune update set-head"
1778         local subcommand="$(__git_find_on_cmdline "$subcommands")"
1779         if [ -z "$subcommand" ]; then
1780                 __gitcomp "$subcommands"
1781                 return
1782         fi
1783
1784         case "$subcommand" in
1785         rename|rm|show|prune)
1786                 __gitcomp "$(__git_remotes)"
1787                 ;;
1788         update)
1789                 local i c='' IFS=$'\n'
1790                 for i in $(git --git-dir="$(__gitdir)" config --get-regexp "remotes\..*" 2>/dev/null); do
1791                         i="${i#remotes.}"
1792                         c="$c ${i/ */}"
1793                 done
1794                 __gitcomp "$c"
1795                 ;;
1796         *)
1797                 COMPREPLY=()
1798                 ;;
1799         esac
1800 }
1801
1802 _git_replace ()
1803 {
1804         __gitcomp "$(__git_refs)"
1805 }
1806
1807 _git_reset ()
1808 {
1809         __git_has_doubledash && return
1810
1811         local cur="${COMP_WORDS[COMP_CWORD]}"
1812         case "$cur" in
1813         --*)
1814                 __gitcomp "--merge --mixed --hard --soft --patch"
1815                 return
1816                 ;;
1817         esac
1818         __gitcomp "$(__git_refs)"
1819 }
1820
1821 _git_revert ()
1822 {
1823         local cur="${COMP_WORDS[COMP_CWORD]}"
1824         case "$cur" in
1825         --*)
1826                 __gitcomp "--edit --mainline --no-edit --no-commit --signoff"
1827                 return
1828                 ;;
1829         esac
1830         __gitcomp "$(__git_refs)"
1831 }
1832
1833 _git_rm ()
1834 {
1835         __git_has_doubledash && return
1836
1837         local cur="${COMP_WORDS[COMP_CWORD]}"
1838         case "$cur" in
1839         --*)
1840                 __gitcomp "--cached --dry-run --ignore-unmatch --quiet"
1841                 return
1842                 ;;
1843         esac
1844         COMPREPLY=()
1845 }
1846
1847 _git_shortlog ()
1848 {
1849         __git_has_doubledash && return
1850
1851         local cur="${COMP_WORDS[COMP_CWORD]}"
1852         case "$cur" in
1853         --*)
1854                 __gitcomp "
1855                         $__git_log_common_options
1856                         $__git_log_shortlog_options
1857                         --numbered --summary
1858                         "
1859                 return
1860                 ;;
1861         esac
1862         __git_complete_revlist
1863 }
1864
1865 _git_show ()
1866 {
1867         __git_has_doubledash && return
1868
1869         local cur="${COMP_WORDS[COMP_CWORD]}"
1870         case "$cur" in
1871         --pretty=*)
1872                 __gitcomp "$__git_log_pretty_formats
1873                         " "" "${cur##--pretty=}"
1874                 return
1875                 ;;
1876         --format=*)
1877                 __gitcomp "$__git_log_pretty_formats
1878                         " "" "${cur##--format=}"
1879                 return
1880                 ;;
1881         --*)
1882                 __gitcomp "--pretty= --format= --abbrev-commit --oneline
1883                         $__git_diff_common_options
1884                         "
1885                 return
1886                 ;;
1887         esac
1888         __git_complete_file
1889 }
1890
1891 _git_show_branch ()
1892 {
1893         local cur="${COMP_WORDS[COMP_CWORD]}"
1894         case "$cur" in
1895         --*)
1896                 __gitcomp "
1897                         --all --remotes --topo-order --current --more=
1898                         --list --independent --merge-base --no-name
1899                         --color --no-color
1900                         --sha1-name --sparse --topics --reflog
1901                         "
1902                 return
1903                 ;;
1904         esac
1905         __git_complete_revlist
1906 }
1907
1908 _git_stash ()
1909 {
1910         local cur="${COMP_WORDS[COMP_CWORD]}"
1911         local save_opts='--keep-index --no-keep-index --quiet --patch'
1912         local subcommands='save list show apply clear drop pop create branch'
1913         local subcommand="$(__git_find_on_cmdline "$subcommands")"
1914         if [ -z "$subcommand" ]; then
1915                 case "$cur" in
1916                 --*)
1917                         __gitcomp "$save_opts"
1918                         ;;
1919                 *)
1920                         if [ -z "$(__git_find_on_cmdline "$save_opts")" ]; then
1921                                 __gitcomp "$subcommands"
1922                         else
1923                                 COMPREPLY=()
1924                         fi
1925                         ;;
1926                 esac
1927         else
1928                 case "$subcommand,$cur" in
1929                 save,--*)
1930                         __gitcomp "$save_opts"
1931                         ;;
1932                 apply,--*|pop,--*)
1933                         __gitcomp "--index --quiet"
1934                         ;;
1935                 show,--*|drop,--*|branch,--*)
1936                         COMPREPLY=()
1937                         ;;
1938                 show,*|apply,*|drop,*|pop,*|branch,*)
1939                         __gitcomp "$(git --git-dir="$(__gitdir)" stash list \
1940                                         | sed -n -e 's/:.*//p')"
1941                         ;;
1942                 *)
1943                         COMPREPLY=()
1944                         ;;
1945                 esac
1946         fi
1947 }
1948
1949 _git_submodule ()
1950 {
1951         __git_has_doubledash && return
1952
1953         local subcommands="add status init update summary foreach sync"
1954         if [ -z "$(__git_find_on_cmdline "$subcommands")" ]; then
1955                 local cur="${COMP_WORDS[COMP_CWORD]}"
1956                 case "$cur" in
1957                 --*)
1958                         __gitcomp "--quiet --cached"
1959                         ;;
1960                 *)
1961                         __gitcomp "$subcommands"
1962                         ;;
1963                 esac
1964                 return
1965         fi
1966 }
1967
1968 _git_svn ()
1969 {
1970         local subcommands="
1971                 init fetch clone rebase dcommit log find-rev
1972                 set-tree commit-diff info create-ignore propget
1973                 proplist show-ignore show-externals branch tag blame
1974                 migrate
1975                 "
1976         local subcommand="$(__git_find_on_cmdline "$subcommands")"
1977         if [ -z "$subcommand" ]; then
1978                 __gitcomp "$subcommands"
1979         else
1980                 local remote_opts="--username= --config-dir= --no-auth-cache"
1981                 local fc_opts="
1982                         --follow-parent --authors-file= --repack=
1983                         --no-metadata --use-svm-props --use-svnsync-props
1984                         --log-window-size= --no-checkout --quiet
1985                         --repack-flags --use-log-author --localtime
1986                         --ignore-paths= $remote_opts
1987                         "
1988                 local init_opts="
1989                         --template= --shared= --trunk= --tags=
1990                         --branches= --stdlayout --minimize-url
1991                         --no-metadata --use-svm-props --use-svnsync-props
1992                         --rewrite-root= --prefix= --use-log-author
1993                         --add-author-from $remote_opts
1994                         "
1995                 local cmt_opts="
1996                         --edit --rmdir --find-copies-harder --copy-similarity=
1997                         "
1998
1999                 local cur="${COMP_WORDS[COMP_CWORD]}"
2000                 case "$subcommand,$cur" in
2001                 fetch,--*)
2002                         __gitcomp "--revision= --fetch-all $fc_opts"
2003                         ;;
2004                 clone,--*)
2005                         __gitcomp "--revision= $fc_opts $init_opts"
2006                         ;;
2007                 init,--*)
2008                         __gitcomp "$init_opts"
2009                         ;;
2010                 dcommit,--*)
2011                         __gitcomp "
2012                                 --merge --strategy= --verbose --dry-run
2013                                 --fetch-all --no-rebase --commit-url
2014                                 --revision $cmt_opts $fc_opts
2015                                 "
2016                         ;;
2017                 set-tree,--*)
2018                         __gitcomp "--stdin $cmt_opts $fc_opts"
2019                         ;;
2020                 create-ignore,--*|propget,--*|proplist,--*|show-ignore,--*|\
2021                 show-externals,--*)
2022                         __gitcomp "--revision="
2023                         ;;
2024                 log,--*)
2025                         __gitcomp "
2026                                 --limit= --revision= --verbose --incremental
2027                                 --oneline --show-commit --non-recursive
2028                                 --authors-file= --color
2029                                 "
2030                         ;;
2031                 rebase,--*)
2032                         __gitcomp "
2033                                 --merge --verbose --strategy= --local
2034                                 --fetch-all --dry-run $fc_opts
2035                                 "
2036                         ;;
2037                 commit-diff,--*)
2038                         __gitcomp "--message= --file= --revision= $cmt_opts"
2039                         ;;
2040                 info,--*)
2041                         __gitcomp "--url"
2042                         ;;
2043                 branch,--*)
2044                         __gitcomp "--dry-run --message --tag"
2045                         ;;
2046                 tag,--*)
2047                         __gitcomp "--dry-run --message"
2048                         ;;
2049                 blame,--*)
2050                         __gitcomp "--git-format"
2051                         ;;
2052                 migrate,--*)
2053                         __gitcomp "
2054                                 --config-dir= --ignore-paths= --minimize
2055                                 --no-auth-cache --username=
2056                                 "
2057                         ;;
2058                 *)
2059                         COMPREPLY=()
2060                         ;;
2061                 esac
2062         fi
2063 }
2064
2065 _git_tag ()
2066 {
2067         local i c=1 f=0
2068         while [ $c -lt $COMP_CWORD ]; do
2069                 i="${COMP_WORDS[c]}"
2070                 case "$i" in
2071                 -d|-v)
2072                         __gitcomp "$(__git_tags)"
2073                         return
2074                         ;;
2075                 -f)
2076                         f=1
2077                         ;;
2078                 esac
2079                 c=$((++c))
2080         done
2081
2082         case "${COMP_WORDS[COMP_CWORD-1]}" in
2083         -m|-F)
2084                 COMPREPLY=()
2085                 ;;
2086         -*|tag)
2087                 if [ $f = 1 ]; then
2088                         __gitcomp "$(__git_tags)"
2089                 else
2090                         COMPREPLY=()
2091                 fi
2092                 ;;
2093         *)
2094                 __gitcomp "$(__git_refs)"
2095                 ;;
2096         esac
2097 }
2098
2099 _git ()
2100 {
2101         local i c=1 command __git_dir
2102
2103         while [ $c -lt $COMP_CWORD ]; do
2104                 i="${COMP_WORDS[c]}"
2105                 case "$i" in
2106                 --git-dir=*) __git_dir="${i#--git-dir=}" ;;
2107                 --bare)      __git_dir="." ;;
2108                 --version|-p|--paginate) ;;
2109                 --help) command="help"; break ;;
2110                 *) command="$i"; break ;;
2111                 esac
2112                 c=$((++c))
2113         done
2114
2115         if [ -z "$command" ]; then
2116                 case "${COMP_WORDS[COMP_CWORD]}" in
2117                 --*)   __gitcomp "
2118                         --paginate
2119                         --no-pager
2120                         --git-dir=
2121                         --bare
2122                         --version
2123                         --exec-path
2124                         --html-path
2125                         --work-tree=
2126                         --help
2127                         "
2128                         ;;
2129                 *)     __gitcomp "$(__git_porcelain_commands) $(__git_aliases)" ;;
2130                 esac
2131                 return
2132         fi
2133
2134         local expansion=$(__git_aliased_command "$command")
2135         [ "$expansion" ] && command="$expansion"
2136
2137         case "$command" in
2138         am)          _git_am ;;
2139         add)         _git_add ;;
2140         apply)       _git_apply ;;
2141         archive)     _git_archive ;;
2142         bisect)      _git_bisect ;;
2143         bundle)      _git_bundle ;;
2144         branch)      _git_branch ;;
2145         checkout)    _git_checkout ;;
2146         cherry)      _git_cherry ;;
2147         cherry-pick) _git_cherry_pick ;;
2148         clean)       _git_clean ;;
2149         clone)       _git_clone ;;
2150         commit)      _git_commit ;;
2151         config)      _git_config ;;
2152         describe)    _git_describe ;;
2153         diff)        _git_diff ;;
2154         difftool)    _git_difftool ;;
2155         fetch)       _git_fetch ;;
2156         format-patch) _git_format_patch ;;
2157         fsck)        _git_fsck ;;
2158         gc)          _git_gc ;;
2159         grep)        _git_grep ;;
2160         help)        _git_help ;;
2161         init)        _git_init ;;
2162         log)         _git_log ;;
2163         ls-files)    _git_ls_files ;;
2164         ls-remote)   _git_ls_remote ;;
2165         ls-tree)     _git_ls_tree ;;
2166         merge)       _git_merge;;
2167         mergetool)   _git_mergetool;;
2168         merge-base)  _git_merge_base ;;
2169         mv)          _git_mv ;;
2170         name-rev)    _git_name_rev ;;
2171         pull)        _git_pull ;;
2172         push)        _git_push ;;
2173         rebase)      _git_rebase ;;
2174         remote)      _git_remote ;;
2175         replace)     _git_replace ;;
2176         reset)       _git_reset ;;
2177         revert)      _git_revert ;;
2178         rm)          _git_rm ;;
2179         send-email)  _git_send_email ;;
2180         shortlog)    _git_shortlog ;;
2181         show)        _git_show ;;
2182         show-branch) _git_show_branch ;;
2183         stash)       _git_stash ;;
2184         stage)       _git_add ;;
2185         submodule)   _git_submodule ;;
2186         svn)         _git_svn ;;
2187         tag)         _git_tag ;;
2188         whatchanged) _git_log ;;
2189         *)           COMPREPLY=() ;;
2190         esac
2191 }
2192
2193 _gitk ()
2194 {
2195         __git_has_doubledash && return
2196
2197         local cur="${COMP_WORDS[COMP_CWORD]}"
2198         local g="$(__gitdir)"
2199         local merge=""
2200         if [ -f "$g/MERGE_HEAD" ]; then
2201                 merge="--merge"
2202         fi
2203         case "$cur" in
2204         --*)
2205                 __gitcomp "
2206                         $__git_log_common_options
2207                         $__git_log_gitk_options
2208                         $merge
2209                         "
2210                 return
2211                 ;;
2212         esac
2213         __git_complete_revlist
2214 }
2215
2216 complete -o bashdefault -o default -o nospace -F _git git 2>/dev/null \
2217         || complete -o default -o nospace -F _git git
2218 complete -o bashdefault -o default -o nospace -F _gitk gitk 2>/dev/null \
2219         || complete -o default -o nospace -F _gitk gitk
2220
2221 # The following are necessary only for Cygwin, and only are needed
2222 # when the user has tab-completed the executable name and consequently
2223 # included the '.exe' suffix.
2224 #
2225 if [ Cygwin = "$(uname -o 2>/dev/null)" ]; then
2226 complete -o bashdefault -o default -o nospace -F _git git.exe 2>/dev/null \
2227         || complete -o default -o nospace -F _git git.exe
2228 fi