contrib/completion/git-completion.bash

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