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