contrib/completion/git-completion.bash

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