git.oblomov.eu Git - git/blob - contrib/completion/git-completion.bash

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