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 --refresh"
 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_describe ()
 529 {
 530         __gitcomp "$(__git_refs)"
 531 }
 532
 533 _git_diff ()
 534 {
 535         __git_complete_file
 536 }
 537
 538 _git_diff_tree ()
 539 {
 540         __gitcomp "$(__git_refs)"
 541 }
 542
 543 _git_fetch ()
 544 {
 545         local cur="${COMP_WORDS[COMP_CWORD]}"
 546
 547         case "${COMP_WORDS[0]},$COMP_CWORD" in
 548         git-fetch*,1)
 549                 __gitcomp "$(__git_remotes)"
 550                 ;;
 551         git,2)
 552                 __gitcomp "$(__git_remotes)"
 553                 ;;
 554         *)
 555                 case "$cur" in
 556                 *:*)
 557                         __gitcomp "$(__git_refs)" "" "${cur#*:}"
 558                         ;;
 559                 *)
 560                         local remote
 561                         case "${COMP_WORDS[0]}" in
 562                         git-fetch) remote="${COMP_WORDS[1]}" ;;
 563                         git)       remote="${COMP_WORDS[2]}" ;;
 564                         esac
 565                         __gitcomp "$(__git_refs2 "$remote")"
 566                         ;;
 567                 esac
 568                 ;;
 569         esac
 570 }
 571
 572 _git_format_patch ()
 573 {
 574         local cur="${COMP_WORDS[COMP_CWORD]}"
 575         case "$cur" in
 576         --*)
 577                 __gitcomp "
 578                         --stdout --attach --thread
 579                         --output-directory
 580                         --numbered --start-number
 581                         --numbered-files
 582                         --keep-subject
 583                         --signoff
 584                         --in-reply-to=
 585                         --full-index --binary
 586                         --not --all
 587                         "
 588                 return
 589                 ;;
 590         esac
 591         __git_complete_revlist
 592 }
 593
 594 _git_gc ()
 595 {
 596         local cur="${COMP_WORDS[COMP_CWORD]}"
 597         case "$cur" in
 598         --*)
 599                 __gitcomp "--prune --aggressive"
 600                 return
 601                 ;;
 602         esac
 603         COMPREPLY=()
 604 }
 605
 606 _git_ls_remote ()
 607 {
 608         __gitcomp "$(__git_remotes)"
 609 }
 610
 611 _git_ls_tree ()
 612 {
 613         __git_complete_file
 614 }
 615
 616 _git_log ()
 617 {
 618         local cur="${COMP_WORDS[COMP_CWORD]}"
 619         case "$cur" in
 620         --pretty=*)
 621                 __gitcomp "
 622                         oneline short medium full fuller email raw
 623                         " "" "${cur##--pretty=}"
 624                 return
 625                 ;;
 626         --date=*)
 627                 __gitcomp "
 628                         relative iso8601 rfc2822 short local default
 629                 " "" "${cur##--date=}"
 630                 return
 631                 ;;
 632         --*)
 633                 __gitcomp "
 634                         --max-count= --max-age= --since= --after=
 635                         --min-age= --before= --until=
 636                         --root --topo-order --date-order --reverse
 637                         --no-merges --follow
 638                         --abbrev-commit --abbrev=
 639                         --relative-date --date=
 640                         --author= --committer= --grep=
 641                         --all-match
 642                         --pretty= --name-status --name-only --raw
 643                         --not --all
 644                         --left-right --cherry-pick
 645                         "
 646                 return
 647                 ;;
 648         esac
 649         __git_complete_revlist
 650 }
 651
 652 _git_merge ()
 653 {
 654         local cur="${COMP_WORDS[COMP_CWORD]}"
 655         case "${COMP_WORDS[COMP_CWORD-1]}" in
 656         -s|--strategy)
 657                 __gitcomp "$(__git_merge_strategies)"
 658                 return
 659         esac
 660         case "$cur" in
 661         --strategy=*)
 662                 __gitcomp "$(__git_merge_strategies)" "" "${cur##--strategy=}"
 663                 return
 664                 ;;
 665         --*)
 666                 __gitcomp "
 667                         --no-commit --no-summary --squash --strategy
 668                         "
 669                 return
 670         esac
 671         __gitcomp "$(__git_refs)"
 672 }
 673
 674 _git_merge_base ()
 675 {
 676         __gitcomp "$(__git_refs)"
 677 }
 678
 679 _git_name_rev ()
 680 {
 681         __gitcomp "--tags --all --stdin"
 682 }
 683
 684 _git_pull ()
 685 {
 686         local cur="${COMP_WORDS[COMP_CWORD]}"
 687
 688         case "${COMP_WORDS[0]},$COMP_CWORD" in
 689         git-pull*,1)
 690                 __gitcomp "$(__git_remotes)"
 691                 ;;
 692         git,2)
 693                 __gitcomp "$(__git_remotes)"
 694                 ;;
 695         *)
 696                 local remote
 697                 case "${COMP_WORDS[0]}" in
 698                 git-pull)  remote="${COMP_WORDS[1]}" ;;
 699                 git)       remote="${COMP_WORDS[2]}" ;;
 700                 esac
 701                 __gitcomp "$(__git_refs "$remote")"
 702                 ;;
 703         esac
 704 }
 705
 706 _git_push ()
 707 {
 708         local cur="${COMP_WORDS[COMP_CWORD]}"
 709
 710         case "${COMP_WORDS[0]},$COMP_CWORD" in
 711         git-push*,1)
 712                 __gitcomp "$(__git_remotes)"
 713                 ;;
 714         git,2)
 715                 __gitcomp "$(__git_remotes)"
 716                 ;;
 717         *)
 718                 case "$cur" in
 719                 *:*)
 720                         local remote
 721                         case "${COMP_WORDS[0]}" in
 722                         git-push)  remote="${COMP_WORDS[1]}" ;;
 723                         git)       remote="${COMP_WORDS[2]}" ;;
 724                         esac
 725                         __gitcomp "$(__git_refs "$remote")" "" "${cur#*:}"
 726                         ;;
 727                 +*)
 728                         __gitcomp "$(__git_refs)" + "${cur#+}"
 729                         ;;
 730                 *)
 731                         __gitcomp "$(__git_refs)"
 732                         ;;
 733                 esac
 734                 ;;
 735         esac
 736 }
 737
 738 _git_rebase ()
 739 {
 740         local cur="${COMP_WORDS[COMP_CWORD]}"
 741         if [ -d .dotest ] || [ -d .git/.dotest-merge ]; then
 742                 __gitcomp "--continue --skip --abort"
 743                 return
 744         fi
 745         case "${COMP_WORDS[COMP_CWORD-1]}" in
 746         -s|--strategy)
 747                 __gitcomp "$(__git_merge_strategies)"
 748                 return
 749         esac
 750         case "$cur" in
 751         --strategy=*)
 752                 __gitcomp "$(__git_merge_strategies)" "" "${cur##--strategy=}"
 753                 return
 754                 ;;
 755         --*)
 756                 __gitcomp "--onto --merge --strategy"
 757                 return
 758         esac
 759         __gitcomp "$(__git_refs)"
 760 }
 761
 762 _git_config ()
 763 {
 764         local cur="${COMP_WORDS[COMP_CWORD]}"
 765         local prv="${COMP_WORDS[COMP_CWORD-1]}"
 766         case "$prv" in
 767         branch.*.remote)
 768                 __gitcomp "$(__git_remotes)"
 769                 return
 770                 ;;
 771         branch.*.merge)
 772                 __gitcomp "$(__git_refs)"
 773                 return
 774                 ;;
 775         remote.*.fetch)
 776                 local remote="${prv#remote.}"
 777                 remote="${remote%.fetch}"
 778                 __gitcomp "$(__git_refs_remotes "$remote")"
 779                 return
 780                 ;;
 781         remote.*.push)
 782                 local remote="${prv#remote.}"
 783                 remote="${remote%.push}"
 784                 __gitcomp "$(git --git-dir="$(__gitdir)" \
 785                         for-each-ref --format='%(refname):%(refname)' \
 786                         refs/heads)"
 787                 return
 788                 ;;
 789         pull.twohead|pull.octopus)
 790                 __gitcomp "$(__git_merge_strategies)"
 791                 return
 792                 ;;
 793         color.branch|color.diff|color.status)
 794                 __gitcomp "always never auto"
 795                 return
 796                 ;;
 797         color.*.*)
 798                 __gitcomp "
 799                         black red green yellow blue magenta cyan white
 800                         bold dim ul blink reverse
 801                         "
 802                 return
 803                 ;;
 804         *.*)
 805                 COMPREPLY=()
 806                 return
 807                 ;;
 808         esac
 809         case "$cur" in
 810         --*)
 811                 __gitcomp "
 812                         --global --system --file=
 813                         --list --replace-all
 814                         --get --get-all --get-regexp
 815                         --add --unset --unset-all
 816                         --remove-section --rename-section
 817                         "
 818                 return
 819                 ;;
 820         branch.*.*)
 821                 local pfx="${cur%.*}."
 822                 cur="${cur##*.}"
 823                 __gitcomp "remote merge" "$pfx" "$cur"
 824                 return
 825                 ;;
 826         branch.*)
 827                 local pfx="${cur%.*}."
 828                 cur="${cur#*.}"
 829                 __gitcomp "$(__git_heads)" "$pfx" "$cur" "."
 830                 return
 831                 ;;
 832         remote.*.*)
 833                 local pfx="${cur%.*}."
 834                 cur="${cur##*.}"
 835                 __gitcomp "
 836                         url fetch push skipDefaultUpdate
 837                         receivepack uploadpack tagopt
 838                         " "$pfx" "$cur"
 839                 return
 840                 ;;
 841         remote.*)
 842                 local pfx="${cur%.*}."
 843                 cur="${cur#*.}"
 844                 __gitcomp "$(__git_remotes)" "$pfx" "$cur" "."
 845                 return
 846                 ;;
 847         esac
 848         __gitcomp "
 849                 apply.whitespace
 850                 core.fileMode
 851                 core.gitProxy
 852                 core.ignoreStat
 853                 core.preferSymlinkRefs
 854                 core.logAllRefUpdates
 855                 core.loosecompression
 856                 core.repositoryFormatVersion
 857                 core.sharedRepository
 858                 core.warnAmbiguousRefs
 859                 core.compression
 860                 core.legacyHeaders
 861                 core.packedGitWindowSize
 862                 core.packedGitLimit
 863                 clean.requireForce
 864                 color.branch
 865                 color.branch.current
 866                 color.branch.local
 867                 color.branch.remote
 868                 color.branch.plain
 869                 color.diff
 870                 color.diff.plain
 871                 color.diff.meta
 872                 color.diff.frag
 873                 color.diff.old
 874                 color.diff.new
 875                 color.diff.commit
 876                 color.diff.whitespace
 877                 color.pager
 878                 color.status
 879                 color.status.header
 880                 color.status.added
 881                 color.status.changed
 882                 color.status.untracked
 883                 diff.renameLimit
 884                 diff.renames
 885                 fetch.unpackLimit
 886                 format.headers
 887                 format.subjectprefix
 888                 gitcvs.enabled
 889                 gitcvs.logfile
 890                 gitcvs.allbinary
 891                 gitcvs.dbname gitcvs.dbdriver gitcvs.dbuser gitcvs.dvpass
 892                 gc.packrefs
 893                 gc.reflogexpire
 894                 gc.reflogexpireunreachable
 895                 gc.rerereresolved
 896                 gc.rerereunresolved
 897                 http.sslVerify
 898                 http.sslCert
 899                 http.sslKey
 900                 http.sslCAInfo
 901                 http.sslCAPath
 902                 http.maxRequests
 903                 http.lowSpeedLimit
 904                 http.lowSpeedTime
 905                 http.noEPSV
 906                 i18n.commitEncoding
 907                 i18n.logOutputEncoding
 908                 log.showroot
 909                 merge.tool
 910                 merge.summary
 911                 merge.verbosity
 912                 pack.window
 913                 pack.depth
 914                 pack.windowMemory
 915                 pack.compression
 916                 pack.deltaCacheSize
 917                 pack.deltaCacheLimit
 918                 pull.octopus
 919                 pull.twohead
 920                 repack.useDeltaBaseOffset
 921                 show.difftree
 922                 showbranch.default
 923                 tar.umask
 924                 transfer.unpackLimit
 925                 receive.unpackLimit
 926                 receive.denyNonFastForwards
 927                 user.name
 928                 user.email
 929                 user.signingkey
 930                 whatchanged.difftree
 931                 branch. remote.
 932         "
 933 }
 934
 935 _git_remote ()
 936 {
 937         local i c=1 command
 938         while [ $c -lt $COMP_CWORD ]; do
 939                 i="${COMP_WORDS[c]}"
 940                 case "$i" in
 941                 add|show|prune|update) command="$i"; break ;;
 942                 esac
 943                 c=$((++c))
 944         done
 945
 946         if [ $c -eq $COMP_CWORD -a -z "$command" ]; then
 947                 __gitcomp "add show prune update"
 948                 return
 949         fi
 950
 951         case "$command" in
 952         show|prune)
 953                 __gitcomp "$(__git_remotes)"
 954                 ;;
 955         update)
 956                 local i c='' IFS=$'\n'
 957                 for i in $(git --git-dir="$(__gitdir)" config --list); do
 958                         case "$i" in
 959                         remotes.*)
 960                                 i="${i#remotes.}"
 961                                 c="$c ${i/=*/}"
 962                                 ;;
 963                         esac
 964                 done
 965                 __gitcomp "$c"
 966                 ;;
 967         *)
 968                 COMPREPLY=()
 969                 ;;
 970         esac
 971 }
 972
 973 _git_reset ()
 974 {
 975         local cur="${COMP_WORDS[COMP_CWORD]}"
 976         case "$cur" in
 977         --*)
 978                 __gitcomp "--mixed --hard --soft"
 979                 return
 980                 ;;
 981         esac
 982         __gitcomp "$(__git_refs)"
 983 }
 984
 985 _git_shortlog ()
 986 {
 987         local cur="${COMP_WORDS[COMP_CWORD]}"
 988         case "$cur" in
 989         --*)
 990                 __gitcomp "
 991                         --max-count= --max-age= --since= --after=
 992                         --min-age= --before= --until=
 993                         --no-merges
 994                         --author= --committer= --grep=
 995                         --all-match
 996                         --not --all
 997                         --numbered --summary
 998                         "
 999                 return
1000                 ;;
1001         esac
1002         __git_complete_revlist
1003 }
1004
1005 _git_show ()
1006 {
1007         local cur="${COMP_WORDS[COMP_CWORD]}"
1008         case "$cur" in
1009         --pretty=*)
1010                 __gitcomp "
1011                         oneline short medium full fuller email raw
1012                         " "" "${cur##--pretty=}"
1013                 return
1014                 ;;
1015         --*)
1016                 __gitcomp "--pretty="
1017                 return
1018                 ;;
1019         esac
1020         __git_complete_file
1021 }
1022
1023 _git_stash ()
1024 {
1025         __gitcomp 'list show apply clear'
1026 }
1027
1028 _git_submodule ()
1029 {
1030         local i c=1 command
1031         while [ $c -lt $COMP_CWORD ]; do
1032                 i="${COMP_WORDS[c]}"
1033                 case "$i" in
1034                 add|status|init|update) command="$i"; break ;;
1035                 esac
1036                 c=$((++c))
1037         done
1038
1039         if [ $c -eq $COMP_CWORD -a -z "$command" ]; then
1040                 local cur="${COMP_WORDS[COMP_CWORD]}"
1041                 case "$cur" in
1042                 --*)
1043                         __gitcomp "--quiet --cached"
1044                         ;;
1045                 *)
1046                         __gitcomp "add status init update"
1047                         ;;
1048                 esac
1049                 return
1050         fi
1051 }
1052
1053 _git ()
1054 {
1055         local i c=1 command __git_dir
1056
1057         while [ $c -lt $COMP_CWORD ]; do
1058                 i="${COMP_WORDS[c]}"
1059                 case "$i" in
1060                 --git-dir=*) __git_dir="${i#--git-dir=}" ;;
1061                 --bare)      __git_dir="." ;;
1062                 --version|--help|-p|--paginate) ;;
1063                 *) command="$i"; break ;;
1064                 esac
1065                 c=$((++c))
1066         done
1067
1068         if [ $c -eq $COMP_CWORD -a -z "$command" ]; then
1069                 case "${COMP_WORDS[COMP_CWORD]}" in
1070                 --*=*) COMPREPLY=() ;;
1071                 --*)   __gitcomp "
1072                         --no-pager
1073                         --git-dir=
1074                         --bare
1075                         --version
1076                         --exec-path
1077                         "
1078                         ;;
1079                 *)     __gitcomp "$(__git_commands) $(__git_aliases)" ;;
1080                 esac
1081                 return
1082         fi
1083
1084         local expansion=$(__git_aliased_command "$command")
1085         [ "$expansion" ] && command="$expansion"
1086
1087         case "$command" in
1088         am)          _git_am ;;
1089         add)         _git_add ;;
1090         apply)       _git_apply ;;
1091         bisect)      _git_bisect ;;
1092         bundle)      _git_bundle ;;
1093         branch)      _git_branch ;;
1094         checkout)    _git_checkout ;;
1095         cherry)      _git_cherry ;;
1096         cherry-pick) _git_cherry_pick ;;
1097         commit)      _git_commit ;;
1098         config)      _git_config ;;
1099         describe)    _git_describe ;;
1100         diff)        _git_diff ;;
1101         fetch)       _git_fetch ;;
1102         format-patch) _git_format_patch ;;
1103         gc)          _git_gc ;;
1104         log)         _git_log ;;
1105         ls-remote)   _git_ls_remote ;;
1106         ls-tree)     _git_ls_tree ;;
1107         merge)       _git_merge;;
1108         merge-base)  _git_merge_base ;;
1109         name-rev)    _git_name_rev ;;
1110         pull)        _git_pull ;;
1111         push)        _git_push ;;
1112         rebase)      _git_rebase ;;
1113         remote)      _git_remote ;;
1114         reset)       _git_reset ;;
1115         shortlog)    _git_shortlog ;;
1116         show)        _git_show ;;
1117         show-branch) _git_log ;;
1118         stash)       _git_stash ;;
1119         submodule)   _git_submodule ;;
1120         whatchanged) _git_log ;;
1121         *)           COMPREPLY=() ;;
1122         esac
1123 }
1124
1125 _gitk ()
1126 {
1127         local cur="${COMP_WORDS[COMP_CWORD]}"
1128         case "$cur" in
1129         --*)
1130                 __gitcomp "--not --all"
1131                 return
1132                 ;;
1133         esac
1134         __git_complete_revlist
1135 }
1136
1137 complete -o default -o nospace -F _git git
1138 complete -o default -o nospace -F _gitk gitk
1139 complete -o default -o nospace -F _git_am git-am
1140 complete -o default -o nospace -F _git_apply git-apply
1141 complete -o default -o nospace -F _git_bisect git-bisect
1142 complete -o default -o nospace -F _git_branch git-branch
1143 complete -o default -o nospace -F _git_bundle git-bundle
1144 complete -o default -o nospace -F _git_checkout git-checkout
1145 complete -o default -o nospace -F _git_cherry git-cherry
1146 complete -o default -o nospace -F _git_cherry_pick git-cherry-pick
1147 complete -o default -o nospace -F _git_commit git-commit
1148 complete -o default -o nospace -F _git_describe git-describe
1149 complete -o default -o nospace -F _git_diff git-diff
1150 complete -o default -o nospace -F _git_fetch git-fetch
1151 complete -o default -o nospace -F _git_format_patch git-format-patch
1152 complete -o default -o nospace -F _git_gc git-gc
1153 complete -o default -o nospace -F _git_log git-log
1154 complete -o default -o nospace -F _git_ls_remote git-ls-remote
1155 complete -o default -o nospace -F _git_ls_tree git-ls-tree
1156 complete -o default -o nospace -F _git_merge git-merge
1157 complete -o default -o nospace -F _git_merge_base git-merge-base
1158 complete -o default -o nospace -F _git_name_rev git-name-rev
1159 complete -o default -o nospace -F _git_pull git-pull
1160 complete -o default -o nospace -F _git_push git-push
1161 complete -o default -o nospace -F _git_rebase git-rebase
1162 complete -o default -o nospace -F _git_config git-config
1163 complete -o default -o nospace -F _git_remote git-remote
1164 complete -o default -o nospace -F _git_reset git-reset
1165 complete -o default -o nospace -F _git_shortlog git-shortlog
1166 complete -o default -o nospace -F _git_show git-show
1167 complete -o default -o nospace -F _git_stash git-stash
1168 complete -o default -o nospace -F _git_submodule git-submodule
1169 complete -o default -o nospace -F _git_log git-show-branch
1170 complete -o default -o nospace -F _git_log git-whatchanged
1171
1172 # The following are necessary only for Cygwin, and only are needed
1173 # when the user has tab-completed the executable name and consequently
1174 # included the '.exe' suffix.
1175 #
1176 if [ Cygwin = "$(uname -o 2>/dev/null)" ]; then
1177 complete -o default -o nospace -F _git_add git-add.exe
1178 complete -o default -o nospace -F _git_apply git-apply.exe
1179 complete -o default -o nospace -F _git git.exe
1180 complete -o default -o nospace -F _git_branch git-branch.exe
1181 complete -o default -o nospace -F _git_bundle git-bundle.exe
1182 complete -o default -o nospace -F _git_cherry git-cherry.exe
1183 complete -o default -o nospace -F _git_describe git-describe.exe
1184 complete -o default -o nospace -F _git_diff git-diff.exe
1185 complete -o default -o nospace -F _git_format_patch git-format-patch.exe
1186 complete -o default -o nospace -F _git_log git-log.exe
1187 complete -o default -o nospace -F _git_ls_tree git-ls-tree.exe
1188 complete -o default -o nospace -F _git_merge_base git-merge-base.exe
1189 complete -o default -o nospace -F _git_name_rev git-name-rev.exe
1190 complete -o default -o nospace -F _git_push git-push.exe
1191 complete -o default -o nospace -F _git_config git-config
1192 complete -o default -o nospace -F _git_shortlog git-shortlog.exe
1193 complete -o default -o nospace -F _git_show git-show.exe
1194 complete -o default -o nospace -F _git_log git-show-branch.exe
1195 complete -o default -o nospace -F _git_log git-whatchanged.exe
1196 fi