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