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