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