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