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