Andrew's git - gitweb.git/blob - contrib/completion/git-completion.bash

   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 --continue --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                        --autosquash
1390                        "
1391
1392                return
1393        esac
1394        __gitcomp "$(__git_refs)"
1395}
1396
1397__git_send_email_confirm_options="always never auto cc compose"
1398__git_send_email_suppresscc_options="author self cc bodycc sob cccmd body all"
1399
1400_git_send_email ()
1401{
1402        local cur="${COMP_WORDS[COMP_CWORD]}"
1403        case "$cur" in
1404        --confirm=*)
1405                __gitcomp "
1406                        $__git_send_email_confirm_options
1407                        " "" "${cur##--confirm=}"
1408                return
1409                ;;
1410        --suppress-cc=*)
1411                __gitcomp "
1412                        $__git_send_email_suppresscc_options
1413                        " "" "${cur##--suppress-cc=}"
1414
1415                return
1416                ;;
1417        --smtp-encryption=*)
1418                __gitcomp "ssl tls" "" "${cur##--smtp-encryption=}"
1419                return
1420                ;;
1421        --*)
1422                __gitcomp "--annotate --bcc --cc --cc-cmd --chain-reply-to
1423                        --compose --confirm= --dry-run --envelope-sender
1424                        --from --identity
1425                        --in-reply-to --no-chain-reply-to --no-signed-off-by-cc
1426                        --no-suppress-from --no-thread --quiet
1427                        --signed-off-by-cc --smtp-pass --smtp-server
1428                        --smtp-server-port --smtp-encryption= --smtp-user
1429                        --subject --suppress-cc= --suppress-from --thread --to
1430                        --validate --no-validate"
1431                return
1432                ;;
1433        esac
1434        COMPREPLY=()
1435}
1436
1437__git_config_get_set_variables ()
1438{
1439        local prevword word config_file= c=$COMP_CWORD
1440        while [ $c -gt 1 ]; do
1441                word="${COMP_WORDS[c]}"
1442                case "$word" in
1443                --global|--system|--file=*)
1444                        config_file="$word"
1445                        break
1446                        ;;
1447                -f|--file)
1448                        config_file="$word $prevword"
1449                        break
1450                        ;;
1451                esac
1452                prevword=$word
1453                c=$((--c))
1454        done
1455
1456        git --git-dir="$(__gitdir)" config $config_file --list 2>/dev/null |
1457        while read line
1458        do
1459                case "$line" in
1460                *.*=*)
1461                        echo "${line/=*/}"
1462                        ;;
1463                esac
1464        done
1465}
1466
1467_git_config ()
1468{
1469        local cur="${COMP_WORDS[COMP_CWORD]}"
1470        local prv="${COMP_WORDS[COMP_CWORD-1]}"
1471        case "$prv" in
1472        branch.*.remote)
1473                __gitcomp "$(__git_remotes)"
1474                return
1475                ;;
1476        branch.*.merge)
1477                __gitcomp "$(__git_refs)"
1478                return
1479                ;;
1480        remote.*.fetch)
1481                local remote="${prv#remote.}"
1482                remote="${remote%.fetch}"
1483                __gitcomp "$(__git_refs_remotes "$remote")"
1484                return
1485                ;;
1486        remote.*.push)
1487                local remote="${prv#remote.}"
1488                remote="${remote%.push}"
1489                __gitcomp "$(git --git-dir="$(__gitdir)" \
1490                        for-each-ref --format='%(refname):%(refname)' \
1491                        refs/heads)"
1492                return
1493                ;;
1494        pull.twohead|pull.octopus)
1495                __git_compute_merge_strategies
1496                __gitcomp "$__git_merge_strategies"
1497                return
1498                ;;
1499        color.branch|color.diff|color.interactive|\
1500        color.showbranch|color.status|color.ui)
1501                __gitcomp "always never auto"
1502                return
1503                ;;
1504        color.pager)
1505                __gitcomp "false true"
1506                return
1507                ;;
1508        color.*.*)
1509                __gitcomp "
1510                        normal black red green yellow blue magenta cyan white
1511                        bold dim ul blink reverse
1512                        "
1513                return
1514                ;;
1515        help.format)
1516                __gitcomp "man info web html"
1517                return
1518                ;;
1519        log.date)
1520                __gitcomp "$__git_log_date_formats"
1521                return
1522                ;;
1523        sendemail.aliasesfiletype)
1524                __gitcomp "mutt mailrc pine elm gnus"
1525                return
1526                ;;
1527        sendemail.confirm)
1528                __gitcomp "$__git_send_email_confirm_options"
1529                return
1530                ;;
1531        sendemail.suppresscc)
1532                __gitcomp "$__git_send_email_suppresscc_options"
1533                return
1534                ;;
1535        --get|--get-all|--unset|--unset-all)
1536                __gitcomp "$(__git_config_get_set_variables)"
1537                return
1538                ;;
1539        *.*)
1540                COMPREPLY=()
1541                return
1542                ;;
1543        esac
1544        case "$cur" in
1545        --*)
1546                __gitcomp "
1547                        --global --system --file=
1548                        --list --replace-all
1549                        --get --get-all --get-regexp
1550                        --add --unset --unset-all
1551                        --remove-section --rename-section
1552                        "
1553                return
1554                ;;
1555        branch.*.*)
1556                local pfx="${cur%.*}."
1557                cur="${cur##*.}"
1558                __gitcomp "remote merge mergeoptions rebase" "$pfx" "$cur"
1559                return
1560                ;;
1561        branch.*)
1562                local pfx="${cur%.*}."
1563                cur="${cur#*.}"
1564                __gitcomp "$(__git_heads)" "$pfx" "$cur" "."
1565                return
1566                ;;
1567        guitool.*.*)
1568                local pfx="${cur%.*}."
1569                cur="${cur##*.}"
1570                __gitcomp "
1571                        argprompt cmd confirm needsfile noconsole norescan
1572                        prompt revprompt revunmerged title
1573                        " "$pfx" "$cur"
1574                return
1575                ;;
1576        difftool.*.*)
1577                local pfx="${cur%.*}."
1578                cur="${cur##*.}"
1579                __gitcomp "cmd path" "$pfx" "$cur"
1580                return
1581                ;;
1582        man.*.*)
1583                local pfx="${cur%.*}."
1584                cur="${cur##*.}"
1585                __gitcomp "cmd path" "$pfx" "$cur"
1586                return
1587                ;;
1588        mergetool.*.*)
1589                local pfx="${cur%.*}."
1590                cur="${cur##*.}"
1591                __gitcomp "cmd path trustExitCode" "$pfx" "$cur"
1592                return
1593                ;;
1594        pager.*)
1595                local pfx="${cur%.*}."
1596                cur="${cur#*.}"
1597                __git_compute_all_commands
1598                __gitcomp "$__git_all_commands" "$pfx" "$cur"
1599                return
1600                ;;
1601        remote.*.*)
1602                local pfx="${cur%.*}."
1603                cur="${cur##*.}"
1604                __gitcomp "
1605                        url proxy fetch push mirror skipDefaultUpdate
1606                        receivepack uploadpack tagopt pushurl
1607                        " "$pfx" "$cur"
1608                return
1609                ;;
1610        remote.*)
1611                local pfx="${cur%.*}."
1612                cur="${cur#*.}"
1613                __gitcomp "$(__git_remotes)" "$pfx" "$cur" "."
1614                return
1615                ;;
1616        url.*.*)
1617                local pfx="${cur%.*}."
1618                cur="${cur##*.}"
1619                __gitcomp "insteadOf pushInsteadOf" "$pfx" "$cur"
1620                return
1621                ;;
1622        esac
1623        __gitcomp "
1624                add.ignore-errors
1625                alias.
1626                apply.ignorewhitespace
1627                apply.whitespace
1628                branch.autosetupmerge
1629                branch.autosetuprebase
1630                clean.requireForce
1631                color.branch
1632                color.branch.current
1633                color.branch.local
1634                color.branch.plain
1635                color.branch.remote
1636                color.diff
1637                color.diff.commit
1638                color.diff.frag
1639                color.diff.meta
1640                color.diff.new
1641                color.diff.old
1642                color.diff.plain
1643                color.diff.whitespace
1644                color.grep
1645                color.grep.external
1646                color.grep.match
1647                color.interactive
1648                color.interactive.header
1649                color.interactive.help
1650                color.interactive.prompt
1651                color.pager
1652                color.showbranch
1653                color.status
1654                color.status.added
1655                color.status.changed
1656                color.status.header
1657                color.status.nobranch
1658                color.status.untracked
1659                color.status.updated
1660                color.ui
1661                commit.template
1662                core.autocrlf
1663                core.bare
1664                core.compression
1665                core.createObject
1666                core.deltaBaseCacheLimit
1667                core.editor
1668                core.excludesfile
1669                core.fileMode
1670                core.fsyncobjectfiles
1671                core.gitProxy
1672                core.ignoreCygwinFSTricks
1673                core.ignoreStat
1674                core.logAllRefUpdates
1675                core.loosecompression
1676                core.packedGitLimit
1677                core.packedGitWindowSize
1678                core.pager
1679                core.preferSymlinkRefs
1680                core.preloadindex
1681                core.quotepath
1682                core.repositoryFormatVersion
1683                core.safecrlf
1684                core.sharedRepository
1685                core.symlinks
1686                core.trustctime
1687                core.warnAmbiguousRefs
1688                core.whitespace
1689                core.worktree
1690                diff.autorefreshindex
1691                diff.external
1692                diff.mnemonicprefix
1693                diff.renameLimit
1694                diff.renameLimit.
1695                diff.renames
1696                diff.suppressBlankEmpty
1697                diff.tool
1698                diff.wordRegex
1699                difftool.
1700                difftool.prompt
1701                fetch.unpackLimit
1702                format.attach
1703                format.cc
1704                format.headers
1705                format.numbered
1706                format.pretty
1707                format.signoff
1708                format.subjectprefix
1709                format.suffix
1710                format.thread
1711                gc.aggressiveWindow
1712                gc.auto
1713                gc.autopacklimit
1714                gc.packrefs
1715                gc.pruneexpire
1716                gc.reflogexpire
1717                gc.reflogexpireunreachable
1718                gc.rerereresolved
1719                gc.rerereunresolved
1720                gitcvs.allbinary
1721                gitcvs.commitmsgannotation
1722                gitcvs.dbTableNamePrefix
1723                gitcvs.dbdriver
1724                gitcvs.dbname
1725                gitcvs.dbpass
1726                gitcvs.dbuser
1727                gitcvs.enabled
1728                gitcvs.logfile
1729                gitcvs.usecrlfattr
1730                guitool.
1731                gui.blamehistoryctx
1732                gui.commitmsgwidth
1733                gui.copyblamethreshold
1734                gui.diffcontext
1735                gui.encoding
1736                gui.fastcopyblame
1737                gui.matchtrackingbranch
1738                gui.newbranchtemplate
1739                gui.pruneduringfetch
1740                gui.spellingdictionary
1741                gui.trustmtime
1742                help.autocorrect
1743                help.browser
1744                help.format
1745                http.lowSpeedLimit
1746                http.lowSpeedTime
1747                http.maxRequests
1748                http.noEPSV
1749                http.proxy
1750                http.sslCAInfo
1751                http.sslCAPath
1752                http.sslCert
1753                http.sslKey
1754                http.sslVerify
1755                i18n.commitEncoding
1756                i18n.logOutputEncoding
1757                imap.folder
1758                imap.host
1759                imap.pass
1760                imap.port
1761                imap.preformattedHTML
1762                imap.sslverify
1763                imap.tunnel
1764                imap.user
1765                instaweb.browser
1766                instaweb.httpd
1767                instaweb.local
1768                instaweb.modulepath
1769                instaweb.port
1770                interactive.singlekey
1771                log.date
1772                log.showroot
1773                mailmap.file
1774                man.
1775                man.viewer
1776                merge.conflictstyle
1777                merge.log
1778                merge.renameLimit
1779                merge.stat
1780                merge.tool
1781                merge.verbosity
1782                mergetool.
1783                mergetool.keepBackup
1784                mergetool.prompt
1785                pack.compression
1786                pack.deltaCacheLimit
1787                pack.deltaCacheSize
1788                pack.depth
1789                pack.indexVersion
1790                pack.packSizeLimit
1791                pack.threads
1792                pack.window
1793                pack.windowMemory
1794                pager.
1795                pull.octopus
1796                pull.twohead
1797                push.default
1798                rebase.stat
1799                receive.denyCurrentBranch
1800                receive.denyDeletes
1801                receive.denyNonFastForwards
1802                receive.fsckObjects
1803                receive.unpackLimit
1804                repack.usedeltabaseoffset
1805                rerere.autoupdate
1806                rerere.enabled
1807                sendemail.aliasesfile
1808                sendemail.aliasesfiletype
1809                sendemail.bcc
1810                sendemail.cc
1811                sendemail.cccmd
1812                sendemail.chainreplyto
1813                sendemail.confirm
1814                sendemail.envelopesender
1815                sendemail.multiedit
1816                sendemail.signedoffbycc
1817                sendemail.smtpencryption
1818                sendemail.smtppass
1819                sendemail.smtpserver
1820                sendemail.smtpserverport
1821                sendemail.smtpuser
1822                sendemail.suppresscc
1823                sendemail.suppressfrom
1824                sendemail.thread
1825                sendemail.to
1826                sendemail.validate
1827                showbranch.default
1828                status.relativePaths
1829                status.showUntrackedFiles
1830                tar.umask
1831                transfer.unpackLimit
1832                url.
1833                user.email
1834                user.name
1835                user.signingkey
1836                web.browser
1837                branch. remote.
1838        "
1839}
1840
1841_git_remote ()
1842{
1843        local subcommands="add rename rm show prune update set-head"
1844        local subcommand="$(__git_find_on_cmdline "$subcommands")"
1845        if [ -z "$subcommand" ]; then
1846                __gitcomp "$subcommands"
1847                return
1848        fi
1849
1850        case "$subcommand" in
1851        rename|rm|show|prune)
1852                __gitcomp "$(__git_remotes)"
1853                ;;
1854        update)
1855                local i c='' IFS=$'\n'
1856                for i in $(git --git-dir="$(__gitdir)" config --get-regexp "remotes\..*" 2>/dev/null); do
1857                        i="${i#remotes.}"
1858                        c="$c ${i/ */}"
1859                done
1860                __gitcomp "$c"
1861                ;;
1862        *)
1863                COMPREPLY=()
1864                ;;
1865        esac
1866}
1867
1868_git_replace ()
1869{
1870        __gitcomp "$(__git_refs)"
1871}
1872
1873_git_reset ()
1874{
1875        __git_has_doubledash && return
1876
1877        local cur="${COMP_WORDS[COMP_CWORD]}"
1878        case "$cur" in
1879        --*)
1880                __gitcomp "--merge --mixed --hard --soft --patch"
1881                return
1882                ;;
1883        esac
1884        __gitcomp "$(__git_refs)"
1885}
1886
1887_git_revert ()
1888{
1889        local cur="${COMP_WORDS[COMP_CWORD]}"
1890        case "$cur" in
1891        --*)
1892                __gitcomp "--edit --mainline --no-edit --no-commit --signoff"
1893                return
1894                ;;
1895        esac
1896        __gitcomp "$(__git_refs)"
1897}
1898
1899_git_rm ()
1900{
1901        __git_has_doubledash && return
1902
1903        local cur="${COMP_WORDS[COMP_CWORD]}"
1904        case "$cur" in
1905        --*)
1906                __gitcomp "--cached --dry-run --ignore-unmatch --quiet"
1907                return
1908                ;;
1909        esac
1910        COMPREPLY=()
1911}
1912
1913_git_shortlog ()
1914{
1915        __git_has_doubledash && return
1916
1917        local cur="${COMP_WORDS[COMP_CWORD]}"
1918        case "$cur" in
1919        --*)
1920                __gitcomp "
1921                        $__git_log_common_options
1922                        $__git_log_shortlog_options
1923                        --numbered --summary
1924                        "
1925                return
1926                ;;
1927        esac
1928        __git_complete_revlist
1929}
1930
1931_git_show ()
1932{
1933        __git_has_doubledash && return
1934
1935        local cur="${COMP_WORDS[COMP_CWORD]}"
1936        case "$cur" in
1937        --pretty=*)
1938                __gitcomp "$__git_log_pretty_formats
1939                        " "" "${cur##--pretty=}"
1940                return
1941                ;;
1942        --format=*)
1943                __gitcomp "$__git_log_pretty_formats
1944                        " "" "${cur##--format=}"
1945                return
1946                ;;
1947        --*)
1948                __gitcomp "--pretty= --format= --abbrev-commit --oneline
1949                        $__git_diff_common_options
1950                        "
1951                return
1952                ;;
1953        esac
1954        __git_complete_file
1955}
1956
1957_git_show_branch ()
1958{
1959        local cur="${COMP_WORDS[COMP_CWORD]}"
1960        case "$cur" in
1961        --*)
1962                __gitcomp "
1963                        --all --remotes --topo-order --current --more=
1964                        --list --independent --merge-base --no-name
1965                        --color --no-color
1966                        --sha1-name --sparse --topics --reflog
1967                        "
1968                return
1969                ;;
1970        esac
1971        __git_complete_revlist
1972}
1973
1974_git_stash ()
1975{
1976        local cur="${COMP_WORDS[COMP_CWORD]}"
1977        local save_opts='--keep-index --no-keep-index --quiet --patch'
1978        local subcommands='save list show apply clear drop pop create branch'
1979        local subcommand="$(__git_find_on_cmdline "$subcommands")"
1980        if [ -z "$subcommand" ]; then
1981                case "$cur" in
1982                --*)
1983                        __gitcomp "$save_opts"
1984                        ;;
1985                *)
1986                        if [ -z "$(__git_find_on_cmdline "$save_opts")" ]; then
1987                                __gitcomp "$subcommands"
1988                        else
1989                                COMPREPLY=()
1990                        fi
1991                        ;;
1992                esac
1993        else
1994                case "$subcommand,$cur" in
1995                save,--*)
1996                        __gitcomp "$save_opts"
1997                        ;;
1998                apply,--*|pop,--*)
1999                        __gitcomp "--index --quiet"
2000                        ;;
2001                show,--*|drop,--*|branch,--*)
2002                        COMPREPLY=()
2003                        ;;
2004                show,*|apply,*|drop,*|pop,*|branch,*)
2005                        __gitcomp "$(git --git-dir="$(__gitdir)" stash list \
2006                                        | sed -n -e 's/:.*//p')"
2007                        ;;
2008                *)
2009                        COMPREPLY=()
2010                        ;;
2011                esac
2012        fi
2013}
2014
2015_git_submodule ()
2016{
2017        __git_has_doubledash && return
2018
2019        local subcommands="add status init update summary foreach sync"
2020        if [ -z "$(__git_find_on_cmdline "$subcommands")" ]; then
2021                local cur="${COMP_WORDS[COMP_CWORD]}"
2022                case "$cur" in
2023                --*)
2024                        __gitcomp "--quiet --cached"
2025                        ;;
2026                *)
2027                        __gitcomp "$subcommands"
2028                        ;;
2029                esac
2030                return
2031        fi
2032}
2033
2034_git_svn ()
2035{
2036        local subcommands="
2037                init fetch clone rebase dcommit log find-rev
2038                set-tree commit-diff info create-ignore propget
2039                proplist show-ignore show-externals branch tag blame
2040                migrate mkdirs reset gc
2041                "
2042        local subcommand="$(__git_find_on_cmdline "$subcommands")"
2043        if [ -z "$subcommand" ]; then
2044                __gitcomp "$subcommands"
2045        else
2046                local remote_opts="--username= --config-dir= --no-auth-cache"
2047                local fc_opts="
2048                        --follow-parent --authors-file= --repack=
2049                        --no-metadata --use-svm-props --use-svnsync-props
2050                        --log-window-size= --no-checkout --quiet
2051                        --repack-flags --use-log-author --localtime
2052                        --ignore-paths= $remote_opts
2053                        "
2054                local init_opts="
2055                        --template= --shared= --trunk= --tags=
2056                        --branches= --stdlayout --minimize-url
2057                        --no-metadata --use-svm-props --use-svnsync-props
2058                        --rewrite-root= --prefix= --use-log-author
2059                        --add-author-from $remote_opts
2060                        "
2061                local cmt_opts="
2062                        --edit --rmdir --find-copies-harder --copy-similarity=
2063                        "
2064
2065                local cur="${COMP_WORDS[COMP_CWORD]}"
2066                case "$subcommand,$cur" in
2067                fetch,--*)
2068                        __gitcomp "--revision= --fetch-all $fc_opts"
2069                        ;;
2070                clone,--*)
2071                        __gitcomp "--revision= $fc_opts $init_opts"
2072                        ;;
2073                init,--*)
2074                        __gitcomp "$init_opts"
2075                        ;;
2076                dcommit,--*)
2077                        __gitcomp "
2078                                --merge --strategy= --verbose --dry-run
2079                                --fetch-all --no-rebase --commit-url
2080                                --revision $cmt_opts $fc_opts
2081                                "
2082                        ;;
2083                set-tree,--*)
2084                        __gitcomp "--stdin $cmt_opts $fc_opts"
2085                        ;;
2086                create-ignore,--*|propget,--*|proplist,--*|show-ignore,--*|\
2087                show-externals,--*|mkdirs,--*)
2088                        __gitcomp "--revision="
2089                        ;;
2090                log,--*)
2091                        __gitcomp "
2092                                --limit= --revision= --verbose --incremental
2093                                --oneline --show-commit --non-recursive
2094                                --authors-file= --color
2095                                "
2096                        ;;
2097                rebase,--*)
2098                        __gitcomp "
2099                                --merge --verbose --strategy= --local
2100                                --fetch-all --dry-run $fc_opts
2101                                "
2102                        ;;
2103                commit-diff,--*)
2104                        __gitcomp "--message= --file= --revision= $cmt_opts"
2105                        ;;
2106                info,--*)
2107                        __gitcomp "--url"
2108                        ;;
2109                branch,--*)
2110                        __gitcomp "--dry-run --message --tag"
2111                        ;;
2112                tag,--*)
2113                        __gitcomp "--dry-run --message"
2114                        ;;
2115                blame,--*)
2116                        __gitcomp "--git-format"
2117                        ;;
2118                migrate,--*)
2119                        __gitcomp "
2120                                --config-dir= --ignore-paths= --minimize
2121                                --no-auth-cache --username=
2122                                "
2123                        ;;
2124                reset,--*)
2125                        __gitcomp "--revision= --parent"
2126                        ;;
2127                *)
2128                        COMPREPLY=()
2129                        ;;
2130                esac
2131        fi
2132}
2133
2134_git_tag ()
2135{
2136        local i c=1 f=0
2137        while [ $c -lt $COMP_CWORD ]; do
2138                i="${COMP_WORDS[c]}"
2139                case "$i" in
2140                -d|-v)
2141                        __gitcomp "$(__git_tags)"
2142                        return
2143                        ;;
2144                -f)
2145                        f=1
2146                        ;;
2147                esac
2148                c=$((++c))
2149        done
2150
2151        case "${COMP_WORDS[COMP_CWORD-1]}" in
2152        -m|-F)
2153                COMPREPLY=()
2154                ;;
2155        -*|tag)
2156                if [ $f = 1 ]; then
2157                        __gitcomp "$(__git_tags)"
2158                else
2159                        COMPREPLY=()
2160                fi
2161                ;;
2162        *)
2163                __gitcomp "$(__git_refs)"
2164                ;;
2165        esac
2166}
2167
2168_git ()
2169{
2170        local i c=1 command __git_dir
2171
2172        while [ $c -lt $COMP_CWORD ]; do
2173                i="${COMP_WORDS[c]}"
2174                case "$i" in
2175                --git-dir=*) __git_dir="${i#--git-dir=}" ;;
2176                --bare)      __git_dir="." ;;
2177                --version|-p|--paginate) ;;
2178                --help) command="help"; break ;;
2179                *) command="$i"; break ;;
2180                esac
2181                c=$((++c))
2182        done
2183
2184        if [ -z "$command" ]; then
2185                case "${COMP_WORDS[COMP_CWORD]}" in
2186                --*)   __gitcomp "
2187                        --paginate
2188                        --no-pager
2189                        --git-dir=
2190                        --bare
2191                        --version
2192                        --exec-path
2193                        --html-path
2194                        --work-tree=
2195                        --help
2196                        "
2197                        ;;
2198                *)     __git_compute_porcelain_commands
2199                       __gitcomp "$__git_porcelain_commands $(__git_aliases)" ;;
2200                esac
2201                return
2202        fi
2203
2204        local expansion=$(__git_aliased_command "$command")
2205        [ "$expansion" ] && command="$expansion"
2206
2207        case "$command" in
2208        am)          _git_am ;;
2209        add)         _git_add ;;
2210        apply)       _git_apply ;;
2211        archive)     _git_archive ;;
2212        bisect)      _git_bisect ;;
2213        bundle)      _git_bundle ;;
2214        branch)      _git_branch ;;
2215        checkout)    _git_checkout ;;
2216        cherry)      _git_cherry ;;
2217        cherry-pick) _git_cherry_pick ;;
2218        clean)       _git_clean ;;
2219        clone)       _git_clone ;;
2220        commit)      _git_commit ;;
2221        config)      _git_config ;;
2222        describe)    _git_describe ;;
2223        diff)        _git_diff ;;
2224        difftool)    _git_difftool ;;
2225        fetch)       _git_fetch ;;
2226        format-patch) _git_format_patch ;;
2227        fsck)        _git_fsck ;;
2228        gc)          _git_gc ;;
2229        grep)        _git_grep ;;
2230        help)        _git_help ;;
2231        init)        _git_init ;;
2232        log)         _git_log ;;
2233        ls-files)    _git_ls_files ;;
2234        ls-remote)   _git_ls_remote ;;
2235        ls-tree)     _git_ls_tree ;;
2236        merge)       _git_merge;;
2237        mergetool)   _git_mergetool;;
2238        merge-base)  _git_merge_base ;;
2239        mv)          _git_mv ;;
2240        name-rev)    _git_name_rev ;;
2241        notes)       _git_notes ;;
2242        pull)        _git_pull ;;
2243        push)        _git_push ;;
2244        rebase)      _git_rebase ;;
2245        remote)      _git_remote ;;
2246        replace)     _git_replace ;;
2247        reset)       _git_reset ;;
2248        revert)      _git_revert ;;
2249        rm)          _git_rm ;;
2250        send-email)  _git_send_email ;;
2251        shortlog)    _git_shortlog ;;
2252        show)        _git_show ;;
2253        show-branch) _git_show_branch ;;
2254        stash)       _git_stash ;;
2255        stage)       _git_add ;;
2256        submodule)   _git_submodule ;;
2257        svn)         _git_svn ;;
2258        tag)         _git_tag ;;
2259        whatchanged) _git_log ;;
2260        *)           COMPREPLY=() ;;
2261        esac
2262}
2263
2264_gitk ()
2265{
2266        __git_has_doubledash && return
2267
2268        local cur="${COMP_WORDS[COMP_CWORD]}"
2269        local g="$(__gitdir)"
2270        local merge=""
2271        if [ -f "$g/MERGE_HEAD" ]; then
2272                merge="--merge"
2273        fi
2274        case "$cur" in
2275        --*)
2276                __gitcomp "
2277                        $__git_log_common_options
2278                        $__git_log_gitk_options
2279                        $merge
2280                        "
2281                return
2282                ;;
2283        esac
2284        __git_complete_revlist
2285}
2286
2287complete -o bashdefault -o default -o nospace -F _git git 2>/dev/null \
2288        || complete -o default -o nospace -F _git git
2289complete -o bashdefault -o default -o nospace -F _gitk gitk 2>/dev/null \
2290        || complete -o default -o nospace -F _gitk gitk
2291
2292# The following are necessary only for Cygwin, and only are needed
2293# when the user has tab-completed the executable name and consequently
2294# included the '.exe' suffix.
2295#
2296if [ Cygwin = "$(uname -o 2>/dev/null)" ]; then
2297complete -o bashdefault -o default -o nospace -F _git git.exe 2>/dev/null \
2298        || complete -o default -o nospace -F _git git.exe
2299fi