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