git.oblomov.eu Git - git/blob - 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 fix"
 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_archive ()
 565 {
 566         local cur="${COMP_WORDS[COMP_CWORD]}"
 567         case "$cur" in
 568         --format=*)
 569                 __gitcomp "$(git archive --list)" "" "${cur##--format=}"
 570                 return
 571                 ;;
 572         --remote=*)
 573                 __gitcomp "$(__git_remotes)" "" "${cur##--remote=}"
 574                 return
 575                 ;;
 576         --*)
 577                 __gitcomp "
 578                         --format= --list --verbose
 579                         --prefix= --remote= --exec=
 580                         "
 581                 return
 582                 ;;
 583         esac
 584         __git_complete_file
 585 }
 586
 587 _git_bisect ()
 588 {
 589         __git_has_doubledash && return
 590
 591         local subcommands="start bad good skip reset visualize replay log run"
 592         local subcommand="$(__git_find_subcommand "$subcommands")"
 593         if [ -z "$subcommand" ]; then
 594                 __gitcomp "$subcommands"
 595                 return
 596         fi
 597
 598         case "$subcommand" in
 599         bad|good|reset|skip)
 600                 __gitcomp "$(__git_refs)"
 601                 ;;
 602         *)
 603                 COMPREPLY=()
 604                 ;;
 605         esac
 606 }
 607
 608 _git_branch ()
 609 {
 610         local i c=1 only_local_ref="n" has_r="n"
 611
 612         while [ $c -lt $COMP_CWORD ]; do
 613                 i="${COMP_WORDS[c]}"
 614                 case "$i" in
 615                 -d|-m)  only_local_ref="y" ;;
 616                 -r)     has_r="y" ;;
 617                 esac
 618                 c=$((++c))
 619         done
 620
 621         case "${COMP_WORDS[COMP_CWORD]}" in
 622         --*=*)  COMPREPLY=() ;;
 623         --*)
 624                 __gitcomp "
 625                         --color --no-color --verbose --abbrev= --no-abbrev
 626                         --track --no-track --contains --merged --no-merged
 627                         "
 628                 ;;
 629         *)
 630                 if [ $only_local_ref = "y" -a $has_r = "n" ]; then
 631                         __gitcomp "$(__git_heads)"
 632                 else
 633                         __gitcomp "$(__git_refs)"
 634                 fi
 635                 ;;
 636         esac
 637 }
 638
 639 _git_bundle ()
 640 {
 641         local mycword="$COMP_CWORD"
 642         case "${COMP_WORDS[0]}" in
 643         git)
 644                 local cmd="${COMP_WORDS[2]}"
 645                 mycword="$((mycword-1))"
 646                 ;;
 647         git-bundle*)
 648                 local cmd="${COMP_WORDS[1]}"
 649                 ;;
 650         esac
 651         case "$mycword" in
 652         1)
 653                 __gitcomp "create list-heads verify unbundle"
 654                 ;;
 655         2)
 656                 # looking for a file
 657                 ;;
 658         *)
 659                 case "$cmd" in
 660                         create)
 661                                 __git_complete_revlist
 662                         ;;
 663                 esac
 664                 ;;
 665         esac
 666 }
 667
 668 _git_checkout ()
 669 {
 670         __git_has_doubledash && return
 671
 672         __gitcomp "$(__git_refs)"
 673 }
 674
 675 _git_cherry ()
 676 {
 677         __gitcomp "$(__git_refs)"
 678 }
 679
 680 _git_cherry_pick ()
 681 {
 682         local cur="${COMP_WORDS[COMP_CWORD]}"
 683         case "$cur" in
 684         --*)
 685                 __gitcomp "--edit --no-commit"
 686                 ;;
 687         *)
 688                 __gitcomp "$(__git_refs)"
 689                 ;;
 690         esac
 691 }
 692
 693 _git_clean ()
 694 {
 695         __git_has_doubledash && return
 696
 697         local cur="${COMP_WORDS[COMP_CWORD]}"
 698         case "$cur" in
 699         --*)
 700                 __gitcomp "--dry-run --quiet"
 701                 return
 702                 ;;
 703         esac
 704         COMPREPLY=()
 705 }
 706
 707 _git_clone ()
 708 {
 709         local cur="${COMP_WORDS[COMP_CWORD]}"
 710         case "$cur" in
 711         --*)
 712                 __gitcomp "
 713                         --local
 714                         --no-hardlinks
 715                         --shared
 716                         --reference
 717                         --quiet
 718                         --no-checkout
 719                         --bare
 720                         --mirror
 721                         --origin
 722                         --upload-pack
 723                         --template=
 724                         --depth
 725                         "
 726                 return
 727                 ;;
 728         esac
 729         COMPREPLY=()
 730 }
 731
 732 _git_commit ()
 733 {
 734         __git_has_doubledash && return
 735
 736         local cur="${COMP_WORDS[COMP_CWORD]}"
 737         case "$cur" in
 738         --*)
 739                 __gitcomp "
 740                         --all --author= --signoff --verify --no-verify
 741                         --edit --amend --include --only
 742                         "
 743                 return
 744         esac
 745         COMPREPLY=()
 746 }
 747
 748 _git_describe ()
 749 {
 750         local cur="${COMP_WORDS[COMP_CWORD]}"
 751         case "$cur" in
 752         --*)
 753                 __gitcomp "
 754                         --all --tags --contains --abbrev= --candidates=
 755                         --exact-match --debug --long --match --always
 756                         "
 757                 return
 758         esac
 759         __gitcomp "$(__git_refs)"
 760 }
 761
 762 _git_diff ()
 763 {
 764         __git_has_doubledash && return
 765
 766         local cur="${COMP_WORDS[COMP_CWORD]}"
 767         case "$cur" in
 768         --*)
 769                 __gitcomp "--cached --stat --numstat --shortstat --summary
 770                         --patch-with-stat --name-only --name-status --color
 771                         --no-color --color-words --no-renames --check
 772                         --full-index --binary --abbrev --diff-filter
 773                         --find-copies-harder --pickaxe-all --pickaxe-regex
 774                         --text --ignore-space-at-eol --ignore-space-change
 775                         --ignore-all-space --exit-code --quiet --ext-diff
 776                         --no-ext-diff
 777                         --no-prefix --src-prefix= --dst-prefix=
 778                         --base --ours --theirs
 779                         "
 780                 return
 781                 ;;
 782         esac
 783         __git_complete_file
 784 }
 785
 786 _git_fetch ()
 787 {
 788         local cur="${COMP_WORDS[COMP_CWORD]}"
 789
 790         case "${COMP_WORDS[0]},$COMP_CWORD" in
 791         git-fetch*,1)
 792                 __gitcomp "$(__git_remotes)"
 793                 ;;
 794         git,2)
 795                 __gitcomp "$(__git_remotes)"
 796                 ;;
 797         *)
 798                 case "$cur" in
 799                 *:*)
 800                         local pfx=""
 801                         case "$COMP_WORDBREAKS" in
 802                         *:*) : great ;;
 803                         *)   pfx="${cur%%:*}:" ;;
 804                         esac
 805                         __gitcomp "$(__git_refs)" "$pfx" "${cur#*:}"
 806                         ;;
 807                 *)
 808                         local remote
 809                         case "${COMP_WORDS[0]}" in
 810                         git-fetch) remote="${COMP_WORDS[1]}" ;;
 811                         git)       remote="${COMP_WORDS[2]}" ;;
 812                         esac
 813                         __gitcomp "$(__git_refs2 "$remote")"
 814                         ;;
 815                 esac
 816                 ;;
 817         esac
 818 }
 819
 820 _git_format_patch ()
 821 {
 822         local cur="${COMP_WORDS[COMP_CWORD]}"
 823         case "$cur" in
 824         --*)
 825                 __gitcomp "
 826                         --stdout --attach --thread
 827                         --output-directory
 828                         --numbered --start-number
 829                         --numbered-files
 830                         --keep-subject
 831                         --signoff
 832                         --in-reply-to=
 833                         --full-index --binary
 834                         --not --all
 835                         --cover-letter
 836                         --no-prefix --src-prefix= --dst-prefix=
 837                         "
 838                 return
 839                 ;;
 840         esac
 841         __git_complete_revlist
 842 }
 843
 844 _git_gc ()
 845 {
 846         local cur="${COMP_WORDS[COMP_CWORD]}"
 847         case "$cur" in
 848         --*)
 849                 __gitcomp "--prune --aggressive"
 850                 return
 851                 ;;
 852         esac
 853         COMPREPLY=()
 854 }
 855
 856 _git_grep ()
 857 {
 858         __git_has_doubledash && return
 859
 860         local cur="${COMP_WORDS[COMP_CWORD]}"
 861         case "$cur" in
 862         --*)
 863                 __gitcomp "
 864                         --cached
 865                         --text --ignore-case --word-regexp --invert-match
 866                         --full-name
 867                         --extended-regexp --basic-regexp --fixed-strings
 868                         --files-with-matches --name-only
 869                         --files-without-match
 870                         --count
 871                         --and --or --not --all-match
 872                         "
 873                 return
 874                 ;;
 875         esac
 876         COMPREPLY=()
 877 }
 878
 879 _git_help ()
 880 {
 881         local cur="${COMP_WORDS[COMP_CWORD]}"
 882         case "$cur" in
 883         --*)
 884                 __gitcomp "--all --info --man --web"
 885                 return
 886                 ;;
 887         esac
 888         __gitcomp "$(__git_all_commands)
 889                 attributes cli core-tutorial cvs-migration
 890                 diffcore gitk glossary hooks ignore modules
 891                 repository-layout tutorial tutorial-2
 892                 "
 893 }
 894
 895 _git_init ()
 896 {
 897         local cur="${COMP_WORDS[COMP_CWORD]}"
 898         case "$cur" in
 899         --shared=*)
 900                 __gitcomp "
 901                         false true umask group all world everybody
 902                         " "" "${cur##--shared=}"
 903                 return
 904                 ;;
 905         --*)
 906                 __gitcomp "--quiet --bare --template= --shared --shared="
 907                 return
 908                 ;;
 909         esac
 910         COMPREPLY=()
 911 }
 912
 913 _git_ls_files ()
 914 {
 915         __git_has_doubledash && return
 916
 917         local cur="${COMP_WORDS[COMP_CWORD]}"
 918         case "$cur" in
 919         --*)
 920                 __gitcomp "--cached --deleted --modified --others --ignored
 921                         --stage --directory --no-empty-directory --unmerged
 922                         --killed --exclude= --exclude-from=
 923                         --exclude-per-directory= --exclude-standard
 924                         --error-unmatch --with-tree= --full-name
 925                         --abbrev --ignored --exclude-per-directory
 926                         "
 927                 return
 928                 ;;
 929         esac
 930         COMPREPLY=()
 931 }
 932
 933 _git_ls_remote ()
 934 {
 935         __gitcomp "$(__git_remotes)"
 936 }
 937
 938 _git_ls_tree ()
 939 {
 940         __git_complete_file
 941 }
 942
 943 _git_log ()
 944 {
 945         __git_has_doubledash && return
 946
 947         local cur="${COMP_WORDS[COMP_CWORD]}"
 948         case "$cur" in
 949         --pretty=*)
 950                 __gitcomp "
 951                         oneline short medium full fuller email raw
 952                         " "" "${cur##--pretty=}"
 953                 return
 954                 ;;
 955         --date=*)
 956                 __gitcomp "
 957                         relative iso8601 rfc2822 short local default
 958                 " "" "${cur##--date=}"
 959                 return
 960                 ;;
 961         --*)
 962                 __gitcomp "
 963                         --max-count= --max-age= --since= --after=
 964                         --min-age= --before= --until=
 965                         --root --topo-order --date-order --reverse
 966                         --no-merges --follow
 967                         --abbrev-commit --abbrev=
 968                         --relative-date --date=
 969                         --author= --committer= --grep=
 970                         --all-match
 971                         --pretty= --name-status --name-only --raw
 972                         --not --all
 973                         --left-right --cherry-pick
 974                         --graph
 975                         --stat --numstat --shortstat
 976                         --decorate --diff-filter=
 977                         --color-words --walk-reflogs
 978                         --parents --children --full-history
 979                         --merge
 980                         "
 981                 return
 982                 ;;
 983         esac
 984         __git_complete_revlist
 985 }
 986
 987 _git_merge ()
 988 {
 989         local cur="${COMP_WORDS[COMP_CWORD]}"
 990         case "${COMP_WORDS[COMP_CWORD-1]}" in
 991         -s|--strategy)
 992                 __gitcomp "$(__git_merge_strategies)"
 993                 return
 994         esac
 995         case "$cur" in
 996         --strategy=*)
 997                 __gitcomp "$(__git_merge_strategies)" "" "${cur##--strategy=}"
 998                 return
 999                 ;;
1000         --*)
1001                 __gitcomp "
1002                         --no-commit --no-stat --log --no-log --squash --strategy
1003                         "
1004                 return
1005         esac
1006         __gitcomp "$(__git_refs)"
1007 }
1008
1009 _git_mergetool ()
1010 {
1011         local cur="${COMP_WORDS[COMP_CWORD]}"
1012         case "$cur" in
1013         --tool=*)
1014                 __gitcomp "
1015                         kdiff3 tkdiff meld xxdiff emerge
1016                         vimdiff gvimdiff ecmerge opendiff
1017                         " "" "${cur##--tool=}"
1018                 return
1019                 ;;
1020         --*)
1021                 __gitcomp "--tool="
1022                 return
1023                 ;;
1024         esac
1025         COMPREPLY=()
1026 }
1027
1028 _git_merge_base ()
1029 {
1030         __gitcomp "$(__git_refs)"
1031 }
1032
1033 _git_mv ()
1034 {
1035         local cur="${COMP_WORDS[COMP_CWORD]}"
1036         case "$cur" in
1037         --*)
1038                 __gitcomp "--dry-run"
1039                 return
1040                 ;;
1041         esac
1042         COMPREPLY=()
1043 }
1044
1045 _git_name_rev ()
1046 {
1047         __gitcomp "--tags --all --stdin"
1048 }
1049
1050 _git_pull ()
1051 {
1052         local cur="${COMP_WORDS[COMP_CWORD]}"
1053
1054         case "${COMP_WORDS[0]},$COMP_CWORD" in
1055         git-pull*,1)
1056                 __gitcomp "$(__git_remotes)"
1057                 ;;
1058         git,2)
1059                 __gitcomp "$(__git_remotes)"
1060                 ;;
1061         *)
1062                 local remote
1063                 case "${COMP_WORDS[0]}" in
1064                 git-pull)  remote="${COMP_WORDS[1]}" ;;
1065                 git)       remote="${COMP_WORDS[2]}" ;;
1066                 esac
1067                 __gitcomp "$(__git_refs "$remote")"
1068                 ;;
1069         esac
1070 }
1071
1072 _git_push ()
1073 {
1074         local cur="${COMP_WORDS[COMP_CWORD]}"
1075
1076         case "${COMP_WORDS[0]},$COMP_CWORD" in
1077         git-push*,1)
1078                 __gitcomp "$(__git_remotes)"
1079                 ;;
1080         git,2)
1081                 __gitcomp "$(__git_remotes)"
1082                 ;;
1083         *)
1084                 case "$cur" in
1085                 *:*)
1086                         local remote
1087                         case "${COMP_WORDS[0]}" in
1088                         git-push)  remote="${COMP_WORDS[1]}" ;;
1089                         git)       remote="${COMP_WORDS[2]}" ;;
1090                         esac
1091
1092                         local pfx=""
1093                         case "$COMP_WORDBREAKS" in
1094                         *:*) : great ;;
1095                         *)   pfx="${cur%%:*}:" ;;
1096                         esac
1097
1098                         __gitcomp "$(__git_refs "$remote")" "$pfx" "${cur#*:}"
1099                         ;;
1100                 +*)
1101                         __gitcomp "$(__git_refs)" + "${cur#+}"
1102                         ;;
1103                 *)
1104                         __gitcomp "$(__git_refs)"
1105                         ;;
1106                 esac
1107                 ;;
1108         esac
1109 }
1110
1111 _git_rebase ()
1112 {
1113         local cur="${COMP_WORDS[COMP_CWORD]}" dir="$(__gitdir)"
1114         if [ -d "$dir"/rebase-apply ] || [ -d "$dir"/rebase-merge ]; then
1115                 __gitcomp "--continue --skip --abort"
1116                 return
1117         fi
1118         case "${COMP_WORDS[COMP_CWORD-1]}" in
1119         -s|--strategy)
1120                 __gitcomp "$(__git_merge_strategies)"
1121                 return
1122         esac
1123         case "$cur" in
1124         --strategy=*)
1125                 __gitcomp "$(__git_merge_strategies)" "" "${cur##--strategy=}"
1126                 return
1127                 ;;
1128         --*)
1129                 __gitcomp "--onto --merge --strategy --interactive"
1130                 return
1131         esac
1132         __gitcomp "$(__git_refs)"
1133 }
1134
1135 _git_send_email ()
1136 {
1137         local cur="${COMP_WORDS[COMP_CWORD]}"
1138         case "$cur" in
1139         --*)
1140                 __gitcomp "--bcc --cc --cc-cmd --chain-reply-to --compose
1141                         --dry-run --envelope-sender --from --identity
1142                         --in-reply-to --no-chain-reply-to --no-signed-off-by-cc
1143                         --no-suppress-from --no-thread --quiet
1144                         --signed-off-by-cc --smtp-pass --smtp-server
1145                         --smtp-server-port --smtp-ssl --smtp-user --subject
1146                         --suppress-cc --suppress-from --thread --to"
1147                 return
1148                 ;;
1149         esac
1150         COMPREPLY=()
1151 }
1152
1153 _git_config ()
1154 {
1155         local cur="${COMP_WORDS[COMP_CWORD]}"
1156         local prv="${COMP_WORDS[COMP_CWORD-1]}"
1157         case "$prv" in
1158         branch.*.remote)
1159                 __gitcomp "$(__git_remotes)"
1160                 return
1161                 ;;
1162         branch.*.merge)
1163                 __gitcomp "$(__git_refs)"
1164                 return
1165                 ;;
1166         remote.*.fetch)
1167                 local remote="${prv#remote.}"
1168                 remote="${remote%.fetch}"
1169                 __gitcomp "$(__git_refs_remotes "$remote")"
1170                 return
1171                 ;;
1172         remote.*.push)
1173                 local remote="${prv#remote.}"
1174                 remote="${remote%.push}"
1175                 __gitcomp "$(git --git-dir="$(__gitdir)" \
1176                         for-each-ref --format='%(refname):%(refname)' \
1177                         refs/heads)"
1178                 return
1179                 ;;
1180         pull.twohead|pull.octopus)
1181                 __gitcomp "$(__git_merge_strategies)"
1182                 return
1183                 ;;
1184         color.branch|color.diff|color.status)
1185                 __gitcomp "always never auto"
1186                 return
1187                 ;;
1188         color.*.*)
1189                 __gitcomp "
1190                         black red green yellow blue magenta cyan white
1191                         bold dim ul blink reverse
1192                         "
1193                 return
1194                 ;;
1195         *.*)
1196                 COMPREPLY=()
1197                 return
1198                 ;;
1199         esac
1200         case "$cur" in
1201         --*)
1202                 __gitcomp "
1203                         --global --system --file=
1204                         --list --replace-all
1205                         --get --get-all --get-regexp
1206                         --add --unset --unset-all
1207                         --remove-section --rename-section
1208                         "
1209                 return
1210                 ;;
1211         branch.*.*)
1212                 local pfx="${cur%.*}."
1213                 cur="${cur##*.}"
1214                 __gitcomp "remote merge" "$pfx" "$cur"
1215                 return
1216                 ;;
1217         branch.*)
1218                 local pfx="${cur%.*}."
1219                 cur="${cur#*.}"
1220                 __gitcomp "$(__git_heads)" "$pfx" "$cur" "."
1221                 return
1222                 ;;
1223         remote.*.*)
1224                 local pfx="${cur%.*}."
1225                 cur="${cur##*.}"
1226                 __gitcomp "
1227                         url fetch push skipDefaultUpdate
1228                         receivepack uploadpack tagopt
1229                         " "$pfx" "$cur"
1230                 return
1231                 ;;
1232         remote.*)
1233                 local pfx="${cur%.*}."
1234                 cur="${cur#*.}"
1235                 __gitcomp "$(__git_remotes)" "$pfx" "$cur" "."
1236                 return
1237                 ;;
1238         esac
1239         __gitcomp "
1240                 apply.whitespace
1241                 core.fileMode
1242                 core.gitProxy
1243                 core.ignoreStat
1244                 core.preferSymlinkRefs
1245                 core.logAllRefUpdates
1246                 core.loosecompression
1247                 core.repositoryFormatVersion
1248                 core.sharedRepository
1249                 core.warnAmbiguousRefs
1250                 core.compression
1251                 core.packedGitWindowSize
1252                 core.packedGitLimit
1253                 clean.requireForce
1254                 color.branch
1255                 color.branch.current
1256                 color.branch.local
1257                 color.branch.remote
1258                 color.branch.plain
1259                 color.diff
1260                 color.diff.plain
1261                 color.diff.meta
1262                 color.diff.frag
1263                 color.diff.old
1264                 color.diff.new
1265                 color.diff.commit
1266                 color.diff.whitespace
1267                 color.pager
1268                 color.status
1269                 color.status.header
1270                 color.status.added
1271                 color.status.changed
1272                 color.status.untracked
1273                 diff.renameLimit
1274                 diff.renames
1275                 fetch.unpackLimit
1276                 format.headers
1277                 format.subjectprefix
1278                 gitcvs.enabled
1279                 gitcvs.logfile
1280                 gitcvs.allbinary
1281                 gitcvs.dbname gitcvs.dbdriver gitcvs.dbuser gitcvs.dbpass
1282                 gitcvs.dbtablenameprefix
1283                 gc.packrefs
1284                 gc.reflogexpire
1285                 gc.reflogexpireunreachable
1286                 gc.rerereresolved
1287                 gc.rerereunresolved
1288                 http.sslVerify
1289                 http.sslCert
1290                 http.sslKey
1291                 http.sslCAInfo
1292                 http.sslCAPath
1293                 http.maxRequests
1294                 http.lowSpeedLimit
1295                 http.lowSpeedTime
1296                 http.noEPSV
1297                 i18n.commitEncoding
1298                 i18n.logOutputEncoding
1299                 log.showroot
1300                 merge.tool
1301                 merge.summary
1302                 merge.verbosity
1303                 pack.window
1304                 pack.depth
1305                 pack.windowMemory
1306                 pack.compression
1307                 pack.deltaCacheSize
1308                 pack.deltaCacheLimit
1309                 pull.octopus
1310                 pull.twohead
1311                 repack.useDeltaBaseOffset
1312                 showbranch.default
1313                 tar.umask
1314                 transfer.unpackLimit
1315                 receive.unpackLimit
1316                 receive.denyNonFastForwards
1317                 user.name
1318                 user.email
1319                 user.signingkey
1320                 branch. remote.
1321         "
1322 }
1323
1324 _git_remote ()
1325 {
1326         local subcommands="add rm show prune update"
1327         local subcommand="$(__git_find_subcommand "$subcommands")"
1328         if [ -z "$subcommand" ]; then
1329                 __gitcomp "$subcommands"
1330                 return
1331         fi
1332
1333         case "$subcommand" in
1334         rm|show|prune)
1335                 __gitcomp "$(__git_remotes)"
1336                 ;;
1337         update)
1338                 local i c='' IFS=$'\n'
1339                 for i in $(git --git-dir="$(__gitdir)" config --list); do
1340                         case "$i" in
1341                         remotes.*)
1342                                 i="${i#remotes.}"
1343                                 c="$c ${i/=*/}"
1344                                 ;;
1345                         esac
1346                 done
1347                 __gitcomp "$c"
1348                 ;;
1349         *)
1350                 COMPREPLY=()
1351                 ;;
1352         esac
1353 }
1354
1355 _git_reset ()
1356 {
1357         __git_has_doubledash && return
1358
1359         local cur="${COMP_WORDS[COMP_CWORD]}"
1360         case "$cur" in
1361         --*)
1362                 __gitcomp "--mixed --hard --soft"
1363                 return
1364                 ;;
1365         esac
1366         __gitcomp "$(__git_refs)"
1367 }
1368
1369 _git_revert ()
1370 {
1371         local cur="${COMP_WORDS[COMP_CWORD]}"
1372         case "$cur" in
1373         --*)
1374                 __gitcomp "--edit --mainline --no-edit --no-commit --signoff"
1375                 return
1376                 ;;
1377         esac
1378         COMPREPLY=()
1379 }
1380
1381 _git_rm ()
1382 {
1383         __git_has_doubledash && return
1384
1385         local cur="${COMP_WORDS[COMP_CWORD]}"
1386         case "$cur" in
1387         --*)
1388                 __gitcomp "--cached --dry-run --ignore-unmatch --quiet"
1389                 return
1390                 ;;
1391         esac
1392         COMPREPLY=()
1393 }
1394
1395 _git_shortlog ()
1396 {
1397         __git_has_doubledash && return
1398
1399         local cur="${COMP_WORDS[COMP_CWORD]}"
1400         case "$cur" in
1401         --*)
1402                 __gitcomp "
1403                         --max-count= --max-age= --since= --after=
1404                         --min-age= --before= --until=
1405                         --no-merges
1406                         --author= --committer= --grep=
1407                         --all-match
1408                         --not --all
1409                         --numbered --summary
1410                         "
1411                 return
1412                 ;;
1413         esac
1414         __git_complete_revlist
1415 }
1416
1417 _git_show ()
1418 {
1419         local cur="${COMP_WORDS[COMP_CWORD]}"
1420         case "$cur" in
1421         --pretty=*)
1422                 __gitcomp "
1423                         oneline short medium full fuller email raw
1424                         " "" "${cur##--pretty=}"
1425                 return
1426                 ;;
1427         --*)
1428                 __gitcomp "--pretty="
1429                 return
1430                 ;;
1431         esac
1432         __git_complete_file
1433 }
1434
1435 _git_show_branch ()
1436 {
1437         local cur="${COMP_WORDS[COMP_CWORD]}"
1438         case "$cur" in
1439         --*)
1440                 __gitcomp "
1441                         --all --remotes --topo-order --current --more=
1442                         --list --independent --merge-base --no-name
1443                         --sha1-name --topics --reflog
1444                         "
1445                 return
1446                 ;;
1447         esac
1448         __git_complete_revlist
1449 }
1450
1451 _git_stash ()
1452 {
1453         local subcommands='save list show apply clear drop pop create branch'
1454         local subcommand="$(__git_find_subcommand "$subcommands")"
1455         if [ -z "$subcommand" ]; then
1456                 __gitcomp "$subcommands"
1457         else
1458                 local cur="${COMP_WORDS[COMP_CWORD]}"
1459                 case "$subcommand,$cur" in
1460                 save,--*)
1461                         __gitcomp "--keep-index"
1462                         ;;
1463                 apply,--*)
1464                         __gitcomp "--index"
1465                         ;;
1466                 show,--*|drop,--*|pop,--*|branch,--*)
1467                         COMPREPLY=()
1468                         ;;
1469                 show,*|apply,*|drop,*|pop,*|branch,*)
1470                         __gitcomp "$(git --git-dir="$(__gitdir)" stash list \
1471                                         | sed -n -e 's/:.*//p')"
1472                         ;;
1473                 *)
1474                         COMPREPLY=()
1475                         ;;
1476                 esac
1477         fi
1478 }
1479
1480 _git_submodule ()
1481 {
1482         __git_has_doubledash && return
1483
1484         local subcommands="add status init update"
1485         if [ -z "$(__git_find_subcommand "$subcommands")" ]; then
1486                 local cur="${COMP_WORDS[COMP_CWORD]}"
1487                 case "$cur" in
1488                 --*)
1489                         __gitcomp "--quiet --cached"
1490                         ;;
1491                 *)
1492                         __gitcomp "$subcommands"
1493                         ;;
1494                 esac
1495                 return
1496         fi
1497 }
1498
1499 _git_svn ()
1500 {
1501         local subcommands="
1502                 init fetch clone rebase dcommit log find-rev
1503                 set-tree commit-diff info create-ignore propget
1504                 proplist show-ignore show-externals
1505                 "
1506         local subcommand="$(__git_find_subcommand "$subcommands")"
1507         if [ -z "$subcommand" ]; then
1508                 __gitcomp "$subcommands"
1509         else
1510                 local remote_opts="--username= --config-dir= --no-auth-cache"
1511                 local fc_opts="
1512                         --follow-parent --authors-file= --repack=
1513                         --no-metadata --use-svm-props --use-svnsync-props
1514                         --log-window-size= --no-checkout --quiet
1515                         --repack-flags --user-log-author $remote_opts
1516                         "
1517                 local init_opts="
1518                         --template= --shared= --trunk= --tags=
1519                         --branches= --stdlayout --minimize-url
1520                         --no-metadata --use-svm-props --use-svnsync-props
1521                         --rewrite-root= $remote_opts
1522                         "
1523                 local cmt_opts="
1524                         --edit --rmdir --find-copies-harder --copy-similarity=
1525                         "
1526
1527                 local cur="${COMP_WORDS[COMP_CWORD]}"
1528                 case "$subcommand,$cur" in
1529                 fetch,--*)
1530                         __gitcomp "--revision= --fetch-all $fc_opts"
1531                         ;;
1532                 clone,--*)
1533                         __gitcomp "--revision= $fc_opts $init_opts"
1534                         ;;
1535                 init,--*)
1536                         __gitcomp "$init_opts"
1537                         ;;
1538                 dcommit,--*)
1539                         __gitcomp "
1540                                 --merge --strategy= --verbose --dry-run
1541                                 --fetch-all --no-rebase $cmt_opts $fc_opts
1542                                 "
1543                         ;;
1544                 set-tree,--*)
1545                         __gitcomp "--stdin $cmt_opts $fc_opts"
1546                         ;;
1547                 create-ignore,--*|propget,--*|proplist,--*|show-ignore,--*|\
1548                 show-externals,--*)
1549                         __gitcomp "--revision="
1550                         ;;
1551                 log,--*)
1552                         __gitcomp "
1553                                 --limit= --revision= --verbose --incremental
1554                                 --oneline --show-commit --non-recursive
1555                                 --authors-file=
1556                                 "
1557                         ;;
1558                 rebase,--*)
1559                         __gitcomp "
1560                                 --merge --verbose --strategy= --local
1561                                 --fetch-all $fc_opts
1562                                 "
1563                         ;;
1564                 commit-diff,--*)
1565                         __gitcomp "--message= --file= --revision= $cmt_opts"
1566                         ;;
1567                 info,--*)
1568                         __gitcomp "--url"
1569                         ;;
1570                 *)
1571                         COMPREPLY=()
1572                         ;;
1573                 esac
1574         fi
1575 }
1576
1577 _git_tag ()
1578 {
1579         local i c=1 f=0
1580         while [ $c -lt $COMP_CWORD ]; do
1581                 i="${COMP_WORDS[c]}"
1582                 case "$i" in
1583                 -d|-v)
1584                         __gitcomp "$(__git_tags)"
1585                         return
1586                         ;;
1587                 -f)
1588                         f=1
1589                         ;;
1590                 esac
1591                 c=$((++c))
1592         done
1593
1594         case "${COMP_WORDS[COMP_CWORD-1]}" in
1595         -m|-F)
1596                 COMPREPLY=()
1597                 ;;
1598         -*|tag|git-tag)
1599                 if [ $f = 1 ]; then
1600                         __gitcomp "$(__git_tags)"
1601                 else
1602                         COMPREPLY=()
1603                 fi
1604                 ;;
1605         *)
1606                 __gitcomp "$(__git_refs)"
1607                 ;;
1608         esac
1609 }
1610
1611 _git ()
1612 {
1613         local i c=1 command __git_dir
1614
1615         while [ $c -lt $COMP_CWORD ]; do
1616                 i="${COMP_WORDS[c]}"
1617                 case "$i" in
1618                 --git-dir=*) __git_dir="${i#--git-dir=}" ;;
1619                 --bare)      __git_dir="." ;;
1620                 --version|-p|--paginate) ;;
1621                 --help) command="help"; break ;;
1622                 *) command="$i"; break ;;
1623                 esac
1624                 c=$((++c))
1625         done
1626
1627         if [ -z "$command" ]; then
1628                 case "${COMP_WORDS[COMP_CWORD]}" in
1629                 --*=*) COMPREPLY=() ;;
1630                 --*)   __gitcomp "
1631                         --paginate
1632                         --no-pager
1633                         --git-dir=
1634                         --bare
1635                         --version
1636                         --exec-path
1637                         --work-tree=
1638                         --help
1639                         "
1640                         ;;
1641                 *)     __gitcomp "$(__git_porcelain_commands) $(__git_aliases)" ;;
1642                 esac
1643                 return
1644         fi
1645
1646         local expansion=$(__git_aliased_command "$command")
1647         [ "$expansion" ] && command="$expansion"
1648
1649         case "$command" in
1650         am)          _git_am ;;
1651         add)         _git_add ;;
1652         apply)       _git_apply ;;
1653         archive)     _git_archive ;;
1654         bisect)      _git_bisect ;;
1655         bundle)      _git_bundle ;;
1656         branch)      _git_branch ;;
1657         checkout)    _git_checkout ;;
1658         cherry)      _git_cherry ;;
1659         cherry-pick) _git_cherry_pick ;;
1660         clean)       _git_clean ;;
1661         clone)       _git_clone ;;
1662         commit)      _git_commit ;;
1663         config)      _git_config ;;
1664         describe)    _git_describe ;;
1665         diff)        _git_diff ;;
1666         fetch)       _git_fetch ;;
1667         format-patch) _git_format_patch ;;
1668         gc)          _git_gc ;;
1669         grep)        _git_grep ;;
1670         help)        _git_help ;;
1671         init)        _git_init ;;
1672         log)         _git_log ;;
1673         ls-files)    _git_ls_files ;;
1674         ls-remote)   _git_ls_remote ;;
1675         ls-tree)     _git_ls_tree ;;
1676         merge)       _git_merge;;
1677         mergetool)   _git_mergetool;;
1678         merge-base)  _git_merge_base ;;
1679         mv)          _git_mv ;;
1680         name-rev)    _git_name_rev ;;
1681         pull)        _git_pull ;;
1682         push)        _git_push ;;
1683         rebase)      _git_rebase ;;
1684         remote)      _git_remote ;;
1685         reset)       _git_reset ;;
1686         revert)      _git_revert ;;
1687         rm)          _git_rm ;;
1688         send-email)  _git_send_email ;;
1689         shortlog)    _git_shortlog ;;
1690         show)        _git_show ;;
1691         show-branch) _git_show_branch ;;
1692         stash)       _git_stash ;;
1693         submodule)   _git_submodule ;;
1694         svn)         _git_svn ;;
1695         tag)         _git_tag ;;
1696         whatchanged) _git_log ;;
1697         *)           COMPREPLY=() ;;
1698         esac
1699 }
1700
1701 _gitk ()
1702 {
1703         __git_has_doubledash && return
1704
1705         local cur="${COMP_WORDS[COMP_CWORD]}"
1706         local g="$(git rev-parse --git-dir 2>/dev/null)"
1707         local merge=""
1708         if [ -f $g/MERGE_HEAD ]; then
1709                 merge="--merge"
1710         fi
1711         case "$cur" in
1712         --*)
1713                 __gitcomp "--not --all $merge"
1714                 return
1715                 ;;
1716         esac
1717         __git_complete_revlist
1718 }
1719
1720 complete -o default -o nospace -F _git git
1721 complete -o default -o nospace -F _gitk gitk
1722
1723 # The following are necessary only for Cygwin, and only are needed
1724 # when the user has tab-completed the executable name and consequently
1725 # included the '.exe' suffix.
1726 #
1727 if [ Cygwin = "$(uname -o 2>/dev/null)" ]; then
1728 complete -o default -o nospace -F _git git.exe
1729 fi