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