git.oblomov.eu Git - git/blob - contrib/completion/git-completion.bash

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