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

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