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

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