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