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 --merges --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 --full-diff
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         git --git-dir="$(__gitdir)" config $config_file --list 2>/dev/null |
1361         while read line
1362         do
1363                 case "$line" in
1364                 *.*=*)
1365                         echo "${line/=*/}"
1366                         ;;
1367                 esac
1368         done
1369 }
1370
1371 _git_config ()
1372 {
1373         local cur="${COMP_WORDS[COMP_CWORD]}"
1374         local prv="${COMP_WORDS[COMP_CWORD-1]}"
1375         case "$prv" in
1376         branch.*.remote)
1377                 __gitcomp "$(__git_remotes)"
1378                 return
1379                 ;;
1380         branch.*.merge)
1381                 __gitcomp "$(__git_refs)"
1382                 return
1383                 ;;
1384         remote.*.fetch)
1385                 local remote="${prv#remote.}"
1386                 remote="${remote%.fetch}"
1387                 __gitcomp "$(__git_refs_remotes "$remote")"
1388                 return
1389                 ;;
1390         remote.*.push)
1391                 local remote="${prv#remote.}"
1392                 remote="${remote%.push}"
1393                 __gitcomp "$(git --git-dir="$(__gitdir)" \
1394                         for-each-ref --format='%(refname):%(refname)' \
1395                         refs/heads)"
1396                 return
1397                 ;;
1398         pull.twohead|pull.octopus)
1399                 __gitcomp "$(__git_merge_strategies)"
1400                 return
1401                 ;;
1402         color.branch|color.diff|color.interactive|\
1403         color.showbranch|color.status|color.ui)
1404                 __gitcomp "always never auto"
1405                 return
1406                 ;;
1407         color.pager)
1408                 __gitcomp "false true"
1409                 return
1410                 ;;
1411         color.*.*)
1412                 __gitcomp "
1413                         normal black red green yellow blue magenta cyan white
1414                         bold dim ul blink reverse
1415                         "
1416                 return
1417                 ;;
1418         help.format)
1419                 __gitcomp "man info web html"
1420                 return
1421                 ;;
1422         log.date)
1423                 __gitcomp "$__git_log_date_formats"
1424                 return
1425                 ;;
1426         sendemail.aliasesfiletype)
1427                 __gitcomp "mutt mailrc pine elm gnus"
1428                 return
1429                 ;;
1430         sendemail.confirm)
1431                 __gitcomp "$__git_send_email_confirm_options"
1432                 return
1433                 ;;
1434         sendemail.suppresscc)
1435                 __gitcomp "$__git_send_email_suppresscc_options"
1436                 return
1437                 ;;
1438         --get|--get-all|--unset|--unset-all)
1439                 __gitcomp "$(__git_config_get_set_variables)"
1440                 return
1441                 ;;
1442         *.*)
1443                 COMPREPLY=()
1444                 return
1445                 ;;
1446         esac
1447         case "$cur" in
1448         --*)
1449                 __gitcomp "
1450                         --global --system --file=
1451                         --list --replace-all
1452                         --get --get-all --get-regexp
1453                         --add --unset --unset-all
1454                         --remove-section --rename-section
1455                         "
1456                 return
1457                 ;;
1458         branch.*.*)
1459                 local pfx="${cur%.*}."
1460                 cur="${cur##*.}"
1461                 __gitcomp "remote merge mergeoptions rebase" "$pfx" "$cur"
1462                 return
1463                 ;;
1464         branch.*)
1465                 local pfx="${cur%.*}."
1466                 cur="${cur#*.}"
1467                 __gitcomp "$(__git_heads)" "$pfx" "$cur" "."
1468                 return
1469                 ;;
1470         guitool.*.*)
1471                 local pfx="${cur%.*}."
1472                 cur="${cur##*.}"
1473                 __gitcomp "
1474                         argprompt cmd confirm needsfile noconsole norescan
1475                         prompt revprompt revunmerged title
1476                         " "$pfx" "$cur"
1477                 return
1478                 ;;
1479         difftool.*.*)
1480                 local pfx="${cur%.*}."
1481                 cur="${cur##*.}"
1482                 __gitcomp "cmd path" "$pfx" "$cur"
1483                 return
1484                 ;;
1485         man.*.*)
1486                 local pfx="${cur%.*}."
1487                 cur="${cur##*.}"
1488                 __gitcomp "cmd path" "$pfx" "$cur"
1489                 return
1490                 ;;
1491         mergetool.*.*)
1492                 local pfx="${cur%.*}."
1493                 cur="${cur##*.}"
1494                 __gitcomp "cmd path trustExitCode" "$pfx" "$cur"
1495                 return
1496                 ;;
1497         pager.*)
1498                 local pfx="${cur%.*}."
1499                 cur="${cur#*.}"
1500                 __gitcomp "$(__git_all_commands)" "$pfx" "$cur"
1501                 return
1502                 ;;
1503         remote.*.*)
1504                 local pfx="${cur%.*}."
1505                 cur="${cur##*.}"
1506                 __gitcomp "
1507                         url proxy fetch push mirror skipDefaultUpdate
1508                         receivepack uploadpack tagopt pushurl
1509                         " "$pfx" "$cur"
1510                 return
1511                 ;;
1512         remote.*)
1513                 local pfx="${cur%.*}."
1514                 cur="${cur#*.}"
1515                 __gitcomp "$(__git_remotes)" "$pfx" "$cur" "."
1516                 return
1517                 ;;
1518         url.*.*)
1519                 local pfx="${cur%.*}."
1520                 cur="${cur##*.}"
1521                 __gitcomp "insteadof" "$pfx" "$cur"
1522                 return
1523                 ;;
1524         esac
1525         __gitcomp "
1526                 add.ignore-errors
1527                 alias.
1528                 apply.whitespace
1529                 branch.autosetupmerge
1530                 branch.autosetuprebase
1531                 clean.requireForce
1532                 color.branch
1533                 color.branch.current
1534                 color.branch.local
1535                 color.branch.plain
1536                 color.branch.remote
1537                 color.diff
1538                 color.diff.commit
1539                 color.diff.frag
1540                 color.diff.meta
1541                 color.diff.new
1542                 color.diff.old
1543                 color.diff.plain
1544                 color.diff.whitespace
1545                 color.grep
1546                 color.grep.external
1547                 color.grep.match
1548                 color.interactive
1549                 color.interactive.header
1550                 color.interactive.help
1551                 color.interactive.prompt
1552                 color.pager
1553                 color.showbranch
1554                 color.status
1555                 color.status.added
1556                 color.status.changed
1557                 color.status.header
1558                 color.status.nobranch
1559                 color.status.untracked
1560                 color.status.updated
1561                 color.ui
1562                 commit.template
1563                 core.autocrlf
1564                 core.bare
1565                 core.compression
1566                 core.createObject
1567                 core.deltaBaseCacheLimit
1568                 core.editor
1569                 core.excludesfile
1570                 core.fileMode
1571                 core.fsyncobjectfiles
1572                 core.gitProxy
1573                 core.ignoreCygwinFSTricks
1574                 core.ignoreStat
1575                 core.logAllRefUpdates
1576                 core.loosecompression
1577                 core.packedGitLimit
1578                 core.packedGitWindowSize
1579                 core.pager
1580                 core.preferSymlinkRefs
1581                 core.preloadindex
1582                 core.quotepath
1583                 core.repositoryFormatVersion
1584                 core.safecrlf
1585                 core.sharedRepository
1586                 core.symlinks
1587                 core.trustctime
1588                 core.warnAmbiguousRefs
1589                 core.whitespace
1590                 core.worktree
1591                 diff.autorefreshindex
1592                 diff.external
1593                 diff.mnemonicprefix
1594                 diff.renameLimit
1595                 diff.renameLimit.
1596                 diff.renames
1597                 diff.suppressBlankEmpty
1598                 diff.tool
1599                 diff.wordRegex
1600                 difftool.
1601                 difftool.prompt
1602                 fetch.unpackLimit
1603                 format.attach
1604                 format.cc
1605                 format.headers
1606                 format.numbered
1607                 format.pretty
1608                 format.signoff
1609                 format.subjectprefix
1610                 format.suffix
1611                 format.thread
1612                 gc.aggressiveWindow
1613                 gc.auto
1614                 gc.autopacklimit
1615                 gc.packrefs
1616                 gc.pruneexpire
1617                 gc.reflogexpire
1618                 gc.reflogexpireunreachable
1619                 gc.rerereresolved
1620                 gc.rerereunresolved
1621                 gitcvs.allbinary
1622                 gitcvs.commitmsgannotation
1623                 gitcvs.dbTableNamePrefix
1624                 gitcvs.dbdriver
1625                 gitcvs.dbname
1626                 gitcvs.dbpass
1627                 gitcvs.dbuser
1628                 gitcvs.enabled
1629                 gitcvs.logfile
1630                 gitcvs.usecrlfattr
1631                 guitool.
1632                 gui.blamehistoryctx
1633                 gui.commitmsgwidth
1634                 gui.copyblamethreshold
1635                 gui.diffcontext
1636                 gui.encoding
1637                 gui.fastcopyblame
1638                 gui.matchtrackingbranch
1639                 gui.newbranchtemplate
1640                 gui.pruneduringfetch
1641                 gui.spellingdictionary
1642                 gui.trustmtime
1643                 help.autocorrect
1644                 help.browser
1645                 help.format
1646                 http.lowSpeedLimit
1647                 http.lowSpeedTime
1648                 http.maxRequests
1649                 http.noEPSV
1650                 http.proxy
1651                 http.sslCAInfo
1652                 http.sslCAPath
1653                 http.sslCert
1654                 http.sslKey
1655                 http.sslVerify
1656                 i18n.commitEncoding
1657                 i18n.logOutputEncoding
1658                 imap.folder
1659                 imap.host
1660                 imap.pass
1661                 imap.port
1662                 imap.preformattedHTML
1663                 imap.sslverify
1664                 imap.tunnel
1665                 imap.user
1666                 instaweb.browser
1667                 instaweb.httpd
1668                 instaweb.local
1669                 instaweb.modulepath
1670                 instaweb.port
1671                 interactive.singlekey
1672                 log.date
1673                 log.showroot
1674                 mailmap.file
1675                 man.
1676                 man.viewer
1677                 merge.conflictstyle
1678                 merge.log
1679                 merge.renameLimit
1680                 merge.stat
1681                 merge.tool
1682                 merge.verbosity
1683                 mergetool.
1684                 mergetool.keepBackup
1685                 mergetool.prompt
1686                 pack.compression
1687                 pack.deltaCacheLimit
1688                 pack.deltaCacheSize
1689                 pack.depth
1690                 pack.indexVersion
1691                 pack.packSizeLimit
1692                 pack.threads
1693                 pack.window
1694                 pack.windowMemory
1695                 pager.
1696                 pull.octopus
1697                 pull.twohead
1698                 push.default
1699                 rebase.stat
1700                 receive.denyCurrentBranch
1701                 receive.denyDeletes
1702                 receive.denyNonFastForwards
1703                 receive.fsckObjects
1704                 receive.unpackLimit
1705                 repack.usedeltabaseoffset
1706                 rerere.autoupdate
1707                 rerere.enabled
1708                 sendemail.aliasesfile
1709                 sendemail.aliasesfiletype
1710                 sendemail.bcc
1711                 sendemail.cc
1712                 sendemail.cccmd
1713                 sendemail.chainreplyto
1714                 sendemail.confirm
1715                 sendemail.envelopesender
1716                 sendemail.multiedit
1717                 sendemail.signedoffbycc
1718                 sendemail.smtpencryption
1719                 sendemail.smtppass
1720                 sendemail.smtpserver
1721                 sendemail.smtpserverport
1722                 sendemail.smtpuser
1723                 sendemail.suppresscc
1724                 sendemail.suppressfrom
1725                 sendemail.thread
1726                 sendemail.to
1727                 sendemail.validate
1728                 showbranch.default
1729                 status.relativePaths
1730                 status.showUntrackedFiles
1731                 tar.umask
1732                 transfer.unpackLimit
1733                 url.
1734                 user.email
1735                 user.name
1736                 user.signingkey
1737                 web.browser
1738                 branch. remote.
1739         "
1740 }
1741
1742 _git_remote ()
1743 {
1744         local subcommands="add rename rm show prune update set-head"
1745         local subcommand="$(__git_find_subcommand "$subcommands")"
1746         if [ -z "$subcommand" ]; then
1747                 __gitcomp "$subcommands"
1748                 return
1749         fi
1750
1751         case "$subcommand" in
1752         rename|rm|show|prune)
1753                 __gitcomp "$(__git_remotes)"
1754                 ;;
1755         update)
1756                 local i c='' IFS=$'\n'
1757                 for i in $(git --git-dir="$(__gitdir)" config --list); do
1758                         case "$i" in
1759                         remotes.*)
1760                                 i="${i#remotes.}"
1761                                 c="$c ${i/=*/}"
1762                                 ;;
1763                         esac
1764                 done
1765                 __gitcomp "$c"
1766                 ;;
1767         *)
1768                 COMPREPLY=()
1769                 ;;
1770         esac
1771 }
1772
1773 _git_reset ()
1774 {
1775         __git_has_doubledash && return
1776
1777         local cur="${COMP_WORDS[COMP_CWORD]}"
1778         case "$cur" in
1779         --*)
1780                 __gitcomp "--merge --mixed --hard --soft"
1781                 return
1782                 ;;
1783         esac
1784         __gitcomp "$(__git_refs)"
1785 }
1786
1787 _git_revert ()
1788 {
1789         local cur="${COMP_WORDS[COMP_CWORD]}"
1790         case "$cur" in
1791         --*)
1792                 __gitcomp "--edit --mainline --no-edit --no-commit --signoff"
1793                 return
1794                 ;;
1795         esac
1796         __gitcomp "$(__git_refs)"
1797 }
1798
1799 _git_rm ()
1800 {
1801         __git_has_doubledash && return
1802
1803         local cur="${COMP_WORDS[COMP_CWORD]}"
1804         case "$cur" in
1805         --*)
1806                 __gitcomp "--cached --dry-run --ignore-unmatch --quiet"
1807                 return
1808                 ;;
1809         esac
1810         COMPREPLY=()
1811 }
1812
1813 _git_shortlog ()
1814 {
1815         __git_has_doubledash && return
1816
1817         local cur="${COMP_WORDS[COMP_CWORD]}"
1818         case "$cur" in
1819         --*)
1820                 __gitcomp "
1821                         $__git_log_common_options
1822                         $__git_log_shortlog_options
1823                         --numbered --summary
1824                         "
1825                 return
1826                 ;;
1827         esac
1828         __git_complete_revlist
1829 }
1830
1831 _git_show ()
1832 {
1833         __git_has_doubledash && return
1834
1835         local cur="${COMP_WORDS[COMP_CWORD]}"
1836         case "$cur" in
1837         --pretty=*)
1838                 __gitcomp "$__git_log_pretty_formats
1839                         " "" "${cur##--pretty=}"
1840                 return
1841                 ;;
1842         --format=*)
1843                 __gitcomp "$__git_log_pretty_formats
1844                         " "" "${cur##--format=}"
1845                 return
1846                 ;;
1847         --*)
1848                 __gitcomp "--pretty= --format= --abbrev-commit --oneline
1849                         $__git_diff_common_options
1850                         "
1851                 return
1852                 ;;
1853         esac
1854         __git_complete_file
1855 }
1856
1857 _git_show_branch ()
1858 {
1859         local cur="${COMP_WORDS[COMP_CWORD]}"
1860         case "$cur" in
1861         --*)
1862                 __gitcomp "
1863                         --all --remotes --topo-order --current --more=
1864                         --list --independent --merge-base --no-name
1865                         --color --no-color
1866                         --sha1-name --sparse --topics --reflog
1867                         "
1868                 return
1869                 ;;
1870         esac
1871         __git_complete_revlist
1872 }
1873
1874 _git_stash ()
1875 {
1876         local subcommands='save list show apply clear drop pop create branch'
1877         local subcommand="$(__git_find_subcommand "$subcommands")"
1878         if [ -z "$subcommand" ]; then
1879                 __gitcomp "$subcommands"
1880         else
1881                 local cur="${COMP_WORDS[COMP_CWORD]}"
1882                 case "$subcommand,$cur" in
1883                 save,--*)
1884                         __gitcomp "--keep-index"
1885                         ;;
1886                 apply,--*|pop,--*)
1887                         __gitcomp "--index"
1888                         ;;
1889                 show,--*|drop,--*|branch,--*)
1890                         COMPREPLY=()
1891                         ;;
1892                 show,*|apply,*|drop,*|pop,*|branch,*)
1893                         __gitcomp "$(git --git-dir="$(__gitdir)" stash list \
1894                                         | sed -n -e 's/:.*//p')"
1895                         ;;
1896                 *)
1897                         COMPREPLY=()
1898                         ;;
1899                 esac
1900         fi
1901 }
1902
1903 _git_submodule ()
1904 {
1905         __git_has_doubledash && return
1906
1907         local subcommands="add status init update summary foreach sync"
1908         if [ -z "$(__git_find_subcommand "$subcommands")" ]; then
1909                 local cur="${COMP_WORDS[COMP_CWORD]}"
1910                 case "$cur" in
1911                 --*)
1912                         __gitcomp "--quiet --cached"
1913                         ;;
1914                 *)
1915                         __gitcomp "$subcommands"
1916                         ;;
1917                 esac
1918                 return
1919         fi
1920 }
1921
1922 _git_svn ()
1923 {
1924         local subcommands="
1925                 init fetch clone rebase dcommit log find-rev
1926                 set-tree commit-diff info create-ignore propget
1927                 proplist show-ignore show-externals branch tag blame
1928                 migrate
1929                 "
1930         local subcommand="$(__git_find_subcommand "$subcommands")"
1931         if [ -z "$subcommand" ]; then
1932                 __gitcomp "$subcommands"
1933         else
1934                 local remote_opts="--username= --config-dir= --no-auth-cache"
1935                 local fc_opts="
1936                         --follow-parent --authors-file= --repack=
1937                         --no-metadata --use-svm-props --use-svnsync-props
1938                         --log-window-size= --no-checkout --quiet
1939                         --repack-flags --use-log-author --localtime
1940                         --ignore-paths= $remote_opts
1941                         "
1942                 local init_opts="
1943                         --template= --shared= --trunk= --tags=
1944                         --branches= --stdlayout --minimize-url
1945                         --no-metadata --use-svm-props --use-svnsync-props
1946                         --rewrite-root= --prefix= --use-log-author
1947                         --add-author-from $remote_opts
1948                         "
1949                 local cmt_opts="
1950                         --edit --rmdir --find-copies-harder --copy-similarity=
1951                         "
1952
1953                 local cur="${COMP_WORDS[COMP_CWORD]}"
1954                 case "$subcommand,$cur" in
1955                 fetch,--*)
1956                         __gitcomp "--revision= --fetch-all $fc_opts"
1957                         ;;
1958                 clone,--*)
1959                         __gitcomp "--revision= $fc_opts $init_opts"
1960                         ;;
1961                 init,--*)
1962                         __gitcomp "$init_opts"
1963                         ;;
1964                 dcommit,--*)
1965                         __gitcomp "
1966                                 --merge --strategy= --verbose --dry-run
1967                                 --fetch-all --no-rebase --commit-url
1968                                 --revision $cmt_opts $fc_opts
1969                                 "
1970                         ;;
1971                 set-tree,--*)
1972                         __gitcomp "--stdin $cmt_opts $fc_opts"
1973                         ;;
1974                 create-ignore,--*|propget,--*|proplist,--*|show-ignore,--*|\
1975                 show-externals,--*)
1976                         __gitcomp "--revision="
1977                         ;;
1978                 log,--*)
1979                         __gitcomp "
1980                                 --limit= --revision= --verbose --incremental
1981                                 --oneline --show-commit --non-recursive
1982                                 --authors-file= --color
1983                                 "
1984                         ;;
1985                 rebase,--*)
1986                         __gitcomp "
1987                                 --merge --verbose --strategy= --local
1988                                 --fetch-all --dry-run $fc_opts
1989                                 "
1990                         ;;
1991                 commit-diff,--*)
1992                         __gitcomp "--message= --file= --revision= $cmt_opts"
1993                         ;;
1994                 info,--*)
1995                         __gitcomp "--url"
1996                         ;;
1997                 branch,--*)
1998                         __gitcomp "--dry-run --message --tag"
1999                         ;;
2000                 tag,--*)
2001                         __gitcomp "--dry-run --message"
2002                         ;;
2003                 blame,--*)
2004                         __gitcomp "--git-format"
2005                         ;;
2006                 migrate,--*)
2007                         __gitcomp "
2008                                 --config-dir= --ignore-paths= --minimize
2009                                 --no-auth-cache --username=
2010                                 "
2011                         ;;
2012                 *)
2013                         COMPREPLY=()
2014                         ;;
2015                 esac
2016         fi
2017 }
2018
2019 _git_tag ()
2020 {
2021         local i c=1 f=0
2022         while [ $c -lt $COMP_CWORD ]; do
2023                 i="${COMP_WORDS[c]}"
2024                 case "$i" in
2025                 -d|-v)
2026                         __gitcomp "$(__git_tags)"
2027                         return
2028                         ;;
2029                 -f)
2030                         f=1
2031                         ;;
2032                 esac
2033                 c=$((++c))
2034         done
2035
2036         case "${COMP_WORDS[COMP_CWORD-1]}" in
2037         -m|-F)
2038                 COMPREPLY=()
2039                 ;;
2040         -*|tag)
2041                 if [ $f = 1 ]; then
2042                         __gitcomp "$(__git_tags)"
2043                 else
2044                         COMPREPLY=()
2045                 fi
2046                 ;;
2047         *)
2048                 __gitcomp "$(__git_refs)"
2049                 ;;
2050         esac
2051 }
2052
2053 _git ()
2054 {
2055         local i c=1 command __git_dir
2056
2057         while [ $c -lt $COMP_CWORD ]; do
2058                 i="${COMP_WORDS[c]}"
2059                 case "$i" in
2060                 --git-dir=*) __git_dir="${i#--git-dir=}" ;;
2061                 --bare)      __git_dir="." ;;
2062                 --version|-p|--paginate) ;;
2063                 --help) command="help"; break ;;
2064                 *) command="$i"; break ;;
2065                 esac
2066                 c=$((++c))
2067         done
2068
2069         if [ -z "$command" ]; then
2070                 case "${COMP_WORDS[COMP_CWORD]}" in
2071                 --*)   __gitcomp "
2072                         --paginate
2073                         --no-pager
2074                         --git-dir=
2075                         --bare
2076                         --version
2077                         --exec-path
2078                         --html-path
2079                         --work-tree=
2080                         --help
2081                         "
2082                         ;;
2083                 *)     __gitcomp "$(__git_porcelain_commands) $(__git_aliases)" ;;
2084                 esac
2085                 return
2086         fi
2087
2088         local expansion=$(__git_aliased_command "$command")
2089         [ "$expansion" ] && command="$expansion"
2090
2091         case "$command" in
2092         am)          _git_am ;;
2093         add)         _git_add ;;
2094         apply)       _git_apply ;;
2095         archive)     _git_archive ;;
2096         bisect)      _git_bisect ;;
2097         bundle)      _git_bundle ;;
2098         branch)      _git_branch ;;
2099         checkout)    _git_checkout ;;
2100         cherry)      _git_cherry ;;
2101         cherry-pick) _git_cherry_pick ;;
2102         clean)       _git_clean ;;
2103         clone)       _git_clone ;;
2104         commit)      _git_commit ;;
2105         config)      _git_config ;;
2106         describe)    _git_describe ;;
2107         diff)        _git_diff ;;
2108         difftool)    _git_difftool ;;
2109         fetch)       _git_fetch ;;
2110         format-patch) _git_format_patch ;;
2111         fsck)        _git_fsck ;;
2112         gc)          _git_gc ;;
2113         grep)        _git_grep ;;
2114         help)        _git_help ;;
2115         init)        _git_init ;;
2116         log)         _git_log ;;
2117         ls-files)    _git_ls_files ;;
2118         ls-remote)   _git_ls_remote ;;
2119         ls-tree)     _git_ls_tree ;;
2120         merge)       _git_merge;;
2121         mergetool)   _git_mergetool;;
2122         merge-base)  _git_merge_base ;;
2123         mv)          _git_mv ;;
2124         name-rev)    _git_name_rev ;;
2125         pull)        _git_pull ;;
2126         push)        _git_push ;;
2127         rebase)      _git_rebase ;;
2128         remote)      _git_remote ;;
2129         reset)       _git_reset ;;
2130         revert)      _git_revert ;;
2131         rm)          _git_rm ;;
2132         send-email)  _git_send_email ;;
2133         shortlog)    _git_shortlog ;;
2134         show)        _git_show ;;
2135         show-branch) _git_show_branch ;;
2136         stash)       _git_stash ;;
2137         stage)       _git_add ;;
2138         submodule)   _git_submodule ;;
2139         svn)         _git_svn ;;
2140         tag)         _git_tag ;;
2141         whatchanged) _git_log ;;
2142         *)           COMPREPLY=() ;;
2143         esac
2144 }
2145
2146 _gitk ()
2147 {
2148         __git_has_doubledash && return
2149
2150         local cur="${COMP_WORDS[COMP_CWORD]}"
2151         local g="$(__gitdir)"
2152         local merge=""
2153         if [ -f "$g/MERGE_HEAD" ]; then
2154                 merge="--merge"
2155         fi
2156         case "$cur" in
2157         --*)
2158                 __gitcomp "
2159                         $__git_log_common_options
2160                         $__git_log_gitk_options
2161                         $merge
2162                         "
2163                 return
2164                 ;;
2165         esac
2166         __git_complete_revlist
2167 }
2168
2169 complete -o bashdefault -o default -o nospace -F _git git 2>/dev/null \
2170         || complete -o default -o nospace -F _git git
2171 complete -o bashdefault -o default -o nospace -F _gitk gitk 2>/dev/null \
2172         || complete -o default -o nospace -F _gitk gitk
2173
2174 # The following are necessary only for Cygwin, and only are needed
2175 # when the user has tab-completed the executable name and consequently
2176 # included the '.exe' suffix.
2177 #
2178 if [ Cygwin = "$(uname -o 2>/dev/null)" ]; then
2179 complete -o bashdefault -o default -o nospace -F _git git.exe 2>/dev/null \
2180         || complete -o default -o nospace -F _git git.exe
2181 fi