git-completion.bash

sh/zsh completion support for core Git.
#
# Copyright (C) 2006,2007 Shawn O. Pearce <spearce@spearce.org>
# Conceptually based on gitcompletion (http://gitweb.hawaga.org.uk/).
# Distributed under the GNU General Public License, version 2.0.
#
# The contained completion routines provide support for completing:
#
#    *) local and remote branch names
#    *) local and remote tag names
#    *) .git/remotes file names
#    *) git 'subcommands'
#    *) tree paths within 'ref:path/to/file' expressions
#    *) file paths within current working directory and index
#    *) common --long-options
#
# To use these routines:
#
#    1) Copy this file to somewhere (e.g. ~/.git-completion.bash).
#    2) Add the following line to your .bashrc/.zshrc:
#        source ~/.git-completion.bash
#    3) Consider changing your PS1 to also show the current branch,
#       see git-prompt.sh for details.
#
# If you use complex aliases of form '!f() { ... }; f', you can use the null
# command ':' as the first command in the function body to declare the desired
# completion style.  For example '!f() { : git commit ; ... }; f' will
# tell the completion to use commit completion.  This also works with aliases
# of form "!sh -c '...'".  For example, "!sh -c ': git commit ; ... '".

case "$COMP_WORDBREAKS" in
*:*) : great ;;
*)   COMP_WORDBREAKS="$COMP_WORDBREAKS:"
esac

# __gitdir accepts 0 or 1 arguments (i.e., location)
# returns location of .git repo
__gitdir ()
{
    if [ -z "${1-}" ]; then
        if [ -n "${__git_dir-}" ]; then
            echo "$__git_dir"
        elif [ -n "${GIT_DIR-}" ]; then
            test -d "${GIT_DIR-}" || return 1
            echo "$GIT_DIR"
        elif [ -d .git ]; then
            echo .git
        else
            git rev-parse --git-dir 2>/dev/null
        fi
    elif [ -d "$1/.git" ]; then
        echo "$1/.git"
    else
        echo "$1"
    fi
}

# The following function is based on code from:
#
#   bash_completion - programmable completion functions for bash 3.2+
#
#   Copyright © 2006-2008, Ian Macdonald <ian@caliban.org>
#             © 2009-2010, Bash Completion Maintainers
#                     <bash-completion-devel@lists.alioth.debian.org>
#
#   This program is free software; you can redistribute it and/or modify
#   it under the terms of the GNU General Public License as published by
#   the Free Software Foundation; either version 2, or (at your option)
#   any later version.
#
#   This program is distributed in the hope that it will be useful,
#   but WITHOUT ANY WARRANTY; without even the implied warranty of
#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#   GNU General Public License for more details.
#
#   You should have received a copy of the GNU General Public License
#   along with this program; if not, write to the Free Software Foundation,
#   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#
#   The latest version of this software can be obtained here:
#
#   http://bash-completion.alioth.debian.org/
#
#   RELEASE: 2.x

# This function can be used to access a tokenized list of words
# on the command line:
#
#   __git_reassemble_comp_words_by_ref '=:'
#   if test "${words_[cword_-1]}" = -w
#   then
#       ...
#   fi
#
# The argument should be a collection of characters from the list of
# word completion separators (COMP_WORDBREAKS) to treat as ordinary
# characters.
#
# This is roughly equivalent to going back in time and setting
# COMP_WORDBREAKS to exclude those characters.  The intent is to
# make option types like --date=<type> and <rev>:<path> easy to
# recognize by treating each shell word as a single token.
#
# It is best not to set COMP_WORDBREAKS directly because the value is
# shared with other completion scripts.  By the time the completion
# function gets called, COMP_WORDS has already been populated so local
# changes to COMP_WORDBREAKS have no effect.
#
# Output: words_, cword_, cur_.

__git_reassemble_comp_words_by_ref()
{
    local exclude i j first
    # Which word separators to exclude?
    exclude="${1//[^$COMP_WORDBREAKS]}"
    cword_=$COMP_CWORD
    if [ -z "$exclude" ]; then
        words_=("${COMP_WORDS[@]}")
        return
    fi
    # List of word completion separators has shrunk;
    # re-assemble words to complete.
    for ((i=0, j=0; i < ${#COMP_WORDS[@]}; i++, j++)); do
        # Append each nonempty word consisting of just
        # word separator characters to the current word.
        first=t
        while
            [ $i -gt 0 ] &&
            [ -n "${COMP_WORDS[$i]}" ] &&
            # word consists of excluded word separators
            [ "${COMP_WORDS[$i]//[^$exclude]}" = "${COMP_WORDS[$i]}" ]
        do
            # Attach to the previous token,
            # unless the previous token is the command name.
            if [ $j -ge 2 ] && [ -n "$first" ]; then
                ((j--))
            fi
            first=
            words_[$j]=${words_[j]}${COMP_WORDS[i]}
            if [ $i = $COMP_CWORD ]; then
                cword_=$j
            fi
            if (($i < ${#COMP_WORDS[@]} - 1)); then
                ((i++))
            else
                # Done.
                return
            fi
        done
        words_[$j]=${words_[j]}${COMP_WORDS[i]}
        if [ $i = $COMP_CWORD ]; then
            cword_=$j
        fi
    done
}

if ! type _get_comp_words_by_ref >/dev/null 2>&1; then
_get_comp_words_by_ref ()
{
    local exclude cur_ words_ cword_
    if [ "$1" = "-n" ]; then
        exclude=$2
        shift 2
    fi
    __git_reassemble_comp_words_by_ref "$exclude"
    cur_=${words_[cword_]}
    while [ $# -gt 0 ]; do
        case "$1" in
        cur)
            cur=$cur_
            ;;
        prev)
            prev=${words_[$cword_-1]}
            ;;
        words)
            words=("${words_[@]}")
            ;;
        cword)
            cword=$cword_
            ;;
        esac
        shift
    done
}
fi

__gitcompappend ()
{
    local i=${#COMPREPLY[@]}
    for x in $1; do
        if [[ "$x" == "$3"* ]]; then
            COMPREPLY[i++]="$2$x$4"
        fi
    done
}

__gitcompadd ()
{
    COMPREPLY=()
    __gitcompappend "$@"
}

# Generates completion reply, appending a space to possible completion words,
# if necessary.
# It accepts 1 to 4 arguments:
# 1: List of possible completion words.
# 2: A prefix to be added to each possible completion word (optional).
# 3: Generate possible completion matches for this word (optional).
# 4: A suffix to be appended to each possible completion word (optional).
__gitcomp ()
{
    local cur_="${3-$cur}"

    case "$cur_" in
    --*=)
        ;;
    *)
        local c i=0 IFS=$' \t\n'
        for c in $1; do
            c="$c${4-}"
            if [[ $c == "$cur_"* ]]; then
                case $c in
                --*=*|*.) ;;
                *) c="$c " ;;
                esac
                COMPREPLY[i++]="${2-}$c"
            fi
        done
        ;;
    esac
}

# Variation of __gitcomp_nl () that appends to the existing list of
# completion candidates, COMPREPLY.
__gitcomp_nl_append ()
{
    local IFS=$'\n'
    __gitcompappend "$1" "${2-}" "${3-$cur}" "${4- }"
}

# Generates completion reply from newline-separated possible completion words
# by appending a space to all of them.
# It accepts 1 to 4 arguments:
# 1: List of possible completion words, separated by a single newline.
# 2: A prefix to be added to each possible completion word (optional).
# 3: Generate possible completion matches for this word (optional).
# 4: A suffix to be appended to each possible completion word instead of
#    the default space (optional).  If specified but empty, nothing is
#    appended.
__gitcomp_nl ()
{
    COMPREPLY=()
    __gitcomp_nl_append "$@"
}

# Generates completion reply with compgen from newline-separated possible
# completion filenames.
# It accepts 1 to 3 arguments:
# 1: List of possible completion filenames, separated by a single newline.
# 2: A directory prefix to be added to each possible completion filename
#    (optional).
# 3: Generate possible completion matches for this word (optional).
__gitcomp_file ()
{
    local IFS=$'\n'

    # XXX does not work when the directory prefix contains a tilde,
    # since tilde expansion is not applied.
    # This means that COMPREPLY will be empty and Bash default
    # completion will be used.
    __gitcompadd "$1" "${2-}" "${3-$cur}" ""

    # use a hack to enable file mode in bash < 4
    compopt -o filenames +o nospace 2>/dev/null ||
    compgen -f /non-existing-dir/ > /dev/null
}

# Execute 'git ls-files', unless the --committable option is specified, in
# which case it runs 'git diff-index' to find out the files that can be
# committed.  It return paths relative to the directory specified in the first
# argument, and using the options specified in the second argument.
__git_ls_files_helper ()
{
    if [ "$2" == "--committable" ]; then
        git -C "$1" diff-index --name-only --relative HEAD
    else
        # NOTE: $2 is not quoted in order to support multiple options
        git -C "$1" ls-files --exclude-standard $2
    fi 2>/dev/null
}


# __git_index_files accepts 1 or 2 arguments:
# 1: Options to pass to ls-files (required).
# 2: A directory path (optional).
#    If provided, only files within the specified directory are listed.
#    Sub directories are never recursed.  Path must have a trailing
#    slash.
__git_index_files ()
{
    local dir="$(__gitdir)" root="${2-.}" file

    if [ -d "$dir" ]; then
        __git_ls_files_helper "$root" "$1" |
        while read -r file; do
            case "$file" in
            ?*/*) echo "${file%%/*}" ;;
            *) echo "$file" ;;
            esac
        done | sort | uniq
    fi
}

__git_heads ()
{
    local dir="$(__gitdir)"
    if [ -d "$dir" ]; then
        git --git-dir="$dir" for-each-ref --format='%(refname:short)' \
            refs/heads
        return
    fi
}

__git_tags ()
{
    local dir="$(__gitdir)"
    if [ -d "$dir" ]; then
        git --git-dir="$dir" for-each-ref --format='%(refname:short)' \
            refs/tags
        return
    fi
}

# __git_refs accepts 0, 1 (to pass to __gitdir), or 2 arguments
# presence of 2nd argument means use the guess heuristic employed
# by checkout for tracking branches
__git_refs ()
{
    local i hash dir="$(__gitdir "${1-}")" track="${2-}"
    local format refs
    if [ -d "$dir" ]; then
        case "$cur" in
        refs|refs/*)
            format="refname"
            refs="${cur%/*}"
            track=""
            ;;
        *)
            for i in HEAD FETCH_HEAD ORIG_HEAD MERGE_HEAD; do
                if [ -e "$dir/$i" ]; then echo $i; fi
            done
            format="refname:short"
            refs="refs/tags refs/heads refs/remotes"
            ;;
        esac
        git --git-dir="$dir" for-each-ref --format="%($format)" \
            $refs
        if [ -n "$track" ]; then
            # employ the heuristic used by git checkout
            # Try to find a remote branch that matches the completion word
            # but only output if the branch name is unique
            local ref entry
            git --git-dir="$dir" for-each-ref --shell --format="ref=%(refname:short)" \
                "refs/remotes/" | \
            while read -r entry; do
                eval "$entry"
                ref="${ref#*/}"
                if [[ "$ref" == "$cur"* ]]; then
                    echo "$ref"
                fi
            done | sort | uniq -u
        fi
        return
    fi
    case "$cur" in
    refs|refs/*)
        git ls-remote "$dir" "$cur*" 2>/dev/null | \
        while read -r hash i; do
            case "$i" in
            *^{}) ;;
            *) echo "$i" ;;
            esac
        done
        ;;
    *)
        echo "HEAD"
        git for-each-ref --format="%(refname:short)" -- \
            "refs/remotes/$dir/" 2>/dev/null | sed -e "s#^$dir/##"
        ;;
    esac
}

# __git_refs2 requires 1 argument (to pass to __git_refs)
__git_refs2 ()
{
    local i
    for i in $(__git_refs "$1"); do
        echo "$i:$i"
    done
}

# __git_refs_remotes requires 1 argument (to pass to ls-remote)
__git_refs_remotes ()
{
    local i hash
    git ls-remote "$1" 'refs/heads/*' 2>/dev/null | \
    while read -r hash i; do
        echo "$i:refs/remotes/$1/${i#refs/heads/}"
    done
}

__git_remotes ()
{
    local i IFS=$'\n' d="$(__gitdir)"
    test -d "$d/remotes" && ls -1 "$d/remotes"
    for i in $(git --git-dir="$d" config --get-regexp 'remote\..*\.url' 2>/dev/null); do
        i="${i#remote.}"
        echo "${i/.url*/}"
    done
}

__git_list_merge_strategies ()
{
    git merge -s help 2>&1 |
    sed -n -e '/[Aa]vailable strategies are: /,/^$/{
        s/\.$//
        s/.*://
        s/^[    ]*//
        s/[     ]*$//
        p
    }'
}

__git_merge_strategies=
# 'git merge -s help' (and thus detection of the merge strategy
# list) fails, unfortunately, if run outside of any git working
# tree.  __git_merge_strategies is set to the empty string in
# that case, and the detection will be repeated the next time it
# is needed.
__git_compute_merge_strategies ()
{
    test -n "$__git_merge_strategies" ||
    __git_merge_strategies=$(__git_list_merge_strategies)
}

__git_complete_revlist_file ()
{
    local pfx ls ref cur_="$cur"
    case "$cur_" in
    *..?*:*)
        return
        ;;
    ?*:*)
        ref="${cur_%%:*}"
        cur_="${cur_#*:}"
        case "$cur_" in
        ?*/*)
            pfx="${cur_%/*}"
            cur_="${cur_##*/}"
            ls="$ref:$pfx"
            pfx="$pfx/"
            ;;
        *)
            ls="$ref"
            ;;
        esac

        case "$COMP_WORDBREAKS" in
        *:*) : great ;;
        *)   pfx="$ref:$pfx" ;;
        esac

        __gitcomp_nl "$(git --git-dir="$(__gitdir)" ls-tree "$ls" 2>/dev/null \
                | sed '/^100... blob /{
                           s,^.*    ,,
                           s,$, ,
                       }
                       /^120000 blob /{
                           s,^.*    ,,
                           s,$, ,
                       }
                       /^040000 tree /{
                           s,^.*    ,,
                           s,$,/,
                       }
                       s/^.*    //')" \
            "$pfx" "$cur_" ""
        ;;
    *...*)
        pfx="${cur_%...*}..."
        cur_="${cur_#*...}"
        __gitcomp_nl "$(__git_refs)" "$pfx" "$cur_"
        ;;
    *..*)
        pfx="${cur_%..*}.."
        cur_="${cur_#*..}"
        __gitcomp_nl "$(__git_refs)" "$pfx" "$cur_"
        ;;
    *)
        __gitcomp_nl "$(__git_refs)"
        ;;
    esac
}


# __git_complete_index_file requires 1 argument:
# 1: the options to pass to ls-file
#
# The exception is --committable, which finds the files appropriate commit.
__git_complete_index_file ()
{
    local pfx="" cur_="$cur"

    case "$cur_" in
    ?*/*)
        pfx="${cur_%/*}"
        cur_="${cur_##*/}"
        pfx="${pfx}/"
        ;;
    esac

    __gitcomp_file "$(__git_index_files "$1" ${pfx:+"$pfx"})" "$pfx" "$cur_"
}

__git_complete_file ()
{
    __git_complete_revlist_file
}

__git_complete_revlist ()
{
    __git_complete_revlist_file
}

__git_complete_remote_or_refspec ()
{
    local cur_="$cur" cmd="${words[1]}"
    local i c=2 remote="" pfx="" lhs=1 no_complete_refspec=0
    if [ "$cmd" = "remote" ]; then
        ((c++))
    fi
    while [ $c -lt $cword ]; do
        i="${words[c]}"
        case "$i" in
        --mirror) [ "$cmd" = "push" ] && no_complete_refspec=1 ;;
        --all)
            case "$cmd" in
            push) no_complete_refspec=1 ;;
            fetch)
                return
                ;;
            *) ;;
            esac
            ;;
        -*) ;;
        *) remote="$i"; break ;;
        esac
        ((c++))
    done
    if [ -z "$remote" ]; then
        __gitcomp_nl "$(__git_remotes)"
        return
    fi
    if [ $no_complete_refspec = 1 ]; then
        return
    fi
    [ "$remote" = "." ] && remote=
    case "$cur_" in
    *:*)
        case "$COMP_WORDBREAKS" in
        *:*) : great ;;
        *)   pfx="${cur_%%:*}:" ;;
        esac
        cur_="${cur_#*:}"
        lhs=0
        ;;
    +*)
        pfx="+"
        cur_="${cur_#+}"
        ;;
    esac
    case "$cmd" in
    fetch)
        if [ $lhs = 1 ]; then
            __gitcomp_nl "$(__git_refs2 "$remote")" "$pfx" "$cur_"
        else
            __gitcomp_nl "$(__git_refs)" "$pfx" "$cur_"
        fi
        ;;
    pull|remote)
        if [ $lhs = 1 ]; then
            __gitcomp_nl "$(__git_refs "$remote")" "$pfx" "$cur_"
        else
            __gitcomp_nl "$(__git_refs)" "$pfx" "$cur_"
        fi
        ;;
    push)
        if [ $lhs = 1 ]; then
            __gitcomp_nl "$(__git_refs)" "$pfx" "$cur_"
        else
            __gitcomp_nl "$(__git_refs "$remote")" "$pfx" "$cur_"
        fi
        ;;
    esac
}

__git_complete_strategy ()
{
    __git_compute_merge_strategies
    case "$prev" in
    -s|--strategy)
        __gitcomp "$__git_merge_strategies"
        return 0
    esac
    case "$cur" in
    --strategy=*)
        __gitcomp "$__git_merge_strategies" "" "${cur##--strategy=}"
        return 0
        ;;
    esac
    return 1
}

__git_commands () {
    if test -n "${GIT_TESTING_COMMAND_COMPLETION:-}"
    then
        printf "%s" "${GIT_TESTING_COMMAND_COMPLETION}"
    else
        git help -a|egrep '^  [a-zA-Z0-9]'
    fi
}

__git_list_all_commands ()
{
    local i IFS=" "$'\n'
    for i in $(__git_commands)
    do
        case $i in
        *--*)             : helper pattern;;
        *) echo $i;;
        esac
    done
}

__git_all_commands=
__git_compute_all_commands ()
{
    test -n "$__git_all_commands" ||
    __git_all_commands=$(__git_list_all_commands)
}

__git_list_porcelain_commands ()
{
    local i IFS=" "$'\n'
    __git_compute_all_commands
    for i in $__git_all_commands
    do
        case $i in
        *--*)             : helper pattern;;
        applymbox)        : ask gittus;;
        applypatch)       : ask gittus;;
        archimport)       : import;;
        cat-file)         : plumbing;;
        check-attr)       : plumbing;;
        check-ignore)     : plumbing;;
        check-mailmap)    : plumbing;;
        check-ref-format) : plumbing;;
        checkout-index)   : plumbing;;
        commit-tree)      : plumbing;;
        count-objects)    : infrequent;;
        credential-cache) : credentials helper;;
        credential-store) : credentials helper;;
        cvsexportcommit)  : export;;
        cvsimport)        : import;;
        cvsserver)        : daemon;;
        daemon)           : daemon;;
        diff-files)       : plumbing;;
        diff-index)       : plumbing;;
        diff-tree)        : plumbing;;
        fast-import)      : import;;
        fast-export)      : export;;
        fsck-objects)     : plumbing;;
        fetch-pack)       : plumbing;;
        fmt-merge-msg)    : plumbing;;
        for-each-ref)     : plumbing;;
        hash-object)      : plumbing;;
        http-*)           : transport;;
        index-pack)       : plumbing;;
        init-db)          : deprecated;;
        local-fetch)      : plumbing;;
        ls-files)         : plumbing;;
        ls-remote)        : plumbing;;
        ls-tree)          : plumbing;;
        mailinfo)         : plumbing;;
        mailsplit)        : plumbing;;
        merge-*)          : plumbing;;
        mktree)           : plumbing;;
        mktag)            : plumbing;;
        pack-objects)     : plumbing;;
        pack-redundant)   : plumbing;;
        pack-refs)        : plumbing;;
        parse-remote)     : plumbing;;
        patch-id)         : plumbing;;
        prune)            : plumbing;;
        prune-packed)     : plumbing;;
        quiltimport)      : import;;
        read-tree)        : plumbing;;
        receive-pack)     : plumbing;;
        remote-*)         : transport;;
        rerere)           : plumbing;;
        rev-list)         : plumbing;;
        rev-parse)        : plumbing;;
        runstatus)        : plumbing;;
        sh-setup)         : internal;;
        shell)            : daemon;;
        show-ref)         : plumbing;;
        send-pack)        : plumbing;;
        show-index)       : plumbing;;
        ssh-*)            : transport;;
        stripspace)       : plumbing;;
        symbolic-ref)     : plumbing;;
        unpack-file)      : plumbing;;
        unpack-objects)   : plumbing;;
        update-index)     : plumbing;;
        update-ref)       : plumbing;;
        update-server-info) : daemon;;
        upload-archive)   : plumbing;;
        upload-pack)      : plumbing;;
        write-tree)       : plumbing;;
        var)              : infrequent;;
        verify-pack)      : infrequent;;
        verify-tag)       : plumbing;;
        *) echo $i;;
        esac
    done
}

__git_porcelain_commands=
__git_compute_porcelain_commands ()
{
    __git_compute_all_commands
    test -n "$__git_porcelain_commands" ||
    __git_porcelain_commands=$(__git_list_porcelain_commands)
}

__git_pretty_aliases ()
{
    local i IFS=$'\n'
    for i in $(git --git-dir="$(__gitdir)" config --get-regexp "pretty\..*" 2>/dev/null); do
        case "$i" in
        pretty.*)
            i="${i#pretty.}"
            echo "${i/ */}"
            ;;
        esac
    done
}

__git_aliases ()
{
    local i IFS=$'\n'
    for i in $(git --git-dir="$(__gitdir)" config --get-regexp "alias\..*" 2>/dev/null); do
        case "$i" in
        alias.*)
            i="${i#alias.}"
            echo "${i/ */}"
            ;;
        esac
    done
}

# __git_aliased_command requires 1 argument
__git_aliased_command ()
{
    local word cmdline=$(git --git-dir="$(__gitdir)" \
        config --get "alias.$1")
    for word in $cmdline; do
        case "$word" in
        \!gitk|gitk)
            echo "gitk"
            return
            ;;
        \!*)    : shell command alias ;;
        -*) : option ;;
        *=*)    : setting env ;;
        git)    : git itself ;;
        \(\))   : skip parens of shell function definition ;;
        {)  : skip start of shell helper function ;;
        :)  : skip null command ;;
        \'*)    : skip opening quote after sh -c ;;
        *)
            echo "$word"
            return
        esac
    done
}

# __git_find_on_cmdline requires 1 argument
__git_find_on_cmdline ()
{
    local word subcommand c=1
    while [ $c -lt $cword ]; do
        word="${words[c]}"
        for subcommand in $1; do
            if [ "$subcommand" = "$word" ]; then
                echo "$subcommand"
                return
            fi
        done
        ((c++))
    done
}

__git_has_doubledash ()
{
    local c=1
    while [ $c -lt $cword ]; do
        if [ "--" = "${words[c]}" ]; then
            return 0
        fi
        ((c++))
    done
    return 1
}

# Try to count non option arguments passed on the command line for the
# specified git command.
# When options are used, it is necessary to use the special -- option to
# tell the implementation were non option arguments begin.
# XXX this can not be improved, since options can appear everywhere, as
# an example:
#   git mv x -n y
#
# __git_count_arguments requires 1 argument: the git command executed.
__git_count_arguments ()
{
    local word i c=0

    # Skip "git" (first argument)
    for ((i=1; i < ${#words[@]}; i++)); do
        word="${words[i]}"

        case "$word" in
            --)
                # Good; we can assume that the following are only non
                # option arguments.
                ((c = 0))
                ;;
            "$1")
                # Skip the specified git command and discard git
                # main options
                ((c = 0))
                ;;
            ?*)
                ((c++))
                ;;
        esac
    done

    printf "%d" $c
}

__git_whitespacelist="nowarn warn error error-all fix"

_git_am ()
{
    local dir="$(__gitdir)"
    if [ -d "$dir"/rebase-apply ]; then
        __gitcomp "--skip --continue --resolved --abort"
        return
    fi
    case "$cur" in
    --whitespace=*)
        __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
        return
        ;;
    --*)
        __gitcomp "
            --3way --committer-date-is-author-date --ignore-date
            --ignore-whitespace --ignore-space-change
            --interactive --keep --no-utf8 --signoff --utf8
            --whitespace= --scissors
            "
        return
    esac
}

_git_apply ()
{
    case "$cur" in
    --whitespace=*)
        __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
        return
        ;;
    --*)
        __gitcomp "
            --stat --numstat --summary --check --index
            --cached --index-info --reverse --reject --unidiff-zero
            --apply --no-add --exclude=
            --ignore-whitespace --ignore-space-change
            --whitespace= --inaccurate-eof --verbose
            "
        return
    esac
}

_git_add ()
{
    case "$cur" in
    --*)
        __gitcomp "
            --interactive --refresh --patch --update --dry-run
            --ignore-errors --intent-to-add
            "
        return
    esac

    # XXX should we check for --update and --all options ?
    __git_complete_index_file "--others --modified --directory --no-empty-directory"
}

_git_archive ()
{
    case "$cur" in
    --format=*)
        __gitcomp "$(git archive --list)" "" "${cur##--format=}"
        return
        ;;
    --remote=*)
        __gitcomp_nl "$(__git_remotes)" "" "${cur##--remote=}"
        return
        ;;
    --*)
        __gitcomp "
            --format= --list --verbose
            --prefix= --remote= --exec=
            "
        return
        ;;
    esac
    __git_complete_file
}

_git_bisect ()
{
    __git_has_doubledash && return

    local subcommands="start bad good skip reset visualize replay log run"
    local subcommand="$(__git_find_on_cmdline "$subcommands")"
    if [ -z "$subcommand" ]; then
        if [ -f "$(__gitdir)"/BISECT_START ]; then
            __gitcomp "$subcommands"
        else
            __gitcomp "replay start"
        fi
        return
    fi

    case "$subcommand" in
    bad|good|reset|skip|start)
        __gitcomp_nl "$(__git_refs)"
        ;;
    *)
        ;;
    esac
}

_git_branch ()
{
    local i c=1 only_local_ref="n" has_r="n"

    while [ $c -lt $cword ]; do
        i="${words[c]}"
        case "$i" in
        -d|-m)  only_local_ref="y" ;;
        -r) has_r="y" ;;
        esac
        ((c++))
    done

    case "$cur" in
    --set-upstream-to=*)
        __gitcomp "$(__git_refs)" "" "${cur##--set-upstream-to=}"
        ;;
    --*)
        __gitcomp "
            --color --no-color --verbose --abbrev= --no-abbrev
            --track --no-track --contains --merged --no-merged
            --set-upstream-to= --edit-description --list
            --unset-upstream
            "
        ;;
    *)
        if [ $only_local_ref = "y" -a $has_r = "n" ]; then
            __gitcomp_nl "$(__git_heads)"
        else
            __gitcomp_nl "$(__git_refs)"
        fi
        ;;
    esac
}

_git_bundle ()
{
    local cmd="${words[2]}"
    case "$cword" in
    2)
        __gitcomp "create list-heads verify unbundle"
        ;;
    3)
        # looking for a file
        ;;
    *)
        case "$cmd" in
            create)
                __git_complete_revlist
            ;;
        esac
        ;;
    esac
}

_git_checkout ()
{
    __git_has_doubledash && return

    case "$cur" in
    --conflict=*)
        __gitcomp "diff3 merge" "" "${cur##--conflict=}"
        ;;
    --*)
        __gitcomp "
            --quiet --ours --theirs --track --no-track --merge
            --conflict= --orphan --patch
            "
        ;;
    *)
        # check if --track, --no-track, or --no-guess was specified
        # if so, disable DWIM mode
        local flags="--track --no-track --no-guess" track=1
        if [ -n "$(__git_find_on_cmdline "$flags")" ]; then
            track=''
        fi
        __gitcomp_nl "$(__git_refs '' $track)"
        ;;
    esac
}

_git_cherry ()
{
    __gitcomp "$(__git_refs)"
}

_git_cherry_pick ()
{
    local dir="$(__gitdir)"
    if [ -f "$dir"/CHERRY_PICK_HEAD ]; then
        __gitcomp "--continue --quit --abort"
        return
    fi
    case "$cur" in
    --*)
        __gitcomp "--edit --no-commit --signoff --strategy= --mainline"
        ;;
    *)
        __gitcomp_nl "$(__git_refs)"
        ;;
    esac
}

_git_clean ()
{
    case "$cur" in
    --*)
        __gitcomp "--dry-run --quiet"
        return
        ;;
    esac

    # XXX should we check for -x option ?
    __git_complete_index_file "--others --directory"
}

_git_clone ()
{
    case "$cur" in
    --*)
        __gitcomp "
            --local
            --no-hardlinks
            --shared
            --reference
            --quiet
            --no-checkout
            --bare
            --mirror
            --origin
            --upload-pack
            --template=
            --depth
            --single-branch
            --branch
            "
        return
        ;;
    esac
}

_git_commit ()
{
    case "$prev" in
    -c|-C)
        __gitcomp_nl "$(__git_refs)" "" "${cur}"
        return
        ;;
    esac

    case "$cur" in
    --cleanup=*)
        __gitcomp "default strip verbatim whitespace
            " "" "${cur##--cleanup=}"
        return
        ;;
    --reuse-message=*|--reedit-message=*|\
    --fixup=*|--squash=*)
        __gitcomp_nl "$(__git_refs)" "" "${cur#*=}"
        return
        ;;
    --untracked-files=*)
        __gitcomp "all no normal" "" "${cur##--untracked-files=}"
        return
        ;;
    --*)
        __gitcomp "
            --all --author= --signoff --verify --no-verify
            --edit --no-edit
            --amend --include --only --interactive
            --dry-run --reuse-message= --reedit-message=
            --reset-author --file= --message= --template=
            --cleanup= --untracked-files --untracked-files=
            --verbose --quiet --fixup= --squash=
            "
        return
    esac

    if git rev-parse --verify --quiet HEAD >/dev/null; then
        __git_complete_index_file "--committable"
    else
        # This is the first commit
        __git_complete_index_file "--cached"
    fi
}

_git_describe ()
{
    case "$cur" in
    --*)
        __gitcomp "
            --all --tags --contains --abbrev= --candidates=
            --exact-match --debug --long --match --always
            "
        return
    esac
    __gitcomp_nl "$(__git_refs)"
}

__git_diff_algorithms="myers minimal patience histogram"

__git_diff_common_options="--stat --numstat --shortstat --summary
            --patch-with-stat --name-only --name-status --color
            --no-color --color-words --no-renames --check
            --full-index --binary --abbrev --diff-filter=
            --find-copies-harder
            --text --ignore-space-at-eol --ignore-space-change
            --ignore-all-space --ignore-blank-lines --exit-code
            --quiet --ext-diff --no-ext-diff
            --no-prefix --src-prefix= --dst-prefix=
            --inter-hunk-context=
            --patience --histogram --minimal
            --raw --word-diff
            --dirstat --dirstat= --dirstat-by-file
            --dirstat-by-file= --cumulative
            --diff-algorithm=
"

_git_diff ()
{
    __git_has_doubledash && return

    case "$cur" in
    --diff-algorithm=*)
        __gitcomp "$__git_diff_algorithms" "" "${cur##--diff-algorithm=}"
        return
        ;;
    --*)
        __gitcomp "--cached --staged --pickaxe-all --pickaxe-regex
            --base --ours --theirs --no-index
            $__git_diff_common_options
            "
        return
        ;;
    esac
    __git_complete_revlist_file
}

__git_mergetools_common="diffuse diffmerge ecmerge emerge kdiff3 meld opendiff
            tkdiff vimdiff gvimdiff xxdiff araxis p4merge bc codecompare
"

_git_difftool ()
{
    __git_has_doubledash && return

    case "$cur" in
    --tool=*)
        __gitcomp "$__git_mergetools_common kompare" "" "${cur##--tool=}"
        return
        ;;
    --*)
        __gitcomp "--cached --staged --pickaxe-all --pickaxe-regex
            --base --ours --theirs
            --no-renames --diff-filter= --find-copies-harder
            --relative --ignore-submodules
            --tool="
        return
        ;;
    esac
    __git_complete_revlist_file
}

__git_fetch_recurse_submodules="yes on-demand no"

__git_fetch_options="
    --quiet --verbose --append --upload-pack --force --keep --depth=
    --tags --no-tags --all --prune --dry-run --recurse-submodules=
"

_git_fetch ()
{
    case "$cur" in
    --recurse-submodules=*)
        __gitcomp "$__git_fetch_recurse_submodules" "" "${cur##--recurse-submodules=}"
        return
        ;;
    --*)
        __gitcomp "$__git_fetch_options"
        return
        ;;
    esac
    __git_complete_remote_or_refspec
}

__git_format_patch_options="
    --stdout --attach --no-attach --thread --thread= --no-thread
    --numbered --start-number --numbered-files --keep-subject --signoff
    --signature --no-signature --in-reply-to= --cc= --full-index --binary
    --not --all --cover-letter --no-prefix --src-prefix= --dst-prefix=
    --inline --suffix= --ignore-if-in-upstream --subject-prefix=
    --output-directory --reroll-count --to= --quiet --notes
"

_git_format_patch ()
{
    case "$cur" in
    --thread=*)
        __gitcomp "
            deep shallow
            " "" "${cur##--thread=}"
        return
        ;;
    --*)
        __gitcomp "$__git_format_patch_options"
        return
        ;;
    esac
    __git_complete_revlist
}

_git_fsck ()
{
    case "$cur" in
    --*)
        __gitcomp "
            --tags --root --unreachable --cache --no-reflogs --full
            --strict --verbose --lost-found
            "
        return
        ;;
    esac
}

_git_gc ()
{
    case "$cur" in
    --*)
        __gitcomp "--prune --aggressive"
        return
        ;;
    esac
}

_git_gitk ()
{
    _gitk
}

__git_match_ctag() {
    awk "/^${1////\\/}/ { print \$1 }" "$2"
}

_git_grep ()
{
    __git_has_doubledash && return

    case "$cur" in
    --*)
        __gitcomp "
            --cached
            --text --ignore-case --word-regexp --invert-match
            --full-name --line-number
            --extended-regexp --basic-regexp --fixed-strings
            --perl-regexp
            --files-with-matches --name-only
            --files-without-match
            --max-depth
            --count
            --and --or --not --all-match
            "
        return
        ;;
    esac

    case "$cword,$prev" in
    2,*|*,-*)
        if test -r tags; then
            __gitcomp_nl "$(__git_match_ctag "$cur" tags)"
            return
        fi
        ;;
    esac

    __gitcomp_nl "$(__git_refs)"
}

_git_help ()
{
    case "$cur" in
    --*)
        __gitcomp "--all --info --man --web"
        return
        ;;
    esac
    __git_compute_all_commands
    __gitcomp "$__git_all_commands $(__git_aliases)
        attributes cli core-tutorial cvs-migration
        diffcore gitk glossary hooks ignore modules
        namespaces repository-layout tutorial tutorial-2
        workflows
        "
}

_git_init ()
{
    case "$cur" in
    --shared=*)
        __gitcomp "
            false true umask group all world everybody
            " "" "${cur##--shared=}"
        return
        ;;
    --*)
        __gitcomp "--quiet --bare --template= --shared --shared="
        return
        ;;
    esac
}

_git_ls_files ()
{
    case "$cur" in
    --*)
        __gitcomp "--cached --deleted --modified --others --ignored
            --stage --directory --no-empty-directory --unmerged
            --killed --exclude= --exclude-from=
            --exclude-per-directory= --exclude-standard
            --error-unmatch --with-tree= --full-name
            --abbrev --ignored --exclude-per-directory
            "
        return
        ;;
    esac

    # XXX ignore options like --modified and always suggest all cached
    # files.
    __git_complete_index_file "--cached"
}

_git_ls_remote ()
{
    __gitcomp_nl "$(__git_remotes)"
}

_git_ls_tree ()
{
    __git_complete_file
}

# Options that go well for log, shortlog and gitk
__git_log_common_options="
    --not --all
    --branches --tags --remotes
    --first-parent --merges --no-merges
    --max-count=
    --max-age= --since= --after=
    --min-age= --until= --before=
    --min-parents= --max-parents=
    --no-min-parents --no-max-parents
"
# Options that go well for log and gitk (not shortlog)
__git_log_gitk_options="
    --dense --sparse --full-history
    --simplify-merges --simplify-by-decoration
    --left-right --notes --no-notes
"
# Options that go well for log and shortlog (not gitk)
__git_log_shortlog_options="
    --author= --committer= --grep=
    --all-match --invert-grep
"

__git_log_pretty_formats="oneline short medium full fuller email raw format:"
__git_log_date_formats="relative iso8601 rfc2822 short local default raw"

_git_log ()
{
    __git_has_doubledash && return

    local g="$(git rev-parse --git-dir 2>/dev/null)"
    local merge=""
    if [ -f "$g/MERGE_HEAD" ]; then
        merge="--merge"
    fi
    case "$cur" in
    --pretty=*|--format=*)
        __gitcomp "$__git_log_pretty_formats $(__git_pretty_aliases)
            " "" "${cur#*=}"
        return
        ;;
    --date=*)
        __gitcomp "$__git_log_date_formats" "" "${cur##--date=}"
        return
        ;;
    --decorate=*)
        __gitcomp "long short" "" "${cur##--decorate=}"
        return
        ;;
    --*)
        __gitcomp "
            $__git_log_common_options
            $__git_log_shortlog_options
            $__git_log_gitk_options
            --root --topo-order --date-order --reverse
            --follow --full-diff
            --abbrev-commit --abbrev=
            --relative-date --date=
            --pretty= --format= --oneline
            --show-signature
            --cherry-pick
            --graph
            --decorate --decorate=
            --walk-reflogs
            --parents --children
            $merge
            $__git_diff_common_options
            --pickaxe-all --pickaxe-regex
            "
        return
        ;;
    esac
    __git_complete_revlist
}

# Common merge options shared by git-merge(1) and git-pull(1).
__git_merge_options="
    --no-commit --no-stat --log --no-log --squash --strategy
    --commit --stat --no-squash --ff --no-ff --ff-only --edit --no-edit
    --verify-signatures --no-verify-signatures --gpg-sign
    --quiet --verbose --progress --no-progress
"

_git_merge ()
{
    __git_complete_strategy && return

    case "$cur" in
    --*)
        __gitcomp "$__git_merge_options
            --rerere-autoupdate --no-rerere-autoupdate --abort"
        return
    esac
    __gitcomp_nl "$(__git_refs)"
}

_git_mergetool ()
{
    case "$cur" in
    --tool=*)
        __gitcomp "$__git_mergetools_common tortoisemerge" "" "${cur##--tool=}"
        return
        ;;
    --*)
        __gitcomp "--tool="
        return
        ;;
    esac
}

_git_merge_base ()
{
    case "$cur" in
    --*)
        __gitcomp "--octopus --independent --is-ancestor --fork-point"
        return
        ;;
    esac
    __gitcomp_nl "$(__git_refs)"
}

_git_mv ()
{
    case "$cur" in
    --*)
        __gitcomp "--dry-run"
        return
        ;;
    esac

    if [ $(__git_count_arguments "mv") -gt 0 ]; then
        # We need to show both cached and untracked files (including
        # empty directories) since this may not be the last argument.
        __git_complete_index_file "--cached --others --directory"
    else
        __git_complete_index_file "--cached"
    fi
}

_git_name_rev ()
{
    __gitcomp "--tags --all --stdin"
}

_git_notes ()
{
    local subcommands='add append copy edit list prune remove show'
    local subcommand="$(__git_find_on_cmdline "$subcommands")"

    case "$subcommand,$cur" in
    ,--*)
        __gitcomp '--ref'
        ;;
    ,*)
        case "$prev" in
        --ref)
            __gitcomp_nl "$(__git_refs)"
            ;;
        *)
            __gitcomp "$subcommands --ref"
            ;;
        esac
        ;;
    add,--reuse-message=*|append,--reuse-message=*|\
    add,--reedit-message=*|append,--reedit-message=*)
        __gitcomp_nl "$(__git_refs)" "" "${cur#*=}"
        ;;
    add,--*|append,--*)
        __gitcomp '--file= --message= --reedit-message=
                --reuse-message='
        ;;
    copy,--*)
        __gitcomp '--stdin'
        ;;
    prune,--*)
        __gitcomp '--dry-run --verbose'
        ;;
    prune,*)
        ;;
    *)
        case "$prev" in
        -m|-F)
            ;;
        *)
            __gitcomp_nl "$(__git_refs)"
            ;;
        esac
        ;;
    esac
}

_git_pull ()
{
    __git_complete_strategy && return

    case "$cur" in
    --recurse-submodules=*)
        __gitcomp "$__git_fetch_recurse_submodules" "" "${cur##--recurse-submodules=}"
        return
        ;;
    --*)
        __gitcomp "
            --rebase --no-rebase
            $__git_merge_options
            $__git_fetch_options
        "
        return
        ;;
    esac
    __git_complete_remote_or_refspec
}

__git_push_recurse_submodules="check on-demand"

__git_complete_force_with_lease ()
{
    local cur_=$1

    case "$cur_" in
    --*=)
        ;;
    *:*)
        __gitcomp_nl "$(__git_refs)" "" "${cur_#*:}"
        ;;
    *)
        __gitcomp_nl "$(__git_refs)" "" "$cur_"
        ;;
    esac
}

_git_push ()
{
    case "$prev" in
    --repo)
        __gitcomp_nl "$(__git_remotes)"
        return
        ;;
    --recurse-submodules)
        __gitcomp "$__git_push_recurse_submodules"
        return
        ;;
    esac
    case "$cur" in
    --repo=*)
        __gitcomp_nl "$(__git_remotes)" "" "${cur##--repo=}"
        return
        ;;
    --recurse-submodules=*)
        __gitcomp "$__git_push_recurse_submodules" "" "${cur##--recurse-submodules=}"
        return
        ;;
    --force-with-lease=*)
        __git_complete_force_with_lease "${cur##--force-with-lease=}"
        return
        ;;
    --*)
        __gitcomp "
            --all --mirror --tags --dry-run --force --verbose
            --quiet --prune --delete --follow-tags
            --receive-pack= --repo= --set-upstream
            --force-with-lease --force-with-lease= --recurse-submodules=
        "
        return
        ;;
    esac
    __git_complete_remote_or_refspec
}

_git_rebase ()
{
    local dir="$(__gitdir)"
    if [ -d "$dir"/rebase-apply ] || [ -d "$dir"/rebase-merge ]; then
        __gitcomp "--continue --skip --abort"
        return
    fi
    __git_complete_strategy && return
    case "$cur" in
    --whitespace=*)
        __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
        return
        ;;
    --*)
        __gitcomp "
            --onto --merge --strategy --interactive
            --preserve-merges --stat --no-stat
            --committer-date-is-author-date --ignore-date
            --ignore-whitespace --whitespace=
            --autosquash --fork-point --no-fork-point
            --autostash
            "

        return
    esac
    __gitcomp_nl "$(__git_refs)"
}

_git_reflog ()
{
    local subcommands="show delete expire"
    local subcommand="$(__git_find_on_cmdline "$subcommands")"

    if [ -z "$subcommand" ]; then
        __gitcomp "$subcommands"
    else
        __gitcomp_nl "$(__git_refs)"
    fi
}

__git_send_email_confirm_options="always never auto cc compose"
__git_send_email_suppresscc_options="author self cc bodycc sob cccmd body all"

_git_send_email ()
{
    case "$cur" in
    --confirm=*)
        __gitcomp "
            $__git_send_email_confirm_options
            " "" "${cur##--confirm=}"
        return
        ;;
    --suppress-cc=*)
        __gitcomp "
            $__git_send_email_suppresscc_options
            " "" "${cur##--suppress-cc=}"

        return
        ;;
    --smtp-encryption=*)
        __gitcomp "ssl tls" "" "${cur##--smtp-encryption=}"
        return
        ;;
    --thread=*)
        __gitcomp "
            deep shallow
            " "" "${cur##--thread=}"
        return
        ;;
    --*)
        __gitcomp "--annotate --bcc --cc --cc-cmd --chain-reply-to
            --compose --confirm= --dry-run --envelope-sender
            --from --identity
            --in-reply-to --no-chain-reply-to --no-signed-off-by-cc
            --no-suppress-from --no-thread --quiet
            --signed-off-by-cc --smtp-pass --smtp-server
            --smtp-server-port --smtp-encryption= --smtp-user
            --subject --suppress-cc= --suppress-from --thread --to
            --validate --no-validate
            $__git_format_patch_options"
        return
        ;;
    esac
    __git_complete_revlist
}

_git_stage ()
{
    _git_add
}

__git_config_get_set_variables ()
{
    local prevword word config_file= c=$cword
    while [ $c -gt 1 ]; do
        word="${words[c]}"
        case "$word" in
        --system|--global|--local|--file=*)
            config_file="$word"
            break
            ;;
        -f|--file)
            config_file="$word $prevword"
            break
            ;;
        esac
        prevword=$word
        c=$((--c))
    done

    git --git-dir="$(__gitdir)" config $config_file --list 2>/dev/null |
    while read -r line
    do
        case "$line" in
        *.*=*)
            echo "${line/=*/}"
            ;;
        esac
    done
}

_git_config ()
{
    case "$prev" in
    branch.*.remote|branch.*.pushremote)
        __gitcomp_nl "$(__git_remotes)"
        return
        ;;
    branch.*.merge)
        __gitcomp_nl "$(__git_refs)"
        return
        ;;
    branch.*.rebase)
        __gitcomp "false true"
        return
        ;;
    remote.pushdefault)
        __gitcomp_nl "$(__git_remotes)"
        return
        ;;
    remote.*.fetch)
        local remote="${prev#remote.}"
        remote="${remote%.fetch}"
        if [ -z "$cur" ]; then
            __gitcomp_nl "refs/heads/" "" "" ""
            return
        fi
        __gitcomp_nl "$(__git_refs_remotes "$remote")"
        return
        ;;
    remote.*.push)
        local remote="${prev#remote.}"
        remote="${remote%.push}"
        __gitcomp_nl "$(git --git-dir="$(__gitdir)" \
            for-each-ref --format='%(refname):%(refname)' \
            refs/heads)"
        return
        ;;
    pull.twohead|pull.octopus)
        __git_compute_merge_strategies
        __gitcomp "$__git_merge_strategies"
        return
        ;;
    color.branch|color.diff|color.interactive|\
    color.showbranch|color.status|color.ui)
        __gitcomp "always never auto"
        return
        ;;
    color.pager)
        __gitcomp "false true"
        return
        ;;
    color.*.*)
        __gitcomp "
            normal black red green yellow blue magenta cyan white
            bold dim ul blink reverse
            "
        return
        ;;
    diff.submodule)
        __gitcomp "log short"
        return
        ;;
    help.format)
        __gitcomp "man info web html"
        return
        ;;
    log.date)
        __gitcomp "$__git_log_date_formats"
        return
        ;;
    sendemail.aliasesfiletype)
        __gitcomp "mutt mailrc pine elm gnus"
        return
        ;;
    sendemail.confirm)
        __gitcomp "$__git_send_email_confirm_options"
        return
        ;;
    sendemail.suppresscc)
        __gitcomp "$__git_send_email_suppresscc_options"
        return
        ;;
    sendemail.transferencoding)
        __gitcomp "7bit 8bit quoted-printable base64"
        return
        ;;
    --get|--get-all|--unset|--unset-all)
        __gitcomp_nl "$(__git_config_get_set_variables)"
        return
        ;;
    *.*)
        return
        ;;
    esac
    case "$cur" in
    --*)
        __gitcomp "
            --system --global --local --file=
            --list --replace-all
            --get --get-all --get-regexp
            --add --unset --unset-all
            --remove-section --rename-section
            "
        return
        ;;
    branch.*.*)
        local pfx="${cur%.*}." cur_="${cur##*.}"
        __gitcomp "remote pushremote merge mergeoptions rebase" "$pfx" "$cur_"
        return
        ;;
    branch.*)
        local pfx="${cur%.*}." cur_="${cur#*.}"
        __gitcomp_nl "$(__git_heads)" "$pfx" "$cur_" "."
        __gitcomp_nl_append $'autosetupmerge\nautosetuprebase\n' "$pfx" "$cur_"
        return
        ;;
    guitool.*.*)
        local pfx="${cur%.*}." cur_="${cur##*.}"
        __gitcomp "
            argprompt cmd confirm needsfile noconsole norescan
            prompt revprompt revunmerged title
            " "$pfx" "$cur_"
        return
        ;;
    difftool.*.*)
        local pfx="${cur%.*}." cur_="${cur##*.}"
        __gitcomp "cmd path" "$pfx" "$cur_"
        return
        ;;
    man.*.*)
        local pfx="${cur%.*}." cur_="${cur##*.}"
        __gitcomp "cmd path" "$pfx" "$cur_"
        return
        ;;
    mergetool.*.*)
        local pfx="${cur%.*}." cur_="${cur##*.}"
        __gitcomp "cmd path trustExitCode" "$pfx" "$cur_"
        return
        ;;
    pager.*)
        local pfx="${cur%.*}." cur_="${cur#*.}"
        __git_compute_all_commands
        __gitcomp_nl "$__git_all_commands" "$pfx" "$cur_"
        return
        ;;
    remote.*.*)
        local pfx="${cur%.*}." cur_="${cur##*.}"
        __gitcomp "
            url proxy fetch push mirror skipDefaultUpdate
            receivepack uploadpack tagopt pushurl
            " "$pfx" "$cur_"
        return
        ;;
    remote.*)
        local pfx="${cur%.*}." cur_="${cur#*.}"
        __gitcomp_nl "$(__git_remotes)" "$pfx" "$cur_" "."
        __gitcomp_nl_append "pushdefault" "$pfx" "$cur_"
        return
        ;;
    url.*.*)
        local pfx="${cur%.*}." cur_="${cur##*.}"
        __gitcomp "insteadOf pushInsteadOf" "$pfx" "$cur_"
        return
        ;;
    esac
    __gitcomp "
        add.ignoreErrors
        advice.commitBeforeMerge
        advice.detachedHead
        advice.implicitIdentity
        advice.pushNonFastForward
        advice.resolveConflict
        advice.statusHints
        alias.
        am.keepcr
        apply.ignorewhitespace
        apply.whitespace
        branch.autosetupmerge
        branch.autosetuprebase
        browser.
        clean.requireForce
        color.branch
        color.branch.current
        color.branch.local
        color.branch.plain
        color.branch.remote
        color.decorate.HEAD
        color.decorate.branch
        color.decorate.remoteBranch
        color.decorate.stash
        color.decorate.tag
        color.diff
        color.diff.commit
        color.diff.frag
        color.diff.func
        color.diff.meta
        color.diff.new
        color.diff.old
        color.diff.plain
        color.diff.whitespace
        color.grep
        color.grep.context
        color.grep.filename
        color.grep.function
        color.grep.linenumber
        color.grep.match
        color.grep.selected
        color.grep.separator
        color.interactive
        color.interactive.error
        color.interactive.header
        color.interactive.help
        color.interactive.prompt
        color.pager
        color.showbranch
        color.status
        color.status.added
        color.status.changed
        color.status.header
        color.status.nobranch
        color.status.untracked
        color.status.updated
        color.ui
        commit.status
        commit.template
        core.abbrev
        core.askpass
        core.attributesfile
        core.autocrlf
        core.bare
        core.bigFileThreshold
        core.compression
        core.createObject
        core.deltaBaseCacheLimit
        core.editor
        core.eol
        core.excludesfile
        core.fileMode
        core.fsyncobjectfiles
        core.gitProxy
        core.ignoreStat
        core.ignorecase
        core.logAllRefUpdates
        core.loosecompression
        core.notesRef
        core.packedGitLimit
        core.packedGitWindowSize
        core.pager
        core.preferSymlinkRefs
        core.preloadindex
        core.quotepath
        core.repositoryFormatVersion
        core.safecrlf
        core.sharedRepository
        core.sparseCheckout
        core.symlinks
        core.trustctime
        core.warnAmbiguousRefs
        core.whitespace
        core.worktree
        diff.autorefreshindex
        diff.external
        diff.ignoreSubmodules
        diff.mnemonicprefix
        diff.noprefix
        diff.renameLimit
        diff.renames
        diff.statGraphWidth
        diff.submodule
        diff.suppressBlankEmpty
        diff.tool
        diff.wordRegex
        diff.algorithm
        difftool.
        difftool.prompt
        fetch.recurseSubmodules
        fetch.unpackLimit
        format.attach
        format.cc
        format.coverLetter
        format.headers
        format.numbered
        format.pretty
        format.signature
        format.signoff
        format.subjectprefix
        format.suffix
        format.thread
        format.to
        gc.
        gc.aggressiveWindow
        gc.auto
        gc.autopacklimit
        gc.packrefs
        gc.pruneexpire
        gc.reflogexpire
        gc.reflogexpireunreachable
        gc.rerereresolved
        gc.rerereunresolved
        gitcvs.allbinary
        gitcvs.commitmsgannotation
        gitcvs.dbTableNamePrefix
        gitcvs.dbdriver
        gitcvs.dbname
        gitcvs.dbpass
        gitcvs.dbuser
        gitcvs.enabled
        gitcvs.logfile
        gitcvs.usecrlfattr
        guitool.
        gui.blamehistoryctx
        gui.commitmsgwidth
        gui.copyblamethreshold
        gui.diffcontext
        gui.encoding
        gui.fastcopyblame
        gui.matchtrackingbranch
        gui.newbranchtemplate
        gui.pruneduringfetch
        gui.spellingdictionary
        gui.trustmtime
        help.autocorrect
        help.browser
        help.format
        http.lowSpeedLimit
        http.lowSpeedTime
        http.maxRequests
        http.minSessions
        http.noEPSV
        http.postBuffer
        http.proxy
        http.sslCAInfo
        http.sslCAPath
        http.sslCert
        http.sslCertPasswordProtected
        http.sslKey
        http.sslVerify
        http.useragent
        i18n.commitEncoding
        i18n.logOutputEncoding
        imap.authMethod
        imap.folder
        imap.host
        imap.pass
        imap.port
        imap.preformattedHTML
        imap.sslverify
        imap.tunnel
        imap.user
        init.templatedir
        instaweb.browser
        instaweb.httpd
        instaweb.local
        instaweb.modulepath
        instaweb.port
        interactive.singlekey
        log.date
        log.decorate
        log.showroot
        mailmap.file
        man.
        man.viewer
        merge.
        merge.conflictstyle
        merge.log
        merge.renameLimit
        merge.renormalize
        merge.stat
        merge.tool
        merge.verbosity
        mergetool.
        mergetool.keepBackup
        mergetool.keepTemporaries
        mergetool.prompt
        notes.displayRef
        notes.rewrite.
        notes.rewrite.amend
        notes.rewrite.rebase
        notes.rewriteMode
        notes.rewriteRef
        pack.compression
        pack.deltaCacheLimit
        pack.deltaCacheSize
        pack.depth
        pack.indexVersion
        pack.packSizeLimit
        pack.threads
        pack.window
        pack.windowMemory
        pager.
        pretty.
        pull.octopus
        pull.twohead
        push.default
        rebase.autosquash
        rebase.stat
        receive.autogc
        receive.denyCurrentBranch
        receive.denyDeleteCurrent
        receive.denyDeletes
        receive.denyNonFastForwards
        receive.fsckObjects
        receive.unpackLimit
        receive.updateserverinfo
        remote.pushdefault
        remotes.
        repack.usedeltabaseoffset
        rerere.autoupdate
        rerere.enabled
        sendemail.
        sendemail.aliasesfile
        sendemail.aliasfiletype
        sendemail.bcc
        sendemail.cc
        sendemail.cccmd
        sendemail.chainreplyto
        sendemail.confirm
        sendemail.envelopesender
        sendemail.from
        sendemail.identity
        sendemail.multiedit
        sendemail.signedoffbycc
        sendemail.smtpdomain
        sendemail.smtpencryption
        sendemail.smtppass
        sendemail.smtpserver
        sendemail.smtpserveroption
        sendemail.smtpserverport
        sendemail.smtpuser
        sendemail.suppresscc
        sendemail.suppressfrom
        sendemail.thread
        sendemail.to
        sendemail.validate
        showbranch.default
        status.relativePaths
        status.showUntrackedFiles
        status.submodulesummary
        submodule.
        tar.umask
        transfer.unpackLimit
        url.
        user.email
        user.name
        user.signingkey
        web.browser
        branch. remote.
    "
}

_git_remote ()
{
    local subcommands="add rename remove set-head set-branches set-url show prune update"
    local subcommand="$(__git_find_on_cmdline "$subcommands")"
    if [ -z "$subcommand" ]; then
        __gitcomp "$subcommands"
        return
    fi

    case "$subcommand" in
    rename|remove|set-url|show|prune)
        __gitcomp_nl "$(__git_remotes)"
        ;;
    set-head|set-branches)
        __git_complete_remote_or_refspec
        ;;
    update)
        local i c='' IFS=$'\n'
        for i in $(git --git-dir="$(__gitdir)" config --get-regexp "remotes\..*" 2>/dev/null); do
            i="${i#remotes.}"
            c="$c ${i/ */}"
        done
        __gitcomp "$c"
        ;;
    *)
        ;;
    esac
}

_git_replace ()
{
    __gitcomp_nl "$(__git_refs)"
}

_git_reset ()
{
    __git_has_doubledash && return

    case "$cur" in
    --*)
        __gitcomp "--merge --mixed --hard --soft --patch"
        return
        ;;
    esac
    __gitcomp_nl "$(__git_refs)"
}

_git_revert ()
{
    case "$cur" in
    --*)
        __gitcomp "--edit --mainline --no-edit --no-commit --signoff"
        return
        ;;
    esac
    __gitcomp_nl "$(__git_refs)"
}

_git_rm ()
{
    case "$cur" in
    --*)
        __gitcomp "--cached --dry-run --ignore-unmatch --quiet"
        return
        ;;
    esac

    __git_complete_index_file "--cached"
}

_git_shortlog ()
{
    __git_has_doubledash && return

    case "$cur" in
    --*)
        __gitcomp "
            $__git_log_common_options
            $__git_log_shortlog_options
            --numbered --summary
            "
        return
        ;;
    esac
    __git_complete_revlist
}

_git_show ()
{
    __git_has_doubledash && return

    case "$cur" in
    --pretty=*|--format=*)
        __gitcomp "$__git_log_pretty_formats $(__git_pretty_aliases)
            " "" "${cur#*=}"
        return
        ;;
    --diff-algorithm=*)
        __gitcomp "$__git_diff_algorithms" "" "${cur##--diff-algorithm=}"
        return
        ;;
    --*)
        __gitcomp "--pretty= --format= --abbrev-commit --oneline
            --show-signature
            $__git_diff_common_options
            "
        return
        ;;
    esac
    __git_complete_revlist_file
}

_git_show_branch ()
{
    case "$cur" in
    --*)
        __gitcomp "
            --all --remotes --topo-order --current --more=
            --list --independent --merge-base --no-name
            --color --no-color
            --sha1-name --sparse --topics --reflog
            "
        return
        ;;
    esac
    __git_complete_revlist
}

_git_stash ()
{
    local save_opts='--keep-index --no-keep-index --quiet --patch'
    local subcommands='save list show apply clear drop pop create branch'
    local subcommand="$(__git_find_on_cmdline "$subcommands")"
    if [ -z "$subcommand" ]; then
        case "$cur" in
        --*)
            __gitcomp "$save_opts"
            ;;
        *)
            if [ -z "$(__git_find_on_cmdline "$save_opts")" ]; then
                __gitcomp "$subcommands"
            fi
            ;;
        esac
    else
        case "$subcommand,$cur" in
        save,--*)
            __gitcomp "$save_opts"
            ;;
        apply,--*|pop,--*)
            __gitcomp "--index --quiet"
            ;;
        show,--*|drop,--*|branch,--*)
            ;;
        show,*|apply,*|drop,*|pop,*|branch,*)
            __gitcomp_nl "$(git --git-dir="$(__gitdir)" stash list \
                    | sed -n -e 's/:.*//p')"
            ;;
        *)
            ;;
        esac
    fi
}

_git_submodule ()
{
    __git_has_doubledash && return

    local subcommands="add status init deinit update summary foreach sync"
    if [ -z "$(__git_find_on_cmdline "$subcommands")" ]; then
        case "$cur" in
        --*)
            __gitcomp "--quiet --cached"
            ;;
        *)
            __gitcomp "$subcommands"
            ;;
        esac
        return
    fi
}

_git_svn ()
{
    local subcommands="
        init fetch clone rebase dcommit log find-rev
        set-tree commit-diff info create-ignore propget
        proplist show-ignore show-externals branch tag blame
        migrate mkdirs reset gc
        "
    local subcommand="$(__git_find_on_cmdline "$subcommands")"
    if [ -z "$subcommand" ]; then
        __gitcomp "$subcommands"
    else
        local remote_opts="--username= --config-dir= --no-auth-cache"
        local fc_opts="
            --follow-parent --authors-file= --repack=
            --no-metadata --use-svm-props --use-svnsync-props
            --log-window-size= --no-checkout --quiet
            --repack-flags --use-log-author --localtime
            --ignore-paths= --include-paths= $remote_opts
            "
        local init_opts="
            --template= --shared= --trunk= --tags=
            --branches= --stdlayout --minimize-url
            --no-metadata --use-svm-props --use-svnsync-props
            --rewrite-root= --prefix= --use-log-author
            --add-author-from $remote_opts
            "
        local cmt_opts="
            --edit --rmdir --find-copies-harder --copy-similarity=
            "

        case "$subcommand,$cur" in
        fetch,--*)
            __gitcomp "--revision= --fetch-all $fc_opts"
            ;;
        clone,--*)
            __gitcomp "--revision= $fc_opts $init_opts"
            ;;
        init,--*)
            __gitcomp "$init_opts"
            ;;
        dcommit,--*)
            __gitcomp "
                --merge --strategy= --verbose --dry-run
                --fetch-all --no-rebase --commit-url
                --revision --interactive $cmt_opts $fc_opts
                "
            ;;
        set-tree,--*)
            __gitcomp "--stdin $cmt_opts $fc_opts"
            ;;
        create-ignore,--*|propget,--*|proplist,--*|show-ignore,--*|\
        show-externals,--*|mkdirs,--*)
            __gitcomp "--revision="
            ;;
        log,--*)
            __gitcomp "
                --limit= --revision= --verbose --incremental
                --oneline --show-commit --non-recursive
                --authors-file= --color
                "
            ;;
        rebase,--*)
            __gitcomp "
                --merge --verbose --strategy= --local
                --fetch-all --dry-run $fc_opts
                "
            ;;
        commit-diff,--*)
            __gitcomp "--message= --file= --revision= $cmt_opts"
            ;;
        info,--*)
            __gitcomp "--url"
            ;;
        branch,--*)
            __gitcomp "--dry-run --message --tag"
            ;;
        tag,--*)
            __gitcomp "--dry-run --message"
            ;;
        blame,--*)
            __gitcomp "--git-format"
            ;;
        migrate,--*)
            __gitcomp "
                --config-dir= --ignore-paths= --minimize
                --no-auth-cache --username=
                "
            ;;
        reset,--*)
            __gitcomp "--revision= --parent"
            ;;
        *)
            ;;
        esac
    fi
}

_git_tag ()
{
    local i c=1 f=0
    while [ $c -lt $cword ]; do
        i="${words[c]}"
        case "$i" in
        -d|-v)
            __gitcomp_nl "$(__git_tags)"
            return
            ;;
        -f)
            f=1
            ;;
        esac
        ((c++))
    done

    case "$prev" in
    -m|-F)
        ;;
    -*|tag)
        if [ $f = 1 ]; then
            __gitcomp_nl "$(__git_tags)"
        fi
        ;;
    *)
        __gitcomp_nl "$(__git_refs)"
        ;;
    esac

    case "$cur" in
    --*)
        __gitcomp "
            --list --delete --verify --annotate --message --file
            --sign --cleanup --local-user --force --column --sort
            --contains --points-at
            "
        ;;
    esac
}

_git_whatchanged ()
{
    _git_log
}

__git_main ()
{
    local i c=1 command __git_dir

    while [ $c -lt $cword ]; do
        i="${words[c]}"
        case "$i" in
        --git-dir=*) __git_dir="${i#--git-dir=}" ;;
        --git-dir)   ((c++)) ; __git_dir="${words[c]}" ;;
        --bare)      __git_dir="." ;;
        --help) command="help"; break ;;
        -c|--work-tree|--namespace) ((c++)) ;;
        -*) ;;
        *) command="$i"; break ;;
        esac
        ((c++))
    done

    if [ -z "$command" ]; then
        case "$cur" in
        --*)   __gitcomp "
            --paginate
            --no-pager
            --git-dir=
            --bare
            --version
            --exec-path
            --exec-path=
            --html-path
            --man-path
            --info-path
            --work-tree=
            --namespace=
            --no-replace-objects
            --help
            "
            ;;
        *)     __git_compute_porcelain_commands
               __gitcomp "$__git_porcelain_commands $(__git_aliases)" ;;
        esac
        return
    fi

    local completion_func="_git_${command//-/_}"
    declare -f $completion_func >/dev/null && $completion_func && return

    local expansion=$(__git_aliased_command "$command")
    if [ -n "$expansion" ]; then
        words[1]=$expansion
        completion_func="_git_${expansion//-/_}"
        declare -f $completion_func >/dev/null && $completion_func
    fi
}

__gitk_main ()
{
    __git_has_doubledash && return

    local g="$(__gitdir)"
    local merge=""
    if [ -f "$g/MERGE_HEAD" ]; then
        merge="--merge"
    fi
    case "$cur" in
    --*)
        __gitcomp "
            $__git_log_common_options
            $__git_log_gitk_options
            $merge
            "
        return
        ;;
    esac
    __git_complete_revlist
}

if [[ -n ${ZSH_VERSION-} ]]; then
    echo "WARNING: this script is deprecated, please see git-completion.zsh" 1>&2

    autoload -U +X compinit && compinit

    __gitcomp ()
    {
        emulate -L zsh

        local cur_="${3-$cur}"

        case "$cur_" in
        --*=)
            ;;
        *)
            local c IFS=$' \t\n'
            local -a array
            for c in ${=1}; do
                c="$c${4-}"
                case $c in
                --*=*|*.) ;;
                *) c="$c " ;;
                esac
                array[${#array[@]}+1]="$c"
            done
            compset -P '*[=:]'
            compadd -Q -S '' -p "${2-}" -a -- array && _ret=0
            ;;
        esac
    }

    __gitcomp_nl ()
    {
        emulate -L zsh

        local IFS=$'\n'
        compset -P '*[=:]'
        compadd -Q -S "${4- }" -p "${2-}" -- ${=1} && _ret=0
    }

    __gitcomp_file ()
    {
        emulate -L zsh

        local IFS=$'\n'
        compset -P '*[=:]'
        compadd -Q -p "${2-}" -f -- ${=1} && _ret=0
    }

    _git ()
    {
        local _ret=1 cur cword prev
        cur=${words[CURRENT]}
        prev=${words[CURRENT-1]}
        let cword=CURRENT-1
        emulate ksh -c __${service}_main
        let _ret && _default && _ret=0
        return _ret
    }

    compdef _git git gitk
    return
fi

__git_func_wrap ()
{
    local cur words cword prev
    _get_comp_words_by_ref -n =: cur words cword prev
    $1
}

# Setup completion for certain functions defined above by setting common
# variables and workarounds.
# This is NOT a public function; use at your own risk.
__git_complete ()
{
    local wrapper="__git_wrap${2}"
    eval "$wrapper () { __git_func_wrap $2 ; }"
    complete -o bashdefault -o default -o nospace -F $wrapper $1 2>/dev/null \
        || complete -o default -o nospace -F $wrapper $1
}

# wrapper for backwards compatibility
_git ()
{
    __git_wrap__git_main
}

# wrapper for backwards compatibility
_gitk ()
{
    __git_wrap__gitk_main
}

__git_complete git __git_main
__git_complete gitk __gitk_main

# The following are necessary only for Cygwin, and only are needed
# when the user has tab-completed the executable name and consequently
# included the '.exe' suffix.
#
if [ Cygwin = "$(uname -o 2>/dev/null)" ]; then
__git_complete git.exe __git_main
fi