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