contrib/completion/git-completion.bash

   1 #!bash
   2 #
   3 # bash completion support for core Git.
   4 #
   5 # Copyright (C) 2006,2007 Shawn O. Pearce <spearce@spearce.org>
   6 # Conceptually based on gitcompletion (http://gitweb.hawaga.org.uk/).
   7 # Distributed under the GNU General Public License, version 2.0.
   8 #
   9 # The contained completion routines provide support for completing:
  10 #
  11 #    *) local and remote branch names
  12 #    *) local and remote tag names
  13 #    *) .git/remotes file names
  14 #    *) git 'subcommands'
  15 #    *) tree paths within 'ref:path/to/file' expressions
  16 #    *) common --long-options
  17 #
  18 # To use these routines:
  19 #
  20 #    1) Copy this file to somewhere (e.g. ~/.git-completion.sh).
  21 #    2) Added the following line to your .bashrc:
  22 #        source ~/.git-completion.sh
  23 #
  24 #    3) You may want to make sure the git executable is available
  25 #       in your PATH before this script is sourced, as some caching
  26 #       is performed while the script loads.  If git isn't found
  27 #       at source time then all lookups will be done on demand,
  28 #       which may be slightly slower.
  29 #
  30 #    4) Consider changing your PS1 to also show the current branch:
  31 #        PS1='[\u@\h \W$(__git_ps1 " (%s)")]\$ '
  32 #
  33 #       The argument to __git_ps1 will be displayed only if you
  34 #       are currently in a git repository.  The %s token will be
  35 #       the name of the current branch.
  36 #
  37 #       In addition, if you set GIT_PS1_SHOWDIRTYSTATE to a nonempty
  38 #       value, unstaged (*) and staged (+) changes will be shown next
  39 #       to the branch name.  You can configure this per-repository
  40 #       with the bash.showDirtyState variable, which defaults to true
  41 #       once GIT_PS1_SHOWDIRTYSTATE is enabled.
  42 #
  43 #       You can also see if currently something is stashed, by setting
  44 #       GIT_PS1_SHOWSTASHSTATE to a nonempty value. If something is stashed,
  45 #       then a '$' will be shown next to the branch name.
  46 #
  47 # To submit patches:
  48 #
  49 #    *) Read Documentation/SubmittingPatches
  50 #    *) Send all patches to the current maintainer:
  51 #
  52 #       "Shawn O. Pearce" <spearce@spearce.org>
  53 #
  54 #    *) Always CC the Git mailing list:
  55 #
  56 #       git@vger.kernel.org
  57 #
  58
  59 case "$COMP_WORDBREAKS" in
  60 *:*) : great ;;
  61 *)   COMP_WORDBREAKS="$COMP_WORDBREAKS:"
  62 esac
  63
  64 # __gitdir accepts 0 or 1 arguments (i.e., location)
  65 # returns location of .git repo
  66 __gitdir ()
  67 {
  68         if [ -z "${1-}" ]; then
  69                 if [ -n "${__git_dir-}" ]; then
  70                         echo "$__git_dir"
  71                 elif [ -d .git ]; then
  72                         echo .git
  73                 else
  74                         git rev-parse --git-dir 2>/dev/null
  75                 fi
  76         elif [ -d "$1/.git" ]; then
  77                 echo "$1/.git"
  78         else
  79                 echo "$1"
  80         fi
  81 }
  82
  83 # __git_ps1 accepts 0 or 1 arguments (i.e., format string)
  84 # returns text to add to bash PS1 prompt (includes branch name)
  85 __git_ps1 ()
  86 {
  87         local g="$(__gitdir)"
  88         if [ -n "$g" ]; then
  89                 local r
  90                 local b
  91                 if [ -f "$g/rebase-merge/interactive" ]; then
  92                         r="|REBASE-i"
  93                         b="$(cat "$g/rebase-merge/head-name")"
  94                 elif [ -d "$g/rebase-merge" ]; then
  95                         r="|REBASE-m"
  96                         b="$(cat "$g/rebase-merge/head-name")"
  97                 else
  98                         if [ -d "$g/rebase-apply" ]; then
  99                                 if [ -f "$g/rebase-apply/rebasing" ]; then
 100                                         r="|REBASE"
 101                                 elif [ -f "$g/rebase-apply/applying" ]; then
 102                                         r="|AM"
 103                                 else
 104                                         r="|AM/REBASE"
 105                                 fi
 106                         elif [ -f "$g/MERGE_HEAD" ]; then
 107                                 r="|MERGING"
 108                         elif [ -f "$g/BISECT_LOG" ]; then
 109                                 r="|BISECTING"
 110                         fi
 111
 112                         b="$(git symbolic-ref HEAD 2>/dev/null)" || {
 113
 114                                 b="$(
 115                                 case "${GIT_PS1_DESCRIBE_STYLE-}" in
 116                                 (contains)
 117                                         git describe --contains HEAD ;;
 118                                 (branch)
 119                                         git describe --contains --all HEAD ;;
 120                                 (describe)
 121                                         git describe HEAD ;;
 122                                 (* | default)
 123                                         git describe --exact-match HEAD ;;
 124                                 esac 2>/dev/null)" ||
 125
 126                                 b="$(cut -c1-7 "$g/HEAD" 2>/dev/null)..." ||
 127                                 b="unknown"
 128                                 b="($b)"
 129                         }
 130                 fi
 131
 132                 local w
 133                 local i
 134                 local s
 135                 local c
 136
 137                 if [ "true" = "$(git rev-parse --is-inside-git-dir 2>/dev/null)" ]; then
 138                         if [ "true" = "$(git rev-parse --is-bare-repository 2>/dev/null)" ]; then
 139                                 c="BARE:"
 140                         else
 141                                 b="GIT_DIR!"
 142                         fi
 143                 elif [ "true" = "$(git rev-parse --is-inside-work-tree 2>/dev/null)" ]; then
 144                         if [ -n "${GIT_PS1_SHOWDIRTYSTATE-}" ]; then
 145                                 if [ "$(git config --bool bash.showDirtyState)" != "false" ]; then
 146                                         git diff --no-ext-diff --ignore-submodules \
 147                                                 --quiet --exit-code || w="*"
 148                                         if git rev-parse --quiet --verify HEAD >/dev/null; then
 149                                                 git diff-index --cached --quiet \
 150                                                         --ignore-submodules HEAD -- || i="+"
 151                                         else
 152                                                 i="#"
 153                                         fi
 154                                 fi
 155                         fi
 156                         if [ -n "${GIT_PS1_SHOWSTASHSTATE-}" ]; then
 157                                 git rev-parse --verify refs/stash >/dev/null 2>&1 && s="$"
 158                         fi
 159                 fi
 160
 161                 if [ -n "${1-}" ]; then
 162                         printf "$1" "$c${b##refs/heads/}$w$i$s$r"
 163                 else
 164                         printf " (%s)" "$c${b##refs/heads/}$w$i$s$r"
 165                 fi
 166         fi
 167 }
 168
 169 # __gitcomp_1 requires 2 arguments
 170 __gitcomp_1 ()
 171 {
 172         local c IFS=' '$'\t'$'\n'
 173         for c in $1; do
 174                 case "$c$2" in
 175                 --*=*) printf %s$'\n' "$c$2" ;;
 176                 *.)    printf %s$'\n' "$c$2" ;;
 177                 *)     printf %s$'\n' "$c$2 " ;;
 178                 esac
 179         done
 180 }
 181
 182 # __gitcomp accepts 1, 2, 3, or 4 arguments
 183 # generates completion reply with compgen
 184 __gitcomp ()
 185 {
 186         local cur="${COMP_WORDS[COMP_CWORD]}"
 187         if [ $# -gt 2 ]; then
 188                 cur="$3"
 189         fi
 190         case "$cur" in
 191         --*=)
 192                 COMPREPLY=()
 193                 ;;
 194         *)
 195                 local IFS=$'\n'
 196                 COMPREPLY=($(compgen -P "${2-}" \
 197                         -W "$(__gitcomp_1 "${1-}" "${4-}")" \
 198                         -- "$cur"))
 199                 ;;
 200         esac
 201 }
 202
 203 # __git_heads accepts 0 or 1 arguments (to pass to __gitdir)
 204 __git_heads ()
 205 {
 206         local cmd i is_hash=y dir="$(__gitdir "${1-}")"
 207         if [ -d "$dir" ]; then
 208                 git --git-dir="$dir" for-each-ref --format='%(refname:short)' \
 209                         refs/heads
 210                 return
 211         fi
 212         for i in $(git ls-remote "${1-}" 2>/dev/null); do
 213                 case "$is_hash,$i" in
 214                 y,*) is_hash=n ;;
 215                 n,*^{}) is_hash=y ;;
 216                 n,refs/heads/*) is_hash=y; echo "${i#refs/heads/}" ;;
 217                 n,*) is_hash=y; echo "$i" ;;
 218                 esac
 219         done
 220 }
 221
 222 # __git_tags accepts 0 or 1 arguments (to pass to __gitdir)
 223 __git_tags ()
 224 {
 225         local cmd i is_hash=y dir="$(__gitdir "${1-}")"
 226         if [ -d "$dir" ]; then
 227                 git --git-dir="$dir" for-each-ref --format='%(refname:short)' \
 228                         refs/tags
 229                 return
 230         fi
 231         for i in $(git ls-remote "${1-}" 2>/dev/null); do
 232                 case "$is_hash,$i" in
 233                 y,*) is_hash=n ;;
 234                 n,*^{}) is_hash=y ;;
 235                 n,refs/tags/*) is_hash=y; echo "${i#refs/tags/}" ;;
 236                 n,*) is_hash=y; echo "$i" ;;
 237                 esac
 238         done
 239 }
 240
 241 # __git_refs accepts 0 or 1 arguments (to pass to __gitdir)
 242 __git_refs ()
 243 {
 244         local i is_hash=y dir="$(__gitdir "${1-}")"
 245         local cur="${COMP_WORDS[COMP_CWORD]}" format refs
 246         if [ -d "$dir" ]; then
 247                 case "$cur" in
 248                 refs|refs/*)
 249                         format="refname"
 250                         refs="${cur%/*}"
 251                         ;;
 252                 *)
 253                         if [ -e "$dir/HEAD" ]; then echo HEAD; fi
 254                         format="refname:short"
 255                         refs="refs/tags refs/heads refs/remotes"
 256                         ;;
 257                 esac
 258                 git --git-dir="$dir" for-each-ref --format="%($format)" \
 259                         $refs
 260                 return
 261         fi
 262         for i in $(git ls-remote "$dir" 2>/dev/null); do
 263                 case "$is_hash,$i" in
 264                 y,*) is_hash=n ;;
 265                 n,*^{}) is_hash=y ;;
 266                 n,refs/tags/*) is_hash=y; echo "${i#refs/tags/}" ;;
 267                 n,refs/heads/*) is_hash=y; echo "${i#refs/heads/}" ;;
 268                 n,refs/remotes/*) is_hash=y; echo "${i#refs/remotes/}" ;;
 269                 n,*) is_hash=y; echo "$i" ;;
 270                 esac
 271         done
 272 }
 273
 274 # __git_refs2 requires 1 argument (to pass to __git_refs)
 275 __git_refs2 ()
 276 {
 277         local i
 278         for i in $(__git_refs "$1"); do
 279                 echo "$i:$i"
 280         done
 281 }
 282
 283 # __git_refs_remotes requires 1 argument (to pass to ls-remote)
 284 __git_refs_remotes ()
 285 {
 286         local cmd i is_hash=y
 287         for i in $(git ls-remote "$1" 2>/dev/null); do
 288                 case "$is_hash,$i" in
 289                 n,refs/heads/*)
 290                         is_hash=y
 291                         echo "$i:refs/remotes/$1/${i#refs/heads/}"
 292                         ;;
 293                 y,*) is_hash=n ;;
 294                 n,*^{}) is_hash=y ;;
 295                 n,refs/tags/*) is_hash=y;;
 296                 n,*) is_hash=y; ;;
 297                 esac
 298         done
 299 }
 300
 301 __git_remotes ()
 302 {
 303         local i ngoff IFS=$'\n' d="$(__gitdir)"
 304         shopt -q nullglob || ngoff=1
 305         shopt -s nullglob
 306         for i in "$d/remotes"/*; do
 307                 echo ${i#$d/remotes/}
 308         done
 309         [ "$ngoff" ] && shopt -u nullglob
 310         for i in $(git --git-dir="$d" config --list); do
 311                 case "$i" in
 312                 remote.*.url=*)
 313                         i="${i#remote.}"
 314                         echo "${i/.url=*/}"
 315                         ;;
 316                 esac
 317         done
 318 }
 319
 320 __git_merge_strategies ()
 321 {
 322         if [ -n "${__git_merge_strategylist-}" ]; then
 323                 echo "$__git_merge_strategylist"
 324                 return
 325         fi
 326         git merge -s help 2>&1 |
 327         sed -n -e '/[Aa]vailable strategies are: /,/^$/{
 328                 s/\.$//
 329                 s/.*://
 330                 s/^[    ]*//
 331                 s/[     ]*$//
 332                 p
 333         }'
 334 }
 335 __git_merge_strategylist=
 336 __git_merge_strategylist=$(__git_merge_strategies 2>/dev/null)
 337
 338 __git_complete_file ()
 339 {
 340         local pfx ls ref cur="${COMP_WORDS[COMP_CWORD]}"
 341         case "$cur" in
 342         ?*:*)
 343                 ref="${cur%%:*}"
 344                 cur="${cur#*:}"
 345                 case "$cur" in
 346                 ?*/*)
 347                         pfx="${cur%/*}"
 348                         cur="${cur##*/}"
 349                         ls="$ref:$pfx"
 350                         pfx="$pfx/"
 351                         ;;
 352                 *)
 353                         ls="$ref"
 354                         ;;
 355             esac
 356
 357                 case "$COMP_WORDBREAKS" in
 358                 *:*) : great ;;
 359                 *)   pfx="$ref:$pfx" ;;
 360                 esac
 361
 362                 local IFS=$'\n'
 363                 COMPREPLY=($(compgen -P "$pfx" \
 364                         -W "$(git --git-dir="$(__gitdir)" ls-tree "$ls" \
 365                                 | sed '/^100... blob /{
 366                                            s,^.*        ,,
 367                                            s,$, ,
 368                                        }
 369                                        /^120000 blob /{
 370                                            s,^.*        ,,
 371                                            s,$, ,
 372                                        }
 373                                        /^040000 tree /{
 374                                            s,^.*        ,,
 375                                            s,$,/,
 376                                        }
 377                                        s/^.*    //')" \
 378                         -- "$cur"))
 379                 ;;
 380         *)
 381                 __gitcomp "$(__git_refs)"
 382                 ;;
 383         esac
 384 }
 385
 386 __git_complete_revlist ()
 387 {
 388         local pfx cur="${COMP_WORDS[COMP_CWORD]}"
 389         case "$cur" in
 390         *...*)
 391                 pfx="${cur%...*}..."
 392                 cur="${cur#*...}"
 393                 __gitcomp "$(__git_refs)" "$pfx" "$cur"
 394                 ;;
 395         *..*)
 396                 pfx="${cur%..*}.."
 397                 cur="${cur#*..}"
 398                 __gitcomp "$(__git_refs)" "$pfx" "$cur"
 399                 ;;
 400         *)
 401                 __gitcomp "$(__git_refs)"
 402                 ;;
 403         esac
 404 }
 405
 406 __git_complete_remote_or_refspec ()
 407 {
 408         local cmd="${COMP_WORDS[1]}"
 409         local cur="${COMP_WORDS[COMP_CWORD]}"
 410         local i c=2 remote="" pfx="" lhs=1 no_complete_refspec=0
 411         while [ $c -lt $COMP_CWORD ]; do
 412                 i="${COMP_WORDS[c]}"
 413                 case "$i" in
 414                 --all|--mirror) [ "$cmd" = "push" ] && no_complete_refspec=1 ;;
 415                 -*) ;;
 416                 *) remote="$i"; break ;;
 417                 esac
 418                 c=$((++c))
 419         done
 420         if [ -z "$remote" ]; then
 421                 __gitcomp "$(__git_remotes)"
 422                 return
 423         fi
 424         if [ $no_complete_refspec = 1 ]; then
 425                 COMPREPLY=()
 426                 return
 427         fi
 428         [ "$remote" = "." ] && remote=
 429         case "$cur" in
 430         *:*)
 431                 case "$COMP_WORDBREAKS" in
 432                 *:*) : great ;;
 433                 *)   pfx="${cur%%:*}:" ;;
 434                 esac
 435                 cur="${cur#*:}"
 436                 lhs=0
 437                 ;;
 438         +*)
 439                 pfx="+"
 440                 cur="${cur#+}"
 441                 ;;
 442         esac
 443         case "$cmd" in
 444         fetch)
 445                 if [ $lhs = 1 ]; then
 446                         __gitcomp "$(__git_refs2 "$remote")" "$pfx" "$cur"
 447                 else
 448                         __gitcomp "$(__git_refs)" "$pfx" "$cur"
 449                 fi
 450                 ;;
 451         pull)
 452                 if [ $lhs = 1 ]; then
 453                         __gitcomp "$(__git_refs "$remote")" "$pfx" "$cur"
 454                 else
 455                         __gitcomp "$(__git_refs)" "$pfx" "$cur"
 456                 fi
 457                 ;;
 458         push)
 459                 if [ $lhs = 1 ]; then
 460                         __gitcomp "$(__git_refs)" "$pfx" "$cur"
 461                 else
 462                         __gitcomp "$(__git_refs "$remote")" "$pfx" "$cur"
 463                 fi
 464                 ;;
 465         esac
 466 }
 467
 468 __git_complete_strategy ()
 469 {
 470         case "${COMP_WORDS[COMP_CWORD-1]}" in
 471         -s|--strategy)
 472                 __gitcomp "$(__git_merge_strategies)"
 473                 return 0
 474         esac
 475         local cur="${COMP_WORDS[COMP_CWORD]}"
 476         case "$cur" in
 477         --strategy=*)
 478                 __gitcomp "$(__git_merge_strategies)" "" "${cur##--strategy=}"
 479                 return 0
 480                 ;;
 481         esac
 482         return 1
 483 }
 484
 485 __git_all_commands ()
 486 {
 487         if [ -n "${__git_all_commandlist-}" ]; then
 488                 echo "$__git_all_commandlist"
 489                 return
 490         fi
 491         local i IFS=" "$'\n'
 492         for i in $(git help -a|egrep '^ ')
 493         do
 494                 case $i in
 495                 *--*)             : helper pattern;;
 496                 *) echo $i;;
 497                 esac
 498         done
 499 }
 500 __git_all_commandlist=
 501 __git_all_commandlist="$(__git_all_commands 2>/dev/null)"
 502
 503 __git_porcelain_commands ()
 504 {
 505         if [ -n "${__git_porcelain_commandlist-}" ]; then
 506                 echo "$__git_porcelain_commandlist"
 507                 return
 508         fi
 509         local i IFS=" "$'\n'
 510         for i in "help" $(__git_all_commands)
 511         do
 512                 case $i in
 513                 *--*)             : helper pattern;;
 514                 applymbox)        : ask gittus;;
 515                 applypatch)       : ask gittus;;
 516                 archimport)       : import;;
 517                 cat-file)         : plumbing;;
 518                 check-attr)       : plumbing;;
 519                 check-ref-format) : plumbing;;
 520                 checkout-index)   : plumbing;;
 521                 commit-tree)      : plumbing;;
 522                 count-objects)    : infrequent;;
 523                 cvsexportcommit)  : export;;
 524                 cvsimport)        : import;;
 525                 cvsserver)        : daemon;;
 526                 daemon)           : daemon;;
 527                 diff-files)       : plumbing;;
 528                 diff-index)       : plumbing;;
 529                 diff-tree)        : plumbing;;
 530                 fast-import)      : import;;
 531                 fast-export)      : export;;
 532                 fsck-objects)     : plumbing;;
 533                 fetch-pack)       : plumbing;;
 534                 fmt-merge-msg)    : plumbing;;
 535                 for-each-ref)     : plumbing;;
 536                 hash-object)      : plumbing;;
 537                 http-*)           : transport;;
 538                 index-pack)       : plumbing;;
 539                 init-db)          : deprecated;;
 540                 local-fetch)      : plumbing;;
 541                 lost-found)       : infrequent;;
 542                 ls-files)         : plumbing;;
 543                 ls-remote)        : plumbing;;
 544                 ls-tree)          : plumbing;;
 545                 mailinfo)         : plumbing;;
 546                 mailsplit)        : plumbing;;
 547                 merge-*)          : plumbing;;
 548                 mktree)           : plumbing;;
 549                 mktag)            : plumbing;;
 550                 pack-objects)     : plumbing;;
 551                 pack-redundant)   : plumbing;;
 552                 pack-refs)        : plumbing;;
 553                 parse-remote)     : plumbing;;
 554                 patch-id)         : plumbing;;
 555                 peek-remote)      : plumbing;;
 556                 prune)            : plumbing;;
 557                 prune-packed)     : plumbing;;
 558                 quiltimport)      : import;;
 559                 read-tree)        : plumbing;;
 560                 receive-pack)     : plumbing;;
 561                 reflog)           : plumbing;;
 562                 repo-config)      : deprecated;;
 563                 rerere)           : plumbing;;
 564                 rev-list)         : plumbing;;
 565                 rev-parse)        : plumbing;;
 566                 runstatus)        : plumbing;;
 567                 sh-setup)         : internal;;
 568                 shell)            : daemon;;
 569                 show-ref)         : plumbing;;
 570                 send-pack)        : plumbing;;
 571                 show-index)       : plumbing;;
 572                 ssh-*)            : transport;;
 573                 stripspace)       : plumbing;;
 574                 symbolic-ref)     : plumbing;;
 575                 tar-tree)         : deprecated;;
 576                 unpack-file)      : plumbing;;
 577                 unpack-objects)   : plumbing;;
 578                 update-index)     : plumbing;;
 579                 update-ref)       : plumbing;;
 580                 update-server-info) : daemon;;
 581                 upload-archive)   : plumbing;;
 582                 upload-pack)      : plumbing;;
 583                 write-tree)       : plumbing;;
 584                 var)              : infrequent;;
 585                 verify-pack)      : infrequent;;
 586                 verify-tag)       : plumbing;;
 587                 *) echo $i;;
 588                 esac
 589         done
 590 }
 591 __git_porcelain_commandlist=
 592 __git_porcelain_commandlist="$(__git_porcelain_commands 2>/dev/null)"
 593
 594 __git_aliases ()
 595 {
 596         local i IFS=$'\n'
 597         for i in $(git --git-dir="$(__gitdir)" config --list); do
 598                 case "$i" in
 599                 alias.*)
 600                         i="${i#alias.}"
 601                         echo "${i/=*/}"
 602                         ;;
 603                 esac
 604         done
 605 }
 606
 607 # __git_aliased_command requires 1 argument
 608 __git_aliased_command ()
 609 {
 610         local word cmdline=$(git --git-dir="$(__gitdir)" \
 611                 config --get "alias.$1")
 612         for word in $cmdline; do
 613                 if [ "${word##-*}" ]; then
 614                         echo $word
 615                         return
 616                 fi
 617         done
 618 }
 619
 620 # __git_find_subcommand requires 1 argument
 621 __git_find_subcommand ()
 622 {
 623         local word subcommand c=1
 624
 625         while [ $c -lt $COMP_CWORD ]; do
 626                 word="${COMP_WORDS[c]}"
 627                 for subcommand in $1; do
 628                         if [ "$subcommand" = "$word" ]; then
 629                                 echo "$subcommand"
 630                                 return
 631                         fi
 632                 done
 633                 c=$((++c))
 634         done
 635 }
 636
 637 __git_has_doubledash ()
 638 {
 639         local c=1
 640         while [ $c -lt $COMP_CWORD ]; do
 641                 if [ "--" = "${COMP_WORDS[c]}" ]; then
 642                         return 0
 643                 fi
 644                 c=$((++c))
 645         done
 646         return 1
 647 }
 648
 649 __git_whitespacelist="nowarn warn error error-all fix"
 650
 651 _git_am ()
 652 {
 653         local cur="${COMP_WORDS[COMP_CWORD]}" dir="$(__gitdir)"
 654         if [ -d "$dir"/rebase-apply ]; then
 655                 __gitcomp "--skip --resolved --abort"
 656                 return
 657         fi
 658         case "$cur" in
 659         --whitespace=*)
 660                 __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
 661                 return
 662                 ;;
 663         --*)
 664                 __gitcomp "
 665                         --3way --committer-date-is-author-date --ignore-date
 666                         --interactive --keep --no-utf8 --signoff --utf8
 667                         --whitespace=
 668                         "
 669                 return
 670         esac
 671         COMPREPLY=()
 672 }
 673
 674 _git_apply ()
 675 {
 676         local cur="${COMP_WORDS[COMP_CWORD]}"
 677         case "$cur" in
 678         --whitespace=*)
 679                 __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
 680                 return
 681                 ;;
 682         --*)
 683                 __gitcomp "
 684                         --stat --numstat --summary --check --index
 685                         --cached --index-info --reverse --reject --unidiff-zero
 686                         --apply --no-add --exclude=
 687                         --whitespace= --inaccurate-eof --verbose
 688                         "
 689                 return
 690         esac
 691         COMPREPLY=()
 692 }
 693
 694 _git_add ()
 695 {
 696         __git_has_doubledash && return
 697
 698         local cur="${COMP_WORDS[COMP_CWORD]}"
 699         case "$cur" in
 700         --*)
 701                 __gitcomp "
 702                         --interactive --refresh --patch --update --dry-run
 703                         --ignore-errors --intent-to-add
 704                         "
 705                 return
 706         esac
 707         COMPREPLY=()
 708 }
 709
 710 _git_archive ()
 711 {
 712         local cur="${COMP_WORDS[COMP_CWORD]}"
 713         case "$cur" in
 714         --format=*)
 715                 __gitcomp "$(git archive --list)" "" "${cur##--format=}"
 716                 return
 717                 ;;
 718         --remote=*)
 719                 __gitcomp "$(__git_remotes)" "" "${cur##--remote=}"
 720                 return
 721                 ;;
 722         --*)
 723                 __gitcomp "
 724                         --format= --list --verbose
 725                         --prefix= --remote= --exec=
 726                         "
 727                 return
 728                 ;;
 729         esac
 730         __git_complete_file
 731 }
 732
 733 _git_bisect ()
 734 {
 735         __git_has_doubledash && return
 736
 737         local subcommands="start bad good skip reset visualize replay log run"
 738         local subcommand="$(__git_find_subcommand "$subcommands")"
 739         if [ -z "$subcommand" ]; then
 740                 __gitcomp "$subcommands"
 741                 return
 742         fi
 743
 744         case "$subcommand" in
 745         bad|good|reset|skip)
 746                 __gitcomp "$(__git_refs)"
 747                 ;;
 748         *)
 749                 COMPREPLY=()
 750                 ;;
 751         esac
 752 }
 753
 754 _git_branch ()
 755 {
 756         local i c=1 only_local_ref="n" has_r="n"
 757
 758         while [ $c -lt $COMP_CWORD ]; do
 759                 i="${COMP_WORDS[c]}"
 760                 case "$i" in
 761                 -d|-m)  only_local_ref="y" ;;
 762                 -r)     has_r="y" ;;
 763                 esac
 764                 c=$((++c))
 765         done
 766
 767         case "${COMP_WORDS[COMP_CWORD]}" in
 768         --*)
 769                 __gitcomp "
 770                         --color --no-color --verbose --abbrev= --no-abbrev
 771                         --track --no-track --contains --merged --no-merged
 772                         "
 773                 ;;
 774         *)
 775                 if [ $only_local_ref = "y" -a $has_r = "n" ]; then
 776                         __gitcomp "$(__git_heads)"
 777                 else
 778                         __gitcomp "$(__git_refs)"
 779                 fi
 780                 ;;
 781         esac
 782 }
 783
 784 _git_bundle ()
 785 {
 786         local cmd="${COMP_WORDS[2]}"
 787         case "$COMP_CWORD" in
 788         2)
 789                 __gitcomp "create list-heads verify unbundle"
 790                 ;;
 791         3)
 792                 # looking for a file
 793                 ;;
 794         *)
 795                 case "$cmd" in
 796                         create)
 797                                 __git_complete_revlist
 798                         ;;
 799                 esac
 800                 ;;
 801         esac
 802 }
 803
 804 _git_checkout ()
 805 {
 806         __git_has_doubledash && return
 807
 808         __gitcomp "$(__git_refs)"
 809 }
 810
 811 _git_cherry ()
 812 {
 813         __gitcomp "$(__git_refs)"
 814 }
 815
 816 _git_cherry_pick ()
 817 {
 818         local cur="${COMP_WORDS[COMP_CWORD]}"
 819         case "$cur" in
 820         --*)
 821                 __gitcomp "--edit --no-commit"
 822                 ;;
 823         *)
 824                 __gitcomp "$(__git_refs)"
 825                 ;;
 826         esac
 827 }
 828
 829 _git_clean ()
 830 {
 831         __git_has_doubledash && return
 832
 833         local cur="${COMP_WORDS[COMP_CWORD]}"
 834         case "$cur" in
 835         --*)
 836                 __gitcomp "--dry-run --quiet"
 837                 return
 838                 ;;
 839         esac
 840         COMPREPLY=()
 841 }
 842
 843 _git_clone ()
 844 {
 845         local cur="${COMP_WORDS[COMP_CWORD]}"
 846         case "$cur" in
 847         --*)
 848                 __gitcomp "
 849                         --local
 850                         --no-hardlinks
 851                         --shared
 852                         --reference
 853                         --quiet
 854                         --no-checkout
 855                         --bare
 856                         --mirror
 857                         --origin
 858                         --upload-pack
 859                         --template=
 860                         --depth
 861                         "
 862                 return
 863                 ;;
 864         esac
 865         COMPREPLY=()
 866 }
 867
 868 _git_commit ()
 869 {
 870         __git_has_doubledash && return
 871
 872         local cur="${COMP_WORDS[COMP_CWORD]}"
 873         case "$cur" in
 874         --*)
 875                 __gitcomp "
 876                         --all --author= --signoff --verify --no-verify
 877                         --edit --amend --include --only --interactive
 878                         "
 879                 return
 880         esac
 881         COMPREPLY=()
 882 }
 883
 884 _git_describe ()
 885 {
 886         local cur="${COMP_WORDS[COMP_CWORD]}"
 887         case "$cur" in
 888         --*)
 889                 __gitcomp "
 890                         --all --tags --contains --abbrev= --candidates=
 891                         --exact-match --debug --long --match --always
 892                         "
 893                 return
 894         esac
 895         __gitcomp "$(__git_refs)"
 896 }
 897
 898 __git_diff_common_options="--stat --numstat --shortstat --summary
 899                         --patch-with-stat --name-only --name-status --color
 900                         --no-color --color-words --no-renames --check
 901                         --full-index --binary --abbrev --diff-filter=
 902                         --find-copies-harder
 903                         --text --ignore-space-at-eol --ignore-space-change
 904                         --ignore-all-space --exit-code --quiet --ext-diff
 905                         --no-ext-diff
 906                         --no-prefix --src-prefix= --dst-prefix=
 907                         --inter-hunk-context=
 908                         --patience
 909                         --raw
 910 "
 911
 912 _git_diff ()
 913 {
 914         __git_has_doubledash && return
 915
 916         local cur="${COMP_WORDS[COMP_CWORD]}"
 917         case "$cur" in
 918         --*)
 919                 __gitcomp "--cached --staged --pickaxe-all --pickaxe-regex
 920                         --base --ours --theirs
 921                         $__git_diff_common_options
 922                         "
 923                 return
 924                 ;;
 925         esac
 926         __git_complete_file
 927 }
 928
 929 __git_mergetools_common="diffuse ecmerge emerge kdiff3 meld opendiff
 930                         tkdiff vimdiff gvimdiff xxdiff araxis
 931 "
 932
 933 _git_difftool ()
 934 {
 935         local cur="${COMP_WORDS[COMP_CWORD]}"
 936         case "$cur" in
 937         --tool=*)
 938                 __gitcomp "$__git_mergetools_common kompare" "" "${cur##--tool=}"
 939                 return
 940                 ;;
 941         --*)
 942                 __gitcomp "--tool="
 943                 return
 944                 ;;
 945         esac
 946         COMPREPLY=()
 947 }
 948
 949 __git_fetch_options="
 950         --quiet --verbose --append --upload-pack --force --keep --depth=
 951         --tags --no-tags
 952 "
 953
 954 _git_fetch ()
 955 {
 956         local cur="${COMP_WORDS[COMP_CWORD]}"
 957         case "$cur" in
 958         --*)
 959                 __gitcomp "$__git_fetch_options"
 960                 return
 961                 ;;
 962         esac
 963         __git_complete_remote_or_refspec
 964 }
 965
 966 _git_format_patch ()
 967 {
 968         local cur="${COMP_WORDS[COMP_CWORD]}"
 969         case "$cur" in
 970         --thread=*)
 971                 __gitcomp "
 972                         deep shallow
 973                         " "" "${cur##--thread=}"
 974                 return
 975                 ;;
 976         --*)
 977                 __gitcomp "
 978                         --stdout --attach --no-attach --thread --thread=
 979                         --output-directory
 980                         --numbered --start-number
 981                         --numbered-files
 982                         --keep-subject
 983                         --signoff
 984                         --in-reply-to= --cc=
 985                         --full-index --binary
 986                         --not --all
 987                         --cover-letter
 988                         --no-prefix --src-prefix= --dst-prefix=
 989                         --inline --suffix= --ignore-if-in-upstream
 990                         --subject-prefix=
 991                         "
 992                 return
 993                 ;;
 994         esac
 995         __git_complete_revlist
 996 }
 997
 998 _git_fsck ()
 999 {
1000         local cur="${COMP_WORDS[COMP_CWORD]}"
1001         case "$cur" in
1002         --*)
1003                 __gitcomp "
1004                         --tags --root --unreachable --cache --no-reflogs --full
1005                         --strict --verbose --lost-found
1006                         "
1007                 return
1008                 ;;
1009         esac
1010         COMPREPLY=()
1011 }
1012
1013 _git_gc ()
1014 {
1015         local cur="${COMP_WORDS[COMP_CWORD]}"
1016         case "$cur" in
1017         --*)
1018                 __gitcomp "--prune --aggressive"
1019                 return
1020                 ;;
1021         esac
1022         COMPREPLY=()
1023 }
1024
1025 _git_grep ()
1026 {
1027         __git_has_doubledash && return
1028
1029         local cur="${COMP_WORDS[COMP_CWORD]}"
1030         case "$cur" in
1031         --*)
1032                 __gitcomp "
1033                         --cached
1034                         --text --ignore-case --word-regexp --invert-match
1035                         --full-name
1036                         --extended-regexp --basic-regexp --fixed-strings
1037                         --files-with-matches --name-only
1038                         --files-without-match
1039                         --count
1040                         --and --or --not --all-match
1041                         "
1042                 return
1043                 ;;
1044         esac
1045         COMPREPLY=()
1046 }
1047
1048 _git_help ()
1049 {
1050         local cur="${COMP_WORDS[COMP_CWORD]}"
1051         case "$cur" in
1052         --*)
1053                 __gitcomp "--all --info --man --web"
1054                 return
1055                 ;;
1056         esac
1057         __gitcomp "$(__git_all_commands)
1058                 attributes cli core-tutorial cvs-migration
1059                 diffcore gitk glossary hooks ignore modules
1060                 repository-layout tutorial tutorial-2
1061                 workflows
1062                 "
1063 }
1064
1065 _git_init ()
1066 {
1067         local cur="${COMP_WORDS[COMP_CWORD]}"
1068         case "$cur" in
1069         --shared=*)
1070                 __gitcomp "
1071                         false true umask group all world everybody
1072                         " "" "${cur##--shared=}"
1073                 return
1074                 ;;
1075         --*)
1076                 __gitcomp "--quiet --bare --template= --shared --shared="
1077                 return
1078                 ;;
1079         esac
1080         COMPREPLY=()
1081 }
1082
1083 _git_ls_files ()
1084 {
1085         __git_has_doubledash && return
1086
1087         local cur="${COMP_WORDS[COMP_CWORD]}"
1088         case "$cur" in
1089         --*)
1090                 __gitcomp "--cached --deleted --modified --others --ignored
1091                         --stage --directory --no-empty-directory --unmerged
1092                         --killed --exclude= --exclude-from=
1093                         --exclude-per-directory= --exclude-standard
1094                         --error-unmatch --with-tree= --full-name
1095                         --abbrev --ignored --exclude-per-directory
1096                         "
1097                 return
1098                 ;;
1099         esac
1100         COMPREPLY=()
1101 }
1102
1103 _git_ls_remote ()
1104 {
1105         __gitcomp "$(__git_remotes)"
1106 }
1107
1108 _git_ls_tree ()
1109 {
1110         __git_complete_file
1111 }
1112
1113 # Options that go well for log, shortlog and gitk
1114 __git_log_common_options="
1115         --not --all
1116         --branches --tags --remotes
1117         --first-parent --no-merges
1118         --max-count=
1119         --max-age= --since= --after=
1120         --min-age= --until= --before=
1121 "
1122 # Options that go well for log and gitk (not shortlog)
1123 __git_log_gitk_options="
1124         --dense --sparse --full-history
1125         --simplify-merges --simplify-by-decoration
1126         --left-right
1127 "
1128 # Options that go well for log and shortlog (not gitk)
1129 __git_log_shortlog_options="
1130         --author= --committer= --grep=
1131         --all-match
1132 "
1133
1134 __git_log_pretty_formats="oneline short medium full fuller email raw format:"
1135 __git_log_date_formats="relative iso8601 rfc2822 short local default raw"
1136
1137 _git_log ()
1138 {
1139         __git_has_doubledash && return
1140
1141         local cur="${COMP_WORDS[COMP_CWORD]}"
1142         local g="$(git rev-parse --git-dir 2>/dev/null)"
1143         local merge=""
1144         if [ -f "$g/MERGE_HEAD" ]; then
1145                 merge="--merge"
1146         fi
1147         case "$cur" in
1148         --pretty=*)
1149                 __gitcomp "$__git_log_pretty_formats
1150                         " "" "${cur##--pretty=}"
1151                 return
1152                 ;;
1153         --format=*)
1154                 __gitcomp "$__git_log_pretty_formats
1155                         " "" "${cur##--format=}"
1156                 return
1157                 ;;
1158         --date=*)
1159                 __gitcomp "$__git_log_date_formats" "" "${cur##--date=}"
1160                 return
1161                 ;;
1162         --*)
1163                 __gitcomp "
1164                         $__git_log_common_options
1165                         $__git_log_shortlog_options
1166                         $__git_log_gitk_options
1167                         --root --topo-order --date-order --reverse
1168                         --follow
1169                         --abbrev-commit --abbrev=
1170                         --relative-date --date=
1171                         --pretty= --format= --oneline
1172                         --cherry-pick
1173                         --graph
1174                         --decorate
1175                         --walk-reflogs
1176                         --parents --children
1177                         $merge
1178                         $__git_diff_common_options
1179                         --pickaxe-all --pickaxe-regex
1180                         "
1181                 return
1182                 ;;
1183         esac
1184         __git_complete_revlist
1185 }
1186
1187 __git_merge_options="
1188         --no-commit --no-stat --log --no-log --squash --strategy
1189         --commit --stat --no-squash --ff --no-ff
1190 "
1191
1192 _git_merge ()
1193 {
1194         __git_complete_strategy && return
1195
1196         local cur="${COMP_WORDS[COMP_CWORD]}"
1197         case "$cur" in
1198         --*)
1199                 __gitcomp "$__git_merge_options"
1200                 return
1201         esac
1202         __gitcomp "$(__git_refs)"
1203 }
1204
1205 _git_mergetool ()
1206 {
1207         local cur="${COMP_WORDS[COMP_CWORD]}"
1208         case "$cur" in
1209         --tool=*)
1210                 __gitcomp "$__git_mergetools_common tortoisemerge" "" "${cur##--tool=}"
1211                 return
1212                 ;;
1213         --*)
1214                 __gitcomp "--tool="
1215                 return
1216                 ;;
1217         esac
1218         COMPREPLY=()
1219 }
1220
1221 _git_merge_base ()
1222 {
1223         __gitcomp "$(__git_refs)"
1224 }
1225
1226 _git_mv ()
1227 {
1228         local cur="${COMP_WORDS[COMP_CWORD]}"
1229         case "$cur" in
1230         --*)
1231                 __gitcomp "--dry-run"
1232                 return
1233                 ;;
1234         esac
1235         COMPREPLY=()
1236 }
1237
1238 _git_name_rev ()
1239 {
1240         __gitcomp "--tags --all --stdin"
1241 }
1242
1243 _git_pull ()
1244 {
1245         __git_complete_strategy && return
1246
1247         local cur="${COMP_WORDS[COMP_CWORD]}"
1248         case "$cur" in
1249         --*)
1250                 __gitcomp "
1251                         --rebase --no-rebase
1252                         $__git_merge_options
1253                         $__git_fetch_options
1254                 "
1255                 return
1256                 ;;
1257         esac
1258         __git_complete_remote_or_refspec
1259 }
1260
1261 _git_push ()
1262 {
1263         local cur="${COMP_WORDS[COMP_CWORD]}"
1264         case "${COMP_WORDS[COMP_CWORD-1]}" in
1265         --repo)
1266                 __gitcomp "$(__git_remotes)"
1267                 return
1268         esac
1269         case "$cur" in
1270         --repo=*)
1271                 __gitcomp "$(__git_remotes)" "" "${cur##--repo=}"
1272                 return
1273                 ;;
1274         --*)
1275                 __gitcomp "
1276                         --all --mirror --tags --dry-run --force --verbose
1277                         --receive-pack= --repo=
1278                 "
1279                 return
1280                 ;;
1281         esac
1282         __git_complete_remote_or_refspec
1283 }
1284
1285 _git_rebase ()
1286 {
1287         local cur="${COMP_WORDS[COMP_CWORD]}" dir="$(__gitdir)"
1288         if [ -d "$dir"/rebase-apply ] || [ -d "$dir"/rebase-merge ]; then
1289                 __gitcomp "--continue --skip --abort"
1290                 return
1291         fi
1292         __git_complete_strategy && return
1293         case "$cur" in
1294         --*)
1295                 __gitcomp "--onto --merge --strategy --interactive"
1296                 return
1297         esac
1298         __gitcomp "$(__git_refs)"
1299 }
1300
1301 __git_send_email_confirm_options="always never auto cc compose"
1302 __git_send_email_suppresscc_options="author self cc bodycc sob cccmd body all"
1303
1304 _git_send_email ()
1305 {
1306         local cur="${COMP_WORDS[COMP_CWORD]}"
1307         case "$cur" in
1308         --confirm=*)
1309                 __gitcomp "
1310                         $__git_send_email_confirm_options
1311                         " "" "${cur##--confirm=}"
1312                 return
1313                 ;;
1314         --suppress-cc=*)
1315                 __gitcomp "
1316                         $__git_send_email_suppresscc_options
1317                         " "" "${cur##--suppress-cc=}"
1318
1319                 return
1320                 ;;
1321         --smtp-encryption=*)
1322                 __gitcomp "ssl tls" "" "${cur##--smtp-encryption=}"
1323                 return
1324                 ;;
1325         --*)
1326                 __gitcomp "--annotate --bcc --cc --cc-cmd --chain-reply-to
1327                         --compose --confirm= --dry-run --envelope-sender
1328                         --from --identity
1329                         --in-reply-to --no-chain-reply-to --no-signed-off-by-cc
1330                         --no-suppress-from --no-thread --quiet
1331                         --signed-off-by-cc --smtp-pass --smtp-server
1332                         --smtp-server-port --smtp-encryption= --smtp-user
1333                         --subject --suppress-cc= --suppress-from --thread --to
1334                         --validate --no-validate"
1335                 return
1336                 ;;
1337         esac
1338         COMPREPLY=()
1339 }
1340
1341 __git_config_get_set_variables ()
1342 {
1343         local prevword word config_file= c=$COMP_CWORD
1344         while [ $c -gt 1 ]; do
1345                 word="${COMP_WORDS[c]}"
1346                 case "$word" in
1347                 --global|--system|--file=*)
1348                         config_file="$word"
1349                         break
1350                         ;;
1351                 -f|--file)
1352                         config_file="$word $prevword"
1353                         break
1354                         ;;
1355                 esac
1356                 prevword=$word
1357                 c=$((--c))
1358         done
1359
1360         for i in $(git --git-dir="$(__gitdir)" config $config_file --list \
1361                         2>/dev/null); do
1362                 case "$i" in
1363                 *.*)
1364                         echo "${i/=*/}"
1365                         ;;
1366                 esac
1367         done
1368 }
1369
1370 _git_config ()
1371 {
1372         local cur="${COMP_WORDS[COMP_CWORD]}"
1373         local prv="${COMP_WORDS[COMP_CWORD-1]}"
1374         case "$prv" in
1375         branch.*.remote)
1376                 __gitcomp "$(__git_remotes)"
1377                 return
1378                 ;;
1379         branch.*.merge)
1380                 __gitcomp "$(__git_refs)"
1381                 return
1382                 ;;
1383         remote.*.fetch)
1384                 local remote="${prv#remote.}"
1385                 remote="${remote%.fetch}"
1386                 __gitcomp "$(__git_refs_remotes "$remote")"
1387                 return
1388                 ;;
1389         remote.*.push)
1390                 local remote="${prv#remote.}"
1391                 remote="${remote%.push}"
1392                 __gitcomp "$(git --git-dir="$(__gitdir)" \
1393                         for-each-ref --format='%(refname):%(refname)' \
1394                         refs/heads)"
1395                 return
1396                 ;;
1397         pull.twohead|pull.octopus)
1398                 __gitcomp "$(__git_merge_strategies)"
1399                 return
1400                 ;;
1401         color.branch|color.diff|color.interactive|\
1402         color.showbranch|color.status|color.ui)
1403                 __gitcomp "always never auto"
1404                 return
1405                 ;;
1406         color.pager)
1407                 __gitcomp "false true"
1408                 return
1409                 ;;
1410         color.*.*)
1411                 __gitcomp "
1412                         normal black red green yellow blue magenta cyan white
1413                         bold dim ul blink reverse
1414                         "
1415                 return
1416                 ;;
1417         help.format)
1418                 __gitcomp "man info web html"
1419                 return
1420                 ;;
1421         log.date)
1422                 __gitcomp "$__git_log_date_formats"
1423                 return
1424                 ;;
1425         sendemail.aliasesfiletype)
1426                 __gitcomp "mutt mailrc pine elm gnus"
1427                 return
1428                 ;;
1429         sendemail.confirm)
1430                 __gitcomp "$__git_send_email_confirm_options"
1431                 return
1432                 ;;
1433         sendemail.suppresscc)
1434                 __gitcomp "$__git_send_email_suppresscc_options"
1435                 return
1436                 ;;
1437         --get|--get-all|--unset|--unset-all)
1438                 __gitcomp "$(__git_config_get_set_variables)"
1439                 return
1440                 ;;
1441         *.*)
1442                 COMPREPLY=()
1443                 return
1444                 ;;
1445         esac
1446         case "$cur" in
1447         --*)
1448                 __gitcomp "
1449                         --global --system --file=
1450                         --list --replace-all
1451                         --get --get-all --get-regexp
1452                         --add --unset --unset-all
1453                         --remove-section --rename-section
1454                         "
1455                 return
1456                 ;;
1457         branch.*.*)
1458                 local pfx="${cur%.*}."
1459                 cur="${cur##*.}"
1460                 __gitcomp "remote merge mergeoptions rebase" "$pfx" "$cur"
1461                 return
1462                 ;;
1463         branch.*)
1464                 local pfx="${cur%.*}."
1465                 cur="${cur#*.}"
1466                 __gitcomp "$(__git_heads)" "$pfx" "$cur" "."
1467                 return
1468                 ;;
1469         guitool.*.*)
1470                 local pfx="${cur%.*}."
1471                 cur="${cur##*.}"
1472                 __gitcomp "
1473                         argprompt cmd confirm needsfile noconsole norescan
1474                         prompt revprompt revunmerged title
1475                         " "$pfx" "$cur"
1476                 return
1477                 ;;
1478         difftool.*.*)
1479                 local pfx="${cur%.*}."
1480                 cur="${cur##*.}"
1481                 __gitcomp "cmd path" "$pfx" "$cur"
1482                 return
1483                 ;;
1484         man.*.*)
1485                 local pfx="${cur%.*}."
1486                 cur="${cur##*.}"
1487                 __gitcomp "cmd path" "$pfx" "$cur"
1488                 return
1489                 ;;
1490         mergetool.*.*)
1491                 local pfx="${cur%.*}."
1492                 cur="${cur##*.}"
1493                 __gitcomp "cmd path trustExitCode" "$pfx" "$cur"
1494                 return
1495                 ;;
1496         pager.*)
1497                 local pfx="${cur%.*}."
1498                 cur="${cur#*.}"
1499                 __gitcomp "$(__git_all_commands)" "$pfx" "$cur"
1500                 return
1501                 ;;
1502         remote.*.*)
1503                 local pfx="${cur%.*}."
1504                 cur="${cur##*.}"
1505                 __gitcomp "
1506                         url proxy fetch push mirror skipDefaultUpdate
1507                         receivepack uploadpack tagopt pushurl
1508                         " "$pfx" "$cur"
1509                 return
1510                 ;;
1511         remote.*)
1512                 local pfx="${cur%.*}."
1513                 cur="${cur#*.}"
1514                 __gitcomp "$(__git_remotes)" "$pfx" "$cur" "."
1515                 return
1516                 ;;
1517         url.*.*)
1518                 local pfx="${cur%.*}."
1519                 cur="${cur##*.}"
1520                 __gitcomp "insteadof" "$pfx" "$cur"
1521                 return
1522                 ;;
1523         esac
1524         __gitcomp "
1525                 add.ignore-errors
1526                 alias.
1527                 apply.whitespace
1528                 branch.autosetupmerge
1529                 branch.autosetuprebase
1530                 clean.requireForce
1531                 color.branch
1532                 color.branch.current
1533                 color.branch.local
1534                 color.branch.plain
1535                 color.branch.remote
1536                 color.diff
1537                 color.diff.commit
1538                 color.diff.frag
1539                 color.diff.meta
1540                 color.diff.new
1541                 color.diff.old
1542                 color.diff.plain
1543                 color.diff.whitespace
1544                 color.grep
1545                 color.grep.external
1546                 color.grep.match
1547                 color.interactive
1548                 color.interactive.header
1549                 color.interactive.help
1550                 color.interactive.prompt
1551                 color.pager
1552                 color.showbranch
1553                 color.status
1554                 color.status.added
1555                 color.status.changed
1556                 color.status.header
1557                 color.status.nobranch
1558                 color.status.untracked
1559                 color.status.updated
1560                 color.ui
1561                 commit.template
1562                 core.autocrlf
1563                 core.bare
1564                 core.compression
1565                 core.createObject
1566                 core.deltaBaseCacheLimit
1567                 core.editor
1568                 core.excludesfile
1569                 core.fileMode
1570                 core.fsyncobjectfiles
1571                 core.gitProxy
1572                 core.ignoreCygwinFSTricks
1573                 core.ignoreStat
1574                 core.logAllRefUpdates
1575                 core.loosecompression
1576                 core.packedGitLimit
1577                 core.packedGitWindowSize
1578                 core.pager
1579                 core.preferSymlinkRefs
1580                 core.preloadindex
1581                 core.quotepath
1582                 core.repositoryFormatVersion
1583                 core.safecrlf
1584                 core.sharedRepository
1585                 core.symlinks
1586                 core.trustctime
1587                 core.warnAmbiguousRefs
1588                 core.whitespace
1589                 core.worktree
1590                 diff.autorefreshindex
1591                 diff.external
1592                 diff.mnemonicprefix
1593                 diff.renameLimit
1594                 diff.renameLimit.
1595                 diff.renames
1596                 diff.suppressBlankEmpty
1597                 diff.tool
1598                 diff.wordRegex
1599                 difftool.
1600                 difftool.prompt
1601                 fetch.unpackLimit
1602                 format.attach
1603                 format.cc
1604                 format.headers
1605                 format.numbered
1606                 format.pretty
1607                 format.signoff
1608                 format.subjectprefix
1609                 format.suffix
1610                 format.thread
1611                 gc.aggressiveWindow
1612                 gc.auto
1613                 gc.autopacklimit
1614                 gc.packrefs
1615                 gc.pruneexpire
1616                 gc.reflogexpire
1617                 gc.reflogexpireunreachable
1618                 gc.rerereresolved
1619                 gc.rerereunresolved
1620                 gitcvs.allbinary
1621                 gitcvs.commitmsgannotation
1622                 gitcvs.dbTableNamePrefix
1623                 gitcvs.dbdriver
1624                 gitcvs.dbname
1625                 gitcvs.dbpass
1626                 gitcvs.dbuser
1627                 gitcvs.enabled
1628                 gitcvs.logfile
1629                 gitcvs.usecrlfattr
1630                 guitool.
1631                 gui.blamehistoryctx
1632                 gui.commitmsgwidth
1633                 gui.copyblamethreshold
1634                 gui.diffcontext
1635                 gui.encoding
1636                 gui.fastcopyblame
1637                 gui.matchtrackingbranch
1638                 gui.newbranchtemplate
1639                 gui.pruneduringfetch
1640                 gui.spellingdictionary
1641                 gui.trustmtime
1642                 help.autocorrect
1643                 help.browser
1644                 help.format
1645                 http.lowSpeedLimit
1646                 http.lowSpeedTime
1647                 http.maxRequests
1648                 http.noEPSV
1649                 http.proxy
1650                 http.sslCAInfo
1651                 http.sslCAPath
1652                 http.sslCert
1653                 http.sslKey
1654                 http.sslVerify
1655                 i18n.commitEncoding
1656                 i18n.logOutputEncoding
1657                 imap.folder
1658                 imap.host
1659                 imap.pass
1660                 imap.port
1661                 imap.preformattedHTML
1662                 imap.sslverify
1663                 imap.tunnel
1664                 imap.user
1665                 instaweb.browser
1666                 instaweb.httpd
1667                 instaweb.local
1668                 instaweb.modulepath
1669                 instaweb.port
1670                 interactive.singlekey
1671                 log.date
1672                 log.showroot
1673                 mailmap.file
1674                 man.
1675                 man.viewer
1676                 merge.conflictstyle
1677                 merge.log
1678                 merge.renameLimit
1679                 merge.stat
1680                 merge.tool
1681                 merge.verbosity
1682                 mergetool.
1683                 mergetool.keepBackup
1684                 mergetool.prompt
1685                 pack.compression
1686                 pack.deltaCacheLimit
1687                 pack.deltaCacheSize
1688                 pack.depth
1689                 pack.indexVersion
1690                 pack.packSizeLimit
1691                 pack.threads
1692                 pack.window
1693                 pack.windowMemory
1694                 pager.
1695                 pull.octopus
1696                 pull.twohead
1697                 push.default
1698                 rebase.stat
1699                 receive.denyCurrentBranch
1700                 receive.denyDeletes
1701                 receive.denyNonFastForwards
1702                 receive.fsckObjects
1703                 receive.unpackLimit
1704                 repack.usedeltabaseoffset
1705                 rerere.autoupdate
1706                 rerere.enabled
1707                 sendemail.aliasesfile
1708                 sendemail.aliasesfiletype
1709                 sendemail.bcc
1710                 sendemail.cc
1711                 sendemail.cccmd
1712                 sendemail.chainreplyto
1713                 sendemail.confirm
1714                 sendemail.envelopesender
1715                 sendemail.multiedit
1716                 sendemail.signedoffbycc
1717                 sendemail.smtpencryption
1718                 sendemail.smtppass
1719                 sendemail.smtpserver
1720                 sendemail.smtpserverport
1721                 sendemail.smtpuser
1722                 sendemail.suppresscc
1723                 sendemail.suppressfrom
1724                 sendemail.thread
1725                 sendemail.to
1726                 sendemail.validate
1727                 showbranch.default
1728                 status.relativePaths
1729                 status.showUntrackedFiles
1730                 tar.umask
1731                 transfer.unpackLimit
1732                 url.
1733                 user.email
1734                 user.name
1735                 user.signingkey
1736                 web.browser
1737                 branch. remote.
1738         "
1739 }
1740
1741 _git_remote ()
1742 {
1743         local subcommands="add rename rm show prune update set-head"
1744         local subcommand="$(__git_find_subcommand "$subcommands")"
1745         if [ -z "$subcommand" ]; then
1746                 __gitcomp "$subcommands"
1747                 return
1748         fi
1749
1750         case "$subcommand" in
1751         rename|rm|show|prune)
1752                 __gitcomp "$(__git_remotes)"
1753                 ;;
1754         update)
1755                 local i c='' IFS=$'\n'
1756                 for i in $(git --git-dir="$(__gitdir)" config --list); do
1757                         case "$i" in
1758                         remotes.*)
1759                                 i="${i#remotes.}"
1760                                 c="$c ${i/=*/}"
1761                                 ;;
1762                         esac
1763                 done
1764                 __gitcomp "$c"
1765                 ;;
1766         *)
1767                 COMPREPLY=()
1768                 ;;
1769         esac
1770 }
1771
1772 _git_reset ()
1773 {
1774         __git_has_doubledash && return
1775
1776         local cur="${COMP_WORDS[COMP_CWORD]}"
1777         case "$cur" in
1778         --*)
1779                 __gitcomp "--merge --mixed --hard --soft"
1780                 return
1781                 ;;
1782         esac
1783         __gitcomp "$(__git_refs)"
1784 }
1785
1786 _git_revert ()
1787 {
1788         local cur="${COMP_WORDS[COMP_CWORD]}"
1789         case "$cur" in
1790         --*)
1791                 __gitcomp "--edit --mainline --no-edit --no-commit --signoff"
1792                 return
1793                 ;;
1794         esac
1795         __gitcomp "$(__git_refs)"
1796 }
1797
1798 _git_rm ()
1799 {
1800         __git_has_doubledash && return
1801
1802         local cur="${COMP_WORDS[COMP_CWORD]}"
1803         case "$cur" in
1804         --*)
1805                 __gitcomp "--cached --dry-run --ignore-unmatch --quiet"
1806                 return
1807                 ;;
1808         esac
1809         COMPREPLY=()
1810 }
1811
1812 _git_shortlog ()
1813 {
1814         __git_has_doubledash && return
1815
1816         local cur="${COMP_WORDS[COMP_CWORD]}"
1817         case "$cur" in
1818         --*)
1819                 __gitcomp "
1820                         $__git_log_common_options
1821                         $__git_log_shortlog_options
1822                         --numbered --summary
1823                         "
1824                 return
1825                 ;;
1826         esac
1827         __git_complete_revlist
1828 }
1829
1830 _git_show ()
1831 {
1832         __git_has_doubledash && return
1833
1834         local cur="${COMP_WORDS[COMP_CWORD]}"
1835         case "$cur" in
1836         --pretty=*)
1837                 __gitcomp "$__git_log_pretty_formats
1838                         " "" "${cur##--pretty=}"
1839                 return
1840                 ;;
1841         --format=*)
1842                 __gitcomp "$__git_log_pretty_formats
1843                         " "" "${cur##--format=}"
1844                 return
1845                 ;;
1846         --*)
1847                 __gitcomp "--pretty= --format= --abbrev-commit --oneline
1848                         $__git_diff_common_options
1849                         "
1850                 return
1851                 ;;
1852         esac
1853         __git_complete_file
1854 }
1855
1856 _git_show_branch ()
1857 {
1858         local cur="${COMP_WORDS[COMP_CWORD]}"
1859         case "$cur" in
1860         --*)
1861                 __gitcomp "
1862                         --all --remotes --topo-order --current --more=
1863                         --list --independent --merge-base --no-name
1864                         --color --no-color
1865                         --sha1-name --sparse --topics --reflog
1866                         "
1867                 return
1868                 ;;
1869         esac
1870         __git_complete_revlist
1871 }
1872
1873 _git_stash ()
1874 {
1875         local subcommands='save list show apply clear drop pop create branch'
1876         local subcommand="$(__git_find_subcommand "$subcommands")"
1877         if [ -z "$subcommand" ]; then
1878                 __gitcomp "$subcommands"
1879         else
1880                 local cur="${COMP_WORDS[COMP_CWORD]}"
1881                 case "$subcommand,$cur" in
1882                 save,--*)
1883                         __gitcomp "--keep-index"
1884                         ;;
1885                 apply,--*|pop,--*)
1886                         __gitcomp "--index"
1887                         ;;
1888                 show,--*|drop,--*|branch,--*)
1889                         COMPREPLY=()
1890                         ;;
1891                 show,*|apply,*|drop,*|pop,*|branch,*)
1892                         __gitcomp "$(git --git-dir="$(__gitdir)" stash list \
1893                                         | sed -n -e 's/:.*//p')"
1894                         ;;
1895                 *)
1896                         COMPREPLY=()
1897                         ;;
1898                 esac
1899         fi
1900 }
1901
1902 _git_submodule ()
1903 {
1904         __git_has_doubledash && return
1905
1906         local subcommands="add status init update summary foreach sync"
1907         if [ -z "$(__git_find_subcommand "$subcommands")" ]; then
1908                 local cur="${COMP_WORDS[COMP_CWORD]}"
1909                 case "$cur" in
1910                 --*)
1911                         __gitcomp "--quiet --cached"
1912                         ;;
1913                 *)
1914                         __gitcomp "$subcommands"
1915                         ;;
1916                 esac
1917                 return
1918         fi
1919 }
1920
1921 _git_svn ()
1922 {
1923         local subcommands="
1924                 init fetch clone rebase dcommit log find-rev
1925                 set-tree commit-diff info create-ignore propget
1926                 proplist show-ignore show-externals branch tag blame
1927                 migrate
1928                 "
1929         local subcommand="$(__git_find_subcommand "$subcommands")"
1930         if [ -z "$subcommand" ]; then
1931                 __gitcomp "$subcommands"
1932         else
1933                 local remote_opts="--username= --config-dir= --no-auth-cache"
1934                 local fc_opts="
1935                         --follow-parent --authors-file= --repack=
1936                         --no-metadata --use-svm-props --use-svnsync-props
1937                         --log-window-size= --no-checkout --quiet
1938                         --repack-flags --use-log-author --localtime
1939                         --ignore-paths= $remote_opts
1940                         "
1941                 local init_opts="
1942                         --template= --shared= --trunk= --tags=
1943                         --branches= --stdlayout --minimize-url
1944                         --no-metadata --use-svm-props --use-svnsync-props
1945                         --rewrite-root= --prefix= --use-log-author
1946                         --add-author-from $remote_opts
1947                         "
1948                 local cmt_opts="
1949                         --edit --rmdir --find-copies-harder --copy-similarity=
1950                         "
1951
1952                 local cur="${COMP_WORDS[COMP_CWORD]}"
1953                 case "$subcommand,$cur" in
1954                 fetch,--*)
1955                         __gitcomp "--revision= --fetch-all $fc_opts"
1956                         ;;
1957                 clone,--*)
1958                         __gitcomp "--revision= $fc_opts $init_opts"
1959                         ;;
1960                 init,--*)
1961                         __gitcomp "$init_opts"
1962                         ;;
1963                 dcommit,--*)
1964                         __gitcomp "
1965                                 --merge --strategy= --verbose --dry-run
1966                                 --fetch-all --no-rebase --commit-url
1967                                 --revision $cmt_opts $fc_opts
1968                                 "
1969                         ;;
1970                 set-tree,--*)
1971                         __gitcomp "--stdin $cmt_opts $fc_opts"
1972                         ;;
1973                 create-ignore,--*|propget,--*|proplist,--*|show-ignore,--*|\
1974                 show-externals,--*)
1975                         __gitcomp "--revision="
1976                         ;;
1977                 log,--*)
1978                         __gitcomp "
1979                                 --limit= --revision= --verbose --incremental
1980                                 --oneline --show-commit --non-recursive
1981                                 --authors-file= --color
1982                                 "
1983                         ;;
1984                 rebase,--*)
1985                         __gitcomp "
1986                                 --merge --verbose --strategy= --local
1987                                 --fetch-all --dry-run $fc_opts
1988                                 "
1989                         ;;
1990                 commit-diff,--*)
1991                         __gitcomp "--message= --file= --revision= $cmt_opts"
1992                         ;;
1993                 info,--*)
1994                         __gitcomp "--url"
1995                         ;;
1996                 branch,--*)
1997                         __gitcomp "--dry-run --message --tag"
1998                         ;;
1999                 tag,--*)
2000                         __gitcomp "--dry-run --message"
2001                         ;;
2002                 blame,--*)
2003                         __gitcomp "--git-format"
2004                         ;;
2005                 migrate,--*)
2006                         __gitcomp "
2007                                 --config-dir= --ignore-paths= --minimize
2008                                 --no-auth-cache --username=
2009                                 "
2010                         ;;
2011                 *)
2012                         COMPREPLY=()
2013                         ;;
2014                 esac
2015         fi
2016 }
2017
2018 _git_tag ()
2019 {
2020         local i c=1 f=0
2021         while [ $c -lt $COMP_CWORD ]; do
2022                 i="${COMP_WORDS[c]}"
2023                 case "$i" in
2024                 -d|-v)
2025                         __gitcomp "$(__git_tags)"
2026                         return
2027                         ;;
2028                 -f)
2029                         f=1
2030                         ;;
2031                 esac
2032                 c=$((++c))
2033         done
2034
2035         case "${COMP_WORDS[COMP_CWORD-1]}" in
2036         -m|-F)
2037                 COMPREPLY=()
2038                 ;;
2039         -*|tag)
2040                 if [ $f = 1 ]; then
2041                         __gitcomp "$(__git_tags)"
2042                 else
2043                         COMPREPLY=()
2044                 fi
2045                 ;;
2046         *)
2047                 __gitcomp "$(__git_refs)"
2048                 ;;
2049         esac
2050 }
2051
2052 _git ()
2053 {
2054         local i c=1 command __git_dir
2055
2056         while [ $c -lt $COMP_CWORD ]; do
2057                 i="${COMP_WORDS[c]}"
2058                 case "$i" in
2059                 --git-dir=*) __git_dir="${i#--git-dir=}" ;;
2060                 --bare)      __git_dir="." ;;
2061                 --version|-p|--paginate) ;;
2062                 --help) command="help"; break ;;
2063                 *) command="$i"; break ;;
2064                 esac
2065                 c=$((++c))
2066         done
2067
2068         if [ -z "$command" ]; then
2069                 case "${COMP_WORDS[COMP_CWORD]}" in
2070                 --*)   __gitcomp "
2071                         --paginate
2072                         --no-pager
2073                         --git-dir=
2074                         --bare
2075                         --version
2076                         --exec-path
2077                         --html-path
2078                         --work-tree=
2079                         --help
2080                         "
2081                         ;;
2082                 *)     __gitcomp "$(__git_porcelain_commands) $(__git_aliases)" ;;
2083                 esac
2084                 return
2085         fi
2086
2087         local expansion=$(__git_aliased_command "$command")
2088         [ "$expansion" ] && command="$expansion"
2089
2090         case "$command" in
2091         am)          _git_am ;;
2092         add)         _git_add ;;
2093         apply)       _git_apply ;;
2094         archive)     _git_archive ;;
2095         bisect)      _git_bisect ;;
2096         bundle)      _git_bundle ;;
2097         branch)      _git_branch ;;
2098         checkout)    _git_checkout ;;
2099         cherry)      _git_cherry ;;
2100         cherry-pick) _git_cherry_pick ;;
2101         clean)       _git_clean ;;
2102         clone)       _git_clone ;;
2103         commit)      _git_commit ;;
2104         config)      _git_config ;;
2105         describe)    _git_describe ;;
2106         diff)        _git_diff ;;
2107         difftool)    _git_difftool ;;
2108         fetch)       _git_fetch ;;
2109         format-patch) _git_format_patch ;;
2110         fsck)        _git_fsck ;;
2111         gc)          _git_gc ;;
2112         grep)        _git_grep ;;
2113         help)        _git_help ;;
2114         init)        _git_init ;;
2115         log)         _git_log ;;
2116         ls-files)    _git_ls_files ;;
2117         ls-remote)   _git_ls_remote ;;
2118         ls-tree)     _git_ls_tree ;;
2119         merge)       _git_merge;;
2120         mergetool)   _git_mergetool;;
2121         merge-base)  _git_merge_base ;;
2122         mv)          _git_mv ;;
2123         name-rev)    _git_name_rev ;;
2124         pull)        _git_pull ;;
2125         push)        _git_push ;;
2126         rebase)      _git_rebase ;;
2127         remote)      _git_remote ;;
2128         reset)       _git_reset ;;
2129         revert)      _git_revert ;;
2130         rm)          _git_rm ;;
2131         send-email)  _git_send_email ;;
2132         shortlog)    _git_shortlog ;;
2133         show)        _git_show ;;
2134         show-branch) _git_show_branch ;;
2135         stash)       _git_stash ;;
2136         stage)       _git_add ;;
2137         submodule)   _git_submodule ;;
2138         svn)         _git_svn ;;
2139         tag)         _git_tag ;;
2140         whatchanged) _git_log ;;
2141         *)           COMPREPLY=() ;;
2142         esac
2143 }
2144
2145 _gitk ()
2146 {
2147         __git_has_doubledash && return
2148
2149         local cur="${COMP_WORDS[COMP_CWORD]}"
2150         local g="$(__gitdir)"
2151         local merge=""
2152         if [ -f "$g/MERGE_HEAD" ]; then
2153                 merge="--merge"
2154         fi
2155         case "$cur" in
2156         --*)
2157                 __gitcomp "
2158                         $__git_log_common_options
2159                         $__git_log_gitk_options
2160                         $merge
2161                         "
2162                 return
2163                 ;;
2164         esac
2165         __git_complete_revlist
2166 }
2167
2168 complete -o bashdefault -o default -o nospace -F _git git 2>/dev/null \
2169         || complete -o default -o nospace -F _git git
2170 complete -o bashdefault -o default -o nospace -F _gitk gitk 2>/dev/null \
2171         || complete -o default -o nospace -F _gitk gitk
2172
2173 # The following are necessary only for Cygwin, and only are needed
2174 # when the user has tab-completed the executable name and consequently
2175 # included the '.exe' suffix.
2176 #
2177 if [ Cygwin = "$(uname -o 2>/dev/null)" ]; then
2178 complete -o bashdefault -o default -o nospace -F _git git.exe 2>/dev/null \
2179         || complete -o default -o nospace -F _git git.exe
2180 fi