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