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