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