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