contrib/completion/git-completion.bash

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