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