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_builtin apply
1138                 return
1139         esac
1140 }
1141
1142 _git_add ()
1143 {
1144         case "$cur" in
1145         --*)
1146                 __gitcomp_builtin add
1147                 return
1148         esac
1149
1150         local complete_opt="--others --modified --directory --no-empty-directory"
1151         if test -n "$(__git_find_on_cmdline "-u --update")"
1152         then
1153                 complete_opt="--modified"
1154         fi
1155         __git_complete_index_file "$complete_opt"
1156 }
1157
1158 _git_archive ()
1159 {
1160         case "$cur" in
1161         --format=*)
1162                 __gitcomp "$(git archive --list)" "" "${cur##--format=}"
1163                 return
1164                 ;;
1165         --remote=*)
1166                 __gitcomp_nl "$(__git_remotes)" "" "${cur##--remote=}"
1167                 return
1168                 ;;
1169         --*)
1170                 __gitcomp "
1171                         --format= --list --verbose
1172                         --prefix= --remote= --exec= --output
1173                         "
1174                 return
1175                 ;;
1176         esac
1177         __git_complete_file
1178 }
1179
1180 _git_bisect ()
1181 {
1182         __git_has_doubledash && return
1183
1184         local subcommands="start bad good skip reset visualize replay log run"
1185         local subcommand="$(__git_find_on_cmdline "$subcommands")"
1186         if [ -z "$subcommand" ]; then
1187                 __git_find_repo_path
1188                 if [ -f "$__git_repo_path"/BISECT_START ]; then
1189                         __gitcomp "$subcommands"
1190                 else
1191                         __gitcomp "replay start"
1192                 fi
1193                 return
1194         fi
1195
1196         case "$subcommand" in
1197         bad|good|reset|skip|start)
1198                 __git_complete_refs
1199                 ;;
1200         *)
1201                 ;;
1202         esac
1203 }
1204
1205 _git_branch ()
1206 {
1207         local i c=1 only_local_ref="n" has_r="n"
1208
1209         while [ $c -lt $cword ]; do
1210                 i="${words[c]}"
1211                 case "$i" in
1212                 -d|--delete|-m|--move)  only_local_ref="y" ;;
1213                 -r|--remotes)           has_r="y" ;;
1214                 esac
1215                 ((c++))
1216         done
1217
1218         case "$cur" in
1219         --set-upstream-to=*)
1220                 __git_complete_refs --cur="${cur##--set-upstream-to=}"
1221                 ;;
1222         --*)
1223                 __gitcomp_builtin branch "--no-color --no-abbrev
1224                         --no-track --no-column
1225                         "
1226                 ;;
1227         *)
1228                 if [ $only_local_ref = "y" -a $has_r = "n" ]; then
1229                         __gitcomp_direct "$(__git_heads "" "$cur" " ")"
1230                 else
1231                         __git_complete_refs
1232                 fi
1233                 ;;
1234         esac
1235 }
1236
1237 _git_bundle ()
1238 {
1239         local cmd="${words[2]}"
1240         case "$cword" in
1241         2)
1242                 __gitcomp "create list-heads verify unbundle"
1243                 ;;
1244         3)
1245                 # looking for a file
1246                 ;;
1247         *)
1248                 case "$cmd" in
1249                         create)
1250                                 __git_complete_revlist
1251                         ;;
1252                 esac
1253                 ;;
1254         esac
1255 }
1256
1257 _git_checkout ()
1258 {
1259         __git_has_doubledash && return
1260
1261         case "$cur" in
1262         --conflict=*)
1263                 __gitcomp "diff3 merge" "" "${cur##--conflict=}"
1264                 ;;
1265         --*)
1266                 __gitcomp_builtin checkout "--no-track --no-recurse-submodules"
1267                 ;;
1268         *)
1269                 # check if --track, --no-track, or --no-guess was specified
1270                 # if so, disable DWIM mode
1271                 local flags="--track --no-track --no-guess" track_opt="--track"
1272                 if [ "$GIT_COMPLETION_CHECKOUT_NO_GUESS" = "1" ] ||
1273                    [ -n "$(__git_find_on_cmdline "$flags")" ]; then
1274                         track_opt=''
1275                 fi
1276                 __git_complete_refs $track_opt
1277                 ;;
1278         esac
1279 }
1280
1281 _git_cherry ()
1282 {
1283         __git_complete_refs
1284 }
1285
1286 _git_cherry_pick ()
1287 {
1288         __git_find_repo_path
1289         if [ -f "$__git_repo_path"/CHERRY_PICK_HEAD ]; then
1290                 __gitcomp "--continue --quit --abort"
1291                 return
1292         fi
1293         case "$cur" in
1294         --*)
1295                 __gitcomp "--edit --no-commit --signoff --strategy= --mainline"
1296                 ;;
1297         *)
1298                 __git_complete_refs
1299                 ;;
1300         esac
1301 }
1302
1303 _git_clean ()
1304 {
1305         case "$cur" in
1306         --*)
1307                 __gitcomp "--dry-run --quiet"
1308                 return
1309                 ;;
1310         esac
1311
1312         # XXX should we check for -x option ?
1313         __git_complete_index_file "--others --directory"
1314 }
1315
1316 _git_clone ()
1317 {
1318         case "$cur" in
1319         --*)
1320                 __gitcomp "
1321                         --local
1322                         --no-hardlinks
1323                         --shared
1324                         --reference
1325                         --quiet
1326                         --no-checkout
1327                         --bare
1328                         --mirror
1329                         --origin
1330                         --upload-pack
1331                         --template=
1332                         --depth
1333                         --single-branch
1334                         --no-tags
1335                         --branch
1336                         --recurse-submodules
1337                         --no-single-branch
1338                         --shallow-submodules
1339                         "
1340                 return
1341                 ;;
1342         esac
1343 }
1344
1345 __git_untracked_file_modes="all no normal"
1346
1347 _git_commit ()
1348 {
1349         case "$prev" in
1350         -c|-C)
1351                 __git_complete_refs
1352                 return
1353                 ;;
1354         esac
1355
1356         case "$cur" in
1357         --cleanup=*)
1358                 __gitcomp "default scissors strip verbatim whitespace
1359                         " "" "${cur##--cleanup=}"
1360                 return
1361                 ;;
1362         --reuse-message=*|--reedit-message=*|\
1363         --fixup=*|--squash=*)
1364                 __git_complete_refs --cur="${cur#*=}"
1365                 return
1366                 ;;
1367         --untracked-files=*)
1368                 __gitcomp "$__git_untracked_file_modes" "" "${cur##--untracked-files=}"
1369                 return
1370                 ;;
1371         --*)
1372                 __gitcomp "
1373                         --all --author= --signoff --verify --no-verify
1374                         --edit --no-edit
1375                         --amend --include --only --interactive
1376                         --dry-run --reuse-message= --reedit-message=
1377                         --reset-author --file= --message= --template=
1378                         --cleanup= --untracked-files --untracked-files=
1379                         --verbose --quiet --fixup= --squash=
1380                         --patch --short --date --allow-empty
1381                         "
1382                 return
1383         esac
1384
1385         if __git rev-parse --verify --quiet HEAD >/dev/null; then
1386                 __git_complete_index_file "--committable"
1387         else
1388                 # This is the first commit
1389                 __git_complete_index_file "--cached"
1390         fi
1391 }
1392
1393 _git_describe ()
1394 {
1395         case "$cur" in
1396         --*)
1397                 __gitcomp "
1398                         --all --tags --contains --abbrev= --candidates=
1399                         --exact-match --debug --long --match --always --first-parent
1400                         --exclude --dirty --broken
1401                         "
1402                 return
1403         esac
1404         __git_complete_refs
1405 }
1406
1407 __git_diff_algorithms="myers minimal patience histogram"
1408
1409 __git_diff_submodule_formats="diff log short"
1410
1411 __git_diff_common_options="--stat --numstat --shortstat --summary
1412                         --patch-with-stat --name-only --name-status --color
1413                         --no-color --color-words --no-renames --check
1414                         --full-index --binary --abbrev --diff-filter=
1415                         --find-copies-harder --ignore-cr-at-eol
1416                         --text --ignore-space-at-eol --ignore-space-change
1417                         --ignore-all-space --ignore-blank-lines --exit-code
1418                         --quiet --ext-diff --no-ext-diff
1419                         --no-prefix --src-prefix= --dst-prefix=
1420                         --inter-hunk-context=
1421                         --patience --histogram --minimal
1422                         --raw --word-diff --word-diff-regex=
1423                         --dirstat --dirstat= --dirstat-by-file
1424                         --dirstat-by-file= --cumulative
1425                         --diff-algorithm=
1426                         --submodule --submodule=
1427 "
1428
1429 _git_diff ()
1430 {
1431         __git_has_doubledash && return
1432
1433         case "$cur" in
1434         --diff-algorithm=*)
1435                 __gitcomp "$__git_diff_algorithms" "" "${cur##--diff-algorithm=}"
1436                 return
1437                 ;;
1438         --submodule=*)
1439                 __gitcomp "$__git_diff_submodule_formats" "" "${cur##--submodule=}"
1440                 return
1441                 ;;
1442         --*)
1443                 __gitcomp "--cached --staged --pickaxe-all --pickaxe-regex
1444                         --base --ours --theirs --no-index
1445                         $__git_diff_common_options
1446                         "
1447                 return
1448                 ;;
1449         esac
1450         __git_complete_revlist_file
1451 }
1452
1453 __git_mergetools_common="diffuse diffmerge ecmerge emerge kdiff3 meld opendiff
1454                         tkdiff vimdiff gvimdiff xxdiff araxis p4merge bc codecompare
1455 "
1456
1457 _git_difftool ()
1458 {
1459         __git_has_doubledash && return
1460
1461         case "$cur" in
1462         --tool=*)
1463                 __gitcomp "$__git_mergetools_common kompare" "" "${cur##--tool=}"
1464                 return
1465                 ;;
1466         --*)
1467                 __gitcomp "--cached --staged --pickaxe-all --pickaxe-regex
1468                         --base --ours --theirs
1469                         --no-renames --diff-filter= --find-copies-harder
1470                         --relative --ignore-submodules
1471                         --tool="
1472                 return
1473                 ;;
1474         esac
1475         __git_complete_revlist_file
1476 }
1477
1478 __git_fetch_recurse_submodules="yes on-demand no"
1479
1480 __git_fetch_options="
1481         --quiet --verbose --append --upload-pack --force --keep --depth=
1482         --tags --no-tags --all --prune --dry-run --recurse-submodules=
1483         --unshallow --update-shallow
1484 "
1485
1486 _git_fetch ()
1487 {
1488         case "$cur" in
1489         --recurse-submodules=*)
1490                 __gitcomp "$__git_fetch_recurse_submodules" "" "${cur##--recurse-submodules=}"
1491                 return
1492                 ;;
1493         --*)
1494                 __gitcomp "$__git_fetch_options"
1495                 return
1496                 ;;
1497         esac
1498         __git_complete_remote_or_refspec
1499 }
1500
1501 __git_format_patch_options="
1502         --stdout --attach --no-attach --thread --thread= --no-thread
1503         --numbered --start-number --numbered-files --keep-subject --signoff
1504         --signature --no-signature --in-reply-to= --cc= --full-index --binary
1505         --not --all --cover-letter --no-prefix --src-prefix= --dst-prefix=
1506         --inline --suffix= --ignore-if-in-upstream --subject-prefix=
1507         --output-directory --reroll-count --to= --quiet --notes
1508 "
1509
1510 _git_format_patch ()
1511 {
1512         case "$cur" in
1513         --thread=*)
1514                 __gitcomp "
1515                         deep shallow
1516                         " "" "${cur##--thread=}"
1517                 return
1518                 ;;
1519         --*)
1520                 __gitcomp "$__git_format_patch_options"
1521                 return
1522                 ;;
1523         esac
1524         __git_complete_revlist
1525 }
1526
1527 _git_fsck ()
1528 {
1529         case "$cur" in
1530         --*)
1531                 __gitcomp "
1532                         --tags --root --unreachable --cache --no-reflogs --full
1533                         --strict --verbose --lost-found --name-objects
1534                         "
1535                 return
1536                 ;;
1537         esac
1538 }
1539
1540 _git_gc ()
1541 {
1542         case "$cur" in
1543         --*)
1544                 __gitcomp "--prune --aggressive"
1545                 return
1546                 ;;
1547         esac
1548 }
1549
1550 _git_gitk ()
1551 {
1552         _gitk
1553 }
1554
1555 # Lists matching symbol names from a tag (as in ctags) file.
1556 # 1: List symbol names matching this word.
1557 # 2: The tag file to list symbol names from.
1558 # 3: A prefix to be added to each listed symbol name (optional).
1559 # 4: A suffix to be appended to each listed symbol name (optional).
1560 __git_match_ctag () {
1561         awk -v pfx="${3-}" -v sfx="${4-}" "
1562                 /^${1//\//\\/}/ { print pfx \$1 sfx }
1563                 " "$2"
1564 }
1565
1566 # Complete symbol names from a tag file.
1567 # Usage: __git_complete_symbol [<option>]...
1568 # --tags=<file>: The tag file to list symbol names from instead of the
1569 #                default "tags".
1570 # --pfx=<prefix>: A prefix to be added to each symbol name.
1571 # --cur=<word>: The current symbol name to be completed.  Defaults to
1572 #               the current word to be completed.
1573 # --sfx=<suffix>: A suffix to be appended to each symbol name instead
1574 #                 of the default space.
1575 __git_complete_symbol () {
1576         local tags=tags pfx="" cur_="${cur-}" sfx=" "
1577
1578         while test $# != 0; do
1579                 case "$1" in
1580                 --tags=*)       tags="${1##--tags=}" ;;
1581                 --pfx=*)        pfx="${1##--pfx=}" ;;
1582                 --cur=*)        cur_="${1##--cur=}" ;;
1583                 --sfx=*)        sfx="${1##--sfx=}" ;;
1584                 *)              return 1 ;;
1585                 esac
1586                 shift
1587         done
1588
1589         if test -r "$tags"; then
1590                 __gitcomp_direct "$(__git_match_ctag "$cur_" "$tags" "$pfx" "$sfx")"
1591         fi
1592 }
1593
1594 _git_grep ()
1595 {
1596         __git_has_doubledash && return
1597
1598         case "$cur" in
1599         --*)
1600                 __gitcomp "
1601                         --cached
1602                         --text --ignore-case --word-regexp --invert-match
1603                         --full-name --line-number
1604                         --extended-regexp --basic-regexp --fixed-strings
1605                         --perl-regexp
1606                         --threads
1607                         --files-with-matches --name-only
1608                         --files-without-match
1609                         --max-depth
1610                         --count
1611                         --and --or --not --all-match
1612                         --break --heading --show-function --function-context
1613                         --untracked --no-index
1614                         "
1615                 return
1616                 ;;
1617         esac
1618
1619         case "$cword,$prev" in
1620         2,*|*,-*)
1621                 __git_complete_symbol && return
1622                 ;;
1623         esac
1624
1625         __git_complete_refs
1626 }
1627
1628 _git_help ()
1629 {
1630         case "$cur" in
1631         --*)
1632                 __gitcomp "--all --guides --info --man --web"
1633                 return
1634                 ;;
1635         esac
1636         __git_compute_all_commands
1637         __gitcomp "$__git_all_commands $(__git_aliases)
1638                 attributes cli core-tutorial cvs-migration
1639                 diffcore everyday gitk glossary hooks ignore modules
1640                 namespaces repository-layout revisions tutorial tutorial-2
1641                 workflows
1642                 "
1643 }
1644
1645 _git_init ()
1646 {
1647         case "$cur" in
1648         --shared=*)
1649                 __gitcomp "
1650                         false true umask group all world everybody
1651                         " "" "${cur##--shared=}"
1652                 return
1653                 ;;
1654         --*)
1655                 __gitcomp "--quiet --bare --template= --shared --shared="
1656                 return
1657                 ;;
1658         esac
1659 }
1660
1661 _git_ls_files ()
1662 {
1663         case "$cur" in
1664         --*)
1665                 __gitcomp "--cached --deleted --modified --others --ignored
1666                         --stage --directory --no-empty-directory --unmerged
1667                         --killed --exclude= --exclude-from=
1668                         --exclude-per-directory= --exclude-standard
1669                         --error-unmatch --with-tree= --full-name
1670                         --abbrev --ignored --exclude-per-directory
1671                         "
1672                 return
1673                 ;;
1674         esac
1675
1676         # XXX ignore options like --modified and always suggest all cached
1677         # files.
1678         __git_complete_index_file "--cached"
1679 }
1680
1681 _git_ls_remote ()
1682 {
1683         case "$cur" in
1684         --*)
1685                 __gitcomp "--heads --tags --refs --get-url --symref"
1686                 return
1687                 ;;
1688         esac
1689         __gitcomp_nl "$(__git_remotes)"
1690 }
1691
1692 _git_ls_tree ()
1693 {
1694         __git_complete_file
1695 }
1696
1697 # Options that go well for log, shortlog and gitk
1698 __git_log_common_options="
1699         --not --all
1700         --branches --tags --remotes
1701         --first-parent --merges --no-merges
1702         --max-count=
1703         --max-age= --since= --after=
1704         --min-age= --until= --before=
1705         --min-parents= --max-parents=
1706         --no-min-parents --no-max-parents
1707 "
1708 # Options that go well for log and gitk (not shortlog)
1709 __git_log_gitk_options="
1710         --dense --sparse --full-history
1711         --simplify-merges --simplify-by-decoration
1712         --left-right --notes --no-notes
1713 "
1714 # Options that go well for log and shortlog (not gitk)
1715 __git_log_shortlog_options="
1716         --author= --committer= --grep=
1717         --all-match --invert-grep
1718 "
1719
1720 __git_log_pretty_formats="oneline short medium full fuller email raw format:"
1721 __git_log_date_formats="relative iso8601 rfc2822 short local default raw"
1722
1723 _git_log ()
1724 {
1725         __git_has_doubledash && return
1726         __git_find_repo_path
1727
1728         local merge=""
1729         if [ -f "$__git_repo_path/MERGE_HEAD" ]; then
1730                 merge="--merge"
1731         fi
1732         case "$prev,$cur" in
1733         -L,:*:*)
1734                 return  # fall back to Bash filename completion
1735                 ;;
1736         -L,:*)
1737                 __git_complete_symbol --cur="${cur#:}" --sfx=":"
1738                 return
1739                 ;;
1740         -G,*|-S,*)
1741                 __git_complete_symbol
1742                 return
1743                 ;;
1744         esac
1745         case "$cur" in
1746         --pretty=*|--format=*)
1747                 __gitcomp "$__git_log_pretty_formats $(__git_pretty_aliases)
1748                         " "" "${cur#*=}"
1749                 return
1750                 ;;
1751         --date=*)
1752                 __gitcomp "$__git_log_date_formats" "" "${cur##--date=}"
1753                 return
1754                 ;;
1755         --decorate=*)
1756                 __gitcomp "full short no" "" "${cur##--decorate=}"
1757                 return
1758                 ;;
1759         --diff-algorithm=*)
1760                 __gitcomp "$__git_diff_algorithms" "" "${cur##--diff-algorithm=}"
1761                 return
1762                 ;;
1763         --submodule=*)
1764                 __gitcomp "$__git_diff_submodule_formats" "" "${cur##--submodule=}"
1765                 return
1766                 ;;
1767         --*)
1768                 __gitcomp "
1769                         $__git_log_common_options
1770                         $__git_log_shortlog_options
1771                         $__git_log_gitk_options
1772                         --root --topo-order --date-order --reverse
1773                         --follow --full-diff
1774                         --abbrev-commit --abbrev=
1775                         --relative-date --date=
1776                         --pretty= --format= --oneline
1777                         --show-signature
1778                         --cherry-mark
1779                         --cherry-pick
1780                         --graph
1781                         --decorate --decorate=
1782                         --walk-reflogs
1783                         --parents --children
1784                         $merge
1785                         $__git_diff_common_options
1786                         --pickaxe-all --pickaxe-regex
1787                         "
1788                 return
1789                 ;;
1790         -L:*:*)
1791                 return  # fall back to Bash filename completion
1792                 ;;
1793         -L:*)
1794                 __git_complete_symbol --cur="${cur#-L:}" --sfx=":"
1795                 return
1796                 ;;
1797         -G*)
1798                 __git_complete_symbol --pfx="-G" --cur="${cur#-G}"
1799                 return
1800                 ;;
1801         -S*)
1802                 __git_complete_symbol --pfx="-S" --cur="${cur#-S}"
1803                 return
1804                 ;;
1805         esac
1806         __git_complete_revlist
1807 }
1808
1809 # Common merge options shared by git-merge(1) and git-pull(1).
1810 __git_merge_options="
1811         --no-commit --no-stat --log --no-log --squash --strategy
1812         --commit --stat --no-squash --ff --no-ff --ff-only --edit --no-edit
1813         --verify-signatures --no-verify-signatures --gpg-sign
1814         --quiet --verbose --progress --no-progress
1815 "
1816
1817 _git_merge ()
1818 {
1819         __git_complete_strategy && return
1820
1821         case "$cur" in
1822         --*)
1823                 __gitcomp "$__git_merge_options
1824                         --rerere-autoupdate --no-rerere-autoupdate --abort --continue"
1825                 return
1826         esac
1827         __git_complete_refs
1828 }
1829
1830 _git_mergetool ()
1831 {
1832         case "$cur" in
1833         --tool=*)
1834                 __gitcomp "$__git_mergetools_common tortoisemerge" "" "${cur##--tool=}"
1835                 return
1836                 ;;
1837         --*)
1838                 __gitcomp "--tool= --prompt --no-prompt"
1839                 return
1840                 ;;
1841         esac
1842 }
1843
1844 _git_merge_base ()
1845 {
1846         case "$cur" in
1847         --*)
1848                 __gitcomp "--octopus --independent --is-ancestor --fork-point"
1849                 return
1850                 ;;
1851         esac
1852         __git_complete_refs
1853 }
1854
1855 _git_mv ()
1856 {
1857         case "$cur" in
1858         --*)
1859                 __gitcomp "--dry-run"
1860                 return
1861                 ;;
1862         esac
1863
1864         if [ $(__git_count_arguments "mv") -gt 0 ]; then
1865                 # We need to show both cached and untracked files (including
1866                 # empty directories) since this may not be the last argument.
1867                 __git_complete_index_file "--cached --others --directory"
1868         else
1869                 __git_complete_index_file "--cached"
1870         fi
1871 }
1872
1873 _git_name_rev ()
1874 {
1875         __gitcomp "--tags --all --stdin"
1876 }
1877
1878 _git_notes ()
1879 {
1880         local subcommands='add append copy edit list prune remove show'
1881         local subcommand="$(__git_find_on_cmdline "$subcommands")"
1882
1883         case "$subcommand,$cur" in
1884         ,--*)
1885                 __gitcomp '--ref'
1886                 ;;
1887         ,*)
1888                 case "$prev" in
1889                 --ref)
1890                         __git_complete_refs
1891                         ;;
1892                 *)
1893                         __gitcomp "$subcommands --ref"
1894                         ;;
1895                 esac
1896                 ;;
1897         add,--reuse-message=*|append,--reuse-message=*|\
1898         add,--reedit-message=*|append,--reedit-message=*)
1899                 __git_complete_refs --cur="${cur#*=}"
1900                 ;;
1901         add,--*|append,--*)
1902                 __gitcomp '--file= --message= --reedit-message=
1903                                 --reuse-message='
1904                 ;;
1905         copy,--*)
1906                 __gitcomp '--stdin'
1907                 ;;
1908         prune,--*)
1909                 __gitcomp '--dry-run --verbose'
1910                 ;;
1911         prune,*)
1912                 ;;
1913         *)
1914                 case "$prev" in
1915                 -m|-F)
1916                         ;;
1917                 *)
1918                         __git_complete_refs
1919                         ;;
1920                 esac
1921                 ;;
1922         esac
1923 }
1924
1925 _git_pull ()
1926 {
1927         __git_complete_strategy && return
1928
1929         case "$cur" in
1930         --recurse-submodules=*)
1931                 __gitcomp "$__git_fetch_recurse_submodules" "" "${cur##--recurse-submodules=}"
1932                 return
1933                 ;;
1934         --*)
1935                 __gitcomp "
1936                         --rebase --no-rebase
1937                         --autostash --no-autostash
1938                         $__git_merge_options
1939                         $__git_fetch_options
1940                 "
1941                 return
1942                 ;;
1943         esac
1944         __git_complete_remote_or_refspec
1945 }
1946
1947 __git_push_recurse_submodules="check on-demand only"
1948
1949 __git_complete_force_with_lease ()
1950 {
1951         local cur_=$1
1952
1953         case "$cur_" in
1954         --*=)
1955                 ;;
1956         *:*)
1957                 __git_complete_refs --cur="${cur_#*:}"
1958                 ;;
1959         *)
1960                 __git_complete_refs --cur="$cur_"
1961                 ;;
1962         esac
1963 }
1964
1965 _git_push ()
1966 {
1967         case "$prev" in
1968         --repo)
1969                 __gitcomp_nl "$(__git_remotes)"
1970                 return
1971                 ;;
1972         --recurse-submodules)
1973                 __gitcomp "$__git_push_recurse_submodules"
1974                 return
1975                 ;;
1976         esac
1977         case "$cur" in
1978         --repo=*)
1979                 __gitcomp_nl "$(__git_remotes)" "" "${cur##--repo=}"
1980                 return
1981                 ;;
1982         --recurse-submodules=*)
1983                 __gitcomp "$__git_push_recurse_submodules" "" "${cur##--recurse-submodules=}"
1984                 return
1985                 ;;
1986         --force-with-lease=*)
1987                 __git_complete_force_with_lease "${cur##--force-with-lease=}"
1988                 return
1989                 ;;
1990         --*)
1991                 __gitcomp "
1992                         --all --mirror --tags --dry-run --force --verbose
1993                         --quiet --prune --delete --follow-tags
1994                         --receive-pack= --repo= --set-upstream
1995                         --force-with-lease --force-with-lease= --recurse-submodules=
1996                 "
1997                 return
1998                 ;;
1999         esac
2000         __git_complete_remote_or_refspec
2001 }
2002
2003 _git_rebase ()
2004 {
2005         __git_find_repo_path
2006         if [ -f "$__git_repo_path"/rebase-merge/interactive ]; then
2007                 __gitcomp "--continue --skip --abort --quit --edit-todo"
2008                 return
2009         elif [ -d "$__git_repo_path"/rebase-apply ] || \
2010              [ -d "$__git_repo_path"/rebase-merge ]; then
2011                 __gitcomp "--continue --skip --abort --quit"
2012                 return
2013         fi
2014         __git_complete_strategy && return
2015         case "$cur" in
2016         --whitespace=*)
2017                 __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
2018                 return
2019                 ;;
2020         --*)
2021                 __gitcomp "
2022                         --onto --merge --strategy --interactive
2023                         --preserve-merges --stat --no-stat
2024                         --committer-date-is-author-date --ignore-date
2025                         --ignore-whitespace --whitespace=
2026                         --autosquash --no-autosquash
2027                         --fork-point --no-fork-point
2028                         --autostash --no-autostash
2029                         --verify --no-verify
2030                         --keep-empty --root --force-rebase --no-ff
2031                         --exec
2032                         "
2033
2034                 return
2035         esac
2036         __git_complete_refs
2037 }
2038
2039 _git_reflog ()
2040 {
2041         local subcommands="show delete expire"
2042         local subcommand="$(__git_find_on_cmdline "$subcommands")"
2043
2044         if [ -z "$subcommand" ]; then
2045                 __gitcomp "$subcommands"
2046         else
2047                 __git_complete_refs
2048         fi
2049 }
2050
2051 __git_send_email_confirm_options="always never auto cc compose"
2052 __git_send_email_suppresscc_options="author self cc bodycc sob cccmd body all"
2053
2054 _git_send_email ()
2055 {
2056         case "$prev" in
2057         --to|--cc|--bcc|--from)
2058                 __gitcomp "$(__git send-email --dump-aliases)"
2059                 return
2060                 ;;
2061         esac
2062
2063         case "$cur" in
2064         --confirm=*)
2065                 __gitcomp "
2066                         $__git_send_email_confirm_options
2067                         " "" "${cur##--confirm=}"
2068                 return
2069                 ;;
2070         --suppress-cc=*)
2071                 __gitcomp "
2072                         $__git_send_email_suppresscc_options
2073                         " "" "${cur##--suppress-cc=}"
2074
2075                 return
2076                 ;;
2077         --smtp-encryption=*)
2078                 __gitcomp "ssl tls" "" "${cur##--smtp-encryption=}"
2079                 return
2080                 ;;
2081         --thread=*)
2082                 __gitcomp "
2083                         deep shallow
2084                         " "" "${cur##--thread=}"
2085                 return
2086                 ;;
2087         --to=*|--cc=*|--bcc=*|--from=*)
2088                 __gitcomp "$(__git send-email --dump-aliases)" "" "${cur#--*=}"
2089                 return
2090                 ;;
2091         --*)
2092                 __gitcomp "--annotate --bcc --cc --cc-cmd --chain-reply-to
2093                         --compose --confirm= --dry-run --envelope-sender
2094                         --from --identity
2095                         --in-reply-to --no-chain-reply-to --no-signed-off-by-cc
2096                         --no-suppress-from --no-thread --quiet
2097                         --signed-off-by-cc --smtp-pass --smtp-server
2098                         --smtp-server-port --smtp-encryption= --smtp-user
2099                         --subject --suppress-cc= --suppress-from --thread --to
2100                         --validate --no-validate
2101                         $__git_format_patch_options"
2102                 return
2103                 ;;
2104         esac
2105         __git_complete_revlist
2106 }
2107
2108 _git_stage ()
2109 {
2110         _git_add
2111 }
2112
2113 _git_status ()
2114 {
2115         local complete_opt
2116         local untracked_state
2117
2118         case "$cur" in
2119         --ignore-submodules=*)
2120                 __gitcomp "none untracked dirty all" "" "${cur##--ignore-submodules=}"
2121                 return
2122                 ;;
2123         --untracked-files=*)
2124                 __gitcomp "$__git_untracked_file_modes" "" "${cur##--untracked-files=}"
2125                 return
2126                 ;;
2127         --column=*)
2128                 __gitcomp "
2129                         always never auto column row plain dense nodense
2130                         " "" "${cur##--column=}"
2131                 return
2132                 ;;
2133         --*)
2134                 __gitcomp "
2135                         --short --branch --porcelain --long --verbose
2136                         --untracked-files= --ignore-submodules= --ignored
2137                         --column= --no-column
2138                         "
2139                 return
2140                 ;;
2141         esac
2142
2143         untracked_state="$(__git_get_option_value "-u" "--untracked-files=" \
2144                 "$__git_untracked_file_modes" "status.showUntrackedFiles")"
2145
2146         case "$untracked_state" in
2147         no)
2148                 # --ignored option does not matter
2149                 complete_opt=
2150                 ;;
2151         all|normal|*)
2152                 complete_opt="--cached --directory --no-empty-directory --others"
2153
2154                 if [ -n "$(__git_find_on_cmdline "--ignored")" ]; then
2155                         complete_opt="$complete_opt --ignored --exclude=*"
2156                 fi
2157                 ;;
2158         esac
2159
2160         __git_complete_index_file "$complete_opt"
2161 }
2162
2163 __git_config_get_set_variables ()
2164 {
2165         local prevword word config_file= c=$cword
2166         while [ $c -gt 1 ]; do
2167                 word="${words[c]}"
2168                 case "$word" in
2169                 --system|--global|--local|--file=*)
2170                         config_file="$word"
2171                         break
2172                         ;;
2173                 -f|--file)
2174                         config_file="$word $prevword"
2175                         break
2176                         ;;
2177                 esac
2178                 prevword=$word
2179                 c=$((--c))
2180         done
2181
2182         __git config $config_file --name-only --list
2183 }
2184
2185 _git_config ()
2186 {
2187         case "$prev" in
2188         branch.*.remote|branch.*.pushremote)
2189                 __gitcomp_nl "$(__git_remotes)"
2190                 return
2191                 ;;
2192         branch.*.merge)
2193                 __git_complete_refs
2194                 return
2195                 ;;
2196         branch.*.rebase)
2197                 __gitcomp "false true preserve interactive"
2198                 return
2199                 ;;
2200         remote.pushdefault)
2201                 __gitcomp_nl "$(__git_remotes)"
2202                 return
2203                 ;;
2204         remote.*.fetch)
2205                 local remote="${prev#remote.}"
2206                 remote="${remote%.fetch}"
2207                 if [ -z "$cur" ]; then
2208                         __gitcomp_nl "refs/heads/" "" "" ""
2209                         return
2210                 fi
2211                 __gitcomp_nl "$(__git_refs_remotes "$remote")"
2212                 return
2213                 ;;
2214         remote.*.push)
2215                 local remote="${prev#remote.}"
2216                 remote="${remote%.push}"
2217                 __gitcomp_nl "$(__git for-each-ref \
2218                         --format='%(refname):%(refname)' refs/heads)"
2219                 return
2220                 ;;
2221         pull.twohead|pull.octopus)
2222                 __git_compute_merge_strategies
2223                 __gitcomp "$__git_merge_strategies"
2224                 return
2225                 ;;
2226         color.branch|color.diff|color.interactive|\
2227         color.showbranch|color.status|color.ui)
2228                 __gitcomp "always never auto"
2229                 return
2230                 ;;
2231         color.pager)
2232                 __gitcomp "false true"
2233                 return
2234                 ;;
2235         color.*.*)
2236                 __gitcomp "
2237                         normal black red green yellow blue magenta cyan white
2238                         bold dim ul blink reverse
2239                         "
2240                 return
2241                 ;;
2242         diff.submodule)
2243                 __gitcomp "log short"
2244                 return
2245                 ;;
2246         help.format)
2247                 __gitcomp "man info web html"
2248                 return
2249                 ;;
2250         log.date)
2251                 __gitcomp "$__git_log_date_formats"
2252                 return
2253                 ;;
2254         sendemail.aliasesfiletype)
2255                 __gitcomp "mutt mailrc pine elm gnus"
2256                 return
2257                 ;;
2258         sendemail.confirm)
2259                 __gitcomp "$__git_send_email_confirm_options"
2260                 return
2261                 ;;
2262         sendemail.suppresscc)
2263                 __gitcomp "$__git_send_email_suppresscc_options"
2264                 return
2265                 ;;
2266         sendemail.transferencoding)
2267                 __gitcomp "7bit 8bit quoted-printable base64"
2268                 return
2269                 ;;
2270         --get|--get-all|--unset|--unset-all)
2271                 __gitcomp_nl "$(__git_config_get_set_variables)"
2272                 return
2273                 ;;
2274         *.*)
2275                 return
2276                 ;;
2277         esac
2278         case "$cur" in
2279         --*)
2280                 __gitcomp "
2281                         --system --global --local --file=
2282                         --list --replace-all
2283                         --get --get-all --get-regexp
2284                         --add --unset --unset-all
2285                         --remove-section --rename-section
2286                         --name-only
2287                         "
2288                 return
2289                 ;;
2290         branch.*.*)
2291                 local pfx="${cur%.*}." cur_="${cur##*.}"
2292                 __gitcomp "remote pushremote merge mergeoptions rebase" "$pfx" "$cur_"
2293                 return
2294                 ;;
2295         branch.*)
2296                 local pfx="${cur%.*}." cur_="${cur#*.}"
2297                 __gitcomp_direct "$(__git_heads "$pfx" "$cur_" ".")"
2298                 __gitcomp_nl_append $'autosetupmerge\nautosetuprebase\n' "$pfx" "$cur_"
2299                 return
2300                 ;;
2301         guitool.*.*)
2302                 local pfx="${cur%.*}." cur_="${cur##*.}"
2303                 __gitcomp "
2304                         argprompt cmd confirm needsfile noconsole norescan
2305                         prompt revprompt revunmerged title
2306                         " "$pfx" "$cur_"
2307                 return
2308                 ;;
2309         difftool.*.*)
2310                 local pfx="${cur%.*}." cur_="${cur##*.}"
2311                 __gitcomp "cmd path" "$pfx" "$cur_"
2312                 return
2313                 ;;
2314         man.*.*)
2315                 local pfx="${cur%.*}." cur_="${cur##*.}"
2316                 __gitcomp "cmd path" "$pfx" "$cur_"
2317                 return
2318                 ;;
2319         mergetool.*.*)
2320                 local pfx="${cur%.*}." cur_="${cur##*.}"
2321                 __gitcomp "cmd path trustExitCode" "$pfx" "$cur_"
2322                 return
2323                 ;;
2324         pager.*)
2325                 local pfx="${cur%.*}." cur_="${cur#*.}"
2326                 __git_compute_all_commands
2327                 __gitcomp_nl "$__git_all_commands" "$pfx" "$cur_"
2328                 return
2329                 ;;
2330         remote.*.*)
2331                 local pfx="${cur%.*}." cur_="${cur##*.}"
2332                 __gitcomp "
2333                         url proxy fetch push mirror skipDefaultUpdate
2334                         receivepack uploadpack tagopt pushurl
2335                         " "$pfx" "$cur_"
2336                 return
2337                 ;;
2338         remote.*)
2339                 local pfx="${cur%.*}." cur_="${cur#*.}"
2340                 __gitcomp_nl "$(__git_remotes)" "$pfx" "$cur_" "."
2341                 __gitcomp_nl_append "pushdefault" "$pfx" "$cur_"
2342                 return
2343                 ;;
2344         url.*.*)
2345                 local pfx="${cur%.*}." cur_="${cur##*.}"
2346                 __gitcomp "insteadOf pushInsteadOf" "$pfx" "$cur_"
2347                 return
2348                 ;;
2349         esac
2350         __gitcomp "
2351                 add.ignoreErrors
2352                 advice.amWorkDir
2353                 advice.commitBeforeMerge
2354                 advice.detachedHead
2355                 advice.implicitIdentity
2356                 advice.pushAlreadyExists
2357                 advice.pushFetchFirst
2358                 advice.pushNeedsForce
2359                 advice.pushNonFFCurrent
2360                 advice.pushNonFFMatching
2361                 advice.pushUpdateRejected
2362                 advice.resolveConflict
2363                 advice.rmHints
2364                 advice.statusHints
2365                 advice.statusUoption
2366                 advice.ignoredHook
2367                 alias.
2368                 am.keepcr
2369                 am.threeWay
2370                 apply.ignorewhitespace
2371                 apply.whitespace
2372                 branch.autosetupmerge
2373                 branch.autosetuprebase
2374                 browser.
2375                 clean.requireForce
2376                 color.branch
2377                 color.branch.current
2378                 color.branch.local
2379                 color.branch.plain
2380                 color.branch.remote
2381                 color.decorate.HEAD
2382                 color.decorate.branch
2383                 color.decorate.remoteBranch
2384                 color.decorate.stash
2385                 color.decorate.tag
2386                 color.diff
2387                 color.diff.commit
2388                 color.diff.frag
2389                 color.diff.func
2390                 color.diff.meta
2391                 color.diff.new
2392                 color.diff.old
2393                 color.diff.plain
2394                 color.diff.whitespace
2395                 color.grep
2396                 color.grep.context
2397                 color.grep.filename
2398                 color.grep.function
2399                 color.grep.linenumber
2400                 color.grep.match
2401                 color.grep.selected
2402                 color.grep.separator
2403                 color.interactive
2404                 color.interactive.error
2405                 color.interactive.header
2406                 color.interactive.help
2407                 color.interactive.prompt
2408                 color.pager
2409                 color.showbranch
2410                 color.status
2411                 color.status.added
2412                 color.status.changed
2413                 color.status.header
2414                 color.status.localBranch
2415                 color.status.nobranch
2416                 color.status.remoteBranch
2417                 color.status.unmerged
2418                 color.status.untracked
2419                 color.status.updated
2420                 color.ui
2421                 commit.cleanup
2422                 commit.gpgSign
2423                 commit.status
2424                 commit.template
2425                 commit.verbose
2426                 core.abbrev
2427                 core.askpass
2428                 core.attributesfile
2429                 core.autocrlf
2430                 core.bare
2431                 core.bigFileThreshold
2432                 core.checkStat
2433                 core.commentChar
2434                 core.compression
2435                 core.createObject
2436                 core.deltaBaseCacheLimit
2437                 core.editor
2438                 core.eol
2439                 core.excludesfile
2440                 core.fileMode
2441                 core.fsyncobjectfiles
2442                 core.gitProxy
2443                 core.hideDotFiles
2444                 core.hooksPath
2445                 core.ignoreStat
2446                 core.ignorecase
2447                 core.logAllRefUpdates
2448                 core.loosecompression
2449                 core.notesRef
2450                 core.packedGitLimit
2451                 core.packedGitWindowSize
2452                 core.packedRefsTimeout
2453                 core.pager
2454                 core.precomposeUnicode
2455                 core.preferSymlinkRefs
2456                 core.preloadindex
2457                 core.protectHFS
2458                 core.protectNTFS
2459                 core.quotepath
2460                 core.repositoryFormatVersion
2461                 core.safecrlf
2462                 core.sharedRepository
2463                 core.sparseCheckout
2464                 core.splitIndex
2465                 core.sshCommand
2466                 core.symlinks
2467                 core.trustctime
2468                 core.untrackedCache
2469                 core.warnAmbiguousRefs
2470                 core.whitespace
2471                 core.worktree
2472                 credential.helper
2473                 credential.useHttpPath
2474                 credential.username
2475                 credentialCache.ignoreSIGHUP
2476                 diff.autorefreshindex
2477                 diff.external
2478                 diff.ignoreSubmodules
2479                 diff.mnemonicprefix
2480                 diff.noprefix
2481                 diff.renameLimit
2482                 diff.renames
2483                 diff.statGraphWidth
2484                 diff.submodule
2485                 diff.suppressBlankEmpty
2486                 diff.tool
2487                 diff.wordRegex
2488                 diff.algorithm
2489                 difftool.
2490                 difftool.prompt
2491                 fetch.recurseSubmodules
2492                 fetch.unpackLimit
2493                 format.attach
2494                 format.cc
2495                 format.coverLetter
2496                 format.from
2497                 format.headers
2498                 format.numbered
2499                 format.pretty
2500                 format.signature
2501                 format.signoff
2502                 format.subjectprefix
2503                 format.suffix
2504                 format.thread
2505                 format.to
2506                 gc.
2507                 gc.aggressiveDepth
2508                 gc.aggressiveWindow
2509                 gc.auto
2510                 gc.autoDetach
2511                 gc.autopacklimit
2512                 gc.logExpiry
2513                 gc.packrefs
2514                 gc.pruneexpire
2515                 gc.reflogexpire
2516                 gc.reflogexpireunreachable
2517                 gc.rerereresolved
2518                 gc.rerereunresolved
2519                 gc.worktreePruneExpire
2520                 gitcvs.allbinary
2521                 gitcvs.commitmsgannotation
2522                 gitcvs.dbTableNamePrefix
2523                 gitcvs.dbdriver
2524                 gitcvs.dbname
2525                 gitcvs.dbpass
2526                 gitcvs.dbuser
2527                 gitcvs.enabled
2528                 gitcvs.logfile
2529                 gitcvs.usecrlfattr
2530                 guitool.
2531                 gui.blamehistoryctx
2532                 gui.commitmsgwidth
2533                 gui.copyblamethreshold
2534                 gui.diffcontext
2535                 gui.encoding
2536                 gui.fastcopyblame
2537                 gui.matchtrackingbranch
2538                 gui.newbranchtemplate
2539                 gui.pruneduringfetch
2540                 gui.spellingdictionary
2541                 gui.trustmtime
2542                 help.autocorrect
2543                 help.browser
2544                 help.format
2545                 http.lowSpeedLimit
2546                 http.lowSpeedTime
2547                 http.maxRequests
2548                 http.minSessions
2549                 http.noEPSV
2550                 http.postBuffer
2551                 http.proxy
2552                 http.sslCipherList
2553                 http.sslVersion
2554                 http.sslCAInfo
2555                 http.sslCAPath
2556                 http.sslCert
2557                 http.sslCertPasswordProtected
2558                 http.sslKey
2559                 http.sslVerify
2560                 http.useragent
2561                 i18n.commitEncoding
2562                 i18n.logOutputEncoding
2563                 imap.authMethod
2564                 imap.folder
2565                 imap.host
2566                 imap.pass
2567                 imap.port
2568                 imap.preformattedHTML
2569                 imap.sslverify
2570                 imap.tunnel
2571                 imap.user
2572                 init.templatedir
2573                 instaweb.browser
2574                 instaweb.httpd
2575                 instaweb.local
2576                 instaweb.modulepath
2577                 instaweb.port
2578                 interactive.singlekey
2579                 log.date
2580                 log.decorate
2581                 log.showroot
2582                 mailmap.file
2583                 man.
2584                 man.viewer
2585                 merge.
2586                 merge.conflictstyle
2587                 merge.log
2588                 merge.renameLimit
2589                 merge.renormalize
2590                 merge.stat
2591                 merge.tool
2592                 merge.verbosity
2593                 mergetool.
2594                 mergetool.keepBackup
2595                 mergetool.keepTemporaries
2596                 mergetool.prompt
2597                 notes.displayRef
2598                 notes.rewrite.
2599                 notes.rewrite.amend
2600                 notes.rewrite.rebase
2601                 notes.rewriteMode
2602                 notes.rewriteRef
2603                 pack.compression
2604                 pack.deltaCacheLimit
2605                 pack.deltaCacheSize
2606                 pack.depth
2607                 pack.indexVersion
2608                 pack.packSizeLimit
2609                 pack.threads
2610                 pack.window
2611                 pack.windowMemory
2612                 pager.
2613                 pretty.
2614                 pull.octopus
2615                 pull.twohead
2616                 push.default
2617                 push.followTags
2618                 rebase.autosquash
2619                 rebase.stat
2620                 receive.autogc
2621                 receive.denyCurrentBranch
2622                 receive.denyDeleteCurrent
2623                 receive.denyDeletes
2624                 receive.denyNonFastForwards
2625                 receive.fsckObjects
2626                 receive.unpackLimit
2627                 receive.updateserverinfo
2628                 remote.pushdefault
2629                 remotes.
2630                 repack.usedeltabaseoffset
2631                 rerere.autoupdate
2632                 rerere.enabled
2633                 sendemail.
2634                 sendemail.aliasesfile
2635                 sendemail.aliasfiletype
2636                 sendemail.bcc
2637                 sendemail.cc
2638                 sendemail.cccmd
2639                 sendemail.chainreplyto
2640                 sendemail.confirm
2641                 sendemail.envelopesender
2642                 sendemail.from
2643                 sendemail.identity
2644                 sendemail.multiedit
2645                 sendemail.signedoffbycc
2646                 sendemail.smtpdomain
2647                 sendemail.smtpencryption
2648                 sendemail.smtppass
2649                 sendemail.smtpserver
2650                 sendemail.smtpserveroption
2651                 sendemail.smtpserverport
2652                 sendemail.smtpuser
2653                 sendemail.suppresscc
2654                 sendemail.suppressfrom
2655                 sendemail.thread
2656                 sendemail.to
2657                 sendemail.tocmd
2658                 sendemail.validate
2659                 sendemail.smtpbatchsize
2660                 sendemail.smtprelogindelay
2661                 showbranch.default
2662                 status.relativePaths
2663                 status.showUntrackedFiles
2664                 status.submodulesummary
2665                 submodule.
2666                 tar.umask
2667                 transfer.unpackLimit
2668                 url.
2669                 user.email
2670                 user.name
2671                 user.signingkey
2672                 web.browser
2673                 branch. remote.
2674         "
2675 }
2676
2677 _git_remote ()
2678 {
2679         local subcommands="
2680                 add rename remove set-head set-branches
2681                 get-url set-url show prune update
2682                 "
2683         local subcommand="$(__git_find_on_cmdline "$subcommands")"
2684         if [ -z "$subcommand" ]; then
2685                 case "$cur" in
2686                 --*)
2687                         __gitcomp "--verbose"
2688                         ;;
2689                 *)
2690                         __gitcomp "$subcommands"
2691                         ;;
2692                 esac
2693                 return
2694         fi
2695
2696         case "$subcommand,$cur" in
2697         add,--*)
2698                 __gitcomp "--track --master --fetch --tags --no-tags --mirror="
2699                 ;;
2700         add,*)
2701                 ;;
2702         set-head,--*)
2703                 __gitcomp "--auto --delete"
2704                 ;;
2705         set-branches,--*)
2706                 __gitcomp "--add"
2707                 ;;
2708         set-head,*|set-branches,*)
2709                 __git_complete_remote_or_refspec
2710                 ;;
2711         update,--*)
2712                 __gitcomp "--prune"
2713                 ;;
2714         update,*)
2715                 __gitcomp "$(__git_get_config_variables "remotes")"
2716                 ;;
2717         set-url,--*)
2718                 __gitcomp "--push --add --delete"
2719                 ;;
2720         get-url,--*)
2721                 __gitcomp "--push --all"
2722                 ;;
2723         prune,--*)
2724                 __gitcomp "--dry-run"
2725                 ;;
2726         *)
2727                 __gitcomp_nl "$(__git_remotes)"
2728                 ;;
2729         esac
2730 }
2731
2732 _git_replace ()
2733 {
2734         case "$cur" in
2735         --*)
2736                 __gitcomp "--edit --graft --format= --list --delete"
2737                 return
2738                 ;;
2739         esac
2740         __git_complete_refs
2741 }
2742
2743 _git_rerere ()
2744 {
2745         local subcommands="clear forget diff remaining status gc"
2746         local subcommand="$(__git_find_on_cmdline "$subcommands")"
2747         if test -z "$subcommand"
2748         then
2749                 __gitcomp "$subcommands"
2750                 return
2751         fi
2752 }
2753
2754 _git_reset ()
2755 {
2756         __git_has_doubledash && return
2757
2758         case "$cur" in
2759         --*)
2760                 __gitcomp "--merge --mixed --hard --soft --patch --keep"
2761                 return
2762                 ;;
2763         esac
2764         __git_complete_refs
2765 }
2766
2767 _git_revert ()
2768 {
2769         __git_find_repo_path
2770         if [ -f "$__git_repo_path"/REVERT_HEAD ]; then
2771                 __gitcomp "--continue --quit --abort"
2772                 return
2773         fi
2774         case "$cur" in
2775         --*)
2776                 __gitcomp "
2777                         --edit --mainline --no-edit --no-commit --signoff
2778                         --strategy= --strategy-option=
2779                         "
2780                 return
2781                 ;;
2782         esac
2783         __git_complete_refs
2784 }
2785
2786 _git_rm ()
2787 {
2788         case "$cur" in
2789         --*)
2790                 __gitcomp "--cached --dry-run --ignore-unmatch --quiet"
2791                 return
2792                 ;;
2793         esac
2794
2795         __git_complete_index_file "--cached"
2796 }
2797
2798 _git_shortlog ()
2799 {
2800         __git_has_doubledash && return
2801
2802         case "$cur" in
2803         --*)
2804                 __gitcomp "
2805                         $__git_log_common_options
2806                         $__git_log_shortlog_options
2807                         --numbered --summary --email
2808                         "
2809                 return
2810                 ;;
2811         esac
2812         __git_complete_revlist
2813 }
2814
2815 _git_show ()
2816 {
2817         __git_has_doubledash && return
2818
2819         case "$cur" in
2820         --pretty=*|--format=*)
2821                 __gitcomp "$__git_log_pretty_formats $(__git_pretty_aliases)
2822                         " "" "${cur#*=}"
2823                 return
2824                 ;;
2825         --diff-algorithm=*)
2826                 __gitcomp "$__git_diff_algorithms" "" "${cur##--diff-algorithm=}"
2827                 return
2828                 ;;
2829         --submodule=*)
2830                 __gitcomp "$__git_diff_submodule_formats" "" "${cur##--submodule=}"
2831                 return
2832                 ;;
2833         --*)
2834                 __gitcomp "--pretty= --format= --abbrev-commit --oneline
2835                         --show-signature
2836                         $__git_diff_common_options
2837                         "
2838                 return
2839                 ;;
2840         esac
2841         __git_complete_revlist_file
2842 }
2843
2844 _git_show_branch ()
2845 {
2846         case "$cur" in
2847         --*)
2848                 __gitcomp "
2849                         --all --remotes --topo-order --date-order --current --more=
2850                         --list --independent --merge-base --no-name
2851                         --color --no-color
2852                         --sha1-name --sparse --topics --reflog
2853                         "
2854                 return
2855                 ;;
2856         esac
2857         __git_complete_revlist
2858 }
2859
2860 _git_stash ()
2861 {
2862         local save_opts='--all --keep-index --no-keep-index --quiet --patch --include-untracked'
2863         local subcommands='push save list show apply clear drop pop create branch'
2864         local subcommand="$(__git_find_on_cmdline "$subcommands")"
2865         if [ -z "$subcommand" ]; then
2866                 case "$cur" in
2867                 --*)
2868                         __gitcomp "$save_opts"
2869                         ;;
2870                 *)
2871                         if [ -z "$(__git_find_on_cmdline "$save_opts")" ]; then
2872                                 __gitcomp "$subcommands"
2873                         fi
2874                         ;;
2875                 esac
2876         else
2877                 case "$subcommand,$cur" in
2878                 push,--*)
2879                         __gitcomp "$save_opts --message"
2880                         ;;
2881                 save,--*)
2882                         __gitcomp "$save_opts"
2883                         ;;
2884                 apply,--*|pop,--*)
2885                         __gitcomp "--index --quiet"
2886                         ;;
2887                 drop,--*)
2888                         __gitcomp "--quiet"
2889                         ;;
2890                 show,--*|branch,--*)
2891                         ;;
2892                 branch,*)
2893                         if [ $cword -eq 3 ]; then
2894                                 __git_complete_refs
2895                         else
2896                                 __gitcomp_nl "$(__git stash list \
2897                                                 | sed -n -e 's/:.*//p')"
2898                         fi
2899                         ;;
2900                 show,*|apply,*|drop,*|pop,*)
2901                         __gitcomp_nl "$(__git stash list \
2902                                         | sed -n -e 's/:.*//p')"
2903                         ;;
2904                 *)
2905                         ;;
2906                 esac
2907         fi
2908 }
2909
2910 _git_submodule ()
2911 {
2912         __git_has_doubledash && return
2913
2914         local subcommands="add status init deinit update summary foreach sync"
2915         local subcommand="$(__git_find_on_cmdline "$subcommands")"
2916         if [ -z "$subcommand" ]; then
2917                 case "$cur" in
2918                 --*)
2919                         __gitcomp "--quiet"
2920                         ;;
2921                 *)
2922                         __gitcomp "$subcommands"
2923                         ;;
2924                 esac
2925                 return
2926         fi
2927
2928         case "$subcommand,$cur" in
2929         add,--*)
2930                 __gitcomp "--branch --force --name --reference --depth"
2931                 ;;
2932         status,--*)
2933                 __gitcomp "--cached --recursive"
2934                 ;;
2935         deinit,--*)
2936                 __gitcomp "--force --all"
2937                 ;;
2938         update,--*)
2939                 __gitcomp "
2940                         --init --remote --no-fetch
2941                         --recommend-shallow --no-recommend-shallow
2942                         --force --rebase --merge --reference --depth --recursive --jobs
2943                 "
2944                 ;;
2945         summary,--*)
2946                 __gitcomp "--cached --files --summary-limit"
2947                 ;;
2948         foreach,--*|sync,--*)
2949                 __gitcomp "--recursive"
2950                 ;;
2951         *)
2952                 ;;
2953         esac
2954 }
2955
2956 _git_svn ()
2957 {
2958         local subcommands="
2959                 init fetch clone rebase dcommit log find-rev
2960                 set-tree commit-diff info create-ignore propget
2961                 proplist show-ignore show-externals branch tag blame
2962                 migrate mkdirs reset gc
2963                 "
2964         local subcommand="$(__git_find_on_cmdline "$subcommands")"
2965         if [ -z "$subcommand" ]; then
2966                 __gitcomp "$subcommands"
2967         else
2968                 local remote_opts="--username= --config-dir= --no-auth-cache"
2969                 local fc_opts="
2970                         --follow-parent --authors-file= --repack=
2971                         --no-metadata --use-svm-props --use-svnsync-props
2972                         --log-window-size= --no-checkout --quiet
2973                         --repack-flags --use-log-author --localtime
2974                         --add-author-from
2975                         --ignore-paths= --include-paths= $remote_opts
2976                         "
2977                 local init_opts="
2978                         --template= --shared= --trunk= --tags=
2979                         --branches= --stdlayout --minimize-url
2980                         --no-metadata --use-svm-props --use-svnsync-props
2981                         --rewrite-root= --prefix= $remote_opts
2982                         "
2983                 local cmt_opts="
2984                         --edit --rmdir --find-copies-harder --copy-similarity=
2985                         "
2986
2987                 case "$subcommand,$cur" in
2988                 fetch,--*)
2989                         __gitcomp "--revision= --fetch-all $fc_opts"
2990                         ;;
2991                 clone,--*)
2992                         __gitcomp "--revision= $fc_opts $init_opts"
2993                         ;;
2994                 init,--*)
2995                         __gitcomp "$init_opts"
2996                         ;;
2997                 dcommit,--*)
2998                         __gitcomp "
2999                                 --merge --strategy= --verbose --dry-run
3000                                 --fetch-all --no-rebase --commit-url
3001                                 --revision --interactive $cmt_opts $fc_opts
3002                                 "
3003                         ;;
3004                 set-tree,--*)
3005                         __gitcomp "--stdin $cmt_opts $fc_opts"
3006                         ;;
3007                 create-ignore,--*|propget,--*|proplist,--*|show-ignore,--*|\
3008                 show-externals,--*|mkdirs,--*)
3009                         __gitcomp "--revision="
3010                         ;;
3011                 log,--*)
3012                         __gitcomp "
3013                                 --limit= --revision= --verbose --incremental
3014                                 --oneline --show-commit --non-recursive
3015                                 --authors-file= --color
3016                                 "
3017                         ;;
3018                 rebase,--*)
3019                         __gitcomp "
3020                                 --merge --verbose --strategy= --local
3021                                 --fetch-all --dry-run $fc_opts
3022                                 "
3023                         ;;
3024                 commit-diff,--*)
3025                         __gitcomp "--message= --file= --revision= $cmt_opts"
3026                         ;;
3027                 info,--*)
3028                         __gitcomp "--url"
3029                         ;;
3030                 branch,--*)
3031                         __gitcomp "--dry-run --message --tag"
3032                         ;;
3033                 tag,--*)
3034                         __gitcomp "--dry-run --message"
3035                         ;;
3036                 blame,--*)
3037                         __gitcomp "--git-format"
3038                         ;;
3039                 migrate,--*)
3040                         __gitcomp "
3041                                 --config-dir= --ignore-paths= --minimize
3042                                 --no-auth-cache --username=
3043                                 "
3044                         ;;
3045                 reset,--*)
3046                         __gitcomp "--revision= --parent"
3047                         ;;
3048                 *)
3049                         ;;
3050                 esac
3051         fi
3052 }
3053
3054 _git_tag ()
3055 {
3056         local i c=1 f=0
3057         while [ $c -lt $cword ]; do
3058                 i="${words[c]}"
3059                 case "$i" in
3060                 -d|-v)
3061                         __gitcomp_direct "$(__git_tags "" "$cur" " ")"
3062                         return
3063                         ;;
3064                 -f)
3065                         f=1
3066                         ;;
3067                 esac
3068                 ((c++))
3069         done
3070
3071         case "$prev" in
3072         -m|-F)
3073                 ;;
3074         -*|tag)
3075                 if [ $f = 1 ]; then
3076                         __gitcomp_direct "$(__git_tags "" "$cur" " ")"
3077                 fi
3078                 ;;
3079         *)
3080                 __git_complete_refs
3081                 ;;
3082         esac
3083
3084         case "$cur" in
3085         --*)
3086                 __gitcomp "
3087                         --list --delete --verify --annotate --message --file
3088                         --sign --cleanup --local-user --force --column --sort=
3089                         --contains --no-contains --points-at --merged --no-merged --create-reflog
3090                         "
3091                 ;;
3092         esac
3093 }
3094
3095 _git_whatchanged ()
3096 {
3097         _git_log
3098 }
3099
3100 _git_worktree ()
3101 {
3102         local subcommands="add list lock prune unlock"
3103         local subcommand="$(__git_find_on_cmdline "$subcommands")"
3104         if [ -z "$subcommand" ]; then
3105                 __gitcomp "$subcommands"
3106         else
3107                 case "$subcommand,$cur" in
3108                 add,--*)
3109                         __gitcomp "--detach"
3110                         ;;
3111                 list,--*)
3112                         __gitcomp "--porcelain"
3113                         ;;
3114                 lock,--*)
3115                         __gitcomp "--reason"
3116                         ;;
3117                 prune,--*)
3118                         __gitcomp "--dry-run --expire --verbose"
3119                         ;;
3120                 *)
3121                         ;;
3122                 esac
3123         fi
3124 }
3125
3126 __git_main ()
3127 {
3128         local i c=1 command __git_dir __git_repo_path
3129         local __git_C_args C_args_count=0
3130
3131         while [ $c -lt $cword ]; do
3132                 i="${words[c]}"
3133                 case "$i" in
3134                 --git-dir=*) __git_dir="${i#--git-dir=}" ;;
3135                 --git-dir)   ((c++)) ; __git_dir="${words[c]}" ;;
3136                 --bare)      __git_dir="." ;;
3137                 --help) command="help"; break ;;
3138                 -c|--work-tree|--namespace) ((c++)) ;;
3139                 -C)     __git_C_args[C_args_count++]=-C
3140                         ((c++))
3141                         __git_C_args[C_args_count++]="${words[c]}"
3142                         ;;
3143                 -*) ;;
3144                 *) command="$i"; break ;;
3145                 esac
3146                 ((c++))
3147         done
3148
3149         if [ -z "$command" ]; then
3150                 case "$prev" in
3151                 --git-dir|-C|--work-tree)
3152                         # these need a path argument, let's fall back to
3153                         # Bash filename completion
3154                         return
3155                         ;;
3156                 -c|--namespace)
3157                         # we don't support completing these options' arguments
3158                         return
3159                         ;;
3160                 esac
3161                 case "$cur" in
3162                 --*)   __gitcomp "
3163                         --paginate
3164                         --no-pager
3165                         --git-dir=
3166                         --bare
3167                         --version
3168                         --exec-path
3169                         --exec-path=
3170                         --html-path
3171                         --man-path
3172                         --info-path
3173                         --work-tree=
3174                         --namespace=
3175                         --no-replace-objects
3176                         --help
3177                         "
3178                         ;;
3179                 *)     __git_compute_porcelain_commands
3180                        __gitcomp "$__git_porcelain_commands $(__git_aliases)" ;;
3181                 esac
3182                 return
3183         fi
3184
3185         local completion_func="_git_${command//-/_}"
3186         declare -f $completion_func >/dev/null 2>/dev/null && $completion_func && return
3187
3188         local expansion=$(__git_aliased_command "$command")
3189         if [ -n "$expansion" ]; then
3190                 words[1]=$expansion
3191                 completion_func="_git_${expansion//-/_}"
3192                 declare -f $completion_func >/dev/null 2>/dev/null && $completion_func
3193         fi
3194 }
3195
3196 __gitk_main ()
3197 {
3198         __git_has_doubledash && return
3199
3200         local __git_repo_path
3201         __git_find_repo_path
3202
3203         local merge=""
3204         if [ -f "$__git_repo_path/MERGE_HEAD" ]; then
3205                 merge="--merge"
3206         fi
3207         case "$cur" in
3208         --*)
3209                 __gitcomp "
3210                         $__git_log_common_options
3211                         $__git_log_gitk_options
3212                         $merge
3213                         "
3214                 return
3215                 ;;
3216         esac
3217         __git_complete_revlist
3218 }
3219
3220 if [[ -n ${ZSH_VERSION-} ]]; then
3221         echo "WARNING: this script is deprecated, please see git-completion.zsh" 1>&2
3222
3223         autoload -U +X compinit && compinit
3224
3225         __gitcomp ()
3226         {
3227                 emulate -L zsh
3228
3229                 local cur_="${3-$cur}"
3230
3231                 case "$cur_" in
3232                 --*=)
3233                         ;;
3234                 *)
3235                         local c IFS=$' \t\n'
3236                         local -a array
3237                         for c in ${=1}; do
3238                                 c="$c${4-}"
3239                                 case $c in
3240                                 --*=*|*.) ;;
3241                                 *) c="$c " ;;
3242                                 esac
3243                                 array[${#array[@]}+1]="$c"
3244                         done
3245                         compset -P '*[=:]'
3246                         compadd -Q -S '' -p "${2-}" -a -- array && _ret=0
3247                         ;;
3248                 esac
3249         }
3250
3251         __gitcomp_direct ()
3252         {
3253                 emulate -L zsh
3254
3255                 local IFS=$'\n'
3256                 compset -P '*[=:]'
3257                 compadd -Q -- ${=1} && _ret=0
3258         }
3259
3260         __gitcomp_nl ()
3261         {
3262                 emulate -L zsh
3263
3264                 local IFS=$'\n'
3265                 compset -P '*[=:]'
3266                 compadd -Q -S "${4- }" -p "${2-}" -- ${=1} && _ret=0
3267         }
3268
3269         __gitcomp_file ()
3270         {
3271                 emulate -L zsh
3272
3273                 local IFS=$'\n'
3274                 compset -P '*[=:]'
3275                 compadd -Q -p "${2-}" -f -- ${=1} && _ret=0
3276         }
3277
3278         _git ()
3279         {
3280                 local _ret=1 cur cword prev
3281                 cur=${words[CURRENT]}
3282                 prev=${words[CURRENT-1]}
3283                 let cword=CURRENT-1
3284                 emulate ksh -c __${service}_main
3285                 let _ret && _default && _ret=0
3286                 return _ret
3287         }
3288
3289         compdef _git git gitk
3290         return
3291 fi
3292
3293 __git_func_wrap ()
3294 {
3295         local cur words cword prev
3296         _get_comp_words_by_ref -n =: cur words cword prev
3297         $1
3298 }
3299
3300 # Setup completion for certain functions defined above by setting common
3301 # variables and workarounds.
3302 # This is NOT a public function; use at your own risk.
3303 __git_complete ()
3304 {
3305         local wrapper="__git_wrap${2}"
3306         eval "$wrapper () { __git_func_wrap $2 ; }"
3307         complete -o bashdefault -o default -o nospace -F $wrapper $1 2>/dev/null \
3308                 || complete -o default -o nospace -F $wrapper $1
3309 }
3310
3311 # wrapper for backwards compatibility
3312 _git ()
3313 {
3314         __git_wrap__git_main
3315 }
3316
3317 # wrapper for backwards compatibility
3318 _gitk ()
3319 {
3320         __git_wrap__gitk_main
3321 }
3322
3323 __git_complete git __git_main
3324 __git_complete gitk __gitk_main
3325
3326 # The following are necessary only for Cygwin, and only are needed
3327 # when the user has tab-completed the executable name and consequently
3328 # included the '.exe' suffix.
3329 #
3330 if [ Cygwin = "$(uname -o 2>/dev/null)" ]; then
3331 __git_complete git.exe __git_main
3332 fi