contrib/completion/git-completion.bash

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