contrib/completion/git-completion.bash

   1 #
   2 # bash completion support for core Git.
   3 #
   4 # Copyright (C) 2006,2007 Shawn O. Pearce <spearce@spearce.org>
   5 # Conceptually based on gitcompletion (http://gitweb.hawaga.org.uk/).
   6 # Distributed under the GNU General Public License, version 2.0.
   7 #
   8 # The contained completion routines provide support for completing:
   9 #
  10 #    *) local and remote branch names
  11 #    *) local and remote tag names
  12 #    *) .git/remotes file names
  13 #    *) git 'subcommands'
  14 #    *) tree paths within 'ref:path/to/file' expressions
  15 #    *) common --long-options
  16 #
  17 # To use these routines:
  18 #
  19 #    1) Copy this file to somewhere (e.g. ~/.git-completion.sh).
  20 #    2) Added the following line to your .bashrc:
  21 #        source ~/.git-completion.sh
  22 #
  23 #    3) You may want to make sure the git executable is available
  24 #       in your PATH before this script is sourced, as some caching
  25 #       is performed while the script loads.  If git isn't found
  26 #       at source time then all lookups will be done on demand,
  27 #       which may be slightly slower.
  28 #
  29 #    4) Consider changing your PS1 to also show the current branch:
  30 #        PS1='[\u@\h \W$(__git_ps1 " (%s)")]\$ '
  31 #
  32 #       The argument to __git_ps1 will be displayed only if you
  33 #       are currently in a git repository.  The %s token will be
  34 #       the name of the current branch.
  35 #
  36 # To submit patches:
  37 #
  38 #    *) Read Documentation/SubmittingPatches
  39 #    *) Send all patches to the current maintainer:
  40 #
  41 #       "Shawn O. Pearce" <spearce@spearce.org>
  42 #
  43 #    *) Always CC the Git mailing list:
  44 #
  45 #       git@vger.kernel.org
  46 #
  47
  48 __gitdir ()
  49 {
  50         if [ -z "$1" ]; then
  51                 if [ -n "$__git_dir" ]; then
  52                         echo "$__git_dir"
  53                 elif [ -d .git ]; then
  54                         echo .git
  55                 else
  56                         git rev-parse --git-dir 2>/dev/null
  57                 fi
  58         elif [ -d "$1/.git" ]; then
  59                 echo "$1/.git"
  60         else
  61                 echo "$1"
  62         fi
  63 }
  64
  65 __git_ps1 ()
  66 {
  67         local b="$(git symbolic-ref HEAD 2>/dev/null)"
  68         if [ -n "$b" ]; then
  69                 if [ -n "$1" ]; then
  70                         printf "$1" "${b##refs/heads/}"
  71                 else
  72                         printf " (%s)" "${b##refs/heads/}"
  73                 fi
  74         fi
  75 }
  76
  77 __gitcomp ()
  78 {
  79         local all c s=$'\n' IFS=' '$'\t'$'\n'
  80         local cur="${COMP_WORDS[COMP_CWORD]}"
  81         if [ $# -gt 2 ]; then
  82                 cur="$3"
  83         fi
  84         for c in $1; do
  85                 case "$c$4" in
  86                 --*=*) all="$all$c$4$s" ;;
  87                 *.)    all="$all$c$4$s" ;;
  88                 *)     all="$all$c$4 $s" ;;
  89                 esac
  90         done
  91         IFS=$s
  92         COMPREPLY=($(compgen -P "$2" -W "$all" -- "$cur"))
  93         return
  94 }
  95
  96 __git_heads ()
  97 {
  98         local cmd i is_hash=y dir="$(__gitdir "$1")"
  99         if [ -d "$dir" ]; then
 100                 for i in $(git --git-dir="$dir" \
 101                         for-each-ref --format='%(refname)' \
 102                         refs/heads ); do
 103                         echo "${i#refs/heads/}"
 104                 done
 105                 return
 106         fi
 107         for i in $(git-ls-remote "$1" 2>/dev/null); do
 108                 case "$is_hash,$i" in
 109                 y,*) is_hash=n ;;
 110                 n,*^{}) is_hash=y ;;
 111                 n,refs/heads/*) is_hash=y; echo "${i#refs/heads/}" ;;
 112                 n,*) is_hash=y; echo "$i" ;;
 113                 esac
 114         done
 115 }
 116
 117 __git_refs ()
 118 {
 119         local cmd i is_hash=y dir="$(__gitdir "$1")"
 120         if [ -d "$dir" ]; then
 121                 if [ -e "$dir/HEAD" ]; then echo HEAD; fi
 122                 for i in $(git --git-dir="$dir" \
 123                         for-each-ref --format='%(refname)' \
 124                         refs/tags refs/heads refs/remotes); do
 125                         case "$i" in
 126                                 refs/tags/*)    echo "${i#refs/tags/}" ;;
 127                                 refs/heads/*)   echo "${i#refs/heads/}" ;;
 128                                 refs/remotes/*) echo "${i#refs/remotes/}" ;;
 129                                 *)              echo "$i" ;;
 130                         esac
 131                 done
 132                 return
 133         fi
 134         for i in $(git-ls-remote "$dir" 2>/dev/null); do
 135                 case "$is_hash,$i" in
 136                 y,*) is_hash=n ;;
 137                 n,*^{}) is_hash=y ;;
 138                 n,refs/tags/*) is_hash=y; echo "${i#refs/tags/}" ;;
 139                 n,refs/heads/*) is_hash=y; echo "${i#refs/heads/}" ;;
 140                 n,refs/remotes/*) is_hash=y; echo "${i#refs/remotes/}" ;;
 141                 n,*) is_hash=y; echo "$i" ;;
 142                 esac
 143         done
 144 }
 145
 146 __git_refs2 ()
 147 {
 148         local i
 149         for i in $(__git_refs "$1"); do
 150                 echo "$i:$i"
 151         done
 152 }
 153
 154 __git_refs_remotes ()
 155 {
 156         local cmd i is_hash=y
 157         for i in $(git-ls-remote "$1" 2>/dev/null); do
 158                 case "$is_hash,$i" in
 159                 n,refs/heads/*)
 160                         is_hash=y
 161                         echo "$i:refs/remotes/$1/${i#refs/heads/}"
 162                         ;;
 163                 y,*) is_hash=n ;;
 164                 n,*^{}) is_hash=y ;;
 165                 n,refs/tags/*) is_hash=y;;
 166                 n,*) is_hash=y; ;;
 167                 esac
 168         done
 169 }
 170
 171 __git_remotes ()
 172 {
 173         local i ngoff IFS=$'\n' d="$(__gitdir)"
 174         shopt -q nullglob || ngoff=1
 175         shopt -s nullglob
 176         for i in "$d/remotes"/*; do
 177                 echo ${i#$d/remotes/}
 178         done
 179         [ "$ngoff" ] && shopt -u nullglob
 180         for i in $(git --git-dir="$d" config --list); do
 181                 case "$i" in
 182                 remote.*.url=*)
 183                         i="${i#remote.}"
 184                         echo "${i/.url=*/}"
 185                         ;;
 186                 esac
 187         done
 188 }
 189
 190 __git_merge_strategies ()
 191 {
 192         if [ -n "$__git_merge_strategylist" ]; then
 193                 echo "$__git_merge_strategylist"
 194                 return
 195         fi
 196         sed -n "/^all_strategies='/{
 197                 s/^all_strategies='//
 198                 s/'//
 199                 p
 200                 q
 201                 }" "$(git --exec-path)/git-merge"
 202 }
 203 __git_merge_strategylist=
 204 __git_merge_strategylist="$(__git_merge_strategies 2>/dev/null)"
 205
 206 __git_complete_file ()
 207 {
 208         local pfx ls ref cur="${COMP_WORDS[COMP_CWORD]}"
 209         case "$cur" in
 210         ?*:*)
 211                 ref="${cur%%:*}"
 212                 cur="${cur#*:}"
 213                 case "$cur" in
 214                 ?*/*)
 215                         pfx="${cur%/*}"
 216                         cur="${cur##*/}"
 217                         ls="$ref:$pfx"
 218                         pfx="$pfx/"
 219                         ;;
 220                 *)
 221                         ls="$ref"
 222                         ;;
 223             esac
 224                 COMPREPLY=($(compgen -P "$pfx" \
 225                         -W "$(git --git-dir="$(__gitdir)" ls-tree "$ls" \
 226                                 | sed '/^100... blob /s,^.*     ,,
 227                                        /^040000 tree /{
 228                                            s,^.*        ,,
 229                                            s,$,/,
 230                                        }
 231                                        s/^.*    //')" \
 232                         -- "$cur"))
 233                 ;;
 234         *)
 235                 __gitcomp "$(__git_refs)"
 236                 ;;
 237         esac
 238 }
 239
 240 __git_complete_revlist ()
 241 {
 242         local pfx cur="${COMP_WORDS[COMP_CWORD]}"
 243         case "$cur" in
 244         *...*)
 245                 pfx="${cur%...*}..."
 246                 cur="${cur#*...}"
 247                 __gitcomp "$(__git_refs)" "$pfx" "$cur"
 248                 ;;
 249         *..*)
 250                 pfx="${cur%..*}.."
 251                 cur="${cur#*..}"
 252                 __gitcomp "$(__git_refs)" "$pfx" "$cur"
 253                 ;;
 254         *.)
 255                 __gitcomp "$cur."
 256                 ;;
 257         *)
 258                 __gitcomp "$(__git_refs)"
 259                 ;;
 260         esac
 261 }
 262
 263 __git_commands ()
 264 {
 265         if [ -n "$__git_commandlist" ]; then
 266                 echo "$__git_commandlist"
 267                 return
 268         fi
 269         local i IFS=" "$'\n'
 270         for i in $(git help -a|egrep '^ ')
 271         do
 272                 case $i in
 273                 add--interactive) : plumbing;;
 274                 applymbox)        : ask gittus;;
 275                 applypatch)       : ask gittus;;
 276                 archimport)       : import;;
 277                 cat-file)         : plumbing;;
 278                 check-attr)       : plumbing;;
 279                 check-ref-format) : plumbing;;
 280                 commit-tree)      : plumbing;;
 281                 convert-objects)  : plumbing;;
 282                 cvsexportcommit)  : export;;
 283                 cvsimport)        : import;;
 284                 cvsserver)        : daemon;;
 285                 daemon)           : daemon;;
 286                 diff-files)       : plumbing;;
 287                 diff-index)       : plumbing;;
 288                 diff-tree)        : plumbing;;
 289                 fast-import)      : import;;
 290                 fsck-objects)     : plumbing;;
 291                 fetch--tool)      : plumbing;;
 292                 fetch-pack)       : plumbing;;
 293                 fmt-merge-msg)    : plumbing;;
 294                 for-each-ref)     : plumbing;;
 295                 hash-object)      : plumbing;;
 296                 http-*)           : transport;;
 297                 index-pack)       : plumbing;;
 298                 init-db)          : deprecated;;
 299                 local-fetch)      : plumbing;;
 300                 mailinfo)         : plumbing;;
 301                 mailsplit)        : plumbing;;
 302                 merge-*)          : plumbing;;
 303                 mktree)           : plumbing;;
 304                 mktag)            : plumbing;;
 305                 pack-objects)     : plumbing;;
 306                 pack-redundant)   : plumbing;;
 307                 pack-refs)        : plumbing;;
 308                 parse-remote)     : plumbing;;
 309                 patch-id)         : plumbing;;
 310                 peek-remote)      : plumbing;;
 311                 prune)            : plumbing;;
 312                 prune-packed)     : plumbing;;
 313                 quiltimport)      : import;;
 314                 read-tree)        : plumbing;;
 315                 receive-pack)     : plumbing;;
 316                 reflog)           : plumbing;;
 317                 repo-config)      : plumbing;;
 318                 rerere)           : plumbing;;
 319                 rev-list)         : plumbing;;
 320                 rev-parse)        : plumbing;;
 321                 runstatus)        : plumbing;;
 322                 sh-setup)         : internal;;
 323                 shell)            : daemon;;
 324                 send-pack)        : plumbing;;
 325                 show-index)       : plumbing;;
 326                 ssh-*)            : transport;;
 327                 stripspace)       : plumbing;;
 328                 svn)              : import export;;
 329                 svnimport)        : import;;
 330                 symbolic-ref)     : plumbing;;
 331                 tar-tree)         : deprecated;;
 332                 unpack-file)      : plumbing;;
 333                 unpack-objects)   : plumbing;;
 334                 update-index)     : plumbing;;
 335                 update-ref)       : plumbing;;
 336                 update-server-info) : daemon;;
 337                 upload-archive)   : plumbing;;
 338                 upload-pack)      : plumbing;;
 339                 write-tree)       : plumbing;;
 340                 verify-tag)       : plumbing;;
 341                 *) echo $i;;
 342                 esac
 343         done
 344 }
 345 __git_commandlist=
 346 __git_commandlist="$(__git_commands 2>/dev/null)"
 347
 348 __git_aliases ()
 349 {
 350         local i IFS=$'\n'
 351         for i in $(git --git-dir="$(__gitdir)" config --list); do
 352                 case "$i" in
 353                 alias.*)
 354                         i="${i#alias.}"
 355                         echo "${i/=*/}"
 356                         ;;
 357                 esac
 358         done
 359 }
 360
 361 __git_aliased_command ()
 362 {
 363         local word cmdline=$(git --git-dir="$(__gitdir)" \
 364                 config --get "alias.$1")
 365         for word in $cmdline; do
 366                 if [ "${word##-*}" ]; then
 367                         echo $word
 368                         return
 369                 fi
 370         done
 371 }
 372
 373 __git_whitespacelist="nowarn warn error error-all strip"
 374
 375 _git_am ()
 376 {
 377         local cur="${COMP_WORDS[COMP_CWORD]}"
 378         if [ -d .dotest ]; then
 379                 __gitcomp "--skip --resolved"
 380                 return
 381         fi
 382         case "$cur" in
 383         --whitespace=*)
 384                 __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
 385                 return
 386                 ;;
 387         --*)
 388                 __gitcomp "
 389                         --signoff --utf8 --binary --3way --interactive
 390                         --whitespace=
 391                         "
 392                 return
 393         esac
 394         COMPREPLY=()
 395 }
 396
 397 _git_apply ()
 398 {
 399         local cur="${COMP_WORDS[COMP_CWORD]}"
 400         case "$cur" in
 401         --whitespace=*)
 402                 __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
 403                 return
 404                 ;;
 405         --*)
 406                 __gitcomp "
 407                         --stat --numstat --summary --check --index
 408                         --cached --index-info --reverse --reject --unidiff-zero
 409                         --apply --no-add --exclude=
 410                         --whitespace= --inaccurate-eof --verbose
 411                         "
 412                 return
 413         esac
 414         COMPREPLY=()
 415 }
 416
 417 _git_add ()
 418 {
 419         local cur="${COMP_WORDS[COMP_CWORD]}"
 420         case "$cur" in
 421         --*)
 422                 __gitcomp "--interactive"
 423                 return
 424         esac
 425         COMPREPLY=()
 426 }
 427
 428 _git_bisect ()
 429 {
 430         local i c=1 command
 431         while [ $c -lt $COMP_CWORD ]; do
 432                 i="${COMP_WORDS[c]}"
 433                 case "$i" in
 434                 start|bad|good|reset|visualize|replay|log)
 435                         command="$i"
 436                         break
 437                         ;;
 438                 esac
 439                 c=$((++c))
 440         done
 441
 442         if [ $c -eq $COMP_CWORD -a -z "$command" ]; then
 443                 __gitcomp "start bad good reset visualize replay log"
 444                 return
 445         fi
 446
 447         case "$command" in
 448         bad|good|reset)
 449                 __gitcomp "$(__git_refs)"
 450                 ;;
 451         *)
 452                 COMPREPLY=()
 453                 ;;
 454         esac
 455 }
 456
 457 _git_branch ()
 458 {
 459         __gitcomp "$(__git_refs)"
 460 }
 461
 462 _git_bundle ()
 463 {
 464         local mycword="$COMP_CWORD"
 465         case "${COMP_WORDS[0]}" in
 466         git)
 467                 local cmd="${COMP_WORDS[2]}"
 468                 mycword="$((mycword-1))"
 469                 ;;
 470         git-bundle*)
 471                 local cmd="${COMP_WORDS[1]}"
 472                 ;;
 473         esac
 474         case "$mycword" in
 475         1)
 476                 __gitcomp "create list-heads verify unbundle"
 477                 ;;
 478         2)
 479                 # looking for a file
 480                 ;;
 481         *)
 482                 case "$cmd" in
 483                         create)
 484                                 __git_complete_revlist
 485                         ;;
 486                 esac
 487                 ;;
 488         esac
 489 }
 490
 491 _git_checkout ()
 492 {
 493         __gitcomp "$(__git_refs)"
 494 }
 495
 496 _git_cherry ()
 497 {
 498         __gitcomp "$(__git_refs)"
 499 }
 500
 501 _git_cherry_pick ()
 502 {
 503         local cur="${COMP_WORDS[COMP_CWORD]}"
 504         case "$cur" in
 505         --*)
 506                 __gitcomp "--edit --no-commit"
 507                 ;;
 508         *)
 509                 __gitcomp "$(__git_refs)"
 510                 ;;
 511         esac
 512 }
 513
 514 _git_commit ()
 515 {
 516         local cur="${COMP_WORDS[COMP_CWORD]}"
 517         case "$cur" in
 518         --*)
 519                 __gitcomp "
 520                         --all --author= --signoff --verify --no-verify
 521                         --edit --amend --include --only
 522                         "
 523                 return
 524         esac
 525         COMPREPLY=()
 526 }
 527
 528 _git_diff ()
 529 {
 530         __git_complete_file
 531 }
 532
 533 _git_diff_tree ()
 534 {
 535         __gitcomp "$(__git_refs)"
 536 }
 537
 538 _git_fetch ()
 539 {
 540         local cur="${COMP_WORDS[COMP_CWORD]}"
 541
 542         case "${COMP_WORDS[0]},$COMP_CWORD" in
 543         git-fetch*,1)
 544                 __gitcomp "$(__git_remotes)"
 545                 ;;
 546         git,2)
 547                 __gitcomp "$(__git_remotes)"
 548                 ;;
 549         *)
 550                 case "$cur" in
 551                 *:*)
 552                         __gitcomp "$(__git_refs)" "" "${cur#*:}"
 553                         ;;
 554                 *)
 555                         local remote
 556                         case "${COMP_WORDS[0]}" in
 557                         git-fetch) remote="${COMP_WORDS[1]}" ;;
 558                         git)       remote="${COMP_WORDS[2]}" ;;
 559                         esac
 560                         __gitcomp "$(__git_refs2 "$remote")"
 561                         ;;
 562                 esac
 563                 ;;
 564         esac
 565 }
 566
 567 _git_format_patch ()
 568 {
 569         local cur="${COMP_WORDS[COMP_CWORD]}"
 570         case "$cur" in
 571         --*)
 572                 __gitcomp "
 573                         --stdout --attach --thread
 574                         --output-directory
 575                         --numbered --start-number
 576                         --keep-subject
 577                         --signoff
 578                         --in-reply-to=
 579                         --full-index --binary
 580                         --not --all
 581                         "
 582                 return
 583                 ;;
 584         esac
 585         __git_complete_revlist
 586 }
 587
 588 _git_gc ()
 589 {
 590         local cur="${COMP_WORDS[COMP_CWORD]}"
 591         case "$cur" in
 592         --*)
 593                 __gitcomp "--prune"
 594                 return
 595                 ;;
 596         esac
 597         COMPREPLY=()
 598 }
 599
 600 _git_ls_remote ()
 601 {
 602         __gitcomp "$(__git_remotes)"
 603 }
 604
 605 _git_ls_tree ()
 606 {
 607         __git_complete_file
 608 }
 609
 610 _git_log ()
 611 {
 612         local cur="${COMP_WORDS[COMP_CWORD]}"
 613         case "$cur" in
 614         --pretty=*)
 615                 __gitcomp "
 616                         oneline short medium full fuller email raw
 617                         " "" "${cur##--pretty=}"
 618                 return
 619                 ;;
 620         --*)
 621                 __gitcomp "
 622                         --max-count= --max-age= --since= --after=
 623                         --min-age= --before= --until=
 624                         --root --topo-order --date-order --reverse
 625                         --no-merges
 626                         --abbrev-commit --abbrev=
 627                         --relative-date
 628                         --author= --committer= --grep=
 629                         --all-match
 630                         --pretty= --name-status --name-only --raw
 631                         --not --all
 632                         "
 633                 return
 634                 ;;
 635         esac
 636         __git_complete_revlist
 637 }
 638
 639 _git_merge ()
 640 {
 641         local cur="${COMP_WORDS[COMP_CWORD]}"
 642         case "${COMP_WORDS[COMP_CWORD-1]}" in
 643         -s|--strategy)
 644                 __gitcomp "$(__git_merge_strategies)"
 645                 return
 646         esac
 647         case "$cur" in
 648         --strategy=*)
 649                 __gitcomp "$(__git_merge_strategies)" "" "${cur##--strategy=}"
 650                 return
 651                 ;;
 652         --*)
 653                 __gitcomp "
 654                         --no-commit --no-summary --squash --strategy
 655                         "
 656                 return
 657         esac
 658         __gitcomp "$(__git_refs)"
 659 }
 660
 661 _git_merge_base ()
 662 {
 663         __gitcomp "$(__git_refs)"
 664 }
 665
 666 _git_name_rev ()
 667 {
 668         __gitcomp "--tags --all --stdin"
 669 }
 670
 671 _git_pull ()
 672 {
 673         local cur="${COMP_WORDS[COMP_CWORD]}"
 674
 675         case "${COMP_WORDS[0]},$COMP_CWORD" in
 676         git-pull*,1)
 677                 __gitcomp "$(__git_remotes)"
 678                 ;;
 679         git,2)
 680                 __gitcomp "$(__git_remotes)"
 681                 ;;
 682         *)
 683                 local remote
 684                 case "${COMP_WORDS[0]}" in
 685                 git-pull)  remote="${COMP_WORDS[1]}" ;;
 686                 git)       remote="${COMP_WORDS[2]}" ;;
 687                 esac
 688                 __gitcomp "$(__git_refs "$remote")"
 689                 ;;
 690         esac
 691 }
 692
 693 _git_push ()
 694 {
 695         local cur="${COMP_WORDS[COMP_CWORD]}"
 696
 697         case "${COMP_WORDS[0]},$COMP_CWORD" in
 698         git-push*,1)
 699                 __gitcomp "$(__git_remotes)"
 700                 ;;
 701         git,2)
 702                 __gitcomp "$(__git_remotes)"
 703                 ;;
 704         *)
 705                 case "$cur" in
 706                 *:*)
 707                         local remote
 708                         case "${COMP_WORDS[0]}" in
 709                         git-push)  remote="${COMP_WORDS[1]}" ;;
 710                         git)       remote="${COMP_WORDS[2]}" ;;
 711                         esac
 712                         __gitcomp "$(__git_refs "$remote")" "" "${cur#*:}"
 713                         ;;
 714                 +*)
 715                         __gitcomp "$(__git_refs)" + "${cur#+}"
 716                         ;;
 717                 *)
 718                         __gitcomp "$(__git_refs)"
 719                         ;;
 720                 esac
 721                 ;;
 722         esac
 723 }
 724
 725 _git_rebase ()
 726 {
 727         local cur="${COMP_WORDS[COMP_CWORD]}"
 728         if [ -d .dotest ] || [ -d .git/.dotest-merge ]; then
 729                 __gitcomp "--continue --skip --abort"
 730                 return
 731         fi
 732         case "${COMP_WORDS[COMP_CWORD-1]}" in
 733         -s|--strategy)
 734                 __gitcomp "$(__git_merge_strategies)"
 735                 return
 736         esac
 737         case "$cur" in
 738         --strategy=*)
 739                 __gitcomp "$(__git_merge_strategies)" "" "${cur##--strategy=}"
 740                 return
 741                 ;;
 742         --*)
 743                 __gitcomp "--onto --merge --strategy"
 744                 return
 745         esac
 746         __gitcomp "$(__git_refs)"
 747 }
 748
 749 _git_config ()
 750 {
 751         local cur="${COMP_WORDS[COMP_CWORD]}"
 752         local prv="${COMP_WORDS[COMP_CWORD-1]}"
 753         case "$prv" in
 754         branch.*.remote)
 755                 __gitcomp "$(__git_remotes)"
 756                 return
 757                 ;;
 758         branch.*.merge)
 759                 __gitcomp "$(__git_refs)"
 760                 return
 761                 ;;
 762         remote.*.fetch)
 763                 local remote="${prv#remote.}"
 764                 remote="${remote%.fetch}"
 765                 __gitcomp "$(__git_refs_remotes "$remote")"
 766                 return
 767                 ;;
 768         remote.*.push)
 769                 local remote="${prv#remote.}"
 770                 remote="${remote%.push}"
 771                 __gitcomp "$(git --git-dir="$(__gitdir)" \
 772                         for-each-ref --format='%(refname):%(refname)' \
 773                         refs/heads)"
 774                 return
 775                 ;;
 776         pull.twohead|pull.octopus)
 777                 __gitcomp "$(__git_merge_strategies)"
 778                 return
 779                 ;;
 780         color.branch|color.diff|color.status)
 781                 __gitcomp "always never auto"
 782                 return
 783                 ;;
 784         color.*.*)
 785                 __gitcomp "
 786                         black red green yellow blue magenta cyan white
 787                         bold dim ul blink reverse
 788                         "
 789                 return
 790                 ;;
 791         *.*)
 792                 COMPREPLY=()
 793                 return
 794                 ;;
 795         esac
 796         case "$cur" in
 797         --*)
 798                 __gitcomp "
 799                         --global --system
 800                         --list --replace-all
 801                         --get --get-all --get-regexp
 802                         --add --unset --unset-all
 803                         --remove-section --rename-section
 804                         "
 805                 return
 806                 ;;
 807         branch.*.*)
 808                 local pfx="${cur%.*}."
 809                 cur="${cur##*.}"
 810                 __gitcomp "remote merge" "$pfx" "$cur"
 811                 return
 812                 ;;
 813         branch.*)
 814                 local pfx="${cur%.*}."
 815                 cur="${cur#*.}"
 816                 __gitcomp "$(__git_heads)" "$pfx" "$cur" "."
 817                 return
 818                 ;;
 819         remote.*.*)
 820                 local pfx="${cur%.*}."
 821                 cur="${cur##*.}"
 822                 __gitcomp "
 823                         url fetch push skipDefaultUpdate
 824                         receivepack uploadpack tagopt
 825                         " "$pfx" "$cur"
 826                 return
 827                 ;;
 828         remote.*)
 829                 local pfx="${cur%.*}."
 830                 cur="${cur#*.}"
 831                 __gitcomp "$(__git_remotes)" "$pfx" "$cur" "."
 832                 return
 833                 ;;
 834         esac
 835         __gitcomp "
 836                 apply.whitespace
 837                 core.fileMode
 838                 core.gitProxy
 839                 core.ignoreStat
 840                 core.preferSymlinkRefs
 841                 core.logAllRefUpdates
 842                 core.repositoryFormatVersion
 843                 core.sharedRepository
 844                 core.warnAmbiguousRefs
 845                 core.compression
 846                 core.legacyHeaders
 847                 core.packedGitWindowSize
 848                 core.packedGitLimit
 849                 clean.requireForce
 850                 color.branch
 851                 color.branch.current
 852                 color.branch.local
 853                 color.branch.remote
 854                 color.branch.plain
 855                 color.diff
 856                 color.diff.plain
 857                 color.diff.meta
 858                 color.diff.frag
 859                 color.diff.old
 860                 color.diff.new
 861                 color.diff.commit
 862                 color.diff.whitespace
 863                 color.pager
 864                 color.status
 865                 color.status.header
 866                 color.status.added
 867                 color.status.changed
 868                 color.status.untracked
 869                 diff.renameLimit
 870                 diff.renames
 871                 fetch.unpackLimit
 872                 format.headers
 873                 gitcvs.enabled
 874                 gitcvs.logfile
 875                 gitcvs.allbinary
 876                 gitcvs.dbname gitcvs.dbdriver gitcvs.dbuser gitcvs.dvpass
 877                 gc.packrefs
 878                 gc.reflogexpire
 879                 gc.reflogexpireunreachable
 880                 gc.rerereresolved
 881                 gc.rerereunresolved
 882                 http.sslVerify
 883                 http.sslCert
 884                 http.sslKey
 885                 http.sslCAInfo
 886                 http.sslCAPath
 887                 http.maxRequests
 888                 http.lowSpeedLimit
 889                 http.lowSpeedTime
 890                 http.noEPSV
 891                 i18n.commitEncoding
 892                 i18n.logOutputEncoding
 893                 log.showroot
 894                 merge.tool
 895                 merge.summary
 896                 merge.verbosity
 897                 pack.window
 898                 pack.depth
 899                 pull.octopus
 900                 pull.twohead
 901                 repack.useDeltaBaseOffset
 902                 show.difftree
 903                 showbranch.default
 904                 tar.umask
 905                 transfer.unpackLimit
 906                 receive.unpackLimit
 907                 receive.denyNonFastForwards
 908                 user.name
 909                 user.email
 910                 user.signingkey
 911                 whatchanged.difftree
 912                 branch. remote.
 913         "
 914 }
 915
 916 _git_remote ()
 917 {
 918         local i c=1 command
 919         while [ $c -lt $COMP_CWORD ]; do
 920                 i="${COMP_WORDS[c]}"
 921                 case "$i" in
 922                 add|show|prune|update) command="$i"; break ;;
 923                 esac
 924                 c=$((++c))
 925         done
 926
 927         if [ $c -eq $COMP_CWORD -a -z "$command" ]; then
 928                 __gitcomp "add show prune update"
 929                 return
 930         fi
 931
 932         case "$command" in
 933         show|prune)
 934                 __gitcomp "$(__git_remotes)"
 935                 ;;
 936         update)
 937                 local i c='' IFS=$'\n'
 938                 for i in $(git --git-dir="$(__gitdir)" config --list); do
 939                         case "$i" in
 940                         remotes.*)
 941                                 i="${i#remotes.}"
 942                                 c="$c ${i/=*/}"
 943                                 ;;
 944                         esac
 945                 done
 946                 __gitcomp "$c"
 947                 ;;
 948         *)
 949                 COMPREPLY=()
 950                 ;;
 951         esac
 952 }
 953
 954 _git_reset ()
 955 {
 956         local cur="${COMP_WORDS[COMP_CWORD]}"
 957         case "$cur" in
 958         --*)
 959                 __gitcomp "--mixed --hard --soft"
 960                 return
 961                 ;;
 962         esac
 963         __gitcomp "$(__git_refs)"
 964 }
 965
 966 _git_shortlog ()
 967 {
 968         local cur="${COMP_WORDS[COMP_CWORD]}"
 969         case "$cur" in
 970         --*)
 971                 __gitcomp "
 972                         --max-count= --max-age= --since= --after=
 973                         --min-age= --before= --until=
 974                         --no-merges
 975                         --author= --committer= --grep=
 976                         --all-match
 977                         --not --all
 978                         --numbered --summary
 979                         "
 980                 return
 981                 ;;
 982         esac
 983         __git_complete_revlist
 984 }
 985
 986 _git_show ()
 987 {
 988         local cur="${COMP_WORDS[COMP_CWORD]}"
 989         case "$cur" in
 990         --pretty=*)
 991                 __gitcomp "
 992                         oneline short medium full fuller email raw
 993                         " "" "${cur##--pretty=}"
 994                 return
 995                 ;;
 996         --*)
 997                 __gitcomp "--pretty="
 998                 return
 999                 ;;
1000         esac
1001         __git_complete_file
1002 }
1003
1004 _git_stash ()
1005 {
1006         __gitcomp 'list show apply clear'
1007 }
1008
1009 _git ()
1010 {
1011         local i c=1 command __git_dir
1012
1013         while [ $c -lt $COMP_CWORD ]; do
1014                 i="${COMP_WORDS[c]}"
1015                 case "$i" in
1016                 --git-dir=*) __git_dir="${i#--git-dir=}" ;;
1017                 --bare)      __git_dir="." ;;
1018                 --version|--help|-p|--paginate) ;;
1019                 *) command="$i"; break ;;
1020                 esac
1021                 c=$((++c))
1022         done
1023
1024         if [ $c -eq $COMP_CWORD -a -z "$command" ]; then
1025                 case "${COMP_WORDS[COMP_CWORD]}" in
1026                 --*=*) COMPREPLY=() ;;
1027                 --*)   __gitcomp "--git-dir= --bare --version --exec-path" ;;
1028                 *)     __gitcomp "$(__git_commands) $(__git_aliases)" ;;
1029                 esac
1030                 return
1031         fi
1032
1033         local expansion=$(__git_aliased_command "$command")
1034         [ "$expansion" ] && command="$expansion"
1035
1036         case "$command" in
1037         am)          _git_am ;;
1038         add)         _git_add ;;
1039         apply)       _git_apply ;;
1040         bisect)      _git_bisect ;;
1041         bundle)      _git_bundle ;;
1042         branch)      _git_branch ;;
1043         checkout)    _git_checkout ;;
1044         cherry)      _git_cherry ;;
1045         cherry-pick) _git_cherry_pick ;;
1046         commit)      _git_commit ;;
1047         config)      _git_config ;;
1048         diff)        _git_diff ;;
1049         fetch)       _git_fetch ;;
1050         format-patch) _git_format_patch ;;
1051         gc)          _git_gc ;;
1052         log)         _git_log ;;
1053         ls-remote)   _git_ls_remote ;;
1054         ls-tree)     _git_ls_tree ;;
1055         merge)       _git_merge;;
1056         merge-base)  _git_merge_base ;;
1057         name-rev)    _git_name_rev ;;
1058         pull)        _git_pull ;;
1059         push)        _git_push ;;
1060         rebase)      _git_rebase ;;
1061         remote)      _git_remote ;;
1062         reset)       _git_reset ;;
1063         shortlog)    _git_shortlog ;;
1064         show)        _git_show ;;
1065         show-branch) _git_log ;;
1066         stash)       _git_stash ;;
1067         whatchanged) _git_log ;;
1068         *)           COMPREPLY=() ;;
1069         esac
1070 }
1071
1072 _gitk ()
1073 {
1074         local cur="${COMP_WORDS[COMP_CWORD]}"
1075         case "$cur" in
1076         --*)
1077                 __gitcomp "--not --all"
1078                 return
1079                 ;;
1080         esac
1081         __git_complete_revlist
1082 }
1083
1084 complete -o default -o nospace -F _git git
1085 complete -o default -o nospace -F _gitk gitk
1086 complete -o default -o nospace -F _git_am git-am
1087 complete -o default -o nospace -F _git_apply git-apply
1088 complete -o default -o nospace -F _git_bisect git-bisect
1089 complete -o default -o nospace -F _git_branch git-branch
1090 complete -o default -o nospace -F _git_bundle git-bundle
1091 complete -o default -o nospace -F _git_checkout git-checkout
1092 complete -o default -o nospace -F _git_cherry git-cherry
1093 complete -o default -o nospace -F _git_cherry_pick git-cherry-pick
1094 complete -o default -o nospace -F _git_commit git-commit
1095 complete -o default -o nospace -F _git_diff git-diff
1096 complete -o default -o nospace -F _git_fetch git-fetch
1097 complete -o default -o nospace -F _git_format_patch git-format-patch
1098 complete -o default -o nospace -F _git_gc git-gc
1099 complete -o default -o nospace -F _git_log git-log
1100 complete -o default -o nospace -F _git_ls_remote git-ls-remote
1101 complete -o default -o nospace -F _git_ls_tree git-ls-tree
1102 complete -o default -o nospace -F _git_merge git-merge
1103 complete -o default -o nospace -F _git_merge_base git-merge-base
1104 complete -o default -o nospace -F _git_name_rev git-name-rev
1105 complete -o default -o nospace -F _git_pull git-pull
1106 complete -o default -o nospace -F _git_push git-push
1107 complete -o default -o nospace -F _git_rebase git-rebase
1108 complete -o default -o nospace -F _git_config git-config
1109 complete -o default -o nospace -F _git_remote git-remote
1110 complete -o default -o nospace -F _git_reset git-reset
1111 complete -o default -o nospace -F _git_shortlog git-shortlog
1112 complete -o default -o nospace -F _git_show git-show
1113 complete -o default -o nospace -F _git_stash git-stash
1114 complete -o default -o nospace -F _git_log git-show-branch
1115 complete -o default -o nospace -F _git_log git-whatchanged
1116
1117 # The following are necessary only for Cygwin, and only are needed
1118 # when the user has tab-completed the executable name and consequently
1119 # included the '.exe' suffix.
1120 #
1121 if [ Cygwin = "$(uname -o 2>/dev/null)" ]; then
1122 complete -o default -o nospace -F _git_add git-add.exe
1123 complete -o default -o nospace -F _git_apply git-apply.exe
1124 complete -o default -o nospace -F _git git.exe
1125 complete -o default -o nospace -F _git_branch git-branch.exe
1126 complete -o default -o nospace -F _git_bundle git-bundle.exe
1127 complete -o default -o nospace -F _git_cherry git-cherry.exe
1128 complete -o default -o nospace -F _git_diff git-diff.exe
1129 complete -o default -o nospace -F _git_format_patch git-format-patch.exe
1130 complete -o default -o nospace -F _git_log git-log.exe
1131 complete -o default -o nospace -F _git_ls_tree git-ls-tree.exe
1132 complete -o default -o nospace -F _git_merge_base git-merge-base.exe
1133 complete -o default -o nospace -F _git_name_rev git-name-rev.exe
1134 complete -o default -o nospace -F _git_push git-push.exe
1135 complete -o default -o nospace -F _git_config git-config
1136 complete -o default -o nospace -F _git_shortlog git-shortlog.exe
1137 complete -o default -o nospace -F _git_show git-show.exe
1138 complete -o default -o nospace -F _git_log git-show-branch.exe
1139 complete -o default -o nospace -F _git_log git-whatchanged.exe
1140 fi