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

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