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