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