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         local cur="${COMP_WORDS[COMP_CWORD]}"
1414         case "$cur" in
1415         --pretty=*)
1416                 __gitcomp "
1417                         oneline short medium full fuller email raw
1418                         " "" "${cur##--pretty=}"
1419                 return
1420                 ;;
1421         --*)
1422                 __gitcomp "--pretty="
1423                 return
1424                 ;;
1425         esac
1426         __git_complete_file
1427 }
1428
1429 _git_show_branch ()
1430 {
1431         local cur="${COMP_WORDS[COMP_CWORD]}"
1432         case "$cur" in
1433         --*)
1434                 __gitcomp "
1435                         --all --remotes --topo-order --current --more=
1436                         --list --independent --merge-base --no-name
1437                         --sha1-name --topics --reflog
1438                         "
1439                 return
1440                 ;;
1441         esac
1442         __git_complete_revlist
1443 }
1444
1445 _git_stash ()
1446 {
1447         local subcommands='save list show apply clear drop pop create branch'
1448         local subcommand="$(__git_find_subcommand "$subcommands")"
1449         if [ -z "$subcommand" ]; then
1450                 __gitcomp "$subcommands"
1451         else
1452                 local cur="${COMP_WORDS[COMP_CWORD]}"
1453                 case "$subcommand,$cur" in
1454                 save,--*)
1455                         __gitcomp "--keep-index"
1456                         ;;
1457                 apply,--*)
1458                         __gitcomp "--index"
1459                         ;;
1460                 show,--*|drop,--*|pop,--*|branch,--*)
1461                         COMPREPLY=()
1462                         ;;
1463                 show,*|apply,*|drop,*|pop,*|branch,*)
1464                         __gitcomp "$(git --git-dir="$(__gitdir)" stash list \
1465                                         | sed -n -e 's/:.*//p')"
1466                         ;;
1467                 *)
1468                         COMPREPLY=()
1469                         ;;
1470                 esac
1471         fi
1472 }
1473
1474 _git_submodule ()
1475 {
1476         __git_has_doubledash && return
1477
1478         local subcommands="add status init update"
1479         if [ -z "$(__git_find_subcommand "$subcommands")" ]; then
1480                 local cur="${COMP_WORDS[COMP_CWORD]}"
1481                 case "$cur" in
1482                 --*)
1483                         __gitcomp "--quiet --cached"
1484                         ;;
1485                 *)
1486                         __gitcomp "$subcommands"
1487                         ;;
1488                 esac
1489                 return
1490         fi
1491 }
1492
1493 _git_svn ()
1494 {
1495         local subcommands="
1496                 init fetch clone rebase dcommit log find-rev
1497                 set-tree commit-diff info create-ignore propget
1498                 proplist show-ignore show-externals
1499                 "
1500         local subcommand="$(__git_find_subcommand "$subcommands")"
1501         if [ -z "$subcommand" ]; then
1502                 __gitcomp "$subcommands"
1503         else
1504                 local remote_opts="--username= --config-dir= --no-auth-cache"
1505                 local fc_opts="
1506                         --follow-parent --authors-file= --repack=
1507                         --no-metadata --use-svm-props --use-svnsync-props
1508                         --log-window-size= --no-checkout --quiet
1509                         --repack-flags --user-log-author $remote_opts
1510                         "
1511                 local init_opts="
1512                         --template= --shared= --trunk= --tags=
1513                         --branches= --stdlayout --minimize-url
1514                         --no-metadata --use-svm-props --use-svnsync-props
1515                         --rewrite-root= $remote_opts
1516                         "
1517                 local cmt_opts="
1518                         --edit --rmdir --find-copies-harder --copy-similarity=
1519                         "
1520
1521                 local cur="${COMP_WORDS[COMP_CWORD]}"
1522                 case "$subcommand,$cur" in
1523                 fetch,--*)
1524                         __gitcomp "--revision= --fetch-all $fc_opts"
1525                         ;;
1526                 clone,--*)
1527                         __gitcomp "--revision= $fc_opts $init_opts"
1528                         ;;
1529                 init,--*)
1530                         __gitcomp "$init_opts"
1531                         ;;
1532                 dcommit,--*)
1533                         __gitcomp "
1534                                 --merge --strategy= --verbose --dry-run
1535                                 --fetch-all --no-rebase $cmt_opts $fc_opts
1536                                 "
1537                         ;;
1538                 set-tree,--*)
1539                         __gitcomp "--stdin $cmt_opts $fc_opts"
1540                         ;;
1541                 create-ignore,--*|propget,--*|proplist,--*|show-ignore,--*|\
1542                 show-externals,--*)
1543                         __gitcomp "--revision="
1544                         ;;
1545                 log,--*)
1546                         __gitcomp "
1547                                 --limit= --revision= --verbose --incremental
1548                                 --oneline --show-commit --non-recursive
1549                                 --authors-file=
1550                                 "
1551                         ;;
1552                 rebase,--*)
1553                         __gitcomp "
1554                                 --merge --verbose --strategy= --local
1555                                 --fetch-all $fc_opts
1556                                 "
1557                         ;;
1558                 commit-diff,--*)
1559                         __gitcomp "--message= --file= --revision= $cmt_opts"
1560                         ;;
1561                 info,--*)
1562                         __gitcomp "--url"
1563                         ;;
1564                 *)
1565                         COMPREPLY=()
1566                         ;;
1567                 esac
1568         fi
1569 }
1570
1571 _git_tag ()
1572 {
1573         local i c=1 f=0
1574         while [ $c -lt $COMP_CWORD ]; do
1575                 i="${COMP_WORDS[c]}"
1576                 case "$i" in
1577                 -d|-v)
1578                         __gitcomp "$(__git_tags)"
1579                         return
1580                         ;;
1581                 -f)
1582                         f=1
1583                         ;;
1584                 esac
1585                 c=$((++c))
1586         done
1587
1588         case "${COMP_WORDS[COMP_CWORD-1]}" in
1589         -m|-F)
1590                 COMPREPLY=()
1591                 ;;
1592         -*|tag|git-tag)
1593                 if [ $f = 1 ]; then
1594                         __gitcomp "$(__git_tags)"
1595                 else
1596                         COMPREPLY=()
1597                 fi
1598                 ;;
1599         *)
1600                 __gitcomp "$(__git_refs)"
1601                 ;;
1602         esac
1603 }
1604
1605 _git ()
1606 {
1607         local i c=1 command __git_dir
1608
1609         while [ $c -lt $COMP_CWORD ]; do
1610                 i="${COMP_WORDS[c]}"
1611                 case "$i" in
1612                 --git-dir=*) __git_dir="${i#--git-dir=}" ;;
1613                 --bare)      __git_dir="." ;;
1614                 --version|-p|--paginate) ;;
1615                 --help) command="help"; break ;;
1616                 *) command="$i"; break ;;
1617                 esac
1618                 c=$((++c))
1619         done
1620
1621         if [ -z "$command" ]; then
1622                 case "${COMP_WORDS[COMP_CWORD]}" in
1623                 --*=*) COMPREPLY=() ;;
1624                 --*)   __gitcomp "
1625                         --paginate
1626                         --no-pager
1627                         --git-dir=
1628                         --bare
1629                         --version
1630                         --exec-path
1631                         --work-tree=
1632                         --help
1633                         "
1634                         ;;
1635                 *)     __gitcomp "$(__git_porcelain_commands) $(__git_aliases)" ;;
1636                 esac
1637                 return
1638         fi
1639
1640         local expansion=$(__git_aliased_command "$command")
1641         [ "$expansion" ] && command="$expansion"
1642
1643         case "$command" in
1644         am)          _git_am ;;
1645         add)         _git_add ;;
1646         apply)       _git_apply ;;
1647         archive)     _git_archive ;;
1648         bisect)      _git_bisect ;;
1649         bundle)      _git_bundle ;;
1650         branch)      _git_branch ;;
1651         checkout)    _git_checkout ;;
1652         cherry)      _git_cherry ;;
1653         cherry-pick) _git_cherry_pick ;;
1654         clean)       _git_clean ;;
1655         clone)       _git_clone ;;
1656         commit)      _git_commit ;;
1657         config)      _git_config ;;
1658         describe)    _git_describe ;;
1659         diff)        _git_diff ;;
1660         fetch)       _git_fetch ;;
1661         format-patch) _git_format_patch ;;
1662         gc)          _git_gc ;;
1663         grep)        _git_grep ;;
1664         help)        _git_help ;;
1665         init)        _git_init ;;
1666         log)         _git_log ;;
1667         ls-files)    _git_ls_files ;;
1668         ls-remote)   _git_ls_remote ;;
1669         ls-tree)     _git_ls_tree ;;
1670         merge)       _git_merge;;
1671         mergetool)   _git_mergetool;;
1672         merge-base)  _git_merge_base ;;
1673         mv)          _git_mv ;;
1674         name-rev)    _git_name_rev ;;
1675         pull)        _git_pull ;;
1676         push)        _git_push ;;
1677         rebase)      _git_rebase ;;
1678         remote)      _git_remote ;;
1679         reset)       _git_reset ;;
1680         revert)      _git_revert ;;
1681         rm)          _git_rm ;;
1682         send-email)  _git_send_email ;;
1683         shortlog)    _git_shortlog ;;
1684         show)        _git_show ;;
1685         show-branch) _git_show_branch ;;
1686         stash)       _git_stash ;;
1687         submodule)   _git_submodule ;;
1688         svn)         _git_svn ;;
1689         tag)         _git_tag ;;
1690         whatchanged) _git_log ;;
1691         *)           COMPREPLY=() ;;
1692         esac
1693 }
1694
1695 _gitk ()
1696 {
1697         __git_has_doubledash && return
1698
1699         local cur="${COMP_WORDS[COMP_CWORD]}"
1700         local g="$(git rev-parse --git-dir 2>/dev/null)"
1701         local merge=""
1702         if [ -f $g/MERGE_HEAD ]; then
1703                 merge="--merge"
1704         fi
1705         case "$cur" in
1706         --*)
1707                 __gitcomp "--not --all $merge"
1708                 return
1709                 ;;
1710         esac
1711         __git_complete_revlist
1712 }
1713
1714 complete -o default -o nospace -F _git git
1715 complete -o default -o nospace -F _gitk gitk
1716
1717 # The following are necessary only for Cygwin, and only are needed
1718 # when the user has tab-completed the executable name and consequently
1719 # included the '.exe' suffix.
1720 #
1721 if [ Cygwin = "$(uname -o 2>/dev/null)" ]; then
1722 complete -o default -o nospace -F _git git.exe
1723 fi