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