contrib/completion/git-completion.bash

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