contrib / completion / git-completion.bashon commit completion: factor out untracked file modes into a variable (21d2a9e)
   1# bash/zsh completion support for core Git.
   2#
   3# Copyright (C) 2006,2007 Shawn O. Pearce <spearce@spearce.org>
   4# Conceptually based on gitcompletion (http://gitweb.hawaga.org.uk/).
   5# Distributed under the GNU General Public License, version 2.0.
   6#
   7# The contained completion routines provide support for completing:
   8#
   9#    *) local and remote branch names
  10#    *) local and remote tag names
  11#    *) .git/remotes file names
  12#    *) git 'subcommands'
  13#    *) git email aliases for git-send-email
  14#    *) tree paths within 'ref:path/to/file' expressions
  15#    *) file paths within current working directory and index
  16#    *) common --long-options
  17#
  18# To use these routines:
  19#
  20#    1) Copy this file to somewhere (e.g. ~/.git-completion.bash).
  21#    2) Add the following line to your .bashrc/.zshrc:
  22#        source ~/.git-completion.bash
  23#    3) Consider changing your PS1 to also show the current branch,
  24#       see git-prompt.sh for details.
  25#
  26# If you use complex aliases of form '!f() { ... }; f', you can use the null
  27# command ':' as the first command in the function body to declare the desired
  28# completion style.  For example '!f() { : git commit ; ... }; f' will
  29# tell the completion to use commit completion.  This also works with aliases
  30# of form "!sh -c '...'".  For example, "!sh -c ': git commit ; ... '".
  31
  32case "$COMP_WORDBREAKS" in
  33*:*) : great ;;
  34*)   COMP_WORDBREAKS="$COMP_WORDBREAKS:"
  35esac
  36
  37# __gitdir accepts 0 or 1 arguments (i.e., location)
  38# returns location of .git repo
  39__gitdir ()
  40{
  41        if [ -z "${1-}" ]; then
  42                if [ -n "${__git_dir-}" ]; then
  43                        echo "$__git_dir"
  44                elif [ -n "${GIT_DIR-}" ]; then
  45                        test -d "${GIT_DIR-}" || return 1
  46                        echo "$GIT_DIR"
  47                elif [ -d .git ]; then
  48                        echo .git
  49                else
  50                        git rev-parse --git-dir 2>/dev/null
  51                fi
  52        elif [ -d "$1/.git" ]; then
  53                echo "$1/.git"
  54        else
  55                echo "$1"
  56        fi
  57}
  58
  59# The following function is based on code from:
  60#
  61#   bash_completion - programmable completion functions for bash 3.2+
  62#
  63#   Copyright © 2006-2008, Ian Macdonald <ian@caliban.org>
  64#             © 2009-2010, Bash Completion Maintainers
  65#                     <bash-completion-devel@lists.alioth.debian.org>
  66#
  67#   This program is free software; you can redistribute it and/or modify
  68#   it under the terms of the GNU General Public License as published by
  69#   the Free Software Foundation; either version 2, or (at your option)
  70#   any later version.
  71#
  72#   This program is distributed in the hope that it will be useful,
  73#   but WITHOUT ANY WARRANTY; without even the implied warranty of
  74#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  75#   GNU General Public License for more details.
  76#
  77#   You should have received a copy of the GNU General Public License
  78#   along with this program; if not, write to the Free Software Foundation,
  79#   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  80#
  81#   The latest version of this software can be obtained here:
  82#
  83#   http://bash-completion.alioth.debian.org/
  84#
  85#   RELEASE: 2.x
  86
  87# This function can be used to access a tokenized list of words
  88# on the command line:
  89#
  90#       __git_reassemble_comp_words_by_ref '=:'
  91#       if test "${words_[cword_-1]}" = -w
  92#       then
  93#               ...
  94#       fi
  95#
  96# The argument should be a collection of characters from the list of
  97# word completion separators (COMP_WORDBREAKS) to treat as ordinary
  98# characters.
  99#
 100# This is roughly equivalent to going back in time and setting
 101# COMP_WORDBREAKS to exclude those characters.  The intent is to
 102# make option types like --date=<type> and <rev>:<path> easy to
 103# recognize by treating each shell word as a single token.
 104#
 105# It is best not to set COMP_WORDBREAKS directly because the value is
 106# shared with other completion scripts.  By the time the completion
 107# function gets called, COMP_WORDS has already been populated so local
 108# changes to COMP_WORDBREAKS have no effect.
 109#
 110# Output: words_, cword_, cur_.
 111
 112__git_reassemble_comp_words_by_ref()
 113{
 114        local exclude i j first
 115        # Which word separators to exclude?
 116        exclude="${1//[^$COMP_WORDBREAKS]}"
 117        cword_=$COMP_CWORD
 118        if [ -z "$exclude" ]; then
 119                words_=("${COMP_WORDS[@]}")
 120                return
 121        fi
 122        # List of word completion separators has shrunk;
 123        # re-assemble words to complete.
 124        for ((i=0, j=0; i < ${#COMP_WORDS[@]}; i++, j++)); do
 125                # Append each nonempty word consisting of just
 126                # word separator characters to the current word.
 127                first=t
 128                while
 129                        [ $i -gt 0 ] &&
 130                        [ -n "${COMP_WORDS[$i]}" ] &&
 131                        # word consists of excluded word separators
 132                        [ "${COMP_WORDS[$i]//[^$exclude]}" = "${COMP_WORDS[$i]}" ]
 133                do
 134                        # Attach to the previous token,
 135                        # unless the previous token is the command name.
 136                        if [ $j -ge 2 ] && [ -n "$first" ]; then
 137                                ((j--))
 138                        fi
 139                        first=
 140                        words_[$j]=${words_[j]}${COMP_WORDS[i]}
 141                        if [ $i = $COMP_CWORD ]; then
 142                                cword_=$j
 143                        fi
 144                        if (($i < ${#COMP_WORDS[@]} - 1)); then
 145                                ((i++))
 146                        else
 147                                # Done.
 148                                return
 149                        fi
 150                done
 151                words_[$j]=${words_[j]}${COMP_WORDS[i]}
 152                if [ $i = $COMP_CWORD ]; then
 153                        cword_=$j
 154                fi
 155        done
 156}
 157
 158if ! type _get_comp_words_by_ref >/dev/null 2>&1; then
 159_get_comp_words_by_ref ()
 160{
 161        local exclude cur_ words_ cword_
 162        if [ "$1" = "-n" ]; then
 163                exclude=$2
 164                shift 2
 165        fi
 166        __git_reassemble_comp_words_by_ref "$exclude"
 167        cur_=${words_[cword_]}
 168        while [ $# -gt 0 ]; do
 169                case "$1" in
 170                cur)
 171                        cur=$cur_
 172                        ;;
 173                prev)
 174                        prev=${words_[$cword_-1]}
 175                        ;;
 176                words)
 177                        words=("${words_[@]}")
 178                        ;;
 179                cword)
 180                        cword=$cword_
 181                        ;;
 182                esac
 183                shift
 184        done
 185}
 186fi
 187
 188__gitcompappend ()
 189{
 190        local x i=${#COMPREPLY[@]}
 191        for x in $1; do
 192                if [[ "$x" == "$3"* ]]; then
 193                        COMPREPLY[i++]="$2$x$4"
 194                fi
 195        done
 196}
 197
 198__gitcompadd ()
 199{
 200        COMPREPLY=()
 201        __gitcompappend "$@"
 202}
 203
 204# Generates completion reply, appending a space to possible completion words,
 205# if necessary.
 206# It accepts 1 to 4 arguments:
 207# 1: List of possible completion words.
 208# 2: A prefix to be added to each possible completion word (optional).
 209# 3: Generate possible completion matches for this word (optional).
 210# 4: A suffix to be appended to each possible completion word (optional).
 211__gitcomp ()
 212{
 213        local cur_="${3-$cur}"
 214
 215        case "$cur_" in
 216        --*=)
 217                ;;
 218        *)
 219                local c i=0 IFS=$' \t\n'
 220                for c in $1; do
 221                        c="$c${4-}"
 222                        if [[ $c == "$cur_"* ]]; then
 223                                case $c in
 224                                --*=*|*.) ;;
 225                                *) c="$c " ;;
 226                                esac
 227                                COMPREPLY[i++]="${2-}$c"
 228                        fi
 229                done
 230                ;;
 231        esac
 232}
 233
 234# Variation of __gitcomp_nl () that appends to the existing list of
 235# completion candidates, COMPREPLY.
 236__gitcomp_nl_append ()
 237{
 238        local IFS=$'\n'
 239        __gitcompappend "$1" "${2-}" "${3-$cur}" "${4- }"
 240}
 241
 242# Generates completion reply from newline-separated possible completion words
 243# by appending a space to all of them.
 244# It accepts 1 to 4 arguments:
 245# 1: List of possible completion words, separated by a single newline.
 246# 2: A prefix to be added to each possible completion word (optional).
 247# 3: Generate possible completion matches for this word (optional).
 248# 4: A suffix to be appended to each possible completion word instead of
 249#    the default space (optional).  If specified but empty, nothing is
 250#    appended.
 251__gitcomp_nl ()
 252{
 253        COMPREPLY=()
 254        __gitcomp_nl_append "$@"
 255}
 256
 257# Generates completion reply with compgen from newline-separated possible
 258# completion filenames.
 259# It accepts 1 to 3 arguments:
 260# 1: List of possible completion filenames, separated by a single newline.
 261# 2: A directory prefix to be added to each possible completion filename
 262#    (optional).
 263# 3: Generate possible completion matches for this word (optional).
 264__gitcomp_file ()
 265{
 266        local IFS=$'\n'
 267
 268        # XXX does not work when the directory prefix contains a tilde,
 269        # since tilde expansion is not applied.
 270        # This means that COMPREPLY will be empty and Bash default
 271        # completion will be used.
 272        __gitcompadd "$1" "${2-}" "${3-$cur}" ""
 273
 274        # use a hack to enable file mode in bash < 4
 275        compopt -o filenames +o nospace 2>/dev/null ||
 276        compgen -f /non-existing-dir/ > /dev/null
 277}
 278
 279# Execute 'git ls-files', unless the --committable option is specified, in
 280# which case it runs 'git diff-index' to find out the files that can be
 281# committed.  It return paths relative to the directory specified in the first
 282# argument, and using the options specified in the second argument.
 283__git_ls_files_helper ()
 284{
 285        if [ "$2" == "--committable" ]; then
 286                git -C "$1" diff-index --name-only --relative HEAD
 287        else
 288                # NOTE: $2 is not quoted in order to support multiple options
 289                git -C "$1" ls-files --exclude-standard $2
 290        fi 2>/dev/null
 291}
 292
 293
 294# __git_index_files accepts 1 or 2 arguments:
 295# 1: Options to pass to ls-files (required).
 296# 2: A directory path (optional).
 297#    If provided, only files within the specified directory are listed.
 298#    Sub directories are never recursed.  Path must have a trailing
 299#    slash.
 300__git_index_files ()
 301{
 302        local dir="$(__gitdir)" root="${2-.}" file
 303
 304        if [ -d "$dir" ]; then
 305                __git_ls_files_helper "$root" "$1" |
 306                while read -r file; do
 307                        case "$file" in
 308                        ?*/*) echo "${file%%/*}" ;;
 309                        *) echo "$file" ;;
 310                        esac
 311                done | sort | uniq
 312        fi
 313}
 314
 315__git_heads ()
 316{
 317        local dir="$(__gitdir)"
 318        if [ -d "$dir" ]; then
 319                git --git-dir="$dir" for-each-ref --format='%(refname:short)' \
 320                        refs/heads
 321                return
 322        fi
 323}
 324
 325__git_tags ()
 326{
 327        local dir="$(__gitdir)"
 328        if [ -d "$dir" ]; then
 329                git --git-dir="$dir" for-each-ref --format='%(refname:short)' \
 330                        refs/tags
 331                return
 332        fi
 333}
 334
 335# __git_refs accepts 0, 1 (to pass to __gitdir), or 2 arguments
 336# presence of 2nd argument means use the guess heuristic employed
 337# by checkout for tracking branches
 338__git_refs ()
 339{
 340        local i hash dir="$(__gitdir "${1-}")" track="${2-}"
 341        local format refs
 342        if [ -d "$dir" ]; then
 343                case "$cur" in
 344                refs|refs/*)
 345                        format="refname"
 346                        refs="${cur%/*}"
 347                        track=""
 348                        ;;
 349                *)
 350                        for i in HEAD FETCH_HEAD ORIG_HEAD MERGE_HEAD; do
 351                                if [ -e "$dir/$i" ]; then echo $i; fi
 352                        done
 353                        format="refname:short"
 354                        refs="refs/tags refs/heads refs/remotes"
 355                        ;;
 356                esac
 357                git --git-dir="$dir" for-each-ref --format="%($format)" \
 358                        $refs
 359                if [ -n "$track" ]; then
 360                        # employ the heuristic used by git checkout
 361                        # Try to find a remote branch that matches the completion word
 362                        # but only output if the branch name is unique
 363                        local ref entry
 364                        git --git-dir="$dir" for-each-ref --shell --format="ref=%(refname:short)" \
 365                                "refs/remotes/" | \
 366                        while read -r entry; do
 367                                eval "$entry"
 368                                ref="${ref#*/}"
 369                                if [[ "$ref" == "$cur"* ]]; then
 370                                        echo "$ref"
 371                                fi
 372                        done | sort | uniq -u
 373                fi
 374                return
 375        fi
 376        case "$cur" in
 377        refs|refs/*)
 378                git ls-remote "$dir" "$cur*" 2>/dev/null | \
 379                while read -r hash i; do
 380                        case "$i" in
 381                        *^{}) ;;
 382                        *) echo "$i" ;;
 383                        esac
 384                done
 385                ;;
 386        *)
 387                echo "HEAD"
 388                git for-each-ref --format="%(refname:short)" -- \
 389                        "refs/remotes/$dir/" 2>/dev/null | sed -e "s#^$dir/##"
 390                ;;
 391        esac
 392}
 393
 394# __git_refs2 requires 1 argument (to pass to __git_refs)
 395__git_refs2 ()
 396{
 397        local i
 398        for i in $(__git_refs "$1"); do
 399                echo "$i:$i"
 400        done
 401}
 402
 403# __git_refs_remotes requires 1 argument (to pass to ls-remote)
 404__git_refs_remotes ()
 405{
 406        local i hash
 407        git ls-remote "$1" 'refs/heads/*' 2>/dev/null | \
 408        while read -r hash i; do
 409                echo "$i:refs/remotes/$1/${i#refs/heads/}"
 410        done
 411}
 412
 413__git_remotes ()
 414{
 415        local d="$(__gitdir)"
 416        test -d "$d/remotes" && ls -1 "$d/remotes"
 417        git --git-dir="$d" remote
 418}
 419
 420__git_list_merge_strategies ()
 421{
 422        git merge -s help 2>&1 |
 423        sed -n -e '/[Aa]vailable strategies are: /,/^$/{
 424                s/\.$//
 425                s/.*://
 426                s/^[    ]*//
 427                s/[     ]*$//
 428                p
 429        }'
 430}
 431
 432__git_merge_strategies=
 433# 'git merge -s help' (and thus detection of the merge strategy
 434# list) fails, unfortunately, if run outside of any git working
 435# tree.  __git_merge_strategies is set to the empty string in
 436# that case, and the detection will be repeated the next time it
 437# is needed.
 438__git_compute_merge_strategies ()
 439{
 440        test -n "$__git_merge_strategies" ||
 441        __git_merge_strategies=$(__git_list_merge_strategies)
 442}
 443
 444__git_complete_revlist_file ()
 445{
 446        local pfx ls ref cur_="$cur"
 447        case "$cur_" in
 448        *..?*:*)
 449                return
 450                ;;
 451        ?*:*)
 452                ref="${cur_%%:*}"
 453                cur_="${cur_#*:}"
 454                case "$cur_" in
 455                ?*/*)
 456                        pfx="${cur_%/*}"
 457                        cur_="${cur_##*/}"
 458                        ls="$ref:$pfx"
 459                        pfx="$pfx/"
 460                        ;;
 461                *)
 462                        ls="$ref"
 463                        ;;
 464                esac
 465
 466                case "$COMP_WORDBREAKS" in
 467                *:*) : great ;;
 468                *)   pfx="$ref:$pfx" ;;
 469                esac
 470
 471                __gitcomp_nl "$(git --git-dir="$(__gitdir)" ls-tree "$ls" 2>/dev/null \
 472                                | sed '/^100... blob /{
 473                                           s,^.*        ,,
 474                                           s,$, ,
 475                                       }
 476                                       /^120000 blob /{
 477                                           s,^.*        ,,
 478                                           s,$, ,
 479                                       }
 480                                       /^040000 tree /{
 481                                           s,^.*        ,,
 482                                           s,$,/,
 483                                       }
 484                                       s/^.*    //')" \
 485                        "$pfx" "$cur_" ""
 486                ;;
 487        *...*)
 488                pfx="${cur_%...*}..."
 489                cur_="${cur_#*...}"
 490                __gitcomp_nl "$(__git_refs)" "$pfx" "$cur_"
 491                ;;
 492        *..*)
 493                pfx="${cur_%..*}.."
 494                cur_="${cur_#*..}"
 495                __gitcomp_nl "$(__git_refs)" "$pfx" "$cur_"
 496                ;;
 497        *)
 498                __gitcomp_nl "$(__git_refs)"
 499                ;;
 500        esac
 501}
 502
 503
 504# __git_complete_index_file requires 1 argument:
 505# 1: the options to pass to ls-file
 506#
 507# The exception is --committable, which finds the files appropriate commit.
 508__git_complete_index_file ()
 509{
 510        local pfx="" cur_="$cur"
 511
 512        case "$cur_" in
 513        ?*/*)
 514                pfx="${cur_%/*}"
 515                cur_="${cur_##*/}"
 516                pfx="${pfx}/"
 517                ;;
 518        esac
 519
 520        __gitcomp_file "$(__git_index_files "$1" ${pfx:+"$pfx"})" "$pfx" "$cur_"
 521}
 522
 523__git_complete_file ()
 524{
 525        __git_complete_revlist_file
 526}
 527
 528__git_complete_revlist ()
 529{
 530        __git_complete_revlist_file
 531}
 532
 533__git_complete_remote_or_refspec ()
 534{
 535        local cur_="$cur" cmd="${words[1]}"
 536        local i c=2 remote="" pfx="" lhs=1 no_complete_refspec=0
 537        if [ "$cmd" = "remote" ]; then
 538                ((c++))
 539        fi
 540        while [ $c -lt $cword ]; do
 541                i="${words[c]}"
 542                case "$i" in
 543                --mirror) [ "$cmd" = "push" ] && no_complete_refspec=1 ;;
 544                --all)
 545                        case "$cmd" in
 546                        push) no_complete_refspec=1 ;;
 547                        fetch)
 548                                return
 549                                ;;
 550                        *) ;;
 551                        esac
 552                        ;;
 553                -*) ;;
 554                *) remote="$i"; break ;;
 555                esac
 556                ((c++))
 557        done
 558        if [ -z "$remote" ]; then
 559                __gitcomp_nl "$(__git_remotes)"
 560                return
 561        fi
 562        if [ $no_complete_refspec = 1 ]; then
 563                return
 564        fi
 565        [ "$remote" = "." ] && remote=
 566        case "$cur_" in
 567        *:*)
 568                case "$COMP_WORDBREAKS" in
 569                *:*) : great ;;
 570                *)   pfx="${cur_%%:*}:" ;;
 571                esac
 572                cur_="${cur_#*:}"
 573                lhs=0
 574                ;;
 575        +*)
 576                pfx="+"
 577                cur_="${cur_#+}"
 578                ;;
 579        esac
 580        case "$cmd" in
 581        fetch)
 582                if [ $lhs = 1 ]; then
 583                        __gitcomp_nl "$(__git_refs2 "$remote")" "$pfx" "$cur_"
 584                else
 585                        __gitcomp_nl "$(__git_refs)" "$pfx" "$cur_"
 586                fi
 587                ;;
 588        pull|remote)
 589                if [ $lhs = 1 ]; then
 590                        __gitcomp_nl "$(__git_refs "$remote")" "$pfx" "$cur_"
 591                else
 592                        __gitcomp_nl "$(__git_refs)" "$pfx" "$cur_"
 593                fi
 594                ;;
 595        push)
 596                if [ $lhs = 1 ]; then
 597                        __gitcomp_nl "$(__git_refs)" "$pfx" "$cur_"
 598                else
 599                        __gitcomp_nl "$(__git_refs "$remote")" "$pfx" "$cur_"
 600                fi
 601                ;;
 602        esac
 603}
 604
 605__git_complete_strategy ()
 606{
 607        __git_compute_merge_strategies
 608        case "$prev" in
 609        -s|--strategy)
 610                __gitcomp "$__git_merge_strategies"
 611                return 0
 612        esac
 613        case "$cur" in
 614        --strategy=*)
 615                __gitcomp "$__git_merge_strategies" "" "${cur##--strategy=}"
 616                return 0
 617                ;;
 618        esac
 619        return 1
 620}
 621
 622__git_commands () {
 623        if test -n "${GIT_TESTING_COMMAND_COMPLETION:-}"
 624        then
 625                printf "%s" "${GIT_TESTING_COMMAND_COMPLETION}"
 626        else
 627                git help -a|egrep '^  [a-zA-Z0-9]'
 628        fi
 629}
 630
 631__git_list_all_commands ()
 632{
 633        local i IFS=" "$'\n'
 634        for i in $(__git_commands)
 635        do
 636                case $i in
 637                *--*)             : helper pattern;;
 638                *) echo $i;;
 639                esac
 640        done
 641}
 642
 643__git_all_commands=
 644__git_compute_all_commands ()
 645{
 646        test -n "$__git_all_commands" ||
 647        __git_all_commands=$(__git_list_all_commands)
 648}
 649
 650__git_list_porcelain_commands ()
 651{
 652        local i IFS=" "$'\n'
 653        __git_compute_all_commands
 654        for i in $__git_all_commands
 655        do
 656                case $i in
 657                *--*)             : helper pattern;;
 658                applymbox)        : ask gittus;;
 659                applypatch)       : ask gittus;;
 660                archimport)       : import;;
 661                cat-file)         : plumbing;;
 662                check-attr)       : plumbing;;
 663                check-ignore)     : plumbing;;
 664                check-mailmap)    : plumbing;;
 665                check-ref-format) : plumbing;;
 666                checkout-index)   : plumbing;;
 667                column)           : internal helper;;
 668                commit-tree)      : plumbing;;
 669                count-objects)    : infrequent;;
 670                credential)       : credentials;;
 671                credential-*)     : credentials helper;;
 672                cvsexportcommit)  : export;;
 673                cvsimport)        : import;;
 674                cvsserver)        : daemon;;
 675                daemon)           : daemon;;
 676                diff-files)       : plumbing;;
 677                diff-index)       : plumbing;;
 678                diff-tree)        : plumbing;;
 679                fast-import)      : import;;
 680                fast-export)      : export;;
 681                fsck-objects)     : plumbing;;
 682                fetch-pack)       : plumbing;;
 683                fmt-merge-msg)    : plumbing;;
 684                for-each-ref)     : plumbing;;
 685                hash-object)      : plumbing;;
 686                http-*)           : transport;;
 687                index-pack)       : plumbing;;
 688                init-db)          : deprecated;;
 689                local-fetch)      : plumbing;;
 690                ls-files)         : plumbing;;
 691                ls-remote)        : plumbing;;
 692                ls-tree)          : plumbing;;
 693                mailinfo)         : plumbing;;
 694                mailsplit)        : plumbing;;
 695                merge-*)          : plumbing;;
 696                mktree)           : plumbing;;
 697                mktag)            : plumbing;;
 698                pack-objects)     : plumbing;;
 699                pack-redundant)   : plumbing;;
 700                pack-refs)        : plumbing;;
 701                parse-remote)     : plumbing;;
 702                patch-id)         : plumbing;;
 703                prune)            : plumbing;;
 704                prune-packed)     : plumbing;;
 705                quiltimport)      : import;;
 706                read-tree)        : plumbing;;
 707                receive-pack)     : plumbing;;
 708                remote-*)         : transport;;
 709                rerere)           : plumbing;;
 710                rev-list)         : plumbing;;
 711                rev-parse)        : plumbing;;
 712                runstatus)        : plumbing;;
 713                sh-setup)         : internal;;
 714                shell)            : daemon;;
 715                show-ref)         : plumbing;;
 716                send-pack)        : plumbing;;
 717                show-index)       : plumbing;;
 718                ssh-*)            : transport;;
 719                stripspace)       : plumbing;;
 720                symbolic-ref)     : plumbing;;
 721                unpack-file)      : plumbing;;
 722                unpack-objects)   : plumbing;;
 723                update-index)     : plumbing;;
 724                update-ref)       : plumbing;;
 725                update-server-info) : daemon;;
 726                upload-archive)   : plumbing;;
 727                upload-pack)      : plumbing;;
 728                write-tree)       : plumbing;;
 729                var)              : infrequent;;
 730                verify-pack)      : infrequent;;
 731                verify-tag)       : plumbing;;
 732                *) echo $i;;
 733                esac
 734        done
 735}
 736
 737__git_porcelain_commands=
 738__git_compute_porcelain_commands ()
 739{
 740        test -n "$__git_porcelain_commands" ||
 741        __git_porcelain_commands=$(__git_list_porcelain_commands)
 742}
 743
 744# Lists all set config variables starting with the given section prefix,
 745# with the prefix removed.
 746__git_get_config_variables ()
 747{
 748        local section="$1" i IFS=$'\n'
 749        for i in $(git --git-dir="$(__gitdir)" config --name-only --get-regexp "^$section\..*" 2>/dev/null); do
 750                echo "${i#$section.}"
 751        done
 752}
 753
 754__git_pretty_aliases ()
 755{
 756        __git_get_config_variables "pretty"
 757}
 758
 759__git_aliases ()
 760{
 761        __git_get_config_variables "alias"
 762}
 763
 764# __git_aliased_command requires 1 argument
 765__git_aliased_command ()
 766{
 767        local word cmdline=$(git --git-dir="$(__gitdir)" \
 768                config --get "alias.$1")
 769        for word in $cmdline; do
 770                case "$word" in
 771                \!gitk|gitk)
 772                        echo "gitk"
 773                        return
 774                        ;;
 775                \!*)    : shell command alias ;;
 776                -*)     : option ;;
 777                *=*)    : setting env ;;
 778                git)    : git itself ;;
 779                \(\))   : skip parens of shell function definition ;;
 780                {)      : skip start of shell helper function ;;
 781                :)      : skip null command ;;
 782                \'*)    : skip opening quote after sh -c ;;
 783                *)
 784                        echo "$word"
 785                        return
 786                esac
 787        done
 788}
 789
 790# __git_find_on_cmdline requires 1 argument
 791__git_find_on_cmdline ()
 792{
 793        local word subcommand c=1
 794        while [ $c -lt $cword ]; do
 795                word="${words[c]}"
 796                for subcommand in $1; do
 797                        if [ "$subcommand" = "$word" ]; then
 798                                echo "$subcommand"
 799                                return
 800                        fi
 801                done
 802                ((c++))
 803        done
 804}
 805
 806__git_has_doubledash ()
 807{
 808        local c=1
 809        while [ $c -lt $cword ]; do
 810                if [ "--" = "${words[c]}" ]; then
 811                        return 0
 812                fi
 813                ((c++))
 814        done
 815        return 1
 816}
 817
 818# Try to count non option arguments passed on the command line for the
 819# specified git command.
 820# When options are used, it is necessary to use the special -- option to
 821# tell the implementation were non option arguments begin.
 822# XXX this can not be improved, since options can appear everywhere, as
 823# an example:
 824#       git mv x -n y
 825#
 826# __git_count_arguments requires 1 argument: the git command executed.
 827__git_count_arguments ()
 828{
 829        local word i c=0
 830
 831        # Skip "git" (first argument)
 832        for ((i=1; i < ${#words[@]}; i++)); do
 833                word="${words[i]}"
 834
 835                case "$word" in
 836                        --)
 837                                # Good; we can assume that the following are only non
 838                                # option arguments.
 839                                ((c = 0))
 840                                ;;
 841                        "$1")
 842                                # Skip the specified git command and discard git
 843                                # main options
 844                                ((c = 0))
 845                                ;;
 846                        ?*)
 847                                ((c++))
 848                                ;;
 849                esac
 850        done
 851
 852        printf "%d" $c
 853}
 854
 855__git_whitespacelist="nowarn warn error error-all fix"
 856
 857_git_am ()
 858{
 859        local dir="$(__gitdir)"
 860        if [ -d "$dir"/rebase-apply ]; then
 861                __gitcomp "--skip --continue --resolved --abort"
 862                return
 863        fi
 864        case "$cur" in
 865        --whitespace=*)
 866                __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
 867                return
 868                ;;
 869        --*)
 870                __gitcomp "
 871                        --3way --committer-date-is-author-date --ignore-date
 872                        --ignore-whitespace --ignore-space-change
 873                        --interactive --keep --no-utf8 --signoff --utf8
 874                        --whitespace= --scissors
 875                        "
 876                return
 877        esac
 878}
 879
 880_git_apply ()
 881{
 882        case "$cur" in
 883        --whitespace=*)
 884                __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
 885                return
 886                ;;
 887        --*)
 888                __gitcomp "
 889                        --stat --numstat --summary --check --index
 890                        --cached --index-info --reverse --reject --unidiff-zero
 891                        --apply --no-add --exclude=
 892                        --ignore-whitespace --ignore-space-change
 893                        --whitespace= --inaccurate-eof --verbose
 894                        "
 895                return
 896        esac
 897}
 898
 899_git_add ()
 900{
 901        case "$cur" in
 902        --*)
 903                __gitcomp "
 904                        --interactive --refresh --patch --update --dry-run
 905                        --ignore-errors --intent-to-add
 906                        "
 907                return
 908        esac
 909
 910        # XXX should we check for --update and --all options ?
 911        __git_complete_index_file "--others --modified --directory --no-empty-directory"
 912}
 913
 914_git_archive ()
 915{
 916        case "$cur" in
 917        --format=*)
 918                __gitcomp "$(git archive --list)" "" "${cur##--format=}"
 919                return
 920                ;;
 921        --remote=*)
 922                __gitcomp_nl "$(__git_remotes)" "" "${cur##--remote=}"
 923                return
 924                ;;
 925        --*)
 926                __gitcomp "
 927                        --format= --list --verbose
 928                        --prefix= --remote= --exec=
 929                        "
 930                return
 931                ;;
 932        esac
 933        __git_complete_file
 934}
 935
 936_git_bisect ()
 937{
 938        __git_has_doubledash && return
 939
 940        local subcommands="start bad good skip reset visualize replay log run"
 941        local subcommand="$(__git_find_on_cmdline "$subcommands")"
 942        if [ -z "$subcommand" ]; then
 943                if [ -f "$(__gitdir)"/BISECT_START ]; then
 944                        __gitcomp "$subcommands"
 945                else
 946                        __gitcomp "replay start"
 947                fi
 948                return
 949        fi
 950
 951        case "$subcommand" in
 952        bad|good|reset|skip|start)
 953                __gitcomp_nl "$(__git_refs)"
 954                ;;
 955        *)
 956                ;;
 957        esac
 958}
 959
 960_git_branch ()
 961{
 962        local i c=1 only_local_ref="n" has_r="n"
 963
 964        while [ $c -lt $cword ]; do
 965                i="${words[c]}"
 966                case "$i" in
 967                -d|-m)  only_local_ref="y" ;;
 968                -r)     has_r="y" ;;
 969                esac
 970                ((c++))
 971        done
 972
 973        case "$cur" in
 974        --set-upstream-to=*)
 975                __gitcomp_nl "$(__git_refs)" "" "${cur##--set-upstream-to=}"
 976                ;;
 977        --*)
 978                __gitcomp "
 979                        --color --no-color --verbose --abbrev= --no-abbrev
 980                        --track --no-track --contains --merged --no-merged
 981                        --set-upstream-to= --edit-description --list
 982                        --unset-upstream
 983                        "
 984                ;;
 985        *)
 986                if [ $only_local_ref = "y" -a $has_r = "n" ]; then
 987                        __gitcomp_nl "$(__git_heads)"
 988                else
 989                        __gitcomp_nl "$(__git_refs)"
 990                fi
 991                ;;
 992        esac
 993}
 994
 995_git_bundle ()
 996{
 997        local cmd="${words[2]}"
 998        case "$cword" in
 999        2)
1000                __gitcomp "create list-heads verify unbundle"
1001                ;;
1002        3)
1003                # looking for a file
1004                ;;
1005        *)
1006                case "$cmd" in
1007                        create)
1008                                __git_complete_revlist
1009                        ;;
1010                esac
1011                ;;
1012        esac
1013}
1014
1015_git_checkout ()
1016{
1017        __git_has_doubledash && return
1018
1019        case "$cur" in
1020        --conflict=*)
1021                __gitcomp "diff3 merge" "" "${cur##--conflict=}"
1022                ;;
1023        --*)
1024                __gitcomp "
1025                        --quiet --ours --theirs --track --no-track --merge
1026                        --conflict= --orphan --patch
1027                        "
1028                ;;
1029        *)
1030                # check if --track, --no-track, or --no-guess was specified
1031                # if so, disable DWIM mode
1032                local flags="--track --no-track --no-guess" track=1
1033                if [ -n "$(__git_find_on_cmdline "$flags")" ]; then
1034                        track=''
1035                fi
1036                __gitcomp_nl "$(__git_refs '' $track)"
1037                ;;
1038        esac
1039}
1040
1041_git_cherry ()
1042{
1043        __gitcomp_nl "$(__git_refs)"
1044}
1045
1046_git_cherry_pick ()
1047{
1048        local dir="$(__gitdir)"
1049        if [ -f "$dir"/CHERRY_PICK_HEAD ]; then
1050                __gitcomp "--continue --quit --abort"
1051                return
1052        fi
1053        case "$cur" in
1054        --*)
1055                __gitcomp "--edit --no-commit --signoff --strategy= --mainline"
1056                ;;
1057        *)
1058                __gitcomp_nl "$(__git_refs)"
1059                ;;
1060        esac
1061}
1062
1063_git_clean ()
1064{
1065        case "$cur" in
1066        --*)
1067                __gitcomp "--dry-run --quiet"
1068                return
1069                ;;
1070        esac
1071
1072        # XXX should we check for -x option ?
1073        __git_complete_index_file "--others --directory"
1074}
1075
1076_git_clone ()
1077{
1078        case "$cur" in
1079        --*)
1080                __gitcomp "
1081                        --local
1082                        --no-hardlinks
1083                        --shared
1084                        --reference
1085                        --quiet
1086                        --no-checkout
1087                        --bare
1088                        --mirror
1089                        --origin
1090                        --upload-pack
1091                        --template=
1092                        --depth
1093                        --single-branch
1094                        --branch
1095                        "
1096                return
1097                ;;
1098        esac
1099}
1100
1101__git_untracked_file_modes="all no normal"
1102
1103_git_commit ()
1104{
1105        case "$prev" in
1106        -c|-C)
1107                __gitcomp_nl "$(__git_refs)" "" "${cur}"
1108                return
1109                ;;
1110        esac
1111
1112        case "$cur" in
1113        --cleanup=*)
1114                __gitcomp "default scissors strip verbatim whitespace
1115                        " "" "${cur##--cleanup=}"
1116                return
1117                ;;
1118        --reuse-message=*|--reedit-message=*|\
1119        --fixup=*|--squash=*)
1120                __gitcomp_nl "$(__git_refs)" "" "${cur#*=}"
1121                return
1122                ;;
1123        --untracked-files=*)
1124                __gitcomp "$__git_untracked_file_modes" "" "${cur##--untracked-files=}"
1125                return
1126                ;;
1127        --*)
1128                __gitcomp "
1129                        --all --author= --signoff --verify --no-verify
1130                        --edit --no-edit
1131                        --amend --include --only --interactive
1132                        --dry-run --reuse-message= --reedit-message=
1133                        --reset-author --file= --message= --template=
1134                        --cleanup= --untracked-files --untracked-files=
1135                        --verbose --quiet --fixup= --squash=
1136                        "
1137                return
1138        esac
1139
1140        if git rev-parse --verify --quiet HEAD >/dev/null; then
1141                __git_complete_index_file "--committable"
1142        else
1143                # This is the first commit
1144                __git_complete_index_file "--cached"
1145        fi
1146}
1147
1148_git_describe ()
1149{
1150        case "$cur" in
1151        --*)
1152                __gitcomp "
1153                        --all --tags --contains --abbrev= --candidates=
1154                        --exact-match --debug --long --match --always
1155                        "
1156                return
1157        esac
1158        __gitcomp_nl "$(__git_refs)"
1159}
1160
1161__git_diff_algorithms="myers minimal patience histogram"
1162
1163__git_diff_common_options="--stat --numstat --shortstat --summary
1164                        --patch-with-stat --name-only --name-status --color
1165                        --no-color --color-words --no-renames --check
1166                        --full-index --binary --abbrev --diff-filter=
1167                        --find-copies-harder
1168                        --text --ignore-space-at-eol --ignore-space-change
1169                        --ignore-all-space --ignore-blank-lines --exit-code
1170                        --quiet --ext-diff --no-ext-diff
1171                        --no-prefix --src-prefix= --dst-prefix=
1172                        --inter-hunk-context=
1173                        --patience --histogram --minimal
1174                        --raw --word-diff --word-diff-regex=
1175                        --dirstat --dirstat= --dirstat-by-file
1176                        --dirstat-by-file= --cumulative
1177                        --diff-algorithm=
1178"
1179
1180_git_diff ()
1181{
1182        __git_has_doubledash && return
1183
1184        case "$cur" in
1185        --diff-algorithm=*)
1186                __gitcomp "$__git_diff_algorithms" "" "${cur##--diff-algorithm=}"
1187                return
1188                ;;
1189        --*)
1190                __gitcomp "--cached --staged --pickaxe-all --pickaxe-regex
1191                        --base --ours --theirs --no-index
1192                        $__git_diff_common_options
1193                        "
1194                return
1195                ;;
1196        esac
1197        __git_complete_revlist_file
1198}
1199
1200__git_mergetools_common="diffuse diffmerge ecmerge emerge kdiff3 meld opendiff
1201                        tkdiff vimdiff gvimdiff xxdiff araxis p4merge bc codecompare
1202"
1203
1204_git_difftool ()
1205{
1206        __git_has_doubledash && return
1207
1208        case "$cur" in
1209        --tool=*)
1210                __gitcomp "$__git_mergetools_common kompare" "" "${cur##--tool=}"
1211                return
1212                ;;
1213        --*)
1214                __gitcomp "--cached --staged --pickaxe-all --pickaxe-regex
1215                        --base --ours --theirs
1216                        --no-renames --diff-filter= --find-copies-harder
1217                        --relative --ignore-submodules
1218                        --tool="
1219                return
1220                ;;
1221        esac
1222        __git_complete_revlist_file
1223}
1224
1225__git_fetch_recurse_submodules="yes on-demand no"
1226
1227__git_fetch_options="
1228        --quiet --verbose --append --upload-pack --force --keep --depth=
1229        --tags --no-tags --all --prune --dry-run --recurse-submodules=
1230"
1231
1232_git_fetch ()
1233{
1234        case "$cur" in
1235        --recurse-submodules=*)
1236                __gitcomp "$__git_fetch_recurse_submodules" "" "${cur##--recurse-submodules=}"
1237                return
1238                ;;
1239        --*)
1240                __gitcomp "$__git_fetch_options"
1241                return
1242                ;;
1243        esac
1244        __git_complete_remote_or_refspec
1245}
1246
1247__git_format_patch_options="
1248        --stdout --attach --no-attach --thread --thread= --no-thread
1249        --numbered --start-number --numbered-files --keep-subject --signoff
1250        --signature --no-signature --in-reply-to= --cc= --full-index --binary
1251        --not --all --cover-letter --no-prefix --src-prefix= --dst-prefix=
1252        --inline --suffix= --ignore-if-in-upstream --subject-prefix=
1253        --output-directory --reroll-count --to= --quiet --notes
1254"
1255
1256_git_format_patch ()
1257{
1258        case "$cur" in
1259        --thread=*)
1260                __gitcomp "
1261                        deep shallow
1262                        " "" "${cur##--thread=}"
1263                return
1264                ;;
1265        --*)
1266                __gitcomp "$__git_format_patch_options"
1267                return
1268                ;;
1269        esac
1270        __git_complete_revlist
1271}
1272
1273_git_fsck ()
1274{
1275        case "$cur" in
1276        --*)
1277                __gitcomp "
1278                        --tags --root --unreachable --cache --no-reflogs --full
1279                        --strict --verbose --lost-found
1280                        "
1281                return
1282                ;;
1283        esac
1284}
1285
1286_git_gc ()
1287{
1288        case "$cur" in
1289        --*)
1290                __gitcomp "--prune --aggressive"
1291                return
1292                ;;
1293        esac
1294}
1295
1296_git_gitk ()
1297{
1298        _gitk
1299}
1300
1301__git_match_ctag() {
1302        awk "/^${1//\//\\/}/ { print \$1 }" "$2"
1303}
1304
1305_git_grep ()
1306{
1307        __git_has_doubledash && return
1308
1309        case "$cur" in
1310        --*)
1311                __gitcomp "
1312                        --cached
1313                        --text --ignore-case --word-regexp --invert-match
1314                        --full-name --line-number
1315                        --extended-regexp --basic-regexp --fixed-strings
1316                        --perl-regexp
1317                        --threads
1318                        --files-with-matches --name-only
1319                        --files-without-match
1320                        --max-depth
1321                        --count
1322                        --and --or --not --all-match
1323                        "
1324                return
1325                ;;
1326        esac
1327
1328        case "$cword,$prev" in
1329        2,*|*,-*)
1330                if test -r tags; then
1331                        __gitcomp_nl "$(__git_match_ctag "$cur" tags)"
1332                        return
1333                fi
1334                ;;
1335        esac
1336
1337        __gitcomp_nl "$(__git_refs)"
1338}
1339
1340_git_help ()
1341{
1342        case "$cur" in
1343        --*)
1344                __gitcomp "--all --info --man --web"
1345                return
1346                ;;
1347        esac
1348        __git_compute_all_commands
1349        __gitcomp "$__git_all_commands $(__git_aliases)
1350                attributes cli core-tutorial cvs-migration
1351                diffcore gitk glossary hooks ignore modules
1352                namespaces repository-layout tutorial tutorial-2
1353                workflows
1354                "
1355}
1356
1357_git_init ()
1358{
1359        case "$cur" in
1360        --shared=*)
1361                __gitcomp "
1362                        false true umask group all world everybody
1363                        " "" "${cur##--shared=}"
1364                return
1365                ;;
1366        --*)
1367                __gitcomp "--quiet --bare --template= --shared --shared="
1368                return
1369                ;;
1370        esac
1371}
1372
1373_git_ls_files ()
1374{
1375        case "$cur" in
1376        --*)
1377                __gitcomp "--cached --deleted --modified --others --ignored
1378                        --stage --directory --no-empty-directory --unmerged
1379                        --killed --exclude= --exclude-from=
1380                        --exclude-per-directory= --exclude-standard
1381                        --error-unmatch --with-tree= --full-name
1382                        --abbrev --ignored --exclude-per-directory
1383                        "
1384                return
1385                ;;
1386        esac
1387
1388        # XXX ignore options like --modified and always suggest all cached
1389        # files.
1390        __git_complete_index_file "--cached"
1391}
1392
1393_git_ls_remote ()
1394{
1395        __gitcomp_nl "$(__git_remotes)"
1396}
1397
1398_git_ls_tree ()
1399{
1400        __git_complete_file
1401}
1402
1403# Options that go well for log, shortlog and gitk
1404__git_log_common_options="
1405        --not --all
1406        --branches --tags --remotes
1407        --first-parent --merges --no-merges
1408        --max-count=
1409        --max-age= --since= --after=
1410        --min-age= --until= --before=
1411        --min-parents= --max-parents=
1412        --no-min-parents --no-max-parents
1413"
1414# Options that go well for log and gitk (not shortlog)
1415__git_log_gitk_options="
1416        --dense --sparse --full-history
1417        --simplify-merges --simplify-by-decoration
1418        --left-right --notes --no-notes
1419"
1420# Options that go well for log and shortlog (not gitk)
1421__git_log_shortlog_options="
1422        --author= --committer= --grep=
1423        --all-match --invert-grep
1424"
1425
1426__git_log_pretty_formats="oneline short medium full fuller email raw format:"
1427__git_log_date_formats="relative iso8601 rfc2822 short local default raw"
1428
1429_git_log ()
1430{
1431        __git_has_doubledash && return
1432
1433        local g="$(git rev-parse --git-dir 2>/dev/null)"
1434        local merge=""
1435        if [ -f "$g/MERGE_HEAD" ]; then
1436                merge="--merge"
1437        fi
1438        case "$cur" in
1439        --pretty=*|--format=*)
1440                __gitcomp "$__git_log_pretty_formats $(__git_pretty_aliases)
1441                        " "" "${cur#*=}"
1442                return
1443                ;;
1444        --date=*)
1445                __gitcomp "$__git_log_date_formats" "" "${cur##--date=}"
1446                return
1447                ;;
1448        --decorate=*)
1449                __gitcomp "full short no" "" "${cur##--decorate=}"
1450                return
1451                ;;
1452        --*)
1453                __gitcomp "
1454                        $__git_log_common_options
1455                        $__git_log_shortlog_options
1456                        $__git_log_gitk_options
1457                        --root --topo-order --date-order --reverse
1458                        --follow --full-diff
1459                        --abbrev-commit --abbrev=
1460                        --relative-date --date=
1461                        --pretty= --format= --oneline
1462                        --show-signature
1463                        --cherry-pick
1464                        --graph
1465                        --decorate --decorate=
1466                        --walk-reflogs
1467                        --parents --children
1468                        $merge
1469                        $__git_diff_common_options
1470                        --pickaxe-all --pickaxe-regex
1471                        "
1472                return
1473                ;;
1474        esac
1475        __git_complete_revlist
1476}
1477
1478# Common merge options shared by git-merge(1) and git-pull(1).
1479__git_merge_options="
1480        --no-commit --no-stat --log --no-log --squash --strategy
1481        --commit --stat --no-squash --ff --no-ff --ff-only --edit --no-edit
1482        --verify-signatures --no-verify-signatures --gpg-sign
1483        --quiet --verbose --progress --no-progress
1484"
1485
1486_git_merge ()
1487{
1488        __git_complete_strategy && return
1489
1490        case "$cur" in
1491        --*)
1492                __gitcomp "$__git_merge_options
1493                        --rerere-autoupdate --no-rerere-autoupdate --abort"
1494                return
1495        esac
1496        __gitcomp_nl "$(__git_refs)"
1497}
1498
1499_git_mergetool ()
1500{
1501        case "$cur" in
1502        --tool=*)
1503                __gitcomp "$__git_mergetools_common tortoisemerge" "" "${cur##--tool=}"
1504                return
1505                ;;
1506        --*)
1507                __gitcomp "--tool="
1508                return
1509                ;;
1510        esac
1511}
1512
1513_git_merge_base ()
1514{
1515        case "$cur" in
1516        --*)
1517                __gitcomp "--octopus --independent --is-ancestor --fork-point"
1518                return
1519                ;;
1520        esac
1521        __gitcomp_nl "$(__git_refs)"
1522}
1523
1524_git_mv ()
1525{
1526        case "$cur" in
1527        --*)
1528                __gitcomp "--dry-run"
1529                return
1530                ;;
1531        esac
1532
1533        if [ $(__git_count_arguments "mv") -gt 0 ]; then
1534                # We need to show both cached and untracked files (including
1535                # empty directories) since this may not be the last argument.
1536                __git_complete_index_file "--cached --others --directory"
1537        else
1538                __git_complete_index_file "--cached"
1539        fi
1540}
1541
1542_git_name_rev ()
1543{
1544        __gitcomp "--tags --all --stdin"
1545}
1546
1547_git_notes ()
1548{
1549        local subcommands='add append copy edit list prune remove show'
1550        local subcommand="$(__git_find_on_cmdline "$subcommands")"
1551
1552        case "$subcommand,$cur" in
1553        ,--*)
1554                __gitcomp '--ref'
1555                ;;
1556        ,*)
1557                case "$prev" in
1558                --ref)
1559                        __gitcomp_nl "$(__git_refs)"
1560                        ;;
1561                *)
1562                        __gitcomp "$subcommands --ref"
1563                        ;;
1564                esac
1565                ;;
1566        add,--reuse-message=*|append,--reuse-message=*|\
1567        add,--reedit-message=*|append,--reedit-message=*)
1568                __gitcomp_nl "$(__git_refs)" "" "${cur#*=}"
1569                ;;
1570        add,--*|append,--*)
1571                __gitcomp '--file= --message= --reedit-message=
1572                                --reuse-message='
1573                ;;
1574        copy,--*)
1575                __gitcomp '--stdin'
1576                ;;
1577        prune,--*)
1578                __gitcomp '--dry-run --verbose'
1579                ;;
1580        prune,*)
1581                ;;
1582        *)
1583                case "$prev" in
1584                -m|-F)
1585                        ;;
1586                *)
1587                        __gitcomp_nl "$(__git_refs)"
1588                        ;;
1589                esac
1590                ;;
1591        esac
1592}
1593
1594_git_pull ()
1595{
1596        __git_complete_strategy && return
1597
1598        case "$cur" in
1599        --recurse-submodules=*)
1600                __gitcomp "$__git_fetch_recurse_submodules" "" "${cur##--recurse-submodules=}"
1601                return
1602                ;;
1603        --*)
1604                __gitcomp "
1605                        --rebase --no-rebase
1606                        $__git_merge_options
1607                        $__git_fetch_options
1608                "
1609                return
1610                ;;
1611        esac
1612        __git_complete_remote_or_refspec
1613}
1614
1615__git_push_recurse_submodules="check on-demand"
1616
1617__git_complete_force_with_lease ()
1618{
1619        local cur_=$1
1620
1621        case "$cur_" in
1622        --*=)
1623                ;;
1624        *:*)
1625                __gitcomp_nl "$(__git_refs)" "" "${cur_#*:}"
1626                ;;
1627        *)
1628                __gitcomp_nl "$(__git_refs)" "" "$cur_"
1629                ;;
1630        esac
1631}
1632
1633_git_push ()
1634{
1635        case "$prev" in
1636        --repo)
1637                __gitcomp_nl "$(__git_remotes)"
1638                return
1639                ;;
1640        --recurse-submodules)
1641                __gitcomp "$__git_push_recurse_submodules"
1642                return
1643                ;;
1644        esac
1645        case "$cur" in
1646        --repo=*)
1647                __gitcomp_nl "$(__git_remotes)" "" "${cur##--repo=}"
1648                return
1649                ;;
1650        --recurse-submodules=*)
1651                __gitcomp "$__git_push_recurse_submodules" "" "${cur##--recurse-submodules=}"
1652                return
1653                ;;
1654        --force-with-lease=*)
1655                __git_complete_force_with_lease "${cur##--force-with-lease=}"
1656                return
1657                ;;
1658        --*)
1659                __gitcomp "
1660                        --all --mirror --tags --dry-run --force --verbose
1661                        --quiet --prune --delete --follow-tags
1662                        --receive-pack= --repo= --set-upstream
1663                        --force-with-lease --force-with-lease= --recurse-submodules=
1664                "
1665                return
1666                ;;
1667        esac
1668        __git_complete_remote_or_refspec
1669}
1670
1671_git_rebase ()
1672{
1673        local dir="$(__gitdir)"
1674        if [ -f "$dir"/rebase-merge/interactive ]; then
1675                __gitcomp "--continue --skip --abort --edit-todo"
1676                return
1677        elif [ -d "$dir"/rebase-apply ] || [ -d "$dir"/rebase-merge ]; then
1678                __gitcomp "--continue --skip --abort"
1679                return
1680        fi
1681        __git_complete_strategy && return
1682        case "$cur" in
1683        --whitespace=*)
1684                __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
1685                return
1686                ;;
1687        --*)
1688                __gitcomp "
1689                        --onto --merge --strategy --interactive
1690                        --preserve-merges --stat --no-stat
1691                        --committer-date-is-author-date --ignore-date
1692                        --ignore-whitespace --whitespace=
1693                        --autosquash --no-autosquash
1694                        --fork-point --no-fork-point
1695                        --autostash --no-autostash
1696                        --verify --no-verify
1697                        --keep-empty --root --force-rebase --no-ff
1698                        --exec
1699                        "
1700
1701                return
1702        esac
1703        __gitcomp_nl "$(__git_refs)"
1704}
1705
1706_git_reflog ()
1707{
1708        local subcommands="show delete expire"
1709        local subcommand="$(__git_find_on_cmdline "$subcommands")"
1710
1711        if [ -z "$subcommand" ]; then
1712                __gitcomp "$subcommands"
1713        else
1714                __gitcomp_nl "$(__git_refs)"
1715        fi
1716}
1717
1718__git_send_email_confirm_options="always never auto cc compose"
1719__git_send_email_suppresscc_options="author self cc bodycc sob cccmd body all"
1720
1721_git_send_email ()
1722{
1723        case "$prev" in
1724        --to|--cc|--bcc|--from)
1725                __gitcomp "
1726                $(git --git-dir="$(__gitdir)" send-email --dump-aliases 2>/dev/null)
1727                "
1728                return
1729                ;;
1730        esac
1731
1732        case "$cur" in
1733        --confirm=*)
1734                __gitcomp "
1735                        $__git_send_email_confirm_options
1736                        " "" "${cur##--confirm=}"
1737                return
1738                ;;
1739        --suppress-cc=*)
1740                __gitcomp "
1741                        $__git_send_email_suppresscc_options
1742                        " "" "${cur##--suppress-cc=}"
1743
1744                return
1745                ;;
1746        --smtp-encryption=*)
1747                __gitcomp "ssl tls" "" "${cur##--smtp-encryption=}"
1748                return
1749                ;;
1750        --thread=*)
1751                __gitcomp "
1752                        deep shallow
1753                        " "" "${cur##--thread=}"
1754                return
1755                ;;
1756        --to=*|--cc=*|--bcc=*|--from=*)
1757                __gitcomp "
1758                $(git --git-dir="$(__gitdir)" send-email --dump-aliases 2>/dev/null)
1759                " "" "${cur#--*=}"
1760                return
1761                ;;
1762        --*)
1763                __gitcomp "--annotate --bcc --cc --cc-cmd --chain-reply-to
1764                        --compose --confirm= --dry-run --envelope-sender
1765                        --from --identity
1766                        --in-reply-to --no-chain-reply-to --no-signed-off-by-cc
1767                        --no-suppress-from --no-thread --quiet
1768                        --signed-off-by-cc --smtp-pass --smtp-server
1769                        --smtp-server-port --smtp-encryption= --smtp-user
1770                        --subject --suppress-cc= --suppress-from --thread --to
1771                        --validate --no-validate
1772                        $__git_format_patch_options"
1773                return
1774                ;;
1775        esac
1776        __git_complete_revlist
1777}
1778
1779_git_stage ()
1780{
1781        _git_add
1782}
1783
1784__git_config_get_set_variables ()
1785{
1786        local prevword word config_file= c=$cword
1787        while [ $c -gt 1 ]; do
1788                word="${words[c]}"
1789                case "$word" in
1790                --system|--global|--local|--file=*)
1791                        config_file="$word"
1792                        break
1793                        ;;
1794                -f|--file)
1795                        config_file="$word $prevword"
1796                        break
1797                        ;;
1798                esac
1799                prevword=$word
1800                c=$((--c))
1801        done
1802
1803        git --git-dir="$(__gitdir)" config $config_file --name-only --list 2>/dev/null
1804}
1805
1806_git_config ()
1807{
1808        case "$prev" in
1809        branch.*.remote|branch.*.pushremote)
1810                __gitcomp_nl "$(__git_remotes)"
1811                return
1812                ;;
1813        branch.*.merge)
1814                __gitcomp_nl "$(__git_refs)"
1815                return
1816                ;;
1817        branch.*.rebase)
1818                __gitcomp "false true preserve interactive"
1819                return
1820                ;;
1821        remote.pushdefault)
1822                __gitcomp_nl "$(__git_remotes)"
1823                return
1824                ;;
1825        remote.*.fetch)
1826                local remote="${prev#remote.}"
1827                remote="${remote%.fetch}"
1828                if [ -z "$cur" ]; then
1829                        __gitcomp_nl "refs/heads/" "" "" ""
1830                        return
1831                fi
1832                __gitcomp_nl "$(__git_refs_remotes "$remote")"
1833                return
1834                ;;
1835        remote.*.push)
1836                local remote="${prev#remote.}"
1837                remote="${remote%.push}"
1838                __gitcomp_nl "$(git --git-dir="$(__gitdir)" \
1839                        for-each-ref --format='%(refname):%(refname)' \
1840                        refs/heads)"
1841                return
1842                ;;
1843        pull.twohead|pull.octopus)
1844                __git_compute_merge_strategies
1845                __gitcomp "$__git_merge_strategies"
1846                return
1847                ;;
1848        color.branch|color.diff|color.interactive|\
1849        color.showbranch|color.status|color.ui)
1850                __gitcomp "always never auto"
1851                return
1852                ;;
1853        color.pager)
1854                __gitcomp "false true"
1855                return
1856                ;;
1857        color.*.*)
1858                __gitcomp "
1859                        normal black red green yellow blue magenta cyan white
1860                        bold dim ul blink reverse
1861                        "
1862                return
1863                ;;
1864        diff.submodule)
1865                __gitcomp "log short"
1866                return
1867                ;;
1868        help.format)
1869                __gitcomp "man info web html"
1870                return
1871                ;;
1872        log.date)
1873                __gitcomp "$__git_log_date_formats"
1874                return
1875                ;;
1876        sendemail.aliasesfiletype)
1877                __gitcomp "mutt mailrc pine elm gnus"
1878                return
1879                ;;
1880        sendemail.confirm)
1881                __gitcomp "$__git_send_email_confirm_options"
1882                return
1883                ;;
1884        sendemail.suppresscc)
1885                __gitcomp "$__git_send_email_suppresscc_options"
1886                return
1887                ;;
1888        sendemail.transferencoding)
1889                __gitcomp "7bit 8bit quoted-printable base64"
1890                return
1891                ;;
1892        --get|--get-all|--unset|--unset-all)
1893                __gitcomp_nl "$(__git_config_get_set_variables)"
1894                return
1895                ;;
1896        *.*)
1897                return
1898                ;;
1899        esac
1900        case "$cur" in
1901        --*)
1902                __gitcomp "
1903                        --system --global --local --file=
1904                        --list --replace-all
1905                        --get --get-all --get-regexp
1906                        --add --unset --unset-all
1907                        --remove-section --rename-section
1908                        --name-only
1909                        "
1910                return
1911                ;;
1912        branch.*.*)
1913                local pfx="${cur%.*}." cur_="${cur##*.}"
1914                __gitcomp "remote pushremote merge mergeoptions rebase" "$pfx" "$cur_"
1915                return
1916                ;;
1917        branch.*)
1918                local pfx="${cur%.*}." cur_="${cur#*.}"
1919                __gitcomp_nl "$(__git_heads)" "$pfx" "$cur_" "."
1920                __gitcomp_nl_append $'autosetupmerge\nautosetuprebase\n' "$pfx" "$cur_"
1921                return
1922                ;;
1923        guitool.*.*)
1924                local pfx="${cur%.*}." cur_="${cur##*.}"
1925                __gitcomp "
1926                        argprompt cmd confirm needsfile noconsole norescan
1927                        prompt revprompt revunmerged title
1928                        " "$pfx" "$cur_"
1929                return
1930                ;;
1931        difftool.*.*)
1932                local pfx="${cur%.*}." cur_="${cur##*.}"
1933                __gitcomp "cmd path" "$pfx" "$cur_"
1934                return
1935                ;;
1936        man.*.*)
1937                local pfx="${cur%.*}." cur_="${cur##*.}"
1938                __gitcomp "cmd path" "$pfx" "$cur_"
1939                return
1940                ;;
1941        mergetool.*.*)
1942                local pfx="${cur%.*}." cur_="${cur##*.}"
1943                __gitcomp "cmd path trustExitCode" "$pfx" "$cur_"
1944                return
1945                ;;
1946        pager.*)
1947                local pfx="${cur%.*}." cur_="${cur#*.}"
1948                __git_compute_all_commands
1949                __gitcomp_nl "$__git_all_commands" "$pfx" "$cur_"
1950                return
1951                ;;
1952        remote.*.*)
1953                local pfx="${cur%.*}." cur_="${cur##*.}"
1954                __gitcomp "
1955                        url proxy fetch push mirror skipDefaultUpdate
1956                        receivepack uploadpack tagopt pushurl
1957                        " "$pfx" "$cur_"
1958                return
1959                ;;
1960        remote.*)
1961                local pfx="${cur%.*}." cur_="${cur#*.}"
1962                __gitcomp_nl "$(__git_remotes)" "$pfx" "$cur_" "."
1963                __gitcomp_nl_append "pushdefault" "$pfx" "$cur_"
1964                return
1965                ;;
1966        url.*.*)
1967                local pfx="${cur%.*}." cur_="${cur##*.}"
1968                __gitcomp "insteadOf pushInsteadOf" "$pfx" "$cur_"
1969                return
1970                ;;
1971        esac
1972        __gitcomp "
1973                add.ignoreErrors
1974                advice.commitBeforeMerge
1975                advice.detachedHead
1976                advice.implicitIdentity
1977                advice.pushNonFastForward
1978                advice.resolveConflict
1979                advice.statusHints
1980                alias.
1981                am.keepcr
1982                apply.ignorewhitespace
1983                apply.whitespace
1984                branch.autosetupmerge
1985                branch.autosetuprebase
1986                browser.
1987                clean.requireForce
1988                color.branch
1989                color.branch.current
1990                color.branch.local
1991                color.branch.plain
1992                color.branch.remote
1993                color.decorate.HEAD
1994                color.decorate.branch
1995                color.decorate.remoteBranch
1996                color.decorate.stash
1997                color.decorate.tag
1998                color.diff
1999                color.diff.commit
2000                color.diff.frag
2001                color.diff.func
2002                color.diff.meta
2003                color.diff.new
2004                color.diff.old
2005                color.diff.plain
2006                color.diff.whitespace
2007                color.grep
2008                color.grep.context
2009                color.grep.filename
2010                color.grep.function
2011                color.grep.linenumber
2012                color.grep.match
2013                color.grep.selected
2014                color.grep.separator
2015                color.interactive
2016                color.interactive.error
2017                color.interactive.header
2018                color.interactive.help
2019                color.interactive.prompt
2020                color.pager
2021                color.showbranch
2022                color.status
2023                color.status.added
2024                color.status.changed
2025                color.status.header
2026                color.status.nobranch
2027                color.status.unmerged
2028                color.status.untracked
2029                color.status.updated
2030                color.ui
2031                commit.status
2032                commit.template
2033                core.abbrev
2034                core.askpass
2035                core.attributesfile
2036                core.autocrlf
2037                core.bare
2038                core.bigFileThreshold
2039                core.compression
2040                core.createObject
2041                core.deltaBaseCacheLimit
2042                core.editor
2043                core.eol
2044                core.excludesfile
2045                core.fileMode
2046                core.fsyncobjectfiles
2047                core.gitProxy
2048                core.ignoreStat
2049                core.ignorecase
2050                core.logAllRefUpdates
2051                core.loosecompression
2052                core.notesRef
2053                core.packedGitLimit
2054                core.packedGitWindowSize
2055                core.pager
2056                core.preferSymlinkRefs
2057                core.preloadindex
2058                core.quotepath
2059                core.repositoryFormatVersion
2060                core.safecrlf
2061                core.sharedRepository
2062                core.sparseCheckout
2063                core.symlinks
2064                core.trustctime
2065                core.untrackedCache
2066                core.warnAmbiguousRefs
2067                core.whitespace
2068                core.worktree
2069                diff.autorefreshindex
2070                diff.external
2071                diff.ignoreSubmodules
2072                diff.mnemonicprefix
2073                diff.noprefix
2074                diff.renameLimit
2075                diff.renames
2076                diff.statGraphWidth
2077                diff.submodule
2078                diff.suppressBlankEmpty
2079                diff.tool
2080                diff.wordRegex
2081                diff.algorithm
2082                difftool.
2083                difftool.prompt
2084                fetch.recurseSubmodules
2085                fetch.unpackLimit
2086                format.attach
2087                format.cc
2088                format.coverLetter
2089                format.headers
2090                format.numbered
2091                format.pretty
2092                format.signature
2093                format.signoff
2094                format.subjectprefix
2095                format.suffix
2096                format.thread
2097                format.to
2098                gc.
2099                gc.aggressiveWindow
2100                gc.auto
2101                gc.autopacklimit
2102                gc.packrefs
2103                gc.pruneexpire
2104                gc.reflogexpire
2105                gc.reflogexpireunreachable
2106                gc.rerereresolved
2107                gc.rerereunresolved
2108                gitcvs.allbinary
2109                gitcvs.commitmsgannotation
2110                gitcvs.dbTableNamePrefix
2111                gitcvs.dbdriver
2112                gitcvs.dbname
2113                gitcvs.dbpass
2114                gitcvs.dbuser
2115                gitcvs.enabled
2116                gitcvs.logfile
2117                gitcvs.usecrlfattr
2118                guitool.
2119                gui.blamehistoryctx
2120                gui.commitmsgwidth
2121                gui.copyblamethreshold
2122                gui.diffcontext
2123                gui.encoding
2124                gui.fastcopyblame
2125                gui.matchtrackingbranch
2126                gui.newbranchtemplate
2127                gui.pruneduringfetch
2128                gui.spellingdictionary
2129                gui.trustmtime
2130                help.autocorrect
2131                help.browser
2132                help.format
2133                http.lowSpeedLimit
2134                http.lowSpeedTime
2135                http.maxRequests
2136                http.minSessions
2137                http.noEPSV
2138                http.postBuffer
2139                http.proxy
2140                http.sslCipherList
2141                http.sslVersion
2142                http.sslCAInfo
2143                http.sslCAPath
2144                http.sslCert
2145                http.sslCertPasswordProtected
2146                http.sslKey
2147                http.sslVerify
2148                http.useragent
2149                i18n.commitEncoding
2150                i18n.logOutputEncoding
2151                imap.authMethod
2152                imap.folder
2153                imap.host
2154                imap.pass
2155                imap.port
2156                imap.preformattedHTML
2157                imap.sslverify
2158                imap.tunnel
2159                imap.user
2160                init.templatedir
2161                instaweb.browser
2162                instaweb.httpd
2163                instaweb.local
2164                instaweb.modulepath
2165                instaweb.port
2166                interactive.singlekey
2167                log.date
2168                log.decorate
2169                log.showroot
2170                mailmap.file
2171                man.
2172                man.viewer
2173                merge.
2174                merge.conflictstyle
2175                merge.log
2176                merge.renameLimit
2177                merge.renormalize
2178                merge.stat
2179                merge.tool
2180                merge.verbosity
2181                mergetool.
2182                mergetool.keepBackup
2183                mergetool.keepTemporaries
2184                mergetool.prompt
2185                notes.displayRef
2186                notes.rewrite.
2187                notes.rewrite.amend
2188                notes.rewrite.rebase
2189                notes.rewriteMode
2190                notes.rewriteRef
2191                pack.compression
2192                pack.deltaCacheLimit
2193                pack.deltaCacheSize
2194                pack.depth
2195                pack.indexVersion
2196                pack.packSizeLimit
2197                pack.threads
2198                pack.window
2199                pack.windowMemory
2200                pager.
2201                pretty.
2202                pull.octopus
2203                pull.twohead
2204                push.default
2205                push.followTags
2206                rebase.autosquash
2207                rebase.stat
2208                receive.autogc
2209                receive.denyCurrentBranch
2210                receive.denyDeleteCurrent
2211                receive.denyDeletes
2212                receive.denyNonFastForwards
2213                receive.fsckObjects
2214                receive.unpackLimit
2215                receive.updateserverinfo
2216                remote.pushdefault
2217                remotes.
2218                repack.usedeltabaseoffset
2219                rerere.autoupdate
2220                rerere.enabled
2221                sendemail.
2222                sendemail.aliasesfile
2223                sendemail.aliasfiletype
2224                sendemail.bcc
2225                sendemail.cc
2226                sendemail.cccmd
2227                sendemail.chainreplyto
2228                sendemail.confirm
2229                sendemail.envelopesender
2230                sendemail.from
2231                sendemail.identity
2232                sendemail.multiedit
2233                sendemail.signedoffbycc
2234                sendemail.smtpdomain
2235                sendemail.smtpencryption
2236                sendemail.smtppass
2237                sendemail.smtpserver
2238                sendemail.smtpserveroption
2239                sendemail.smtpserverport
2240                sendemail.smtpuser
2241                sendemail.suppresscc
2242                sendemail.suppressfrom
2243                sendemail.thread
2244                sendemail.to
2245                sendemail.validate
2246                showbranch.default
2247                status.relativePaths
2248                status.showUntrackedFiles
2249                status.submodulesummary
2250                submodule.
2251                tar.umask
2252                transfer.unpackLimit
2253                url.
2254                user.email
2255                user.name
2256                user.signingkey
2257                web.browser
2258                branch. remote.
2259        "
2260}
2261
2262_git_remote ()
2263{
2264        local subcommands="add rename remove set-head set-branches set-url show prune update"
2265        local subcommand="$(__git_find_on_cmdline "$subcommands")"
2266        if [ -z "$subcommand" ]; then
2267                __gitcomp "$subcommands"
2268                return
2269        fi
2270
2271        case "$subcommand" in
2272        rename|remove|set-url|show|prune)
2273                __gitcomp_nl "$(__git_remotes)"
2274                ;;
2275        set-head|set-branches)
2276                __git_complete_remote_or_refspec
2277                ;;
2278        update)
2279                __gitcomp "$(__git_get_config_variables "remotes")"
2280                ;;
2281        *)
2282                ;;
2283        esac
2284}
2285
2286_git_replace ()
2287{
2288        __gitcomp_nl "$(__git_refs)"
2289}
2290
2291_git_reset ()
2292{
2293        __git_has_doubledash && return
2294
2295        case "$cur" in
2296        --*)
2297                __gitcomp "--merge --mixed --hard --soft --patch"
2298                return
2299                ;;
2300        esac
2301        __gitcomp_nl "$(__git_refs)"
2302}
2303
2304_git_revert ()
2305{
2306        local dir="$(__gitdir)"
2307        if [ -f "$dir"/REVERT_HEAD ]; then
2308                __gitcomp "--continue --quit --abort"
2309                return
2310        fi
2311        case "$cur" in
2312        --*)
2313                __gitcomp "--edit --mainline --no-edit --no-commit --signoff"
2314                return
2315                ;;
2316        esac
2317        __gitcomp_nl "$(__git_refs)"
2318}
2319
2320_git_rm ()
2321{
2322        case "$cur" in
2323        --*)
2324                __gitcomp "--cached --dry-run --ignore-unmatch --quiet"
2325                return
2326                ;;
2327        esac
2328
2329        __git_complete_index_file "--cached"
2330}
2331
2332_git_shortlog ()
2333{
2334        __git_has_doubledash && return
2335
2336        case "$cur" in
2337        --*)
2338                __gitcomp "
2339                        $__git_log_common_options
2340                        $__git_log_shortlog_options
2341                        --numbered --summary
2342                        "
2343                return
2344                ;;
2345        esac
2346        __git_complete_revlist
2347}
2348
2349_git_show ()
2350{
2351        __git_has_doubledash && return
2352
2353        case "$cur" in
2354        --pretty=*|--format=*)
2355                __gitcomp "$__git_log_pretty_formats $(__git_pretty_aliases)
2356                        " "" "${cur#*=}"
2357                return
2358                ;;
2359        --diff-algorithm=*)
2360                __gitcomp "$__git_diff_algorithms" "" "${cur##--diff-algorithm=}"
2361                return
2362                ;;
2363        --*)
2364                __gitcomp "--pretty= --format= --abbrev-commit --oneline
2365                        --show-signature
2366                        $__git_diff_common_options
2367                        "
2368                return
2369                ;;
2370        esac
2371        __git_complete_revlist_file
2372}
2373
2374_git_show_branch ()
2375{
2376        case "$cur" in
2377        --*)
2378                __gitcomp "
2379                        --all --remotes --topo-order --date-order --current --more=
2380                        --list --independent --merge-base --no-name
2381                        --color --no-color
2382                        --sha1-name --sparse --topics --reflog
2383                        "
2384                return
2385                ;;
2386        esac
2387        __git_complete_revlist
2388}
2389
2390_git_stash ()
2391{
2392        local save_opts='--all --keep-index --no-keep-index --quiet --patch --include-untracked'
2393        local subcommands='save list show apply clear drop pop create branch'
2394        local subcommand="$(__git_find_on_cmdline "$subcommands")"
2395        if [ -z "$subcommand" ]; then
2396                case "$cur" in
2397                --*)
2398                        __gitcomp "$save_opts"
2399                        ;;
2400                *)
2401                        if [ -z "$(__git_find_on_cmdline "$save_opts")" ]; then
2402                                __gitcomp "$subcommands"
2403                        fi
2404                        ;;
2405                esac
2406        else
2407                case "$subcommand,$cur" in
2408                save,--*)
2409                        __gitcomp "$save_opts"
2410                        ;;
2411                apply,--*|pop,--*)
2412                        __gitcomp "--index --quiet"
2413                        ;;
2414                drop,--*)
2415                        __gitcomp "--quiet"
2416                        ;;
2417                show,--*|branch,--*)
2418                        ;;
2419                branch,*)
2420                        if [ $cword -eq 3 ]; then
2421                                __gitcomp_nl "$(__git_refs)";
2422                        else
2423                                __gitcomp_nl "$(git --git-dir="$(__gitdir)" stash list \
2424                                                | sed -n -e 's/:.*//p')"
2425                        fi
2426                        ;;
2427                show,*|apply,*|drop,*|pop,*)
2428                        __gitcomp_nl "$(git --git-dir="$(__gitdir)" stash list \
2429                                        | sed -n -e 's/:.*//p')"
2430                        ;;
2431                *)
2432                        ;;
2433                esac
2434        fi
2435}
2436
2437_git_submodule ()
2438{
2439        __git_has_doubledash && return
2440
2441        local subcommands="add status init deinit update summary foreach sync"
2442        if [ -z "$(__git_find_on_cmdline "$subcommands")" ]; then
2443                case "$cur" in
2444                --*)
2445                        __gitcomp "--quiet --cached"
2446                        ;;
2447                *)
2448                        __gitcomp "$subcommands"
2449                        ;;
2450                esac
2451                return
2452        fi
2453}
2454
2455_git_svn ()
2456{
2457        local subcommands="
2458                init fetch clone rebase dcommit log find-rev
2459                set-tree commit-diff info create-ignore propget
2460                proplist show-ignore show-externals branch tag blame
2461                migrate mkdirs reset gc
2462                "
2463        local subcommand="$(__git_find_on_cmdline "$subcommands")"
2464        if [ -z "$subcommand" ]; then
2465                __gitcomp "$subcommands"
2466        else
2467                local remote_opts="--username= --config-dir= --no-auth-cache"
2468                local fc_opts="
2469                        --follow-parent --authors-file= --repack=
2470                        --no-metadata --use-svm-props --use-svnsync-props
2471                        --log-window-size= --no-checkout --quiet
2472                        --repack-flags --use-log-author --localtime
2473                        --ignore-paths= --include-paths= $remote_opts
2474                        "
2475                local init_opts="
2476                        --template= --shared= --trunk= --tags=
2477                        --branches= --stdlayout --minimize-url
2478                        --no-metadata --use-svm-props --use-svnsync-props
2479                        --rewrite-root= --prefix= --use-log-author
2480                        --add-author-from $remote_opts
2481                        "
2482                local cmt_opts="
2483                        --edit --rmdir --find-copies-harder --copy-similarity=
2484                        "
2485
2486                case "$subcommand,$cur" in
2487                fetch,--*)
2488                        __gitcomp "--revision= --fetch-all $fc_opts"
2489                        ;;
2490                clone,--*)
2491                        __gitcomp "--revision= $fc_opts $init_opts"
2492                        ;;
2493                init,--*)
2494                        __gitcomp "$init_opts"
2495                        ;;
2496                dcommit,--*)
2497                        __gitcomp "
2498                                --merge --strategy= --verbose --dry-run
2499                                --fetch-all --no-rebase --commit-url
2500                                --revision --interactive $cmt_opts $fc_opts
2501                                "
2502                        ;;
2503                set-tree,--*)
2504                        __gitcomp "--stdin $cmt_opts $fc_opts"
2505                        ;;
2506                create-ignore,--*|propget,--*|proplist,--*|show-ignore,--*|\
2507                show-externals,--*|mkdirs,--*)
2508                        __gitcomp "--revision="
2509                        ;;
2510                log,--*)
2511                        __gitcomp "
2512                                --limit= --revision= --verbose --incremental
2513                                --oneline --show-commit --non-recursive
2514                                --authors-file= --color
2515                                "
2516                        ;;
2517                rebase,--*)
2518                        __gitcomp "
2519                                --merge --verbose --strategy= --local
2520                                --fetch-all --dry-run $fc_opts
2521                                "
2522                        ;;
2523                commit-diff,--*)
2524                        __gitcomp "--message= --file= --revision= $cmt_opts"
2525                        ;;
2526                info,--*)
2527                        __gitcomp "--url"
2528                        ;;
2529                branch,--*)
2530                        __gitcomp "--dry-run --message --tag"
2531                        ;;
2532                tag,--*)
2533                        __gitcomp "--dry-run --message"
2534                        ;;
2535                blame,--*)
2536                        __gitcomp "--git-format"
2537                        ;;
2538                migrate,--*)
2539                        __gitcomp "
2540                                --config-dir= --ignore-paths= --minimize
2541                                --no-auth-cache --username=
2542                                "
2543                        ;;
2544                reset,--*)
2545                        __gitcomp "--revision= --parent"
2546                        ;;
2547                *)
2548                        ;;
2549                esac
2550        fi
2551}
2552
2553_git_tag ()
2554{
2555        local i c=1 f=0
2556        while [ $c -lt $cword ]; do
2557                i="${words[c]}"
2558                case "$i" in
2559                -d|-v)
2560                        __gitcomp_nl "$(__git_tags)"
2561                        return
2562                        ;;
2563                -f)
2564                        f=1
2565                        ;;
2566                esac
2567                ((c++))
2568        done
2569
2570        case "$prev" in
2571        -m|-F)
2572                ;;
2573        -*|tag)
2574                if [ $f = 1 ]; then
2575                        __gitcomp_nl "$(__git_tags)"
2576                fi
2577                ;;
2578        *)
2579                __gitcomp_nl "$(__git_refs)"
2580                ;;
2581        esac
2582
2583        case "$cur" in
2584        --*)
2585                __gitcomp "
2586                        --list --delete --verify --annotate --message --file
2587                        --sign --cleanup --local-user --force --column --sort
2588                        --contains --points-at
2589                        "
2590                ;;
2591        esac
2592}
2593
2594_git_whatchanged ()
2595{
2596        _git_log
2597}
2598
2599__git_main ()
2600{
2601        local i c=1 command __git_dir
2602
2603        while [ $c -lt $cword ]; do
2604                i="${words[c]}"
2605                case "$i" in
2606                --git-dir=*) __git_dir="${i#--git-dir=}" ;;
2607                --git-dir)   ((c++)) ; __git_dir="${words[c]}" ;;
2608                --bare)      __git_dir="." ;;
2609                --help) command="help"; break ;;
2610                -c|--work-tree|--namespace) ((c++)) ;;
2611                -*) ;;
2612                *) command="$i"; break ;;
2613                esac
2614                ((c++))
2615        done
2616
2617        if [ -z "$command" ]; then
2618                case "$cur" in
2619                --*)   __gitcomp "
2620                        --paginate
2621                        --no-pager
2622                        --git-dir=
2623                        --bare
2624                        --version
2625                        --exec-path
2626                        --exec-path=
2627                        --html-path
2628                        --man-path
2629                        --info-path
2630                        --work-tree=
2631                        --namespace=
2632                        --no-replace-objects
2633                        --help
2634                        "
2635                        ;;
2636                *)     __git_compute_porcelain_commands
2637                       __gitcomp "$__git_porcelain_commands $(__git_aliases)" ;;
2638                esac
2639                return
2640        fi
2641
2642        local completion_func="_git_${command//-/_}"
2643        declare -f $completion_func >/dev/null && $completion_func && return
2644
2645        local expansion=$(__git_aliased_command "$command")
2646        if [ -n "$expansion" ]; then
2647                words[1]=$expansion
2648                completion_func="_git_${expansion//-/_}"
2649                declare -f $completion_func >/dev/null && $completion_func
2650        fi
2651}
2652
2653__gitk_main ()
2654{
2655        __git_has_doubledash && return
2656
2657        local g="$(__gitdir)"
2658        local merge=""
2659        if [ -f "$g/MERGE_HEAD" ]; then
2660                merge="--merge"
2661        fi
2662        case "$cur" in
2663        --*)
2664                __gitcomp "
2665                        $__git_log_common_options
2666                        $__git_log_gitk_options
2667                        $merge
2668                        "
2669                return
2670                ;;
2671        esac
2672        __git_complete_revlist
2673}
2674
2675if [[ -n ${ZSH_VERSION-} ]]; then
2676        echo "WARNING: this script is deprecated, please see git-completion.zsh" 1>&2
2677
2678        autoload -U +X compinit && compinit
2679
2680        __gitcomp ()
2681        {
2682                emulate -L zsh
2683
2684                local cur_="${3-$cur}"
2685
2686                case "$cur_" in
2687                --*=)
2688                        ;;
2689                *)
2690                        local c IFS=$' \t\n'
2691                        local -a array
2692                        for c in ${=1}; do
2693                                c="$c${4-}"
2694                                case $c in
2695                                --*=*|*.) ;;
2696                                *) c="$c " ;;
2697                                esac
2698                                array[${#array[@]}+1]="$c"
2699                        done
2700                        compset -P '*[=:]'
2701                        compadd -Q -S '' -p "${2-}" -a -- array && _ret=0
2702                        ;;
2703                esac
2704        }
2705
2706        __gitcomp_nl ()
2707        {
2708                emulate -L zsh
2709
2710                local IFS=$'\n'
2711                compset -P '*[=:]'
2712                compadd -Q -S "${4- }" -p "${2-}" -- ${=1} && _ret=0
2713        }
2714
2715        __gitcomp_file ()
2716        {
2717                emulate -L zsh
2718
2719                local IFS=$'\n'
2720                compset -P '*[=:]'
2721                compadd -Q -p "${2-}" -f -- ${=1} && _ret=0
2722        }
2723
2724        _git ()
2725        {
2726                local _ret=1 cur cword prev
2727                cur=${words[CURRENT]}
2728                prev=${words[CURRENT-1]}
2729                let cword=CURRENT-1
2730                emulate ksh -c __${service}_main
2731                let _ret && _default && _ret=0
2732                return _ret
2733        }
2734
2735        compdef _git git gitk
2736        return
2737fi
2738
2739__git_func_wrap ()
2740{
2741        local cur words cword prev
2742        _get_comp_words_by_ref -n =: cur words cword prev
2743        $1
2744}
2745
2746# Setup completion for certain functions defined above by setting common
2747# variables and workarounds.
2748# This is NOT a public function; use at your own risk.
2749__git_complete ()
2750{
2751        local wrapper="__git_wrap${2}"
2752        eval "$wrapper () { __git_func_wrap $2 ; }"
2753        complete -o bashdefault -o default -o nospace -F $wrapper $1 2>/dev/null \
2754                || complete -o default -o nospace -F $wrapper $1
2755}
2756
2757# wrapper for backwards compatibility
2758_git ()
2759{
2760        __git_wrap__git_main
2761}
2762
2763# wrapper for backwards compatibility
2764_gitk ()
2765{
2766        __git_wrap__gitk_main
2767}
2768
2769__git_complete git __git_main
2770__git_complete gitk __gitk_main
2771
2772# The following are necessary only for Cygwin, and only are needed
2773# when the user has tab-completed the executable name and consequently
2774# included the '.exe' suffix.
2775#
2776if [ Cygwin = "$(uname -o 2>/dev/null)" ]; then
2777__git_complete git.exe __git_main
2778fi