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_commit ()
 671 {
 672         __git_has_doubledash && return
 673
 674         local cur="${COMP_WORDS[COMP_CWORD]}"
 675         case "$cur" in
 676         --*)
 677                 __gitcomp "
 678                         --all --author= --signoff --verify --no-verify
 679                         --edit --amend --include --only
 680                         "
 681                 return
 682         esac
 683         COMPREPLY=()
 684 }
 685
 686 _git_describe ()
 687 {
 688         local cur="${COMP_WORDS[COMP_CWORD]}"
 689         case "$cur" in
 690         --*)
 691                 __gitcomp "
 692                         --all --tags --contains --abbrev= --candidates=
 693                         --exact-match --debug --long --match --always
 694                         "
 695                 return
 696         esac
 697         __gitcomp "$(__git_refs)"
 698 }
 699
 700 _git_diff ()
 701 {
 702         __git_has_doubledash && return
 703
 704         local cur="${COMP_WORDS[COMP_CWORD]}"
 705         case "$cur" in
 706         --*)
 707                 __gitcomp "--cached --stat --numstat --shortstat --summary
 708                         --patch-with-stat --name-only --name-status --color
 709                         --no-color --color-words --no-renames --check
 710                         --full-index --binary --abbrev --diff-filter
 711                         --find-copies-harder --pickaxe-all --pickaxe-regex
 712                         --text --ignore-space-at-eol --ignore-space-change
 713                         --ignore-all-space --exit-code --quiet --ext-diff
 714                         --no-ext-diff
 715                         --no-prefix --src-prefix= --dst-prefix=
 716                         --base --ours --theirs
 717                         "
 718                 return
 719                 ;;
 720         esac
 721         __git_complete_file
 722 }
 723
 724 _git_fetch ()
 725 {
 726         local cur="${COMP_WORDS[COMP_CWORD]}"
 727
 728         case "${COMP_WORDS[0]},$COMP_CWORD" in
 729         git-fetch*,1)
 730                 __gitcomp "$(__git_remotes)"
 731                 ;;
 732         git,2)
 733                 __gitcomp "$(__git_remotes)"
 734                 ;;
 735         *)
 736                 case "$cur" in
 737                 *:*)
 738                         local pfx=""
 739                         case "$COMP_WORDBREAKS" in
 740                         *:*) : great ;;
 741                         *)   pfx="${cur%%:*}:" ;;
 742                         esac
 743                         __gitcomp "$(__git_refs)" "$pfx" "${cur#*:}"
 744                         ;;
 745                 *)
 746                         local remote
 747                         case "${COMP_WORDS[0]}" in
 748                         git-fetch) remote="${COMP_WORDS[1]}" ;;
 749                         git)       remote="${COMP_WORDS[2]}" ;;
 750                         esac
 751                         __gitcomp "$(__git_refs2 "$remote")"
 752                         ;;
 753                 esac
 754                 ;;
 755         esac
 756 }
 757
 758 _git_format_patch ()
 759 {
 760         local cur="${COMP_WORDS[COMP_CWORD]}"
 761         case "$cur" in
 762         --*)
 763                 __gitcomp "
 764                         --stdout --attach --thread
 765                         --output-directory
 766                         --numbered --start-number
 767                         --numbered-files
 768                         --keep-subject
 769                         --signoff
 770                         --in-reply-to=
 771                         --full-index --binary
 772                         --not --all
 773                         --cover-letter
 774                         --no-prefix --src-prefix= --dst-prefix=
 775                         "
 776                 return
 777                 ;;
 778         esac
 779         __git_complete_revlist
 780 }
 781
 782 _git_gc ()
 783 {
 784         local cur="${COMP_WORDS[COMP_CWORD]}"
 785         case "$cur" in
 786         --*)
 787                 __gitcomp "--prune --aggressive"
 788                 return
 789                 ;;
 790         esac
 791         COMPREPLY=()
 792 }
 793
 794 _git_help ()
 795 {
 796         local cur="${COMP_WORDS[COMP_CWORD]}"
 797         case "$cur" in
 798         --*)
 799                 __gitcomp "--all --info --man --web"
 800                 return
 801                 ;;
 802         esac
 803         __gitcomp "$(__git_all_commands)"
 804 }
 805
 806 _git_ls_remote ()
 807 {
 808         __gitcomp "$(__git_remotes)"
 809 }
 810
 811 _git_ls_tree ()
 812 {
 813         __git_complete_file
 814 }
 815
 816 _git_log ()
 817 {
 818         __git_has_doubledash && return
 819
 820         local cur="${COMP_WORDS[COMP_CWORD]}"
 821         case "$cur" in
 822         --pretty=*)
 823                 __gitcomp "
 824                         oneline short medium full fuller email raw
 825                         " "" "${cur##--pretty=}"
 826                 return
 827                 ;;
 828         --date=*)
 829                 __gitcomp "
 830                         relative iso8601 rfc2822 short local default
 831                 " "" "${cur##--date=}"
 832                 return
 833                 ;;
 834         --*)
 835                 __gitcomp "
 836                         --max-count= --max-age= --since= --after=
 837                         --min-age= --before= --until=
 838                         --root --topo-order --date-order --reverse
 839                         --no-merges --follow
 840                         --abbrev-commit --abbrev=
 841                         --relative-date --date=
 842                         --author= --committer= --grep=
 843                         --all-match
 844                         --pretty= --name-status --name-only --raw
 845                         --not --all
 846                         --left-right --cherry-pick
 847                         --graph
 848                         --stat --numstat --shortstat
 849                         --decorate --diff-filter=
 850                         --color-words --walk-reflogs
 851                         --parents --children --full-history
 852                         "
 853                 return
 854                 ;;
 855         esac
 856         __git_complete_revlist
 857 }
 858
 859 _git_merge ()
 860 {
 861         local cur="${COMP_WORDS[COMP_CWORD]}"
 862         case "${COMP_WORDS[COMP_CWORD-1]}" in
 863         -s|--strategy)
 864                 __gitcomp "$(__git_merge_strategies)"
 865                 return
 866         esac
 867         case "$cur" in
 868         --strategy=*)
 869                 __gitcomp "$(__git_merge_strategies)" "" "${cur##--strategy=}"
 870                 return
 871                 ;;
 872         --*)
 873                 __gitcomp "
 874                         --no-commit --no-stat --log --no-log --squash --strategy
 875                         "
 876                 return
 877         esac
 878         __gitcomp "$(__git_refs)"
 879 }
 880
 881 _git_merge_base ()
 882 {
 883         __gitcomp "$(__git_refs)"
 884 }
 885
 886 _git_name_rev ()
 887 {
 888         __gitcomp "--tags --all --stdin"
 889 }
 890
 891 _git_pull ()
 892 {
 893         local cur="${COMP_WORDS[COMP_CWORD]}"
 894
 895         case "${COMP_WORDS[0]},$COMP_CWORD" in
 896         git-pull*,1)
 897                 __gitcomp "$(__git_remotes)"
 898                 ;;
 899         git,2)
 900                 __gitcomp "$(__git_remotes)"
 901                 ;;
 902         *)
 903                 local remote
 904                 case "${COMP_WORDS[0]}" in
 905                 git-pull)  remote="${COMP_WORDS[1]}" ;;
 906                 git)       remote="${COMP_WORDS[2]}" ;;
 907                 esac
 908                 __gitcomp "$(__git_refs "$remote")"
 909                 ;;
 910         esac
 911 }
 912
 913 _git_push ()
 914 {
 915         local cur="${COMP_WORDS[COMP_CWORD]}"
 916
 917         case "${COMP_WORDS[0]},$COMP_CWORD" in
 918         git-push*,1)
 919                 __gitcomp "$(__git_remotes)"
 920                 ;;
 921         git,2)
 922                 __gitcomp "$(__git_remotes)"
 923                 ;;
 924         *)
 925                 case "$cur" in
 926                 *:*)
 927                         local remote
 928                         case "${COMP_WORDS[0]}" in
 929                         git-push)  remote="${COMP_WORDS[1]}" ;;
 930                         git)       remote="${COMP_WORDS[2]}" ;;
 931                         esac
 932
 933                         local pfx=""
 934                         case "$COMP_WORDBREAKS" in
 935                         *:*) : great ;;
 936                         *)   pfx="${cur%%:*}:" ;;
 937                         esac
 938
 939                         __gitcomp "$(__git_refs "$remote")" "$pfx" "${cur#*:}"
 940                         ;;
 941                 +*)
 942                         __gitcomp "$(__git_refs)" + "${cur#+}"
 943                         ;;
 944                 *)
 945                         __gitcomp "$(__git_refs)"
 946                         ;;
 947                 esac
 948                 ;;
 949         esac
 950 }
 951
 952 _git_rebase ()
 953 {
 954         local cur="${COMP_WORDS[COMP_CWORD]}" dir="$(__gitdir)"
 955         if [ -d "$dir"/rebase-apply ] || [ -d "$dir"/rebase-merge ]; then
 956                 __gitcomp "--continue --skip --abort"
 957                 return
 958         fi
 959         case "${COMP_WORDS[COMP_CWORD-1]}" in
 960         -s|--strategy)
 961                 __gitcomp "$(__git_merge_strategies)"
 962                 return
 963         esac
 964         case "$cur" in
 965         --strategy=*)
 966                 __gitcomp "$(__git_merge_strategies)" "" "${cur##--strategy=}"
 967                 return
 968                 ;;
 969         --*)
 970                 __gitcomp "--onto --merge --strategy --interactive"
 971                 return
 972         esac
 973         __gitcomp "$(__git_refs)"
 974 }
 975
 976 _git_send_email ()
 977 {
 978         local cur="${COMP_WORDS[COMP_CWORD]}"
 979         case "$cur" in
 980         --*)
 981                 __gitcomp "--bcc --cc --cc-cmd --chain-reply-to --compose
 982                         --dry-run --envelope-sender --from --identity
 983                         --in-reply-to --no-chain-reply-to --no-signed-off-by-cc
 984                         --no-suppress-from --no-thread --quiet
 985                         --signed-off-by-cc --smtp-pass --smtp-server
 986                         --smtp-server-port --smtp-ssl --smtp-user --subject
 987                         --suppress-cc --suppress-from --thread --to"
 988                 return
 989                 ;;
 990         esac
 991         COMPREPLY=()
 992 }
 993
 994 _git_config ()
 995 {
 996         local cur="${COMP_WORDS[COMP_CWORD]}"
 997         local prv="${COMP_WORDS[COMP_CWORD-1]}"
 998         case "$prv" in
 999         branch.*.remote)
1000                 __gitcomp "$(__git_remotes)"
1001                 return
1002                 ;;
1003         branch.*.merge)
1004                 __gitcomp "$(__git_refs)"
1005                 return
1006                 ;;
1007         remote.*.fetch)
1008                 local remote="${prv#remote.}"
1009                 remote="${remote%.fetch}"
1010                 __gitcomp "$(__git_refs_remotes "$remote")"
1011                 return
1012                 ;;
1013         remote.*.push)
1014                 local remote="${prv#remote.}"
1015                 remote="${remote%.push}"
1016                 __gitcomp "$(git --git-dir="$(__gitdir)" \
1017                         for-each-ref --format='%(refname):%(refname)' \
1018                         refs/heads)"
1019                 return
1020                 ;;
1021         pull.twohead|pull.octopus)
1022                 __gitcomp "$(__git_merge_strategies)"
1023                 return
1024                 ;;
1025         color.branch|color.diff|color.status)
1026                 __gitcomp "always never auto"
1027                 return
1028                 ;;
1029         color.*.*)
1030                 __gitcomp "
1031                         black red green yellow blue magenta cyan white
1032                         bold dim ul blink reverse
1033                         "
1034                 return
1035                 ;;
1036         *.*)
1037                 COMPREPLY=()
1038                 return
1039                 ;;
1040         esac
1041         case "$cur" in
1042         --*)
1043                 __gitcomp "
1044                         --global --system --file=
1045                         --list --replace-all
1046                         --get --get-all --get-regexp
1047                         --add --unset --unset-all
1048                         --remove-section --rename-section
1049                         "
1050                 return
1051                 ;;
1052         branch.*.*)
1053                 local pfx="${cur%.*}."
1054                 cur="${cur##*.}"
1055                 __gitcomp "remote merge" "$pfx" "$cur"
1056                 return
1057                 ;;
1058         branch.*)
1059                 local pfx="${cur%.*}."
1060                 cur="${cur#*.}"
1061                 __gitcomp "$(__git_heads)" "$pfx" "$cur" "."
1062                 return
1063                 ;;
1064         remote.*.*)
1065                 local pfx="${cur%.*}."
1066                 cur="${cur##*.}"
1067                 __gitcomp "
1068                         url fetch push skipDefaultUpdate
1069                         receivepack uploadpack tagopt
1070                         " "$pfx" "$cur"
1071                 return
1072                 ;;
1073         remote.*)
1074                 local pfx="${cur%.*}."
1075                 cur="${cur#*.}"
1076                 __gitcomp "$(__git_remotes)" "$pfx" "$cur" "."
1077                 return
1078                 ;;
1079         esac
1080         __gitcomp "
1081                 apply.whitespace
1082                 core.fileMode
1083                 core.gitProxy
1084                 core.ignoreStat
1085                 core.preferSymlinkRefs
1086                 core.logAllRefUpdates
1087                 core.loosecompression
1088                 core.repositoryFormatVersion
1089                 core.sharedRepository
1090                 core.warnAmbiguousRefs
1091                 core.compression
1092                 core.packedGitWindowSize
1093                 core.packedGitLimit
1094                 clean.requireForce
1095                 color.branch
1096                 color.branch.current
1097                 color.branch.local
1098                 color.branch.remote
1099                 color.branch.plain
1100                 color.diff
1101                 color.diff.plain
1102                 color.diff.meta
1103                 color.diff.frag
1104                 color.diff.old
1105                 color.diff.new
1106                 color.diff.commit
1107                 color.diff.whitespace
1108                 color.pager
1109                 color.status
1110                 color.status.header
1111                 color.status.added
1112                 color.status.changed
1113                 color.status.untracked
1114                 diff.renameLimit
1115                 diff.renames
1116                 fetch.unpackLimit
1117                 format.headers
1118                 format.subjectprefix
1119                 gitcvs.enabled
1120                 gitcvs.logfile
1121                 gitcvs.allbinary
1122                 gitcvs.dbname gitcvs.dbdriver gitcvs.dbuser gitcvs.dbpass
1123                 gitcvs.dbtablenameprefix
1124                 gc.packrefs
1125                 gc.reflogexpire
1126                 gc.reflogexpireunreachable
1127                 gc.rerereresolved
1128                 gc.rerereunresolved
1129                 http.sslVerify
1130                 http.sslCert
1131                 http.sslKey
1132                 http.sslCAInfo
1133                 http.sslCAPath
1134                 http.maxRequests
1135                 http.lowSpeedLimit
1136                 http.lowSpeedTime
1137                 http.noEPSV
1138                 i18n.commitEncoding
1139                 i18n.logOutputEncoding
1140                 log.showroot
1141                 merge.tool
1142                 merge.summary
1143                 merge.verbosity
1144                 pack.window
1145                 pack.depth
1146                 pack.windowMemory
1147                 pack.compression
1148                 pack.deltaCacheSize
1149                 pack.deltaCacheLimit
1150                 pull.octopus
1151                 pull.twohead
1152                 repack.useDeltaBaseOffset
1153                 showbranch.default
1154                 tar.umask
1155                 transfer.unpackLimit
1156                 receive.unpackLimit
1157                 receive.denyNonFastForwards
1158                 user.name
1159                 user.email
1160                 user.signingkey
1161                 branch. remote.
1162         "
1163 }
1164
1165 _git_remote ()
1166 {
1167         local subcommands="add rm show prune update"
1168         local subcommand="$(__git_find_subcommand "$subcommands")"
1169         if [ -z "$subcommand" ]; then
1170                 __gitcomp "$subcommands"
1171                 return
1172         fi
1173
1174         case "$subcommand" in
1175         rm|show|prune)
1176                 __gitcomp "$(__git_remotes)"
1177                 ;;
1178         update)
1179                 local i c='' IFS=$'\n'
1180                 for i in $(git --git-dir="$(__gitdir)" config --list); do
1181                         case "$i" in
1182                         remotes.*)
1183                                 i="${i#remotes.}"
1184                                 c="$c ${i/=*/}"
1185                                 ;;
1186                         esac
1187                 done
1188                 __gitcomp "$c"
1189                 ;;
1190         *)
1191                 COMPREPLY=()
1192                 ;;
1193         esac
1194 }
1195
1196 _git_reset ()
1197 {
1198         __git_has_doubledash && return
1199
1200         local cur="${COMP_WORDS[COMP_CWORD]}"
1201         case "$cur" in
1202         --*)
1203                 __gitcomp "--mixed --hard --soft"
1204                 return
1205                 ;;
1206         esac
1207         __gitcomp "$(__git_refs)"
1208 }
1209
1210 _git_rm ()
1211 {
1212         __git_has_doubledash && return
1213
1214         local cur="${COMP_WORDS[COMP_CWORD]}"
1215         case "$cur" in
1216         --*)
1217                 __gitcomp "--cached --dry-run --ignore-unmatch --quiet"
1218                 return
1219                 ;;
1220         esac
1221         COMPREPLY=()
1222 }
1223
1224 _git_shortlog ()
1225 {
1226         __git_has_doubledash && return
1227
1228         local cur="${COMP_WORDS[COMP_CWORD]}"
1229         case "$cur" in
1230         --*)
1231                 __gitcomp "
1232                         --max-count= --max-age= --since= --after=
1233                         --min-age= --before= --until=
1234                         --no-merges
1235                         --author= --committer= --grep=
1236                         --all-match
1237                         --not --all
1238                         --numbered --summary
1239                         "
1240                 return
1241                 ;;
1242         esac
1243         __git_complete_revlist
1244 }
1245
1246 _git_show ()
1247 {
1248         local cur="${COMP_WORDS[COMP_CWORD]}"
1249         case "$cur" in
1250         --pretty=*)
1251                 __gitcomp "
1252                         oneline short medium full fuller email raw
1253                         " "" "${cur##--pretty=}"
1254                 return
1255                 ;;
1256         --*)
1257                 __gitcomp "--pretty="
1258                 return
1259                 ;;
1260         esac
1261         __git_complete_file
1262 }
1263
1264 _git_show_branch ()
1265 {
1266         local cur="${COMP_WORDS[COMP_CWORD]}"
1267         case "$cur" in
1268         --*)
1269                 __gitcomp "
1270                         --all --remotes --topo-order --current --more=
1271                         --list --independent --merge-base --no-name
1272                         --sha1-name --topics --reflog
1273                         "
1274                 return
1275                 ;;
1276         esac
1277         __git_complete_revlist
1278 }
1279
1280 _git_stash ()
1281 {
1282         local subcommands='save list show apply clear drop pop create'
1283         local subcommand="$(__git_find_subcommand "$subcommands")"
1284         if [ -z "$subcommand" ]; then
1285                 __gitcomp "$subcommands"
1286         else
1287                 local cur="${COMP_WORDS[COMP_CWORD]}"
1288                 case "$subcommand,$cur" in
1289                 save,--*)
1290                         __gitcomp "--keep-index"
1291                         ;;
1292                 *)
1293                         COMPREPLY=()
1294                         ;;
1295                 esac
1296         fi
1297 }
1298
1299 _git_submodule ()
1300 {
1301         __git_has_doubledash && return
1302
1303         local subcommands="add status init update"
1304         if [ -z "$(__git_find_subcommand "$subcommands")" ]; then
1305                 local cur="${COMP_WORDS[COMP_CWORD]}"
1306                 case "$cur" in
1307                 --*)
1308                         __gitcomp "--quiet --cached"
1309                         ;;
1310                 *)
1311                         __gitcomp "$subcommands"
1312                         ;;
1313                 esac
1314                 return
1315         fi
1316 }
1317
1318 _git_svn ()
1319 {
1320         local subcommands="
1321                 init fetch clone rebase dcommit log find-rev
1322                 set-tree commit-diff info create-ignore propget
1323                 proplist show-ignore show-externals
1324                 "
1325         local subcommand="$(__git_find_subcommand "$subcommands")"
1326         if [ -z "$subcommand" ]; then
1327                 __gitcomp "$subcommands"
1328         else
1329                 local remote_opts="--username= --config-dir= --no-auth-cache"
1330                 local fc_opts="
1331                         --follow-parent --authors-file= --repack=
1332                         --no-metadata --use-svm-props --use-svnsync-props
1333                         --log-window-size= --no-checkout --quiet
1334                         --repack-flags --user-log-author $remote_opts
1335                         "
1336                 local init_opts="
1337                         --template= --shared= --trunk= --tags=
1338                         --branches= --stdlayout --minimize-url
1339                         --no-metadata --use-svm-props --use-svnsync-props
1340                         --rewrite-root= $remote_opts
1341                         "
1342                 local cmt_opts="
1343                         --edit --rmdir --find-copies-harder --copy-similarity=
1344                         "
1345
1346                 local cur="${COMP_WORDS[COMP_CWORD]}"
1347                 case "$subcommand,$cur" in
1348                 fetch,--*)
1349                         __gitcomp "--revision= --fetch-all $fc_opts"
1350                         ;;
1351                 clone,--*)
1352                         __gitcomp "--revision= $fc_opts $init_opts"
1353                         ;;
1354                 init,--*)
1355                         __gitcomp "$init_opts"
1356                         ;;
1357                 dcommit,--*)
1358                         __gitcomp "
1359                                 --merge --strategy= --verbose --dry-run
1360                                 --fetch-all --no-rebase $cmt_opts $fc_opts
1361                                 "
1362                         ;;
1363                 set-tree,--*)
1364                         __gitcomp "--stdin $cmt_opts $fc_opts"
1365                         ;;
1366                 create-ignore,--*|propget,--*|proplist,--*|show-ignore,--*|\
1367                 show-externals,--*)
1368                         __gitcomp "--revision="
1369                         ;;
1370                 log,--*)
1371                         __gitcomp "
1372                                 --limit= --revision= --verbose --incremental
1373                                 --oneline --show-commit --non-recursive
1374                                 --authors-file=
1375                                 "
1376                         ;;
1377                 rebase,--*)
1378                         __gitcomp "
1379                                 --merge --verbose --strategy= --local
1380                                 --fetch-all $fc_opts
1381                                 "
1382                         ;;
1383                 commit-diff,--*)
1384                         __gitcomp "--message= --file= --revision= $cmt_opts"
1385                         ;;
1386                 info,--*)
1387                         __gitcomp "--url"
1388                         ;;
1389                 *)
1390                         COMPREPLY=()
1391                         ;;
1392                 esac
1393         fi
1394 }
1395
1396 _git_tag ()
1397 {
1398         local i c=1 f=0
1399         while [ $c -lt $COMP_CWORD ]; do
1400                 i="${COMP_WORDS[c]}"
1401                 case "$i" in
1402                 -d|-v)
1403                         __gitcomp "$(__git_tags)"
1404                         return
1405                         ;;
1406                 -f)
1407                         f=1
1408                         ;;
1409                 esac
1410                 c=$((++c))
1411         done
1412
1413         case "${COMP_WORDS[COMP_CWORD-1]}" in
1414         -m|-F)
1415                 COMPREPLY=()
1416                 ;;
1417         -*|tag|git-tag)
1418                 if [ $f = 1 ]; then
1419                         __gitcomp "$(__git_tags)"
1420                 else
1421                         COMPREPLY=()
1422                 fi
1423                 ;;
1424         *)
1425                 __gitcomp "$(__git_refs)"
1426                 ;;
1427         esac
1428 }
1429
1430 _git ()
1431 {
1432         local i c=1 command __git_dir
1433
1434         while [ $c -lt $COMP_CWORD ]; do
1435                 i="${COMP_WORDS[c]}"
1436                 case "$i" in
1437                 --git-dir=*) __git_dir="${i#--git-dir=}" ;;
1438                 --bare)      __git_dir="." ;;
1439                 --version|-p|--paginate) ;;
1440                 --help) command="help"; break ;;
1441                 *) command="$i"; break ;;
1442                 esac
1443                 c=$((++c))
1444         done
1445
1446         if [ -z "$command" ]; then
1447                 case "${COMP_WORDS[COMP_CWORD]}" in
1448                 --*=*) COMPREPLY=() ;;
1449                 --*)   __gitcomp "
1450                         --paginate
1451                         --no-pager
1452                         --git-dir=
1453                         --bare
1454                         --version
1455                         --exec-path
1456                         --work-tree=
1457                         --help
1458                         "
1459                         ;;
1460                 *)     __gitcomp "$(__git_porcelain_commands) $(__git_aliases)" ;;
1461                 esac
1462                 return
1463         fi
1464
1465         local expansion=$(__git_aliased_command "$command")
1466         [ "$expansion" ] && command="$expansion"
1467
1468         case "$command" in
1469         am)          _git_am ;;
1470         add)         _git_add ;;
1471         apply)       _git_apply ;;
1472         bisect)      _git_bisect ;;
1473         bundle)      _git_bundle ;;
1474         branch)      _git_branch ;;
1475         checkout)    _git_checkout ;;
1476         cherry)      _git_cherry ;;
1477         cherry-pick) _git_cherry_pick ;;
1478         commit)      _git_commit ;;
1479         config)      _git_config ;;
1480         describe)    _git_describe ;;
1481         diff)        _git_diff ;;
1482         fetch)       _git_fetch ;;
1483         format-patch) _git_format_patch ;;
1484         gc)          _git_gc ;;
1485         help)        _git_help ;;
1486         log)         _git_log ;;
1487         ls-remote)   _git_ls_remote ;;
1488         ls-tree)     _git_ls_tree ;;
1489         merge)       _git_merge;;
1490         merge-base)  _git_merge_base ;;
1491         name-rev)    _git_name_rev ;;
1492         pull)        _git_pull ;;
1493         push)        _git_push ;;
1494         rebase)      _git_rebase ;;
1495         remote)      _git_remote ;;
1496         reset)       _git_reset ;;
1497         rm)          _git_rm ;;
1498         send-email)  _git_send_email ;;
1499         shortlog)    _git_shortlog ;;
1500         show)        _git_show ;;
1501         show-branch) _git_show_branch ;;
1502         stash)       _git_stash ;;
1503         submodule)   _git_submodule ;;
1504         svn)         _git_svn ;;
1505         tag)         _git_tag ;;
1506         whatchanged) _git_log ;;
1507         *)           COMPREPLY=() ;;
1508         esac
1509 }
1510
1511 _gitk ()
1512 {
1513         __git_has_doubledash && return
1514
1515         local cur="${COMP_WORDS[COMP_CWORD]}"
1516         local g="$(git rev-parse --git-dir 2>/dev/null)"
1517         local merge=""
1518         if [ -f $g/MERGE_HEAD ]; then
1519                 merge="--merge"
1520         fi
1521         case "$cur" in
1522         --*)
1523                 __gitcomp "--not --all $merge"
1524                 return
1525                 ;;
1526         esac
1527         __git_complete_revlist
1528 }
1529
1530 complete -o default -o nospace -F _git git
1531 complete -o default -o nospace -F _gitk gitk
1532
1533 # The following are necessary only for Cygwin, and only are needed
1534 # when the user has tab-completed the executable name and consequently
1535 # included the '.exe' suffix.
1536 #
1537 if [ Cygwin = "$(uname -o 2>/dev/null)" ]; then
1538 complete -o default -o nospace -F _git git.exe
1539 fi