be978cf3d3d5f4368a882596ed152f94f6affb32
   1#
   2# bash completion support for core Git.
   3#
   4# Copyright (C) 2006 Shawn Pearce
   5# Conceptually based on gitcompletion (http://gitweb.hawaga.org.uk/).
   6#
   7# The contained completion routines provide support for completing:
   8#
   9#    *) local and remote branch names
  10#    *) local and remote tag names
  11#    *) .git/remotes file names
  12#    *) git 'subcommands'
  13#    *) tree paths within 'ref:path/to/file' expressions
  14#
  15# To use these routines:
  16#
  17#    1) Copy this file to somewhere (e.g. ~/.git-completion.sh).
  18#    2) Added the following line to your .bashrc:
  19#        source ~/.git-completion.sh
  20#
  21#    3) You may want to make sure the git executable is available
  22#       in your PATH before this script is sourced, as some caching
  23#       is performed while the script loads.  If git isn't found
  24#       at source time then all lookups will be done on demand,
  25#       which may be slightly slower.
  26#
  27#    4) Consider changing your PS1 to also show the current branch:
  28#        PS1='[\u@\h \W$(__git_ps1 " (%s)")]\$ '
  29#
  30#       The argument to __git_ps1 will be displayed only if you
  31#       are currently in a git repository.  The %s token will be
  32#       the name of the current branch.
  33#
  34
  35__gitdir ()
  36{
  37        echo "${__git_dir:-$(git rev-parse --git-dir 2>/dev/null)}"
  38}
  39
  40__git_ps1 ()
  41{
  42        local b="$(git symbolic-ref HEAD 2>/dev/null)"
  43        if [ -n "$b" ]; then
  44                if [ -n "$1" ]; then
  45                        printf "$1" "${b##refs/heads/}"
  46                else
  47                        printf " (%s)" "${b##refs/heads/}"
  48                fi
  49        fi
  50}
  51
  52__git_heads ()
  53{
  54        local cmd i is_hash=y dir="${1:-$(__gitdir)}"
  55        if [ -d "$dir" ]; then
  56                for i in $(git --git-dir="$dir" \
  57                        for-each-ref --format='%(refname)' \
  58                        refs/heads ); do
  59                        echo "${i#refs/heads/}"
  60                done
  61                return
  62        fi
  63        for i in $(git-ls-remote "$dir" 2>/dev/null); do
  64                case "$is_hash,$i" in
  65                y,*) is_hash=n ;;
  66                n,*^{}) is_hash=y ;;
  67                n,refs/heads/*) is_hash=y; echo "${i#refs/heads/}" ;;
  68                n,*) is_hash=y; echo "$i" ;;
  69                esac
  70        done
  71}
  72
  73__git_refs ()
  74{
  75        local cmd i is_hash=y dir="${1:-$(__gitdir)}"
  76        if [ -d "$dir" ]; then
  77                if [ -e "$dir/HEAD" ]; then echo HEAD; fi
  78                for i in $(git --git-dir="$dir" \
  79                        for-each-ref --format='%(refname)' \
  80                        refs/tags refs/heads refs/remotes); do
  81                        case "$i" in
  82                                refs/tags/*)    echo "${i#refs/tags/}" ;;
  83                                refs/heads/*)   echo "${i#refs/heads/}" ;;
  84                                refs/remotes/*) echo "${i#refs/remotes/}" ;;
  85                                *)              echo "$i" ;;
  86                        esac
  87                done
  88                return
  89        fi
  90        for i in $(git-ls-remote "$dir" 2>/dev/null); do
  91                case "$is_hash,$i" in
  92                y,*) is_hash=n ;;
  93                n,*^{}) is_hash=y ;;
  94                n,refs/tags/*) is_hash=y; echo "${i#refs/tags/}" ;;
  95                n,refs/heads/*) is_hash=y; echo "${i#refs/heads/}" ;;
  96                n,refs/remotes/*) is_hash=y; echo "${i#refs/remotes/}" ;;
  97                n,*) is_hash=y; echo "$i" ;;
  98                esac
  99        done
 100}
 101
 102__git_refs2 ()
 103{
 104        local cmd i is_hash=y dir="${1:-$(__gitdir)}"
 105        if [ -d "$dir" ]; then
 106                cmd=git-peek-remote
 107        else
 108                cmd=git-ls-remote
 109        fi
 110        for i in $($cmd "$dir" 2>/dev/null); do
 111                case "$is_hash,$i" in
 112                y,*) is_hash=n ;;
 113                n,*^{}) is_hash=y ;;
 114                n,refs/tags/*) is_hash=y; echo "${i#refs/tags/}:${i#refs/tags/}" ;;
 115                n,refs/heads/*) is_hash=y; echo "${i#refs/heads/}:${i#refs/heads/}" ;;
 116                n,*) is_hash=y; echo "$i:$i" ;;
 117                esac
 118        done
 119}
 120
 121__git_refs_remotes ()
 122{
 123        local cmd i is_hash=y
 124        for i in $(git-ls-remote "$1" 2>/dev/null); do
 125                case "$is_hash,$i" in
 126                n,refs/heads/*)
 127                        is_hash=y
 128                        echo "$i:refs/remotes/$1/${i#refs/heads/}"
 129                        ;;
 130                y,*) is_hash=n ;;
 131                n,*^{}) is_hash=y ;;
 132                n,refs/tags/*) is_hash=y;;
 133                n,*) is_hash=y; ;;
 134                esac
 135        done
 136}
 137
 138__git_remotes ()
 139{
 140        local i ngoff IFS=$'\n' d="$(__gitdir)"
 141        shopt -q nullglob || ngoff=1
 142        shopt -s nullglob
 143        for i in "$d/remotes"/*; do
 144                echo ${i#$d/remotes/}
 145        done
 146        [ "$ngoff" ] && shopt -u nullglob
 147        for i in $(git --git-dir="$d" repo-config --list); do
 148                case "$i" in
 149                remote.*.url=*)
 150                        i="${i#remote.}"
 151                        echo "${i/.url=*/}"
 152                        ;;
 153                esac
 154        done
 155}
 156
 157__git_merge_strategies ()
 158{
 159        if [ -n "$__git_merge_strategylist" ]; then
 160                echo "$__git_merge_strategylist"
 161                return
 162        fi
 163        sed -n "/^all_strategies='/{
 164                s/^all_strategies='//
 165                s/'//
 166                p
 167                q
 168                }" "$(git --exec-path)/git-merge"
 169}
 170__git_merge_strategylist=
 171__git_merge_strategylist="$(__git_merge_strategies 2>/dev/null)"
 172
 173__git_complete_file ()
 174{
 175        local pfx ls ref cur="${COMP_WORDS[COMP_CWORD]}"
 176        case "$cur" in
 177        ?*:*)
 178                ref="${cur%%:*}"
 179                cur="${cur#*:}"
 180                case "$cur" in
 181                ?*/*)
 182                        pfx="${cur%/*}"
 183                        cur="${cur##*/}"
 184                        ls="$ref:$pfx"
 185                        pfx="$pfx/"
 186                        ;;
 187                *)
 188                        ls="$ref"
 189                        ;;
 190            esac
 191                COMPREPLY=($(compgen -P "$pfx" \
 192                        -W "$(git --git-dir="$(__gitdir)" ls-tree "$ls" \
 193                                | sed '/^100... blob /s,^.*     ,,
 194                                       /^040000 tree /{
 195                                           s,^.*        ,,
 196                                           s,$,/,
 197                                       }
 198                                       s/^.*    //')" \
 199                        -- "$cur"))
 200                ;;
 201        *)
 202                COMPREPLY=($(compgen -W "$(__git_refs)" -- "$cur"))
 203                ;;
 204        esac
 205}
 206
 207__git_complete_revlist ()
 208{
 209        local pfx cur="${COMP_WORDS[COMP_CWORD]}"
 210        case "$cur" in
 211        *...*)
 212                pfx="${cur%...*}..."
 213                cur="${cur#*...}"
 214                COMPREPLY=($(compgen -P "$pfx" -W "$(__git_refs)" -- "$cur"))
 215                ;;
 216        *..*)
 217                pfx="${cur%..*}.."
 218                cur="${cur#*..}"
 219                COMPREPLY=($(compgen -P "$pfx" -W "$(__git_refs)" -- "$cur"))
 220                ;;
 221        *)
 222                COMPREPLY=($(compgen -W "$(__git_refs)" -- "$cur"))
 223                ;;
 224        esac
 225}
 226
 227__git_commands ()
 228{
 229        if [ -n "$__git_commandlist" ]; then
 230                echo "$__git_commandlist"
 231                return
 232        fi
 233        local i IFS=" "$'\n'
 234        for i in $(git help -a|egrep '^ ')
 235        do
 236                case $i in
 237                check-ref-format) : plumbing;;
 238                commit-tree)      : plumbing;;
 239                convert-objects)  : plumbing;;
 240                cvsserver)        : daemon;;
 241                daemon)           : daemon;;
 242                fetch-pack)       : plumbing;;
 243                hash-object)      : plumbing;;
 244                http-*)           : transport;;
 245                index-pack)       : plumbing;;
 246                local-fetch)      : plumbing;;
 247                mailinfo)         : plumbing;;
 248                mailsplit)        : plumbing;;
 249                merge-*)          : plumbing;;
 250                mktree)           : plumbing;;
 251                mktag)            : plumbing;;
 252                pack-objects)     : plumbing;;
 253                pack-redundant)   : plumbing;;
 254                pack-refs)        : plumbing;;
 255                parse-remote)     : plumbing;;
 256                patch-id)         : plumbing;;
 257                peek-remote)      : plumbing;;
 258                read-tree)        : plumbing;;
 259                receive-pack)     : plumbing;;
 260                rerere)           : plumbing;;
 261                rev-list)         : plumbing;;
 262                rev-parse)        : plumbing;;
 263                runstatus)        : plumbing;;
 264                sh-setup)         : internal;;
 265                shell)            : daemon;;
 266                send-pack)        : plumbing;;
 267                show-index)       : plumbing;;
 268                ssh-*)            : transport;;
 269                stripspace)       : plumbing;;
 270                symbolic-ref)     : plumbing;;
 271                unpack-file)      : plumbing;;
 272                unpack-objects)   : plumbing;;
 273                update-ref)       : plumbing;;
 274                update-server-info) : daemon;;
 275                upload-archive)   : plumbing;;
 276                upload-pack)      : plumbing;;
 277                write-tree)       : plumbing;;
 278                *) echo $i;;
 279                esac
 280        done
 281}
 282__git_commandlist=
 283__git_commandlist="$(__git_commands 2>/dev/null)"
 284
 285__git_aliases ()
 286{
 287        local i IFS=$'\n'
 288        for i in $(git --git-dir="$(__gitdir)" repo-config --list); do
 289                case "$i" in
 290                alias.*)
 291                        i="${i#alias.}"
 292                        echo "${i/=*/}"
 293                        ;;
 294                esac
 295        done
 296}
 297
 298__git_aliased_command ()
 299{
 300        local word cmdline=$(git --git-dir="$(__gitdir)" \
 301                repo-config --get "alias.$1")
 302        for word in $cmdline; do
 303                if [ "${word##-*}" ]; then
 304                        echo $word
 305                        return
 306                fi
 307        done
 308}
 309
 310__git_whitespacelist="nowarn warn error error-all strip"
 311
 312_git_am ()
 313{
 314        local cur="${COMP_WORDS[COMP_CWORD]}"
 315        if [ -d .dotest ]; then
 316                COMPREPLY=($(compgen -W "
 317                        --skip --resolved
 318                        " -- "$cur"))
 319                return
 320        fi
 321        case "$cur" in
 322        --whitespace=*)
 323                COMPREPLY=($(compgen -W "$__git_whitespacelist" \
 324                        -- "${cur##--whitespace=}"))
 325                return
 326                ;;
 327        --*)
 328                COMPREPLY=($(compgen -W "
 329                        --signoff --utf8 --binary --3way --interactive
 330                        --whitespace=
 331                        " -- "$cur"))
 332                return
 333        esac
 334        COMPREPLY=()
 335}
 336
 337_git_apply ()
 338{
 339        local cur="${COMP_WORDS[COMP_CWORD]}"
 340        case "$cur" in
 341        --whitespace=*)
 342                COMPREPLY=($(compgen -W "$__git_whitespacelist" \
 343                        -- "${cur##--whitespace=}"))
 344                return
 345                ;;
 346        --*)
 347                COMPREPLY=($(compgen -W "
 348                        --stat --numstat --summary --check --index
 349                        --cached --index-info --reverse --reject --unidiff-zero
 350                        --apply --no-add --exclude=
 351                        --whitespace= --inaccurate-eof --verbose
 352                        " -- "$cur"))
 353                return
 354        esac
 355        COMPREPLY=()
 356}
 357
 358_git_branch ()
 359{
 360        local cur="${COMP_WORDS[COMP_CWORD]}"
 361        COMPREPLY=($(compgen -W "-l -f -d -D $(__git_refs)" -- "$cur"))
 362}
 363
 364_git_cat_file ()
 365{
 366        local cur="${COMP_WORDS[COMP_CWORD]}"
 367        case "${COMP_WORDS[0]},$COMP_CWORD" in
 368        git-cat-file*,1)
 369                COMPREPLY=($(compgen -W "-p -t blob tree commit tag" -- "$cur"))
 370                ;;
 371        git,2)
 372                COMPREPLY=($(compgen -W "-p -t blob tree commit tag" -- "$cur"))
 373                ;;
 374        *)
 375                __git_complete_file
 376                ;;
 377        esac
 378}
 379
 380_git_checkout ()
 381{
 382        local cur="${COMP_WORDS[COMP_CWORD]}"
 383        COMPREPLY=($(compgen -W "-l -b $(__git_refs)" -- "$cur"))
 384}
 385
 386_git_cherry_pick ()
 387{
 388        local cur="${COMP_WORDS[COMP_CWORD]}"
 389        case "$cur" in
 390        --*)
 391                COMPREPLY=($(compgen -W "
 392                        --edit --no-commit
 393                        " -- "$cur"))
 394                ;;
 395        *)
 396                COMPREPLY=($(compgen -W "$(__git_refs)" -- "$cur"))
 397                ;;
 398        esac
 399}
 400
 401_git_commit ()
 402{
 403        local cur="${COMP_WORDS[COMP_CWORD]}"
 404        case "$cur" in
 405        --*)
 406                COMPREPLY=($(compgen -W "
 407                        --all --author= --signoff --verify --no-verify
 408                        --edit --amend --include --only
 409                        " -- "$cur"))
 410                return
 411        esac
 412        COMPREPLY=()
 413}
 414
 415_git_diff ()
 416{
 417        __git_complete_file
 418}
 419
 420_git_diff_tree ()
 421{
 422        local cur="${COMP_WORDS[COMP_CWORD]}"
 423        COMPREPLY=($(compgen -W "-r -p -M $(__git_refs)" -- "$cur"))
 424}
 425
 426_git_fetch ()
 427{
 428        local cur="${COMP_WORDS[COMP_CWORD]}"
 429
 430        case "${COMP_WORDS[0]},$COMP_CWORD" in
 431        git-fetch*,1)
 432                COMPREPLY=($(compgen -W "$(__git_remotes)" -- "$cur"))
 433                ;;
 434        git,2)
 435                COMPREPLY=($(compgen -W "$(__git_remotes)" -- "$cur"))
 436                ;;
 437        *)
 438                case "$cur" in
 439                *:*)
 440                        cur="${cur#*:}"
 441                        COMPREPLY=($(compgen -W "$(__git_refs)" -- "$cur"))
 442                        ;;
 443                *)
 444                        local remote
 445                        case "${COMP_WORDS[0]}" in
 446                        git-fetch) remote="${COMP_WORDS[1]}" ;;
 447                        git)       remote="${COMP_WORDS[2]}" ;;
 448                        esac
 449                        COMPREPLY=($(compgen -W "$(__git_refs2 "$remote")" -- "$cur"))
 450                        ;;
 451                esac
 452                ;;
 453        esac
 454}
 455
 456_git_format_patch ()
 457{
 458        local cur="${COMP_WORDS[COMP_CWORD]}"
 459        case "$cur" in
 460        --*)
 461                COMPREPLY=($(compgen -W "
 462                        --stdout --attach --thread
 463                        --output-directory
 464                        --numbered --start-number
 465                        --keep-subject
 466                        --signoff
 467                        --in-reply-to=
 468                        --full-index --binary
 469                        " -- "$cur"))
 470                return
 471                ;;
 472        esac
 473        __git_complete_revlist
 474}
 475
 476_git_ls_remote ()
 477{
 478        local cur="${COMP_WORDS[COMP_CWORD]}"
 479        COMPREPLY=($(compgen -W "$(__git_remotes)" -- "$cur"))
 480}
 481
 482_git_ls_tree ()
 483{
 484        __git_complete_file
 485}
 486
 487_git_log ()
 488{
 489        local cur="${COMP_WORDS[COMP_CWORD]}"
 490        case "$cur" in
 491        --pretty=*)
 492                COMPREPLY=($(compgen -W "
 493                        oneline short medium full fuller email raw
 494                        " -- "${cur##--pretty=}"))
 495                return
 496                ;;
 497        --*)
 498                COMPREPLY=($(compgen -W "
 499                        --max-count= --max-age= --since= --after=
 500                        --min-age= --before= --until=
 501                        --root --not --topo-order --date-order
 502                        --no-merges
 503                        --abbrev-commit --abbrev=
 504                        --relative-date
 505                        --author= --committer= --grep=
 506                        --all-match
 507                        --pretty= --name-status --name-only
 508                        " -- "$cur"))
 509                return
 510                ;;
 511        esac
 512        __git_complete_revlist
 513}
 514
 515_git_merge ()
 516{
 517        local cur="${COMP_WORDS[COMP_CWORD]}"
 518        case "${COMP_WORDS[COMP_CWORD-1]}" in
 519        -s|--strategy)
 520                COMPREPLY=($(compgen -W "$(__git_merge_strategies)" -- "$cur"))
 521                return
 522        esac
 523        case "$cur" in
 524        --strategy=*)
 525                COMPREPLY=($(compgen -W "$(__git_merge_strategies)" \
 526                        -- "${cur##--strategy=}"))
 527                return
 528                ;;
 529        --*)
 530                COMPREPLY=($(compgen -W "
 531                        --no-commit --no-summary --squash --strategy
 532                        " -- "$cur"))
 533                return
 534        esac
 535        COMPREPLY=($(compgen -W "$(__git_refs)" -- "$cur"))
 536}
 537
 538_git_merge_base ()
 539{
 540        local cur="${COMP_WORDS[COMP_CWORD]}"
 541        COMPREPLY=($(compgen -W "$(__git_refs)" -- "$cur"))
 542}
 543
 544_git_name_rev ()
 545{
 546        local cur="${COMP_WORDS[COMP_CWORD]}"
 547        COMPREPLY=($(compgen -W "--tags --all --stdin" -- "$cur"))
 548}
 549
 550_git_pull ()
 551{
 552        local cur="${COMP_WORDS[COMP_CWORD]}"
 553
 554        case "${COMP_WORDS[0]},$COMP_CWORD" in
 555        git-pull*,1)
 556                COMPREPLY=($(compgen -W "$(__git_remotes)" -- "$cur"))
 557                ;;
 558        git,2)
 559                COMPREPLY=($(compgen -W "$(__git_remotes)" -- "$cur"))
 560                ;;
 561        *)
 562                local remote
 563                case "${COMP_WORDS[0]}" in
 564                git-pull)  remote="${COMP_WORDS[1]}" ;;
 565                git)       remote="${COMP_WORDS[2]}" ;;
 566                esac
 567                COMPREPLY=($(compgen -W "$(__git_refs "$remote")" -- "$cur"))
 568                ;;
 569        esac
 570}
 571
 572_git_push ()
 573{
 574        local cur="${COMP_WORDS[COMP_CWORD]}"
 575
 576        case "${COMP_WORDS[0]},$COMP_CWORD" in
 577        git-push*,1)
 578                COMPREPLY=($(compgen -W "$(__git_remotes)" -- "$cur"))
 579                ;;
 580        git,2)
 581                COMPREPLY=($(compgen -W "$(__git_remotes)" -- "$cur"))
 582                ;;
 583        *)
 584                case "$cur" in
 585                *:*)
 586                        local remote
 587                        case "${COMP_WORDS[0]}" in
 588                        git-push)  remote="${COMP_WORDS[1]}" ;;
 589                        git)       remote="${COMP_WORDS[2]}" ;;
 590                        esac
 591                        cur="${cur#*:}"
 592                        COMPREPLY=($(compgen -W "$(__git_refs "$remote")" -- "$cur"))
 593                        ;;
 594                *)
 595                        COMPREPLY=($(compgen -W "$(__git_refs2)" -- "$cur"))
 596                        ;;
 597                esac
 598                ;;
 599        esac
 600}
 601
 602_git_rebase ()
 603{
 604        local cur="${COMP_WORDS[COMP_CWORD]}"
 605        if [ -d .dotest ]; then
 606                COMPREPLY=($(compgen -W "
 607                        --continue --skip --abort
 608                        " -- "$cur"))
 609                return
 610        fi
 611        case "${COMP_WORDS[COMP_CWORD-1]}" in
 612        -s|--strategy)
 613                COMPREPLY=($(compgen -W "$(__git_merge_strategies)" -- "$cur"))
 614                return
 615        esac
 616        case "$cur" in
 617        --strategy=*)
 618                COMPREPLY=($(compgen -W "$(__git_merge_strategies)" \
 619                        -- "${cur##--strategy=}"))
 620                return
 621                ;;
 622        --*)
 623                COMPREPLY=($(compgen -W "
 624                        --onto --merge --strategy
 625                        " -- "$cur"))
 626                return
 627        esac
 628        COMPREPLY=($(compgen -W "$(__git_refs)" -- "$cur"))
 629}
 630
 631_git_repo_config ()
 632{
 633        local cur="${COMP_WORDS[COMP_CWORD]}"
 634        local prv="${COMP_WORDS[COMP_CWORD-1]}"
 635        case "$prv" in
 636        branch.*.remote)
 637                COMPREPLY=($(compgen -W "$(__git_remotes)" -- "$cur"))
 638                return
 639                ;;
 640        branch.*.merge)
 641                COMPREPLY=($(compgen -W "$(__git_refs)" -- "$cur"))
 642                return
 643                ;;
 644        remote.*.fetch)
 645                local remote="${prv#remote.}"
 646                remote="${remote%.fetch}"
 647                COMPREPLY=($(compgen -W "$(__git_refs_remotes "$remote")" \
 648                        -- "$cur"))
 649                return
 650                ;;
 651        remote.*.push)
 652                local remote="${prv#remote.}"
 653                remote="${remote%.push}"
 654                COMPREPLY=($(compgen -W "$(git --git-dir="$(__gitdir)" \
 655                        for-each-ref --format='%(refname):%(refname)' \
 656                        refs/heads)" -- "$cur"))
 657                return
 658                ;;
 659        *.*)
 660                COMPREPLY=()
 661                return
 662                ;;
 663        esac
 664        case "$cur" in
 665        --*)
 666                COMPREPLY=($(compgen -W "
 667                        --global --list --replace-all
 668                        --get --get-all --get-regexp
 669                        --unset --unset-all
 670                        " -- "$cur"))
 671                return
 672                ;;
 673        branch.*.*)
 674                local pfx="${cur%.*}."
 675                cur="${cur##*.}"
 676                COMPREPLY=($(compgen -P "$pfx" -W "remote merge" -- "$cur"))
 677                return
 678                ;;
 679        branch.*)
 680                local pfx="${cur%.*}."
 681                cur="${cur#*.}"
 682                COMPREPLY=($(compgen -P "$pfx" -S . \
 683                        -W "$(__git_heads)" -- "$cur"))
 684                return
 685                ;;
 686        remote.*.*)
 687                local pfx="${cur%.*}."
 688                cur="${cur##*.}"
 689                COMPREPLY=($(compgen -P "$pfx" -W "url fetch push" -- "$cur"))
 690                return
 691                ;;
 692        remote.*)
 693                local pfx="${cur%.*}."
 694                cur="${cur#*.}"
 695                COMPREPLY=($(compgen -P "$pfx" -S . \
 696                        -W "$(__git_remotes)" -- "$cur"))
 697                return
 698                ;;
 699        esac
 700        COMPREPLY=($(compgen -W "
 701                apply.whitespace
 702                core.fileMode
 703                core.gitProxy
 704                core.ignoreStat
 705                core.preferSymlinkRefs
 706                core.logAllRefUpdates
 707                core.repositoryFormatVersion
 708                core.sharedRepository
 709                core.warnAmbiguousRefs
 710                core.compression
 711                core.legacyHeaders
 712                i18n.commitEncoding
 713                diff.color
 714                diff.renameLimit
 715                diff.renames
 716                pager.color
 717                status.color
 718                log.showroot
 719                show.difftree
 720                showbranch.default
 721                whatchanged.difftree
 722                http.sslVerify
 723                http.sslCert
 724                http.sslKey
 725                http.sslCAInfo
 726                http.sslCAPath
 727                http.maxRequests
 728                http.lowSpeedLimit http.lowSpeedTime
 729                http.noEPSV
 730                pack.window
 731                repack.useDeltaBaseOffset
 732                pull.octopus pull.twohead
 733                merge.summary
 734                receive.unpackLimit
 735                receive.denyNonFastForwards
 736                user.name user.email
 737                tar.umask
 738                gitcvs.enabled
 739                gitcvs.logfile
 740                branch. remote.
 741        " -- "$cur"))
 742}
 743
 744_git_reset ()
 745{
 746        local cur="${COMP_WORDS[COMP_CWORD]}"
 747        local opt="--mixed --hard --soft"
 748        COMPREPLY=($(compgen -W "$opt $(__git_refs)" -- "$cur"))
 749}
 750
 751_git ()
 752{
 753        local i c=1 command __git_dir
 754
 755        while [ $c -lt $COMP_CWORD ]; do
 756                i="${COMP_WORDS[c]}"
 757                case "$i" in
 758                --git-dir=*) __git_dir="${i#--git-dir=}" ;;
 759                --bare)      __git_dir="." ;;
 760                --version|--help|-p|--paginate) ;;
 761                *) command="$i"; break ;;
 762                esac
 763                c=$((++c))
 764        done
 765
 766        if [ $c -eq $COMP_CWORD -a -z "$command" ]; then
 767                COMPREPLY=($(compgen -W "
 768                        --git-dir= --version --exec-path
 769                        $(__git_commands)
 770                        $(__git_aliases)
 771                        " -- "${COMP_WORDS[COMP_CWORD]}"))
 772                return;
 773        fi
 774
 775        local expansion=$(__git_aliased_command "$command")
 776        [ "$expansion" ] && command="$expansion"
 777
 778        case "$command" in
 779        am)          _git_am ;;
 780        apply)       _git_apply ;;
 781        branch)      _git_branch ;;
 782        cat-file)    _git_cat_file ;;
 783        checkout)    _git_checkout ;;
 784        cherry-pick) _git_cherry_pick ;;
 785        commit)      _git_commit ;;
 786        diff)        _git_diff ;;
 787        diff-tree)   _git_diff_tree ;;
 788        fetch)       _git_fetch ;;
 789        format-patch) _git_format_patch ;;
 790        log)         _git_log ;;
 791        ls-remote)   _git_ls_remote ;;
 792        ls-tree)     _git_ls_tree ;;
 793        merge)       _git_merge;;
 794        merge-base)  _git_merge_base ;;
 795        name-rev)    _git_name_rev ;;
 796        pull)        _git_pull ;;
 797        push)        _git_push ;;
 798        rebase)      _git_rebase ;;
 799        repo-config) _git_repo_config ;;
 800        reset)       _git_reset ;;
 801        show)        _git_log ;;
 802        show-branch) _git_log ;;
 803        whatchanged) _git_log ;;
 804        *)           COMPREPLY=() ;;
 805        esac
 806}
 807
 808_gitk ()
 809{
 810        local cur="${COMP_WORDS[COMP_CWORD]}"
 811        COMPREPLY=($(compgen -W "--all $(__git_refs)" -- "$cur"))
 812}
 813
 814complete -o default -o nospace -F _git git
 815complete -o default            -F _gitk gitk
 816complete -o default            -F _git_am git-am
 817complete -o default            -F _git_apply git-apply
 818complete -o default            -F _git_branch git-branch
 819complete -o default -o nospace -F _git_cat_file git-cat-file
 820complete -o default            -F _git_checkout git-checkout
 821complete -o default            -F _git_cherry_pick git-cherry-pick
 822complete -o default            -F _git_commit git-commit
 823complete -o default -o nospace -F _git_diff git-diff
 824complete -o default            -F _git_diff_tree git-diff-tree
 825complete -o default -o nospace -F _git_fetch git-fetch
 826complete -o default -o nospace -F _git_format_patch git-format-patch
 827complete -o default -o nospace -F _git_log git-log
 828complete -o default            -F _git_ls_remote git-ls-remote
 829complete -o default -o nospace -F _git_ls_tree git-ls-tree
 830complete -o default            -F _git_merge git-merge
 831complete -o default            -F _git_merge_base git-merge-base
 832complete -o default            -F _git_name_rev git-name-rev
 833complete -o default -o nospace -F _git_pull git-pull
 834complete -o default -o nospace -F _git_push git-push
 835complete -o default            -F _git_rebase git-rebase
 836complete -o default            -F _git_repo_config git-repo-config
 837complete -o default            -F _git_reset git-reset
 838complete -o default            -F _git_log git-show
 839complete -o default -o nospace -F _git_log git-show-branch
 840complete -o default -o nospace -F _git_log git-whatchanged
 841
 842# The following are necessary only for Cygwin, and only are needed
 843# when the user has tab-completed the executable name and consequently
 844# included the '.exe' suffix.
 845#
 846if [ Cygwin = "$(uname -o 2>/dev/null)" ]; then
 847complete -o default            -F _git_apply git-apply.exe
 848complete -o default -o nospace -F _git git.exe
 849complete -o default            -F _git_branch git-branch.exe
 850complete -o default -o nospace -F _git_cat_file git-cat-file.exe
 851complete -o default -o nospace -F _git_diff git-diff.exe
 852complete -o default -o nospace -F _git_diff_tree git-diff-tree.exe
 853complete -o default -o nospace -F _git_format_patch git-format-patch.exe
 854complete -o default -o nospace -F _git_log git-log.exe
 855complete -o default -o nospace -F _git_ls_tree git-ls-tree.exe
 856complete -o default            -F _git_merge_base git-merge-base.exe
 857complete -o default            -F _git_name_rev git-name-rev.exe
 858complete -o default -o nospace -F _git_push git-push.exe
 859complete -o default            -F _git_repo_config git-repo-config
 860complete -o default -o nospace -F _git_log git-show.exe
 861complete -o default -o nospace -F _git_log git-show-branch.exe
 862complete -o default -o nospace -F _git_log git-whatchanged.exe
 863fi