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