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