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