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_revlist_file ()
 668 {
 669         local pfx ls ref cur
 670         _get_comp_words_by_ref -n =: cur
 671         case "$cur" in
 672         *..?*:*)
 673                 return
 674                 ;;
 675         ?*:*)
 676                 ref="${cur%%:*}"
 677                 cur="${cur#*:}"
 678                 case "$cur" in
 679                 ?*/*)
 680                         pfx="${cur%/*}"
 681                         cur="${cur##*/}"
 682                         ls="$ref:$pfx"
 683                         pfx="$pfx/"
 684                         ;;
 685                 *)
 686                         ls="$ref"
 687                         ;;
 688                 esac
 689
 690                 case "$COMP_WORDBREAKS" in
 691                 *:*) : great ;;
 692                 *)   pfx="$ref:$pfx" ;;
 693                 esac
 694
 695                 local IFS=$'\n'
 696                 COMPREPLY=($(compgen -P "$pfx" \
 697                         -W "$(git --git-dir="$(__gitdir)" ls-tree "$ls" \
 698                                 | sed '/^100... blob /{
 699                                            s,^.*        ,,
 700                                            s,$, ,
 701                                        }
 702                                        /^120000 blob /{
 703                                            s,^.*        ,,
 704                                            s,$, ,
 705                                        }
 706                                        /^040000 tree /{
 707                                            s,^.*        ,,
 708                                            s,$,/,
 709                                        }
 710                                        s/^.*    //')" \
 711                         -- "$cur"))
 712                 ;;
 713         *...*)
 714                 pfx="${cur%...*}..."
 715                 cur="${cur#*...}"
 716                 __gitcomp "$(__git_refs)" "$pfx" "$cur"
 717                 ;;
 718         *..*)
 719                 pfx="${cur%..*}.."
 720                 cur="${cur#*..}"
 721                 __gitcomp "$(__git_refs)" "$pfx" "$cur"
 722                 ;;
 723         *)
 724                 __gitcomp "$(__git_refs)"
 725                 ;;
 726         esac
 727 }
 728
 729
 730 __git_complete_file ()
 731 {
 732         __git_complete_revlist_file
 733 }
 734
 735 __git_complete_revlist ()
 736 {
 737         __git_complete_revlist_file
 738 }
 739
 740 __git_complete_remote_or_refspec ()
 741 {
 742         local cur words cword
 743         _get_comp_words_by_ref -n =: cur words cword
 744         local cmd="${words[1]}"
 745         local i c=2 remote="" pfx="" lhs=1 no_complete_refspec=0
 746         while [ $c -lt $cword ]; do
 747                 i="${words[c]}"
 748                 case "$i" in
 749                 --mirror) [ "$cmd" = "push" ] && no_complete_refspec=1 ;;
 750                 --all)
 751                         case "$cmd" in
 752                         push) no_complete_refspec=1 ;;
 753                         fetch)
 754                                 COMPREPLY=()
 755                                 return
 756                                 ;;
 757                         *) ;;
 758                         esac
 759                         ;;
 760                 -*) ;;
 761                 *) remote="$i"; break ;;
 762                 esac
 763                 c=$((++c))
 764         done
 765         if [ -z "$remote" ]; then
 766                 __gitcomp "$(__git_remotes)"
 767                 return
 768         fi
 769         if [ $no_complete_refspec = 1 ]; then
 770                 COMPREPLY=()
 771                 return
 772         fi
 773         [ "$remote" = "." ] && remote=
 774         case "$cur" in
 775         *:*)
 776                 case "$COMP_WORDBREAKS" in
 777                 *:*) : great ;;
 778                 *)   pfx="${cur%%:*}:" ;;
 779                 esac
 780                 cur="${cur#*:}"
 781                 lhs=0
 782                 ;;
 783         +*)
 784                 pfx="+"
 785                 cur="${cur#+}"
 786                 ;;
 787         esac
 788         case "$cmd" in
 789         fetch)
 790                 if [ $lhs = 1 ]; then
 791                         __gitcomp "$(__git_refs2 "$remote")" "$pfx" "$cur"
 792                 else
 793                         __gitcomp "$(__git_refs)" "$pfx" "$cur"
 794                 fi
 795                 ;;
 796         pull)
 797                 if [ $lhs = 1 ]; then
 798                         __gitcomp "$(__git_refs "$remote")" "$pfx" "$cur"
 799                 else
 800                         __gitcomp "$(__git_refs)" "$pfx" "$cur"
 801                 fi
 802                 ;;
 803         push)
 804                 if [ $lhs = 1 ]; then
 805                         __gitcomp "$(__git_refs)" "$pfx" "$cur"
 806                 else
 807                         __gitcomp "$(__git_refs "$remote")" "$pfx" "$cur"
 808                 fi
 809                 ;;
 810         esac
 811 }
 812
 813 __git_complete_strategy ()
 814 {
 815         local cur prev
 816         _get_comp_words_by_ref -n =: cur prev
 817         __git_compute_merge_strategies
 818         case "$prev" in
 819         -s|--strategy)
 820                 __gitcomp "$__git_merge_strategies"
 821                 return 0
 822         esac
 823         case "$cur" in
 824         --strategy=*)
 825                 __gitcomp "$__git_merge_strategies" "" "${cur##--strategy=}"
 826                 return 0
 827                 ;;
 828         esac
 829         return 1
 830 }
 831
 832 __git_list_all_commands ()
 833 {
 834         local i IFS=" "$'\n'
 835         for i in $(git help -a|egrep '^  [a-zA-Z0-9]')
 836         do
 837                 case $i in
 838                 *--*)             : helper pattern;;
 839                 *) echo $i;;
 840                 esac
 841         done
 842 }
 843
 844 __git_all_commands=
 845 __git_compute_all_commands ()
 846 {
 847         : ${__git_all_commands:=$(__git_list_all_commands)}
 848 }
 849
 850 __git_list_porcelain_commands ()
 851 {
 852         local i IFS=" "$'\n'
 853         __git_compute_all_commands
 854         for i in "help" $__git_all_commands
 855         do
 856                 case $i in
 857                 *--*)             : helper pattern;;
 858                 applymbox)        : ask gittus;;
 859                 applypatch)       : ask gittus;;
 860                 archimport)       : import;;
 861                 cat-file)         : plumbing;;
 862                 check-attr)       : plumbing;;
 863                 check-ref-format) : plumbing;;
 864                 checkout-index)   : plumbing;;
 865                 commit-tree)      : plumbing;;
 866                 count-objects)    : infrequent;;
 867                 cvsexportcommit)  : export;;
 868                 cvsimport)        : import;;
 869                 cvsserver)        : daemon;;
 870                 daemon)           : daemon;;
 871                 diff-files)       : plumbing;;
 872                 diff-index)       : plumbing;;
 873                 diff-tree)        : plumbing;;
 874                 fast-import)      : import;;
 875                 fast-export)      : export;;
 876                 fsck-objects)     : plumbing;;
 877                 fetch-pack)       : plumbing;;
 878                 fmt-merge-msg)    : plumbing;;
 879                 for-each-ref)     : plumbing;;
 880                 hash-object)      : plumbing;;
 881                 http-*)           : transport;;
 882                 index-pack)       : plumbing;;
 883                 init-db)          : deprecated;;
 884                 local-fetch)      : plumbing;;
 885                 lost-found)       : infrequent;;
 886                 ls-files)         : plumbing;;
 887                 ls-remote)        : plumbing;;
 888                 ls-tree)          : plumbing;;
 889                 mailinfo)         : plumbing;;
 890                 mailsplit)        : plumbing;;
 891                 merge-*)          : plumbing;;
 892                 mktree)           : plumbing;;
 893                 mktag)            : plumbing;;
 894                 pack-objects)     : plumbing;;
 895                 pack-redundant)   : plumbing;;
 896                 pack-refs)        : plumbing;;
 897                 parse-remote)     : plumbing;;
 898                 patch-id)         : plumbing;;
 899                 peek-remote)      : plumbing;;
 900                 prune)            : plumbing;;
 901                 prune-packed)     : plumbing;;
 902                 quiltimport)      : import;;
 903                 read-tree)        : plumbing;;
 904                 receive-pack)     : plumbing;;
 905                 remote-*)         : transport;;
 906                 repo-config)      : deprecated;;
 907                 rerere)           : plumbing;;
 908                 rev-list)         : plumbing;;
 909                 rev-parse)        : plumbing;;
 910                 runstatus)        : plumbing;;
 911                 sh-setup)         : internal;;
 912                 shell)            : daemon;;
 913                 show-ref)         : plumbing;;
 914                 send-pack)        : plumbing;;
 915                 show-index)       : plumbing;;
 916                 ssh-*)            : transport;;
 917                 stripspace)       : plumbing;;
 918                 symbolic-ref)     : plumbing;;
 919                 tar-tree)         : deprecated;;
 920                 unpack-file)      : plumbing;;
 921                 unpack-objects)   : plumbing;;
 922                 update-index)     : plumbing;;
 923                 update-ref)       : plumbing;;
 924                 update-server-info) : daemon;;
 925                 upload-archive)   : plumbing;;
 926                 upload-pack)      : plumbing;;
 927                 write-tree)       : plumbing;;
 928                 var)              : infrequent;;
 929                 verify-pack)      : infrequent;;
 930                 verify-tag)       : plumbing;;
 931                 *) echo $i;;
 932                 esac
 933         done
 934 }
 935
 936 __git_porcelain_commands=
 937 __git_compute_porcelain_commands ()
 938 {
 939         __git_compute_all_commands
 940         : ${__git_porcelain_commands:=$(__git_list_porcelain_commands)}
 941 }
 942
 943 __git_pretty_aliases ()
 944 {
 945         local i IFS=$'\n'
 946         for i in $(git --git-dir="$(__gitdir)" config --get-regexp "pretty\..*" 2>/dev/null); do
 947                 case "$i" in
 948                 pretty.*)
 949                         i="${i#pretty.}"
 950                         echo "${i/ */}"
 951                         ;;
 952                 esac
 953         done
 954 }
 955
 956 __git_aliases ()
 957 {
 958         local i IFS=$'\n'
 959         for i in $(git --git-dir="$(__gitdir)" config --get-regexp "alias\..*" 2>/dev/null); do
 960                 case "$i" in
 961                 alias.*)
 962                         i="${i#alias.}"
 963                         echo "${i/ */}"
 964                         ;;
 965                 esac
 966         done
 967 }
 968
 969 # __git_aliased_command requires 1 argument
 970 __git_aliased_command ()
 971 {
 972         local word cmdline=$(git --git-dir="$(__gitdir)" \
 973                 config --get "alias.$1")
 974         for word in $cmdline; do
 975                 case "$word" in
 976                 \!gitk|gitk)
 977                         echo "gitk"
 978                         return
 979                         ;;
 980                 \!*)    : shell command alias ;;
 981                 -*)     : option ;;
 982                 *=*)    : setting env ;;
 983                 git)    : git itself ;;
 984                 *)
 985                         echo "$word"
 986                         return
 987                 esac
 988         done
 989 }
 990
 991 # __git_find_on_cmdline requires 1 argument
 992 __git_find_on_cmdline ()
 993 {
 994         local word subcommand c=1 words cword
 995         _get_comp_words_by_ref -n =: words cword
 996         while [ $c -lt $cword ]; do
 997                 word="${words[c]}"
 998                 for subcommand in $1; do
 999                         if [ "$subcommand" = "$word" ]; then
1000                                 echo "$subcommand"
1001                                 return
1002                         fi
1003                 done
1004                 c=$((++c))
1005         done
1006 }
1007
1008 __git_has_doubledash ()
1009 {
1010         local c=1 words cword
1011         _get_comp_words_by_ref -n =: words cword
1012         while [ $c -lt $cword ]; do
1013                 if [ "--" = "${words[c]}" ]; then
1014                         return 0
1015                 fi
1016                 c=$((++c))
1017         done
1018         return 1
1019 }
1020
1021 __git_whitespacelist="nowarn warn error error-all fix"
1022
1023 _git_am ()
1024 {
1025         local cur dir="$(__gitdir)"
1026         _get_comp_words_by_ref -n =: cur
1027         if [ -d "$dir"/rebase-apply ]; then
1028                 __gitcomp "--skip --continue --resolved --abort"
1029                 return
1030         fi
1031         case "$cur" in
1032         --whitespace=*)
1033                 __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
1034                 return
1035                 ;;
1036         --*)
1037                 __gitcomp "
1038                         --3way --committer-date-is-author-date --ignore-date
1039                         --ignore-whitespace --ignore-space-change
1040                         --interactive --keep --no-utf8 --signoff --utf8
1041                         --whitespace= --scissors
1042                         "
1043                 return
1044         esac
1045         COMPREPLY=()
1046 }
1047
1048 _git_apply ()
1049 {
1050         local cur
1051         _get_comp_words_by_ref -n =: cur
1052         case "$cur" in
1053         --whitespace=*)
1054                 __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
1055                 return
1056                 ;;
1057         --*)
1058                 __gitcomp "
1059                         --stat --numstat --summary --check --index
1060                         --cached --index-info --reverse --reject --unidiff-zero
1061                         --apply --no-add --exclude=
1062                         --ignore-whitespace --ignore-space-change
1063                         --whitespace= --inaccurate-eof --verbose
1064                         "
1065                 return
1066         esac
1067         COMPREPLY=()
1068 }
1069
1070 _git_add ()
1071 {
1072         __git_has_doubledash && return
1073
1074         local cur
1075         _get_comp_words_by_ref -n =: cur
1076         case "$cur" in
1077         --*)
1078                 __gitcomp "
1079                         --interactive --refresh --patch --update --dry-run
1080                         --ignore-errors --intent-to-add
1081                         "
1082                 return
1083         esac
1084         COMPREPLY=()
1085 }
1086
1087 _git_archive ()
1088 {
1089         local cur
1090         _get_comp_words_by_ref -n =: cur
1091         case "$cur" in
1092         --format=*)
1093                 __gitcomp "$(git archive --list)" "" "${cur##--format=}"
1094                 return
1095                 ;;
1096         --remote=*)
1097                 __gitcomp "$(__git_remotes)" "" "${cur##--remote=}"
1098                 return
1099                 ;;
1100         --*)
1101                 __gitcomp "
1102                         --format= --list --verbose
1103                         --prefix= --remote= --exec=
1104                         "
1105                 return
1106                 ;;
1107         esac
1108         __git_complete_file
1109 }
1110
1111 _git_bisect ()
1112 {
1113         __git_has_doubledash && return
1114
1115         local subcommands="start bad good skip reset visualize replay log run"
1116         local subcommand="$(__git_find_on_cmdline "$subcommands")"
1117         if [ -z "$subcommand" ]; then
1118                 if [ -f "$(__gitdir)"/BISECT_START ]; then
1119                         __gitcomp "$subcommands"
1120                 else
1121                         __gitcomp "replay start"
1122                 fi
1123                 return
1124         fi
1125
1126         case "$subcommand" in
1127         bad|good|reset|skip|start)
1128                 __gitcomp "$(__git_refs)"
1129                 ;;
1130         *)
1131                 COMPREPLY=()
1132                 ;;
1133         esac
1134 }
1135
1136 _git_branch ()
1137 {
1138         local i c=1 only_local_ref="n" has_r="n" cur words cword
1139
1140         _get_comp_words_by_ref -n =: cur words cword
1141         while [ $c -lt $cword ]; do
1142                 i="${words[c]}"
1143                 case "$i" in
1144                 -d|-m)  only_local_ref="y" ;;
1145                 -r)     has_r="y" ;;
1146                 esac
1147                 c=$((++c))
1148         done
1149
1150         case "$cur" in
1151         --*)
1152                 __gitcomp "
1153                         --color --no-color --verbose --abbrev= --no-abbrev
1154                         --track --no-track --contains --merged --no-merged
1155                         --set-upstream
1156                         "
1157                 ;;
1158         *)
1159                 if [ $only_local_ref = "y" -a $has_r = "n" ]; then
1160                         __gitcomp "$(__git_heads)"
1161                 else
1162                         __gitcomp "$(__git_refs)"
1163                 fi
1164                 ;;
1165         esac
1166 }
1167
1168 _git_bundle ()
1169 {
1170         local words cword
1171         _get_comp_words_by_ref -n =: words cword
1172         local cmd="${words[2]}"
1173         case "$cword" in
1174         2)
1175                 __gitcomp "create list-heads verify unbundle"
1176                 ;;
1177         3)
1178                 # looking for a file
1179                 ;;
1180         *)
1181                 case "$cmd" in
1182                         create)
1183                                 __git_complete_revlist
1184                         ;;
1185                 esac
1186                 ;;
1187         esac
1188 }
1189
1190 _git_checkout ()
1191 {
1192         __git_has_doubledash && return
1193
1194         local cur
1195         _get_comp_words_by_ref -n =: cur
1196         case "$cur" in
1197         --conflict=*)
1198                 __gitcomp "diff3 merge" "" "${cur##--conflict=}"
1199                 ;;
1200         --*)
1201                 __gitcomp "
1202                         --quiet --ours --theirs --track --no-track --merge
1203                         --conflict= --orphan --patch
1204                         "
1205                 ;;
1206         *)
1207                 # check if --track, --no-track, or --no-guess was specified
1208                 # if so, disable DWIM mode
1209                 local flags="--track --no-track --no-guess" track=1
1210                 if [ -n "$(__git_find_on_cmdline "$flags")" ]; then
1211                         track=''
1212                 fi
1213                 __gitcomp "$(__git_refs '' $track)"
1214                 ;;
1215         esac
1216 }
1217
1218 _git_cherry ()
1219 {
1220         __gitcomp "$(__git_refs)"
1221 }
1222
1223 _git_cherry_pick ()
1224 {
1225         local cur
1226         _get_comp_words_by_ref -n =: cur
1227         case "$cur" in
1228         --*)
1229                 __gitcomp "--edit --no-commit"
1230                 ;;
1231         *)
1232                 __gitcomp "$(__git_refs)"
1233                 ;;
1234         esac
1235 }
1236
1237 _git_clean ()
1238 {
1239         __git_has_doubledash && return
1240
1241         local cur
1242         _get_comp_words_by_ref -n =: cur
1243         case "$cur" in
1244         --*)
1245                 __gitcomp "--dry-run --quiet"
1246                 return
1247                 ;;
1248         esac
1249         COMPREPLY=()
1250 }
1251
1252 _git_clone ()
1253 {
1254         local cur
1255         _get_comp_words_by_ref -n =: cur
1256         case "$cur" in
1257         --*)
1258                 __gitcomp "
1259                         --local
1260                         --no-hardlinks
1261                         --shared
1262                         --reference
1263                         --quiet
1264                         --no-checkout
1265                         --bare
1266                         --mirror
1267                         --origin
1268                         --upload-pack
1269                         --template=
1270                         --depth
1271                         "
1272                 return
1273                 ;;
1274         esac
1275         COMPREPLY=()
1276 }
1277
1278 _git_commit ()
1279 {
1280         __git_has_doubledash && return
1281
1282         local cur
1283         _get_comp_words_by_ref -n =: cur
1284         case "$cur" in
1285         --cleanup=*)
1286                 __gitcomp "default strip verbatim whitespace
1287                         " "" "${cur##--cleanup=}"
1288                 return
1289                 ;;
1290         --reuse-message=*)
1291                 __gitcomp "$(__git_refs)" "" "${cur##--reuse-message=}"
1292                 return
1293                 ;;
1294         --reedit-message=*)
1295                 __gitcomp "$(__git_refs)" "" "${cur##--reedit-message=}"
1296                 return
1297                 ;;
1298         --untracked-files=*)
1299                 __gitcomp "all no normal" "" "${cur##--untracked-files=}"
1300                 return
1301                 ;;
1302         --*)
1303                 __gitcomp "
1304                         --all --author= --signoff --verify --no-verify
1305                         --edit --amend --include --only --interactive
1306                         --dry-run --reuse-message= --reedit-message=
1307                         --reset-author --file= --message= --template=
1308                         --cleanup= --untracked-files --untracked-files=
1309                         --verbose --quiet
1310                         "
1311                 return
1312         esac
1313         COMPREPLY=()
1314 }
1315
1316 _git_describe ()
1317 {
1318         local cur
1319         _get_comp_words_by_ref -n =: cur
1320         case "$cur" in
1321         --*)
1322                 __gitcomp "
1323                         --all --tags --contains --abbrev= --candidates=
1324                         --exact-match --debug --long --match --always
1325                         "
1326                 return
1327         esac
1328         __gitcomp "$(__git_refs)"
1329 }
1330
1331 __git_diff_common_options="--stat --numstat --shortstat --summary
1332                         --patch-with-stat --name-only --name-status --color
1333                         --no-color --color-words --no-renames --check
1334                         --full-index --binary --abbrev --diff-filter=
1335                         --find-copies-harder
1336                         --text --ignore-space-at-eol --ignore-space-change
1337                         --ignore-all-space --exit-code --quiet --ext-diff
1338                         --no-ext-diff
1339                         --no-prefix --src-prefix= --dst-prefix=
1340                         --inter-hunk-context=
1341                         --patience
1342                         --raw
1343                         --dirstat --dirstat= --dirstat-by-file
1344                         --dirstat-by-file= --cumulative
1345 "
1346
1347 _git_diff ()
1348 {
1349         __git_has_doubledash && return
1350
1351         local cur
1352         _get_comp_words_by_ref -n =: cur
1353         case "$cur" in
1354         --*)
1355                 __gitcomp "--cached --staged --pickaxe-all --pickaxe-regex
1356                         --base --ours --theirs --no-index
1357                         $__git_diff_common_options
1358                         "
1359                 return
1360                 ;;
1361         esac
1362         __git_complete_revlist_file
1363 }
1364
1365 __git_mergetools_common="diffuse ecmerge emerge kdiff3 meld opendiff
1366                         tkdiff vimdiff gvimdiff xxdiff araxis p4merge bc3
1367 "
1368
1369 _git_difftool ()
1370 {
1371         __git_has_doubledash && return
1372
1373         local cur
1374         _get_comp_words_by_ref -n =: cur
1375         case "$cur" in
1376         --tool=*)
1377                 __gitcomp "$__git_mergetools_common kompare" "" "${cur##--tool=}"
1378                 return
1379                 ;;
1380         --*)
1381                 __gitcomp "--cached --staged --pickaxe-all --pickaxe-regex
1382                         --base --ours --theirs
1383                         --no-renames --diff-filter= --find-copies-harder
1384                         --relative --ignore-submodules
1385                         --tool="
1386                 return
1387                 ;;
1388         esac
1389         __git_complete_file
1390 }
1391
1392 __git_fetch_options="
1393         --quiet --verbose --append --upload-pack --force --keep --depth=
1394         --tags --no-tags --all --prune --dry-run
1395 "
1396
1397 _git_fetch ()
1398 {
1399         local cur
1400         _get_comp_words_by_ref -n =: cur
1401         case "$cur" in
1402         --*)
1403                 __gitcomp "$__git_fetch_options"
1404                 return
1405                 ;;
1406         esac
1407         __git_complete_remote_or_refspec
1408 }
1409
1410 _git_format_patch ()
1411 {
1412         local cur
1413         _get_comp_words_by_ref -n =: cur
1414         case "$cur" in
1415         --thread=*)
1416                 __gitcomp "
1417                         deep shallow
1418                         " "" "${cur##--thread=}"
1419                 return
1420                 ;;
1421         --*)
1422                 __gitcomp "
1423                         --stdout --attach --no-attach --thread --thread=
1424                         --output-directory
1425                         --numbered --start-number
1426                         --numbered-files
1427                         --keep-subject
1428                         --signoff --signature --no-signature
1429                         --in-reply-to= --cc=
1430                         --full-index --binary
1431                         --not --all
1432                         --cover-letter
1433                         --no-prefix --src-prefix= --dst-prefix=
1434                         --inline --suffix= --ignore-if-in-upstream
1435                         --subject-prefix=
1436                         "
1437                 return
1438                 ;;
1439         esac
1440         __git_complete_revlist
1441 }
1442
1443 _git_fsck ()
1444 {
1445         local cur
1446         _get_comp_words_by_ref -n =: cur
1447         case "$cur" in
1448         --*)
1449                 __gitcomp "
1450                         --tags --root --unreachable --cache --no-reflogs --full
1451                         --strict --verbose --lost-found
1452                         "
1453                 return
1454                 ;;
1455         esac
1456         COMPREPLY=()
1457 }
1458
1459 _git_gc ()
1460 {
1461         local cur
1462         _get_comp_words_by_ref -n =: cur
1463         case "$cur" in
1464         --*)
1465                 __gitcomp "--prune --aggressive"
1466                 return
1467                 ;;
1468         esac
1469         COMPREPLY=()
1470 }
1471
1472 _git_gitk ()
1473 {
1474         _gitk
1475 }
1476
1477 _git_grep ()
1478 {
1479         __git_has_doubledash && return
1480
1481         local cur
1482         _get_comp_words_by_ref -n =: cur
1483         case "$cur" in
1484         --*)
1485                 __gitcomp "
1486                         --cached
1487                         --text --ignore-case --word-regexp --invert-match
1488                         --full-name
1489                         --extended-regexp --basic-regexp --fixed-strings
1490                         --files-with-matches --name-only
1491                         --files-without-match
1492                         --max-depth
1493                         --count
1494                         --and --or --not --all-match
1495                         "
1496                 return
1497                 ;;
1498         esac
1499
1500         __gitcomp "$(__git_refs)"
1501 }
1502
1503 _git_help ()
1504 {
1505         local cur
1506         _get_comp_words_by_ref -n =: cur
1507         case "$cur" in
1508         --*)
1509                 __gitcomp "--all --info --man --web"
1510                 return
1511                 ;;
1512         esac
1513         __git_compute_all_commands
1514         __gitcomp "$__git_all_commands $(__git_aliases)
1515                 attributes cli core-tutorial cvs-migration
1516                 diffcore gitk glossary hooks ignore modules
1517                 repository-layout tutorial tutorial-2
1518                 workflows
1519                 "
1520 }
1521
1522 _git_init ()
1523 {
1524         local cur
1525         _get_comp_words_by_ref -n =: cur
1526         case "$cur" in
1527         --shared=*)
1528                 __gitcomp "
1529                         false true umask group all world everybody
1530                         " "" "${cur##--shared=}"
1531                 return
1532                 ;;
1533         --*)
1534                 __gitcomp "--quiet --bare --template= --shared --shared="
1535                 return
1536                 ;;
1537         esac
1538         COMPREPLY=()
1539 }
1540
1541 _git_ls_files ()
1542 {
1543         __git_has_doubledash && return
1544
1545         local cur
1546         _get_comp_words_by_ref -n =: cur
1547         case "$cur" in
1548         --*)
1549                 __gitcomp "--cached --deleted --modified --others --ignored
1550                         --stage --directory --no-empty-directory --unmerged
1551                         --killed --exclude= --exclude-from=
1552                         --exclude-per-directory= --exclude-standard
1553                         --error-unmatch --with-tree= --full-name
1554                         --abbrev --ignored --exclude-per-directory
1555                         "
1556                 return
1557                 ;;
1558         esac
1559         COMPREPLY=()
1560 }
1561
1562 _git_ls_remote ()
1563 {
1564         __gitcomp "$(__git_remotes)"
1565 }
1566
1567 _git_ls_tree ()
1568 {
1569         __git_complete_file
1570 }
1571
1572 # Options that go well for log, shortlog and gitk
1573 __git_log_common_options="
1574         --not --all
1575         --branches --tags --remotes
1576         --first-parent --merges --no-merges
1577         --max-count=
1578         --max-age= --since= --after=
1579         --min-age= --until= --before=
1580         --min-parents= --max-parents=
1581         --no-min-parents --no-max-parents
1582 "
1583 # Options that go well for log and gitk (not shortlog)
1584 __git_log_gitk_options="
1585         --dense --sparse --full-history
1586         --simplify-merges --simplify-by-decoration
1587         --left-right
1588 "
1589 # Options that go well for log and shortlog (not gitk)
1590 __git_log_shortlog_options="
1591         --author= --committer= --grep=
1592         --all-match
1593 "
1594
1595 __git_log_pretty_formats="oneline short medium full fuller email raw format:"
1596 __git_log_date_formats="relative iso8601 rfc2822 short local default raw"
1597
1598 _git_log ()
1599 {
1600         __git_has_doubledash && return
1601
1602         local g="$(git rev-parse --git-dir 2>/dev/null)"
1603         local merge=""
1604         if [ -f "$g/MERGE_HEAD" ]; then
1605                 merge="--merge"
1606         fi
1607         local cur
1608         _get_comp_words_by_ref -n =: cur
1609         case "$cur" in
1610         --pretty=*)
1611                 __gitcomp "$__git_log_pretty_formats $(__git_pretty_aliases)
1612                         " "" "${cur##--pretty=}"
1613                 return
1614                 ;;
1615         --format=*)
1616                 __gitcomp "$__git_log_pretty_formats $(__git_pretty_aliases)
1617                         " "" "${cur##--format=}"
1618                 return
1619                 ;;
1620         --date=*)
1621                 __gitcomp "$__git_log_date_formats" "" "${cur##--date=}"
1622                 return
1623                 ;;
1624         --decorate=*)
1625                 __gitcomp "long short" "" "${cur##--decorate=}"
1626                 return
1627                 ;;
1628         --*)
1629                 __gitcomp "
1630                         $__git_log_common_options
1631                         $__git_log_shortlog_options
1632                         $__git_log_gitk_options
1633                         --root --topo-order --date-order --reverse
1634                         --follow --full-diff
1635                         --abbrev-commit --abbrev=
1636                         --relative-date --date=
1637                         --pretty= --format= --oneline
1638                         --cherry-pick
1639                         --graph
1640                         --decorate --decorate=
1641                         --walk-reflogs
1642                         --parents --children
1643                         $merge
1644                         $__git_diff_common_options
1645                         --pickaxe-all --pickaxe-regex
1646                         "
1647                 return
1648                 ;;
1649         esac
1650         __git_complete_revlist
1651 }
1652
1653 __git_merge_options="
1654         --no-commit --no-stat --log --no-log --squash --strategy
1655         --commit --stat --no-squash --ff --no-ff --ff-only
1656 "
1657
1658 _git_merge ()
1659 {
1660         __git_complete_strategy && return
1661
1662         local cur
1663         _get_comp_words_by_ref -n =: cur
1664         case "$cur" in
1665         --*)
1666                 __gitcomp "$__git_merge_options"
1667                 return
1668         esac
1669         __gitcomp "$(__git_refs)"
1670 }
1671
1672 _git_mergetool ()
1673 {
1674         local cur
1675         _get_comp_words_by_ref -n =: cur
1676         case "$cur" in
1677         --tool=*)
1678                 __gitcomp "$__git_mergetools_common tortoisemerge" "" "${cur##--tool=}"
1679                 return
1680                 ;;
1681         --*)
1682                 __gitcomp "--tool="
1683                 return
1684                 ;;
1685         esac
1686         COMPREPLY=()
1687 }
1688
1689 _git_merge_base ()
1690 {
1691         __gitcomp "$(__git_refs)"
1692 }
1693
1694 _git_mv ()
1695 {
1696         local cur
1697         _get_comp_words_by_ref -n =: cur
1698         case "$cur" in
1699         --*)
1700                 __gitcomp "--dry-run"
1701                 return
1702                 ;;
1703         esac
1704         COMPREPLY=()
1705 }
1706
1707 _git_name_rev ()
1708 {
1709         __gitcomp "--tags --all --stdin"
1710 }
1711
1712 _git_notes ()
1713 {
1714         local subcommands='add append copy edit list prune remove show'
1715         local subcommand="$(__git_find_on_cmdline "$subcommands")"
1716         local cur words cword
1717         _get_comp_words_by_ref -n =: cur words cword
1718
1719         case "$subcommand,$cur" in
1720         ,--*)
1721                 __gitcomp '--ref'
1722                 ;;
1723         ,*)
1724                 case "${words[cword-1]}" in
1725                 --ref)
1726                         __gitcomp "$(__git_refs)"
1727                         ;;
1728                 *)
1729                         __gitcomp "$subcommands --ref"
1730                         ;;
1731                 esac
1732                 ;;
1733         add,--reuse-message=*|append,--reuse-message=*)
1734                 __gitcomp "$(__git_refs)" "" "${cur##--reuse-message=}"
1735                 ;;
1736         add,--reedit-message=*|append,--reedit-message=*)
1737                 __gitcomp "$(__git_refs)" "" "${cur##--reedit-message=}"
1738                 ;;
1739         add,--*|append,--*)
1740                 __gitcomp '--file= --message= --reedit-message=
1741                                 --reuse-message='
1742                 ;;
1743         copy,--*)
1744                 __gitcomp '--stdin'
1745                 ;;
1746         prune,--*)
1747                 __gitcomp '--dry-run --verbose'
1748                 ;;
1749         prune,*)
1750                 ;;
1751         *)
1752                 case "${words[cword-1]}" in
1753                 -m|-F)
1754                         ;;
1755                 *)
1756                         __gitcomp "$(__git_refs)"
1757                         ;;
1758                 esac
1759                 ;;
1760         esac
1761 }
1762
1763 _git_pull ()
1764 {
1765         __git_complete_strategy && return
1766
1767         local cur
1768         _get_comp_words_by_ref -n =: cur
1769         case "$cur" in
1770         --*)
1771                 __gitcomp "
1772                         --rebase --no-rebase
1773                         $__git_merge_options
1774                         $__git_fetch_options
1775                 "
1776                 return
1777                 ;;
1778         esac
1779         __git_complete_remote_or_refspec
1780 }
1781
1782 _git_push ()
1783 {
1784         local cur prev
1785         _get_comp_words_by_ref -n =: cur prev
1786         case "$prev" in
1787         --repo)
1788                 __gitcomp "$(__git_remotes)"
1789                 return
1790         esac
1791         case "$cur" in
1792         --repo=*)
1793                 __gitcomp "$(__git_remotes)" "" "${cur##--repo=}"
1794                 return
1795                 ;;
1796         --*)
1797                 __gitcomp "
1798                         --all --mirror --tags --dry-run --force --verbose
1799                         --receive-pack= --repo=
1800                 "
1801                 return
1802                 ;;
1803         esac
1804         __git_complete_remote_or_refspec
1805 }
1806
1807 _git_rebase ()
1808 {
1809         local dir="$(__gitdir)"
1810         local cur
1811         _get_comp_words_by_ref -n =: cur
1812         if [ -d "$dir"/rebase-apply ] || [ -d "$dir"/rebase-merge ]; then
1813                 __gitcomp "--continue --skip --abort"
1814                 return
1815         fi
1816         __git_complete_strategy && return
1817         case "$cur" in
1818         --whitespace=*)
1819                 __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
1820                 return
1821                 ;;
1822         --*)
1823                 __gitcomp "
1824                         --onto --merge --strategy --interactive
1825                         --preserve-merges --stat --no-stat
1826                         --committer-date-is-author-date --ignore-date
1827                         --ignore-whitespace --whitespace=
1828                         --autosquash
1829                         "
1830
1831                 return
1832         esac
1833         __gitcomp "$(__git_refs)"
1834 }
1835
1836 _git_reflog ()
1837 {
1838         local subcommands="show delete expire"
1839         local subcommand="$(__git_find_on_cmdline "$subcommands")"
1840
1841         if [ -z "$subcommand" ]; then
1842                 __gitcomp "$subcommands"
1843         else
1844                 __gitcomp "$(__git_refs)"
1845         fi
1846 }
1847
1848 __git_send_email_confirm_options="always never auto cc compose"
1849 __git_send_email_suppresscc_options="author self cc bodycc sob cccmd body all"
1850
1851 _git_send_email ()
1852 {
1853         local cur
1854         _get_comp_words_by_ref -n =: cur
1855         case "$cur" in
1856         --confirm=*)
1857                 __gitcomp "
1858                         $__git_send_email_confirm_options
1859                         " "" "${cur##--confirm=}"
1860                 return
1861                 ;;
1862         --suppress-cc=*)
1863                 __gitcomp "
1864                         $__git_send_email_suppresscc_options
1865                         " "" "${cur##--suppress-cc=}"
1866
1867                 return
1868                 ;;
1869         --smtp-encryption=*)
1870                 __gitcomp "ssl tls" "" "${cur##--smtp-encryption=}"
1871                 return
1872                 ;;
1873         --*)
1874                 __gitcomp "--annotate --bcc --cc --cc-cmd --chain-reply-to
1875                         --compose --confirm= --dry-run --envelope-sender
1876                         --from --identity
1877                         --in-reply-to --no-chain-reply-to --no-signed-off-by-cc
1878                         --no-suppress-from --no-thread --quiet
1879                         --signed-off-by-cc --smtp-pass --smtp-server
1880                         --smtp-server-port --smtp-encryption= --smtp-user
1881                         --subject --suppress-cc= --suppress-from --thread --to
1882                         --validate --no-validate"
1883                 return
1884                 ;;
1885         esac
1886         COMPREPLY=()
1887 }
1888
1889 _git_stage ()
1890 {
1891         _git_add
1892 }
1893
1894 __git_config_get_set_variables ()
1895 {
1896         local words cword
1897         _get_comp_words_by_ref -n =: words cword
1898         local prevword word config_file= c=$cword
1899         while [ $c -gt 1 ]; do
1900                 word="${words[c]}"
1901                 case "$word" in
1902                 --global|--system|--file=*)
1903                         config_file="$word"
1904                         break
1905                         ;;
1906                 -f|--file)
1907                         config_file="$word $prevword"
1908                         break
1909                         ;;
1910                 esac
1911                 prevword=$word
1912                 c=$((--c))
1913         done
1914
1915         git --git-dir="$(__gitdir)" config $config_file --list 2>/dev/null |
1916         while read line
1917         do
1918                 case "$line" in
1919                 *.*=*)
1920                         echo "${line/=*/}"
1921                         ;;
1922                 esac
1923         done
1924 }
1925
1926 _git_config ()
1927 {
1928         local cur prev
1929         _get_comp_words_by_ref -n =: cur prev
1930         case "$prev" in
1931         branch.*.remote)
1932                 __gitcomp "$(__git_remotes)"
1933                 return
1934                 ;;
1935         branch.*.merge)
1936                 __gitcomp "$(__git_refs)"
1937                 return
1938                 ;;
1939         remote.*.fetch)
1940                 local remote="${prev#remote.}"
1941                 remote="${remote%.fetch}"
1942                 __gitcomp "$(__git_refs_remotes "$remote")"
1943                 return
1944                 ;;
1945         remote.*.push)
1946                 local remote="${prev#remote.}"
1947                 remote="${remote%.push}"
1948                 __gitcomp "$(git --git-dir="$(__gitdir)" \
1949                         for-each-ref --format='%(refname):%(refname)' \
1950                         refs/heads)"
1951                 return
1952                 ;;
1953         pull.twohead|pull.octopus)
1954                 __git_compute_merge_strategies
1955                 __gitcomp "$__git_merge_strategies"
1956                 return
1957                 ;;
1958         color.branch|color.diff|color.interactive|\
1959         color.showbranch|color.status|color.ui)
1960                 __gitcomp "always never auto"
1961                 return
1962                 ;;
1963         color.pager)
1964                 __gitcomp "false true"
1965                 return
1966                 ;;
1967         color.*.*)
1968                 __gitcomp "
1969                         normal black red green yellow blue magenta cyan white
1970                         bold dim ul blink reverse
1971                         "
1972                 return
1973                 ;;
1974         help.format)
1975                 __gitcomp "man info web html"
1976                 return
1977                 ;;
1978         log.date)
1979                 __gitcomp "$__git_log_date_formats"
1980                 return
1981                 ;;
1982         sendemail.aliasesfiletype)
1983                 __gitcomp "mutt mailrc pine elm gnus"
1984                 return
1985                 ;;
1986         sendemail.confirm)
1987                 __gitcomp "$__git_send_email_confirm_options"
1988                 return
1989                 ;;
1990         sendemail.suppresscc)
1991                 __gitcomp "$__git_send_email_suppresscc_options"
1992                 return
1993                 ;;
1994         --get|--get-all|--unset|--unset-all)
1995                 __gitcomp "$(__git_config_get_set_variables)"
1996                 return
1997                 ;;
1998         *.*)
1999                 COMPREPLY=()
2000                 return
2001                 ;;
2002         esac
2003         case "$cur" in
2004         --*)
2005                 __gitcomp "
2006                         --global --system --file=
2007                         --list --replace-all
2008                         --get --get-all --get-regexp
2009                         --add --unset --unset-all
2010                         --remove-section --rename-section
2011                         "
2012                 return
2013                 ;;
2014         branch.*.*)
2015                 local pfx="${cur%.*}."
2016                 cur="${cur##*.}"
2017                 __gitcomp "remote merge mergeoptions rebase" "$pfx" "$cur"
2018                 return
2019                 ;;
2020         branch.*)
2021                 local pfx="${cur%.*}."
2022                 cur="${cur#*.}"
2023                 __gitcomp "$(__git_heads)" "$pfx" "$cur" "."
2024                 return
2025                 ;;
2026         guitool.*.*)
2027                 local pfx="${cur%.*}."
2028                 cur="${cur##*.}"
2029                 __gitcomp "
2030                         argprompt cmd confirm needsfile noconsole norescan
2031                         prompt revprompt revunmerged title
2032                         " "$pfx" "$cur"
2033                 return
2034                 ;;
2035         difftool.*.*)
2036                 local pfx="${cur%.*}."
2037                 cur="${cur##*.}"
2038                 __gitcomp "cmd path" "$pfx" "$cur"
2039                 return
2040                 ;;
2041         man.*.*)
2042                 local pfx="${cur%.*}."
2043                 cur="${cur##*.}"
2044                 __gitcomp "cmd path" "$pfx" "$cur"
2045                 return
2046                 ;;
2047         mergetool.*.*)
2048                 local pfx="${cur%.*}."
2049                 cur="${cur##*.}"
2050                 __gitcomp "cmd path trustExitCode" "$pfx" "$cur"
2051                 return
2052                 ;;
2053         pager.*)
2054                 local pfx="${cur%.*}."
2055                 cur="${cur#*.}"
2056                 __git_compute_all_commands
2057                 __gitcomp "$__git_all_commands" "$pfx" "$cur"
2058                 return
2059                 ;;
2060         remote.*.*)
2061                 local pfx="${cur%.*}."
2062                 cur="${cur##*.}"
2063                 __gitcomp "
2064                         url proxy fetch push mirror skipDefaultUpdate
2065                         receivepack uploadpack tagopt pushurl
2066                         " "$pfx" "$cur"
2067                 return
2068                 ;;
2069         remote.*)
2070                 local pfx="${cur%.*}."
2071                 cur="${cur#*.}"
2072                 __gitcomp "$(__git_remotes)" "$pfx" "$cur" "."
2073                 return
2074                 ;;
2075         url.*.*)
2076                 local pfx="${cur%.*}."
2077                 cur="${cur##*.}"
2078                 __gitcomp "insteadOf pushInsteadOf" "$pfx" "$cur"
2079                 return
2080                 ;;
2081         esac
2082         __gitcomp "
2083                 add.ignoreErrors
2084                 advice.commitBeforeMerge
2085                 advice.detachedHead
2086                 advice.implicitIdentity
2087                 advice.pushNonFastForward
2088                 advice.resolveConflict
2089                 advice.statusHints
2090                 alias.
2091                 am.keepcr
2092                 apply.ignorewhitespace
2093                 apply.whitespace
2094                 branch.autosetupmerge
2095                 branch.autosetuprebase
2096                 browser.
2097                 clean.requireForce
2098                 color.branch
2099                 color.branch.current
2100                 color.branch.local
2101                 color.branch.plain
2102                 color.branch.remote
2103                 color.decorate.HEAD
2104                 color.decorate.branch
2105                 color.decorate.remoteBranch
2106                 color.decorate.stash
2107                 color.decorate.tag
2108                 color.diff
2109                 color.diff.commit
2110                 color.diff.frag
2111                 color.diff.func
2112                 color.diff.meta
2113                 color.diff.new
2114                 color.diff.old
2115                 color.diff.plain
2116                 color.diff.whitespace
2117                 color.grep
2118                 color.grep.context
2119                 color.grep.filename
2120                 color.grep.function
2121                 color.grep.linenumber
2122                 color.grep.match
2123                 color.grep.selected
2124                 color.grep.separator
2125                 color.interactive
2126                 color.interactive.error
2127                 color.interactive.header
2128                 color.interactive.help
2129                 color.interactive.prompt
2130                 color.pager
2131                 color.showbranch
2132                 color.status
2133                 color.status.added
2134                 color.status.changed
2135                 color.status.header
2136                 color.status.nobranch
2137                 color.status.untracked
2138                 color.status.updated
2139                 color.ui
2140                 commit.status
2141                 commit.template
2142                 core.abbrev
2143                 core.askpass
2144                 core.attributesfile
2145                 core.autocrlf
2146                 core.bare
2147                 core.bigFileThreshold
2148                 core.compression
2149                 core.createObject
2150                 core.deltaBaseCacheLimit
2151                 core.editor
2152                 core.eol
2153                 core.excludesfile
2154                 core.fileMode
2155                 core.fsyncobjectfiles
2156                 core.gitProxy
2157                 core.ignoreCygwinFSTricks
2158                 core.ignoreStat
2159                 core.ignorecase
2160                 core.logAllRefUpdates
2161                 core.loosecompression
2162                 core.notesRef
2163                 core.packedGitLimit
2164                 core.packedGitWindowSize
2165                 core.pager
2166                 core.preferSymlinkRefs
2167                 core.preloadindex
2168                 core.quotepath
2169                 core.repositoryFormatVersion
2170                 core.safecrlf
2171                 core.sharedRepository
2172                 core.sparseCheckout
2173                 core.symlinks
2174                 core.trustctime
2175                 core.warnAmbiguousRefs
2176                 core.whitespace
2177                 core.worktree
2178                 diff.autorefreshindex
2179                 diff.external
2180                 diff.ignoreSubmodules
2181                 diff.mnemonicprefix
2182                 diff.noprefix
2183                 diff.renameLimit
2184                 diff.renames
2185                 diff.suppressBlankEmpty
2186                 diff.tool
2187                 diff.wordRegex
2188                 difftool.
2189                 difftool.prompt
2190                 fetch.recurseSubmodules
2191                 fetch.unpackLimit
2192                 format.attach
2193                 format.cc
2194                 format.headers
2195                 format.numbered
2196                 format.pretty
2197                 format.signature
2198                 format.signoff
2199                 format.subjectprefix
2200                 format.suffix
2201                 format.thread
2202                 format.to
2203                 gc.
2204                 gc.aggressiveWindow
2205                 gc.auto
2206                 gc.autopacklimit
2207                 gc.packrefs
2208                 gc.pruneexpire
2209                 gc.reflogexpire
2210                 gc.reflogexpireunreachable
2211                 gc.rerereresolved
2212                 gc.rerereunresolved
2213                 gitcvs.allbinary
2214                 gitcvs.commitmsgannotation
2215                 gitcvs.dbTableNamePrefix
2216                 gitcvs.dbdriver
2217                 gitcvs.dbname
2218                 gitcvs.dbpass
2219                 gitcvs.dbuser
2220                 gitcvs.enabled
2221                 gitcvs.logfile
2222                 gitcvs.usecrlfattr
2223                 guitool.
2224                 gui.blamehistoryctx
2225                 gui.commitmsgwidth
2226                 gui.copyblamethreshold
2227                 gui.diffcontext
2228                 gui.encoding
2229                 gui.fastcopyblame
2230                 gui.matchtrackingbranch
2231                 gui.newbranchtemplate
2232                 gui.pruneduringfetch
2233                 gui.spellingdictionary
2234                 gui.trustmtime
2235                 help.autocorrect
2236                 help.browser
2237                 help.format
2238                 http.lowSpeedLimit
2239                 http.lowSpeedTime
2240                 http.maxRequests
2241                 http.minSessions
2242                 http.noEPSV
2243                 http.postBuffer
2244                 http.proxy
2245                 http.sslCAInfo
2246                 http.sslCAPath
2247                 http.sslCert
2248                 http.sslCertPasswordProtected
2249                 http.sslKey
2250                 http.sslVerify
2251                 http.useragent
2252                 i18n.commitEncoding
2253                 i18n.logOutputEncoding
2254                 imap.authMethod
2255                 imap.folder
2256                 imap.host
2257                 imap.pass
2258                 imap.port
2259                 imap.preformattedHTML
2260                 imap.sslverify
2261                 imap.tunnel
2262                 imap.user
2263                 init.templatedir
2264                 instaweb.browser
2265                 instaweb.httpd
2266                 instaweb.local
2267                 instaweb.modulepath
2268                 instaweb.port
2269                 interactive.singlekey
2270                 log.date
2271                 log.decorate
2272                 log.showroot
2273                 mailmap.file
2274                 man.
2275                 man.viewer
2276                 merge.
2277                 merge.conflictstyle
2278                 merge.log
2279                 merge.renameLimit
2280                 merge.renormalize
2281                 merge.stat
2282                 merge.tool
2283                 merge.verbosity
2284                 mergetool.
2285                 mergetool.keepBackup
2286                 mergetool.keepTemporaries
2287                 mergetool.prompt
2288                 notes.displayRef
2289                 notes.rewrite.
2290                 notes.rewrite.amend
2291                 notes.rewrite.rebase
2292                 notes.rewriteMode
2293                 notes.rewriteRef
2294                 pack.compression
2295                 pack.deltaCacheLimit
2296                 pack.deltaCacheSize
2297                 pack.depth
2298                 pack.indexVersion
2299                 pack.packSizeLimit
2300                 pack.threads
2301                 pack.window
2302                 pack.windowMemory
2303                 pager.
2304                 pretty.
2305                 pull.octopus
2306                 pull.twohead
2307                 push.default
2308                 rebase.autosquash
2309                 rebase.stat
2310                 receive.autogc
2311                 receive.denyCurrentBranch
2312                 receive.denyDeleteCurrent
2313                 receive.denyDeletes
2314                 receive.denyNonFastForwards
2315                 receive.fsckObjects
2316                 receive.unpackLimit
2317                 receive.updateserverinfo
2318                 remotes.
2319                 repack.usedeltabaseoffset
2320                 rerere.autoupdate
2321                 rerere.enabled
2322                 sendemail.
2323                 sendemail.aliasesfile
2324                 sendemail.aliasfiletype
2325                 sendemail.bcc
2326                 sendemail.cc
2327                 sendemail.cccmd
2328                 sendemail.chainreplyto
2329                 sendemail.confirm
2330                 sendemail.envelopesender
2331                 sendemail.from
2332                 sendemail.identity
2333                 sendemail.multiedit
2334                 sendemail.signedoffbycc
2335                 sendemail.smtpdomain
2336                 sendemail.smtpencryption
2337                 sendemail.smtppass
2338                 sendemail.smtpserver
2339                 sendemail.smtpserveroption
2340                 sendemail.smtpserverport
2341                 sendemail.smtpuser
2342                 sendemail.suppresscc
2343                 sendemail.suppressfrom
2344                 sendemail.thread
2345                 sendemail.to
2346                 sendemail.validate
2347                 showbranch.default
2348                 status.relativePaths
2349                 status.showUntrackedFiles
2350                 status.submodulesummary
2351                 submodule.
2352                 tar.umask
2353                 transfer.unpackLimit
2354                 url.
2355                 user.email
2356                 user.name
2357                 user.signingkey
2358                 web.browser
2359                 branch. remote.
2360         "
2361 }
2362
2363 _git_remote ()
2364 {
2365         local subcommands="add rename rm show prune update set-head"
2366         local subcommand="$(__git_find_on_cmdline "$subcommands")"
2367         if [ -z "$subcommand" ]; then
2368                 __gitcomp "$subcommands"
2369                 return
2370         fi
2371
2372         case "$subcommand" in
2373         rename|rm|show|prune)
2374                 __gitcomp "$(__git_remotes)"
2375                 ;;
2376         update)
2377                 local i c='' IFS=$'\n'
2378                 for i in $(git --git-dir="$(__gitdir)" config --get-regexp "remotes\..*" 2>/dev/null); do
2379                         i="${i#remotes.}"
2380                         c="$c ${i/ */}"
2381                 done
2382                 __gitcomp "$c"
2383                 ;;
2384         *)
2385                 COMPREPLY=()
2386                 ;;
2387         esac
2388 }
2389
2390 _git_replace ()
2391 {
2392         __gitcomp "$(__git_refs)"
2393 }
2394
2395 _git_reset ()
2396 {
2397         __git_has_doubledash && return
2398
2399         local cur
2400         _get_comp_words_by_ref -n =: cur
2401         case "$cur" in
2402         --*)
2403                 __gitcomp "--merge --mixed --hard --soft --patch"
2404                 return
2405                 ;;
2406         esac
2407         __gitcomp "$(__git_refs)"
2408 }
2409
2410 _git_revert ()
2411 {
2412         local cur
2413         _get_comp_words_by_ref -n =: cur
2414         case "$cur" in
2415         --*)
2416                 __gitcomp "--edit --mainline --no-edit --no-commit --signoff"
2417                 return
2418                 ;;
2419         esac
2420         __gitcomp "$(__git_refs)"
2421 }
2422
2423 _git_rm ()
2424 {
2425         __git_has_doubledash && return
2426
2427         local cur
2428         _get_comp_words_by_ref -n =: cur
2429         case "$cur" in
2430         --*)
2431                 __gitcomp "--cached --dry-run --ignore-unmatch --quiet"
2432                 return
2433                 ;;
2434         esac
2435         COMPREPLY=()
2436 }
2437
2438 _git_shortlog ()
2439 {
2440         __git_has_doubledash && return
2441
2442         local cur
2443         _get_comp_words_by_ref -n =: cur
2444         case "$cur" in
2445         --*)
2446                 __gitcomp "
2447                         $__git_log_common_options
2448                         $__git_log_shortlog_options
2449                         --numbered --summary
2450                         "
2451                 return
2452                 ;;
2453         esac
2454         __git_complete_revlist
2455 }
2456
2457 _git_show ()
2458 {
2459         __git_has_doubledash && return
2460
2461         local cur
2462         _get_comp_words_by_ref -n =: cur
2463         case "$cur" in
2464         --pretty=*)
2465                 __gitcomp "$__git_log_pretty_formats $(__git_pretty_aliases)
2466                         " "" "${cur##--pretty=}"
2467                 return
2468                 ;;
2469         --format=*)
2470                 __gitcomp "$__git_log_pretty_formats $(__git_pretty_aliases)
2471                         " "" "${cur##--format=}"
2472                 return
2473                 ;;
2474         --*)
2475                 __gitcomp "--pretty= --format= --abbrev-commit --oneline
2476                         $__git_diff_common_options
2477                         "
2478                 return
2479                 ;;
2480         esac
2481         __git_complete_file
2482 }
2483
2484 _git_show_branch ()
2485 {
2486         local cur
2487         _get_comp_words_by_ref -n =: cur
2488         case "$cur" in
2489         --*)
2490                 __gitcomp "
2491                         --all --remotes --topo-order --current --more=
2492                         --list --independent --merge-base --no-name
2493                         --color --no-color
2494                         --sha1-name --sparse --topics --reflog
2495                         "
2496                 return
2497                 ;;
2498         esac
2499         __git_complete_revlist
2500 }
2501
2502 _git_stash ()
2503 {
2504         local cur
2505         _get_comp_words_by_ref -n =: cur
2506         local save_opts='--keep-index --no-keep-index --quiet --patch'
2507         local subcommands='save list show apply clear drop pop create branch'
2508         local subcommand="$(__git_find_on_cmdline "$subcommands")"
2509         if [ -z "$subcommand" ]; then
2510                 case "$cur" in
2511                 --*)
2512                         __gitcomp "$save_opts"
2513                         ;;
2514                 *)
2515                         if [ -z "$(__git_find_on_cmdline "$save_opts")" ]; then
2516                                 __gitcomp "$subcommands"
2517                         else
2518                                 COMPREPLY=()
2519                         fi
2520                         ;;
2521                 esac
2522         else
2523                 case "$subcommand,$cur" in
2524                 save,--*)
2525                         __gitcomp "$save_opts"
2526                         ;;
2527                 apply,--*|pop,--*)
2528                         __gitcomp "--index --quiet"
2529                         ;;
2530                 show,--*|drop,--*|branch,--*)
2531                         COMPREPLY=()
2532                         ;;
2533                 show,*|apply,*|drop,*|pop,*|branch,*)
2534                         __gitcomp "$(git --git-dir="$(__gitdir)" stash list \
2535                                         | sed -n -e 's/:.*//p')"
2536                         ;;
2537                 *)
2538                         COMPREPLY=()
2539                         ;;
2540                 esac
2541         fi
2542 }
2543
2544 _git_submodule ()
2545 {
2546         __git_has_doubledash && return
2547
2548         local subcommands="add status init update summary foreach sync"
2549         if [ -z "$(__git_find_on_cmdline "$subcommands")" ]; then
2550                 local cur
2551                 _get_comp_words_by_ref -n =: cur
2552                 case "$cur" in
2553                 --*)
2554                         __gitcomp "--quiet --cached"
2555                         ;;
2556                 *)
2557                         __gitcomp "$subcommands"
2558                         ;;
2559                 esac
2560                 return
2561         fi
2562 }
2563
2564 _git_svn ()
2565 {
2566         local subcommands="
2567                 init fetch clone rebase dcommit log find-rev
2568                 set-tree commit-diff info create-ignore propget
2569                 proplist show-ignore show-externals branch tag blame
2570                 migrate mkdirs reset gc
2571                 "
2572         local subcommand="$(__git_find_on_cmdline "$subcommands")"
2573         if [ -z "$subcommand" ]; then
2574                 __gitcomp "$subcommands"
2575         else
2576                 local remote_opts="--username= --config-dir= --no-auth-cache"
2577                 local fc_opts="
2578                         --follow-parent --authors-file= --repack=
2579                         --no-metadata --use-svm-props --use-svnsync-props
2580                         --log-window-size= --no-checkout --quiet
2581                         --repack-flags --use-log-author --localtime
2582                         --ignore-paths= $remote_opts
2583                         "
2584                 local init_opts="
2585                         --template= --shared= --trunk= --tags=
2586                         --branches= --stdlayout --minimize-url
2587                         --no-metadata --use-svm-props --use-svnsync-props
2588                         --rewrite-root= --prefix= --use-log-author
2589                         --add-author-from $remote_opts
2590                         "
2591                 local cmt_opts="
2592                         --edit --rmdir --find-copies-harder --copy-similarity=
2593                         "
2594
2595                 local cur
2596                 _get_comp_words_by_ref -n =: cur
2597                 case "$subcommand,$cur" in
2598                 fetch,--*)
2599                         __gitcomp "--revision= --fetch-all $fc_opts"
2600                         ;;
2601                 clone,--*)
2602                         __gitcomp "--revision= $fc_opts $init_opts"
2603                         ;;
2604                 init,--*)
2605                         __gitcomp "$init_opts"
2606                         ;;
2607                 dcommit,--*)
2608                         __gitcomp "
2609                                 --merge --strategy= --verbose --dry-run
2610                                 --fetch-all --no-rebase --commit-url
2611                                 --revision $cmt_opts $fc_opts
2612                                 "
2613                         ;;
2614                 set-tree,--*)
2615                         __gitcomp "--stdin $cmt_opts $fc_opts"
2616                         ;;
2617                 create-ignore,--*|propget,--*|proplist,--*|show-ignore,--*|\
2618                 show-externals,--*|mkdirs,--*)
2619                         __gitcomp "--revision="
2620                         ;;
2621                 log,--*)
2622                         __gitcomp "
2623                                 --limit= --revision= --verbose --incremental
2624                                 --oneline --show-commit --non-recursive
2625                                 --authors-file= --color
2626                                 "
2627                         ;;
2628                 rebase,--*)
2629                         __gitcomp "
2630                                 --merge --verbose --strategy= --local
2631                                 --fetch-all --dry-run $fc_opts
2632                                 "
2633                         ;;
2634                 commit-diff,--*)
2635                         __gitcomp "--message= --file= --revision= $cmt_opts"
2636                         ;;
2637                 info,--*)
2638                         __gitcomp "--url"
2639                         ;;
2640                 branch,--*)
2641                         __gitcomp "--dry-run --message --tag"
2642                         ;;
2643                 tag,--*)
2644                         __gitcomp "--dry-run --message"
2645                         ;;
2646                 blame,--*)
2647                         __gitcomp "--git-format"
2648                         ;;
2649                 migrate,--*)
2650                         __gitcomp "
2651                                 --config-dir= --ignore-paths= --minimize
2652                                 --no-auth-cache --username=
2653                                 "
2654                         ;;
2655                 reset,--*)
2656                         __gitcomp "--revision= --parent"
2657                         ;;
2658                 *)
2659                         COMPREPLY=()
2660                         ;;
2661                 esac
2662         fi
2663 }
2664
2665 _git_tag ()
2666 {
2667         local i c=1 f=0
2668         local words cword prev
2669         _get_comp_words_by_ref -n =: words cword prev
2670         while [ $c -lt $cword ]; do
2671                 i="${words[c]}"
2672                 case "$i" in
2673                 -d|-v)
2674                         __gitcomp "$(__git_tags)"
2675                         return
2676                         ;;
2677                 -f)
2678                         f=1
2679                         ;;
2680                 esac
2681                 c=$((++c))
2682         done
2683
2684         case "$prev" in
2685         -m|-F)
2686                 COMPREPLY=()
2687                 ;;
2688         -*|tag)
2689                 if [ $f = 1 ]; then
2690                         __gitcomp "$(__git_tags)"
2691                 else
2692                         COMPREPLY=()
2693                 fi
2694                 ;;
2695         *)
2696                 __gitcomp "$(__git_refs)"
2697                 ;;
2698         esac
2699 }
2700
2701 _git_whatchanged ()
2702 {
2703         _git_log
2704 }
2705
2706 _git ()
2707 {
2708         local i c=1 command __git_dir
2709
2710         if [[ -n ${ZSH_VERSION-} ]]; then
2711                 emulate -L bash
2712                 setopt KSH_TYPESET
2713
2714                 # workaround zsh's bug that leaves 'words' as a special
2715                 # variable in versions < 4.3.12
2716                 typeset -h words
2717         fi
2718
2719         local cur words cword
2720         _get_comp_words_by_ref -n =: cur words cword
2721         while [ $c -lt $cword ]; do
2722                 i="${words[c]}"
2723                 case "$i" in
2724                 --git-dir=*) __git_dir="${i#--git-dir=}" ;;
2725                 --bare)      __git_dir="." ;;
2726                 --version|-p|--paginate) ;;
2727                 --help) command="help"; break ;;
2728                 *) command="$i"; break ;;
2729                 esac
2730                 c=$((++c))
2731         done
2732
2733         if [ -z "$command" ]; then
2734                 case "$cur" in
2735                 --*)   __gitcomp "
2736                         --paginate
2737                         --no-pager
2738                         --git-dir=
2739                         --bare
2740                         --version
2741                         --exec-path
2742                         --html-path
2743                         --work-tree=
2744                         --help
2745                         "
2746                         ;;
2747                 *)     __git_compute_porcelain_commands
2748                        __gitcomp "$__git_porcelain_commands $(__git_aliases)" ;;
2749                 esac
2750                 return
2751         fi
2752
2753         local completion_func="_git_${command//-/_}"
2754         declare -f $completion_func >/dev/null && $completion_func && return
2755
2756         local expansion=$(__git_aliased_command "$command")
2757         if [ -n "$expansion" ]; then
2758                 completion_func="_git_${expansion//-/_}"
2759                 declare -f $completion_func >/dev/null && $completion_func
2760         fi
2761 }
2762
2763 _gitk ()
2764 {
2765         if [[ -n ${ZSH_VERSION-} ]]; then
2766                 emulate -L bash
2767                 setopt KSH_TYPESET
2768
2769                 # workaround zsh's bug that leaves 'words' as a special
2770                 # variable in versions < 4.3.12
2771                 typeset -h words
2772         fi
2773
2774         __git_has_doubledash && return
2775
2776         local cur
2777         local g="$(__gitdir)"
2778         local merge=""
2779         if [ -f "$g/MERGE_HEAD" ]; then
2780                 merge="--merge"
2781         fi
2782         _get_comp_words_by_ref -n =: cur
2783         case "$cur" in
2784         --*)
2785                 __gitcomp "
2786                         $__git_log_common_options
2787                         $__git_log_gitk_options
2788                         $merge
2789                         "
2790                 return
2791                 ;;
2792         esac
2793         __git_complete_revlist
2794 }
2795
2796 complete -o bashdefault -o default -o nospace -F _git git 2>/dev/null \
2797         || complete -o default -o nospace -F _git git
2798 complete -o bashdefault -o default -o nospace -F _gitk gitk 2>/dev/null \
2799         || complete -o default -o nospace -F _gitk gitk
2800
2801 # The following are necessary only for Cygwin, and only are needed
2802 # when the user has tab-completed the executable name and consequently
2803 # included the '.exe' suffix.
2804 #
2805 if [ Cygwin = "$(uname -o 2>/dev/null)" ]; then
2806 complete -o bashdefault -o default -o nospace -F _git git.exe 2>/dev/null \
2807         || complete -o default -o nospace -F _git git.exe
2808 fi
2809
2810 if [[ -n ${ZSH_VERSION-} ]]; then
2811         shopt () {
2812                 local option
2813                 if [ $# -ne 2 ]; then
2814                         echo "USAGE: $0 (-q|-s|-u) <option>" >&2
2815                         return 1
2816                 fi
2817                 case "$2" in
2818                 nullglob)
2819                         option="$2"
2820                         ;;
2821                 *)
2822                         echo "$0: invalid option: $2" >&2
2823                         return 1
2824                 esac
2825                 case "$1" in
2826                 -q)     setopt | grep -q "$option" ;;
2827                 -u)     unsetopt "$option" ;;
2828                 -s)     setopt "$option" ;;
2829                 *)
2830                         echo "$0: invalid flag: $1" >&2
2831                         return 1
2832                 esac
2833         }
2834 fi