Andrew's git / gitweb.git / contrib/completion/git-completion.bash
?
contrib / completion / git-completion.bashon commit Typofixes outside documentation area (9517e6b)
   1#!bash
   2#
   3# bash completion support for core Git.
   4#
   5# Copyright (C) 2006,2007 Shawn O. Pearce <spearce@spearce.org>
   6# Conceptually based on gitcompletion (http://gitweb.hawaga.org.uk/).
   7# Distributed under the GNU General Public License, version 2.0.
   8#
   9# The contained completion routines provide support for completing:
  10#
  11#    *) local and remote branch names
  12#    *) local and remote tag names
  13#    *) .git/remotes file names
  14#    *) git 'subcommands'
  15#    *) tree paths within 'ref:path/to/file' expressions
  16#    *) common --long-options
  17#
  18# To use these routines:
  19#
  20#    1) Copy this file to somewhere (e.g. ~/.git-completion.sh).
  21#    2) Added the following line to your .bashrc:
  22#        source ~/.git-completion.sh
  23#
  24#    3) Consider changing your PS1 to also show the current branch:
  25#        PS1='[\u@\h \W$(__git_ps1 " (%s)")]\$ '
  26#
  27#       The argument to __git_ps1 will be displayed only if you
  28#       are currently in a git repository.  The %s token will be
  29#       the name of the current branch.
  30#
  31#       In addition, if you set GIT_PS1_SHOWDIRTYSTATE to a nonempty
  32#       value, unstaged (*) and staged (+) changes will be shown next
  33#       to the branch name.  You can configure this per-repository
  34#       with the bash.showDirtyState variable, which defaults to true
  35#       once GIT_PS1_SHOWDIRTYSTATE is enabled.
  36#
  37#       You can also see if currently something is stashed, by setting
  38#       GIT_PS1_SHOWSTASHSTATE to a nonempty value. If something is stashed,
  39#       then a '$' will be shown next to the branch name.
  40#
  41#       If you would like to see if there're untracked files, then you can
  42#       set GIT_PS1_SHOWUNTRACKEDFILES to a nonempty value. If there're
  43#       untracked files, then a '%' will be shown next to the branch name.
  44#
  45# To submit patches:
  46#
  47#    *) Read Documentation/SubmittingPatches
  48#    *) Send all patches to the current maintainer:
  49#
  50#       "Shawn O. Pearce" <spearce@spearce.org>
  51#
  52#    *) Always CC the Git mailing list:
  53#
  54#       git@vger.kernel.org
  55#
  56
  57case "$COMP_WORDBREAKS" in
  58*:*) : great ;;
  59*)   COMP_WORDBREAKS="$COMP_WORDBREAKS:"
  60esac
  61
  62# __gitdir accepts 0 or 1 arguments (i.e., location)
  63# returns location of .git repo
  64__gitdir ()
  65{
  66        if [ -z "${1-}" ]; then
  67                if [ -n "${__git_dir-}" ]; then
  68                        echo "$__git_dir"
  69                elif [ -d .git ]; then
  70                        echo .git
  71                else
  72                        git rev-parse --git-dir 2>/dev/null
  73                fi
  74        elif [ -d "$1/.git" ]; then
  75                echo "$1/.git"
  76        else
  77                echo "$1"
  78        fi
  79}
  80
  81# __git_ps1 accepts 0 or 1 arguments (i.e., format string)
  82# returns text to add to bash PS1 prompt (includes branch name)
  83__git_ps1 ()
  84{
  85        local g="$(__gitdir)"
  86        if [ -n "$g" ]; then
  87                local r
  88                local b
  89                if [ -f "$g/rebase-merge/interactive" ]; then
  90                        r="|REBASE-i"
  91                        b="$(cat "$g/rebase-merge/head-name")"
  92                elif [ -d "$g/rebase-merge" ]; then
  93                        r="|REBASE-m"
  94                        b="$(cat "$g/rebase-merge/head-name")"
  95                else
  96                        if [ -d "$g/rebase-apply" ]; then
  97                                if [ -f "$g/rebase-apply/rebasing" ]; then
  98                                        r="|REBASE"
  99                                elif [ -f "$g/rebase-apply/applying" ]; then
 100                                        r="|AM"
 101                                else
 102                                        r="|AM/REBASE"
 103                                fi
 104                        elif [ -f "$g/MERGE_HEAD" ]; then
 105                                r="|MERGING"
 106                        elif [ -f "$g/BISECT_LOG" ]; then
 107                                r="|BISECTING"
 108                        fi
 109
 110                        b="$(git symbolic-ref HEAD 2>/dev/null)" || {
 111
 112                                b="$(
 113                                case "${GIT_PS1_DESCRIBE_STYLE-}" in
 114                                (contains)
 115                                        git describe --contains HEAD ;;
 116                                (branch)
 117                                        git describe --contains --all HEAD ;;
 118                                (describe)
 119                                        git describe HEAD ;;
 120                                (* | default)
 121                                        git describe --exact-match HEAD ;;
 122                                esac 2>/dev/null)" ||
 123
 124                                b="$(cut -c1-7 "$g/HEAD" 2>/dev/null)..." ||
 125                                b="unknown"
 126                                b="($b)"
 127                        }
 128                fi
 129
 130                local w
 131                local i
 132                local s
 133                local u
 134                local c
 135
 136                if [ "true" = "$(git rev-parse --is-inside-git-dir 2>/dev/null)" ]; then
 137                        if [ "true" = "$(git rev-parse --is-bare-repository 2>/dev/null)" ]; then
 138                                c="BARE:"
 139                        else
 140                                b="GIT_DIR!"
 141                        fi
 142                elif [ "true" = "$(git rev-parse --is-inside-work-tree 2>/dev/null)" ]; then
 143                        if [ -n "${GIT_PS1_SHOWDIRTYSTATE-}" ]; then
 144                                if [ "$(git config --bool bash.showDirtyState)" != "false" ]; then
 145                                        git diff --no-ext-diff --quiet --exit-code || w="*"
 146                                        if git rev-parse --quiet --verify HEAD >/dev/null; then
 147                                                git diff-index --cached --quiet HEAD -- || i="+"
 148                                        else
 149                                                i="#"
 150                                        fi
 151                                fi
 152                        fi
 153                        if [ -n "${GIT_PS1_SHOWSTASHSTATE-}" ]; then
 154                                git rev-parse --verify refs/stash >/dev/null 2>&1 && s="$"
 155                        fi
 156
 157                        if [ -n "${GIT_PS1_SHOWUNTRACKEDFILES-}" ]; then
 158                           if [ -n "$(git ls-files --others --exclude-standard)" ]; then
 159                              u="%"
 160                           fi
 161                        fi
 162                fi
 163
 164                local f="$w$i$s$u"
 165                printf "${1:- (%s)}" "$c${b##refs/heads/}${f:+ $f}$r"
 166        fi
 167}
 168
 169# __gitcomp_1 requires 2 arguments
 170__gitcomp_1 ()
 171{
 172        local c IFS=' '$'\t'$'\n'
 173        for c in $1; do
 174                case "$c$2" in
 175                --*=*) printf %s$'\n' "$c$2" ;;
 176                *.)    printf %s$'\n' "$c$2" ;;
 177                *)     printf %s$'\n' "$c$2 " ;;
 178                esac
 179        done
 180}
 181
 182# __gitcomp accepts 1, 2, 3, or 4 arguments
 183# generates completion reply with compgen
 184__gitcomp ()
 185{
 186        local cur="${COMP_WORDS[COMP_CWORD]}"
 187        if [ $# -gt 2 ]; then
 188                cur="$3"
 189        fi
 190        case "$cur" in
 191        --*=)
 192                COMPREPLY=()
 193                ;;
 194        *)
 195                local IFS=$'\n'
 196                COMPREPLY=($(compgen -P "${2-}" \
 197                        -W "$(__gitcomp_1 "${1-}" "${4-}")" \
 198                        -- "$cur"))
 199                ;;
 200        esac
 201}
 202
 203# __git_heads accepts 0 or 1 arguments (to pass to __gitdir)
 204__git_heads ()
 205{
 206        local cmd i is_hash=y dir="$(__gitdir "${1-}")"
 207        if [ -d "$dir" ]; then
 208                git --git-dir="$dir" for-each-ref --format='%(refname:short)' \
 209                        refs/heads
 210                return
 211        fi
 212        for i in $(git ls-remote "${1-}" 2>/dev/null); do
 213                case "$is_hash,$i" in
 214                y,*) is_hash=n ;;
 215                n,*^{}) is_hash=y ;;
 216                n,refs/heads/*) is_hash=y; echo "${i#refs/heads/}" ;;
 217                n,*) is_hash=y; echo "$i" ;;
 218                esac
 219        done
 220}
 221
 222# __git_tags accepts 0 or 1 arguments (to pass to __gitdir)
 223__git_tags ()
 224{
 225        local cmd i is_hash=y dir="$(__gitdir "${1-}")"
 226        if [ -d "$dir" ]; then
 227                git --git-dir="$dir" for-each-ref --format='%(refname:short)' \
 228                        refs/tags
 229                return
 230        fi
 231        for i in $(git ls-remote "${1-}" 2>/dev/null); do
 232                case "$is_hash,$i" in
 233                y,*) is_hash=n ;;
 234                n,*^{}) is_hash=y ;;
 235                n,refs/tags/*) is_hash=y; echo "${i#refs/tags/}" ;;
 236                n,*) is_hash=y; echo "$i" ;;
 237                esac
 238        done
 239}
 240
 241# __git_refs accepts 0 or 1 arguments (to pass to __gitdir)
 242__git_refs ()
 243{
 244        local i is_hash=y dir="$(__gitdir "${1-}")"
 245        local cur="${COMP_WORDS[COMP_CWORD]}" format refs
 246        if [ -d "$dir" ]; then
 247                case "$cur" in
 248                refs|refs/*)
 249                        format="refname"
 250                        refs="${cur%/*}"
 251                        ;;
 252                *)
 253                        if [ -e "$dir/HEAD" ]; then echo HEAD; fi
 254                        format="refname:short"
 255                        refs="refs/tags refs/heads refs/remotes"
 256                        ;;
 257                esac
 258                git --git-dir="$dir" for-each-ref --format="%($format)" \
 259                        $refs
 260                return
 261        fi
 262        for i in $(git ls-remote "$dir" 2>/dev/null); do
 263                case "$is_hash,$i" in
 264                y,*) is_hash=n ;;
 265                n,*^{}) is_hash=y ;;
 266                n,refs/tags/*) is_hash=y; echo "${i#refs/tags/}" ;;
 267                n,refs/heads/*) is_hash=y; echo "${i#refs/heads/}" ;;
 268                n,refs/remotes/*) is_hash=y; echo "${i#refs/remotes/}" ;;
 269                n,*) is_hash=y; echo "$i" ;;
 270                esac
 271        done
 272}
 273
 274# __git_refs2 requires 1 argument (to pass to __git_refs)
 275__git_refs2 ()
 276{
 277        local i
 278        for i in $(__git_refs "$1"); do
 279                echo "$i:$i"
 280        done
 281}
 282
 283# __git_refs_remotes requires 1 argument (to pass to ls-remote)
 284__git_refs_remotes ()
 285{
 286        local cmd i is_hash=y
 287        for i in $(git ls-remote "$1" 2>/dev/null); do
 288                case "$is_hash,$i" in
 289                n,refs/heads/*)
 290                        is_hash=y
 291                        echo "$i:refs/remotes/$1/${i#refs/heads/}"
 292                        ;;
 293                y,*) is_hash=n ;;
 294                n,*^{}) is_hash=y ;;
 295                n,refs/tags/*) is_hash=y;;
 296                n,*) is_hash=y; ;;
 297                esac
 298        done
 299}
 300
 301__git_remotes ()
 302{
 303        local i ngoff IFS=$'\n' d="$(__gitdir)"
 304        shopt -q nullglob || ngoff=1
 305        shopt -s nullglob
 306        for i in "$d/remotes"/*; do
 307                echo ${i#$d/remotes/}
 308        done
 309        [ "$ngoff" ] && shopt -u nullglob
 310        for i in $(git --git-dir="$d" config --get-regexp 'remote\..*\.url' 2>/dev/null); do
 311                i="${i#remote.}"
 312                echo "${i/.url*/}"
 313        done
 314}
 315
 316__git_list_merge_strategies ()
 317{
 318        git merge -s help 2>&1 |
 319        sed -n -e '/[Aa]vailable strategies are: /,/^$/{
 320                s/\.$//
 321                s/.*://
 322                s/^[    ]*//
 323                s/[     ]*$//
 324                p
 325        }'
 326}
 327
 328__git_merge_strategies=
 329# 'git merge -s help' (and thus detection of the merge strategy
 330# list) fails, unfortunately, if run outside of any git working
 331# tree.  __git_merge_strategies is set to the empty string in
 332# that case, and the detection will be repeated the next time it
 333# is needed.
 334__git_compute_merge_strategies ()
 335{
 336        : ${__git_merge_strategies:=$(__git_list_merge_strategies)}
 337}
 338
 339__git_complete_file ()
 340{
 341        local pfx ls ref cur="${COMP_WORDS[COMP_CWORD]}"
 342        case "$cur" in
 343        ?*:*)
 344                ref="${cur%%:*}"
 345                cur="${cur#*:}"
 346                case "$cur" in
 347                ?*/*)
 348                        pfx="${cur%/*}"
 349                        cur="${cur##*/}"
 350                        ls="$ref:$pfx"
 351                        pfx="$pfx/"
 352                        ;;
 353                *)
 354                        ls="$ref"
 355                        ;;
 356            esac
 357
 358                case "$COMP_WORDBREAKS" in
 359                *:*) : great ;;
 360                *)   pfx="$ref:$pfx" ;;
 361                esac
 362
 363                local IFS=$'\n'
 364                COMPREPLY=($(compgen -P "$pfx" \
 365                        -W "$(git --git-dir="$(__gitdir)" ls-tree "$ls" \
 366                                | sed '/^100... blob /{
 367                                           s,^.*        ,,
 368                                           s,$, ,
 369                                       }
 370                                       /^120000 blob /{
 371                                           s,^.*        ,,
 372                                           s,$, ,
 373                                       }
 374                                       /^040000 tree /{
 375                                           s,^.*        ,,
 376                                           s,$,/,
 377                                       }
 378                                       s/^.*    //')" \
 379                        -- "$cur"))
 380                ;;
 381        *)
 382                __gitcomp "$(__git_refs)"
 383                ;;
 384        esac
 385}
 386
 387__git_complete_revlist ()
 388{
 389        local pfx cur="${COMP_WORDS[COMP_CWORD]}"
 390        case "$cur" in
 391        *...*)
 392                pfx="${cur%...*}..."
 393                cur="${cur#*...}"
 394                __gitcomp "$(__git_refs)" "$pfx" "$cur"
 395                ;;
 396        *..*)
 397                pfx="${cur%..*}.."
 398                cur="${cur#*..}"
 399                __gitcomp "$(__git_refs)" "$pfx" "$cur"
 400                ;;
 401        *)
 402                __gitcomp "$(__git_refs)"
 403                ;;
 404        esac
 405}
 406
 407__git_complete_remote_or_refspec ()
 408{
 409        local cmd="${COMP_WORDS[1]}"
 410        local cur="${COMP_WORDS[COMP_CWORD]}"
 411        local i c=2 remote="" pfx="" lhs=1 no_complete_refspec=0
 412        while [ $c -lt $COMP_CWORD ]; do
 413                i="${COMP_WORDS[c]}"
 414                case "$i" in
 415                --mirror) [ "$cmd" = "push" ] && no_complete_refspec=1 ;;
 416                --all)
 417                        case "$cmd" in
 418                        push) no_complete_refspec=1 ;;
 419                        fetch)
 420                                COMPREPLY=()
 421                                return
 422                                ;;
 423                        *) ;;
 424                        esac
 425                        ;;
 426                -*) ;;
 427                *) remote="$i"; break ;;
 428                esac
 429                c=$((++c))
 430        done
 431        if [ -z "$remote" ]; then
 432                __gitcomp "$(__git_remotes)"
 433                return
 434        fi
 435        if [ $no_complete_refspec = 1 ]; then
 436                COMPREPLY=()
 437                return
 438        fi
 439        [ "$remote" = "." ] && remote=
 440        case "$cur" in
 441        *:*)
 442                case "$COMP_WORDBREAKS" in
 443                *:*) : great ;;
 444                *)   pfx="${cur%%:*}:" ;;
 445                esac
 446                cur="${cur#*:}"
 447                lhs=0
 448                ;;
 449        +*)
 450                pfx="+"
 451                cur="${cur#+}"
 452                ;;
 453        esac
 454        case "$cmd" in
 455        fetch)
 456                if [ $lhs = 1 ]; then
 457                        __gitcomp "$(__git_refs2 "$remote")" "$pfx" "$cur"
 458                else
 459                        __gitcomp "$(__git_refs)" "$pfx" "$cur"
 460                fi
 461                ;;
 462        pull)
 463                if [ $lhs = 1 ]; then
 464                        __gitcomp "$(__git_refs "$remote")" "$pfx" "$cur"
 465                else
 466                        __gitcomp "$(__git_refs)" "$pfx" "$cur"
 467                fi
 468                ;;
 469        push)
 470                if [ $lhs = 1 ]; then
 471                        __gitcomp "$(__git_refs)" "$pfx" "$cur"
 472                else
 473                        __gitcomp "$(__git_refs "$remote")" "$pfx" "$cur"
 474                fi
 475                ;;
 476        esac
 477}
 478
 479__git_complete_strategy ()
 480{
 481        __git_compute_merge_strategies
 482        case "${COMP_WORDS[COMP_CWORD-1]}" in
 483        -s|--strategy)
 484                __gitcomp "$__git_merge_strategies"
 485                return 0
 486        esac
 487        local cur="${COMP_WORDS[COMP_CWORD]}"
 488        case "$cur" in
 489        --strategy=*)
 490                __gitcomp "$__git_merge_strategies" "" "${cur##--strategy=}"
 491                return 0
 492                ;;
 493        esac
 494        return 1
 495}
 496
 497__git_list_all_commands ()
 498{
 499        local i IFS=" "$'\n'
 500        for i in $(git help -a|egrep '^  [a-zA-Z0-9]')
 501        do
 502                case $i in
 503                *--*)             : helper pattern;;
 504                *) echo $i;;
 505                esac
 506        done
 507}
 508
 509__git_all_commands=
 510__git_compute_all_commands ()
 511{
 512        : ${__git_all_commands:=$(__git_list_all_commands)}
 513}
 514
 515__git_list_porcelain_commands ()
 516{
 517        local i IFS=" "$'\n'
 518        __git_compute_all_commands
 519        for i in "help" $__git_all_commands
 520        do
 521                case $i in
 522                *--*)             : helper pattern;;
 523                applymbox)        : ask gittus;;
 524                applypatch)       : ask gittus;;
 525                archimport)       : import;;
 526                cat-file)         : plumbing;;
 527                check-attr)       : plumbing;;
 528                check-ref-format) : plumbing;;
 529                checkout-index)   : plumbing;;
 530                commit-tree)      : plumbing;;
 531                count-objects)    : infrequent;;
 532                cvsexportcommit)  : export;;
 533                cvsimport)        : import;;
 534                cvsserver)        : daemon;;
 535                daemon)           : daemon;;
 536                diff-files)       : plumbing;;
 537                diff-index)       : plumbing;;
 538                diff-tree)        : plumbing;;
 539                fast-import)      : import;;
 540                fast-export)      : export;;
 541                fsck-objects)     : plumbing;;
 542                fetch-pack)       : plumbing;;
 543                fmt-merge-msg)    : plumbing;;
 544                for-each-ref)     : plumbing;;
 545                hash-object)      : plumbing;;
 546                http-*)           : transport;;
 547                index-pack)       : plumbing;;
 548                init-db)          : deprecated;;
 549                local-fetch)      : plumbing;;
 550                lost-found)       : infrequent;;
 551                ls-files)         : plumbing;;
 552                ls-remote)        : plumbing;;
 553                ls-tree)          : plumbing;;
 554                mailinfo)         : plumbing;;
 555                mailsplit)        : plumbing;;
 556                merge-*)          : plumbing;;
 557                mktree)           : plumbing;;
 558                mktag)            : plumbing;;
 559                pack-objects)     : plumbing;;
 560                pack-redundant)   : plumbing;;
 561                pack-refs)        : plumbing;;
 562                parse-remote)     : plumbing;;
 563                patch-id)         : plumbing;;
 564                peek-remote)      : plumbing;;
 565                prune)            : plumbing;;
 566                prune-packed)     : plumbing;;
 567                quiltimport)      : import;;
 568                read-tree)        : plumbing;;
 569                receive-pack)     : plumbing;;
 570                reflog)           : plumbing;;
 571                remote-*)         : transport;;
 572                repo-config)      : deprecated;;
 573                rerere)           : plumbing;;
 574                rev-list)         : plumbing;;
 575                rev-parse)        : plumbing;;
 576                runstatus)        : plumbing;;
 577                sh-setup)         : internal;;
 578                shell)            : daemon;;
 579                show-ref)         : plumbing;;
 580                send-pack)        : plumbing;;
 581                show-index)       : plumbing;;
 582                ssh-*)            : transport;;
 583                stripspace)       : plumbing;;
 584                symbolic-ref)     : plumbing;;
 585                tar-tree)         : deprecated;;
 586                unpack-file)      : plumbing;;
 587                unpack-objects)   : plumbing;;
 588                update-index)     : plumbing;;
 589                update-ref)       : plumbing;;
 590                update-server-info) : daemon;;
 591                upload-archive)   : plumbing;;
 592                upload-pack)      : plumbing;;
 593                write-tree)       : plumbing;;
 594                var)              : infrequent;;
 595                verify-pack)      : infrequent;;
 596                verify-tag)       : plumbing;;
 597                *) echo $i;;
 598                esac
 599        done
 600}
 601
 602__git_porcelain_commands=
 603__git_compute_porcelain_commands ()
 604{
 605        __git_compute_all_commands
 606        : ${__git_porcelain_commands:=$(__git_list_porcelain_commands)}
 607}
 608
 609__git_aliases ()
 610{
 611        local i IFS=$'\n'
 612        for i in $(git --git-dir="$(__gitdir)" config --get-regexp "alias\..*" 2>/dev/null); do
 613                case "$i" in
 614                alias.*)
 615                        i="${i#alias.}"
 616                        echo "${i/ */}"
 617                        ;;
 618                esac
 619        done
 620}
 621
 622# __git_aliased_command requires 1 argument
 623__git_aliased_command ()
 624{
 625        local word cmdline=$(git --git-dir="$(__gitdir)" \
 626                config --get "alias.$1")
 627        for word in $cmdline; do
 628                if [ "${word##-*}" ]; then
 629                        echo $word
 630                        return
 631                fi
 632        done
 633}
 634
 635# __git_find_on_cmdline requires 1 argument
 636__git_find_on_cmdline ()
 637{
 638        local word subcommand c=1
 639
 640        while [ $c -lt $COMP_CWORD ]; do
 641                word="${COMP_WORDS[c]}"
 642                for subcommand in $1; do
 643                        if [ "$subcommand" = "$word" ]; then
 644                                echo "$subcommand"
 645                                return
 646                        fi
 647                done
 648                c=$((++c))
 649        done
 650}
 651
 652__git_has_doubledash ()
 653{
 654        local c=1
 655        while [ $c -lt $COMP_CWORD ]; do
 656                if [ "--" = "${COMP_WORDS[c]}" ]; then
 657                        return 0
 658                fi
 659                c=$((++c))
 660        done
 661        return 1
 662}
 663
 664__git_whitespacelist="nowarn warn error error-all fix"
 665
 666_git_am ()
 667{
 668        local cur="${COMP_WORDS[COMP_CWORD]}" dir="$(__gitdir)"
 669        if [ -d "$dir"/rebase-apply ]; then
 670                __gitcomp "--skip --resolved --abort"
 671                return
 672        fi
 673        case "$cur" in
 674        --whitespace=*)
 675                __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
 676                return
 677                ;;
 678        --*)
 679                __gitcomp "
 680                        --3way --committer-date-is-author-date --ignore-date
 681                        --ignore-whitespace --ignore-space-change
 682                        --interactive --keep --no-utf8 --signoff --utf8
 683                        --whitespace= --scissors
 684                        "
 685                return
 686        esac
 687        COMPREPLY=()
 688}
 689
 690_git_apply ()
 691{
 692        local cur="${COMP_WORDS[COMP_CWORD]}"
 693        case "$cur" in
 694        --whitespace=*)
 695                __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
 696                return
 697                ;;
 698        --*)
 699                __gitcomp "
 700                        --stat --numstat --summary --check --index
 701                        --cached --index-info --reverse --reject --unidiff-zero
 702                        --apply --no-add --exclude=
 703                        --ignore-whitespace --ignore-space-change
 704                        --whitespace= --inaccurate-eof --verbose
 705                        "
 706                return
 707        esac
 708        COMPREPLY=()
 709}
 710
 711_git_add ()
 712{
 713        __git_has_doubledash && return
 714
 715        local cur="${COMP_WORDS[COMP_CWORD]}"
 716        case "$cur" in
 717        --*)
 718                __gitcomp "
 719                        --interactive --refresh --patch --update --dry-run
 720                        --ignore-errors --intent-to-add
 721                        "
 722                return
 723        esac
 724        COMPREPLY=()
 725}
 726
 727_git_archive ()
 728{
 729        local cur="${COMP_WORDS[COMP_CWORD]}"
 730        case "$cur" in
 731        --format=*)
 732                __gitcomp "$(git archive --list)" "" "${cur##--format=}"
 733                return
 734                ;;
 735        --remote=*)
 736                __gitcomp "$(__git_remotes)" "" "${cur##--remote=}"
 737                return
 738                ;;
 739        --*)
 740                __gitcomp "
 741                        --format= --list --verbose
 742                        --prefix= --remote= --exec=
 743                        "
 744                return
 745                ;;
 746        esac
 747        __git_complete_file
 748}
 749
 750_git_bisect ()
 751{
 752        __git_has_doubledash && return
 753
 754        local subcommands="start bad good skip reset visualize replay log run"
 755        local subcommand="$(__git_find_on_cmdline "$subcommands")"
 756        if [ -z "$subcommand" ]; then
 757                __gitcomp "$subcommands"
 758                return
 759        fi
 760
 761        case "$subcommand" in
 762        bad|good|reset|skip)
 763                __gitcomp "$(__git_refs)"
 764                ;;
 765        *)
 766                COMPREPLY=()
 767                ;;
 768        esac
 769}
 770
 771_git_branch ()
 772{
 773        local i c=1 only_local_ref="n" has_r="n"
 774
 775        while [ $c -lt $COMP_CWORD ]; do
 776                i="${COMP_WORDS[c]}"
 777                case "$i" in
 778                -d|-m)  only_local_ref="y" ;;
 779                -r)     has_r="y" ;;
 780                esac
 781                c=$((++c))
 782        done
 783
 784        case "${COMP_WORDS[COMP_CWORD]}" in
 785        --*)
 786                __gitcomp "
 787                        --color --no-color --verbose --abbrev= --no-abbrev
 788                        --track --no-track --contains --merged --no-merged
 789                        "
 790                ;;
 791        *)
 792                if [ $only_local_ref = "y" -a $has_r = "n" ]; then
 793                        __gitcomp "$(__git_heads)"
 794                else
 795                        __gitcomp "$(__git_refs)"
 796                fi
 797                ;;
 798        esac
 799}
 800
 801_git_bundle ()
 802{
 803        local cmd="${COMP_WORDS[2]}"
 804        case "$COMP_CWORD" in
 805        2)
 806                __gitcomp "create list-heads verify unbundle"
 807                ;;
 808        3)
 809                # looking for a file
 810                ;;
 811        *)
 812                case "$cmd" in
 813                        create)
 814                                __git_complete_revlist
 815                        ;;
 816                esac
 817                ;;
 818        esac
 819}
 820
 821_git_checkout ()
 822{
 823        __git_has_doubledash && return
 824
 825        local cur="${COMP_WORDS[COMP_CWORD]}"
 826        case "$cur" in
 827        --conflict=*)
 828                __gitcomp "diff3 merge" "" "${cur##--conflict=}"
 829                ;;
 830        --*)
 831                __gitcomp "
 832                        --quiet --ours --theirs --track --no-track --merge
 833                        --conflict= --patch
 834                        "
 835                ;;
 836        *)
 837                __gitcomp "$(__git_refs)"
 838                ;;
 839        esac
 840}
 841
 842_git_cherry ()
 843{
 844        __gitcomp "$(__git_refs)"
 845}
 846
 847_git_cherry_pick ()
 848{
 849        local cur="${COMP_WORDS[COMP_CWORD]}"
 850        case "$cur" in
 851        --*)
 852                __gitcomp "--edit --no-commit"
 853                ;;
 854        *)
 855                __gitcomp "$(__git_refs)"
 856                ;;
 857        esac
 858}
 859
 860_git_clean ()
 861{
 862        __git_has_doubledash && return
 863
 864        local cur="${COMP_WORDS[COMP_CWORD]}"
 865        case "$cur" in
 866        --*)
 867                __gitcomp "--dry-run --quiet"
 868                return
 869                ;;
 870        esac
 871        COMPREPLY=()
 872}
 873
 874_git_clone ()
 875{
 876        local cur="${COMP_WORDS[COMP_CWORD]}"
 877        case "$cur" in
 878        --*)
 879                __gitcomp "
 880                        --local
 881                        --no-hardlinks
 882                        --shared
 883                        --reference
 884                        --quiet
 885                        --no-checkout
 886                        --bare
 887                        --mirror
 888                        --origin
 889                        --upload-pack
 890                        --template=
 891                        --depth
 892                        "
 893                return
 894                ;;
 895        esac
 896        COMPREPLY=()
 897}
 898
 899_git_commit ()
 900{
 901        __git_has_doubledash && return
 902
 903        local cur="${COMP_WORDS[COMP_CWORD]}"
 904        case "$cur" in
 905        --cleanup=*)
 906                __gitcomp "default strip verbatim whitespace
 907                        " "" "${cur##--cleanup=}"
 908                return
 909                ;;
 910        --reuse-message=*)
 911                __gitcomp "$(__git_refs)" "" "${cur##--reuse-message=}"
 912                return
 913                ;;
 914        --reedit-message=*)
 915                __gitcomp "$(__git_refs)" "" "${cur##--reedit-message=}"
 916                return
 917                ;;
 918        --untracked-files=*)
 919                __gitcomp "all no normal" "" "${cur##--untracked-files=}"
 920                return
 921                ;;
 922        --*)
 923                __gitcomp "
 924                        --all --author= --signoff --verify --no-verify
 925                        --edit --amend --include --only --interactive
 926                        --dry-run --reuse-message= --reedit-message=
 927                        --reset-author --file= --message= --template=
 928                        --cleanup= --untracked-files --untracked-files=
 929                        --verbose --quiet
 930                        "
 931                return
 932        esac
 933        COMPREPLY=()
 934}
 935
 936_git_describe ()
 937{
 938        local cur="${COMP_WORDS[COMP_CWORD]}"
 939        case "$cur" in
 940        --*)
 941                __gitcomp "
 942                        --all --tags --contains --abbrev= --candidates=
 943                        --exact-match --debug --long --match --always
 944                        "
 945                return
 946        esac
 947        __gitcomp "$(__git_refs)"
 948}
 949
 950__git_diff_common_options="--stat --numstat --shortstat --summary
 951                        --patch-with-stat --name-only --name-status --color
 952                        --no-color --color-words --no-renames --check
 953                        --full-index --binary --abbrev --diff-filter=
 954                        --find-copies-harder
 955                        --text --ignore-space-at-eol --ignore-space-change
 956                        --ignore-all-space --exit-code --quiet --ext-diff
 957                        --no-ext-diff
 958                        --no-prefix --src-prefix= --dst-prefix=
 959                        --inter-hunk-context=
 960                        --patience
 961                        --raw
 962                        --dirstat --dirstat= --dirstat-by-file
 963                        --dirstat-by-file= --cumulative
 964"
 965
 966_git_diff ()
 967{
 968        __git_has_doubledash && return
 969
 970        local cur="${COMP_WORDS[COMP_CWORD]}"
 971        case "$cur" in
 972        --*)
 973                __gitcomp "--cached --staged --pickaxe-all --pickaxe-regex
 974                        --base --ours --theirs
 975                        $__git_diff_common_options
 976                        "
 977                return
 978                ;;
 979        esac
 980        __git_complete_file
 981}
 982
 983__git_mergetools_common="diffuse ecmerge emerge kdiff3 meld opendiff
 984                        tkdiff vimdiff gvimdiff xxdiff araxis p4merge
 985"
 986
 987_git_difftool ()
 988{
 989        __git_has_doubledash && return
 990
 991        local cur="${COMP_WORDS[COMP_CWORD]}"
 992        case "$cur" in
 993        --tool=*)
 994                __gitcomp "$__git_mergetools_common kompare" "" "${cur##--tool=}"
 995                return
 996                ;;
 997        --*)
 998                __gitcomp "--cached --staged --pickaxe-all --pickaxe-regex
 999                        --base --ours --theirs
1000                        --no-renames --diff-filter= --find-copies-harder
1001                        --relative --ignore-submodules
1002                        --tool="
1003                return
1004                ;;
1005        esac
1006        __git_complete_file
1007}
1008
1009__git_fetch_options="
1010        --quiet --verbose --append --upload-pack --force --keep --depth=
1011        --tags --no-tags --all --prune --dry-run
1012"
1013
1014_git_fetch ()
1015{
1016        local cur="${COMP_WORDS[COMP_CWORD]}"
1017        case "$cur" in
1018        --*)
1019                __gitcomp "$__git_fetch_options"
1020                return
1021                ;;
1022        esac
1023        __git_complete_remote_or_refspec
1024}
1025
1026_git_format_patch ()
1027{
1028        local cur="${COMP_WORDS[COMP_CWORD]}"
1029        case "$cur" in
1030        --thread=*)
1031                __gitcomp "
1032                        deep shallow
1033                        " "" "${cur##--thread=}"
1034                return
1035                ;;
1036        --*)
1037                __gitcomp "
1038                        --stdout --attach --no-attach --thread --thread=
1039                        --output-directory
1040                        --numbered --start-number
1041                        --numbered-files
1042                        --keep-subject
1043                        --signoff
1044                        --in-reply-to= --cc=
1045                        --full-index --binary
1046                        --not --all
1047                        --cover-letter
1048                        --no-prefix --src-prefix= --dst-prefix=
1049                        --inline --suffix= --ignore-if-in-upstream
1050                        --subject-prefix=
1051                        "
1052                return
1053                ;;
1054        esac
1055        __git_complete_revlist
1056}
1057
1058_git_fsck ()
1059{
1060        local cur="${COMP_WORDS[COMP_CWORD]}"
1061        case "$cur" in
1062        --*)
1063                __gitcomp "
1064                        --tags --root --unreachable --cache --no-reflogs --full
1065                        --strict --verbose --lost-found
1066                        "
1067                return
1068                ;;
1069        esac
1070        COMPREPLY=()
1071}
1072
1073_git_gc ()
1074{
1075        local cur="${COMP_WORDS[COMP_CWORD]}"
1076        case "$cur" in
1077        --*)
1078                __gitcomp "--prune --aggressive"
1079                return
1080                ;;
1081        esac
1082        COMPREPLY=()
1083}
1084
1085_git_grep ()
1086{
1087        __git_has_doubledash && return
1088
1089        local cur="${COMP_WORDS[COMP_CWORD]}"
1090        case "$cur" in
1091        --*)
1092                __gitcomp "
1093                        --cached
1094                        --text --ignore-case --word-regexp --invert-match
1095                        --full-name
1096                        --extended-regexp --basic-regexp --fixed-strings
1097                        --files-with-matches --name-only
1098                        --files-without-match
1099                        --max-depth
1100                        --count
1101                        --and --or --not --all-match
1102                        "
1103                return
1104                ;;
1105        esac
1106
1107        __gitcomp "$(__git_refs)"
1108}
1109
1110_git_help ()
1111{
1112        local cur="${COMP_WORDS[COMP_CWORD]}"
1113        case "$cur" in
1114        --*)
1115                __gitcomp "--all --info --man --web"
1116                return
1117                ;;
1118        esac
1119        __git_compute_all_commands
1120        __gitcomp "$__git_all_commands
1121                attributes cli core-tutorial cvs-migration
1122                diffcore gitk glossary hooks ignore modules
1123                repository-layout tutorial tutorial-2
1124                workflows
1125                "
1126}
1127
1128_git_init ()
1129{
1130        local cur="${COMP_WORDS[COMP_CWORD]}"
1131        case "$cur" in
1132        --shared=*)
1133                __gitcomp "
1134                        false true umask group all world everybody
1135                        " "" "${cur##--shared=}"
1136                return
1137                ;;
1138        --*)
1139                __gitcomp "--quiet --bare --template= --shared --shared="
1140                return
1141                ;;
1142        esac
1143        COMPREPLY=()
1144}
1145
1146_git_ls_files ()
1147{
1148        __git_has_doubledash && return
1149
1150        local cur="${COMP_WORDS[COMP_CWORD]}"
1151        case "$cur" in
1152        --*)
1153                __gitcomp "--cached --deleted --modified --others --ignored
1154                        --stage --directory --no-empty-directory --unmerged
1155                        --killed --exclude= --exclude-from=
1156                        --exclude-per-directory= --exclude-standard
1157                        --error-unmatch --with-tree= --full-name
1158                        --abbrev --ignored --exclude-per-directory
1159                        "
1160                return
1161                ;;
1162        esac
1163        COMPREPLY=()
1164}
1165
1166_git_ls_remote ()
1167{
1168        __gitcomp "$(__git_remotes)"
1169}
1170
1171_git_ls_tree ()
1172{
1173        __git_complete_file
1174}
1175
1176# Options that go well for log, shortlog and gitk
1177__git_log_common_options="
1178        --not --all
1179        --branches --tags --remotes
1180        --first-parent --merges --no-merges
1181        --max-count=
1182        --max-age= --since= --after=
1183        --min-age= --until= --before=
1184"
1185# Options that go well for log and gitk (not shortlog)
1186__git_log_gitk_options="
1187        --dense --sparse --full-history
1188        --simplify-merges --simplify-by-decoration
1189        --left-right
1190"
1191# Options that go well for log and shortlog (not gitk)
1192__git_log_shortlog_options="
1193        --author= --committer= --grep=
1194        --all-match
1195"
1196
1197__git_log_pretty_formats="oneline short medium full fuller email raw format:"
1198__git_log_date_formats="relative iso8601 rfc2822 short local default raw"
1199
1200_git_log ()
1201{
1202        __git_has_doubledash && return
1203
1204        local cur="${COMP_WORDS[COMP_CWORD]}"
1205        local g="$(git rev-parse --git-dir 2>/dev/null)"
1206        local merge=""
1207        if [ -f "$g/MERGE_HEAD" ]; then
1208                merge="--merge"
1209        fi
1210        case "$cur" in
1211        --pretty=*)
1212                __gitcomp "$__git_log_pretty_formats
1213                        " "" "${cur##--pretty=}"
1214                return
1215                ;;
1216        --format=*)
1217                __gitcomp "$__git_log_pretty_formats
1218                        " "" "${cur##--format=}"
1219                return
1220                ;;
1221        --date=*)
1222                __gitcomp "$__git_log_date_formats" "" "${cur##--date=}"
1223                return
1224                ;;
1225        --decorate=*)
1226                __gitcomp "long short" "" "${cur##--decorate=}"
1227                return
1228                ;;
1229        --*)
1230                __gitcomp "
1231                        $__git_log_common_options
1232                        $__git_log_shortlog_options
1233                        $__git_log_gitk_options
1234                        --root --topo-order --date-order --reverse
1235                        --follow --full-diff
1236                        --abbrev-commit --abbrev=
1237                        --relative-date --date=
1238                        --pretty= --format= --oneline
1239                        --cherry-pick
1240                        --graph
1241                        --decorate --decorate=
1242                        --walk-reflogs
1243                        --parents --children
1244                        $merge
1245                        $__git_diff_common_options
1246                        --pickaxe-all --pickaxe-regex
1247                        "
1248                return
1249                ;;
1250        esac
1251        __git_complete_revlist
1252}
1253
1254__git_merge_options="
1255        --no-commit --no-stat --log --no-log --squash --strategy
1256        --commit --stat --no-squash --ff --no-ff --ff-only
1257"
1258
1259_git_merge ()
1260{
1261        __git_complete_strategy && return
1262
1263        local cur="${COMP_WORDS[COMP_CWORD]}"
1264        case "$cur" in
1265        --*)
1266                __gitcomp "$__git_merge_options"
1267                return
1268        esac
1269        __gitcomp "$(__git_refs)"
1270}
1271
1272_git_mergetool ()
1273{
1274        local cur="${COMP_WORDS[COMP_CWORD]}"
1275        case "$cur" in
1276        --tool=*)
1277                __gitcomp "$__git_mergetools_common tortoisemerge" "" "${cur##--tool=}"
1278                return
1279                ;;
1280        --*)
1281                __gitcomp "--tool="
1282                return
1283                ;;
1284        esac
1285        COMPREPLY=()
1286}
1287
1288_git_merge_base ()
1289{
1290        __gitcomp "$(__git_refs)"
1291}
1292
1293_git_mv ()
1294{
1295        local cur="${COMP_WORDS[COMP_CWORD]}"
1296        case "$cur" in
1297        --*)
1298                __gitcomp "--dry-run"
1299                return
1300                ;;
1301        esac
1302        COMPREPLY=()
1303}
1304
1305_git_name_rev ()
1306{
1307        __gitcomp "--tags --all --stdin"
1308}
1309
1310_git_notes ()
1311{
1312        local subcommands="edit show"
1313        if [ -z "$(__git_find_on_cmdline "$subcommands")" ]; then
1314                __gitcomp "$subcommands"
1315                return
1316        fi
1317
1318        case "${COMP_WORDS[COMP_CWORD-1]}" in
1319        -m|-F)
1320                COMPREPLY=()
1321                ;;
1322        *)
1323                __gitcomp "$(__git_refs)"
1324                ;;
1325        esac
1326}
1327
1328_git_pull ()
1329{
1330        __git_complete_strategy && return
1331
1332        local cur="${COMP_WORDS[COMP_CWORD]}"
1333        case "$cur" in
1334        --*)
1335                __gitcomp "
1336                        --rebase --no-rebase
1337                        $__git_merge_options
1338                        $__git_fetch_options
1339                "
1340                return
1341                ;;
1342        esac
1343        __git_complete_remote_or_refspec
1344}
1345
1346_git_push ()
1347{
1348        local cur="${COMP_WORDS[COMP_CWORD]}"
1349        case "${COMP_WORDS[COMP_CWORD-1]}" in
1350        --repo)
1351                __gitcomp "$(__git_remotes)"
1352                return
1353        esac
1354        case "$cur" in
1355        --repo=*)
1356                __gitcomp "$(__git_remotes)" "" "${cur##--repo=}"
1357                return
1358                ;;
1359        --*)
1360                __gitcomp "
1361                        --all --mirror --tags --dry-run --force --verbose
1362                        --receive-pack= --repo=
1363                "
1364                return
1365                ;;
1366        esac
1367        __git_complete_remote_or_refspec
1368}
1369
1370_git_rebase ()
1371{
1372        local cur="${COMP_WORDS[COMP_CWORD]}" dir="$(__gitdir)"
1373        if [ -d "$dir"/rebase-apply ] || [ -d "$dir"/rebase-merge ]; then
1374                __gitcomp "--continue --skip --abort"
1375                return
1376        fi
1377        __git_complete_strategy && return
1378        case "$cur" in
1379        --whitespace=*)
1380                __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
1381                return
1382                ;;
1383        --*)
1384                __gitcomp "
1385                        --onto --merge --strategy --interactive
1386                        --preserve-merges --stat --no-stat
1387                        --committer-date-is-author-date --ignore-date
1388                        --ignore-whitespace --whitespace=
1389                        "
1390
1391                return
1392        esac
1393        __gitcomp "$(__git_refs)"
1394}
1395
1396__git_send_email_confirm_options="always never auto cc compose"
1397__git_send_email_suppresscc_options="author self cc bodycc sob cccmd body all"
1398
1399_git_send_email ()
1400{
1401        local cur="${COMP_WORDS[COMP_CWORD]}"
1402        case "$cur" in
1403        --confirm=*)
1404                __gitcomp "
1405                        $__git_send_email_confirm_options
1406                        " "" "${cur##--confirm=}"
1407                return
1408                ;;
1409        --suppress-cc=*)
1410                __gitcomp "
1411                        $__git_send_email_suppresscc_options
1412                        " "" "${cur##--suppress-cc=}"
1413
1414                return
1415                ;;
1416        --smtp-encryption=*)
1417                __gitcomp "ssl tls" "" "${cur##--smtp-encryption=}"
1418                return
1419                ;;
1420        --*)
1421                __gitcomp "--annotate --bcc --cc --cc-cmd --chain-reply-to
1422                        --compose --confirm= --dry-run --envelope-sender
1423                        --from --identity
1424                        --in-reply-to --no-chain-reply-to --no-signed-off-by-cc
1425                        --no-suppress-from --no-thread --quiet
1426                        --signed-off-by-cc --smtp-pass --smtp-server
1427                        --smtp-server-port --smtp-encryption= --smtp-user
1428                        --subject --suppress-cc= --suppress-from --thread --to
1429                        --validate --no-validate"
1430                return
1431                ;;
1432        esac
1433        COMPREPLY=()
1434}
1435
1436__git_config_get_set_variables ()
1437{
1438        local prevword word config_file= c=$COMP_CWORD
1439        while [ $c -gt 1 ]; do
1440                word="${COMP_WORDS[c]}"
1441                case "$word" in
1442                --global|--system|--file=*)
1443                        config_file="$word"
1444                        break
1445                        ;;
1446                -f|--file)
1447                        config_file="$word $prevword"
1448                        break
1449                        ;;
1450                esac
1451                prevword=$word
1452                c=$((--c))
1453        done
1454
1455        git --git-dir="$(__gitdir)" config $config_file --list 2>/dev/null |
1456        while read line
1457        do
1458                case "$line" in
1459                *.*=*)
1460                        echo "${line/=*/}"
1461                        ;;
1462                esac
1463        done
1464}
1465
1466_git_config ()
1467{
1468        local cur="${COMP_WORDS[COMP_CWORD]}"
1469        local prv="${COMP_WORDS[COMP_CWORD-1]}"
1470        case "$prv" in
1471        branch.*.remote)
1472                __gitcomp "$(__git_remotes)"
1473                return
1474                ;;
1475        branch.*.merge)
1476                __gitcomp "$(__git_refs)"
1477                return
1478                ;;
1479        remote.*.fetch)
1480                local remote="${prv#remote.}"
1481                remote="${remote%.fetch}"
1482                __gitcomp "$(__git_refs_remotes "$remote")"
1483                return
1484                ;;
1485        remote.*.push)
1486                local remote="${prv#remote.}"
1487                remote="${remote%.push}"
1488                __gitcomp "$(git --git-dir="$(__gitdir)" \
1489                        for-each-ref --format='%(refname):%(refname)' \
1490                        refs/heads)"
1491                return
1492                ;;
1493        pull.twohead|pull.octopus)
1494                __git_compute_merge_strategies
1495                __gitcomp "$__git_merge_strategies"
1496                return
1497                ;;
1498        color.branch|color.diff|color.interactive|\
1499        color.showbranch|color.status|color.ui)
1500                __gitcomp "always never auto"
1501                return
1502                ;;
1503        color.pager)
1504                __gitcomp "false true"
1505                return
1506                ;;
1507        color.*.*)
1508                __gitcomp "
1509                        normal black red green yellow blue magenta cyan white
1510                        bold dim ul blink reverse
1511                        "
1512                return
1513                ;;
1514        help.format)
1515                __gitcomp "man info web html"
1516                return
1517                ;;
1518        log.date)
1519                __gitcomp "$__git_log_date_formats"
1520                return
1521                ;;
1522        sendemail.aliasesfiletype)
1523                __gitcomp "mutt mailrc pine elm gnus"
1524                return
1525                ;;
1526        sendemail.confirm)
1527                __gitcomp "$__git_send_email_confirm_options"
1528                return
1529                ;;
1530        sendemail.suppresscc)
1531                __gitcomp "$__git_send_email_suppresscc_options"
1532                return
1533                ;;
1534        --get|--get-all|--unset|--unset-all)
1535                __gitcomp "$(__git_config_get_set_variables)"
1536                return
1537                ;;
1538        *.*)
1539                COMPREPLY=()
1540                return
1541                ;;
1542        esac
1543        case "$cur" in
1544        --*)
1545                __gitcomp "
1546                        --global --system --file=
1547                        --list --replace-all
1548                        --get --get-all --get-regexp
1549                        --add --unset --unset-all
1550                        --remove-section --rename-section
1551                        "
1552                return
1553                ;;
1554        branch.*.*)
1555                local pfx="${cur%.*}."
1556                cur="${cur##*.}"
1557                __gitcomp "remote merge mergeoptions rebase" "$pfx" "$cur"
1558                return
1559                ;;
1560        branch.*)
1561                local pfx="${cur%.*}."
1562                cur="${cur#*.}"
1563                __gitcomp "$(__git_heads)" "$pfx" "$cur" "."
1564                return
1565                ;;
1566        guitool.*.*)
1567                local pfx="${cur%.*}."
1568                cur="${cur##*.}"
1569                __gitcomp "
1570                        argprompt cmd confirm needsfile noconsole norescan
1571                        prompt revprompt revunmerged title
1572                        " "$pfx" "$cur"
1573                return
1574                ;;
1575        difftool.*.*)
1576                local pfx="${cur%.*}."
1577                cur="${cur##*.}"
1578                __gitcomp "cmd path" "$pfx" "$cur"
1579                return
1580                ;;
1581        man.*.*)
1582                local pfx="${cur%.*}."
1583                cur="${cur##*.}"
1584                __gitcomp "cmd path" "$pfx" "$cur"
1585                return
1586                ;;
1587        mergetool.*.*)
1588                local pfx="${cur%.*}."
1589                cur="${cur##*.}"
1590                __gitcomp "cmd path trustExitCode" "$pfx" "$cur"
1591                return
1592                ;;
1593        pager.*)
1594                local pfx="${cur%.*}."
1595                cur="${cur#*.}"
1596                __git_compute_all_commands
1597                __gitcomp "$__git_all_commands" "$pfx" "$cur"
1598                return
1599                ;;
1600        remote.*.*)
1601                local pfx="${cur%.*}."
1602                cur="${cur##*.}"
1603                __gitcomp "
1604                        url proxy fetch push mirror skipDefaultUpdate
1605                        receivepack uploadpack tagopt pushurl
1606                        " "$pfx" "$cur"
1607                return
1608                ;;
1609        remote.*)
1610                local pfx="${cur%.*}."
1611                cur="${cur#*.}"
1612                __gitcomp "$(__git_remotes)" "$pfx" "$cur" "."
1613                return
1614                ;;
1615        url.*.*)
1616                local pfx="${cur%.*}."
1617                cur="${cur##*.}"
1618                __gitcomp "insteadOf pushInsteadOf" "$pfx" "$cur"
1619                return
1620                ;;
1621        esac
1622        __gitcomp "
1623                add.ignore-errors
1624                alias.
1625                apply.ignorewhitespace
1626                apply.whitespace
1627                branch.autosetupmerge
1628                branch.autosetuprebase
1629                clean.requireForce
1630                color.branch
1631                color.branch.current
1632                color.branch.local
1633                color.branch.plain
1634                color.branch.remote
1635                color.diff
1636                color.diff.commit
1637                color.diff.frag
1638                color.diff.meta
1639                color.diff.new
1640                color.diff.old
1641                color.diff.plain
1642                color.diff.whitespace
1643                color.grep
1644                color.grep.external
1645                color.grep.match
1646                color.interactive
1647                color.interactive.header
1648                color.interactive.help
1649                color.interactive.prompt
1650                color.pager
1651                color.showbranch
1652                color.status
1653                color.status.added
1654                color.status.changed
1655                color.status.header
1656                color.status.nobranch
1657                color.status.untracked
1658                color.status.updated
1659                color.ui
1660                commit.template
1661                core.autocrlf
1662                core.bare
1663                core.compression
1664                core.createObject
1665                core.deltaBaseCacheLimit
1666                core.editor
1667                core.excludesfile
1668                core.fileMode
1669                core.fsyncobjectfiles
1670                core.gitProxy
1671                core.ignoreCygwinFSTricks
1672                core.ignoreStat
1673                core.logAllRefUpdates
1674                core.loosecompression
1675                core.packedGitLimit
1676                core.packedGitWindowSize
1677                core.pager
1678                core.preferSymlinkRefs
1679                core.preloadindex
1680                core.quotepath
1681                core.repositoryFormatVersion
1682                core.safecrlf
1683                core.sharedRepository
1684                core.symlinks
1685                core.trustctime
1686                core.warnAmbiguousRefs
1687                core.whitespace
1688                core.worktree
1689                diff.autorefreshindex
1690                diff.external
1691                diff.mnemonicprefix
1692                diff.renameLimit
1693                diff.renameLimit.
1694                diff.renames
1695                diff.suppressBlankEmpty
1696                diff.tool
1697                diff.wordRegex
1698                difftool.
1699                difftool.prompt
1700                fetch.unpackLimit
1701                format.attach
1702                format.cc
1703                format.headers
1704                format.numbered
1705                format.pretty
1706                format.signoff
1707                format.subjectprefix
1708                format.suffix
1709                format.thread
1710                gc.aggressiveWindow
1711                gc.auto
1712                gc.autopacklimit
1713                gc.packrefs
1714                gc.pruneexpire
1715                gc.reflogexpire
1716                gc.reflogexpireunreachable
1717                gc.rerereresolved
1718                gc.rerereunresolved
1719                gitcvs.allbinary
1720                gitcvs.commitmsgannotation
1721                gitcvs.dbTableNamePrefix
1722                gitcvs.dbdriver
1723                gitcvs.dbname
1724                gitcvs.dbpass
1725                gitcvs.dbuser
1726                gitcvs.enabled
1727                gitcvs.logfile
1728                gitcvs.usecrlfattr
1729                guitool.
1730                gui.blamehistoryctx
1731                gui.commitmsgwidth
1732                gui.copyblamethreshold
1733                gui.diffcontext
1734                gui.encoding
1735                gui.fastcopyblame
1736                gui.matchtrackingbranch
1737                gui.newbranchtemplate
1738                gui.pruneduringfetch
1739                gui.spellingdictionary
1740                gui.trustmtime
1741                help.autocorrect
1742                help.browser
1743                help.format
1744                http.lowSpeedLimit
1745                http.lowSpeedTime
1746                http.maxRequests
1747                http.noEPSV
1748                http.proxy
1749                http.sslCAInfo
1750                http.sslCAPath
1751                http.sslCert
1752                http.sslKey
1753                http.sslVerify
1754                i18n.commitEncoding
1755                i18n.logOutputEncoding
1756                imap.folder
1757                imap.host
1758                imap.pass
1759                imap.port
1760                imap.preformattedHTML
1761                imap.sslverify
1762                imap.tunnel
1763                imap.user
1764                instaweb.browser
1765                instaweb.httpd
1766                instaweb.local
1767                instaweb.modulepath
1768                instaweb.port
1769                interactive.singlekey
1770                log.date
1771                log.showroot
1772                mailmap.file
1773                man.
1774                man.viewer
1775                merge.conflictstyle
1776                merge.log
1777                merge.renameLimit
1778                merge.stat
1779                merge.tool
1780                merge.verbosity
1781                mergetool.
1782                mergetool.keepBackup
1783                mergetool.prompt
1784                pack.compression
1785                pack.deltaCacheLimit
1786                pack.deltaCacheSize
1787                pack.depth
1788                pack.indexVersion
1789                pack.packSizeLimit
1790                pack.threads
1791                pack.window
1792                pack.windowMemory
1793                pager.
1794                pull.octopus
1795                pull.twohead
1796                push.default
1797                rebase.stat
1798                receive.denyCurrentBranch
1799                receive.denyDeletes
1800                receive.denyNonFastForwards
1801                receive.fsckObjects
1802                receive.unpackLimit
1803                repack.usedeltabaseoffset
1804                rerere.autoupdate
1805                rerere.enabled
1806                sendemail.aliasesfile
1807                sendemail.aliasesfiletype
1808                sendemail.bcc
1809                sendemail.cc
1810                sendemail.cccmd
1811                sendemail.chainreplyto
1812                sendemail.confirm
1813                sendemail.envelopesender
1814                sendemail.multiedit
1815                sendemail.signedoffbycc
1816                sendemail.smtpencryption
1817                sendemail.smtppass
1818                sendemail.smtpserver
1819                sendemail.smtpserverport
1820                sendemail.smtpuser
1821                sendemail.suppresscc
1822                sendemail.suppressfrom
1823                sendemail.thread
1824                sendemail.to
1825                sendemail.validate
1826                showbranch.default
1827                status.relativePaths
1828                status.showUntrackedFiles
1829                tar.umask
1830                transfer.unpackLimit
1831                url.
1832                user.email
1833                user.name
1834                user.signingkey
1835                web.browser
1836                branch. remote.
1837        "
1838}
1839
1840_git_remote ()
1841{
1842        local subcommands="add rename rm show prune update set-head"
1843        local subcommand="$(__git_find_on_cmdline "$subcommands")"
1844        if [ -z "$subcommand" ]; then
1845                __gitcomp "$subcommands"
1846                return
1847        fi
1848
1849        case "$subcommand" in
1850        rename|rm|show|prune)
1851                __gitcomp "$(__git_remotes)"
1852                ;;
1853        update)
1854                local i c='' IFS=$'\n'
1855                for i in $(git --git-dir="$(__gitdir)" config --get-regexp "remotes\..*" 2>/dev/null); do
1856                        i="${i#remotes.}"
1857                        c="$c ${i/ */}"
1858                done
1859                __gitcomp "$c"
1860                ;;
1861        *)
1862                COMPREPLY=()
1863                ;;
1864        esac
1865}
1866
1867_git_replace ()
1868{
1869        __gitcomp "$(__git_refs)"
1870}
1871
1872_git_reset ()
1873{
1874        __git_has_doubledash && return
1875
1876        local cur="${COMP_WORDS[COMP_CWORD]}"
1877        case "$cur" in
1878        --*)
1879                __gitcomp "--merge --mixed --hard --soft --patch"
1880                return
1881                ;;
1882        esac
1883        __gitcomp "$(__git_refs)"
1884}
1885
1886_git_revert ()
1887{
1888        local cur="${COMP_WORDS[COMP_CWORD]}"
1889        case "$cur" in
1890        --*)
1891                __gitcomp "--edit --mainline --no-edit --no-commit --signoff"
1892                return
1893                ;;
1894        esac
1895        __gitcomp "$(__git_refs)"
1896}
1897
1898_git_rm ()
1899{
1900        __git_has_doubledash && return
1901
1902        local cur="${COMP_WORDS[COMP_CWORD]}"
1903        case "$cur" in
1904        --*)
1905                __gitcomp "--cached --dry-run --ignore-unmatch --quiet"
1906                return
1907                ;;
1908        esac
1909        COMPREPLY=()
1910}
1911
1912_git_shortlog ()
1913{
1914        __git_has_doubledash && return
1915
1916        local cur="${COMP_WORDS[COMP_CWORD]}"
1917        case "$cur" in
1918        --*)
1919                __gitcomp "
1920                        $__git_log_common_options
1921                        $__git_log_shortlog_options
1922                        --numbered --summary
1923                        "
1924                return
1925                ;;
1926        esac
1927        __git_complete_revlist
1928}
1929
1930_git_show ()
1931{
1932        __git_has_doubledash && return
1933
1934        local cur="${COMP_WORDS[COMP_CWORD]}"
1935        case "$cur" in
1936        --pretty=*)
1937                __gitcomp "$__git_log_pretty_formats
1938                        " "" "${cur##--pretty=}"
1939                return
1940                ;;
1941        --format=*)
1942                __gitcomp "$__git_log_pretty_formats
1943                        " "" "${cur##--format=}"
1944                return
1945                ;;
1946        --*)
1947                __gitcomp "--pretty= --format= --abbrev-commit --oneline
1948                        $__git_diff_common_options
1949                        "
1950                return
1951                ;;
1952        esac
1953        __git_complete_file
1954}
1955
1956_git_show_branch ()
1957{
1958        local cur="${COMP_WORDS[COMP_CWORD]}"
1959        case "$cur" in
1960        --*)
1961                __gitcomp "
1962                        --all --remotes --topo-order --current --more=
1963                        --list --independent --merge-base --no-name
1964                        --color --no-color
1965                        --sha1-name --sparse --topics --reflog
1966                        "
1967                return
1968                ;;
1969        esac
1970        __git_complete_revlist
1971}
1972
1973_git_stash ()
1974{
1975        local cur="${COMP_WORDS[COMP_CWORD]}"
1976        local save_opts='--keep-index --no-keep-index --quiet --patch'
1977        local subcommands='save list show apply clear drop pop create branch'
1978        local subcommand="$(__git_find_on_cmdline "$subcommands")"
1979        if [ -z "$subcommand" ]; then
1980                case "$cur" in
1981                --*)
1982                        __gitcomp "$save_opts"
1983                        ;;
1984                *)
1985                        if [ -z "$(__git_find_on_cmdline "$save_opts")" ]; then
1986                                __gitcomp "$subcommands"
1987                        else
1988                                COMPREPLY=()
1989                        fi
1990                        ;;
1991                esac
1992        else
1993                case "$subcommand,$cur" in
1994                save,--*)
1995                        __gitcomp "$save_opts"
1996                        ;;
1997                apply,--*|pop,--*)
1998                        __gitcomp "--index --quiet"
1999                        ;;
2000                show,--*|drop,--*|branch,--*)
2001                        COMPREPLY=()
2002                        ;;
2003                show,*|apply,*|drop,*|pop,*|branch,*)
2004                        __gitcomp "$(git --git-dir="$(__gitdir)" stash list \
2005                                        | sed -n -e 's/:.*//p')"
2006                        ;;
2007                *)
2008                        COMPREPLY=()
2009                        ;;
2010                esac
2011        fi
2012}
2013
2014_git_submodule ()
2015{
2016        __git_has_doubledash && return
2017
2018        local subcommands="add status init update summary foreach sync"
2019        if [ -z "$(__git_find_on_cmdline "$subcommands")" ]; then
2020                local cur="${COMP_WORDS[COMP_CWORD]}"
2021                case "$cur" in
2022                --*)
2023                        __gitcomp "--quiet --cached"
2024                        ;;
2025                *)
2026                        __gitcomp "$subcommands"
2027                        ;;
2028                esac
2029                return
2030        fi
2031}
2032
2033_git_svn ()
2034{
2035        local subcommands="
2036                init fetch clone rebase dcommit log find-rev
2037                set-tree commit-diff info create-ignore propget
2038                proplist show-ignore show-externals branch tag blame
2039                migrate mkdirs reset gc
2040                "
2041        local subcommand="$(__git_find_on_cmdline "$subcommands")"
2042        if [ -z "$subcommand" ]; then
2043                __gitcomp "$subcommands"
2044        else
2045                local remote_opts="--username= --config-dir= --no-auth-cache"
2046                local fc_opts="
2047                        --follow-parent --authors-file= --repack=
2048                        --no-metadata --use-svm-props --use-svnsync-props
2049                        --log-window-size= --no-checkout --quiet
2050                        --repack-flags --use-log-author --localtime
2051                        --ignore-paths= $remote_opts
2052                        "
2053                local init_opts="
2054                        --template= --shared= --trunk= --tags=
2055                        --branches= --stdlayout --minimize-url
2056                        --no-metadata --use-svm-props --use-svnsync-props
2057                        --rewrite-root= --prefix= --use-log-author
2058                        --add-author-from $remote_opts
2059                        "
2060                local cmt_opts="
2061                        --edit --rmdir --find-copies-harder --copy-similarity=
2062                        "
2063
2064                local cur="${COMP_WORDS[COMP_CWORD]}"
2065                case "$subcommand,$cur" in
2066                fetch,--*)
2067                        __gitcomp "--revision= --fetch-all $fc_opts"
2068                        ;;
2069                clone,--*)
2070                        __gitcomp "--revision= $fc_opts $init_opts"
2071                        ;;
2072                init,--*)
2073                        __gitcomp "$init_opts"
2074                        ;;
2075                dcommit,--*)
2076                        __gitcomp "
2077                                --merge --strategy= --verbose --dry-run
2078                                --fetch-all --no-rebase --commit-url
2079                                --revision $cmt_opts $fc_opts
2080                                "
2081                        ;;
2082                set-tree,--*)
2083                        __gitcomp "--stdin $cmt_opts $fc_opts"
2084                        ;;
2085                create-ignore,--*|propget,--*|proplist,--*|show-ignore,--*|\
2086                show-externals,--*|mkdirs,--*)
2087                        __gitcomp "--revision="
2088                        ;;
2089                log,--*)
2090                        __gitcomp "
2091                                --limit= --revision= --verbose --incremental
2092                                --oneline --show-commit --non-recursive
2093                                --authors-file= --color
2094                                "
2095                        ;;
2096                rebase,--*)
2097                        __gitcomp "
2098                                --merge --verbose --strategy= --local
2099                                --fetch-all --dry-run $fc_opts
2100                                "
2101                        ;;
2102                commit-diff,--*)
2103                        __gitcomp "--message= --file= --revision= $cmt_opts"
2104                        ;;
2105                info,--*)
2106                        __gitcomp "--url"
2107                        ;;
2108                branch,--*)
2109                        __gitcomp "--dry-run --message --tag"
2110                        ;;
2111                tag,--*)
2112                        __gitcomp "--dry-run --message"
2113                        ;;
2114                blame,--*)
2115                        __gitcomp "--git-format"
2116                        ;;
2117                migrate,--*)
2118                        __gitcomp "
2119                                --config-dir= --ignore-paths= --minimize
2120                                --no-auth-cache --username=
2121                                "
2122                        ;;
2123                reset,--*)
2124                        __gitcomp "--revision= --parent"
2125                        ;;
2126                *)
2127                        COMPREPLY=()
2128                        ;;
2129                esac
2130        fi
2131}
2132
2133_git_tag ()
2134{
2135        local i c=1 f=0
2136        while [ $c -lt $COMP_CWORD ]; do
2137                i="${COMP_WORDS[c]}"
2138                case "$i" in
2139                -d|-v)
2140                        __gitcomp "$(__git_tags)"
2141                        return
2142                        ;;
2143                -f)
2144                        f=1
2145                        ;;
2146                esac
2147                c=$((++c))
2148        done
2149
2150        case "${COMP_WORDS[COMP_CWORD-1]}" in
2151        -m|-F)
2152                COMPREPLY=()
2153                ;;
2154        -*|tag)
2155                if [ $f = 1 ]; then
2156                        __gitcomp "$(__git_tags)"
2157                else
2158                        COMPREPLY=()
2159                fi
2160                ;;
2161        *)
2162                __gitcomp "$(__git_refs)"
2163                ;;
2164        esac
2165}
2166
2167_git ()
2168{
2169        local i c=1 command __git_dir
2170
2171        while [ $c -lt $COMP_CWORD ]; do
2172                i="${COMP_WORDS[c]}"
2173                case "$i" in
2174                --git-dir=*) __git_dir="${i#--git-dir=}" ;;
2175                --bare)      __git_dir="." ;;
2176                --version|-p|--paginate) ;;
2177                --help) command="help"; break ;;
2178                *) command="$i"; break ;;
2179                esac
2180                c=$((++c))
2181        done
2182
2183        if [ -z "$command" ]; then
2184                case "${COMP_WORDS[COMP_CWORD]}" in
2185                --*)   __gitcomp "
2186                        --paginate
2187                        --no-pager
2188                        --git-dir=
2189                        --bare
2190                        --version
2191                        --exec-path
2192                        --html-path
2193                        --work-tree=
2194                        --help
2195                        "
2196                        ;;
2197                *)     __git_compute_porcelain_commands
2198                       __gitcomp "$__git_porcelain_commands $(__git_aliases)" ;;
2199                esac
2200                return
2201        fi
2202
2203        local expansion=$(__git_aliased_command "$command")
2204        [ "$expansion" ] && command="$expansion"
2205
2206        case "$command" in
2207        am)          _git_am ;;
2208        add)         _git_add ;;
2209        apply)       _git_apply ;;
2210        archive)     _git_archive ;;
2211        bisect)      _git_bisect ;;
2212        bundle)      _git_bundle ;;
2213        branch)      _git_branch ;;
2214        checkout)    _git_checkout ;;
2215        cherry)      _git_cherry ;;
2216        cherry-pick) _git_cherry_pick ;;
2217        clean)       _git_clean ;;
2218        clone)       _git_clone ;;
2219        commit)      _git_commit ;;
2220        config)      _git_config ;;
2221        describe)    _git_describe ;;
2222        diff)        _git_diff ;;
2223        difftool)    _git_difftool ;;
2224        fetch)       _git_fetch ;;
2225        format-patch) _git_format_patch ;;
2226        fsck)        _git_fsck ;;
2227        gc)          _git_gc ;;
2228        grep)        _git_grep ;;
2229        help)        _git_help ;;
2230        init)        _git_init ;;
2231        log)         _git_log ;;
2232        ls-files)    _git_ls_files ;;
2233        ls-remote)   _git_ls_remote ;;
2234        ls-tree)     _git_ls_tree ;;
2235        merge)       _git_merge;;
2236        mergetool)   _git_mergetool;;
2237        merge-base)  _git_merge_base ;;
2238        mv)          _git_mv ;;
2239        name-rev)    _git_name_rev ;;
2240        notes)       _git_notes ;;
2241        pull)        _git_pull ;;
2242        push)        _git_push ;;
2243        rebase)      _git_rebase ;;
2244        remote)      _git_remote ;;
2245        replace)     _git_replace ;;
2246        reset)       _git_reset ;;
2247        revert)      _git_revert ;;
2248        rm)          _git_rm ;;
2249        send-email)  _git_send_email ;;
2250        shortlog)    _git_shortlog ;;
2251        show)        _git_show ;;
2252        show-branch) _git_show_branch ;;
2253        stash)       _git_stash ;;
2254        stage)       _git_add ;;
2255        submodule)   _git_submodule ;;
2256        svn)         _git_svn ;;
2257        tag)         _git_tag ;;
2258        whatchanged) _git_log ;;
2259        *)           COMPREPLY=() ;;
2260        esac
2261}
2262
2263_gitk ()
2264{
2265        __git_has_doubledash && return
2266
2267        local cur="${COMP_WORDS[COMP_CWORD]}"
2268        local g="$(__gitdir)"
2269        local merge=""
2270        if [ -f "$g/MERGE_HEAD" ]; then
2271                merge="--merge"
2272        fi
2273        case "$cur" in
2274        --*)
2275                __gitcomp "
2276                        $__git_log_common_options
2277                        $__git_log_gitk_options
2278                        $merge
2279                        "
2280                return
2281                ;;
2282        esac
2283        __git_complete_revlist
2284}
2285
2286complete -o bashdefault -o default -o nospace -F _git git 2>/dev/null \
2287        || complete -o default -o nospace -F _git git
2288complete -o bashdefault -o default -o nospace -F _gitk gitk 2>/dev/null \
2289        || complete -o default -o nospace -F _gitk gitk
2290
2291# The following are necessary only for Cygwin, and only are needed
2292# when the user has tab-completed the executable name and consequently
2293# included the '.exe' suffix.
2294#
2295if [ Cygwin = "$(uname -o 2>/dev/null)" ]; then
2296complete -o bashdefault -o default -o nospace -F _git git.exe 2>/dev/null \
2297        || complete -o default -o nospace -F _git git.exe
2298fi