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