contrib/completion/git-completion.bash

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