git.oblomov.eu Git - git/blob - contrib/completion/git-completion.bash

   1 # bash/zsh completion support for core Git.
   2 #
   3 # Copyright (C) 2006,2007 Shawn O. Pearce <spearce@spearce.org>
   4 # Conceptually based on gitcompletion (http://gitweb.hawaga.org.uk/).
   5 # Distributed under the GNU General Public License, version 2.0.
   6 #
   7 # The contained completion routines provide support for completing:
   8 #
   9 #    *) local and remote branch names
  10 #    *) local and remote tag names
  11 #    *) .git/remotes file names
  12 #    *) git 'subcommands'
  13 #    *) git email aliases for git-send-email
  14 #    *) tree paths within 'ref:path/to/file' expressions
  15 #    *) file paths within current working directory and index
  16 #    *) common --long-options
  17 #
  18 # To use these routines:
  19 #
  20 #    1) Copy this file to somewhere (e.g. ~/.git-completion.bash).
  21 #    2) Add the following line to your .bashrc/.zshrc:
  22 #        source ~/.git-completion.bash
  23 #    3) Consider changing your PS1 to also show the current branch,
  24 #       see git-prompt.sh for details.
  25 #
  26 # If you use complex aliases of form '!f() { ... }; f', you can use the null
  27 # command ':' as the first command in the function body to declare the desired
  28 # completion style.  For example '!f() { : git commit ; ... }; f' will
  29 # tell the completion to use commit completion.  This also works with aliases
  30 # of form "!sh -c '...'".  For example, "!sh -c ': git commit ; ... '".
  31 #
  32 # Compatible with bash 3.2.57.
  33 #
  34 # You can set the following environment variables to influence the behavior of
  35 # the completion routines:
  36 #
  37 #   GIT_COMPLETION_CHECKOUT_NO_GUESS
  38 #
  39 #     When set to "1", do not include "DWIM" suggestions in git-checkout
  40 #     completion (e.g., completing "foo" when "origin/foo" exists).
  41
  42 case "$COMP_WORDBREAKS" in
  43 *:*) : great ;;
  44 *)   COMP_WORDBREAKS="$COMP_WORDBREAKS:"
  45 esac
  46
  47 # Discovers the path to the git repository taking any '--git-dir=<path>' and
  48 # '-C <path>' options into account and stores it in the $__git_repo_path
  49 # variable.
  50 __git_find_repo_path ()
  51 {
  52         if [ -n "$__git_repo_path" ]; then
  53                 # we already know where it is
  54                 return
  55         fi
  56
  57         if [ -n "${__git_C_args-}" ]; then
  58                 __git_repo_path="$(git "${__git_C_args[@]}" \
  59                         ${__git_dir:+--git-dir="$__git_dir"} \
  60                         rev-parse --absolute-git-dir 2>/dev/null)"
  61         elif [ -n "${__git_dir-}" ]; then
  62                 test -d "$__git_dir" &&
  63                 __git_repo_path="$__git_dir"
  64         elif [ -n "${GIT_DIR-}" ]; then
  65                 test -d "${GIT_DIR-}" &&
  66                 __git_repo_path="$GIT_DIR"
  67         elif [ -d .git ]; then
  68                 __git_repo_path=.git
  69         else
  70                 __git_repo_path="$(git rev-parse --git-dir 2>/dev/null)"
  71         fi
  72 }
  73
  74 # Deprecated: use __git_find_repo_path() and $__git_repo_path instead
  75 # __gitdir accepts 0 or 1 arguments (i.e., location)
  76 # returns location of .git repo
  77 __gitdir ()
  78 {
  79         if [ -z "${1-}" ]; then
  80                 __git_find_repo_path || return 1
  81                 echo "$__git_repo_path"
  82         elif [ -d "$1/.git" ]; then
  83                 echo "$1/.git"
  84         else
  85                 echo "$1"
  86         fi
  87 }
  88
  89 # Runs git with all the options given as argument, respecting any
  90 # '--git-dir=<path>' and '-C <path>' options present on the command line
  91 __git ()
  92 {
  93         git ${__git_C_args:+"${__git_C_args[@]}"} \
  94                 ${__git_dir:+--git-dir="$__git_dir"} "$@" 2>/dev/null
  95 }
  96
  97 # The following function is based on code from:
  98 #
  99 #   bash_completion - programmable completion functions for bash 3.2+
 100 #
 101 #   Copyright © 2006-2008, Ian Macdonald <ian@caliban.org>
 102 #             © 2009-2010, Bash Completion Maintainers
 103 #                     <bash-completion-devel@lists.alioth.debian.org>
 104 #
 105 #   This program is free software; you can redistribute it and/or modify
 106 #   it under the terms of the GNU General Public License as published by
 107 #   the Free Software Foundation; either version 2, or (at your option)
 108 #   any later version.
 109 #
 110 #   This program is distributed in the hope that it will be useful,
 111 #   but WITHOUT ANY WARRANTY; without even the implied warranty of
 112 #   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 113 #   GNU General Public License for more details.
 114 #
 115 #   You should have received a copy of the GNU General Public License
 116 #   along with this program; if not, see <http://www.gnu.org/licenses/>.
 117 #
 118 #   The latest version of this software can be obtained here:
 119 #
 120 #   http://bash-completion.alioth.debian.org/
 121 #
 122 #   RELEASE: 2.x
 123
 124 # This function can be used to access a tokenized list of words
 125 # on the command line:
 126 #
 127 #       __git_reassemble_comp_words_by_ref '=:'
 128 #       if test "${words_[cword_-1]}" = -w
 129 #       then
 130 #               ...
 131 #       fi
 132 #
 133 # The argument should be a collection of characters from the list of
 134 # word completion separators (COMP_WORDBREAKS) to treat as ordinary
 135 # characters.
 136 #
 137 # This is roughly equivalent to going back in time and setting
 138 # COMP_WORDBREAKS to exclude those characters.  The intent is to
 139 # make option types like --date=<type> and <rev>:<path> easy to
 140 # recognize by treating each shell word as a single token.
 141 #
 142 # It is best not to set COMP_WORDBREAKS directly because the value is
 143 # shared with other completion scripts.  By the time the completion
 144 # function gets called, COMP_WORDS has already been populated so local
 145 # changes to COMP_WORDBREAKS have no effect.
 146 #
 147 # Output: words_, cword_, cur_.
 148
 149 __git_reassemble_comp_words_by_ref()
 150 {
 151         local exclude i j first
 152         # Which word separators to exclude?
 153         exclude="${1//[^$COMP_WORDBREAKS]}"
 154         cword_=$COMP_CWORD
 155         if [ -z "$exclude" ]; then
 156                 words_=("${COMP_WORDS[@]}")
 157                 return
 158         fi
 159         # List of word completion separators has shrunk;
 160         # re-assemble words to complete.
 161         for ((i=0, j=0; i < ${#COMP_WORDS[@]}; i++, j++)); do
 162                 # Append each nonempty word consisting of just
 163                 # word separator characters to the current word.
 164                 first=t
 165                 while
 166                         [ $i -gt 0 ] &&
 167                         [ -n "${COMP_WORDS[$i]}" ] &&
 168                         # word consists of excluded word separators
 169                         [ "${COMP_WORDS[$i]//[^$exclude]}" = "${COMP_WORDS[$i]}" ]
 170                 do
 171                         # Attach to the previous token,
 172                         # unless the previous token is the command name.
 173                         if [ $j -ge 2 ] && [ -n "$first" ]; then
 174                                 ((j--))
 175                         fi
 176                         first=
 177                         words_[$j]=${words_[j]}${COMP_WORDS[i]}
 178                         if [ $i = $COMP_CWORD ]; then
 179                                 cword_=$j
 180                         fi
 181                         if (($i < ${#COMP_WORDS[@]} - 1)); then
 182                                 ((i++))
 183                         else
 184                                 # Done.
 185                                 return
 186                         fi
 187                 done
 188                 words_[$j]=${words_[j]}${COMP_WORDS[i]}
 189                 if [ $i = $COMP_CWORD ]; then
 190                         cword_=$j
 191                 fi
 192         done
 193 }
 194
 195 if ! type _get_comp_words_by_ref >/dev/null 2>&1; then
 196 _get_comp_words_by_ref ()
 197 {
 198         local exclude cur_ words_ cword_
 199         if [ "$1" = "-n" ]; then
 200                 exclude=$2
 201                 shift 2
 202         fi
 203         __git_reassemble_comp_words_by_ref "$exclude"
 204         cur_=${words_[cword_]}
 205         while [ $# -gt 0 ]; do
 206                 case "$1" in
 207                 cur)
 208                         cur=$cur_
 209                         ;;
 210                 prev)
 211                         prev=${words_[$cword_-1]}
 212                         ;;
 213                 words)
 214                         words=("${words_[@]}")
 215                         ;;
 216                 cword)
 217                         cword=$cword_
 218                         ;;
 219                 esac
 220                 shift
 221         done
 222 }
 223 fi
 224
 225 # Fills the COMPREPLY array with prefiltered words without any additional
 226 # processing.
 227 # Callers must take care of providing only words that match the current word
 228 # to be completed and adding any prefix and/or suffix (trailing space!), if
 229 # necessary.
 230 # 1: List of newline-separated matching completion words, complete with
 231 #    prefix and suffix.
 232 __gitcomp_direct ()
 233 {
 234         local IFS=$'\n'
 235
 236         COMPREPLY=($1)
 237 }
 238
 239 __gitcompappend ()
 240 {
 241         local x i=${#COMPREPLY[@]}
 242         for x in $1; do
 243                 if [[ "$x" == "$3"* ]]; then
 244                         COMPREPLY[i++]="$2$x$4"
 245                 fi
 246         done
 247 }
 248
 249 __gitcompadd ()
 250 {
 251         COMPREPLY=()
 252         __gitcompappend "$@"
 253 }
 254
 255 # Generates completion reply, appending a space to possible completion words,
 256 # if necessary.
 257 # It accepts 1 to 4 arguments:
 258 # 1: List of possible completion words.
 259 # 2: A prefix to be added to each possible completion word (optional).
 260 # 3: Generate possible completion matches for this word (optional).
 261 # 4: A suffix to be appended to each possible completion word (optional).
 262 __gitcomp ()
 263 {
 264         local cur_="${3-$cur}"
 265
 266         case "$cur_" in
 267         --*=)
 268                 ;;
 269         *)
 270                 local c i=0 IFS=$' \t\n'
 271                 for c in $1; do
 272                         c="$c${4-}"
 273                         if [[ $c == "$cur_"* ]]; then
 274                                 case $c in
 275                                 --*=*|*.) ;;
 276                                 *) c="$c " ;;
 277                                 esac
 278                                 COMPREPLY[i++]="${2-}$c"
 279                         fi
 280                 done
 281                 ;;
 282         esac
 283 }
 284
 285 # Clear the variables caching builtins' options when (re-)sourcing
 286 # the completion script.
 287 unset $(set |sed -ne 's/^\(__gitcomp_builtin_[a-zA-Z0-9_][a-zA-Z0-9_]*\)=.*/\1/p') 2>/dev/null
 288
 289 # This function is equivalent to
 290 #
 291 #    __gitcomp "$(git xxx --git-completion-helper) ..."
 292 #
 293 # except that the output is cached. Accept 1-3 arguments:
 294 # 1: the git command to execute, this is also the cache key
 295 # 2: extra options to be added on top (e.g. negative forms)
 296 # 3: options to be excluded
 297 __gitcomp_builtin ()
 298 {
 299         # spaces must be replaced with underscore for multi-word
 300         # commands, e.g. "git remote add" becomes remote_add.
 301         local cmd="$1"
 302         local incl="$2"
 303         local excl="$3"
 304
 305         local var=__gitcomp_builtin_"${cmd/-/_}"
 306         local options
 307         eval "options=\$$var"
 308
 309         if [ -z "$options" ]; then
 310                 # leading and trailing spaces are significant to make
 311                 # option removal work correctly.
 312                 options=" $(__git ${cmd/_/ } --git-completion-helper) $incl "
 313                 for i in $excl; do
 314                         options="${options/ $i / }"
 315                 done
 316                 eval "$var=\"$options\""
 317         fi
 318
 319         __gitcomp "$options"
 320 }
 321
 322 # Variation of __gitcomp_nl () that appends to the existing list of
 323 # completion candidates, COMPREPLY.
 324 __gitcomp_nl_append ()
 325 {
 326         local IFS=$'\n'
 327         __gitcompappend "$1" "${2-}" "${3-$cur}" "${4- }"
 328 }
 329
 330 # Generates completion reply from newline-separated possible completion words
 331 # by appending a space to all of them.
 332 # It accepts 1 to 4 arguments:
 333 # 1: List of possible completion words, separated by a single newline.
 334 # 2: A prefix to be added to each possible completion word (optional).
 335 # 3: Generate possible completion matches for this word (optional).
 336 # 4: A suffix to be appended to each possible completion word instead of
 337 #    the default space (optional).  If specified but empty, nothing is
 338 #    appended.
 339 __gitcomp_nl ()
 340 {
 341         COMPREPLY=()
 342         __gitcomp_nl_append "$@"
 343 }
 344
 345 # Generates completion reply with compgen from newline-separated possible
 346 # completion filenames.
 347 # It accepts 1 to 3 arguments:
 348 # 1: List of possible completion filenames, separated by a single newline.
 349 # 2: A directory prefix to be added to each possible completion filename
 350 #    (optional).
 351 # 3: Generate possible completion matches for this word (optional).
 352 __gitcomp_file ()
 353 {
 354         local IFS=$'\n'
 355
 356         # XXX does not work when the directory prefix contains a tilde,
 357         # since tilde expansion is not applied.
 358         # This means that COMPREPLY will be empty and Bash default
 359         # completion will be used.
 360         __gitcompadd "$1" "${2-}" "${3-$cur}" ""
 361
 362         # use a hack to enable file mode in bash < 4
 363         compopt -o filenames +o nospace 2>/dev/null ||
 364         compgen -f /non-existing-dir/ > /dev/null
 365 }
 366
 367 # Execute 'git ls-files', unless the --committable option is specified, in
 368 # which case it runs 'git diff-index' to find out the files that can be
 369 # committed.  It return paths relative to the directory specified in the first
 370 # argument, and using the options specified in the second argument.
 371 __git_ls_files_helper ()
 372 {
 373         if [ "$2" == "--committable" ]; then
 374                 __git -C "$1" diff-index --name-only --relative HEAD
 375         else
 376                 # NOTE: $2 is not quoted in order to support multiple options
 377                 __git -C "$1" ls-files --exclude-standard $2
 378         fi
 379 }
 380
 381
 382 # __git_index_files accepts 1 or 2 arguments:
 383 # 1: Options to pass to ls-files (required).
 384 # 2: A directory path (optional).
 385 #    If provided, only files within the specified directory are listed.
 386 #    Sub directories are never recursed.  Path must have a trailing
 387 #    slash.
 388 __git_index_files ()
 389 {
 390         local root="${2-.}" file
 391
 392         __git_ls_files_helper "$root" "$1" |
 393         while read -r file; do
 394                 case "$file" in
 395                 ?*/*) echo "${file%%/*}" ;;
 396                 *) echo "$file" ;;
 397                 esac
 398         done | sort | uniq
 399 }
 400
 401 # Lists branches from the local repository.
 402 # 1: A prefix to be added to each listed branch (optional).
 403 # 2: List only branches matching this word (optional; list all branches if
 404 #    unset or empty).
 405 # 3: A suffix to be appended to each listed branch (optional).
 406 __git_heads ()
 407 {
 408         local pfx="${1-}" cur_="${2-}" sfx="${3-}"
 409
 410         __git for-each-ref --format="${pfx//\%/%%}%(refname:strip=2)$sfx" \
 411                         "refs/heads/$cur_*" "refs/heads/$cur_*/**"
 412 }
 413
 414 # Lists tags from the local repository.
 415 # Accepts the same positional parameters as __git_heads() above.
 416 __git_tags ()
 417 {
 418         local pfx="${1-}" cur_="${2-}" sfx="${3-}"
 419
 420         __git for-each-ref --format="${pfx//\%/%%}%(refname:strip=2)$sfx" \
 421                         "refs/tags/$cur_*" "refs/tags/$cur_*/**"
 422 }
 423
 424 # Lists refs from the local (by default) or from a remote repository.
 425 # It accepts 0, 1 or 2 arguments:
 426 # 1: The remote to list refs from (optional; ignored, if set but empty).
 427 #    Can be the name of a configured remote, a path, or a URL.
 428 # 2: In addition to local refs, list unique branches from refs/remotes/ for
 429 #    'git checkout's tracking DWIMery (optional; ignored, if set but empty).
 430 # 3: A prefix to be added to each listed ref (optional).
 431 # 4: List only refs matching this word (optional; list all refs if unset or
 432 #    empty).
 433 # 5: A suffix to be appended to each listed ref (optional; ignored, if set
 434 #    but empty).
 435 #
 436 # Use __git_complete_refs() instead.
 437 __git_refs ()
 438 {
 439         local i hash dir track="${2-}"
 440         local list_refs_from=path remote="${1-}"
 441         local format refs
 442         local pfx="${3-}" cur_="${4-$cur}" sfx="${5-}"
 443         local match="${4-}"
 444         local fer_pfx="${pfx//\%/%%}" # "escape" for-each-ref format specifiers
 445
 446         __git_find_repo_path
 447         dir="$__git_repo_path"
 448
 449         if [ -z "$remote" ]; then
 450                 if [ -z "$dir" ]; then
 451                         return
 452                 fi
 453         else
 454                 if __git_is_configured_remote "$remote"; then
 455                         # configured remote takes precedence over a
 456                         # local directory with the same name
 457                         list_refs_from=remote
 458                 elif [ -d "$remote/.git" ]; then
 459                         dir="$remote/.git"
 460                 elif [ -d "$remote" ]; then
 461                         dir="$remote"
 462                 else
 463                         list_refs_from=url
 464                 fi
 465         fi
 466
 467         if [ "$list_refs_from" = path ]; then
 468                 if [[ "$cur_" == ^* ]]; then
 469                         pfx="$pfx^"
 470                         fer_pfx="$fer_pfx^"
 471                         cur_=${cur_#^}
 472                         match=${match#^}
 473                 fi
 474                 case "$cur_" in
 475                 refs|refs/*)
 476                         format="refname"
 477                         refs=("$match*" "$match*/**")
 478                         track=""
 479                         ;;
 480                 *)
 481                         for i in HEAD FETCH_HEAD ORIG_HEAD MERGE_HEAD REBASE_HEAD; do
 482                                 case "$i" in
 483                                 $match*)
 484                                         if [ -e "$dir/$i" ]; then
 485                                                 echo "$pfx$i$sfx"
 486                                         fi
 487                                         ;;
 488                                 esac
 489                         done
 490                         format="refname:strip=2"
 491                         refs=("refs/tags/$match*" "refs/tags/$match*/**"
 492                                 "refs/heads/$match*" "refs/heads/$match*/**"
 493                                 "refs/remotes/$match*" "refs/remotes/$match*/**")
 494                         ;;
 495                 esac
 496                 __git_dir="$dir" __git for-each-ref --format="$fer_pfx%($format)$sfx" \
 497                         "${refs[@]}"
 498                 if [ -n "$track" ]; then
 499                         # employ the heuristic used by git checkout
 500                         # Try to find a remote branch that matches the completion word
 501                         # but only output if the branch name is unique
 502                         __git for-each-ref --format="$fer_pfx%(refname:strip=3)$sfx" \
 503                                 --sort="refname:strip=3" \
 504                                 "refs/remotes/*/$match*" "refs/remotes/*/$match*/**" | \
 505                         uniq -u
 506                 fi
 507                 return
 508         fi
 509         case "$cur_" in
 510         refs|refs/*)
 511                 __git ls-remote "$remote" "$match*" | \
 512                 while read -r hash i; do
 513                         case "$i" in
 514                         *^{}) ;;
 515                         *) echo "$pfx$i$sfx" ;;
 516                         esac
 517                 done
 518                 ;;
 519         *)
 520                 if [ "$list_refs_from" = remote ]; then
 521                         case "HEAD" in
 522                         $match*)        echo "${pfx}HEAD$sfx" ;;
 523                         esac
 524                         __git for-each-ref --format="$fer_pfx%(refname:strip=3)$sfx" \
 525                                 "refs/remotes/$remote/$match*" \
 526                                 "refs/remotes/$remote/$match*/**"
 527                 else
 528                         local query_symref
 529                         case "HEAD" in
 530                         $match*)        query_symref="HEAD" ;;
 531                         esac
 532                         __git ls-remote "$remote" $query_symref \
 533                                 "refs/tags/$match*" "refs/heads/$match*" \
 534                                 "refs/remotes/$match*" |
 535                         while read -r hash i; do
 536                                 case "$i" in
 537                                 *^{})   ;;
 538                                 refs/*) echo "$pfx${i#refs/*/}$sfx" ;;
 539                                 *)      echo "$pfx$i$sfx" ;;  # symbolic refs
 540                                 esac
 541                         done
 542                 fi
 543                 ;;
 544         esac
 545 }
 546
 547 # Completes refs, short and long, local and remote, symbolic and pseudo.
 548 #
 549 # Usage: __git_complete_refs [<option>]...
 550 # --remote=<remote>: The remote to list refs from, can be the name of a
 551 #                    configured remote, a path, or a URL.
 552 # --track: List unique remote branches for 'git checkout's tracking DWIMery.
 553 # --pfx=<prefix>: A prefix to be added to each ref.
 554 # --cur=<word>: The current ref to be completed.  Defaults to the current
 555 #               word to be completed.
 556 # --sfx=<suffix>: A suffix to be appended to each ref instead of the default
 557 #                 space.
 558 __git_complete_refs ()
 559 {
 560         local remote track pfx cur_="$cur" sfx=" "
 561
 562         while test $# != 0; do
 563                 case "$1" in
 564                 --remote=*)     remote="${1##--remote=}" ;;
 565                 --track)        track="yes" ;;
 566                 --pfx=*)        pfx="${1##--pfx=}" ;;
 567                 --cur=*)        cur_="${1##--cur=}" ;;
 568                 --sfx=*)        sfx="${1##--sfx=}" ;;
 569                 *)              return 1 ;;
 570                 esac
 571                 shift
 572         done
 573
 574         __gitcomp_direct "$(__git_refs "$remote" "$track" "$pfx" "$cur_" "$sfx")"
 575 }
 576
 577 # __git_refs2 requires 1 argument (to pass to __git_refs)
 578 # Deprecated: use __git_complete_fetch_refspecs() instead.
 579 __git_refs2 ()
 580 {
 581         local i
 582         for i in $(__git_refs "$1"); do
 583                 echo "$i:$i"
 584         done
 585 }
 586
 587 # Completes refspecs for fetching from a remote repository.
 588 # 1: The remote repository.
 589 # 2: A prefix to be added to each listed refspec (optional).
 590 # 3: The ref to be completed as a refspec instead of the current word to be
 591 #    completed (optional)
 592 # 4: A suffix to be appended to each listed refspec instead of the default
 593 #    space (optional).
 594 __git_complete_fetch_refspecs ()
 595 {
 596         local i remote="$1" pfx="${2-}" cur_="${3-$cur}" sfx="${4- }"
 597
 598         __gitcomp_direct "$(
 599                 for i in $(__git_refs "$remote" "" "" "$cur_") ; do
 600                         echo "$pfx$i:$i$sfx"
 601                 done
 602                 )"
 603 }
 604
 605 # __git_refs_remotes requires 1 argument (to pass to ls-remote)
 606 __git_refs_remotes ()
 607 {
 608         local i hash
 609         __git ls-remote "$1" 'refs/heads/*' | \
 610         while read -r hash i; do
 611                 echo "$i:refs/remotes/$1/${i#refs/heads/}"
 612         done
 613 }
 614
 615 __git_remotes ()
 616 {
 617         __git_find_repo_path
 618         test -d "$__git_repo_path/remotes" && ls -1 "$__git_repo_path/remotes"
 619         __git remote
 620 }
 621
 622 # Returns true if $1 matches the name of a configured remote, false otherwise.
 623 __git_is_configured_remote ()
 624 {
 625         local remote
 626         for remote in $(__git_remotes); do
 627                 if [ "$remote" = "$1" ]; then
 628                         return 0
 629                 fi
 630         done
 631         return 1
 632 }
 633
 634 __git_list_merge_strategies ()
 635 {
 636         LANG=C LC_ALL=C git merge -s help 2>&1 |
 637         sed -n -e '/[Aa]vailable strategies are: /,/^$/{
 638                 s/\.$//
 639                 s/.*://
 640                 s/^[    ]*//
 641                 s/[     ]*$//
 642                 p
 643         }'
 644 }
 645
 646 __git_merge_strategies=
 647 # 'git merge -s help' (and thus detection of the merge strategy
 648 # list) fails, unfortunately, if run outside of any git working
 649 # tree.  __git_merge_strategies is set to the empty string in
 650 # that case, and the detection will be repeated the next time it
 651 # is needed.
 652 __git_compute_merge_strategies ()
 653 {
 654         test -n "$__git_merge_strategies" ||
 655         __git_merge_strategies=$(__git_list_merge_strategies)
 656 }
 657
 658 __git_complete_revlist_file ()
 659 {
 660         local pfx ls ref cur_="$cur"
 661         case "$cur_" in
 662         *..?*:*)
 663                 return
 664                 ;;
 665         ?*:*)
 666                 ref="${cur_%%:*}"
 667                 cur_="${cur_#*:}"
 668                 case "$cur_" in
 669                 ?*/*)
 670                         pfx="${cur_%/*}"
 671                         cur_="${cur_##*/}"
 672                         ls="$ref:$pfx"
 673                         pfx="$pfx/"
 674                         ;;
 675                 *)
 676                         ls="$ref"
 677                         ;;
 678                 esac
 679
 680                 case "$COMP_WORDBREAKS" in
 681                 *:*) : great ;;
 682                 *)   pfx="$ref:$pfx" ;;
 683                 esac
 684
 685                 __gitcomp_nl "$(__git ls-tree "$ls" \
 686                                 | sed '/^100... blob /{
 687                                            s,^.*        ,,
 688                                            s,$, ,
 689                                        }
 690                                        /^120000 blob /{
 691                                            s,^.*        ,,
 692                                            s,$, ,
 693                                        }
 694                                        /^040000 tree /{
 695                                            s,^.*        ,,
 696                                            s,$,/,
 697                                        }
 698                                        s/^.*    //')" \
 699                         "$pfx" "$cur_" ""
 700                 ;;
 701         *...*)
 702                 pfx="${cur_%...*}..."
 703                 cur_="${cur_#*...}"
 704                 __git_complete_refs --pfx="$pfx" --cur="$cur_"
 705                 ;;
 706         *..*)
 707                 pfx="${cur_%..*}.."
 708                 cur_="${cur_#*..}"
 709                 __git_complete_refs --pfx="$pfx" --cur="$cur_"
 710                 ;;
 711         *)
 712                 __git_complete_refs
 713                 ;;
 714         esac
 715 }
 716
 717
 718 # __git_complete_index_file requires 1 argument:
 719 # 1: the options to pass to ls-file
 720 #
 721 # The exception is --committable, which finds the files appropriate commit.
 722 __git_complete_index_file ()
 723 {
 724         local pfx="" cur_="$cur"
 725
 726         case "$cur_" in
 727         ?*/*)
 728                 pfx="${cur_%/*}"
 729                 cur_="${cur_##*/}"
 730                 pfx="${pfx}/"
 731                 ;;
 732         esac
 733
 734         __gitcomp_file "$(__git_index_files "$1" ${pfx:+"$pfx"})" "$pfx" "$cur_"
 735 }
 736
 737 __git_complete_file ()
 738 {
 739         __git_complete_revlist_file
 740 }
 741
 742 __git_complete_revlist ()
 743 {
 744         __git_complete_revlist_file
 745 }
 746
 747 __git_complete_remote_or_refspec ()
 748 {
 749         local cur_="$cur" cmd="${words[1]}"
 750         local i c=2 remote="" pfx="" lhs=1 no_complete_refspec=0
 751         if [ "$cmd" = "remote" ]; then
 752                 ((c++))
 753         fi
 754         while [ $c -lt $cword ]; do
 755                 i="${words[c]}"
 756                 case "$i" in
 757                 --mirror) [ "$cmd" = "push" ] && no_complete_refspec=1 ;;
 758                 -d|--delete) [ "$cmd" = "push" ] && lhs=0 ;;
 759                 --all)
 760                         case "$cmd" in
 761                         push) no_complete_refspec=1 ;;
 762                         fetch)
 763                                 return
 764                                 ;;
 765                         *) ;;
 766                         esac
 767                         ;;
 768                 -*) ;;
 769                 *) remote="$i"; break ;;
 770                 esac
 771                 ((c++))
 772         done
 773         if [ -z "$remote" ]; then
 774                 __gitcomp_nl "$(__git_remotes)"
 775                 return
 776         fi
 777         if [ $no_complete_refspec = 1 ]; then
 778                 return
 779         fi
 780         [ "$remote" = "." ] && remote=
 781         case "$cur_" in
 782         *:*)
 783                 case "$COMP_WORDBREAKS" in
 784                 *:*) : great ;;
 785                 *)   pfx="${cur_%%:*}:" ;;
 786                 esac
 787                 cur_="${cur_#*:}"
 788                 lhs=0
 789                 ;;
 790         +*)
 791                 pfx="+"
 792                 cur_="${cur_#+}"
 793                 ;;
 794         esac
 795         case "$cmd" in
 796         fetch)
 797                 if [ $lhs = 1 ]; then
 798                         __git_complete_fetch_refspecs "$remote" "$pfx" "$cur_"
 799                 else
 800                         __git_complete_refs --pfx="$pfx" --cur="$cur_"
 801                 fi
 802                 ;;
 803         pull|remote)
 804                 if [ $lhs = 1 ]; then
 805                         __git_complete_refs --remote="$remote" --pfx="$pfx" --cur="$cur_"
 806                 else
 807                         __git_complete_refs --pfx="$pfx" --cur="$cur_"
 808                 fi
 809                 ;;
 810         push)
 811                 if [ $lhs = 1 ]; then
 812                         __git_complete_refs --pfx="$pfx" --cur="$cur_"
 813                 else
 814                         __git_complete_refs --remote="$remote" --pfx="$pfx" --cur="$cur_"
 815                 fi
 816                 ;;
 817         esac
 818 }
 819
 820 __git_complete_strategy ()
 821 {
 822         __git_compute_merge_strategies
 823         case "$prev" in
 824         -s|--strategy)
 825                 __gitcomp "$__git_merge_strategies"
 826                 return 0
 827         esac
 828         case "$cur" in
 829         --strategy=*)
 830                 __gitcomp "$__git_merge_strategies" "" "${cur##--strategy=}"
 831                 return 0
 832                 ;;
 833         esac
 834         return 1
 835 }
 836
 837 __git_commands () {
 838         if test -n "${GIT_TESTING_COMMAND_COMPLETION:-}"
 839         then
 840                 printf "%s" "${GIT_TESTING_COMMAND_COMPLETION}"
 841         else
 842                 git help -a|egrep '^  [a-zA-Z0-9]'
 843         fi
 844 }
 845
 846 __git_list_all_commands ()
 847 {
 848         local i IFS=" "$'\n'
 849         for i in $(__git_commands)
 850         do
 851                 case $i in
 852                 *--*)             : helper pattern;;
 853                 *) echo $i;;
 854                 esac
 855         done
 856 }
 857
 858 __git_all_commands=
 859 __git_compute_all_commands ()
 860 {
 861         test -n "$__git_all_commands" ||
 862         __git_all_commands=$(__git_list_all_commands)
 863 }
 864
 865 __git_list_porcelain_commands ()
 866 {
 867         local i IFS=" "$'\n'
 868         __git_compute_all_commands
 869         for i in $__git_all_commands
 870         do
 871                 case $i in
 872                 *--*)             : helper pattern;;
 873                 applymbox)        : ask gittus;;
 874                 applypatch)       : ask gittus;;
 875                 archimport)       : import;;
 876                 cat-file)         : plumbing;;
 877                 check-attr)       : plumbing;;
 878                 check-ignore)     : plumbing;;
 879                 check-mailmap)    : plumbing;;
 880                 check-ref-format) : plumbing;;
 881                 checkout-index)   : plumbing;;
 882                 column)           : internal helper;;
 883                 commit-tree)      : plumbing;;
 884                 count-objects)    : infrequent;;
 885                 credential)       : credentials;;
 886                 credential-*)     : credentials helper;;
 887                 cvsexportcommit)  : export;;
 888                 cvsimport)        : import;;
 889                 cvsserver)        : daemon;;
 890                 daemon)           : daemon;;
 891                 diff-files)       : plumbing;;
 892                 diff-index)       : plumbing;;
 893                 diff-tree)        : plumbing;;
 894                 fast-import)      : import;;
 895                 fast-export)      : export;;
 896                 fsck-objects)     : plumbing;;
 897                 fetch-pack)       : plumbing;;
 898                 fmt-merge-msg)    : plumbing;;
 899                 for-each-ref)     : plumbing;;
 900                 hash-object)      : plumbing;;
 901                 http-*)           : transport;;
 902                 index-pack)       : plumbing;;
 903                 init-db)          : deprecated;;
 904                 local-fetch)      : plumbing;;
 905                 ls-files)         : plumbing;;
 906                 ls-remote)        : plumbing;;
 907                 ls-tree)          : plumbing;;
 908                 mailinfo)         : plumbing;;
 909                 mailsplit)        : plumbing;;
 910                 merge-*)          : plumbing;;
 911                 mktree)           : plumbing;;
 912                 mktag)            : plumbing;;
 913                 pack-objects)     : plumbing;;
 914                 pack-redundant)   : plumbing;;
 915                 pack-refs)        : plumbing;;
 916                 parse-remote)     : plumbing;;
 917                 patch-id)         : plumbing;;
 918                 prune)            : plumbing;;
 919                 prune-packed)     : plumbing;;
 920                 quiltimport)      : import;;
 921                 read-tree)        : plumbing;;
 922                 receive-pack)     : plumbing;;
 923                 remote-*)         : transport;;
 924                 rerere)           : plumbing;;
 925                 rev-list)         : plumbing;;
 926                 rev-parse)        : plumbing;;
 927                 runstatus)        : plumbing;;
 928                 sh-setup)         : internal;;
 929                 shell)            : daemon;;
 930                 show-ref)         : plumbing;;
 931                 send-pack)        : plumbing;;
 932                 show-index)       : plumbing;;
 933                 ssh-*)            : transport;;
 934                 stripspace)       : plumbing;;
 935                 symbolic-ref)     : plumbing;;
 936                 unpack-file)      : plumbing;;
 937                 unpack-objects)   : plumbing;;
 938                 update-index)     : plumbing;;
 939                 update-ref)       : plumbing;;
 940                 update-server-info) : daemon;;
 941                 upload-archive)   : plumbing;;
 942                 upload-pack)      : plumbing;;
 943                 write-tree)       : plumbing;;
 944                 var)              : infrequent;;
 945                 verify-pack)      : infrequent;;
 946                 verify-tag)       : plumbing;;
 947                 *) echo $i;;
 948                 esac
 949         done
 950 }
 951
 952 __git_porcelain_commands=
 953 __git_compute_porcelain_commands ()
 954 {
 955         test -n "$__git_porcelain_commands" ||
 956         __git_porcelain_commands=$(__git_list_porcelain_commands)
 957 }
 958
 959 # Lists all set config variables starting with the given section prefix,
 960 # with the prefix removed.
 961 __git_get_config_variables ()
 962 {
 963         local section="$1" i IFS=$'\n'
 964         for i in $(__git config --name-only --get-regexp "^$section\..*"); do
 965                 echo "${i#$section.}"
 966         done
 967 }
 968
 969 __git_pretty_aliases ()
 970 {
 971         __git_get_config_variables "pretty"
 972 }
 973
 974 __git_aliases ()
 975 {
 976         __git_get_config_variables "alias"
 977 }
 978
 979 # __git_aliased_command requires 1 argument
 980 __git_aliased_command ()
 981 {
 982         local word cmdline=$(__git config --get "alias.$1")
 983         for word in $cmdline; do
 984                 case "$word" in
 985                 \!gitk|gitk)
 986                         echo "gitk"
 987                         return
 988                         ;;
 989                 \!*)    : shell command alias ;;
 990                 -*)     : option ;;
 991                 *=*)    : setting env ;;
 992                 git)    : git itself ;;
 993                 \(\))   : skip parens of shell function definition ;;
 994                 {)      : skip start of shell helper function ;;
 995                 :)      : skip null command ;;
 996                 \'*)    : skip opening quote after sh -c ;;
 997                 *)
 998                         echo "$word"
 999                         return
1000                 esac
1001         done
1002 }
1003
1004 # __git_find_on_cmdline requires 1 argument
1005 __git_find_on_cmdline ()
1006 {
1007         local word subcommand c=1
1008         while [ $c -lt $cword ]; do
1009                 word="${words[c]}"
1010                 for subcommand in $1; do
1011                         if [ "$subcommand" = "$word" ]; then
1012                                 echo "$subcommand"
1013                                 return
1014                         fi
1015                 done
1016                 ((c++))
1017         done
1018 }
1019
1020 # Echo the value of an option set on the command line or config
1021 #
1022 # $1: short option name
1023 # $2: long option name including =
1024 # $3: list of possible values
1025 # $4: config string (optional)
1026 #
1027 # example:
1028 # result="$(__git_get_option_value "-d" "--do-something=" \
1029 #     "yes no" "core.doSomething")"
1030 #
1031 # result is then either empty (no option set) or "yes" or "no"
1032 #
1033 # __git_get_option_value requires 3 arguments
1034 __git_get_option_value ()
1035 {
1036         local c short_opt long_opt val
1037         local result= values config_key word
1038
1039         short_opt="$1"
1040         long_opt="$2"
1041         values="$3"
1042         config_key="$4"
1043
1044         ((c = $cword - 1))
1045         while [ $c -ge 0 ]; do
1046                 word="${words[c]}"
1047                 for val in $values; do
1048                         if [ "$short_opt$val" = "$word" ] ||
1049                            [ "$long_opt$val"  = "$word" ]; then
1050                                 result="$val"
1051                                 break 2
1052                         fi
1053                 done
1054                 ((c--))
1055         done
1056
1057         if [ -n "$config_key" ] && [ -z "$result" ]; then
1058                 result="$(__git config "$config_key")"
1059         fi
1060
1061         echo "$result"
1062 }
1063
1064 __git_has_doubledash ()
1065 {
1066         local c=1
1067         while [ $c -lt $cword ]; do
1068                 if [ "--" = "${words[c]}" ]; then
1069                         return 0
1070                 fi
1071                 ((c++))
1072         done
1073         return 1
1074 }
1075
1076 # Try to count non option arguments passed on the command line for the
1077 # specified git command.
1078 # When options are used, it is necessary to use the special -- option to
1079 # tell the implementation were non option arguments begin.
1080 # XXX this can not be improved, since options can appear everywhere, as
1081 # an example:
1082 #       git mv x -n y
1083 #
1084 # __git_count_arguments requires 1 argument: the git command executed.
1085 __git_count_arguments ()
1086 {
1087         local word i c=0
1088
1089         # Skip "git" (first argument)
1090         for ((i=1; i < ${#words[@]}; i++)); do
1091                 word="${words[i]}"
1092
1093                 case "$word" in
1094                         --)
1095                                 # Good; we can assume that the following are only non
1096                                 # option arguments.
1097                                 ((c = 0))
1098                                 ;;
1099                         "$1")
1100                                 # Skip the specified git command and discard git
1101                                 # main options
1102                                 ((c = 0))
1103                                 ;;
1104                         ?*)
1105                                 ((c++))
1106                                 ;;
1107                 esac
1108         done
1109
1110         printf "%d" $c
1111 }
1112
1113 __git_whitespacelist="nowarn warn error error-all fix"
1114 __git_am_inprogress_options="--skip --continue --resolved --abort --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.compression
2354                 core.createObject
2355                 core.deltaBaseCacheLimit
2356                 core.editor
2357                 core.eol
2358                 core.excludesfile
2359                 core.fileMode
2360                 core.fsyncobjectfiles
2361                 core.gitProxy
2362                 core.hideDotFiles
2363                 core.hooksPath
2364                 core.ignoreStat
2365                 core.ignorecase
2366                 core.logAllRefUpdates
2367                 core.loosecompression
2368                 core.notesRef
2369                 core.packedGitLimit
2370                 core.packedGitWindowSize
2371                 core.packedRefsTimeout
2372                 core.pager
2373                 core.precomposeUnicode
2374                 core.preferSymlinkRefs
2375                 core.preloadindex
2376                 core.protectHFS
2377                 core.protectNTFS
2378                 core.quotepath
2379                 core.repositoryFormatVersion
2380                 core.safecrlf
2381                 core.sharedRepository
2382                 core.sparseCheckout
2383                 core.splitIndex
2384                 core.sshCommand
2385                 core.symlinks
2386                 core.trustctime
2387                 core.untrackedCache
2388                 core.warnAmbiguousRefs
2389                 core.whitespace
2390                 core.worktree
2391                 credential.helper
2392                 credential.useHttpPath
2393                 credential.username
2394                 credentialCache.ignoreSIGHUP
2395                 diff.autorefreshindex
2396                 diff.external
2397                 diff.ignoreSubmodules
2398                 diff.mnemonicprefix
2399                 diff.noprefix
2400                 diff.renameLimit
2401                 diff.renames
2402                 diff.statGraphWidth
2403                 diff.submodule
2404                 diff.suppressBlankEmpty
2405                 diff.tool
2406                 diff.wordRegex
2407                 diff.algorithm
2408                 difftool.
2409                 difftool.prompt
2410                 fetch.recurseSubmodules
2411                 fetch.unpackLimit
2412                 format.attach
2413                 format.cc
2414                 format.coverLetter
2415                 format.from
2416                 format.headers
2417                 format.numbered
2418                 format.pretty
2419                 format.signature
2420                 format.signoff
2421                 format.subjectprefix
2422                 format.suffix
2423                 format.thread
2424                 format.to
2425                 gc.
2426                 gc.aggressiveDepth
2427                 gc.aggressiveWindow
2428                 gc.auto
2429                 gc.autoDetach
2430                 gc.autopacklimit
2431                 gc.logExpiry
2432                 gc.packrefs
2433                 gc.pruneexpire
2434                 gc.reflogexpire
2435                 gc.reflogexpireunreachable
2436                 gc.rerereresolved
2437                 gc.rerereunresolved
2438                 gc.worktreePruneExpire
2439                 gitcvs.allbinary
2440                 gitcvs.commitmsgannotation
2441                 gitcvs.dbTableNamePrefix
2442                 gitcvs.dbdriver
2443                 gitcvs.dbname
2444                 gitcvs.dbpass
2445                 gitcvs.dbuser
2446                 gitcvs.enabled
2447                 gitcvs.logfile
2448                 gitcvs.usecrlfattr
2449                 guitool.
2450                 gui.blamehistoryctx
2451                 gui.commitmsgwidth
2452                 gui.copyblamethreshold
2453                 gui.diffcontext
2454                 gui.encoding
2455                 gui.fastcopyblame
2456                 gui.matchtrackingbranch
2457                 gui.newbranchtemplate
2458                 gui.pruneduringfetch
2459                 gui.spellingdictionary
2460                 gui.trustmtime
2461                 help.autocorrect
2462                 help.browser
2463                 help.format
2464                 http.lowSpeedLimit
2465                 http.lowSpeedTime
2466                 http.maxRequests
2467                 http.minSessions
2468                 http.noEPSV
2469                 http.postBuffer
2470                 http.proxy
2471                 http.sslCipherList
2472                 http.sslVersion
2473                 http.sslCAInfo
2474                 http.sslCAPath
2475                 http.sslCert
2476                 http.sslCertPasswordProtected
2477                 http.sslKey
2478                 http.sslVerify
2479                 http.useragent
2480                 i18n.commitEncoding
2481                 i18n.logOutputEncoding
2482                 imap.authMethod
2483                 imap.folder
2484                 imap.host
2485                 imap.pass
2486                 imap.port
2487                 imap.preformattedHTML
2488                 imap.sslverify
2489                 imap.tunnel
2490                 imap.user
2491                 init.templatedir
2492                 instaweb.browser
2493                 instaweb.httpd
2494                 instaweb.local
2495                 instaweb.modulepath
2496                 instaweb.port
2497                 interactive.singlekey
2498                 log.date
2499                 log.decorate
2500                 log.showroot
2501                 mailmap.file
2502                 man.
2503                 man.viewer
2504                 merge.
2505                 merge.conflictstyle
2506                 merge.log
2507                 merge.renameLimit
2508                 merge.renormalize
2509                 merge.stat
2510                 merge.tool
2511                 merge.verbosity
2512                 mergetool.
2513                 mergetool.keepBackup
2514                 mergetool.keepTemporaries
2515                 mergetool.prompt
2516                 notes.displayRef
2517                 notes.rewrite.
2518                 notes.rewrite.amend
2519                 notes.rewrite.rebase
2520                 notes.rewriteMode
2521                 notes.rewriteRef
2522                 pack.compression
2523                 pack.deltaCacheLimit
2524                 pack.deltaCacheSize
2525                 pack.depth
2526                 pack.indexVersion
2527                 pack.packSizeLimit
2528                 pack.threads
2529                 pack.window
2530                 pack.windowMemory
2531                 pager.
2532                 pretty.
2533                 pull.octopus
2534                 pull.twohead
2535                 push.default
2536                 push.followTags
2537                 rebase.autosquash
2538                 rebase.stat
2539                 receive.autogc
2540                 receive.denyCurrentBranch
2541                 receive.denyDeleteCurrent
2542                 receive.denyDeletes
2543                 receive.denyNonFastForwards
2544                 receive.fsckObjects
2545                 receive.unpackLimit
2546                 receive.updateserverinfo
2547                 remote.pushdefault
2548                 remotes.
2549                 repack.usedeltabaseoffset
2550                 rerere.autoupdate
2551                 rerere.enabled
2552                 sendemail.
2553                 sendemail.aliasesfile
2554                 sendemail.aliasfiletype
2555                 sendemail.bcc
2556                 sendemail.cc
2557                 sendemail.cccmd
2558                 sendemail.chainreplyto
2559                 sendemail.confirm
2560                 sendemail.envelopesender
2561                 sendemail.from
2562                 sendemail.identity
2563                 sendemail.multiedit
2564                 sendemail.signedoffbycc
2565                 sendemail.smtpdomain
2566                 sendemail.smtpencryption
2567                 sendemail.smtppass
2568                 sendemail.smtpserver
2569                 sendemail.smtpserveroption
2570                 sendemail.smtpserverport
2571                 sendemail.smtpuser
2572                 sendemail.suppresscc
2573                 sendemail.suppressfrom
2574                 sendemail.thread
2575                 sendemail.to
2576                 sendemail.tocmd
2577                 sendemail.validate
2578                 sendemail.smtpbatchsize
2579                 sendemail.smtprelogindelay
2580                 showbranch.default
2581                 status.relativePaths
2582                 status.showUntrackedFiles
2583                 status.submodulesummary
2584                 submodule.
2585                 tar.umask
2586                 transfer.unpackLimit
2587                 url.
2588                 user.email
2589                 user.name
2590                 user.signingkey
2591                 web.browser
2592                 branch. remote.
2593         "
2594 }
2595
2596 _git_remote ()
2597 {
2598         local subcommands="
2599                 add rename remove set-head set-branches
2600                 get-url set-url show prune update
2601                 "
2602         local subcommand="$(__git_find_on_cmdline "$subcommands")"
2603         if [ -z "$subcommand" ]; then
2604                 case "$cur" in
2605                 --*)
2606                         __gitcomp_builtin remote
2607                         ;;
2608                 *)
2609                         __gitcomp "$subcommands"
2610                         ;;
2611                 esac
2612                 return
2613         fi
2614
2615         case "$subcommand,$cur" in
2616         add,--*)
2617                 __gitcomp_builtin remote_add "--no-tags"
2618                 ;;
2619         add,*)
2620                 ;;
2621         set-head,--*)
2622                 __gitcomp_builtin remote_set-head
2623                 ;;
2624         set-branches,--*)
2625                 __gitcomp_builtin remote_set-branches
2626                 ;;
2627         set-head,*|set-branches,*)
2628                 __git_complete_remote_or_refspec
2629                 ;;
2630         update,--*)
2631                 __gitcomp_builtin remote_update
2632                 ;;
2633         update,*)
2634                 __gitcomp "$(__git_get_config_variables "remotes")"
2635                 ;;
2636         set-url,--*)
2637                 __gitcomp_builtin remote_set-url
2638                 ;;
2639         get-url,--*)
2640                 __gitcomp_builtin remote_get-url
2641                 ;;
2642         prune,--*)
2643                 __gitcomp_builtin remote_prune
2644                 ;;
2645         *)
2646                 __gitcomp_nl "$(__git_remotes)"
2647                 ;;
2648         esac
2649 }
2650
2651 _git_replace ()
2652 {
2653         case "$cur" in
2654         --*)
2655                 __gitcomp_builtin replace
2656                 return
2657                 ;;
2658         esac
2659         __git_complete_refs
2660 }
2661
2662 _git_rerere ()
2663 {
2664         local subcommands="clear forget diff remaining status gc"
2665         local subcommand="$(__git_find_on_cmdline "$subcommands")"
2666         if test -z "$subcommand"
2667         then
2668                 __gitcomp "$subcommands"
2669                 return
2670         fi
2671 }
2672
2673 _git_reset ()
2674 {
2675         __git_has_doubledash && return
2676
2677         case "$cur" in
2678         --*)
2679                 __gitcomp_builtin reset
2680                 return
2681                 ;;
2682         esac
2683         __git_complete_refs
2684 }
2685
2686 __git_revert_inprogress_options="--continue --quit --abort"
2687
2688 _git_revert ()
2689 {
2690         __git_find_repo_path
2691         if [ -f "$__git_repo_path"/REVERT_HEAD ]; then
2692                 __gitcomp "$__git_revert_inprogress_options"
2693                 return
2694         fi
2695         case "$cur" in
2696         --*)
2697                 __gitcomp_builtin revert "--no-edit" \
2698                         "$__git_revert_inprogress_options"
2699                 return
2700                 ;;
2701         esac
2702         __git_complete_refs
2703 }
2704
2705 _git_rm ()
2706 {
2707         case "$cur" in
2708         --*)
2709                 __gitcomp_builtin rm
2710                 return
2711                 ;;
2712         esac
2713
2714         __git_complete_index_file "--cached"
2715 }
2716
2717 _git_shortlog ()
2718 {
2719         __git_has_doubledash && return
2720
2721         case "$cur" in
2722         --*)
2723                 __gitcomp "
2724                         $__git_log_common_options
2725                         $__git_log_shortlog_options
2726                         --numbered --summary --email
2727                         "
2728                 return
2729                 ;;
2730         esac
2731         __git_complete_revlist
2732 }
2733
2734 _git_show ()
2735 {
2736         __git_has_doubledash && return
2737
2738         case "$cur" in
2739         --pretty=*|--format=*)
2740                 __gitcomp "$__git_log_pretty_formats $(__git_pretty_aliases)
2741                         " "" "${cur#*=}"
2742                 return
2743                 ;;
2744         --diff-algorithm=*)
2745                 __gitcomp "$__git_diff_algorithms" "" "${cur##--diff-algorithm=}"
2746                 return
2747                 ;;
2748         --submodule=*)
2749                 __gitcomp "$__git_diff_submodule_formats" "" "${cur##--submodule=}"
2750                 return
2751                 ;;
2752         --*)
2753                 __gitcomp "--pretty= --format= --abbrev-commit --oneline
2754                         --show-signature
2755                         $__git_diff_common_options
2756                         "
2757                 return
2758                 ;;
2759         esac
2760         __git_complete_revlist_file
2761 }
2762
2763 _git_show_branch ()
2764 {
2765         case "$cur" in
2766         --*)
2767                 __gitcomp_builtin show-branch "--no-color"
2768                 return
2769                 ;;
2770         esac
2771         __git_complete_revlist
2772 }
2773
2774 _git_stash ()
2775 {
2776         local save_opts='--all --keep-index --no-keep-index --quiet --patch --include-untracked'
2777         local subcommands='push save list show apply clear drop pop create branch'
2778         local subcommand="$(__git_find_on_cmdline "$subcommands")"
2779         if [ -z "$subcommand" ]; then
2780                 case "$cur" in
2781                 --*)
2782                         __gitcomp "$save_opts"
2783                         ;;
2784                 *)
2785                         if [ -z "$(__git_find_on_cmdline "$save_opts")" ]; then
2786                                 __gitcomp "$subcommands"
2787                         fi
2788                         ;;
2789                 esac
2790         else
2791                 case "$subcommand,$cur" in
2792                 push,--*)
2793                         __gitcomp "$save_opts --message"
2794                         ;;
2795                 save,--*)
2796                         __gitcomp "$save_opts"
2797                         ;;
2798                 apply,--*|pop,--*)
2799                         __gitcomp "--index --quiet"
2800                         ;;
2801                 drop,--*)
2802                         __gitcomp "--quiet"
2803                         ;;
2804                 show,--*|branch,--*)
2805                         ;;
2806                 branch,*)
2807                         if [ $cword -eq 3 ]; then
2808                                 __git_complete_refs
2809                         else
2810                                 __gitcomp_nl "$(__git stash list \
2811                                                 | sed -n -e 's/:.*//p')"
2812                         fi
2813                         ;;
2814                 show,*|apply,*|drop,*|pop,*)
2815                         __gitcomp_nl "$(__git stash list \
2816                                         | sed -n -e 's/:.*//p')"
2817                         ;;
2818                 *)
2819                         ;;
2820                 esac
2821         fi
2822 }
2823
2824 _git_submodule ()
2825 {
2826         __git_has_doubledash && return
2827
2828         local subcommands="add status init deinit update summary foreach sync"
2829         local subcommand="$(__git_find_on_cmdline "$subcommands")"
2830         if [ -z "$subcommand" ]; then
2831                 case "$cur" in
2832                 --*)
2833                         __gitcomp "--quiet"
2834                         ;;
2835                 *)
2836                         __gitcomp "$subcommands"
2837                         ;;
2838                 esac
2839                 return
2840         fi
2841
2842         case "$subcommand,$cur" in
2843         add,--*)
2844                 __gitcomp "--branch --force --name --reference --depth"
2845                 ;;
2846         status,--*)
2847                 __gitcomp "--cached --recursive"
2848                 ;;
2849         deinit,--*)
2850                 __gitcomp "--force --all"
2851                 ;;
2852         update,--*)
2853                 __gitcomp "
2854                         --init --remote --no-fetch
2855                         --recommend-shallow --no-recommend-shallow
2856                         --force --rebase --merge --reference --depth --recursive --jobs
2857                 "
2858                 ;;
2859         summary,--*)
2860                 __gitcomp "--cached --files --summary-limit"
2861                 ;;
2862         foreach,--*|sync,--*)
2863                 __gitcomp "--recursive"
2864                 ;;
2865         *)
2866                 ;;
2867         esac
2868 }
2869
2870 _git_svn ()
2871 {
2872         local subcommands="
2873                 init fetch clone rebase dcommit log find-rev
2874                 set-tree commit-diff info create-ignore propget
2875                 proplist show-ignore show-externals branch tag blame
2876                 migrate mkdirs reset gc
2877                 "
2878         local subcommand="$(__git_find_on_cmdline "$subcommands")"
2879         if [ -z "$subcommand" ]; then
2880                 __gitcomp "$subcommands"
2881         else
2882                 local remote_opts="--username= --config-dir= --no-auth-cache"
2883                 local fc_opts="
2884                         --follow-parent --authors-file= --repack=
2885                         --no-metadata --use-svm-props --use-svnsync-props
2886                         --log-window-size= --no-checkout --quiet
2887                         --repack-flags --use-log-author --localtime
2888                         --add-author-from
2889                         --ignore-paths= --include-paths= $remote_opts
2890                         "
2891                 local init_opts="
2892                         --template= --shared= --trunk= --tags=
2893                         --branches= --stdlayout --minimize-url
2894                         --no-metadata --use-svm-props --use-svnsync-props
2895                         --rewrite-root= --prefix= $remote_opts
2896                         "
2897                 local cmt_opts="
2898                         --edit --rmdir --find-copies-harder --copy-similarity=
2899                         "
2900
2901                 case "$subcommand,$cur" in
2902                 fetch,--*)
2903                         __gitcomp "--revision= --fetch-all $fc_opts"
2904                         ;;
2905                 clone,--*)
2906                         __gitcomp "--revision= $fc_opts $init_opts"
2907                         ;;
2908                 init,--*)
2909                         __gitcomp "$init_opts"
2910                         ;;
2911                 dcommit,--*)
2912                         __gitcomp "
2913                                 --merge --strategy= --verbose --dry-run
2914                                 --fetch-all --no-rebase --commit-url
2915                                 --revision --interactive $cmt_opts $fc_opts
2916                                 "
2917                         ;;
2918                 set-tree,--*)
2919                         __gitcomp "--stdin $cmt_opts $fc_opts"
2920                         ;;
2921                 create-ignore,--*|propget,--*|proplist,--*|show-ignore,--*|\
2922                 show-externals,--*|mkdirs,--*)
2923                         __gitcomp "--revision="
2924                         ;;
2925                 log,--*)
2926                         __gitcomp "
2927                                 --limit= --revision= --verbose --incremental
2928                                 --oneline --show-commit --non-recursive
2929                                 --authors-file= --color
2930                                 "
2931                         ;;
2932                 rebase,--*)
2933                         __gitcomp "
2934                                 --merge --verbose --strategy= --local
2935                                 --fetch-all --dry-run $fc_opts
2936                                 "
2937                         ;;
2938                 commit-diff,--*)
2939                         __gitcomp "--message= --file= --revision= $cmt_opts"
2940                         ;;
2941                 info,--*)
2942                         __gitcomp "--url"
2943                         ;;
2944                 branch,--*)
2945                         __gitcomp "--dry-run --message --tag"
2946                         ;;
2947                 tag,--*)
2948                         __gitcomp "--dry-run --message"
2949                         ;;
2950                 blame,--*)
2951                         __gitcomp "--git-format"
2952                         ;;
2953                 migrate,--*)
2954                         __gitcomp "
2955                                 --config-dir= --ignore-paths= --minimize
2956                                 --no-auth-cache --username=
2957                                 "
2958                         ;;
2959                 reset,--*)
2960                         __gitcomp "--revision= --parent"
2961                         ;;
2962                 *)
2963                         ;;
2964                 esac
2965         fi
2966 }
2967
2968 _git_tag ()
2969 {
2970         local i c=1 f=0
2971         while [ $c -lt $cword ]; do
2972                 i="${words[c]}"
2973                 case "$i" in
2974                 -d|--delete|-v|--verify)
2975                         __gitcomp_direct "$(__git_tags "" "$cur" " ")"
2976                         return
2977                         ;;
2978                 -f)
2979                         f=1
2980                         ;;
2981                 esac
2982                 ((c++))
2983         done
2984
2985         case "$prev" in
2986         -m|-F)
2987                 ;;
2988         -*|tag)
2989                 if [ $f = 1 ]; then
2990                         __gitcomp_direct "$(__git_tags "" "$cur" " ")"
2991                 fi
2992                 ;;
2993         *)
2994                 __git_complete_refs
2995                 ;;
2996         esac
2997
2998         case "$cur" in
2999         --*)
3000                 __gitcomp_builtin tag
3001                 ;;
3002         esac
3003 }
3004
3005 _git_whatchanged ()
3006 {
3007         _git_log
3008 }
3009
3010 _git_worktree ()
3011 {
3012         local subcommands="add list lock move prune remove unlock"
3013         local subcommand="$(__git_find_on_cmdline "$subcommands")"
3014         if [ -z "$subcommand" ]; then
3015                 __gitcomp "$subcommands"
3016         else
3017                 case "$subcommand,$cur" in
3018                 add,--*)
3019                         __gitcomp_builtin worktree_add
3020                         ;;
3021                 list,--*)
3022                         __gitcomp_builtin worktree_list
3023                         ;;
3024                 lock,--*)
3025                         __gitcomp_builtin worktree_lock
3026                         ;;
3027                 prune,--*)
3028                         __gitcomp_builtin worktree_prune
3029                         ;;
3030                 remove,--*)
3031                         __gitcomp "--force"
3032                         ;;
3033                 *)
3034                         ;;
3035                 esac
3036         fi
3037 }
3038
3039 __git_complete_common () {
3040         local command="$1"
3041
3042         case "$cur" in
3043         --*)
3044                 __gitcomp_builtin "$command"
3045                 ;;
3046         esac
3047 }
3048
3049 __git_cmds_with_parseopt_helper=
3050 __git_support_parseopt_helper () {
3051         test -n "$__git_cmds_with_parseopt_helper" ||
3052                 __git_cmds_with_parseopt_helper="$(__git --list-parseopt-builtins)"
3053
3054         case " $__git_cmds_with_parseopt_helper " in
3055         *" $1 "*)
3056                 return 0
3057                 ;;
3058         *)
3059                 return 1
3060                 ;;
3061         esac
3062 }
3063
3064 __git_complete_command () {
3065         local command="$1"
3066         local completion_func="_git_${command//-/_}"
3067         if declare -f $completion_func >/dev/null 2>/dev/null; then
3068                 $completion_func
3069                 return 0
3070         elif __git_support_parseopt_helper "$command"; then
3071                 __git_complete_common "$command"
3072                 return 0
3073         else
3074                 return 1
3075         fi
3076 }
3077
3078 __git_main ()
3079 {
3080         local i c=1 command __git_dir __git_repo_path
3081         local __git_C_args C_args_count=0
3082
3083         while [ $c -lt $cword ]; do
3084                 i="${words[c]}"
3085                 case "$i" in
3086                 --git-dir=*) __git_dir="${i#--git-dir=}" ;;
3087                 --git-dir)   ((c++)) ; __git_dir="${words[c]}" ;;
3088                 --bare)      __git_dir="." ;;
3089                 --help) command="help"; break ;;
3090                 -c|--work-tree|--namespace) ((c++)) ;;
3091                 -C)     __git_C_args[C_args_count++]=-C
3092                         ((c++))
3093                         __git_C_args[C_args_count++]="${words[c]}"
3094                         ;;
3095                 -*) ;;
3096                 *) command="$i"; break ;;
3097                 esac
3098                 ((c++))
3099         done
3100
3101         if [ -z "$command" ]; then
3102                 case "$prev" in
3103                 --git-dir|-C|--work-tree)
3104                         # these need a path argument, let's fall back to
3105                         # Bash filename completion
3106                         return
3107                         ;;
3108                 -c|--namespace)
3109                         # we don't support completing these options' arguments
3110                         return
3111                         ;;
3112                 esac
3113                 case "$cur" in
3114                 --*)   __gitcomp "
3115                         --paginate
3116                         --no-pager
3117                         --git-dir=
3118                         --bare
3119                         --version
3120                         --exec-path
3121                         --exec-path=
3122                         --html-path
3123                         --man-path
3124                         --info-path
3125                         --work-tree=
3126                         --namespace=
3127                         --no-replace-objects
3128                         --help
3129                         "
3130                         ;;
3131                 *)     __git_compute_porcelain_commands
3132                        __gitcomp "$__git_porcelain_commands $(__git_aliases)" ;;
3133                 esac
3134                 return
3135         fi
3136
3137         __git_complete_command "$command" && return
3138
3139         local expansion=$(__git_aliased_command "$command")
3140         if [ -n "$expansion" ]; then
3141                 words[1]=$expansion
3142                 __git_complete_command "$expansion"
3143         fi
3144 }
3145
3146 __gitk_main ()
3147 {
3148         __git_has_doubledash && return
3149
3150         local __git_repo_path
3151         __git_find_repo_path
3152
3153         local merge=""
3154         if [ -f "$__git_repo_path/MERGE_HEAD" ]; then
3155                 merge="--merge"
3156         fi
3157         case "$cur" in
3158         --*)
3159                 __gitcomp "
3160                         $__git_log_common_options
3161                         $__git_log_gitk_options
3162                         $merge
3163                         "
3164                 return
3165                 ;;
3166         esac
3167         __git_complete_revlist
3168 }
3169
3170 if [[ -n ${ZSH_VERSION-} ]]; then
3171         echo "WARNING: this script is deprecated, please see git-completion.zsh" 1>&2
3172
3173         autoload -U +X compinit && compinit
3174
3175         __gitcomp ()
3176         {
3177                 emulate -L zsh
3178
3179                 local cur_="${3-$cur}"
3180
3181                 case "$cur_" in
3182                 --*=)
3183                         ;;
3184                 *)
3185                         local c IFS=$' \t\n'
3186                         local -a array
3187                         for c in ${=1}; do
3188                                 c="$c${4-}"
3189                                 case $c in
3190                                 --*=*|*.) ;;
3191                                 *) c="$c " ;;
3192                                 esac
3193                                 array[${#array[@]}+1]="$c"
3194                         done
3195                         compset -P '*[=:]'
3196                         compadd -Q -S '' -p "${2-}" -a -- array && _ret=0
3197                         ;;
3198                 esac
3199         }
3200
3201         __gitcomp_direct ()
3202         {
3203                 emulate -L zsh
3204
3205                 local IFS=$'\n'
3206                 compset -P '*[=:]'
3207                 compadd -Q -- ${=1} && _ret=0
3208         }
3209
3210         __gitcomp_nl ()
3211         {
3212                 emulate -L zsh
3213
3214                 local IFS=$'\n'
3215                 compset -P '*[=:]'
3216                 compadd -Q -S "${4- }" -p "${2-}" -- ${=1} && _ret=0
3217         }
3218
3219         __gitcomp_file ()
3220         {
3221                 emulate -L zsh
3222
3223                 local IFS=$'\n'
3224                 compset -P '*[=:]'
3225                 compadd -Q -p "${2-}" -f -- ${=1} && _ret=0
3226         }
3227
3228         _git ()
3229         {
3230                 local _ret=1 cur cword prev
3231                 cur=${words[CURRENT]}
3232                 prev=${words[CURRENT-1]}
3233                 let cword=CURRENT-1
3234                 emulate ksh -c __${service}_main
3235                 let _ret && _default && _ret=0
3236                 return _ret
3237         }
3238
3239         compdef _git git gitk
3240         return
3241 fi
3242
3243 __git_func_wrap ()
3244 {
3245         local cur words cword prev
3246         _get_comp_words_by_ref -n =: cur words cword prev
3247         $1
3248 }
3249
3250 # Setup completion for certain functions defined above by setting common
3251 # variables and workarounds.
3252 # This is NOT a public function; use at your own risk.
3253 __git_complete ()
3254 {
3255         local wrapper="__git_wrap${2}"
3256         eval "$wrapper () { __git_func_wrap $2 ; }"
3257         complete -o bashdefault -o default -o nospace -F $wrapper $1 2>/dev/null \
3258                 || complete -o default -o nospace -F $wrapper $1
3259 }
3260
3261 # wrapper for backwards compatibility
3262 _git ()
3263 {
3264         __git_wrap__git_main
3265 }
3266
3267 # wrapper for backwards compatibility
3268 _gitk ()
3269 {
3270         __git_wrap__gitk_main
3271 }
3272
3273 __git_complete git __git_main
3274 __git_complete gitk __gitk_main
3275
3276 # The following are necessary only for Cygwin, and only are needed
3277 # when the user has tab-completed the executable name and consequently
3278 # included the '.exe' suffix.
3279 #
3280 if [ Cygwin = "$(uname -o 2>/dev/null)" ]; then
3281 __git_complete git.exe __git_main
3282 fi