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