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         svn_remote=()
 113         # get some config options from git-config
 114         local output="$(git config -z --get-regexp '^(svn-remote\..*\.url|bash\.showupstream)$' 2>/dev/null | tr '\0\n' '\n ')"
 115         while read -r key value; do
 116                 case "$key" in
 117                 bash.showupstream)
 118                         GIT_PS1_SHOWUPSTREAM="$value"
 119                         if [[ -z "${GIT_PS1_SHOWUPSTREAM}" ]]; then
 120                                 p=""
 121                                 return
 122                         fi
 123                         ;;
 124                 svn-remote.*.url)
 125                         svn_remote[ $((${#svn_remote[@]} + 1)) ]="$value"
 126                         svn_url_pattern+="\\|$value"
 127                         upstream=svn+git # default upstream is SVN if available, else git
 128                         ;;
 129                 esac
 130         done <<< "$output"
 131
 132         # parse configuration values
 133         for option in ${GIT_PS1_SHOWUPSTREAM}; do
 134                 case "$option" in
 135                 git|svn) upstream="$option" ;;
 136                 verbose) verbose=1 ;;
 137                 legacy)  legacy=1  ;;
 138                 esac
 139         done
 140
 141         # Find our upstream
 142         case "$upstream" in
 143         git)    upstream="@{upstream}" ;;
 144         svn*)
 145                 # get the upstream from the "git-svn-id: ..." in a commit message
 146                 # (git-svn uses essentially the same procedure internally)
 147                 local svn_upstream=($(git log --first-parent -1 \
 148                                         --grep="^git-svn-id: \(${svn_url_pattern#??}\)" 2>/dev/null))
 149                 if [[ 0 -ne ${#svn_upstream[@]} ]]; then
 150                         svn_upstream=${svn_upstream[ ${#svn_upstream[@]} - 2 ]}
 151                         svn_upstream=${svn_upstream%@*}
 152                         local n_stop="${#svn_remote[@]}"
 153                         for ((n=1; n <= n_stop; ++n)); do
 154                                 svn_upstream=${svn_upstream#${svn_remote[$n]}}
 155                         done
 156
 157                         if [[ -z "$svn_upstream" ]]; then
 158                                 # default branch name for checkouts with no layout:
 159                                 upstream=${GIT_SVN_ID:-git-svn}
 160                         else
 161                                 upstream=${svn_upstream#/}
 162                         fi
 163                 elif [[ "svn+git" = "$upstream" ]]; then
 164                         upstream="@{upstream}"
 165                 fi
 166                 ;;
 167         esac
 168
 169         # Find how many commits we are ahead/behind our upstream
 170         if [[ -z "$legacy" ]]; then
 171                 count="$(git rev-list --count --left-right \
 172                                 "$upstream"...HEAD 2>/dev/null)"
 173         else
 174                 # produce equivalent output to --count for older versions of git
 175                 local commits
 176                 if commits="$(git rev-list --left-right "$upstream"...HEAD 2>/dev/null)"
 177                 then
 178                         local commit behind=0 ahead=0
 179                         for commit in $commits
 180                         do
 181                                 case "$commit" in
 182                                 "<"*) let ++behind
 183                                         ;;
 184                                 *)    let ++ahead
 185                                         ;;
 186                                 esac
 187                         done
 188                         count="$behind  $ahead"
 189                 else
 190                         count=""
 191                 fi
 192         fi
 193
 194         # calculate the result
 195         if [[ -z "$verbose" ]]; then
 196                 case "$count" in
 197                 "") # no upstream
 198                         p="" ;;
 199                 "0      0") # equal to upstream
 200                         p="=" ;;
 201                 "0      "*) # ahead of upstream
 202                         p=">" ;;
 203                 *"      0") # behind upstream
 204                         p="<" ;;
 205                 *)          # diverged from upstream
 206                         p="<>" ;;
 207                 esac
 208         else
 209                 case "$count" in
 210                 "") # no upstream
 211                         p="" ;;
 212                 "0      0") # equal to upstream
 213                         p=" u=" ;;
 214                 "0      "*) # ahead of upstream
 215                         p=" u+${count#0 }" ;;
 216                 *"      0") # behind upstream
 217                         p=" u-${count%  0}" ;;
 218                 *)          # diverged from upstream
 219                         p=" u+${count#* }-${count%      *}" ;;
 220                 esac
 221         fi
 222
 223 }
 224
 225
 226 # __git_ps1 accepts 0 or 1 arguments (i.e., format string)
 227 # returns text to add to bash PS1 prompt (includes branch name)
 228 __git_ps1 ()
 229 {
 230         local g="$(__gitdir)"
 231         if [ -n "$g" ]; then
 232                 local r=""
 233                 local b=""
 234                 if [ -f "$g/rebase-merge/interactive" ]; then
 235                         r="|REBASE-i"
 236                         b="$(cat "$g/rebase-merge/head-name")"
 237                 elif [ -d "$g/rebase-merge" ]; then
 238                         r="|REBASE-m"
 239                         b="$(cat "$g/rebase-merge/head-name")"
 240                 else
 241                         if [ -d "$g/rebase-apply" ]; then
 242                                 if [ -f "$g/rebase-apply/rebasing" ]; then
 243                                         r="|REBASE"
 244                                 elif [ -f "$g/rebase-apply/applying" ]; then
 245                                         r="|AM"
 246                                 else
 247                                         r="|AM/REBASE"
 248                                 fi
 249                         elif [ -f "$g/MERGE_HEAD" ]; then
 250                                 r="|MERGING"
 251                         elif [ -f "$g/CHERRY_PICK_HEAD" ]; then
 252                                 r="|CHERRY-PICKING"
 253                         elif [ -f "$g/BISECT_LOG" ]; then
 254                                 r="|BISECTING"
 255                         fi
 256
 257                         b="$(git symbolic-ref HEAD 2>/dev/null)" || {
 258
 259                                 b="$(
 260                                 case "${GIT_PS1_DESCRIBE_STYLE-}" in
 261                                 (contains)
 262                                         git describe --contains HEAD ;;
 263                                 (branch)
 264                                         git describe --contains --all HEAD ;;
 265                                 (describe)
 266                                         git describe HEAD ;;
 267                                 (* | default)
 268                                         git describe --tags --exact-match HEAD ;;
 269                                 esac 2>/dev/null)" ||
 270
 271                                 b="$(cut -c1-7 "$g/HEAD" 2>/dev/null)..." ||
 272                                 b="unknown"
 273                                 b="($b)"
 274                         }
 275                 fi
 276
 277                 local w=""
 278                 local i=""
 279                 local s=""
 280                 local u=""
 281                 local c=""
 282                 local p=""
 283
 284                 if [ "true" = "$(git rev-parse --is-inside-git-dir 2>/dev/null)" ]; then
 285                         if [ "true" = "$(git rev-parse --is-bare-repository 2>/dev/null)" ]; then
 286                                 c="BARE:"
 287                         else
 288                                 b="GIT_DIR!"
 289                         fi
 290                 elif [ "true" = "$(git rev-parse --is-inside-work-tree 2>/dev/null)" ]; then
 291                         if [ -n "${GIT_PS1_SHOWDIRTYSTATE-}" ]; then
 292                                 if [ "$(git config --bool bash.showDirtyState)" != "false" ]; then
 293                                         git diff --no-ext-diff --quiet --exit-code || w="*"
 294                                         if git rev-parse --quiet --verify HEAD >/dev/null; then
 295                                                 git diff-index --cached --quiet HEAD -- || i="+"
 296                                         else
 297                                                 i="#"
 298                                         fi
 299                                 fi
 300                         fi
 301                         if [ -n "${GIT_PS1_SHOWSTASHSTATE-}" ]; then
 302                                 git rev-parse --verify refs/stash >/dev/null 2>&1 && s="$"
 303                         fi
 304
 305                         if [ -n "${GIT_PS1_SHOWUNTRACKEDFILES-}" ]; then
 306                            if [ -n "$(git ls-files --others --exclude-standard)" ]; then
 307                               u="%"
 308                            fi
 309                         fi
 310
 311                         if [ -n "${GIT_PS1_SHOWUPSTREAM-}" ]; then
 312                                 __git_ps1_show_upstream
 313                         fi
 314                 fi
 315
 316                 local f="$w$i$s$u"
 317                 printf "${1:- (%s)}" "$c${b##refs/heads/}${f:+ $f}$r$p"
 318         fi
 319 }
 320
 321 # __gitcomp_1 requires 2 arguments
 322 __gitcomp_1 ()
 323 {
 324         local c IFS=' '$'\t'$'\n'
 325         for c in $1; do
 326                 case "$c$2" in
 327                 --*=*) printf %s$'\n' "$c$2" ;;
 328                 *.)    printf %s$'\n' "$c$2" ;;
 329                 *)     printf %s$'\n' "$c$2 " ;;
 330                 esac
 331         done
 332 }
 333
 334 # The following function is based on code from:
 335 #
 336 #   bash_completion - programmable completion functions for bash 3.2+
 337 #
 338 #   Copyright © 2006-2008, Ian Macdonald <ian@caliban.org>
 339 #             © 2009-2010, Bash Completion Maintainers
 340 #                     <bash-completion-devel@lists.alioth.debian.org>
 341 #
 342 #   This program is free software; you can redistribute it and/or modify
 343 #   it under the terms of the GNU General Public License as published by
 344 #   the Free Software Foundation; either version 2, or (at your option)
 345 #   any later version.
 346 #
 347 #   This program is distributed in the hope that it will be useful,
 348 #   but WITHOUT ANY WARRANTY; without even the implied warranty of
 349 #   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 350 #   GNU General Public License for more details.
 351 #
 352 #   You should have received a copy of the GNU General Public License
 353 #   along with this program; if not, write to the Free Software Foundation,
 354 #   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 355 #
 356 #   The latest version of this software can be obtained here:
 357 #
 358 #   http://bash-completion.alioth.debian.org/
 359 #
 360 #   RELEASE: 2.x
 361
 362 # This function can be used to access a tokenized list of words
 363 # on the command line:
 364 #
 365 #       __git_reassemble_comp_words_by_ref '=:'
 366 #       if test "${words_[cword_-1]}" = -w
 367 #       then
 368 #               ...
 369 #       fi
 370 #
 371 # The argument should be a collection of characters from the list of
 372 # word completion separators (COMP_WORDBREAKS) to treat as ordinary
 373 # characters.
 374 #
 375 # This is roughly equivalent to going back in time and setting
 376 # COMP_WORDBREAKS to exclude those characters.  The intent is to
 377 # make option types like --date=<type> and <rev>:<path> easy to
 378 # recognize by treating each shell word as a single token.
 379 #
 380 # It is best not to set COMP_WORDBREAKS directly because the value is
 381 # shared with other completion scripts.  By the time the completion
 382 # function gets called, COMP_WORDS has already been populated so local
 383 # changes to COMP_WORDBREAKS have no effect.
 384 #
 385 # Output: words_, cword_, cur_.
 386
 387 __git_reassemble_comp_words_by_ref()
 388 {
 389         local exclude i j first
 390         # Which word separators to exclude?
 391         exclude="${1//[^$COMP_WORDBREAKS]}"
 392         cword_=$COMP_CWORD
 393         if [ -z "$exclude" ]; then
 394                 words_=("${COMP_WORDS[@]}")
 395                 return
 396         fi
 397         # List of word completion separators has shrunk;
 398         # re-assemble words to complete.
 399         for ((i=0, j=0; i < ${#COMP_WORDS[@]}; i++, j++)); do
 400                 # Append each nonempty word consisting of just
 401                 # word separator characters to the current word.
 402                 first=t
 403                 while
 404                         [ $i -gt 0 ] &&
 405                         [ -n "${COMP_WORDS[$i]}" ] &&
 406                         # word consists of excluded word separators
 407                         [ "${COMP_WORDS[$i]//[^$exclude]}" = "${COMP_WORDS[$i]}" ]
 408                 do
 409                         # Attach to the previous token,
 410                         # unless the previous token is the command name.
 411                         if [ $j -ge 2 ] && [ -n "$first" ]; then
 412                                 ((j--))
 413                         fi
 414                         first=
 415                         words_[$j]=${words_[j]}${COMP_WORDS[i]}
 416                         if [ $i = $COMP_CWORD ]; then
 417                                 cword_=$j
 418                         fi
 419                         if (($i < ${#COMP_WORDS[@]} - 1)); then
 420                                 ((i++))
 421                         else
 422                                 # Done.
 423                                 return
 424                         fi
 425                 done
 426                 words_[$j]=${words_[j]}${COMP_WORDS[i]}
 427                 if [ $i = $COMP_CWORD ]; then
 428                         cword_=$j
 429                 fi
 430         done
 431 }
 432
 433 if ! type _get_comp_words_by_ref >/dev/null 2>&1; then
 434 if [[ -z ${ZSH_VERSION:+set} ]]; then
 435 _get_comp_words_by_ref ()
 436 {
 437         local exclude cur_ words_ cword_
 438         if [ "$1" = "-n" ]; then
 439                 exclude=$2
 440                 shift 2
 441         fi
 442         __git_reassemble_comp_words_by_ref "$exclude"
 443         cur_=${words_[cword_]}
 444         while [ $# -gt 0 ]; do
 445                 case "$1" in
 446                 cur)
 447                         cur=$cur_
 448                         ;;
 449                 prev)
 450                         prev=${words_[$cword_-1]}
 451                         ;;
 452                 words)
 453                         words=("${words_[@]}")
 454                         ;;
 455                 cword)
 456                         cword=$cword_
 457                         ;;
 458                 esac
 459                 shift
 460         done
 461 }
 462 else
 463 _get_comp_words_by_ref ()
 464 {
 465         while [ $# -gt 0 ]; do
 466                 case "$1" in
 467                 cur)
 468                         cur=${COMP_WORDS[COMP_CWORD]}
 469                         ;;
 470                 prev)
 471                         prev=${COMP_WORDS[COMP_CWORD-1]}
 472                         ;;
 473                 words)
 474                         words=("${COMP_WORDS[@]}")
 475                         ;;
 476                 cword)
 477                         cword=$COMP_CWORD
 478                         ;;
 479                 -n)
 480                         # assume COMP_WORDBREAKS is already set sanely
 481                         shift
 482                         ;;
 483                 esac
 484                 shift
 485         done
 486 }
 487 fi
 488 fi
 489
 490 # Generates completion reply with compgen, appending a space to possible
 491 # completion words, if necessary.
 492 # It accepts 1 to 4 arguments:
 493 # 1: List of possible completion words.
 494 # 2: A prefix to be added to each possible completion word (optional).
 495 # 3: Generate possible completion matches for this word (optional).
 496 # 4: A suffix to be appended to each possible completion word (optional).
 497 __gitcomp ()
 498 {
 499         local cur_="${3-$cur}"
 500
 501         case "$cur_" in
 502         --*=)
 503                 COMPREPLY=()
 504                 ;;
 505         *)
 506                 local IFS=$'\n'
 507                 COMPREPLY=($(compgen -P "${2-}" \
 508                         -W "$(__gitcomp_1 "${1-}" "${4-}")" \
 509                         -- "$cur_"))
 510                 ;;
 511         esac
 512 }
 513
 514 # Generates completion reply with compgen from newline-separated possible
 515 # completion words by appending a space to all of them.
 516 # It accepts 1 to 4 arguments:
 517 # 1: List of possible completion words, separated by a single newline.
 518 # 2: A prefix to be added to each possible completion word (optional).
 519 # 3: Generate possible completion matches for this word (optional).
 520 # 4: A suffix to be appended to each possible completion word instead of
 521 #    the default space (optional).  If specified but empty, nothing is
 522 #    appended.
 523 __gitcomp_nl ()
 524 {
 525         local IFS=$'\n'
 526         COMPREPLY=($(compgen -P "${2-}" -S "${4- }" -W "$1" -- "${3-$cur}"))
 527 }
 528
 529 __git_heads ()
 530 {
 531         local dir="$(__gitdir)"
 532         if [ -d "$dir" ]; then
 533                 git --git-dir="$dir" for-each-ref --format='%(refname:short)' \
 534                         refs/heads
 535                 return
 536         fi
 537 }
 538
 539 __git_tags ()
 540 {
 541         local dir="$(__gitdir)"
 542         if [ -d "$dir" ]; then
 543                 git --git-dir="$dir" for-each-ref --format='%(refname:short)' \
 544                         refs/tags
 545                 return
 546         fi
 547 }
 548
 549 # __git_refs accepts 0, 1 (to pass to __gitdir), or 2 arguments
 550 # presence of 2nd argument means use the guess heuristic employed
 551 # by checkout for tracking branches
 552 __git_refs ()
 553 {
 554         local i hash dir="$(__gitdir "${1-}")" track="${2-}"
 555         local format refs
 556         if [ -d "$dir" ]; then
 557                 case "$cur" in
 558                 refs|refs/*)
 559                         format="refname"
 560                         refs="${cur%/*}"
 561                         track=""
 562                         ;;
 563                 *)
 564                         for i in HEAD FETCH_HEAD ORIG_HEAD MERGE_HEAD; do
 565                                 if [ -e "$dir/$i" ]; then echo $i; fi
 566                         done
 567                         format="refname:short"
 568                         refs="refs/tags refs/heads refs/remotes"
 569                         ;;
 570                 esac
 571                 git --git-dir="$dir" for-each-ref --format="%($format)" \
 572                         $refs
 573                 if [ -n "$track" ]; then
 574                         # employ the heuristic used by git checkout
 575                         # Try to find a remote branch that matches the completion word
 576                         # but only output if the branch name is unique
 577                         local ref entry
 578                         git --git-dir="$dir" for-each-ref --shell --format="ref=%(refname:short)" \
 579                                 "refs/remotes/" | \
 580                         while read -r entry; do
 581                                 eval "$entry"
 582                                 ref="${ref#*/}"
 583                                 if [[ "$ref" == "$cur"* ]]; then
 584                                         echo "$ref"
 585                                 fi
 586                         done | uniq -u
 587                 fi
 588                 return
 589         fi
 590         case "$cur" in
 591         refs|refs/*)
 592                 git ls-remote "$dir" "$cur*" 2>/dev/null | \
 593                 while read -r hash i; do
 594                         case "$i" in
 595                         *^{}) ;;
 596                         *) echo "$i" ;;
 597                         esac
 598                 done
 599                 ;;
 600         *)
 601                 git ls-remote "$dir" HEAD ORIG_HEAD 'refs/tags/*' 'refs/heads/*' 'refs/remotes/*' 2>/dev/null | \
 602                 while read -r hash i; do
 603                         case "$i" in
 604                         *^{}) ;;
 605                         refs/*) echo "${i#refs/*/}" ;;
 606                         *) echo "$i" ;;
 607                         esac
 608                 done
 609                 ;;
 610         esac
 611 }
 612
 613 # __git_refs2 requires 1 argument (to pass to __git_refs)
 614 __git_refs2 ()
 615 {
 616         local i
 617         for i in $(__git_refs "$1"); do
 618                 echo "$i:$i"
 619         done
 620 }
 621
 622 # __git_refs_remotes requires 1 argument (to pass to ls-remote)
 623 __git_refs_remotes ()
 624 {
 625         local i hash
 626         git ls-remote "$1" 'refs/heads/*' 2>/dev/null | \
 627         while read -r hash i; do
 628                 echo "$i:refs/remotes/$1/${i#refs/heads/}"
 629         done
 630 }
 631
 632 __git_remotes ()
 633 {
 634         local i IFS=$'\n' d="$(__gitdir)"
 635         test -d "$d/remotes" && ls -1 "$d/remotes"
 636         for i in $(git --git-dir="$d" config --get-regexp 'remote\..*\.url' 2>/dev/null); do
 637                 i="${i#remote.}"
 638                 echo "${i/.url*/}"
 639         done
 640 }
 641
 642 __git_list_merge_strategies ()
 643 {
 644         git merge -s help 2>&1 |
 645         sed -n -e '/[Aa]vailable strategies are: /,/^$/{
 646                 s/\.$//
 647                 s/.*://
 648                 s/^[    ]*//
 649                 s/[     ]*$//
 650                 p
 651         }'
 652 }
 653
 654 __git_merge_strategies=
 655 # 'git merge -s help' (and thus detection of the merge strategy
 656 # list) fails, unfortunately, if run outside of any git working
 657 # tree.  __git_merge_strategies is set to the empty string in
 658 # that case, and the detection will be repeated the next time it
 659 # is needed.
 660 __git_compute_merge_strategies ()
 661 {
 662         test -n "$__git_merge_strategies" ||
 663         __git_merge_strategies=$(__git_list_merge_strategies)
 664 }
 665
 666 __git_complete_revlist_file ()
 667 {
 668         local pfx ls ref cur_="$cur"
 669         case "$cur_" in
 670         *..?*:*)
 671                 return
 672                 ;;
 673         ?*:*)
 674                 ref="${cur_%%:*}"
 675                 cur_="${cur_#*:}"
 676                 case "$cur_" in
 677                 ?*/*)
 678                         pfx="${cur_%/*}"
 679                         cur_="${cur_##*/}"
 680                         ls="$ref:$pfx"
 681                         pfx="$pfx/"
 682                         ;;
 683                 *)
 684                         ls="$ref"
 685                         ;;
 686                 esac
 687
 688                 case "$COMP_WORDBREAKS" in
 689                 *:*) : great ;;
 690                 *)   pfx="$ref:$pfx" ;;
 691                 esac
 692
 693                 local IFS=$'\n'
 694                 COMPREPLY=($(compgen -P "$pfx" \
 695                         -W "$(git --git-dir="$(__gitdir)" ls-tree "$ls" \
 696                                 | sed '/^100... blob /{
 697                                            s,^.*        ,,
 698                                            s,$, ,
 699                                        }
 700                                        /^120000 blob /{
 701                                            s,^.*        ,,
 702                                            s,$, ,
 703                                        }
 704                                        /^040000 tree /{
 705                                            s,^.*        ,,
 706                                            s,$,/,
 707                                        }
 708                                        s/^.*    //')" \
 709                         -- "$cur_"))
 710                 ;;
 711         *...*)
 712                 pfx="${cur_%...*}..."
 713                 cur_="${cur_#*...}"
 714                 __gitcomp_nl "$(__git_refs)" "$pfx" "$cur_"
 715                 ;;
 716         *..*)
 717                 pfx="${cur_%..*}.."
 718                 cur_="${cur_#*..}"
 719                 __gitcomp_nl "$(__git_refs)" "$pfx" "$cur_"
 720                 ;;
 721         *)
 722                 __gitcomp_nl "$(__git_refs)"
 723                 ;;
 724         esac
 725 }
 726
 727
 728 __git_complete_file ()
 729 {
 730         __git_complete_revlist_file
 731 }
 732
 733 __git_complete_revlist ()
 734 {
 735         __git_complete_revlist_file
 736 }
 737
 738 __git_complete_remote_or_refspec ()
 739 {
 740         local cur_="$cur" cmd="${words[1]}"
 741         local i c=2 remote="" pfx="" lhs=1 no_complete_refspec=0
 742         while [ $c -lt $cword ]; do
 743                 i="${words[c]}"
 744                 case "$i" in
 745                 --mirror) [ "$cmd" = "push" ] && no_complete_refspec=1 ;;
 746                 --all)
 747                         case "$cmd" in
 748                         push) no_complete_refspec=1 ;;
 749                         fetch)
 750                                 COMPREPLY=()
 751                                 return
 752                                 ;;
 753                         *) ;;
 754                         esac
 755                         ;;
 756                 -*) ;;
 757                 *) remote="$i"; break ;;
 758                 esac
 759                 c=$((++c))
 760         done
 761         if [ -z "$remote" ]; then
 762                 __gitcomp_nl "$(__git_remotes)"
 763                 return
 764         fi
 765         if [ $no_complete_refspec = 1 ]; then
 766                 COMPREPLY=()
 767                 return
 768         fi
 769         [ "$remote" = "." ] && remote=
 770         case "$cur_" in
 771         *:*)
 772                 case "$COMP_WORDBREAKS" in
 773                 *:*) : great ;;
 774                 *)   pfx="${cur_%%:*}:" ;;
 775                 esac
 776                 cur_="${cur_#*:}"
 777                 lhs=0
 778                 ;;
 779         +*)
 780                 pfx="+"
 781                 cur_="${cur_#+}"
 782                 ;;
 783         esac
 784         case "$cmd" in
 785         fetch)
 786                 if [ $lhs = 1 ]; then
 787                         __gitcomp_nl "$(__git_refs2 "$remote")" "$pfx" "$cur_"
 788                 else
 789                         __gitcomp_nl "$(__git_refs)" "$pfx" "$cur_"
 790                 fi
 791                 ;;
 792         pull)
 793                 if [ $lhs = 1 ]; then
 794                         __gitcomp_nl "$(__git_refs "$remote")" "$pfx" "$cur_"
 795                 else
 796                         __gitcomp_nl "$(__git_refs)" "$pfx" "$cur_"
 797                 fi
 798                 ;;
 799         push)
 800                 if [ $lhs = 1 ]; then
 801                         __gitcomp_nl "$(__git_refs)" "$pfx" "$cur_"
 802                 else
 803                         __gitcomp_nl "$(__git_refs "$remote")" "$pfx" "$cur_"
 804                 fi
 805                 ;;
 806         esac
 807 }
 808
 809 __git_complete_strategy ()
 810 {
 811         __git_compute_merge_strategies
 812         case "$prev" in
 813         -s|--strategy)
 814                 __gitcomp "$__git_merge_strategies"
 815                 return 0
 816         esac
 817         case "$cur" in
 818         --strategy=*)
 819                 __gitcomp "$__git_merge_strategies" "" "${cur##--strategy=}"
 820                 return 0
 821                 ;;
 822         esac
 823         return 1
 824 }
 825
 826 __git_list_all_commands ()
 827 {
 828         local i IFS=" "$'\n'
 829         for i in $(git help -a|egrep '^  [a-zA-Z0-9]')
 830         do
 831                 case $i in
 832                 *--*)             : helper pattern;;
 833                 *) echo $i;;
 834                 esac
 835         done
 836 }
 837
 838 __git_all_commands=
 839 __git_compute_all_commands ()
 840 {
 841         test -n "$__git_all_commands" ||
 842         __git_all_commands=$(__git_list_all_commands)
 843 }
 844
 845 __git_list_porcelain_commands ()
 846 {
 847         local i IFS=" "$'\n'
 848         __git_compute_all_commands
 849         for i in "help" $__git_all_commands
 850         do
 851                 case $i in
 852                 *--*)             : helper pattern;;
 853                 applymbox)        : ask gittus;;
 854                 applypatch)       : ask gittus;;
 855                 archimport)       : import;;
 856                 cat-file)         : plumbing;;
 857                 check-attr)       : plumbing;;
 858                 check-ref-format) : plumbing;;
 859                 checkout-index)   : plumbing;;
 860                 commit-tree)      : plumbing;;
 861                 count-objects)    : infrequent;;
 862                 cvsexportcommit)  : export;;
 863                 cvsimport)        : import;;
 864                 cvsserver)        : daemon;;
 865                 daemon)           : daemon;;
 866                 diff-files)       : plumbing;;
 867                 diff-index)       : plumbing;;
 868                 diff-tree)        : plumbing;;
 869                 fast-import)      : import;;
 870                 fast-export)      : export;;
 871                 fsck-objects)     : plumbing;;
 872                 fetch-pack)       : plumbing;;
 873                 fmt-merge-msg)    : plumbing;;
 874                 for-each-ref)     : plumbing;;
 875                 hash-object)      : plumbing;;
 876                 http-*)           : transport;;
 877                 index-pack)       : plumbing;;
 878                 init-db)          : deprecated;;
 879                 local-fetch)      : plumbing;;
 880                 lost-found)       : infrequent;;
 881                 ls-files)         : plumbing;;
 882                 ls-remote)        : plumbing;;
 883                 ls-tree)          : plumbing;;
 884                 mailinfo)         : plumbing;;
 885                 mailsplit)        : plumbing;;
 886                 merge-*)          : plumbing;;
 887                 mktree)           : plumbing;;
 888                 mktag)            : plumbing;;
 889                 pack-objects)     : plumbing;;
 890                 pack-redundant)   : plumbing;;
 891                 pack-refs)        : plumbing;;
 892                 parse-remote)     : plumbing;;
 893                 patch-id)         : plumbing;;
 894                 peek-remote)      : plumbing;;
 895                 prune)            : plumbing;;
 896                 prune-packed)     : plumbing;;
 897                 quiltimport)      : import;;
 898                 read-tree)        : plumbing;;
 899                 receive-pack)     : plumbing;;
 900                 remote-*)         : transport;;
 901                 repo-config)      : deprecated;;
 902                 rerere)           : plumbing;;
 903                 rev-list)         : plumbing;;
 904                 rev-parse)        : plumbing;;
 905                 runstatus)        : plumbing;;
 906                 sh-setup)         : internal;;
 907                 shell)            : daemon;;
 908                 show-ref)         : plumbing;;
 909                 send-pack)        : plumbing;;
 910                 show-index)       : plumbing;;
 911                 ssh-*)            : transport;;
 912                 stripspace)       : plumbing;;
 913                 symbolic-ref)     : plumbing;;
 914                 tar-tree)         : deprecated;;
 915                 unpack-file)      : plumbing;;
 916                 unpack-objects)   : plumbing;;
 917                 update-index)     : plumbing;;
 918                 update-ref)       : plumbing;;
 919                 update-server-info) : daemon;;
 920                 upload-archive)   : plumbing;;
 921                 upload-pack)      : plumbing;;
 922                 write-tree)       : plumbing;;
 923                 var)              : infrequent;;
 924                 verify-pack)      : infrequent;;
 925                 verify-tag)       : plumbing;;
 926                 *) echo $i;;
 927                 esac
 928         done
 929 }
 930
 931 __git_porcelain_commands=
 932 __git_compute_porcelain_commands ()
 933 {
 934         __git_compute_all_commands
 935         test -n "$__git_porcelain_commands" ||
 936         __git_porcelain_commands=$(__git_list_porcelain_commands)
 937 }
 938
 939 __git_pretty_aliases ()
 940 {
 941         local i IFS=$'\n'
 942         for i in $(git --git-dir="$(__gitdir)" config --get-regexp "pretty\..*" 2>/dev/null); do
 943                 case "$i" in
 944                 pretty.*)
 945                         i="${i#pretty.}"
 946                         echo "${i/ */}"
 947                         ;;
 948                 esac
 949         done
 950 }
 951
 952 __git_aliases ()
 953 {
 954         local i IFS=$'\n'
 955         for i in $(git --git-dir="$(__gitdir)" config --get-regexp "alias\..*" 2>/dev/null); do
 956                 case "$i" in
 957                 alias.*)
 958                         i="${i#alias.}"
 959                         echo "${i/ */}"
 960                         ;;
 961                 esac
 962         done
 963 }
 964
 965 # __git_aliased_command requires 1 argument
 966 __git_aliased_command ()
 967 {
 968         local word cmdline=$(git --git-dir="$(__gitdir)" \
 969                 config --get "alias.$1")
 970         for word in $cmdline; do
 971                 case "$word" in
 972                 \!gitk|gitk)
 973                         echo "gitk"
 974                         return
 975                         ;;
 976                 \!*)    : shell command alias ;;
 977                 -*)     : option ;;
 978                 *=*)    : setting env ;;
 979                 git)    : git itself ;;
 980                 *)
 981                         echo "$word"
 982                         return
 983                 esac
 984         done
 985 }
 986
 987 # __git_find_on_cmdline requires 1 argument
 988 __git_find_on_cmdline ()
 989 {
 990         local word subcommand c=1
 991         while [ $c -lt $cword ]; do
 992                 word="${words[c]}"
 993                 for subcommand in $1; do
 994                         if [ "$subcommand" = "$word" ]; then
 995                                 echo "$subcommand"
 996                                 return
 997                         fi
 998                 done
 999                 c=$((++c))
1000         done
1001 }
1002
1003 __git_has_doubledash ()
1004 {
1005         local c=1
1006         while [ $c -lt $cword ]; do
1007                 if [ "--" = "${words[c]}" ]; then
1008                         return 0
1009                 fi
1010                 c=$((++c))
1011         done
1012         return 1
1013 }
1014
1015 __git_whitespacelist="nowarn warn error error-all fix"
1016
1017 _git_am ()
1018 {
1019         local dir="$(__gitdir)"
1020         if [ -d "$dir"/rebase-apply ]; then
1021                 __gitcomp "--skip --continue --resolved --abort"
1022                 return
1023         fi
1024         case "$cur" in
1025         --whitespace=*)
1026                 __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
1027                 return
1028                 ;;
1029         --*)
1030                 __gitcomp "
1031                         --3way --committer-date-is-author-date --ignore-date
1032                         --ignore-whitespace --ignore-space-change
1033                         --interactive --keep --no-utf8 --signoff --utf8
1034                         --whitespace= --scissors
1035                         "
1036                 return
1037         esac
1038         COMPREPLY=()
1039 }
1040
1041 _git_apply ()
1042 {
1043         case "$cur" in
1044         --whitespace=*)
1045                 __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
1046                 return
1047                 ;;
1048         --*)
1049                 __gitcomp "
1050                         --stat --numstat --summary --check --index
1051                         --cached --index-info --reverse --reject --unidiff-zero
1052                         --apply --no-add --exclude=
1053                         --ignore-whitespace --ignore-space-change
1054                         --whitespace= --inaccurate-eof --verbose
1055                         "
1056                 return
1057         esac
1058         COMPREPLY=()
1059 }
1060
1061 _git_add ()
1062 {
1063         __git_has_doubledash && return
1064
1065         case "$cur" in
1066         --*)
1067                 __gitcomp "
1068                         --interactive --refresh --patch --update --dry-run
1069                         --ignore-errors --intent-to-add
1070                         "
1071                 return
1072         esac
1073         COMPREPLY=()
1074 }
1075
1076 _git_archive ()
1077 {
1078         case "$cur" in
1079         --format=*)
1080                 __gitcomp "$(git archive --list)" "" "${cur##--format=}"
1081                 return
1082                 ;;
1083         --remote=*)
1084                 __gitcomp_nl "$(__git_remotes)" "" "${cur##--remote=}"
1085                 return
1086                 ;;
1087         --*)
1088                 __gitcomp "
1089                         --format= --list --verbose
1090                         --prefix= --remote= --exec=
1091                         "
1092                 return
1093                 ;;
1094         esac
1095         __git_complete_file
1096 }
1097
1098 _git_bisect ()
1099 {
1100         __git_has_doubledash && return
1101
1102         local subcommands="start bad good skip reset visualize replay log run"
1103         local subcommand="$(__git_find_on_cmdline "$subcommands")"
1104         if [ -z "$subcommand" ]; then
1105                 if [ -f "$(__gitdir)"/BISECT_START ]; then
1106                         __gitcomp "$subcommands"
1107                 else
1108                         __gitcomp "replay start"
1109                 fi
1110                 return
1111         fi
1112
1113         case "$subcommand" in
1114         bad|good|reset|skip|start)
1115                 __gitcomp_nl "$(__git_refs)"
1116                 ;;
1117         *)
1118                 COMPREPLY=()
1119                 ;;
1120         esac
1121 }
1122
1123 _git_branch ()
1124 {
1125         local i c=1 only_local_ref="n" has_r="n"
1126
1127         while [ $c -lt $cword ]; do
1128                 i="${words[c]}"
1129                 case "$i" in
1130                 -d|-m)  only_local_ref="y" ;;
1131                 -r)     has_r="y" ;;
1132                 esac
1133                 c=$((++c))
1134         done
1135
1136         case "$cur" in
1137         --*)
1138                 __gitcomp "
1139                         --color --no-color --verbose --abbrev= --no-abbrev
1140                         --track --no-track --contains --merged --no-merged
1141                         --set-upstream --edit-description
1142                         "
1143                 ;;
1144         *)
1145                 if [ $only_local_ref = "y" -a $has_r = "n" ]; then
1146                         __gitcomp_nl "$(__git_heads)"
1147                 else
1148                         __gitcomp_nl "$(__git_refs)"
1149                 fi
1150                 ;;
1151         esac
1152 }
1153
1154 _git_bundle ()
1155 {
1156         local cmd="${words[2]}"
1157         case "$cword" in
1158         2)
1159                 __gitcomp "create list-heads verify unbundle"
1160                 ;;
1161         3)
1162                 # looking for a file
1163                 ;;
1164         *)
1165                 case "$cmd" in
1166                         create)
1167                                 __git_complete_revlist
1168                         ;;
1169                 esac
1170                 ;;
1171         esac
1172 }
1173
1174 _git_checkout ()
1175 {
1176         __git_has_doubledash && return
1177
1178         case "$cur" in
1179         --conflict=*)
1180                 __gitcomp "diff3 merge" "" "${cur##--conflict=}"
1181                 ;;
1182         --*)
1183                 __gitcomp "
1184                         --quiet --ours --theirs --track --no-track --merge
1185                         --conflict= --orphan --patch
1186                         "
1187                 ;;
1188         *)
1189                 # check if --track, --no-track, or --no-guess was specified
1190                 # if so, disable DWIM mode
1191                 local flags="--track --no-track --no-guess" track=1
1192                 if [ -n "$(__git_find_on_cmdline "$flags")" ]; then
1193                         track=''
1194                 fi
1195                 __gitcomp_nl "$(__git_refs '' $track)"
1196                 ;;
1197         esac
1198 }
1199
1200 _git_cherry ()
1201 {
1202         __gitcomp "$(__git_refs)"
1203 }
1204
1205 _git_cherry_pick ()
1206 {
1207         case "$cur" in
1208         --*)
1209                 __gitcomp "--edit --no-commit"
1210                 ;;
1211         *)
1212                 __gitcomp_nl "$(__git_refs)"
1213                 ;;
1214         esac
1215 }
1216
1217 _git_clean ()
1218 {
1219         __git_has_doubledash && return
1220
1221         case "$cur" in
1222         --*)
1223                 __gitcomp "--dry-run --quiet"
1224                 return
1225                 ;;
1226         esac
1227         COMPREPLY=()
1228 }
1229
1230 _git_clone ()
1231 {
1232         case "$cur" in
1233         --*)
1234                 __gitcomp "
1235                         --local
1236                         --no-hardlinks
1237                         --shared
1238                         --reference
1239                         --quiet
1240                         --no-checkout
1241                         --bare
1242                         --mirror
1243                         --origin
1244                         --upload-pack
1245                         --template=
1246                         --depth
1247                         "
1248                 return
1249                 ;;
1250         esac
1251         COMPREPLY=()
1252 }
1253
1254 _git_commit ()
1255 {
1256         __git_has_doubledash && return
1257
1258         case "$cur" in
1259         --cleanup=*)
1260                 __gitcomp "default strip verbatim whitespace
1261                         " "" "${cur##--cleanup=}"
1262                 return
1263                 ;;
1264         --reuse-message=*|--reedit-message=*|\
1265         --fixup=*|--squash=*)
1266                 __gitcomp_nl "$(__git_refs)" "" "${cur#*=}"
1267                 return
1268                 ;;
1269         --untracked-files=*)
1270                 __gitcomp "all no normal" "" "${cur##--untracked-files=}"
1271                 return
1272                 ;;
1273         --*)
1274                 __gitcomp "
1275                         --all --author= --signoff --verify --no-verify
1276                         --edit --amend --include --only --interactive
1277                         --dry-run --reuse-message= --reedit-message=
1278                         --reset-author --file= --message= --template=
1279                         --cleanup= --untracked-files --untracked-files=
1280                         --verbose --quiet --fixup= --squash=
1281                         "
1282                 return
1283         esac
1284         COMPREPLY=()
1285 }
1286
1287 _git_describe ()
1288 {
1289         case "$cur" in
1290         --*)
1291                 __gitcomp "
1292                         --all --tags --contains --abbrev= --candidates=
1293                         --exact-match --debug --long --match --always
1294                         "
1295                 return
1296         esac
1297         __gitcomp_nl "$(__git_refs)"
1298 }
1299
1300 __git_diff_common_options="--stat --numstat --shortstat --summary
1301                         --patch-with-stat --name-only --name-status --color
1302                         --no-color --color-words --no-renames --check
1303                         --full-index --binary --abbrev --diff-filter=
1304                         --find-copies-harder
1305                         --text --ignore-space-at-eol --ignore-space-change
1306                         --ignore-all-space --exit-code --quiet --ext-diff
1307                         --no-ext-diff
1308                         --no-prefix --src-prefix= --dst-prefix=
1309                         --inter-hunk-context=
1310                         --patience
1311                         --raw
1312                         --dirstat --dirstat= --dirstat-by-file
1313                         --dirstat-by-file= --cumulative
1314 "
1315
1316 _git_diff ()
1317 {
1318         __git_has_doubledash && return
1319
1320         case "$cur" in
1321         --*)
1322                 __gitcomp "--cached --staged --pickaxe-all --pickaxe-regex
1323                         --base --ours --theirs --no-index
1324                         $__git_diff_common_options
1325                         "
1326                 return
1327                 ;;
1328         esac
1329         __git_complete_revlist_file
1330 }
1331
1332 __git_mergetools_common="diffuse ecmerge emerge kdiff3 meld opendiff
1333                         tkdiff vimdiff gvimdiff xxdiff araxis p4merge bc3
1334 "
1335
1336 _git_difftool ()
1337 {
1338         __git_has_doubledash && return
1339
1340         case "$cur" in
1341         --tool=*)
1342                 __gitcomp "$__git_mergetools_common kompare" "" "${cur##--tool=}"
1343                 return
1344                 ;;
1345         --*)
1346                 __gitcomp "--cached --staged --pickaxe-all --pickaxe-regex
1347                         --base --ours --theirs
1348                         --no-renames --diff-filter= --find-copies-harder
1349                         --relative --ignore-submodules
1350                         --tool="
1351                 return
1352                 ;;
1353         esac
1354         __git_complete_file
1355 }
1356
1357 __git_fetch_options="
1358         --quiet --verbose --append --upload-pack --force --keep --depth=
1359         --tags --no-tags --all --prune --dry-run
1360 "
1361
1362 _git_fetch ()
1363 {
1364         case "$cur" in
1365         --*)
1366                 __gitcomp "$__git_fetch_options"
1367                 return
1368                 ;;
1369         esac
1370         __git_complete_remote_or_refspec
1371 }
1372
1373 _git_format_patch ()
1374 {
1375         case "$cur" in
1376         --thread=*)
1377                 __gitcomp "
1378                         deep shallow
1379                         " "" "${cur##--thread=}"
1380                 return
1381                 ;;
1382         --*)
1383                 __gitcomp "
1384                         --stdout --attach --no-attach --thread --thread=
1385                         --output-directory
1386                         --numbered --start-number
1387                         --numbered-files
1388                         --keep-subject
1389                         --signoff --signature --no-signature
1390                         --in-reply-to= --cc=
1391                         --full-index --binary
1392                         --not --all
1393                         --cover-letter
1394                         --no-prefix --src-prefix= --dst-prefix=
1395                         --inline --suffix= --ignore-if-in-upstream
1396                         --subject-prefix=
1397                         "
1398                 return
1399                 ;;
1400         esac
1401         __git_complete_revlist
1402 }
1403
1404 _git_fsck ()
1405 {
1406         case "$cur" in
1407         --*)
1408                 __gitcomp "
1409                         --tags --root --unreachable --cache --no-reflogs --full
1410                         --strict --verbose --lost-found
1411                         "
1412                 return
1413                 ;;
1414         esac
1415         COMPREPLY=()
1416 }
1417
1418 _git_gc ()
1419 {
1420         case "$cur" in
1421         --*)
1422                 __gitcomp "--prune --aggressive"
1423                 return
1424                 ;;
1425         esac
1426         COMPREPLY=()
1427 }
1428
1429 _git_gitk ()
1430 {
1431         _gitk
1432 }
1433
1434 __git_match_ctag() {
1435         awk "/^${1////\\/}/ { print \$1 }" "$2"
1436 }
1437
1438 _git_grep ()
1439 {
1440         __git_has_doubledash && return
1441
1442         case "$cur" in
1443         --*)
1444                 __gitcomp "
1445                         --cached
1446                         --text --ignore-case --word-regexp --invert-match
1447                         --full-name --line-number
1448                         --extended-regexp --basic-regexp --fixed-strings
1449                         --perl-regexp
1450                         --files-with-matches --name-only
1451                         --files-without-match
1452                         --max-depth
1453                         --count
1454                         --and --or --not --all-match
1455                         "
1456                 return
1457                 ;;
1458         esac
1459
1460         case "$cword,$prev" in
1461         2,*|*,-*)
1462                 if test -r tags; then
1463                         __gitcomp_nl "$(__git_match_ctag "$cur" tags)"
1464                         return
1465                 fi
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 --edit --no-edit
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 -r 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
2621                 # workaround zsh's bug that quotes spaces in the COMPREPLY
2622                 # array if IFS doesn't contain spaces.
2623                 typeset -h IFS
2624         fi
2625
2626         local cur words cword prev
2627         _get_comp_words_by_ref -n =: cur words cword prev
2628         while [ $c -lt $cword ]; do
2629                 i="${words[c]}"
2630                 case "$i" in
2631                 --git-dir=*) __git_dir="${i#--git-dir=}" ;;
2632                 --bare)      __git_dir="." ;;
2633                 --version|-p|--paginate) ;;
2634                 --help) command="help"; break ;;
2635                 *) command="$i"; break ;;
2636                 esac
2637                 c=$((++c))
2638         done
2639
2640         if [ -z "$command" ]; then
2641                 case "$cur" in
2642                 --*)   __gitcomp "
2643                         --paginate
2644                         --no-pager
2645                         --git-dir=
2646                         --bare
2647                         --version
2648                         --exec-path
2649                         --html-path
2650                         --work-tree=
2651                         --namespace=
2652                         --help
2653                         "
2654                         ;;
2655                 *)     __git_compute_porcelain_commands
2656                        __gitcomp "$__git_porcelain_commands $(__git_aliases)" ;;
2657                 esac
2658                 return
2659         fi
2660
2661         local completion_func="_git_${command//-/_}"
2662         declare -f $completion_func >/dev/null && $completion_func && return
2663
2664         local expansion=$(__git_aliased_command "$command")
2665         if [ -n "$expansion" ]; then
2666                 completion_func="_git_${expansion//-/_}"
2667                 declare -f $completion_func >/dev/null && $completion_func
2668         fi
2669 }
2670
2671 _gitk ()
2672 {
2673         if [[ -n ${ZSH_VERSION-} ]]; then
2674                 emulate -L bash
2675                 setopt KSH_TYPESET
2676
2677                 # workaround zsh's bug that leaves 'words' as a special
2678                 # variable in versions < 4.3.12
2679                 typeset -h words
2680
2681                 # workaround zsh's bug that quotes spaces in the COMPREPLY
2682                 # array if IFS doesn't contain spaces.
2683                 typeset -h IFS
2684         fi
2685
2686         local cur words cword prev
2687         _get_comp_words_by_ref -n =: cur words cword prev
2688
2689         __git_has_doubledash && return
2690
2691         local g="$(__gitdir)"
2692         local merge=""
2693         if [ -f "$g/MERGE_HEAD" ]; then
2694                 merge="--merge"
2695         fi
2696         case "$cur" in
2697         --*)
2698                 __gitcomp "
2699                         $__git_log_common_options
2700                         $__git_log_gitk_options
2701                         $merge
2702                         "
2703                 return
2704                 ;;
2705         esac
2706         __git_complete_revlist
2707 }
2708
2709 complete -o bashdefault -o default -o nospace -F _git git 2>/dev/null \
2710         || complete -o default -o nospace -F _git git
2711 complete -o bashdefault -o default -o nospace -F _gitk gitk 2>/dev/null \
2712         || complete -o default -o nospace -F _gitk gitk
2713
2714 # The following are necessary only for Cygwin, and only are needed
2715 # when the user has tab-completed the executable name and consequently
2716 # included the '.exe' suffix.
2717 #
2718 if [ Cygwin = "$(uname -o 2>/dev/null)" ]; then
2719 complete -o bashdefault -o default -o nospace -F _git git.exe 2>/dev/null \
2720         || complete -o default -o nospace -F _git git.exe
2721 fi