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