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