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                 fsck-objects)     : plumbing;;
 273                 fetch-pack)       : plumbing;;
 274                 fmt-merge-msg)    : plumbing;;
 275                 hash-object)      : plumbing;;
 276                 http-*)           : transport;;
 277                 index-pack)       : plumbing;;
 278                 init-db)          : deprecated;;
 279                 local-fetch)      : plumbing;;
 280                 mailinfo)         : plumbing;;
 281                 mailsplit)        : plumbing;;
 282                 merge-*)          : plumbing;;
 283                 mktree)           : plumbing;;
 284                 mktag)            : plumbing;;
 285                 pack-objects)     : plumbing;;
 286                 pack-redundant)   : plumbing;;
 287                 pack-refs)        : plumbing;;
 288                 parse-remote)     : plumbing;;
 289                 patch-id)         : plumbing;;
 290                 peek-remote)      : plumbing;;
 291                 prune)            : plumbing;;
 292                 prune-packed)     : plumbing;;
 293                 quiltimport)      : import;;
 294                 read-tree)        : plumbing;;
 295                 receive-pack)     : plumbing;;
 296                 reflog)           : plumbing;;
 297                 repo-config)      : plumbing;;
 298                 rerere)           : plumbing;;
 299                 rev-list)         : plumbing;;
 300                 rev-parse)        : plumbing;;
 301                 runstatus)        : plumbing;;
 302                 sh-setup)         : internal;;
 303                 shell)            : daemon;;
 304                 send-pack)        : plumbing;;
 305                 show-index)       : plumbing;;
 306                 ssh-*)            : transport;;
 307                 stripspace)       : plumbing;;
 308                 svn)              : import export;;
 309                 svnimport)        : import;;
 310                 symbolic-ref)     : plumbing;;
 311                 tar-tree)         : deprecated;;
 312                 unpack-file)      : plumbing;;
 313                 unpack-objects)   : plumbing;;
 314                 update-index)     : plumbing;;
 315                 update-ref)       : plumbing;;
 316                 update-server-info) : daemon;;
 317                 upload-archive)   : plumbing;;
 318                 upload-pack)      : plumbing;;
 319                 write-tree)       : plumbing;;
 320                 verify-tag)       : plumbing;;
 321                 *) echo $i;;
 322                 esac
 323         done
 324 }
 325 __git_commandlist=
 326 __git_commandlist="$(__git_commands 2>/dev/null)"
 327
 328 __git_aliases ()
 329 {
 330         local i IFS=$'\n'
 331         for i in $(git --git-dir="$(__gitdir)" config --list); do
 332                 case "$i" in
 333                 alias.*)
 334                         i="${i#alias.}"
 335                         echo "${i/=*/}"
 336                         ;;
 337                 esac
 338         done
 339 }
 340
 341 __git_aliased_command ()
 342 {
 343         local word cmdline=$(git --git-dir="$(__gitdir)" \
 344                 config --get "alias.$1")
 345         for word in $cmdline; do
 346                 if [ "${word##-*}" ]; then
 347                         echo $word
 348                         return
 349                 fi
 350         done
 351 }
 352
 353 __git_whitespacelist="nowarn warn error error-all strip"
 354
 355 _git_am ()
 356 {
 357         local cur="${COMP_WORDS[COMP_CWORD]}"
 358         if [ -d .dotest ]; then
 359                 __gitcomp "--skip --resolved"
 360                 return
 361         fi
 362         case "$cur" in
 363         --whitespace=*)
 364                 __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
 365                 return
 366                 ;;
 367         --*)
 368                 __gitcomp "
 369                         --signoff --utf8 --binary --3way --interactive
 370                         --whitespace=
 371                         "
 372                 return
 373         esac
 374         COMPREPLY=()
 375 }
 376
 377 _git_apply ()
 378 {
 379         local cur="${COMP_WORDS[COMP_CWORD]}"
 380         case "$cur" in
 381         --whitespace=*)
 382                 __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
 383                 return
 384                 ;;
 385         --*)
 386                 __gitcomp "
 387                         --stat --numstat --summary --check --index
 388                         --cached --index-info --reverse --reject --unidiff-zero
 389                         --apply --no-add --exclude=
 390                         --whitespace= --inaccurate-eof --verbose
 391                         "
 392                 return
 393         esac
 394         COMPREPLY=()
 395 }
 396
 397 _git_add ()
 398 {
 399         local cur="${COMP_WORDS[COMP_CWORD]}"
 400         case "$cur" in
 401         --*)
 402                 __gitcomp "--interactive"
 403                 return
 404         esac
 405         COMPREPLY=()
 406 }
 407
 408 _git_branch ()
 409 {
 410         __gitcomp "$(__git_refs)"
 411 }
 412
 413 _git_checkout ()
 414 {
 415         __gitcomp "$(__git_refs)"
 416 }
 417
 418 _git_cherry_pick ()
 419 {
 420         local cur="${COMP_WORDS[COMP_CWORD]}"
 421         case "$cur" in
 422         --*)
 423                 __gitcomp "--edit --no-commit"
 424                 ;;
 425         *)
 426                 __gitcomp "$(__git_refs)"
 427                 ;;
 428         esac
 429 }
 430
 431 _git_commit ()
 432 {
 433         local cur="${COMP_WORDS[COMP_CWORD]}"
 434         case "$cur" in
 435         --*)
 436                 __gitcomp "
 437                         --all --author= --signoff --verify --no-verify
 438                         --edit --amend --include --only
 439                         "
 440                 return
 441         esac
 442         COMPREPLY=()
 443 }
 444
 445 _git_diff ()
 446 {
 447         __git_complete_file
 448 }
 449
 450 _git_diff_tree ()
 451 {
 452         __gitcomp "$(__git_refs)"
 453 }
 454
 455 _git_fetch ()
 456 {
 457         local cur="${COMP_WORDS[COMP_CWORD]}"
 458
 459         case "${COMP_WORDS[0]},$COMP_CWORD" in
 460         git-fetch*,1)
 461                 __gitcomp "$(__git_remotes)"
 462                 ;;
 463         git,2)
 464                 __gitcomp "$(__git_remotes)"
 465                 ;;
 466         *)
 467                 case "$cur" in
 468                 *:*)
 469                         __gitcomp "$(__git_refs)" "" "${cur#*:}"
 470                         ;;
 471                 *)
 472                         local remote
 473                         case "${COMP_WORDS[0]}" in
 474                         git-fetch) remote="${COMP_WORDS[1]}" ;;
 475                         git)       remote="${COMP_WORDS[2]}" ;;
 476                         esac
 477                         __gitcomp "$(__git_refs2 "$remote")"
 478                         ;;
 479                 esac
 480                 ;;
 481         esac
 482 }
 483
 484 _git_format_patch ()
 485 {
 486         local cur="${COMP_WORDS[COMP_CWORD]}"
 487         case "$cur" in
 488         --*)
 489                 __gitcomp "
 490                         --stdout --attach --thread
 491                         --output-directory
 492                         --numbered --start-number
 493                         --keep-subject
 494                         --signoff
 495                         --in-reply-to=
 496                         --full-index --binary
 497                         --not --all
 498                         "
 499                 return
 500                 ;;
 501         esac
 502         __git_complete_revlist
 503 }
 504
 505 _git_ls_remote ()
 506 {
 507         __gitcomp "$(__git_remotes)"
 508 }
 509
 510 _git_ls_tree ()
 511 {
 512         __git_complete_file
 513 }
 514
 515 _git_log ()
 516 {
 517         local cur="${COMP_WORDS[COMP_CWORD]}"
 518         case "$cur" in
 519         --pretty=*)
 520                 __gitcomp "
 521                         oneline short medium full fuller email raw
 522                         " "" "${cur##--pretty=}"
 523                 return
 524                 ;;
 525         --*)
 526                 __gitcomp "
 527                         --max-count= --max-age= --since= --after=
 528                         --min-age= --before= --until=
 529                         --root --not --topo-order --date-order
 530                         --no-merges
 531                         --abbrev-commit --abbrev=
 532                         --relative-date
 533                         --author= --committer= --grep=
 534                         --all-match
 535                         --pretty= --name-status --name-only
 536                         --not --all
 537                         "
 538                 return
 539                 ;;
 540         esac
 541         __git_complete_revlist
 542 }
 543
 544 _git_merge ()
 545 {
 546         local cur="${COMP_WORDS[COMP_CWORD]}"
 547         case "${COMP_WORDS[COMP_CWORD-1]}" in
 548         -s|--strategy)
 549                 __gitcomp "$(__git_merge_strategies)"
 550                 return
 551         esac
 552         case "$cur" in
 553         --strategy=*)
 554                 __gitcomp "$(__git_merge_strategies)" "" "${cur##--strategy=}"
 555                 return
 556                 ;;
 557         --*)
 558                 __gitcomp "
 559                         --no-commit --no-summary --squash --strategy
 560                         "
 561                 return
 562         esac
 563         __gitcomp "$(__git_refs)"
 564 }
 565
 566 _git_merge_base ()
 567 {
 568         __gitcomp "$(__git_refs)"
 569 }
 570
 571 _git_name_rev ()
 572 {
 573         __gitcomp "--tags --all --stdin"
 574 }
 575
 576 _git_pull ()
 577 {
 578         local cur="${COMP_WORDS[COMP_CWORD]}"
 579
 580         case "${COMP_WORDS[0]},$COMP_CWORD" in
 581         git-pull*,1)
 582                 __gitcomp "$(__git_remotes)"
 583                 ;;
 584         git,2)
 585                 __gitcomp "$(__git_remotes)"
 586                 ;;
 587         *)
 588                 local remote
 589                 case "${COMP_WORDS[0]}" in
 590                 git-pull)  remote="${COMP_WORDS[1]}" ;;
 591                 git)       remote="${COMP_WORDS[2]}" ;;
 592                 esac
 593                 __gitcomp "$(__git_refs "$remote")"
 594                 ;;
 595         esac
 596 }
 597
 598 _git_push ()
 599 {
 600         local cur="${COMP_WORDS[COMP_CWORD]}"
 601
 602         case "${COMP_WORDS[0]},$COMP_CWORD" in
 603         git-push*,1)
 604                 __gitcomp "$(__git_remotes)"
 605                 ;;
 606         git,2)
 607                 __gitcomp "$(__git_remotes)"
 608                 ;;
 609         *)
 610                 case "$cur" in
 611                 *:*)
 612                         local remote
 613                         case "${COMP_WORDS[0]}" in
 614                         git-push)  remote="${COMP_WORDS[1]}" ;;
 615                         git)       remote="${COMP_WORDS[2]}" ;;
 616                         esac
 617                         __gitcomp "$(__git_refs "$remote")" "" "${cur#*:}"
 618                         ;;
 619                 *)
 620                         __gitcomp "$(__git_refs2)"
 621                         ;;
 622                 esac
 623                 ;;
 624         esac
 625 }
 626
 627 _git_rebase ()
 628 {
 629         local cur="${COMP_WORDS[COMP_CWORD]}"
 630         if [ -d .dotest ]; then
 631                 __gitcomp "--continue --skip --abort"
 632                 return
 633         fi
 634         case "${COMP_WORDS[COMP_CWORD-1]}" in
 635         -s|--strategy)
 636                 __gitcomp "$(__git_merge_strategies)"
 637                 return
 638         esac
 639         case "$cur" in
 640         --strategy=*)
 641                 __gitcomp "$(__git_merge_strategies)" "" "${cur##--strategy=}"
 642                 return
 643                 ;;
 644         --*)
 645                 __gitcomp "--onto --merge --strategy"
 646                 return
 647         esac
 648         __gitcomp "$(__git_refs)"
 649 }
 650
 651 _git_config ()
 652 {
 653         local cur="${COMP_WORDS[COMP_CWORD]}"
 654         local prv="${COMP_WORDS[COMP_CWORD-1]}"
 655         case "$prv" in
 656         branch.*.remote)
 657                 __gitcomp "$(__git_remotes)"
 658                 return
 659                 ;;
 660         branch.*.merge)
 661                 __gitcomp "$(__git_refs)"
 662                 return
 663                 ;;
 664         remote.*.fetch)
 665                 local remote="${prv#remote.}"
 666                 remote="${remote%.fetch}"
 667                 __gitcomp "$(__git_refs_remotes "$remote")"
 668                 return
 669                 ;;
 670         remote.*.push)
 671                 local remote="${prv#remote.}"
 672                 remote="${remote%.push}"
 673                 __gitcomp "$(git --git-dir="$(__gitdir)" \
 674                         for-each-ref --format='%(refname):%(refname)' \
 675                         refs/heads)"
 676                 return
 677                 ;;
 678         pull.twohead|pull.octopus)
 679                 __gitcomp "$(__git_merge_strategies)"
 680                 return
 681                 ;;
 682         color.branch|color.diff|color.status)
 683                 __gitcomp "always never auto"
 684                 return
 685                 ;;
 686         color.*.*)
 687                 __gitcomp "
 688                         black red green yellow blue magenta cyan white
 689                         bold dim ul blink reverse
 690                         "
 691                 return
 692                 ;;
 693         *.*)
 694                 COMPREPLY=()
 695                 return
 696                 ;;
 697         esac
 698         case "$cur" in
 699         --*)
 700                 __gitcomp "
 701                         --global --list --replace-all
 702                         --get --get-all --get-regexp
 703                         --unset --unset-all
 704                         "
 705                 return
 706                 ;;
 707         branch.*.*)
 708                 local pfx="${cur%.*}."
 709                 cur="${cur##*.}"
 710                 __gitcomp "remote merge" "$pfx" "$cur"
 711                 return
 712                 ;;
 713         branch.*)
 714                 local pfx="${cur%.*}."
 715                 cur="${cur#*.}"
 716                 __gitcomp "$(__git_heads)" "$pfx" "$cur" "."
 717                 return
 718                 ;;
 719         remote.*.*)
 720                 local pfx="${cur%.*}."
 721                 cur="${cur##*.}"
 722                 __gitcomp "url fetch push" "$pfx" "$cur"
 723                 return
 724                 ;;
 725         remote.*)
 726                 local pfx="${cur%.*}."
 727                 cur="${cur#*.}"
 728                 __gitcomp "$(__git_remotes)" "$pfx" "$cur" "."
 729                 return
 730                 ;;
 731         esac
 732         __gitcomp "
 733                 apply.whitespace
 734                 core.fileMode
 735                 core.gitProxy
 736                 core.ignoreStat
 737                 core.preferSymlinkRefs
 738                 core.logAllRefUpdates
 739                 core.repositoryFormatVersion
 740                 core.sharedRepository
 741                 core.warnAmbiguousRefs
 742                 core.compression
 743                 core.legacyHeaders
 744                 core.packedGitWindowSize
 745                 core.packedGitLimit
 746                 color.branch
 747                 color.branch.current
 748                 color.branch.local
 749                 color.branch.remote
 750                 color.branch.plain
 751                 color.diff
 752                 color.diff.plain
 753                 color.diff.meta
 754                 color.diff.frag
 755                 color.diff.old
 756                 color.diff.new
 757                 color.diff.commit
 758                 color.diff.whitespace
 759                 color.pager
 760                 color.status
 761                 color.status.header
 762                 color.status.added
 763                 color.status.changed
 764                 color.status.untracked
 765                 diff.renameLimit
 766                 diff.renames
 767                 fetch.unpackLimit
 768                 format.headers
 769                 gitcvs.enabled
 770                 gitcvs.logfile
 771                 gc.reflogexpire
 772                 gc.reflogexpireunreachable
 773                 gc.rerereresolved
 774                 gc.rerereunresolved
 775                 http.sslVerify
 776                 http.sslCert
 777                 http.sslKey
 778                 http.sslCAInfo
 779                 http.sslCAPath
 780                 http.maxRequests
 781                 http.lowSpeedLimit
 782                 http.lowSpeedTime
 783                 http.noEPSV
 784                 i18n.commitEncoding
 785                 i18n.logOutputEncoding
 786                 log.showroot
 787                 merge.summary
 788                 merge.verbosity
 789                 pack.window
 790                 pull.octopus
 791                 pull.twohead
 792                 repack.useDeltaBaseOffset
 793                 show.difftree
 794                 showbranch.default
 795                 tar.umask
 796                 transfer.unpackLimit
 797                 receive.unpackLimit
 798                 receive.denyNonFastForwards
 799                 user.name
 800                 user.email
 801                 user.signingkey
 802                 whatchanged.difftree
 803                 branch. remote.
 804         "
 805 }
 806
 807 _git_reset ()
 808 {
 809         local cur="${COMP_WORDS[COMP_CWORD]}"
 810         case "$cur" in
 811         --*)
 812                 __gitcomp "--mixed --hard --soft"
 813                 return
 814                 ;;
 815         esac
 816         __gitcomp "$(__git_refs)"
 817 }
 818
 819 _git_show ()
 820 {
 821         local cur="${COMP_WORDS[COMP_CWORD]}"
 822         case "$cur" in
 823         --pretty=*)
 824                 __gitcomp "
 825                         oneline short medium full fuller email raw
 826                         " "" "${cur##--pretty=}"
 827                 return
 828                 ;;
 829         --*)
 830                 __gitcomp "--pretty="
 831                 return
 832                 ;;
 833         esac
 834         __git_complete_file
 835 }
 836
 837 _git ()
 838 {
 839         local i c=1 command __git_dir
 840
 841         while [ $c -lt $COMP_CWORD ]; do
 842                 i="${COMP_WORDS[c]}"
 843                 case "$i" in
 844                 --git-dir=*) __git_dir="${i#--git-dir=}" ;;
 845                 --bare)      __git_dir="." ;;
 846                 --version|--help|-p|--paginate) ;;
 847                 *) command="$i"; break ;;
 848                 esac
 849                 c=$((++c))
 850         done
 851
 852         if [ $c -eq $COMP_CWORD -a -z "$command" ]; then
 853                 case "${COMP_WORDS[COMP_CWORD]}" in
 854                 --*=*) COMPREPLY=() ;;
 855                 --*)   __gitcomp "--git-dir= --bare --version --exec-path" ;;
 856                 *)     __gitcomp "$(__git_commands) $(__git_aliases)" ;;
 857                 esac
 858                 return
 859         fi
 860
 861         local expansion=$(__git_aliased_command "$command")
 862         [ "$expansion" ] && command="$expansion"
 863
 864         case "$command" in
 865         am)          _git_am ;;
 866         add)         _git_add ;;
 867         apply)       _git_apply ;;
 868         branch)      _git_branch ;;
 869         checkout)    _git_checkout ;;
 870         cherry-pick) _git_cherry_pick ;;
 871         commit)      _git_commit ;;
 872         config)      _git_config ;;
 873         diff)        _git_diff ;;
 874         diff-tree)   _git_diff_tree ;;
 875         fetch)       _git_fetch ;;
 876         format-patch) _git_format_patch ;;
 877         log)         _git_log ;;
 878         ls-remote)   _git_ls_remote ;;
 879         ls-tree)     _git_ls_tree ;;
 880         merge)       _git_merge;;
 881         merge-base)  _git_merge_base ;;
 882         name-rev)    _git_name_rev ;;
 883         pull)        _git_pull ;;
 884         push)        _git_push ;;
 885         rebase)      _git_rebase ;;
 886         reset)       _git_reset ;;
 887         show)        _git_show ;;
 888         show-branch) _git_log ;;
 889         whatchanged) _git_log ;;
 890         *)           COMPREPLY=() ;;
 891         esac
 892 }
 893
 894 _gitk ()
 895 {
 896         local cur="${COMP_WORDS[COMP_CWORD]}"
 897         case "$cur" in
 898         --*)
 899                 __gitcomp "--not --all"
 900                 return
 901                 ;;
 902         esac
 903         __git_complete_revlist
 904 }
 905
 906 complete -o default -o nospace -F _git git
 907 complete -o default -o nospace -F _gitk gitk
 908 complete -o default -o nospace -F _git_am git-am
 909 complete -o default -o nospace -F _git_apply git-apply
 910 complete -o default -o nospace -F _git_branch git-branch
 911 complete -o default -o nospace -F _git_checkout git-checkout
 912 complete -o default -o nospace -F _git_cherry_pick git-cherry-pick
 913 complete -o default -o nospace -F _git_commit git-commit
 914 complete -o default -o nospace -F _git_diff git-diff
 915 complete -o default -o nospace -F _git_diff_tree git-diff-tree
 916 complete -o default -o nospace -F _git_fetch git-fetch
 917 complete -o default -o nospace -F _git_format_patch git-format-patch
 918 complete -o default -o nospace -F _git_log git-log
 919 complete -o default -o nospace -F _git_ls_remote git-ls-remote
 920 complete -o default -o nospace -F _git_ls_tree git-ls-tree
 921 complete -o default -o nospace -F _git_merge git-merge
 922 complete -o default -o nospace -F _git_merge_base git-merge-base
 923 complete -o default -o nospace -F _git_name_rev git-name-rev
 924 complete -o default -o nospace -F _git_pull git-pull
 925 complete -o default -o nospace -F _git_push git-push
 926 complete -o default -o nospace -F _git_rebase git-rebase
 927 complete -o default -o nospace -F _git_config git-config
 928 complete -o default -o nospace -F _git_reset git-reset
 929 complete -o default -o nospace -F _git_show git-show
 930 complete -o default -o nospace -F _git_log git-show-branch
 931 complete -o default -o nospace -F _git_log git-whatchanged
 932
 933 # The following are necessary only for Cygwin, and only are needed
 934 # when the user has tab-completed the executable name and consequently
 935 # included the '.exe' suffix.
 936 #
 937 if [ Cygwin = "$(uname -o 2>/dev/null)" ]; then
 938 complete -o default -o nospace -F _git_add git-add.exe
 939 complete -o default -o nospace -F _git_apply git-apply.exe
 940 complete -o default -o nospace -F _git git.exe
 941 complete -o default -o nospace -F _git_branch git-branch.exe
 942 complete -o default -o nospace -F _git_diff git-diff.exe
 943 complete -o default -o nospace -F _git_diff_tree git-diff-tree.exe
 944 complete -o default -o nospace -F _git_format_patch git-format-patch.exe
 945 complete -o default -o nospace -F _git_log git-log.exe
 946 complete -o default -o nospace -F _git_ls_tree git-ls-tree.exe
 947 complete -o default -o nospace -F _git_merge_base git-merge-base.exe
 948 complete -o default -o nospace -F _git_name_rev git-name-rev.exe
 949 complete -o default -o nospace -F _git_push git-push.exe
 950 complete -o default -o nospace -F _git_config git-config
 951 complete -o default -o nospace -F _git_show git-show.exe
 952 complete -o default -o nospace -F _git_log git-show-branch.exe
 953 complete -o default -o nospace -F _git_log git-whatchanged.exe
 954 fi