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/BISECT_LOG" ]; then
 250                                 r="|BISECTING"
 251                         fi
 252
 253                         b="$(git symbolic-ref HEAD 2>/dev/null)" || {
 254
 255                                 b="$(
 256                                 case "${GIT_PS1_DESCRIBE_STYLE-}" in
 257                                 (contains)
 258                                         git describe --contains HEAD ;;
 259                                 (branch)
 260                                         git describe --contains --all HEAD ;;
 261                                 (describe)
 262                                         git describe HEAD ;;
 263                                 (* | default)
 264                                         git describe --tags --exact-match HEAD ;;
 265                                 esac 2>/dev/null)" ||
 266
 267                                 b="$(cut -c1-7 "$g/HEAD" 2>/dev/null)..." ||
 268                                 b="unknown"
 269                                 b="($b)"
 270                         }
 271                 fi
 272
 273                 local w=""
 274                 local i=""
 275                 local s=""
 276                 local u=""
 277                 local c=""
 278                 local p=""
 279
 280                 if [ "true" = "$(git rev-parse --is-inside-git-dir 2>/dev/null)" ]; then
 281                         if [ "true" = "$(git rev-parse --is-bare-repository 2>/dev/null)" ]; then
 282                                 c="BARE:"
 283                         else
 284                                 b="GIT_DIR!"
 285                         fi
 286                 elif [ "true" = "$(git rev-parse --is-inside-work-tree 2>/dev/null)" ]; then
 287                         if [ -n "${GIT_PS1_SHOWDIRTYSTATE-}" ]; then
 288                                 if [ "$(git config --bool bash.showDirtyState)" != "false" ]; then
 289                                         git diff --no-ext-diff --quiet --exit-code || w="*"
 290                                         if git rev-parse --quiet --verify HEAD >/dev/null; then
 291                                                 git diff-index --cached --quiet HEAD -- || i="+"
 292                                         else
 293                                                 i="#"
 294                                         fi
 295                                 fi
 296                         fi
 297                         if [ -n "${GIT_PS1_SHOWSTASHSTATE-}" ]; then
 298                                 git rev-parse --verify refs/stash >/dev/null 2>&1 && s="$"
 299                         fi
 300
 301                         if [ -n "${GIT_PS1_SHOWUNTRACKEDFILES-}" ]; then
 302                            if [ -n "$(git ls-files --others --exclude-standard)" ]; then
 303                               u="%"
 304                            fi
 305                         fi
 306
 307                         if [ -n "${GIT_PS1_SHOWUPSTREAM-}" ]; then
 308                                 __git_ps1_show_upstream
 309                         fi
 310                 fi
 311
 312                 local f="$w$i$s$u"
 313                 printf "${1:- (%s)}" "$c${b##refs/heads/}${f:+ $f}$r$p"
 314         fi
 315 }
 316
 317 # __gitcomp_1 requires 2 arguments
 318 __gitcomp_1 ()
 319 {
 320         local c IFS=' '$'\t'$'\n'
 321         for c in $1; do
 322                 case "$c$2" in
 323                 --*=*) printf %s$'\n' "$c$2" ;;
 324                 *.)    printf %s$'\n' "$c$2" ;;
 325                 *)     printf %s$'\n' "$c$2 " ;;
 326                 esac
 327         done
 328 }
 329
 330 # The following function is based on code from:
 331 #
 332 #   bash_completion - programmable completion functions for bash 3.2+
 333 #
 334 #   Copyright © 2006-2008, Ian Macdonald <ian@caliban.org>
 335 #             © 2009-2010, Bash Completion Maintainers
 336 #                     <bash-completion-devel@lists.alioth.debian.org>
 337 #
 338 #   This program is free software; you can redistribute it and/or modify
 339 #   it under the terms of the GNU General Public License as published by
 340 #   the Free Software Foundation; either version 2, or (at your option)
 341 #   any later version.
 342 #
 343 #   This program is distributed in the hope that it will be useful,
 344 #   but WITHOUT ANY WARRANTY; without even the implied warranty of
 345 #   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 346 #   GNU General Public License for more details.
 347 #
 348 #   You should have received a copy of the GNU General Public License
 349 #   along with this program; if not, write to the Free Software Foundation,
 350 #   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 351 #
 352 #   The latest version of this software can be obtained here:
 353 #
 354 #   http://bash-completion.alioth.debian.org/
 355 #
 356 #   RELEASE: 2.x
 357
 358 # This function can be used to access a tokenized list of words
 359 # on the command line:
 360 #
 361 #       __git_reassemble_comp_words_by_ref '=:'
 362 #       if test "${words_[cword_-1]}" = -w
 363 #       then
 364 #               ...
 365 #       fi
 366 #
 367 # The argument should be a collection of characters from the list of
 368 # word completion separators (COMP_WORDBREAKS) to treat as ordinary
 369 # characters.
 370 #
 371 # This is roughly equivalent to going back in time and setting
 372 # COMP_WORDBREAKS to exclude those characters.  The intent is to
 373 # make option types like --date=<type> and <rev>:<path> easy to
 374 # recognize by treating each shell word as a single token.
 375 #
 376 # It is best not to set COMP_WORDBREAKS directly because the value is
 377 # shared with other completion scripts.  By the time the completion
 378 # function gets called, COMP_WORDS has already been populated so local
 379 # changes to COMP_WORDBREAKS have no effect.
 380 #
 381 # Output: words_, cword_, cur_.
 382
 383 __git_reassemble_comp_words_by_ref()
 384 {
 385         local exclude i j first
 386         # Which word separators to exclude?
 387         exclude="${1//[^$COMP_WORDBREAKS]}"
 388         cword_=$COMP_CWORD
 389         if [ -z "$exclude" ]; then
 390                 words_=("${COMP_WORDS[@]}")
 391                 return
 392         fi
 393         # List of word completion separators has shrunk;
 394         # re-assemble words to complete.
 395         for ((i=0, j=0; i < ${#COMP_WORDS[@]}; i++, j++)); do
 396                 # Append each nonempty word consisting of just
 397                 # word separator characters to the current word.
 398                 first=t
 399                 while
 400                         [ $i -gt 0 ] &&
 401                         [ -n "${COMP_WORDS[$i]}" ] &&
 402                         # word consists of excluded word separators
 403                         [ "${COMP_WORDS[$i]//[^$exclude]}" = "${COMP_WORDS[$i]}" ]
 404                 do
 405                         # Attach to the previous token,
 406                         # unless the previous token is the command name.
 407                         if [ $j -ge 2 ] && [ -n "$first" ]; then
 408                                 ((j--))
 409                         fi
 410                         first=
 411                         words_[$j]=${words_[j]}${COMP_WORDS[i]}
 412                         if [ $i = $COMP_CWORD ]; then
 413                                 cword_=$j
 414                         fi
 415                         if (($i < ${#COMP_WORDS[@]} - 1)); then
 416                                 ((i++))
 417                         else
 418                                 # Done.
 419                                 return
 420                         fi
 421                 done
 422                 words_[$j]=${words_[j]}${COMP_WORDS[i]}
 423                 if [ $i = $COMP_CWORD ]; then
 424                         cword_=$j
 425                 fi
 426         done
 427 }
 428
 429 if ! type _get_comp_words_by_ref >/dev/null 2>&1; then
 430 if [[ -z ${ZSH_VERSION:+set} ]]; then
 431 _get_comp_words_by_ref ()
 432 {
 433         local exclude cur_ words_ cword_
 434         if [ "$1" = "-n" ]; then
 435                 exclude=$2
 436                 shift 2
 437         fi
 438         __git_reassemble_comp_words_by_ref "$exclude"
 439         cur_=${words_[cword_]}
 440         while [ $# -gt 0 ]; do
 441                 case "$1" in
 442                 cur)
 443                         cur=$cur_
 444                         ;;
 445                 prev)
 446                         prev=${words_[$cword_-1]}
 447                         ;;
 448                 words)
 449                         words=("${words_[@]}")
 450                         ;;
 451                 cword)
 452                         cword=$cword_
 453                         ;;
 454                 esac
 455                 shift
 456         done
 457 }
 458 else
 459 _get_comp_words_by_ref ()
 460 {
 461         while [ $# -gt 0 ]; do
 462                 case "$1" in
 463                 cur)
 464                         cur=${COMP_WORDS[COMP_CWORD]}
 465                         ;;
 466                 prev)
 467                         prev=${COMP_WORDS[COMP_CWORD-1]}
 468                         ;;
 469                 words)
 470                         words=("${COMP_WORDS[@]}")
 471                         ;;
 472                 cword)
 473                         cword=$COMP_CWORD
 474                         ;;
 475                 -n)
 476                         # assume COMP_WORDBREAKS is already set sanely
 477                         shift
 478                         ;;
 479                 esac
 480                 shift
 481         done
 482 }
 483 fi
 484 fi
 485
 486 # __gitcomp accepts 1, 2, 3, or 4 arguments
 487 # generates completion reply with compgen
 488 __gitcomp ()
 489 {
 490         local cur
 491         _get_comp_words_by_ref -n =: cur
 492         if [ $# -gt 2 ]; then
 493                 cur="$3"
 494         fi
 495         case "$cur" in
 496         --*=)
 497                 COMPREPLY=()
 498                 ;;
 499         *)
 500                 local IFS=$'\n'
 501                 COMPREPLY=($(compgen -P "${2-}" \
 502                         -W "$(__gitcomp_1 "${1-}" "${4-}")" \
 503                         -- "$cur"))
 504                 ;;
 505         esac
 506 }
 507
 508 # __git_heads accepts 0 or 1 arguments (to pass to __gitdir)
 509 __git_heads ()
 510 {
 511         local cmd i is_hash=y dir="$(__gitdir "${1-}")"
 512         if [ -d "$dir" ]; then
 513                 git --git-dir="$dir" for-each-ref --format='%(refname:short)' \
 514                         refs/heads
 515                 return
 516         fi
 517         for i in $(git ls-remote "${1-}" 2>/dev/null); do
 518                 case "$is_hash,$i" in
 519                 y,*) is_hash=n ;;
 520                 n,*^{}) is_hash=y ;;
 521                 n,refs/heads/*) is_hash=y; echo "${i#refs/heads/}" ;;
 522                 n,*) is_hash=y; echo "$i" ;;
 523                 esac
 524         done
 525 }
 526
 527 # __git_tags accepts 0 or 1 arguments (to pass to __gitdir)
 528 __git_tags ()
 529 {
 530         local cmd i is_hash=y dir="$(__gitdir "${1-}")"
 531         if [ -d "$dir" ]; then
 532                 git --git-dir="$dir" for-each-ref --format='%(refname:short)' \
 533                         refs/tags
 534                 return
 535         fi
 536         for i in $(git ls-remote "${1-}" 2>/dev/null); do
 537                 case "$is_hash,$i" in
 538                 y,*) is_hash=n ;;
 539                 n,*^{}) is_hash=y ;;
 540                 n,refs/tags/*) is_hash=y; echo "${i#refs/tags/}" ;;
 541                 n,*) is_hash=y; echo "$i" ;;
 542                 esac
 543         done
 544 }
 545
 546 # __git_refs accepts 0, 1 (to pass to __gitdir), or 2 arguments
 547 # presence of 2nd argument means use the guess heuristic employed
 548 # by checkout for tracking branches
 549 __git_refs ()
 550 {
 551         local i is_hash=y dir="$(__gitdir "${1-}")" track="${2-}"
 552         local cur format refs
 553         _get_comp_words_by_ref -n =: cur
 554         if [ -d "$dir" ]; then
 555                 case "$cur" in
 556                 refs|refs/*)
 557                         format="refname"
 558                         refs="${cur%/*}"
 559                         track=""
 560                         ;;
 561                 *)
 562                         for i in HEAD FETCH_HEAD ORIG_HEAD MERGE_HEAD; do
 563                                 if [ -e "$dir/$i" ]; then echo $i; fi
 564                         done
 565                         format="refname:short"
 566                         refs="refs/tags refs/heads refs/remotes"
 567                         ;;
 568                 esac
 569                 git --git-dir="$dir" for-each-ref --format="%($format)" \
 570                         $refs
 571                 if [ -n "$track" ]; then
 572                         # employ the heuristic used by git checkout
 573                         # Try to find a remote branch that matches the completion word
 574                         # but only output if the branch name is unique
 575                         local ref entry
 576                         git --git-dir="$dir" for-each-ref --shell --format="ref=%(refname:short)" \
 577                                 "refs/remotes/" | \
 578                         while read entry; do
 579                                 eval "$entry"
 580                                 ref="${ref#*/}"
 581                                 if [[ "$ref" == "$cur"* ]]; then
 582                                         echo "$ref"
 583                                 fi
 584                         done | uniq -u
 585                 fi
 586                 return
 587         fi
 588         for i in $(git ls-remote "$dir" 2>/dev/null); do
 589                 case "$is_hash,$i" in
 590                 y,*) is_hash=n ;;
 591                 n,*^{}) is_hash=y ;;
 592                 n,refs/tags/*) is_hash=y; echo "${i#refs/tags/}" ;;
 593                 n,refs/heads/*) is_hash=y; echo "${i#refs/heads/}" ;;
 594                 n,refs/remotes/*) is_hash=y; echo "${i#refs/remotes/}" ;;
 595                 n,*) is_hash=y; echo "$i" ;;
 596                 esac
 597         done
 598 }
 599
 600 # __git_refs2 requires 1 argument (to pass to __git_refs)
 601 __git_refs2 ()
 602 {
 603         local i
 604         for i in $(__git_refs "$1"); do
 605                 echo "$i:$i"
 606         done
 607 }
 608
 609 # __git_refs_remotes requires 1 argument (to pass to ls-remote)
 610 __git_refs_remotes ()
 611 {
 612         local cmd i is_hash=y
 613         for i in $(git ls-remote "$1" 2>/dev/null); do
 614                 case "$is_hash,$i" in
 615                 n,refs/heads/*)
 616                         is_hash=y
 617                         echo "$i:refs/remotes/$1/${i#refs/heads/}"
 618                         ;;
 619                 y,*) is_hash=n ;;
 620                 n,*^{}) is_hash=y ;;
 621                 n,refs/tags/*) is_hash=y;;
 622                 n,*) is_hash=y; ;;
 623                 esac
 624         done
 625 }
 626
 627 __git_remotes ()
 628 {
 629         local i ngoff IFS=$'\n' d="$(__gitdir)"
 630         shopt -q nullglob || ngoff=1
 631         shopt -s nullglob
 632         for i in "$d/remotes"/*; do
 633                 echo ${i#$d/remotes/}
 634         done
 635         [ "$ngoff" ] && shopt -u nullglob
 636         for i in $(git --git-dir="$d" config --get-regexp 'remote\..*\.url' 2>/dev/null); do
 637                 i="${i#remote.}"
 638                 echo "${i/.url*/}"
 639         done
 640 }
 641
 642 __git_list_merge_strategies ()
 643 {
 644         git merge -s help 2>&1 |
 645         sed -n -e '/[Aa]vailable strategies are: /,/^$/{
 646                 s/\.$//
 647                 s/.*://
 648                 s/^[    ]*//
 649                 s/[     ]*$//
 650                 p
 651         }'
 652 }
 653
 654 __git_merge_strategies=
 655 # 'git merge -s help' (and thus detection of the merge strategy
 656 # list) fails, unfortunately, if run outside of any git working
 657 # tree.  __git_merge_strategies is set to the empty string in
 658 # that case, and the detection will be repeated the next time it
 659 # is needed.
 660 __git_compute_merge_strategies ()
 661 {
 662         : ${__git_merge_strategies:=$(__git_list_merge_strategies)}
 663 }
 664
 665 __git_complete_revlist_file ()
 666 {
 667         local pfx ls ref cur
 668         _get_comp_words_by_ref -n =: cur
 669         case "$cur" in
 670         *..?*:*)
 671                 return
 672                 ;;
 673         ?*:*)
 674                 ref="${cur%%:*}"
 675                 cur="${cur#*:}"
 676                 case "$cur" in
 677                 ?*/*)
 678                         pfx="${cur%/*}"
 679                         cur="${cur##*/}"
 680                         ls="$ref:$pfx"
 681                         pfx="$pfx/"
 682                         ;;
 683                 *)
 684                         ls="$ref"
 685                         ;;
 686                 esac
 687
 688                 case "$COMP_WORDBREAKS" in
 689                 *:*) : great ;;
 690                 *)   pfx="$ref:$pfx" ;;
 691                 esac
 692
 693                 local IFS=$'\n'
 694                 COMPREPLY=($(compgen -P "$pfx" \
 695                         -W "$(git --git-dir="$(__gitdir)" ls-tree "$ls" \
 696                                 | sed '/^100... blob /{
 697                                            s,^.*        ,,
 698                                            s,$, ,
 699                                        }
 700                                        /^120000 blob /{
 701                                            s,^.*        ,,
 702                                            s,$, ,
 703                                        }
 704                                        /^040000 tree /{
 705                                            s,^.*        ,,
 706                                            s,$,/,
 707                                        }
 708                                        s/^.*    //')" \
 709                         -- "$cur"))
 710                 ;;
 711         *...*)
 712                 pfx="${cur%...*}..."
 713                 cur="${cur#*...}"
 714                 __gitcomp "$(__git_refs)" "$pfx" "$cur"
 715                 ;;
 716         *..*)
 717                 pfx="${cur%..*}.."
 718                 cur="${cur#*..}"
 719                 __gitcomp "$(__git_refs)" "$pfx" "$cur"
 720                 ;;
 721         *)
 722                 __gitcomp "$(__git_refs)"
 723                 ;;
 724         esac
 725 }
 726
 727
 728 __git_complete_file ()
 729 {
 730         __git_complete_revlist_file
 731 }
 732
 733 __git_complete_revlist ()
 734 {
 735         __git_complete_revlist_file
 736 }
 737
 738 __git_complete_remote_or_refspec ()
 739 {
 740         local cur words cword
 741         _get_comp_words_by_ref -n =: cur words cword
 742         local cmd="${words[1]}"
 743         local i c=2 remote="" pfx="" lhs=1 no_complete_refspec=0
 744         while [ $c -lt $cword ]; do
 745                 i="${words[c]}"
 746                 case "$i" in
 747                 --mirror) [ "$cmd" = "push" ] && no_complete_refspec=1 ;;
 748                 --all)
 749                         case "$cmd" in
 750                         push) no_complete_refspec=1 ;;
 751                         fetch)
 752                                 COMPREPLY=()
 753                                 return
 754                                 ;;
 755                         *) ;;
 756                         esac
 757                         ;;
 758                 -*) ;;
 759                 *) remote="$i"; break ;;
 760                 esac
 761                 c=$((++c))
 762         done
 763         if [ -z "$remote" ]; then
 764                 __gitcomp "$(__git_remotes)"
 765                 return
 766         fi
 767         if [ $no_complete_refspec = 1 ]; then
 768                 COMPREPLY=()
 769                 return
 770         fi
 771         [ "$remote" = "." ] && remote=
 772         case "$cur" in
 773         *:*)
 774                 case "$COMP_WORDBREAKS" in
 775                 *:*) : great ;;
 776                 *)   pfx="${cur%%:*}:" ;;
 777                 esac
 778                 cur="${cur#*:}"
 779                 lhs=0
 780                 ;;
 781         +*)
 782                 pfx="+"
 783                 cur="${cur#+}"
 784                 ;;
 785         esac
 786         case "$cmd" in
 787         fetch)
 788                 if [ $lhs = 1 ]; then
 789                         __gitcomp "$(__git_refs2 "$remote")" "$pfx" "$cur"
 790                 else
 791                         __gitcomp "$(__git_refs)" "$pfx" "$cur"
 792                 fi
 793                 ;;
 794         pull)
 795                 if [ $lhs = 1 ]; then
 796                         __gitcomp "$(__git_refs "$remote")" "$pfx" "$cur"
 797                 else
 798                         __gitcomp "$(__git_refs)" "$pfx" "$cur"
 799                 fi
 800                 ;;
 801         push)
 802                 if [ $lhs = 1 ]; then
 803                         __gitcomp "$(__git_refs)" "$pfx" "$cur"
 804                 else
 805                         __gitcomp "$(__git_refs "$remote")" "$pfx" "$cur"
 806                 fi
 807                 ;;
 808         esac
 809 }
 810
 811 __git_complete_strategy ()
 812 {
 813         local cur prev
 814         _get_comp_words_by_ref -n =: cur prev
 815         __git_compute_merge_strategies
 816         case "$prev" in
 817         -s|--strategy)
 818                 __gitcomp "$__git_merge_strategies"
 819                 return 0
 820         esac
 821         case "$cur" in
 822         --strategy=*)
 823                 __gitcomp "$__git_merge_strategies" "" "${cur##--strategy=}"
 824                 return 0
 825                 ;;
 826         esac
 827         return 1
 828 }
 829
 830 __git_list_all_commands ()
 831 {
 832         local i IFS=" "$'\n'
 833         for i in $(git help -a|egrep '^  [a-zA-Z0-9]')
 834         do
 835                 case $i in
 836                 *--*)             : helper pattern;;
 837                 *) echo $i;;
 838                 esac
 839         done
 840 }
 841
 842 __git_all_commands=
 843 __git_compute_all_commands ()
 844 {
 845         : ${__git_all_commands:=$(__git_list_all_commands)}
 846 }
 847
 848 __git_list_porcelain_commands ()
 849 {
 850         local i IFS=" "$'\n'
 851         __git_compute_all_commands
 852         for i in "help" $__git_all_commands
 853         do
 854                 case $i in
 855                 *--*)             : helper pattern;;
 856                 applymbox)        : ask gittus;;
 857                 applypatch)       : ask gittus;;
 858                 archimport)       : import;;
 859                 cat-file)         : plumbing;;
 860                 check-attr)       : plumbing;;
 861                 check-ref-format) : plumbing;;
 862                 checkout-index)   : plumbing;;
 863                 commit-tree)      : plumbing;;
 864                 count-objects)    : infrequent;;
 865                 cvsexportcommit)  : export;;
 866                 cvsimport)        : import;;
 867                 cvsserver)        : daemon;;
 868                 daemon)           : daemon;;
 869                 diff-files)       : plumbing;;
 870                 diff-index)       : plumbing;;
 871                 diff-tree)        : plumbing;;
 872                 fast-import)      : import;;
 873                 fast-export)      : export;;
 874                 fsck-objects)     : plumbing;;
 875                 fetch-pack)       : plumbing;;
 876                 fmt-merge-msg)    : plumbing;;
 877                 for-each-ref)     : plumbing;;
 878                 hash-object)      : plumbing;;
 879                 http-*)           : transport;;
 880                 index-pack)       : plumbing;;
 881                 init-db)          : deprecated;;
 882                 local-fetch)      : plumbing;;
 883                 lost-found)       : infrequent;;
 884                 ls-files)         : plumbing;;
 885                 ls-remote)        : plumbing;;
 886                 ls-tree)          : plumbing;;
 887                 mailinfo)         : plumbing;;
 888                 mailsplit)        : plumbing;;
 889                 merge-*)          : plumbing;;
 890                 mktree)           : plumbing;;
 891                 mktag)            : plumbing;;
 892                 pack-objects)     : plumbing;;
 893                 pack-redundant)   : plumbing;;
 894                 pack-refs)        : plumbing;;
 895                 parse-remote)     : plumbing;;
 896                 patch-id)         : plumbing;;
 897                 peek-remote)      : plumbing;;
 898                 prune)            : plumbing;;
 899                 prune-packed)     : plumbing;;
 900                 quiltimport)      : import;;
 901                 read-tree)        : plumbing;;
 902                 receive-pack)     : plumbing;;
 903                 remote-*)         : transport;;
 904                 repo-config)      : deprecated;;
 905                 rerere)           : plumbing;;
 906                 rev-list)         : plumbing;;
 907                 rev-parse)        : plumbing;;
 908                 runstatus)        : plumbing;;
 909                 sh-setup)         : internal;;
 910                 shell)            : daemon;;
 911                 show-ref)         : plumbing;;
 912                 send-pack)        : plumbing;;
 913                 show-index)       : plumbing;;
 914                 ssh-*)            : transport;;
 915                 stripspace)       : plumbing;;
 916                 symbolic-ref)     : plumbing;;
 917                 tar-tree)         : deprecated;;
 918                 unpack-file)      : plumbing;;
 919                 unpack-objects)   : plumbing;;
 920                 update-index)     : plumbing;;
 921                 update-ref)       : plumbing;;
 922                 update-server-info) : daemon;;
 923                 upload-archive)   : plumbing;;
 924                 upload-pack)      : plumbing;;
 925                 write-tree)       : plumbing;;
 926                 var)              : infrequent;;
 927                 verify-pack)      : infrequent;;
 928                 verify-tag)       : plumbing;;
 929                 *) echo $i;;
 930                 esac
 931         done
 932 }
 933
 934 __git_porcelain_commands=
 935 __git_compute_porcelain_commands ()
 936 {
 937         __git_compute_all_commands
 938         : ${__git_porcelain_commands:=$(__git_list_porcelain_commands)}
 939 }
 940
 941 __git_pretty_aliases ()
 942 {
 943         local i IFS=$'\n'
 944         for i in $(git --git-dir="$(__gitdir)" config --get-regexp "pretty\..*" 2>/dev/null); do
 945                 case "$i" in
 946                 pretty.*)
 947                         i="${i#pretty.}"
 948                         echo "${i/ */}"
 949                         ;;
 950                 esac
 951         done
 952 }
 953
 954 __git_aliases ()
 955 {
 956         local i IFS=$'\n'
 957         for i in $(git --git-dir="$(__gitdir)" config --get-regexp "alias\..*" 2>/dev/null); do
 958                 case "$i" in
 959                 alias.*)
 960                         i="${i#alias.}"
 961                         echo "${i/ */}"
 962                         ;;
 963                 esac
 964         done
 965 }
 966
 967 # __git_aliased_command requires 1 argument
 968 __git_aliased_command ()
 969 {
 970         local word cmdline=$(git --git-dir="$(__gitdir)" \
 971                 config --get "alias.$1")
 972         for word in $cmdline; do
 973                 case "$word" in
 974                 \!gitk|gitk)
 975                         echo "gitk"
 976                         return
 977                         ;;
 978                 \!*)    : shell command alias ;;
 979                 -*)     : option ;;
 980                 *=*)    : setting env ;;
 981                 git)    : git itself ;;
 982                 *)
 983                         echo "$word"
 984                         return
 985                 esac
 986         done
 987 }
 988
 989 # __git_find_on_cmdline requires 1 argument
 990 __git_find_on_cmdline ()
 991 {
 992         local word subcommand c=1 words cword
 993         _get_comp_words_by_ref -n =: words cword
 994         while [ $c -lt $cword ]; do
 995                 word="${words[c]}"
 996                 for subcommand in $1; do
 997                         if [ "$subcommand" = "$word" ]; then
 998                                 echo "$subcommand"
 999                                 return
1000                         fi
1001                 done
1002                 c=$((++c))
1003         done
1004 }
1005
1006 __git_has_doubledash ()
1007 {
1008         local c=1 words cword
1009         _get_comp_words_by_ref -n =: words cword
1010         while [ $c -lt $cword ]; do
1011                 if [ "--" = "${words[c]}" ]; then
1012                         return 0
1013                 fi
1014                 c=$((++c))
1015         done
1016         return 1
1017 }
1018
1019 __git_whitespacelist="nowarn warn error error-all fix"
1020
1021 _git_am ()
1022 {
1023         local cur dir="$(__gitdir)"
1024         _get_comp_words_by_ref -n =: cur
1025         if [ -d "$dir"/rebase-apply ]; then
1026                 __gitcomp "--skip --continue --resolved --abort"
1027                 return
1028         fi
1029         case "$cur" in
1030         --whitespace=*)
1031                 __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
1032                 return
1033                 ;;
1034         --*)
1035                 __gitcomp "
1036                         --3way --committer-date-is-author-date --ignore-date
1037                         --ignore-whitespace --ignore-space-change
1038                         --interactive --keep --no-utf8 --signoff --utf8
1039                         --whitespace= --scissors
1040                         "
1041                 return
1042         esac
1043         COMPREPLY=()
1044 }
1045
1046 _git_apply ()
1047 {
1048         local cur
1049         _get_comp_words_by_ref -n =: cur
1050         case "$cur" in
1051         --whitespace=*)
1052                 __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
1053                 return
1054                 ;;
1055         --*)
1056                 __gitcomp "
1057                         --stat --numstat --summary --check --index
1058                         --cached --index-info --reverse --reject --unidiff-zero
1059                         --apply --no-add --exclude=
1060                         --ignore-whitespace --ignore-space-change
1061                         --whitespace= --inaccurate-eof --verbose
1062                         "
1063                 return
1064         esac
1065         COMPREPLY=()
1066 }
1067
1068 _git_add ()
1069 {
1070         __git_has_doubledash && return
1071
1072         local cur
1073         _get_comp_words_by_ref -n =: cur
1074         case "$cur" in
1075         --*)
1076                 __gitcomp "
1077                         --interactive --refresh --patch --update --dry-run
1078                         --ignore-errors --intent-to-add
1079                         "
1080                 return
1081         esac
1082         COMPREPLY=()
1083 }
1084
1085 _git_archive ()
1086 {
1087         local cur
1088         _get_comp_words_by_ref -n =: cur
1089         case "$cur" in
1090         --format=*)
1091                 __gitcomp "$(git archive --list)" "" "${cur##--format=}"
1092                 return
1093                 ;;
1094         --remote=*)
1095                 __gitcomp "$(__git_remotes)" "" "${cur##--remote=}"
1096                 return
1097                 ;;
1098         --*)
1099                 __gitcomp "
1100                         --format= --list --verbose
1101                         --prefix= --remote= --exec=
1102                         "
1103                 return
1104                 ;;
1105         esac
1106         __git_complete_file
1107 }
1108
1109 _git_bisect ()
1110 {
1111         __git_has_doubledash && return
1112
1113         local subcommands="start bad good skip reset visualize replay log run"
1114         local subcommand="$(__git_find_on_cmdline "$subcommands")"
1115         if [ -z "$subcommand" ]; then
1116                 if [ -f "$(__gitdir)"/BISECT_START ]; then
1117                         __gitcomp "$subcommands"
1118                 else
1119                         __gitcomp "replay start"
1120                 fi
1121                 return
1122         fi
1123
1124         case "$subcommand" in
1125         bad|good|reset|skip|start)
1126                 __gitcomp "$(__git_refs)"
1127                 ;;
1128         *)
1129                 COMPREPLY=()
1130                 ;;
1131         esac
1132 }
1133
1134 _git_branch ()
1135 {
1136         local i c=1 only_local_ref="n" has_r="n" cur words cword
1137
1138         _get_comp_words_by_ref -n =: cur words cword
1139         while [ $c -lt $cword ]; do
1140                 i="${words[c]}"
1141                 case "$i" in
1142                 -d|-m)  only_local_ref="y" ;;
1143                 -r)     has_r="y" ;;
1144                 esac
1145                 c=$((++c))
1146         done
1147
1148         case "$cur" in
1149         --*)
1150                 __gitcomp "
1151                         --color --no-color --verbose --abbrev= --no-abbrev
1152                         --track --no-track --contains --merged --no-merged
1153                         --set-upstream
1154                         "
1155                 ;;
1156         *)
1157                 if [ $only_local_ref = "y" -a $has_r = "n" ]; then
1158                         __gitcomp "$(__git_heads)"
1159                 else
1160                         __gitcomp "$(__git_refs)"
1161                 fi
1162                 ;;
1163         esac
1164 }
1165
1166 _git_bundle ()
1167 {
1168         local words cword
1169         _get_comp_words_by_ref -n =: words cword
1170         local cmd="${words[2]}"
1171         case "$cword" in
1172         2)
1173                 __gitcomp "create list-heads verify unbundle"
1174                 ;;
1175         3)
1176                 # looking for a file
1177                 ;;
1178         *)
1179                 case "$cmd" in
1180                         create)
1181                                 __git_complete_revlist
1182                         ;;
1183                 esac
1184                 ;;
1185         esac
1186 }
1187
1188 _git_checkout ()
1189 {
1190         __git_has_doubledash && return
1191
1192         local cur
1193         _get_comp_words_by_ref -n =: cur
1194         case "$cur" in
1195         --conflict=*)
1196                 __gitcomp "diff3 merge" "" "${cur##--conflict=}"
1197                 ;;
1198         --*)
1199                 __gitcomp "
1200                         --quiet --ours --theirs --track --no-track --merge
1201                         --conflict= --orphan --patch
1202                         "
1203                 ;;
1204         *)
1205                 # check if --track, --no-track, or --no-guess was specified
1206                 # if so, disable DWIM mode
1207                 local flags="--track --no-track --no-guess" track=1
1208                 if [ -n "$(__git_find_on_cmdline "$flags")" ]; then
1209                         track=''
1210                 fi
1211                 __gitcomp "$(__git_refs '' $track)"
1212                 ;;
1213         esac
1214 }
1215
1216 _git_cherry ()
1217 {
1218         __gitcomp "$(__git_refs)"
1219 }
1220
1221 _git_cherry_pick ()
1222 {
1223         local cur
1224         _get_comp_words_by_ref -n =: cur
1225         case "$cur" in
1226         --*)
1227                 __gitcomp "--edit --no-commit"
1228                 ;;
1229         *)
1230                 __gitcomp "$(__git_refs)"
1231                 ;;
1232         esac
1233 }
1234
1235 _git_clean ()
1236 {
1237         __git_has_doubledash && return
1238
1239         local cur
1240         _get_comp_words_by_ref -n =: cur
1241         case "$cur" in
1242         --*)
1243                 __gitcomp "--dry-run --quiet"
1244                 return
1245                 ;;
1246         esac
1247         COMPREPLY=()
1248 }
1249
1250 _git_clone ()
1251 {
1252         local cur
1253         _get_comp_words_by_ref -n =: cur
1254         case "$cur" in
1255         --*)
1256                 __gitcomp "
1257                         --local
1258                         --no-hardlinks
1259                         --shared
1260                         --reference
1261                         --quiet
1262                         --no-checkout
1263                         --bare
1264                         --mirror
1265                         --origin
1266                         --upload-pack
1267                         --template=
1268                         --depth
1269                         "
1270                 return
1271                 ;;
1272         esac
1273         COMPREPLY=()
1274 }
1275
1276 _git_commit ()
1277 {
1278         __git_has_doubledash && return
1279
1280         local cur
1281         _get_comp_words_by_ref -n =: cur
1282         case "$cur" in
1283         --cleanup=*)
1284                 __gitcomp "default strip verbatim whitespace
1285                         " "" "${cur##--cleanup=}"
1286                 return
1287                 ;;
1288         --reuse-message=*)
1289                 __gitcomp "$(__git_refs)" "" "${cur##--reuse-message=}"
1290                 return
1291                 ;;
1292         --reedit-message=*)
1293                 __gitcomp "$(__git_refs)" "" "${cur##--reedit-message=}"
1294                 return
1295                 ;;
1296         --untracked-files=*)
1297                 __gitcomp "all no normal" "" "${cur##--untracked-files=}"
1298                 return
1299                 ;;
1300         --*)
1301                 __gitcomp "
1302                         --all --author= --signoff --verify --no-verify
1303                         --edit --amend --include --only --interactive
1304                         --dry-run --reuse-message= --reedit-message=
1305                         --reset-author --file= --message= --template=
1306                         --cleanup= --untracked-files --untracked-files=
1307                         --verbose --quiet
1308                         "
1309                 return
1310         esac
1311         COMPREPLY=()
1312 }
1313
1314 _git_describe ()
1315 {
1316         local cur
1317         _get_comp_words_by_ref -n =: cur
1318         case "$cur" in
1319         --*)
1320                 __gitcomp "
1321                         --all --tags --contains --abbrev= --candidates=
1322                         --exact-match --debug --long --match --always
1323                         "
1324                 return
1325         esac
1326         __gitcomp "$(__git_refs)"
1327 }
1328
1329 __git_diff_common_options="--stat --numstat --shortstat --summary
1330                         --patch-with-stat --name-only --name-status --color
1331                         --no-color --color-words --no-renames --check
1332                         --full-index --binary --abbrev --diff-filter=
1333                         --find-copies-harder
1334                         --text --ignore-space-at-eol --ignore-space-change
1335                         --ignore-all-space --exit-code --quiet --ext-diff
1336                         --no-ext-diff
1337                         --no-prefix --src-prefix= --dst-prefix=
1338                         --inter-hunk-context=
1339                         --patience
1340                         --raw
1341                         --dirstat --dirstat= --dirstat-by-file
1342                         --dirstat-by-file= --cumulative
1343 "
1344
1345 _git_diff ()
1346 {
1347         __git_has_doubledash && return
1348
1349         local cur
1350         _get_comp_words_by_ref -n =: cur
1351         case "$cur" in
1352         --*)
1353                 __gitcomp "--cached --staged --pickaxe-all --pickaxe-regex
1354                         --base --ours --theirs --no-index
1355                         $__git_diff_common_options
1356                         "
1357                 return
1358                 ;;
1359         esac
1360         __git_complete_revlist_file
1361 }
1362
1363 __git_mergetools_common="diffuse ecmerge emerge kdiff3 meld opendiff
1364                         tkdiff vimdiff gvimdiff xxdiff araxis p4merge
1365 "
1366
1367 _git_difftool ()
1368 {
1369         __git_has_doubledash && return
1370
1371         local cur
1372         _get_comp_words_by_ref -n =: cur
1373         case "$cur" in
1374         --tool=*)
1375                 __gitcomp "$__git_mergetools_common kompare" "" "${cur##--tool=}"
1376                 return
1377                 ;;
1378         --*)
1379                 __gitcomp "--cached --staged --pickaxe-all --pickaxe-regex
1380                         --base --ours --theirs
1381                         --no-renames --diff-filter= --find-copies-harder
1382                         --relative --ignore-submodules
1383                         --tool="
1384                 return
1385                 ;;
1386         esac
1387         __git_complete_file
1388 }
1389
1390 __git_fetch_options="
1391         --quiet --verbose --append --upload-pack --force --keep --depth=
1392         --tags --no-tags --all --prune --dry-run
1393 "
1394
1395 _git_fetch ()
1396 {
1397         local cur
1398         _get_comp_words_by_ref -n =: cur
1399         case "$cur" in
1400         --*)
1401                 __gitcomp "$__git_fetch_options"
1402                 return
1403                 ;;
1404         esac
1405         __git_complete_remote_or_refspec
1406 }
1407
1408 _git_format_patch ()
1409 {
1410         local cur
1411         _get_comp_words_by_ref -n =: cur
1412         case "$cur" in
1413         --thread=*)
1414                 __gitcomp "
1415                         deep shallow
1416                         " "" "${cur##--thread=}"
1417                 return
1418                 ;;
1419         --*)
1420                 __gitcomp "
1421                         --stdout --attach --no-attach --thread --thread=
1422                         --output-directory
1423                         --numbered --start-number
1424                         --numbered-files
1425                         --keep-subject
1426                         --signoff --signature --no-signature
1427                         --in-reply-to= --cc=
1428                         --full-index --binary
1429                         --not --all
1430                         --cover-letter
1431                         --no-prefix --src-prefix= --dst-prefix=
1432                         --inline --suffix= --ignore-if-in-upstream
1433                         --subject-prefix=
1434                         "
1435                 return
1436                 ;;
1437         esac
1438         __git_complete_revlist
1439 }
1440
1441 _git_fsck ()
1442 {
1443         local cur
1444         _get_comp_words_by_ref -n =: cur
1445         case "$cur" in
1446         --*)
1447                 __gitcomp "
1448                         --tags --root --unreachable --cache --no-reflogs --full
1449                         --strict --verbose --lost-found
1450                         "
1451                 return
1452                 ;;
1453         esac
1454         COMPREPLY=()
1455 }
1456
1457 _git_gc ()
1458 {
1459         local cur
1460         _get_comp_words_by_ref -n =: cur
1461         case "$cur" in
1462         --*)
1463                 __gitcomp "--prune --aggressive"
1464                 return
1465                 ;;
1466         esac
1467         COMPREPLY=()
1468 }
1469
1470 _git_gitk ()
1471 {
1472         _gitk
1473 }
1474
1475 _git_grep ()
1476 {
1477         __git_has_doubledash && return
1478
1479         local cur
1480         _get_comp_words_by_ref -n =: cur
1481         case "$cur" in
1482         --*)
1483                 __gitcomp "
1484                         --cached
1485                         --text --ignore-case --word-regexp --invert-match
1486                         --full-name
1487                         --extended-regexp --basic-regexp --fixed-strings
1488                         --files-with-matches --name-only
1489                         --files-without-match
1490                         --max-depth
1491                         --count
1492                         --and --or --not --all-match
1493                         "
1494                 return
1495                 ;;
1496         esac
1497
1498         __gitcomp "$(__git_refs)"
1499 }
1500
1501 _git_help ()
1502 {
1503         local cur
1504         _get_comp_words_by_ref -n =: cur
1505         case "$cur" in
1506         --*)
1507                 __gitcomp "--all --info --man --web"
1508                 return
1509                 ;;
1510         esac
1511         __git_compute_all_commands
1512         __gitcomp "$__git_all_commands
1513                 attributes cli core-tutorial cvs-migration
1514                 diffcore gitk glossary hooks ignore modules
1515                 repository-layout tutorial tutorial-2
1516                 workflows
1517                 "
1518 }
1519
1520 _git_init ()
1521 {
1522         local cur
1523         _get_comp_words_by_ref -n =: cur
1524         case "$cur" in
1525         --shared=*)
1526                 __gitcomp "
1527                         false true umask group all world everybody
1528                         " "" "${cur##--shared=}"
1529                 return
1530                 ;;
1531         --*)
1532                 __gitcomp "--quiet --bare --template= --shared --shared="
1533                 return
1534                 ;;
1535         esac
1536         COMPREPLY=()
1537 }
1538
1539 _git_ls_files ()
1540 {
1541         __git_has_doubledash && return
1542
1543         local cur
1544         _get_comp_words_by_ref -n =: cur
1545         case "$cur" in
1546         --*)
1547                 __gitcomp "--cached --deleted --modified --others --ignored
1548                         --stage --directory --no-empty-directory --unmerged
1549                         --killed --exclude= --exclude-from=
1550                         --exclude-per-directory= --exclude-standard
1551                         --error-unmatch --with-tree= --full-name
1552                         --abbrev --ignored --exclude-per-directory
1553                         "
1554                 return
1555                 ;;
1556         esac
1557         COMPREPLY=()
1558 }
1559
1560 _git_ls_remote ()
1561 {
1562         __gitcomp "$(__git_remotes)"
1563 }
1564
1565 _git_ls_tree ()
1566 {
1567         __git_complete_file
1568 }
1569
1570 # Options that go well for log, shortlog and gitk
1571 __git_log_common_options="
1572         --not --all
1573         --branches --tags --remotes
1574         --first-parent --merges --no-merges
1575         --max-count=
1576         --max-age= --since= --after=
1577         --min-age= --until= --before=
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