git.oblomov.eu Git - git/blob - 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/../.dotest" ]
  77                 then
  78                         if test -f "$g/../.dotest/rebasing"
  79                         then
  80                                 r="|REBASE"
  81                         elif test -f "$g/../.dotest/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/.dotest-merge/interactive" ]
  89                 then
  90                         r="|REBASE-i"
  91                         b="$(cat "$g/.dotest-merge/head-name")"
  92                 elif [ -d "$g/.dotest-merge" ]
  93                 then
  94                         r="|REBASE-m"
  95                         b="$(cat "$g/.dotest-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_commands ()
 353 {
 354         if [ -n "$__git_commandlist" ]; then
 355                 echo "$__git_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                 applymbox)        : ask gittus;;
 364                 applypatch)       : ask gittus;;
 365                 archimport)       : import;;
 366                 cat-file)         : plumbing;;
 367                 check-attr)       : plumbing;;
 368                 check-ref-format) : plumbing;;
 369                 commit-tree)      : plumbing;;
 370                 cvsexportcommit)  : export;;
 371                 cvsimport)        : import;;
 372                 cvsserver)        : daemon;;
 373                 daemon)           : daemon;;
 374                 diff-files)       : plumbing;;
 375                 diff-index)       : plumbing;;
 376                 diff-tree)        : plumbing;;
 377                 fast-import)      : import;;
 378                 fsck-objects)     : plumbing;;
 379                 fetch-pack)       : plumbing;;
 380                 fmt-merge-msg)    : plumbing;;
 381                 for-each-ref)     : plumbing;;
 382                 hash-object)      : plumbing;;
 383                 http-*)           : transport;;
 384                 index-pack)       : plumbing;;
 385                 init-db)          : deprecated;;
 386                 local-fetch)      : plumbing;;
 387                 mailinfo)         : plumbing;;
 388                 mailsplit)        : plumbing;;
 389                 merge-*)          : plumbing;;
 390                 mktree)           : plumbing;;
 391                 mktag)            : plumbing;;
 392                 pack-objects)     : plumbing;;
 393                 pack-redundant)   : plumbing;;
 394                 pack-refs)        : plumbing;;
 395                 parse-remote)     : plumbing;;
 396                 patch-id)         : plumbing;;
 397                 peek-remote)      : plumbing;;
 398                 prune)            : plumbing;;
 399                 prune-packed)     : plumbing;;
 400                 quiltimport)      : import;;
 401                 read-tree)        : plumbing;;
 402                 receive-pack)     : plumbing;;
 403                 reflog)           : plumbing;;
 404                 repo-config)      : deprecated;;
 405                 rerere)           : plumbing;;
 406                 rev-list)         : plumbing;;
 407                 rev-parse)        : plumbing;;
 408                 runstatus)        : plumbing;;
 409                 sh-setup)         : internal;;
 410                 shell)            : daemon;;
 411                 send-pack)        : plumbing;;
 412                 show-index)       : plumbing;;
 413                 ssh-*)            : transport;;
 414                 stripspace)       : plumbing;;
 415                 symbolic-ref)     : plumbing;;
 416                 tar-tree)         : deprecated;;
 417                 unpack-file)      : plumbing;;
 418                 unpack-objects)   : plumbing;;
 419                 update-index)     : plumbing;;
 420                 update-ref)       : plumbing;;
 421                 update-server-info) : daemon;;
 422                 upload-archive)   : plumbing;;
 423                 upload-pack)      : plumbing;;
 424                 write-tree)       : plumbing;;
 425                 verify-tag)       : plumbing;;
 426                 *) echo $i;;
 427                 esac
 428         done
 429 }
 430 __git_commandlist=
 431 __git_commandlist="$(__git_commands 2>/dev/null)"
 432
 433 __git_aliases ()
 434 {
 435         local i IFS=$'\n'
 436         for i in $(git --git-dir="$(__gitdir)" config --list); do
 437                 case "$i" in
 438                 alias.*)
 439                         i="${i#alias.}"
 440                         echo "${i/=*/}"
 441                         ;;
 442                 esac
 443         done
 444 }
 445
 446 __git_aliased_command ()
 447 {
 448         local word cmdline=$(git --git-dir="$(__gitdir)" \
 449                 config --get "alias.$1")
 450         for word in $cmdline; do
 451                 if [ "${word##-*}" ]; then
 452                         echo $word
 453                         return
 454                 fi
 455         done
 456 }
 457
 458 __git_find_subcommand ()
 459 {
 460         local word subcommand c=1
 461
 462         while [ $c -lt $COMP_CWORD ]; do
 463                 word="${COMP_WORDS[c]}"
 464                 for subcommand in $1; do
 465                         if [ "$subcommand" = "$word" ]; then
 466                                 echo "$subcommand"
 467                                 return
 468                         fi
 469                 done
 470                 c=$((++c))
 471         done
 472 }
 473
 474 __git_has_doubledash ()
 475 {
 476         local c=1
 477         while [ $c -lt $COMP_CWORD ]; do
 478                 if [ "--" = "${COMP_WORDS[c]}" ]; then
 479                         return 0
 480                 fi
 481                 c=$((++c))
 482         done
 483         return 1
 484 }
 485
 486 __git_whitespacelist="nowarn warn error error-all strip"
 487
 488 _git_am ()
 489 {
 490         local cur="${COMP_WORDS[COMP_CWORD]}"
 491         if [ -d .dotest ]; then
 492                 __gitcomp "--skip --resolved"
 493                 return
 494         fi
 495         case "$cur" in
 496         --whitespace=*)
 497                 __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
 498                 return
 499                 ;;
 500         --*)
 501                 __gitcomp "
 502                         --signoff --utf8 --binary --3way --interactive
 503                         --whitespace=
 504                         "
 505                 return
 506         esac
 507         COMPREPLY=()
 508 }
 509
 510 _git_apply ()
 511 {
 512         local cur="${COMP_WORDS[COMP_CWORD]}"
 513         case "$cur" in
 514         --whitespace=*)
 515                 __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
 516                 return
 517                 ;;
 518         --*)
 519                 __gitcomp "
 520                         --stat --numstat --summary --check --index
 521                         --cached --index-info --reverse --reject --unidiff-zero
 522                         --apply --no-add --exclude=
 523                         --whitespace= --inaccurate-eof --verbose
 524                         "
 525                 return
 526         esac
 527         COMPREPLY=()
 528 }
 529
 530 _git_add ()
 531 {
 532         __git_has_doubledash && return
 533
 534         local cur="${COMP_WORDS[COMP_CWORD]}"
 535         case "$cur" in
 536         --*)
 537                 __gitcomp "
 538                         --interactive --refresh --patch --update --dry-run
 539                         --ignore-errors
 540                         "
 541                 return
 542         esac
 543         COMPREPLY=()
 544 }
 545
 546 _git_bisect ()
 547 {
 548         __git_has_doubledash && return
 549
 550         local subcommands="start bad good reset visualize replay log"
 551         local subcommand="$(__git_find_subcommand "$subcommands")"
 552         if [ -z "$subcommand" ]; then
 553                 __gitcomp "$subcommands"
 554                 return
 555         fi
 556
 557         case "$subcommand" in
 558         bad|good|reset)
 559                 __gitcomp "$(__git_refs)"
 560                 ;;
 561         *)
 562                 COMPREPLY=()
 563                 ;;
 564         esac
 565 }
 566
 567 _git_branch ()
 568 {
 569         local i c=1 only_local_ref="n" has_r="n"
 570
 571         while [ $c -lt $COMP_CWORD ]; do
 572                 i="${COMP_WORDS[c]}"
 573                 case "$i" in
 574                 -d|-m)  only_local_ref="y" ;;
 575                 -r)     has_r="y" ;;
 576                 esac
 577                 c=$((++c))
 578         done
 579
 580         case "${COMP_WORDS[COMP_CWORD]}" in
 581         --*=*)  COMPREPLY=() ;;
 582         --*)
 583                 __gitcomp "
 584                         --color --no-color --verbose --abbrev= --no-abbrev
 585                         --track --no-track
 586                         "
 587                 ;;
 588         *)
 589                 if [ $only_local_ref = "y" -a $has_r = "n" ]; then
 590                         __gitcomp "$(__git_heads)"
 591                 else
 592                         __gitcomp "$(__git_refs)"
 593                 fi
 594                 ;;
 595         esac
 596 }
 597
 598 _git_bundle ()
 599 {
 600         local mycword="$COMP_CWORD"
 601         case "${COMP_WORDS[0]}" in
 602         git)
 603                 local cmd="${COMP_WORDS[2]}"
 604                 mycword="$((mycword-1))"
 605                 ;;
 606         git-bundle*)
 607                 local cmd="${COMP_WORDS[1]}"
 608                 ;;
 609         esac
 610         case "$mycword" in
 611         1)
 612                 __gitcomp "create list-heads verify unbundle"
 613                 ;;
 614         2)
 615                 # looking for a file
 616                 ;;
 617         *)
 618                 case "$cmd" in
 619                         create)
 620                                 __git_complete_revlist
 621                         ;;
 622                 esac
 623                 ;;
 624         esac
 625 }
 626
 627 _git_checkout ()
 628 {
 629         __gitcomp "$(__git_refs)"
 630 }
 631
 632 _git_cherry ()
 633 {
 634         __gitcomp "$(__git_refs)"
 635 }
 636
 637 _git_cherry_pick ()
 638 {
 639         local cur="${COMP_WORDS[COMP_CWORD]}"
 640         case "$cur" in
 641         --*)
 642                 __gitcomp "--edit --no-commit"
 643                 ;;
 644         *)
 645                 __gitcomp "$(__git_refs)"
 646                 ;;
 647         esac
 648 }
 649
 650 _git_commit ()
 651 {
 652         __git_has_doubledash && return
 653
 654         local cur="${COMP_WORDS[COMP_CWORD]}"
 655         case "$cur" in
 656         --*)
 657                 __gitcomp "
 658                         --all --author= --signoff --verify --no-verify
 659                         --edit --amend --include --only
 660                         "
 661                 return
 662         esac
 663         COMPREPLY=()
 664 }
 665
 666 _git_describe ()
 667 {
 668         __gitcomp "$(__git_refs)"
 669 }
 670
 671 _git_diff ()
 672 {
 673         __git_has_doubledash && return
 674
 675         local cur="${COMP_WORDS[COMP_CWORD]}"
 676         case "$cur" in
 677         --*)
 678                 __gitcomp "--cached --stat --numstat --shortstat --summary
 679                         --patch-with-stat --name-only --name-status --color
 680                         --no-color --color-words --no-renames --check
 681                         --full-index --binary --abbrev --diff-filter
 682                         --find-copies-harder --pickaxe-all --pickaxe-regex
 683                         --text --ignore-space-at-eol --ignore-space-change
 684                         --ignore-all-space --exit-code --quiet --ext-diff
 685                         --no-ext-diff
 686                         --no-prefix --src-prefix= --dst-prefix=
 687                         --base --ours --theirs
 688                         "
 689                 return
 690                 ;;
 691         esac
 692         __git_complete_file
 693 }
 694
 695 _git_diff_tree ()
 696 {
 697         __gitcomp "$(__git_refs)"
 698 }
 699
 700 _git_fetch ()
 701 {
 702         local cur="${COMP_WORDS[COMP_CWORD]}"
 703
 704         case "${COMP_WORDS[0]},$COMP_CWORD" in
 705         git-fetch*,1)
 706                 __gitcomp "$(__git_remotes)"
 707                 ;;
 708         git,2)
 709                 __gitcomp "$(__git_remotes)"
 710                 ;;
 711         *)
 712                 case "$cur" in
 713                 *:*)
 714                         local pfx=""
 715                         case "$COMP_WORDBREAKS" in
 716                         *:*) : great ;;
 717                         *)   pfx="${cur%%:*}:" ;;
 718                         esac
 719                         __gitcomp "$(__git_refs)" "$pfx" "${cur#*:}"
 720                         ;;
 721                 *)
 722                         local remote
 723                         case "${COMP_WORDS[0]}" in
 724                         git-fetch) remote="${COMP_WORDS[1]}" ;;
 725                         git)       remote="${COMP_WORDS[2]}" ;;
 726                         esac
 727                         __gitcomp "$(__git_refs2 "$remote")"
 728                         ;;
 729                 esac
 730                 ;;
 731         esac
 732 }
 733
 734 _git_format_patch ()
 735 {
 736         local cur="${COMP_WORDS[COMP_CWORD]}"
 737         case "$cur" in
 738         --*)
 739                 __gitcomp "
 740                         --stdout --attach --thread
 741                         --output-directory
 742                         --numbered --start-number
 743                         --numbered-files
 744                         --keep-subject
 745                         --signoff
 746                         --in-reply-to=
 747                         --full-index --binary
 748                         --not --all
 749                         --cover-letter
 750                         --no-prefix --src-prefix= --dst-prefix=
 751                         "
 752                 return
 753                 ;;
 754         esac
 755         __git_complete_revlist
 756 }
 757
 758 _git_gc ()
 759 {
 760         local cur="${COMP_WORDS[COMP_CWORD]}"
 761         case "$cur" in
 762         --*)
 763                 __gitcomp "--prune --aggressive"
 764                 return
 765                 ;;
 766         esac
 767         COMPREPLY=()
 768 }
 769
 770 _git_ls_remote ()
 771 {
 772         __gitcomp "$(__git_remotes)"
 773 }
 774
 775 _git_ls_tree ()
 776 {
 777         __git_complete_file
 778 }
 779
 780 _git_log ()
 781 {
 782         __git_has_doubledash && return
 783
 784         local cur="${COMP_WORDS[COMP_CWORD]}"
 785         case "$cur" in
 786         --pretty=*)
 787                 __gitcomp "
 788                         oneline short medium full fuller email raw
 789                         " "" "${cur##--pretty=}"
 790                 return
 791                 ;;
 792         --date=*)
 793                 __gitcomp "
 794                         relative iso8601 rfc2822 short local default
 795                 " "" "${cur##--date=}"
 796                 return
 797                 ;;
 798         --*)
 799                 __gitcomp "
 800                         --max-count= --max-age= --since= --after=
 801                         --min-age= --before= --until=
 802                         --root --topo-order --date-order --reverse
 803                         --no-merges --follow
 804                         --abbrev-commit --abbrev=
 805                         --relative-date --date=
 806                         --author= --committer= --grep=
 807                         --all-match
 808                         --pretty= --name-status --name-only --raw
 809                         --not --all
 810                         --left-right --cherry-pick
 811                         --graph
 812                         "
 813                 return
 814                 ;;
 815         esac
 816         __git_complete_revlist
 817 }
 818
 819 _git_merge ()
 820 {
 821         local cur="${COMP_WORDS[COMP_CWORD]}"
 822         case "${COMP_WORDS[COMP_CWORD-1]}" in
 823         -s|--strategy)
 824                 __gitcomp "$(__git_merge_strategies)"
 825                 return
 826         esac
 827         case "$cur" in
 828         --strategy=*)
 829                 __gitcomp "$(__git_merge_strategies)" "" "${cur##--strategy=}"
 830                 return
 831                 ;;
 832         --*)
 833                 __gitcomp "
 834                         --no-commit --no-stat --log --no-log --squash --strategy
 835                         "
 836                 return
 837         esac
 838         __gitcomp "$(__git_refs)"
 839 }
 840
 841 _git_merge_base ()
 842 {
 843         __gitcomp "$(__git_refs)"
 844 }
 845
 846 _git_name_rev ()
 847 {
 848         __gitcomp "--tags --all --stdin"
 849 }
 850
 851 _git_pull ()
 852 {
 853         local cur="${COMP_WORDS[COMP_CWORD]}"
 854
 855         case "${COMP_WORDS[0]},$COMP_CWORD" in
 856         git-pull*,1)
 857                 __gitcomp "$(__git_remotes)"
 858                 ;;
 859         git,2)
 860                 __gitcomp "$(__git_remotes)"
 861                 ;;
 862         *)
 863                 local remote
 864                 case "${COMP_WORDS[0]}" in
 865                 git-pull)  remote="${COMP_WORDS[1]}" ;;
 866                 git)       remote="${COMP_WORDS[2]}" ;;
 867                 esac
 868                 __gitcomp "$(__git_refs "$remote")"
 869                 ;;
 870         esac
 871 }
 872
 873 _git_push ()
 874 {
 875         local cur="${COMP_WORDS[COMP_CWORD]}"
 876
 877         case "${COMP_WORDS[0]},$COMP_CWORD" in
 878         git-push*,1)
 879                 __gitcomp "$(__git_remotes)"
 880                 ;;
 881         git,2)
 882                 __gitcomp "$(__git_remotes)"
 883                 ;;
 884         *)
 885                 case "$cur" in
 886                 *:*)
 887                         local remote
 888                         case "${COMP_WORDS[0]}" in
 889                         git-push)  remote="${COMP_WORDS[1]}" ;;
 890                         git)       remote="${COMP_WORDS[2]}" ;;
 891                         esac
 892
 893                         local pfx=""
 894                         case "$COMP_WORDBREAKS" in
 895                         *:*) : great ;;
 896                         *)   pfx="${cur%%:*}:" ;;
 897                         esac
 898
 899                         __gitcomp "$(__git_refs "$remote")" "$pfx" "${cur#*:}"
 900                         ;;
 901                 +*)
 902                         __gitcomp "$(__git_refs)" + "${cur#+}"
 903                         ;;
 904                 *)
 905                         __gitcomp "$(__git_refs)"
 906                         ;;
 907                 esac
 908                 ;;
 909         esac
 910 }
 911
 912 _git_rebase ()
 913 {
 914         local cur="${COMP_WORDS[COMP_CWORD]}" dir="$(__gitdir)"
 915         if [ -d .dotest ] || [ -d "$dir"/.dotest-merge ]; then
 916                 __gitcomp "--continue --skip --abort"
 917                 return
 918         fi
 919         case "${COMP_WORDS[COMP_CWORD-1]}" in
 920         -s|--strategy)
 921                 __gitcomp "$(__git_merge_strategies)"
 922                 return
 923         esac
 924         case "$cur" in
 925         --strategy=*)
 926                 __gitcomp "$(__git_merge_strategies)" "" "${cur##--strategy=}"
 927                 return
 928                 ;;
 929         --*)
 930                 __gitcomp "--onto --merge --strategy --interactive"
 931                 return
 932         esac
 933         __gitcomp "$(__git_refs)"
 934 }
 935
 936 _git_config ()
 937 {
 938         local cur="${COMP_WORDS[COMP_CWORD]}"
 939         local prv="${COMP_WORDS[COMP_CWORD-1]}"
 940         case "$prv" in
 941         branch.*.remote)
 942                 __gitcomp "$(__git_remotes)"
 943                 return
 944                 ;;
 945         branch.*.merge)
 946                 __gitcomp "$(__git_refs)"
 947                 return
 948                 ;;
 949         remote.*.fetch)
 950                 local remote="${prv#remote.}"
 951                 remote="${remote%.fetch}"
 952                 __gitcomp "$(__git_refs_remotes "$remote")"
 953                 return
 954                 ;;
 955         remote.*.push)
 956                 local remote="${prv#remote.}"
 957                 remote="${remote%.push}"
 958                 __gitcomp "$(git --git-dir="$(__gitdir)" \
 959                         for-each-ref --format='%(refname):%(refname)' \
 960                         refs/heads)"
 961                 return
 962                 ;;
 963         pull.twohead|pull.octopus)
 964                 __gitcomp "$(__git_merge_strategies)"
 965                 return
 966                 ;;
 967         color.branch|color.diff|color.status)
 968                 __gitcomp "always never auto"
 969                 return
 970                 ;;
 971         color.*.*)
 972                 __gitcomp "
 973                         black red green yellow blue magenta cyan white
 974                         bold dim ul blink reverse
 975                         "
 976                 return
 977                 ;;
 978         *.*)
 979                 COMPREPLY=()
 980                 return
 981                 ;;
 982         esac
 983         case "$cur" in
 984         --*)
 985                 __gitcomp "
 986                         --global --system --file=
 987                         --list --replace-all
 988                         --get --get-all --get-regexp
 989                         --add --unset --unset-all
 990                         --remove-section --rename-section
 991                         "
 992                 return
 993                 ;;
 994         branch.*.*)
 995                 local pfx="${cur%.*}."
 996                 cur="${cur##*.}"
 997                 __gitcomp "remote merge" "$pfx" "$cur"
 998                 return
 999                 ;;
1000         branch.*)
1001                 local pfx="${cur%.*}."
1002                 cur="${cur#*.}"
1003                 __gitcomp "$(__git_heads)" "$pfx" "$cur" "."
1004                 return
1005                 ;;
1006         remote.*.*)
1007                 local pfx="${cur%.*}."
1008                 cur="${cur##*.}"
1009                 __gitcomp "
1010                         url fetch push skipDefaultUpdate
1011                         receivepack uploadpack tagopt
1012                         " "$pfx" "$cur"
1013                 return
1014                 ;;
1015         remote.*)
1016                 local pfx="${cur%.*}."
1017                 cur="${cur#*.}"
1018                 __gitcomp "$(__git_remotes)" "$pfx" "$cur" "."
1019                 return
1020                 ;;
1021         esac
1022         __gitcomp "
1023                 apply.whitespace
1024                 core.fileMode
1025                 core.gitProxy
1026                 core.ignoreStat
1027                 core.preferSymlinkRefs
1028                 core.logAllRefUpdates
1029                 core.loosecompression
1030                 core.repositoryFormatVersion
1031                 core.sharedRepository
1032                 core.warnAmbiguousRefs
1033                 core.compression
1034                 core.packedGitWindowSize
1035                 core.packedGitLimit
1036                 clean.requireForce
1037                 color.branch
1038                 color.branch.current
1039                 color.branch.local
1040                 color.branch.remote
1041                 color.branch.plain
1042                 color.diff
1043                 color.diff.plain
1044                 color.diff.meta
1045                 color.diff.frag
1046                 color.diff.old
1047                 color.diff.new
1048                 color.diff.commit
1049                 color.diff.whitespace
1050                 color.pager
1051                 color.status
1052                 color.status.header
1053                 color.status.added
1054                 color.status.changed
1055                 color.status.untracked
1056                 diff.renameLimit
1057                 diff.renames
1058                 fetch.unpackLimit
1059                 format.headers
1060                 format.subjectprefix
1061                 gitcvs.enabled
1062                 gitcvs.logfile
1063                 gitcvs.allbinary
1064                 gitcvs.dbname gitcvs.dbdriver gitcvs.dbuser gitcvs.dbpass
1065                 gitcvs.dbtablenameprefix
1066                 gc.packrefs
1067                 gc.reflogexpire
1068                 gc.reflogexpireunreachable
1069                 gc.rerereresolved
1070                 gc.rerereunresolved
1071                 http.sslVerify
1072                 http.sslCert
1073                 http.sslKey
1074                 http.sslCAInfo
1075                 http.sslCAPath
1076                 http.maxRequests
1077                 http.lowSpeedLimit
1078                 http.lowSpeedTime
1079                 http.noEPSV
1080                 i18n.commitEncoding
1081                 i18n.logOutputEncoding
1082                 log.showroot
1083                 merge.tool
1084                 merge.summary
1085                 merge.verbosity
1086                 pack.window
1087                 pack.depth
1088                 pack.windowMemory
1089                 pack.compression
1090                 pack.deltaCacheSize
1091                 pack.deltaCacheLimit
1092                 pull.octopus
1093                 pull.twohead
1094                 repack.useDeltaBaseOffset
1095                 show.difftree
1096                 showbranch.default
1097                 tar.umask
1098                 transfer.unpackLimit
1099                 receive.unpackLimit
1100                 receive.denyNonFastForwards
1101                 user.name
1102                 user.email
1103                 user.signingkey
1104                 whatchanged.difftree
1105                 branch. remote.
1106         "
1107 }
1108
1109 _git_remote ()
1110 {
1111         local subcommands="add rm show prune update"
1112         local subcommand="$(__git_find_subcommand "$subcommands")"
1113         if [ -z "$subcommand" ]; then
1114                 __gitcomp "$subcommands"
1115                 return
1116         fi
1117
1118         case "$subcommand" in
1119         rm|show|prune)
1120                 __gitcomp "$(__git_remotes)"
1121                 ;;
1122         update)
1123                 local i c='' IFS=$'\n'
1124                 for i in $(git --git-dir="$(__gitdir)" config --list); do
1125                         case "$i" in
1126                         remotes.*)
1127                                 i="${i#remotes.}"
1128                                 c="$c ${i/=*/}"
1129                                 ;;
1130                         esac
1131                 done
1132                 __gitcomp "$c"
1133                 ;;
1134         *)
1135                 COMPREPLY=()
1136                 ;;
1137         esac
1138 }
1139
1140 _git_reset ()
1141 {
1142         __git_has_doubledash && return
1143
1144         local cur="${COMP_WORDS[COMP_CWORD]}"
1145         case "$cur" in
1146         --*)
1147                 __gitcomp "--mixed --hard --soft"
1148                 return
1149                 ;;
1150         esac
1151         __gitcomp "$(__git_refs)"
1152 }
1153
1154 _git_shortlog ()
1155 {
1156         __git_has_doubledash && return
1157
1158         local cur="${COMP_WORDS[COMP_CWORD]}"
1159         case "$cur" in
1160         --*)
1161                 __gitcomp "
1162                         --max-count= --max-age= --since= --after=
1163                         --min-age= --before= --until=
1164                         --no-merges
1165                         --author= --committer= --grep=
1166                         --all-match
1167                         --not --all
1168                         --numbered --summary
1169                         "
1170                 return
1171                 ;;
1172         esac
1173         __git_complete_revlist
1174 }
1175
1176 _git_show ()
1177 {
1178         local cur="${COMP_WORDS[COMP_CWORD]}"
1179         case "$cur" in
1180         --pretty=*)
1181                 __gitcomp "
1182                         oneline short medium full fuller email raw
1183                         " "" "${cur##--pretty=}"
1184                 return
1185                 ;;
1186         --*)
1187                 __gitcomp "--pretty="
1188                 return
1189                 ;;
1190         esac
1191         __git_complete_file
1192 }
1193
1194 _git_stash ()
1195 {
1196         local subcommands='save list show apply clear drop pop create'
1197         if [ -z "$(__git_find_subcommand "$subcommands")" ]; then
1198                 __gitcomp "$subcommands"
1199         fi
1200 }
1201
1202 _git_submodule ()
1203 {
1204         __git_has_doubledash && return
1205
1206         local subcommands="add status init update"
1207         if [ -z "$(__git_find_subcommand "$subcommands")" ]; then
1208                 local cur="${COMP_WORDS[COMP_CWORD]}"
1209                 case "$cur" in
1210                 --*)
1211                         __gitcomp "--quiet --cached"
1212                         ;;
1213                 *)
1214                         __gitcomp "$subcommands"
1215                         ;;
1216                 esac
1217                 return
1218         fi
1219 }
1220
1221 _git_svn ()
1222 {
1223         local subcommands="
1224                 init fetch clone rebase dcommit log find-rev
1225                 set-tree commit-diff info create-ignore propget
1226                 proplist show-ignore show-externals
1227                 "
1228         local subcommand="$(__git_find_subcommand "$subcommands")"
1229         if [ -z "$subcommand" ]; then
1230                 __gitcomp "$subcommands"
1231         else
1232                 local remote_opts="--username= --config-dir= --no-auth-cache"
1233                 local fc_opts="
1234                         --follow-parent --authors-file= --repack=
1235                         --no-metadata --use-svm-props --use-svnsync-props
1236                         --log-window-size= --no-checkout --quiet
1237                         --repack-flags --user-log-author $remote_opts
1238                         "
1239                 local init_opts="
1240                         --template= --shared= --trunk= --tags=
1241                         --branches= --stdlayout --minimize-url
1242                         --no-metadata --use-svm-props --use-svnsync-props
1243                         --rewrite-root= $remote_opts
1244                         "
1245                 local cmt_opts="
1246                         --edit --rmdir --find-copies-harder --copy-similarity=
1247                         "
1248
1249                 local cur="${COMP_WORDS[COMP_CWORD]}"
1250                 case "$subcommand,$cur" in
1251                 fetch,--*)
1252                         __gitcomp "--revision= --fetch-all $fc_opts"
1253                         ;;
1254                 clone,--*)
1255                         __gitcomp "--revision= $fc_opts $init_opts"
1256                         ;;
1257                 init,--*)
1258                         __gitcomp "$init_opts"
1259                         ;;
1260                 dcommit,--*)
1261                         __gitcomp "
1262                                 --merge --strategy= --verbose --dry-run
1263                                 --fetch-all --no-rebase $cmt_opts $fc_opts
1264                                 "
1265                         ;;
1266                 set-tree,--*)
1267                         __gitcomp "--stdin $cmt_opts $fc_opts"
1268                         ;;
1269                 create-ignore,--*|propget,--*|proplist,--*|show-ignore,--*|\
1270                 show-externals,--*)
1271                         __gitcomp "--revision="
1272                         ;;
1273                 log,--*)
1274                         __gitcomp "
1275                                 --limit= --revision= --verbose --incremental
1276                                 --oneline --show-commit --non-recursive
1277                                 --authors-file=
1278                                 "
1279                         ;;
1280                 rebase,--*)
1281                         __gitcomp "
1282                                 --merge --verbose --strategy= --local
1283                                 --fetch-all $fc_opts
1284                                 "
1285                         ;;
1286                 commit-diff,--*)
1287                         __gitcomp "--message= --file= --revision= $cmt_opts"
1288                         ;;
1289                 info,--*)
1290                         __gitcomp "--url"
1291                         ;;
1292                 *)
1293                         COMPREPLY=()
1294                         ;;
1295                 esac
1296         fi
1297 }
1298
1299 _git_tag ()
1300 {
1301         local i c=1 f=0
1302         while [ $c -lt $COMP_CWORD ]; do
1303                 i="${COMP_WORDS[c]}"
1304                 case "$i" in
1305                 -d|-v)
1306                         __gitcomp "$(__git_tags)"
1307                         return
1308                         ;;
1309                 -f)
1310                         f=1
1311                         ;;
1312                 esac
1313                 c=$((++c))
1314         done
1315
1316         case "${COMP_WORDS[COMP_CWORD-1]}" in
1317         -m|-F)
1318                 COMPREPLY=()
1319                 ;;
1320         -*|tag|git-tag)
1321                 if [ $f = 1 ]; then
1322                         __gitcomp "$(__git_tags)"
1323                 else
1324                         COMPREPLY=()
1325                 fi
1326                 ;;
1327         *)
1328                 __gitcomp "$(__git_refs)"
1329                 ;;
1330         esac
1331 }
1332
1333 _git ()
1334 {
1335         local i c=1 command __git_dir
1336
1337         while [ $c -lt $COMP_CWORD ]; do
1338                 i="${COMP_WORDS[c]}"
1339                 case "$i" in
1340                 --git-dir=*) __git_dir="${i#--git-dir=}" ;;
1341                 --bare)      __git_dir="." ;;
1342                 --version|--help|-p|--paginate) ;;
1343                 *) command="$i"; break ;;
1344                 esac
1345                 c=$((++c))
1346         done
1347
1348         if [ -z "$command" ]; then
1349                 case "${COMP_WORDS[COMP_CWORD]}" in
1350                 --*=*) COMPREPLY=() ;;
1351                 --*)   __gitcomp "
1352                         --paginate
1353                         --no-pager
1354                         --git-dir=
1355                         --bare
1356                         --version
1357                         --exec-path
1358                         --work-tree=
1359                         --help
1360                         "
1361                         ;;
1362                 *)     __gitcomp "$(__git_commands) $(__git_aliases)" ;;
1363                 esac
1364                 return
1365         fi
1366
1367         local expansion=$(__git_aliased_command "$command")
1368         [ "$expansion" ] && command="$expansion"
1369
1370         case "$command" in
1371         am)          _git_am ;;
1372         add)         _git_add ;;
1373         apply)       _git_apply ;;
1374         bisect)      _git_bisect ;;
1375         bundle)      _git_bundle ;;
1376         branch)      _git_branch ;;
1377         checkout)    _git_checkout ;;
1378         cherry)      _git_cherry ;;
1379         cherry-pick) _git_cherry_pick ;;
1380         commit)      _git_commit ;;
1381         config)      _git_config ;;
1382         describe)    _git_describe ;;
1383         diff)        _git_diff ;;
1384         fetch)       _git_fetch ;;
1385         format-patch) _git_format_patch ;;
1386         gc)          _git_gc ;;
1387         log)         _git_log ;;
1388         ls-remote)   _git_ls_remote ;;
1389         ls-tree)     _git_ls_tree ;;
1390         merge)       _git_merge;;
1391         merge-base)  _git_merge_base ;;
1392         name-rev)    _git_name_rev ;;
1393         pull)        _git_pull ;;
1394         push)        _git_push ;;
1395         rebase)      _git_rebase ;;
1396         remote)      _git_remote ;;
1397         reset)       _git_reset ;;
1398         shortlog)    _git_shortlog ;;
1399         show)        _git_show ;;
1400         show-branch) _git_log ;;
1401         stash)       _git_stash ;;
1402         submodule)   _git_submodule ;;
1403         svn)         _git_svn ;;
1404         tag)         _git_tag ;;
1405         whatchanged) _git_log ;;
1406         *)           COMPREPLY=() ;;
1407         esac
1408 }
1409
1410 _gitk ()
1411 {
1412         __git_has_doubledash && return
1413
1414         local cur="${COMP_WORDS[COMP_CWORD]}"
1415         local g="$(git rev-parse --git-dir 2>/dev/null)"
1416         local merge=""
1417         if [ -f $g/MERGE_HEAD ]; then
1418                 merge="--merge"
1419         fi
1420         case "$cur" in
1421         --*)
1422                 __gitcomp "--not --all $merge"
1423                 return
1424                 ;;
1425         esac
1426         __git_complete_revlist
1427 }
1428
1429 complete -o default -o nospace -F _git git
1430 complete -o default -o nospace -F _gitk gitk
1431 complete -o default -o nospace -F _git_am git-am
1432 complete -o default -o nospace -F _git_apply git-apply
1433 complete -o default -o nospace -F _git_bisect git-bisect
1434 complete -o default -o nospace -F _git_branch git-branch
1435 complete -o default -o nospace -F _git_bundle git-bundle
1436 complete -o default -o nospace -F _git_checkout git-checkout
1437 complete -o default -o nospace -F _git_cherry git-cherry
1438 complete -o default -o nospace -F _git_cherry_pick git-cherry-pick
1439 complete -o default -o nospace -F _git_commit git-commit
1440 complete -o default -o nospace -F _git_describe git-describe
1441 complete -o default -o nospace -F _git_diff git-diff
1442 complete -o default -o nospace -F _git_fetch git-fetch
1443 complete -o default -o nospace -F _git_format_patch git-format-patch
1444 complete -o default -o nospace -F _git_gc git-gc
1445 complete -o default -o nospace -F _git_log git-log
1446 complete -o default -o nospace -F _git_ls_remote git-ls-remote
1447 complete -o default -o nospace -F _git_ls_tree git-ls-tree
1448 complete -o default -o nospace -F _git_merge git-merge
1449 complete -o default -o nospace -F _git_merge_base git-merge-base
1450 complete -o default -o nospace -F _git_name_rev git-name-rev
1451 complete -o default -o nospace -F _git_pull git-pull
1452 complete -o default -o nospace -F _git_push git-push
1453 complete -o default -o nospace -F _git_rebase git-rebase
1454 complete -o default -o nospace -F _git_config git-config
1455 complete -o default -o nospace -F _git_remote git-remote
1456 complete -o default -o nospace -F _git_reset git-reset
1457 complete -o default -o nospace -F _git_shortlog git-shortlog
1458 complete -o default -o nospace -F _git_show git-show
1459 complete -o default -o nospace -F _git_stash git-stash
1460 complete -o default -o nospace -F _git_submodule git-submodule
1461 complete -o default -o nospace -F _git_svn git-svn
1462 complete -o default -o nospace -F _git_log git-show-branch
1463 complete -o default -o nospace -F _git_tag git-tag
1464 complete -o default -o nospace -F _git_log git-whatchanged
1465
1466 # The following are necessary only for Cygwin, and only are needed
1467 # when the user has tab-completed the executable name and consequently
1468 # included the '.exe' suffix.
1469 #
1470 if [ Cygwin = "$(uname -o 2>/dev/null)" ]; then
1471 complete -o default -o nospace -F _git_add git-add.exe
1472 complete -o default -o nospace -F _git_apply git-apply.exe
1473 complete -o default -o nospace -F _git git.exe
1474 complete -o default -o nospace -F _git_branch git-branch.exe
1475 complete -o default -o nospace -F _git_bundle git-bundle.exe
1476 complete -o default -o nospace -F _git_cherry git-cherry.exe
1477 complete -o default -o nospace -F _git_describe git-describe.exe
1478 complete -o default -o nospace -F _git_diff git-diff.exe
1479 complete -o default -o nospace -F _git_format_patch git-format-patch.exe
1480 complete -o default -o nospace -F _git_log git-log.exe
1481 complete -o default -o nospace -F _git_ls_tree git-ls-tree.exe
1482 complete -o default -o nospace -F _git_merge_base git-merge-base.exe
1483 complete -o default -o nospace -F _git_name_rev git-name-rev.exe
1484 complete -o default -o nospace -F _git_push git-push.exe
1485 complete -o default -o nospace -F _git_config git-config
1486 complete -o default -o nospace -F _git_shortlog git-shortlog.exe
1487 complete -o default -o nospace -F _git_show git-show.exe
1488 complete -o default -o nospace -F _git_log git-show-branch.exe
1489 complete -o default -o nospace -F _git_tag git-tag.exe
1490 complete -o default -o nospace -F _git_log git-whatchanged.exe
1491 fi