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