contrib/completion/git-completion.bash

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