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