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