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         local g="$(git rev-parse --git-dir 2>/dev/null)"
 939         local merge=""
 940         if [ -f "$g/MERGE_HEAD" ]; then
 941                 merge="--merge"
 942         fi
 943         case "$cur" in
 944         --pretty=*)
 945                 __gitcomp "
 946                         oneline short medium full fuller email raw
 947                         " "" "${cur##--pretty=}"
 948                 return
 949                 ;;
 950         --date=*)
 951                 __gitcomp "
 952                         relative iso8601 rfc2822 short local default
 953                 " "" "${cur##--date=}"
 954                 return
 955                 ;;
 956         --*)
 957                 __gitcomp "
 958                         --max-count= --max-age= --since= --after=
 959                         --min-age= --before= --until=
 960                         --root --topo-order --date-order --reverse
 961                         --no-merges --follow
 962                         --abbrev-commit --abbrev=
 963                         --relative-date --date=
 964                         --author= --committer= --grep=
 965                         --all-match
 966                         --pretty= --name-status --name-only --raw
 967                         --not --all
 968                         --left-right --cherry-pick
 969                         --graph
 970                         --stat --numstat --shortstat
 971                         --decorate --diff-filter=
 972                         --color-words --walk-reflogs
 973                         --parents --children --full-history
 974                         $merge
 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_mergetool ()
1005 {
1006         local cur="${COMP_WORDS[COMP_CWORD]}"
1007         case "$cur" in
1008         --tool=*)
1009                 __gitcomp "
1010                         kdiff3 tkdiff meld xxdiff emerge
1011                         vimdiff gvimdiff ecmerge opendiff
1012                         " "" "${cur##--tool=}"
1013                 return
1014                 ;;
1015         --*)
1016                 __gitcomp "--tool="
1017                 return
1018                 ;;
1019         esac
1020         COMPREPLY=()
1021 }
1022
1023 _git_merge_base ()
1024 {
1025         __gitcomp "$(__git_refs)"
1026 }
1027
1028 _git_mv ()
1029 {
1030         local cur="${COMP_WORDS[COMP_CWORD]}"
1031         case "$cur" in
1032         --*)
1033                 __gitcomp "--dry-run"
1034                 return
1035                 ;;
1036         esac
1037         COMPREPLY=()
1038 }
1039
1040 _git_name_rev ()
1041 {
1042         __gitcomp "--tags --all --stdin"
1043 }
1044
1045 _git_pull ()
1046 {
1047         local cur="${COMP_WORDS[COMP_CWORD]}"
1048
1049         if [ "$COMP_CWORD" = 2 ]; then
1050                 __gitcomp "$(__git_remotes)"
1051         else
1052                 __gitcomp "$(__git_refs "${COMP_WORDS[2]}")"
1053         fi
1054 }
1055
1056 _git_push ()
1057 {
1058         local cur="${COMP_WORDS[COMP_CWORD]}"
1059
1060         if [ "$COMP_CWORD" = 2 ]; then
1061                 __gitcomp "$(__git_remotes)"
1062         else
1063                 case "$cur" in
1064                 *:*)
1065                         local pfx=""
1066                         case "$COMP_WORDBREAKS" in
1067                         *:*) : great ;;
1068                         *)   pfx="${cur%%:*}:" ;;
1069                         esac
1070
1071                         __gitcomp "$(__git_refs "${COMP_WORDS[2]}")" "$pfx" "${cur#*:}"
1072                         ;;
1073                 +*)
1074                         __gitcomp "$(__git_refs)" + "${cur#+}"
1075                         ;;
1076                 *)
1077                         __gitcomp "$(__git_refs)"
1078                         ;;
1079                 esac
1080         fi
1081 }
1082
1083 _git_rebase ()
1084 {
1085         local cur="${COMP_WORDS[COMP_CWORD]}" dir="$(__gitdir)"
1086         if [ -d "$dir"/rebase-apply ] || [ -d "$dir"/rebase-merge ]; then
1087                 __gitcomp "--continue --skip --abort"
1088                 return
1089         fi
1090         case "${COMP_WORDS[COMP_CWORD-1]}" in
1091         -s|--strategy)
1092                 __gitcomp "$(__git_merge_strategies)"
1093                 return
1094         esac
1095         case "$cur" in
1096         --strategy=*)
1097                 __gitcomp "$(__git_merge_strategies)" "" "${cur##--strategy=}"
1098                 return
1099                 ;;
1100         --*)
1101                 __gitcomp "--onto --merge --strategy --interactive"
1102                 return
1103         esac
1104         __gitcomp "$(__git_refs)"
1105 }
1106
1107 _git_send_email ()
1108 {
1109         local cur="${COMP_WORDS[COMP_CWORD]}"
1110         case "$cur" in
1111         --*)
1112                 __gitcomp "--bcc --cc --cc-cmd --chain-reply-to --compose
1113                         --dry-run --envelope-sender --from --identity
1114                         --in-reply-to --no-chain-reply-to --no-signed-off-by-cc
1115                         --no-suppress-from --no-thread --quiet
1116                         --signed-off-by-cc --smtp-pass --smtp-server
1117                         --smtp-server-port --smtp-ssl --smtp-user --subject
1118                         --suppress-cc --suppress-from --thread --to
1119                         --validate --no-validate"
1120                 return
1121                 ;;
1122         esac
1123         COMPREPLY=()
1124 }
1125
1126 _git_config ()
1127 {
1128         local cur="${COMP_WORDS[COMP_CWORD]}"
1129         local prv="${COMP_WORDS[COMP_CWORD-1]}"
1130         case "$prv" in
1131         branch.*.remote)
1132                 __gitcomp "$(__git_remotes)"
1133                 return
1134                 ;;
1135         branch.*.merge)
1136                 __gitcomp "$(__git_refs)"
1137                 return
1138                 ;;
1139         remote.*.fetch)
1140                 local remote="${prv#remote.}"
1141                 remote="${remote%.fetch}"
1142                 __gitcomp "$(__git_refs_remotes "$remote")"
1143                 return
1144                 ;;
1145         remote.*.push)
1146                 local remote="${prv#remote.}"
1147                 remote="${remote%.push}"
1148                 __gitcomp "$(git --git-dir="$(__gitdir)" \
1149                         for-each-ref --format='%(refname):%(refname)' \
1150                         refs/heads)"
1151                 return
1152                 ;;
1153         pull.twohead|pull.octopus)
1154                 __gitcomp "$(__git_merge_strategies)"
1155                 return
1156                 ;;
1157         color.branch|color.diff|color.status)
1158                 __gitcomp "always never auto"
1159                 return
1160                 ;;
1161         color.*.*)
1162                 __gitcomp "
1163                         normal black red green yellow blue magenta cyan white
1164                         bold dim ul blink reverse
1165                         "
1166                 return
1167                 ;;
1168         *.*)
1169                 COMPREPLY=()
1170                 return
1171                 ;;
1172         esac
1173         case "$cur" in
1174         --*)
1175                 __gitcomp "
1176                         --global --system --file=
1177                         --list --replace-all
1178                         --get --get-all --get-regexp
1179                         --add --unset --unset-all
1180                         --remove-section --rename-section
1181                         "
1182                 return
1183                 ;;
1184         branch.*.*)
1185                 local pfx="${cur%.*}."
1186                 cur="${cur##*.}"
1187                 __gitcomp "remote merge mergeoptions" "$pfx" "$cur"
1188                 return
1189                 ;;
1190         branch.*)
1191                 local pfx="${cur%.*}."
1192                 cur="${cur#*.}"
1193                 __gitcomp "$(__git_heads)" "$pfx" "$cur" "."
1194                 return
1195                 ;;
1196         remote.*.*)
1197                 local pfx="${cur%.*}."
1198                 cur="${cur##*.}"
1199                 __gitcomp "
1200                         url proxy fetch push mirror skipDefaultUpdate
1201                         receivepack uploadpack tagopt
1202                         " "$pfx" "$cur"
1203                 return
1204                 ;;
1205         remote.*)
1206                 local pfx="${cur%.*}."
1207                 cur="${cur#*.}"
1208                 __gitcomp "$(__git_remotes)" "$pfx" "$cur" "."
1209                 return
1210                 ;;
1211         esac
1212         __gitcomp "
1213                 apply.whitespace
1214                 branch.autosetupmerge
1215                 branch.autosetuprebase
1216                 clean.requireForce
1217                 color.branch
1218                 color.branch.current
1219                 color.branch.local
1220                 color.branch.plain
1221                 color.branch.remote
1222                 color.diff
1223                 color.diff.commit
1224                 color.diff.frag
1225                 color.diff.meta
1226                 color.diff.new
1227                 color.diff.old
1228                 color.diff.plain
1229                 color.diff.whitespace
1230                 color.interactive
1231                 color.interactive.header
1232                 color.interactive.help
1233                 color.interactive.prompt
1234                 color.pager
1235                 color.status
1236                 color.status.added
1237                 color.status.changed
1238                 color.status.header
1239                 color.status.nobranch
1240                 color.status.untracked
1241                 color.status.updated
1242                 color.ui
1243                 commit.template
1244                 core.autocrlf
1245                 core.bare
1246                 core.compression
1247                 core.deltaBaseCacheLimit
1248                 core.editor
1249                 core.excludesfile
1250                 core.fileMode
1251                 core.fsyncobjectfiles
1252                 core.gitProxy
1253                 core.ignoreCygwinFSTricks
1254                 core.ignoreStat
1255                 core.logAllRefUpdates
1256                 core.loosecompression
1257                 core.packedGitLimit
1258                 core.packedGitWindowSize
1259                 core.pager
1260                 core.preferSymlinkRefs
1261                 core.preloadindex
1262                 core.quotepath
1263                 core.repositoryFormatVersion
1264                 core.safecrlf
1265                 core.sharedRepository
1266                 core.symlinks
1267                 core.trustctime
1268                 core.warnAmbiguousRefs
1269                 core.whitespace
1270                 core.worktree
1271                 diff.autorefreshindex
1272                 diff.external
1273                 diff.mnemonicprefix
1274                 diff.renameLimit
1275                 diff.renameLimit.
1276                 diff.renames
1277                 fetch.unpackLimit
1278                 format.headers
1279                 format.numbered
1280                 format.pretty
1281                 format.suffix
1282                 gc.aggressiveWindow
1283                 gc.auto
1284                 gc.autopacklimit
1285                 gc.packrefs
1286                 gc.pruneexpire
1287                 gc.reflogexpire
1288                 gc.reflogexpireunreachable
1289                 gc.rerereresolved
1290                 gc.rerereunresolved
1291                 gitcvs.allbinary
1292                 gitcvs.dbTableNamePrefix
1293                 gitcvs.dbdriver
1294                 gitcvs.dbname
1295                 gitcvs.dbpass
1296                 gitcvs.dbuser
1297                 gitcvs.enabled
1298                 gitcvs.logfile
1299                 gitcvs.usecrlfattr
1300                 gui.blamehistoryctx
1301                 gui.commitmsgwidth
1302                 gui.copyblamethreshold
1303                 gui.diffcontext
1304                 gui.encoding
1305                 gui.fastcopyblame
1306                 gui.matchtrackingbranch
1307                 gui.newbranchtemplate
1308                 gui.pruneduringfetch
1309                 gui.spellingdictionary
1310                 gui.trustmtime
1311                 help.autocorrect
1312                 help.browser
1313                 help.format
1314                 http.lowSpeedLimit
1315                 http.lowSpeedTime
1316                 http.maxRequests
1317                 http.noEPSV
1318                 http.proxy
1319                 http.sslCAInfo
1320                 http.sslCAPath
1321                 http.sslCert
1322                 http.sslKey
1323                 http.sslVerify
1324                 i18n.commitEncoding
1325                 i18n.logOutputEncoding
1326                 instaweb.browser
1327                 instaweb.httpd
1328                 instaweb.local
1329                 instaweb.modulepath
1330                 instaweb.port
1331                 log.date
1332                 log.showroot
1333                 man.viewer
1334                 merge.conflictstyle
1335                 merge.log
1336                 merge.renameLimit
1337                 merge.stat
1338                 merge.tool
1339                 merge.verbosity
1340                 mergetool.keepBackup
1341                 pack.compression
1342                 pack.deltaCacheLimit
1343                 pack.deltaCacheSize
1344                 pack.depth
1345                 pack.indexVersion
1346                 pack.packSizeLimit
1347                 pack.threads
1348                 pack.window
1349                 pack.windowMemory
1350                 pull.octopus
1351                 pull.twohead
1352                 receive.denyCurrentBranch
1353                 receive.denyDeletes
1354                 receive.denyNonFastForwards
1355                 receive.fsckObjects
1356                 receive.unpackLimit
1357                 repack.usedeltabaseoffset
1358                 rerere.autoupdate
1359                 rerere.enabled
1360                 showbranch.default
1361                 status.relativePaths
1362                 status.showUntrackedFiles
1363                 tar.umask
1364                 transfer.unpackLimit
1365                 user.email
1366                 user.name
1367                 user.signingkey
1368                 web.browser
1369                 branch. remote.
1370         "
1371 }
1372
1373 _git_remote ()
1374 {
1375         local subcommands="add rm show prune update"
1376         local subcommand="$(__git_find_subcommand "$subcommands")"
1377         if [ -z "$subcommand" ]; then
1378                 __gitcomp "$subcommands"
1379                 return
1380         fi
1381
1382         case "$subcommand" in
1383         rm|show|prune)
1384                 __gitcomp "$(__git_remotes)"
1385                 ;;
1386         update)
1387                 local i c='' IFS=$'\n'
1388                 for i in $(git --git-dir="$(__gitdir)" config --list); do
1389                         case "$i" in
1390                         remotes.*)
1391                                 i="${i#remotes.}"
1392                                 c="$c ${i/=*/}"
1393                                 ;;
1394                         esac
1395                 done
1396                 __gitcomp "$c"
1397                 ;;
1398         *)
1399                 COMPREPLY=()
1400                 ;;
1401         esac
1402 }
1403
1404 _git_reset ()
1405 {
1406         __git_has_doubledash && return
1407
1408         local cur="${COMP_WORDS[COMP_CWORD]}"
1409         case "$cur" in
1410         --*)
1411                 __gitcomp "--mixed --hard --soft"
1412                 return
1413                 ;;
1414         esac
1415         __gitcomp "$(__git_refs)"
1416 }
1417
1418 _git_revert ()
1419 {
1420         local cur="${COMP_WORDS[COMP_CWORD]}"
1421         case "$cur" in
1422         --*)
1423                 __gitcomp "--edit --mainline --no-edit --no-commit --signoff"
1424                 return
1425                 ;;
1426         esac
1427         __gitcomp "$(__git_refs)"
1428 }
1429
1430 _git_rm ()
1431 {
1432         __git_has_doubledash && return
1433
1434         local cur="${COMP_WORDS[COMP_CWORD]}"
1435         case "$cur" in
1436         --*)
1437                 __gitcomp "--cached --dry-run --ignore-unmatch --quiet"
1438                 return
1439                 ;;
1440         esac
1441         COMPREPLY=()
1442 }
1443
1444 _git_shortlog ()
1445 {
1446         __git_has_doubledash && return
1447
1448         local cur="${COMP_WORDS[COMP_CWORD]}"
1449         case "$cur" in
1450         --*)
1451                 __gitcomp "
1452                         --max-count= --max-age= --since= --after=
1453                         --min-age= --before= --until=
1454                         --no-merges
1455                         --author= --committer= --grep=
1456                         --all-match
1457                         --not --all
1458                         --numbered --summary
1459                         "
1460                 return
1461                 ;;
1462         esac
1463         __git_complete_revlist
1464 }
1465
1466 _git_show ()
1467 {
1468         __git_has_doubledash && return
1469
1470         local cur="${COMP_WORDS[COMP_CWORD]}"
1471         case "$cur" in
1472         --pretty=*)
1473                 __gitcomp "
1474                         oneline short medium full fuller email raw
1475                         " "" "${cur##--pretty=}"
1476                 return
1477                 ;;
1478         --*)
1479                 __gitcomp "--pretty="
1480                 return
1481                 ;;
1482         esac
1483         __git_complete_file
1484 }
1485
1486 _git_show_branch ()
1487 {
1488         local cur="${COMP_WORDS[COMP_CWORD]}"
1489         case "$cur" in
1490         --*)
1491                 __gitcomp "
1492                         --all --remotes --topo-order --current --more=
1493                         --list --independent --merge-base --no-name
1494                         --sha1-name --topics --reflog
1495                         "
1496                 return
1497                 ;;
1498         esac
1499         __git_complete_revlist
1500 }
1501
1502 _git_stash ()
1503 {
1504         local subcommands='save list show apply clear drop pop create branch'
1505         local subcommand="$(__git_find_subcommand "$subcommands")"
1506         if [ -z "$subcommand" ]; then
1507                 __gitcomp "$subcommands"
1508         else
1509                 local cur="${COMP_WORDS[COMP_CWORD]}"
1510                 case "$subcommand,$cur" in
1511                 save,--*)
1512                         __gitcomp "--keep-index"
1513                         ;;
1514                 apply,--*)
1515                         __gitcomp "--index"
1516                         ;;
1517                 show,--*|drop,--*|pop,--*|branch,--*)
1518                         COMPREPLY=()
1519                         ;;
1520                 show,*|apply,*|drop,*|pop,*|branch,*)
1521                         __gitcomp "$(git --git-dir="$(__gitdir)" stash list \
1522                                         | sed -n -e 's/:.*//p')"
1523                         ;;
1524                 *)
1525                         COMPREPLY=()
1526                         ;;
1527                 esac
1528         fi
1529 }
1530
1531 _git_submodule ()
1532 {
1533         __git_has_doubledash && return
1534
1535         local subcommands="add status init update summary foreach sync"
1536         if [ -z "$(__git_find_subcommand "$subcommands")" ]; then
1537                 local cur="${COMP_WORDS[COMP_CWORD]}"
1538                 case "$cur" in
1539                 --*)
1540                         __gitcomp "--quiet --cached"
1541                         ;;
1542                 *)
1543                         __gitcomp "$subcommands"
1544                         ;;
1545                 esac
1546                 return
1547         fi
1548 }
1549
1550 _git_svn ()
1551 {
1552         local subcommands="
1553                 init fetch clone rebase dcommit log find-rev
1554                 set-tree commit-diff info create-ignore propget
1555                 proplist show-ignore show-externals
1556                 "
1557         local subcommand="$(__git_find_subcommand "$subcommands")"
1558         if [ -z "$subcommand" ]; then
1559                 __gitcomp "$subcommands"
1560         else
1561                 local remote_opts="--username= --config-dir= --no-auth-cache"
1562                 local fc_opts="
1563                         --follow-parent --authors-file= --repack=
1564                         --no-metadata --use-svm-props --use-svnsync-props
1565                         --log-window-size= --no-checkout --quiet
1566                         --repack-flags --user-log-author $remote_opts
1567                         "
1568                 local init_opts="
1569                         --template= --shared= --trunk= --tags=
1570                         --branches= --stdlayout --minimize-url
1571                         --no-metadata --use-svm-props --use-svnsync-props
1572                         --rewrite-root= $remote_opts
1573                         "
1574                 local cmt_opts="
1575                         --edit --rmdir --find-copies-harder --copy-similarity=
1576                         "
1577
1578                 local cur="${COMP_WORDS[COMP_CWORD]}"
1579                 case "$subcommand,$cur" in
1580                 fetch,--*)
1581                         __gitcomp "--revision= --fetch-all $fc_opts"
1582                         ;;
1583                 clone,--*)
1584                         __gitcomp "--revision= $fc_opts $init_opts"
1585                         ;;
1586                 init,--*)
1587                         __gitcomp "$init_opts"
1588                         ;;
1589                 dcommit,--*)
1590                         __gitcomp "
1591                                 --merge --strategy= --verbose --dry-run
1592                                 --fetch-all --no-rebase $cmt_opts $fc_opts
1593                                 "
1594                         ;;
1595                 set-tree,--*)
1596                         __gitcomp "--stdin $cmt_opts $fc_opts"
1597                         ;;
1598                 create-ignore,--*|propget,--*|proplist,--*|show-ignore,--*|\
1599                 show-externals,--*)
1600                         __gitcomp "--revision="
1601                         ;;
1602                 log,--*)
1603                         __gitcomp "
1604                                 --limit= --revision= --verbose --incremental
1605                                 --oneline --show-commit --non-recursive
1606                                 --authors-file=
1607                                 "
1608                         ;;
1609                 rebase,--*)
1610                         __gitcomp "
1611                                 --merge --verbose --strategy= --local
1612                                 --fetch-all $fc_opts
1613                                 "
1614                         ;;
1615                 commit-diff,--*)
1616                         __gitcomp "--message= --file= --revision= $cmt_opts"
1617                         ;;
1618                 info,--*)
1619                         __gitcomp "--url"
1620                         ;;
1621                 *)
1622                         COMPREPLY=()
1623                         ;;
1624                 esac
1625         fi
1626 }
1627
1628 _git_tag ()
1629 {
1630         local i c=1 f=0
1631         while [ $c -lt $COMP_CWORD ]; do
1632                 i="${COMP_WORDS[c]}"
1633                 case "$i" in
1634                 -d|-v)
1635                         __gitcomp "$(__git_tags)"
1636                         return
1637                         ;;
1638                 -f)
1639                         f=1
1640                         ;;
1641                 esac
1642                 c=$((++c))
1643         done
1644
1645         case "${COMP_WORDS[COMP_CWORD-1]}" in
1646         -m|-F)
1647                 COMPREPLY=()
1648                 ;;
1649         -*|tag)
1650                 if [ $f = 1 ]; then
1651                         __gitcomp "$(__git_tags)"
1652                 else
1653                         COMPREPLY=()
1654                 fi
1655                 ;;
1656         *)
1657                 __gitcomp "$(__git_refs)"
1658                 ;;
1659         esac
1660 }
1661
1662 _git ()
1663 {
1664         local i c=1 command __git_dir
1665
1666         while [ $c -lt $COMP_CWORD ]; do
1667                 i="${COMP_WORDS[c]}"
1668                 case "$i" in
1669                 --git-dir=*) __git_dir="${i#--git-dir=}" ;;
1670                 --bare)      __git_dir="." ;;
1671                 --version|-p|--paginate) ;;
1672                 --help) command="help"; break ;;
1673                 *) command="$i"; break ;;
1674                 esac
1675                 c=$((++c))
1676         done
1677
1678         if [ -z "$command" ]; then
1679                 case "${COMP_WORDS[COMP_CWORD]}" in
1680                 --*=*) COMPREPLY=() ;;
1681                 --*)   __gitcomp "
1682                         --paginate
1683                         --no-pager
1684                         --git-dir=
1685                         --bare
1686                         --version
1687                         --exec-path
1688                         --work-tree=
1689                         --help
1690                         "
1691                         ;;
1692                 *)     __gitcomp "$(__git_porcelain_commands) $(__git_aliases)" ;;
1693                 esac
1694                 return
1695         fi
1696
1697         local expansion=$(__git_aliased_command "$command")
1698         [ "$expansion" ] && command="$expansion"
1699
1700         case "$command" in
1701         am)          _git_am ;;
1702         add)         _git_add ;;
1703         apply)       _git_apply ;;
1704         archive)     _git_archive ;;
1705         bisect)      _git_bisect ;;
1706         bundle)      _git_bundle ;;
1707         branch)      _git_branch ;;
1708         checkout)    _git_checkout ;;
1709         cherry)      _git_cherry ;;
1710         cherry-pick) _git_cherry_pick ;;
1711         clean)       _git_clean ;;
1712         clone)       _git_clone ;;
1713         commit)      _git_commit ;;
1714         config)      _git_config ;;
1715         describe)    _git_describe ;;
1716         diff)        _git_diff ;;
1717         fetch)       _git_fetch ;;
1718         format-patch) _git_format_patch ;;
1719         gc)          _git_gc ;;
1720         grep)        _git_grep ;;
1721         help)        _git_help ;;
1722         init)        _git_init ;;
1723         log)         _git_log ;;
1724         ls-files)    _git_ls_files ;;
1725         ls-remote)   _git_ls_remote ;;
1726         ls-tree)     _git_ls_tree ;;
1727         merge)       _git_merge;;
1728         mergetool)   _git_mergetool;;
1729         merge-base)  _git_merge_base ;;
1730         mv)          _git_mv ;;
1731         name-rev)    _git_name_rev ;;
1732         pull)        _git_pull ;;
1733         push)        _git_push ;;
1734         rebase)      _git_rebase ;;
1735         remote)      _git_remote ;;
1736         reset)       _git_reset ;;
1737         revert)      _git_revert ;;
1738         rm)          _git_rm ;;
1739         send-email)  _git_send_email ;;
1740         shortlog)    _git_shortlog ;;
1741         show)        _git_show ;;
1742         show-branch) _git_show_branch ;;
1743         stash)       _git_stash ;;
1744         submodule)   _git_submodule ;;
1745         svn)         _git_svn ;;
1746         tag)         _git_tag ;;
1747         whatchanged) _git_log ;;
1748         *)           COMPREPLY=() ;;
1749         esac
1750 }
1751
1752 _gitk ()
1753 {
1754         __git_has_doubledash && return
1755
1756         local cur="${COMP_WORDS[COMP_CWORD]}"
1757         local g="$(git rev-parse --git-dir 2>/dev/null)"
1758         local merge=""
1759         if [ -f "$g/MERGE_HEAD" ]; then
1760                 merge="--merge"
1761         fi
1762         case "$cur" in
1763         --*)
1764                 __gitcomp "--not --all $merge"
1765                 return
1766                 ;;
1767         esac
1768         __git_complete_revlist
1769 }
1770
1771 complete -o default -o nospace -F _git git
1772 complete -o default -o nospace -F _gitk gitk
1773
1774 # The following are necessary only for Cygwin, and only are needed
1775 # when the user has tab-completed the executable name and consequently
1776 # included the '.exe' suffix.
1777 #
1778 if [ Cygwin = "$(uname -o 2>/dev/null)" ]; then
1779 complete -o default -o nospace -F _git git.exe
1780 fi