contrib/completion/git-completion.bash

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