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