git.oblomov.eu Git - git/blob - contrib/completion/git-completion.bash

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