contrib/completion/git-completion.bash

   1 #
   2 # bash completion support for core Git.
   3 #
   4 # Copyright (C) 2006,2007 Shawn O. Pearce <spearce@spearce.org>
   5 # Conceptually based on gitcompletion (http://gitweb.hawaga.org.uk/).
   6 # Distributed under the GNU General Public License, version 2.0.
   7 #
   8 # The contained completion routines provide support for completing:
   9 #
  10 #    *) local and remote branch names
  11 #    *) local and remote tag names
  12 #    *) .git/remotes file names
  13 #    *) git 'subcommands'
  14 #    *) tree paths within 'ref:path/to/file' expressions
  15 #    *) common --long-options
  16 #
  17 # To use these routines:
  18 #
  19 #    1) Copy this file to somewhere (e.g. ~/.git-completion.sh).
  20 #    2) Added the following line to your .bashrc:
  21 #        source ~/.git-completion.sh
  22 #
  23 #    3) You may want to make sure the git executable is available
  24 #       in your PATH before this script is sourced, as some caching
  25 #       is performed while the script loads.  If git isn't found
  26 #       at source time then all lookups will be done on demand,
  27 #       which may be slightly slower.
  28 #
  29 #    4) Consider changing your PS1 to also show the current branch:
  30 #        PS1='[\u@\h \W$(__git_ps1 " (%s)")]\$ '
  31 #
  32 #       The argument to __git_ps1 will be displayed only if you
  33 #       are currently in a git repository.  The %s token will be
  34 #       the name of the current branch.
  35 #
  36 # To submit patches:
  37 #
  38 #    *) Read Documentation/SubmittingPatches
  39 #    *) Send all patches to the current maintainer:
  40 #
  41 #       "Shawn O. Pearce" <spearce@spearce.org>
  42 #
  43 #    *) Always CC the Git mailing list:
  44 #
  45 #       git@vger.kernel.org
  46 #
  47
  48 __gitdir ()
  49 {
  50         if [ -z "$1" ]; then
  51                 if [ -n "$__git_dir" ]; then
  52                         echo "$__git_dir"
  53                 elif [ -d .git ]; then
  54                         echo .git
  55                 else
  56                         git rev-parse --git-dir 2>/dev/null
  57                 fi
  58         elif [ -d "$1/.git" ]; then
  59                 echo "$1/.git"
  60         else
  61                 echo "$1"
  62         fi
  63 }
  64
  65 __git_ps1 ()
  66 {
  67         local g="$(git rev-parse --git-dir 2>/dev/null)"
  68         if [ -n "$g" ]; then
  69                 local r
  70                 local b
  71                 if [ -d "$g/../.dotest" ]
  72                 then
  73                         r="|AM/REBASE"
  74                         b="$(git symbolic-ref HEAD 2>/dev/null)"
  75                 elif [ -f "$g/.dotest-merge/interactive" ]
  76                 then
  77                         r="|REBASE-i"
  78                         b="$(cat $g/.dotest-merge/head-name)"
  79                 elif [ -d "$g/.dotest-merge" ]
  80                 then
  81                         r="|REBASE-m"
  82                         b="$(cat $g/.dotest-merge/head-name)"
  83                 elif [ -f "$g/MERGE_HEAD" ]
  84                 then
  85                         r="|MERGING"
  86                         b="$(git symbolic-ref HEAD 2>/dev/null)"
  87                 else
  88                         if [ -f $g/BISECT_LOG ]
  89                         then
  90                                 r="|BISECTING"
  91                         fi
  92                         if ! b="$(git symbolic-ref HEAD 2>/dev/null)"
  93                         then
  94                                 if ! b="$(git describe --exact-match HEAD 2>/dev/null)"
  95                                 then
  96                                         b="$(cut -c1-7 $g/HEAD)..."
  97                                 fi
  98                         fi
  99                 fi
 100
 101                 if [ -n "$1" ]; then
 102                         printf "$1" "${b##refs/heads/}$r"
 103                 else
 104                         printf " (%s)" "${b##refs/heads/}$r"
 105                 fi
 106         fi
 107 }
 108
 109 __gitcomp ()
 110 {
 111         local all c s=$'\n' IFS=' '$'\t'$'\n'
 112         local cur="${COMP_WORDS[COMP_CWORD]}"
 113         if [ $# -gt 2 ]; then
 114                 cur="$3"
 115         fi
 116         for c in $1; do
 117                 case "$c$4" in
 118                 --*=*) all="$all$c$4$s" ;;
 119                 *.)    all="$all$c$4$s" ;;
 120                 *)     all="$all$c$4 $s" ;;
 121                 esac
 122         done
 123         IFS=$s
 124         COMPREPLY=($(compgen -P "$2" -W "$all" -- "$cur"))
 125         return
 126 }
 127
 128 __git_heads ()
 129 {
 130         local cmd i is_hash=y dir="$(__gitdir "$1")"
 131         if [ -d "$dir" ]; then
 132                 for i in $(git --git-dir="$dir" \
 133                         for-each-ref --format='%(refname)' \
 134                         refs/heads ); do
 135                         echo "${i#refs/heads/}"
 136                 done
 137                 return
 138         fi
 139         for i in $(git-ls-remote "$1" 2>/dev/null); do
 140                 case "$is_hash,$i" in
 141                 y,*) is_hash=n ;;
 142                 n,*^{}) is_hash=y ;;
 143                 n,refs/heads/*) is_hash=y; echo "${i#refs/heads/}" ;;
 144                 n,*) is_hash=y; echo "$i" ;;
 145                 esac
 146         done
 147 }
 148
 149 __git_tags ()
 150 {
 151         local cmd i is_hash=y dir="$(__gitdir "$1")"
 152         if [ -d "$dir" ]; then
 153                 for i in $(git --git-dir="$dir" \
 154                         for-each-ref --format='%(refname)' \
 155                         refs/tags ); do
 156                         echo "${i#refs/tags/}"
 157                 done
 158                 return
 159         fi
 160         for i in $(git-ls-remote "$1" 2>/dev/null); do
 161                 case "$is_hash,$i" in
 162                 y,*) is_hash=n ;;
 163                 n,*^{}) is_hash=y ;;
 164                 n,refs/tags/*) is_hash=y; echo "${i#refs/tags/}" ;;
 165                 n,*) is_hash=y; echo "$i" ;;
 166                 esac
 167         done
 168 }
 169
 170 __git_refs ()
 171 {
 172         local cmd i is_hash=y dir="$(__gitdir "$1")"
 173         if [ -d "$dir" ]; then
 174                 if [ -e "$dir/HEAD" ]; then echo HEAD; fi
 175                 for i in $(git --git-dir="$dir" \
 176                         for-each-ref --format='%(refname)' \
 177                         refs/tags refs/heads refs/remotes); do
 178                         case "$i" in
 179                                 refs/tags/*)    echo "${i#refs/tags/}" ;;
 180                                 refs/heads/*)   echo "${i#refs/heads/}" ;;
 181                                 refs/remotes/*) echo "${i#refs/remotes/}" ;;
 182                                 *)              echo "$i" ;;
 183                         esac
 184                 done
 185                 return
 186         fi
 187         for i in $(git-ls-remote "$dir" 2>/dev/null); do
 188                 case "$is_hash,$i" in
 189                 y,*) is_hash=n ;;
 190                 n,*^{}) is_hash=y ;;
 191                 n,refs/tags/*) is_hash=y; echo "${i#refs/tags/}" ;;
 192                 n,refs/heads/*) is_hash=y; echo "${i#refs/heads/}" ;;
 193                 n,refs/remotes/*) is_hash=y; echo "${i#refs/remotes/}" ;;
 194                 n,*) is_hash=y; echo "$i" ;;
 195                 esac
 196         done
 197 }
 198
 199 __git_refs2 ()
 200 {
 201         local i
 202         for i in $(__git_refs "$1"); do
 203                 echo "$i:$i"
 204         done
 205 }
 206
 207 __git_refs_remotes ()
 208 {
 209         local cmd i is_hash=y
 210         for i in $(git-ls-remote "$1" 2>/dev/null); do
 211                 case "$is_hash,$i" in
 212                 n,refs/heads/*)
 213                         is_hash=y
 214                         echo "$i:refs/remotes/$1/${i#refs/heads/}"
 215                         ;;
 216                 y,*) is_hash=n ;;
 217                 n,*^{}) is_hash=y ;;
 218                 n,refs/tags/*) is_hash=y;;
 219                 n,*) is_hash=y; ;;
 220                 esac
 221         done
 222 }
 223
 224 __git_remotes ()
 225 {
 226         local i ngoff IFS=$'\n' d="$(__gitdir)"
 227         shopt -q nullglob || ngoff=1
 228         shopt -s nullglob
 229         for i in "$d/remotes"/*; do
 230                 echo ${i#$d/remotes/}
 231         done
 232         [ "$ngoff" ] && shopt -u nullglob
 233         for i in $(git --git-dir="$d" config --list); do
 234                 case "$i" in
 235                 remote.*.url=*)
 236                         i="${i#remote.}"
 237                         echo "${i/.url=*/}"
 238                         ;;
 239                 esac
 240         done
 241 }
 242
 243 __git_merge_strategies ()
 244 {
 245         if [ -n "$__git_merge_strategylist" ]; then
 246                 echo "$__git_merge_strategylist"
 247                 return
 248         fi
 249         sed -n "/^all_strategies='/{
 250                 s/^all_strategies='//
 251                 s/'//
 252                 p
 253                 q
 254                 }" "$(git --exec-path)/git-merge"
 255 }
 256 __git_merge_strategylist=
 257 __git_merge_strategylist="$(__git_merge_strategies 2>/dev/null)"
 258
 259 __git_complete_file ()
 260 {
 261         local pfx ls ref cur="${COMP_WORDS[COMP_CWORD]}"
 262         case "$cur" in
 263         ?*:*)
 264                 ref="${cur%%:*}"
 265                 cur="${cur#*:}"
 266                 case "$cur" in
 267                 ?*/*)
 268                         pfx="${cur%/*}"
 269                         cur="${cur##*/}"
 270                         ls="$ref:$pfx"
 271                         pfx="$pfx/"
 272                         ;;
 273                 *)
 274                         ls="$ref"
 275                         ;;
 276             esac
 277                 COMPREPLY=($(compgen -P "$pfx" \
 278                         -W "$(git --git-dir="$(__gitdir)" ls-tree "$ls" \
 279                                 | sed '/^100... blob /s,^.*     ,,
 280                                        /^040000 tree /{
 281                                            s,^.*        ,,
 282                                            s,$,/,
 283                                        }
 284                                        s/^.*    //')" \
 285                         -- "$cur"))
 286                 ;;
 287         *)
 288                 __gitcomp "$(__git_refs)"
 289                 ;;
 290         esac
 291 }
 292
 293 __git_complete_revlist ()
 294 {
 295         local pfx cur="${COMP_WORDS[COMP_CWORD]}"
 296         case "$cur" in
 297         *...*)
 298                 pfx="${cur%...*}..."
 299                 cur="${cur#*...}"
 300                 __gitcomp "$(__git_refs)" "$pfx" "$cur"
 301                 ;;
 302         *..*)
 303                 pfx="${cur%..*}.."
 304                 cur="${cur#*..}"
 305                 __gitcomp "$(__git_refs)" "$pfx" "$cur"
 306                 ;;
 307         *.)
 308                 __gitcomp "$cur."
 309                 ;;
 310         *)
 311                 __gitcomp "$(__git_refs)"
 312                 ;;
 313         esac
 314 }
 315
 316 __git_commands ()
 317 {
 318         if [ -n "$__git_commandlist" ]; then
 319                 echo "$__git_commandlist"
 320                 return
 321         fi
 322         local i IFS=" "$'\n'
 323         for i in $(git help -a|egrep '^ ')
 324         do
 325                 case $i in
 326                 *--*)             : helper pattern;;
 327                 applymbox)        : ask gittus;;
 328                 applypatch)       : ask gittus;;
 329                 archimport)       : import;;
 330                 cat-file)         : plumbing;;
 331                 check-attr)       : plumbing;;
 332                 check-ref-format) : plumbing;;
 333                 commit-tree)      : plumbing;;
 334                 cvsexportcommit)  : export;;
 335                 cvsimport)        : import;;
 336                 cvsserver)        : daemon;;
 337                 daemon)           : daemon;;
 338                 diff-files)       : plumbing;;
 339                 diff-index)       : plumbing;;
 340                 diff-tree)        : plumbing;;
 341                 fast-import)      : import;;
 342                 fsck-objects)     : plumbing;;
 343                 fetch-pack)       : plumbing;;
 344                 fmt-merge-msg)    : plumbing;;
 345                 for-each-ref)     : plumbing;;
 346                 hash-object)      : plumbing;;
 347                 http-*)           : transport;;
 348                 index-pack)       : plumbing;;
 349                 init-db)          : deprecated;;
 350                 local-fetch)      : plumbing;;
 351                 mailinfo)         : plumbing;;
 352                 mailsplit)        : plumbing;;
 353                 merge-*)          : plumbing;;
 354                 mktree)           : plumbing;;
 355                 mktag)            : plumbing;;
 356                 pack-objects)     : plumbing;;
 357                 pack-redundant)   : plumbing;;
 358                 pack-refs)        : plumbing;;
 359                 parse-remote)     : plumbing;;
 360                 patch-id)         : plumbing;;
 361                 peek-remote)      : plumbing;;
 362                 prune)            : plumbing;;
 363                 prune-packed)     : plumbing;;
 364                 quiltimport)      : import;;
 365                 read-tree)        : plumbing;;
 366                 receive-pack)     : plumbing;;
 367                 reflog)           : plumbing;;
 368                 repo-config)      : deprecated;;
 369                 rerere)           : plumbing;;
 370                 rev-list)         : plumbing;;
 371                 rev-parse)        : plumbing;;
 372                 runstatus)        : plumbing;;
 373                 sh-setup)         : internal;;
 374                 shell)            : daemon;;
 375                 send-pack)        : plumbing;;
 376                 show-index)       : plumbing;;
 377                 ssh-*)            : transport;;
 378                 stripspace)       : plumbing;;
 379                 svn)              : import export;;
 380                 symbolic-ref)     : plumbing;;
 381                 tar-tree)         : deprecated;;
 382                 unpack-file)      : plumbing;;
 383                 unpack-objects)   : plumbing;;
 384                 update-index)     : plumbing;;
 385                 update-ref)       : plumbing;;
 386                 update-server-info) : daemon;;
 387                 upload-archive)   : plumbing;;
 388                 upload-pack)      : plumbing;;
 389                 write-tree)       : plumbing;;
 390                 verify-tag)       : plumbing;;
 391                 *) echo $i;;
 392                 esac
 393         done
 394 }
 395 __git_commandlist=
 396 __git_commandlist="$(__git_commands 2>/dev/null)"
 397
 398 __git_aliases ()
 399 {
 400         local i IFS=$'\n'
 401         for i in $(git --git-dir="$(__gitdir)" config --list); do
 402                 case "$i" in
 403                 alias.*)
 404                         i="${i#alias.}"
 405                         echo "${i/=*/}"
 406                         ;;
 407                 esac
 408         done
 409 }
 410
 411 __git_aliased_command ()
 412 {
 413         local word cmdline=$(git --git-dir="$(__gitdir)" \
 414                 config --get "alias.$1")
 415         for word in $cmdline; do
 416                 if [ "${word##-*}" ]; then
 417                         echo $word
 418                         return
 419                 fi
 420         done
 421 }
 422
 423 __git_whitespacelist="nowarn warn error error-all strip"
 424
 425 _git_am ()
 426 {
 427         local cur="${COMP_WORDS[COMP_CWORD]}"
 428         if [ -d .dotest ]; then
 429                 __gitcomp "--skip --resolved"
 430                 return
 431         fi
 432         case "$cur" in
 433         --whitespace=*)
 434                 __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
 435                 return
 436                 ;;
 437         --*)
 438                 __gitcomp "
 439                         --signoff --utf8 --binary --3way --interactive
 440                         --whitespace=
 441                         "
 442                 return
 443         esac
 444         COMPREPLY=()
 445 }
 446
 447 _git_apply ()
 448 {
 449         local cur="${COMP_WORDS[COMP_CWORD]}"
 450         case "$cur" in
 451         --whitespace=*)
 452                 __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
 453                 return
 454                 ;;
 455         --*)
 456                 __gitcomp "
 457                         --stat --numstat --summary --check --index
 458                         --cached --index-info --reverse --reject --unidiff-zero
 459                         --apply --no-add --exclude=
 460                         --whitespace= --inaccurate-eof --verbose
 461                         "
 462                 return
 463         esac
 464         COMPREPLY=()
 465 }
 466
 467 _git_add ()
 468 {
 469         local cur="${COMP_WORDS[COMP_CWORD]}"
 470         case "$cur" in
 471         --*)
 472                 __gitcomp "--interactive --refresh"
 473                 return
 474         esac
 475         COMPREPLY=()
 476 }
 477
 478 _git_bisect ()
 479 {
 480         local i c=1 command
 481         while [ $c -lt $COMP_CWORD ]; do
 482                 i="${COMP_WORDS[c]}"
 483                 case "$i" in
 484                 start|bad|good|reset|visualize|replay|log)
 485                         command="$i"
 486                         break
 487                         ;;
 488                 esac
 489                 c=$((++c))
 490         done
 491
 492         if [ $c -eq $COMP_CWORD -a -z "$command" ]; then
 493                 __gitcomp "start bad good reset visualize replay log"
 494                 return
 495         fi
 496
 497         case "$command" in
 498         bad|good|reset)
 499                 __gitcomp "$(__git_refs)"
 500                 ;;
 501         *)
 502                 COMPREPLY=()
 503                 ;;
 504         esac
 505 }
 506
 507 _git_branch ()
 508 {
 509         __gitcomp "$(__git_refs)"
 510 }
 511
 512 _git_bundle ()
 513 {
 514         local mycword="$COMP_CWORD"
 515         case "${COMP_WORDS[0]}" in
 516         git)
 517                 local cmd="${COMP_WORDS[2]}"
 518                 mycword="$((mycword-1))"
 519                 ;;
 520         git-bundle*)
 521                 local cmd="${COMP_WORDS[1]}"
 522                 ;;
 523         esac
 524         case "$mycword" in
 525         1)
 526                 __gitcomp "create list-heads verify unbundle"
 527                 ;;
 528         2)
 529                 # looking for a file
 530                 ;;
 531         *)
 532                 case "$cmd" in
 533                         create)
 534                                 __git_complete_revlist
 535                         ;;
 536                 esac
 537                 ;;
 538         esac
 539 }
 540
 541 _git_checkout ()
 542 {
 543         __gitcomp "$(__git_refs)"
 544 }
 545
 546 _git_cherry ()
 547 {
 548         __gitcomp "$(__git_refs)"
 549 }
 550
 551 _git_cherry_pick ()
 552 {
 553         local cur="${COMP_WORDS[COMP_CWORD]}"
 554         case "$cur" in
 555         --*)
 556                 __gitcomp "--edit --no-commit"
 557                 ;;
 558         *)
 559                 __gitcomp "$(__git_refs)"
 560                 ;;
 561         esac
 562 }
 563
 564 _git_commit ()
 565 {
 566         local cur="${COMP_WORDS[COMP_CWORD]}"
 567         case "$cur" in
 568         --*)
 569                 __gitcomp "
 570                         --all --author= --signoff --verify --no-verify
 571                         --edit --amend --include --only
 572                         "
 573                 return
 574         esac
 575         COMPREPLY=()
 576 }
 577
 578 _git_describe ()
 579 {
 580         __gitcomp "$(__git_refs)"
 581 }
 582
 583 _git_diff ()
 584 {
 585         local cur="${COMP_WORDS[COMP_CWORD]}"
 586         case "$cur" in
 587         --*)
 588                 __gitcomp "--cached --stat --numstat --shortstat --summary
 589                         --patch-with-stat --name-only --name-status --color
 590                         --no-color --color-words --no-renames --check
 591                         --full-index --binary --abbrev --diff-filter
 592                         --find-copies-harder --pickaxe-all --pickaxe-regex
 593                         --text --ignore-space-at-eol --ignore-space-change
 594                         --ignore-all-space --exit-code --quiet --ext-diff
 595                         --no-ext-diff"
 596                 return
 597                 ;;
 598         esac
 599         __git_complete_file
 600 }
 601
 602 _git_diff_tree ()
 603 {
 604         __gitcomp "$(__git_refs)"
 605 }
 606
 607 _git_fetch ()
 608 {
 609         local cur="${COMP_WORDS[COMP_CWORD]}"
 610
 611         case "${COMP_WORDS[0]},$COMP_CWORD" in
 612         git-fetch*,1)
 613                 __gitcomp "$(__git_remotes)"
 614                 ;;
 615         git,2)
 616                 __gitcomp "$(__git_remotes)"
 617                 ;;
 618         *)
 619                 case "$cur" in
 620                 *:*)
 621                         __gitcomp "$(__git_refs)" "" "${cur#*:}"
 622                         ;;
 623                 *)
 624                         local remote
 625                         case "${COMP_WORDS[0]}" in
 626                         git-fetch) remote="${COMP_WORDS[1]}" ;;
 627                         git)       remote="${COMP_WORDS[2]}" ;;
 628                         esac
 629                         __gitcomp "$(__git_refs2 "$remote")"
 630                         ;;
 631                 esac
 632                 ;;
 633         esac
 634 }
 635
 636 _git_format_patch ()
 637 {
 638         local cur="${COMP_WORDS[COMP_CWORD]}"
 639         case "$cur" in
 640         --*)
 641                 __gitcomp "
 642                         --stdout --attach --thread
 643                         --output-directory
 644                         --numbered --start-number
 645                         --numbered-files
 646                         --keep-subject
 647                         --signoff
 648                         --in-reply-to=
 649                         --full-index --binary
 650                         --not --all
 651                         --cover-letter
 652                         "
 653                 return
 654                 ;;
 655         esac
 656         __git_complete_revlist
 657 }
 658
 659 _git_gc ()
 660 {
 661         local cur="${COMP_WORDS[COMP_CWORD]}"
 662         case "$cur" in
 663         --*)
 664                 __gitcomp "--prune --aggressive"
 665                 return
 666                 ;;
 667         esac
 668         COMPREPLY=()
 669 }
 670
 671 _git_ls_remote ()
 672 {
 673         __gitcomp "$(__git_remotes)"
 674 }
 675
 676 _git_ls_tree ()
 677 {
 678         __git_complete_file
 679 }
 680
 681 _git_log ()
 682 {
 683         local cur="${COMP_WORDS[COMP_CWORD]}"
 684         case "$cur" in
 685         --pretty=*)
 686                 __gitcomp "
 687                         oneline short medium full fuller email raw
 688                         " "" "${cur##--pretty=}"
 689                 return
 690                 ;;
 691         --date=*)
 692                 __gitcomp "
 693                         relative iso8601 rfc2822 short local default
 694                 " "" "${cur##--date=}"
 695                 return
 696                 ;;
 697         --*)
 698                 __gitcomp "
 699                         --max-count= --max-age= --since= --after=
 700                         --min-age= --before= --until=
 701                         --root --topo-order --date-order --reverse
 702                         --no-merges --follow
 703                         --abbrev-commit --abbrev=
 704                         --relative-date --date=
 705                         --author= --committer= --grep=
 706                         --all-match
 707                         --pretty= --name-status --name-only --raw
 708                         --not --all
 709                         --left-right --cherry-pick
 710                         "
 711                 return
 712                 ;;
 713         esac
 714         __git_complete_revlist
 715 }
 716
 717 _git_merge ()
 718 {
 719         local cur="${COMP_WORDS[COMP_CWORD]}"
 720         case "${COMP_WORDS[COMP_CWORD-1]}" in
 721         -s|--strategy)
 722                 __gitcomp "$(__git_merge_strategies)"
 723                 return
 724         esac
 725         case "$cur" in
 726         --strategy=*)
 727                 __gitcomp "$(__git_merge_strategies)" "" "${cur##--strategy=}"
 728                 return
 729                 ;;
 730         --*)
 731                 __gitcomp "
 732                         --no-commit --no-summary --squash --strategy
 733                         "
 734                 return
 735         esac
 736         __gitcomp "$(__git_refs)"
 737 }
 738
 739 _git_merge_base ()
 740 {
 741         __gitcomp "$(__git_refs)"
 742 }
 743
 744 _git_name_rev ()
 745 {
 746         __gitcomp "--tags --all --stdin"
 747 }
 748
 749 _git_pull ()
 750 {
 751         local cur="${COMP_WORDS[COMP_CWORD]}"
 752
 753         case "${COMP_WORDS[0]},$COMP_CWORD" in
 754         git-pull*,1)
 755                 __gitcomp "$(__git_remotes)"
 756                 ;;
 757         git,2)
 758                 __gitcomp "$(__git_remotes)"
 759                 ;;
 760         *)
 761                 local remote
 762                 case "${COMP_WORDS[0]}" in
 763                 git-pull)  remote="${COMP_WORDS[1]}" ;;
 764                 git)       remote="${COMP_WORDS[2]}" ;;
 765                 esac
 766                 __gitcomp "$(__git_refs "$remote")"
 767                 ;;
 768         esac
 769 }
 770
 771 _git_push ()
 772 {
 773         local cur="${COMP_WORDS[COMP_CWORD]}"
 774
 775         case "${COMP_WORDS[0]},$COMP_CWORD" in
 776         git-push*,1)
 777                 __gitcomp "$(__git_remotes)"
 778                 ;;
 779         git,2)
 780                 __gitcomp "$(__git_remotes)"
 781                 ;;
 782         *)
 783                 case "$cur" in
 784                 *:*)
 785                         local remote
 786                         case "${COMP_WORDS[0]}" in
 787                         git-push)  remote="${COMP_WORDS[1]}" ;;
 788                         git)       remote="${COMP_WORDS[2]}" ;;
 789                         esac
 790                         __gitcomp "$(__git_refs "$remote")" "" "${cur#*:}"
 791                         ;;
 792                 +*)
 793                         __gitcomp "$(__git_refs)" + "${cur#+}"
 794                         ;;
 795                 *)
 796                         __gitcomp "$(__git_refs)"
 797                         ;;
 798                 esac
 799                 ;;
 800         esac
 801 }
 802
 803 _git_rebase ()
 804 {
 805         local cur="${COMP_WORDS[COMP_CWORD]}"
 806         if [ -d .dotest ] || [ -d .git/.dotest-merge ]; then
 807                 __gitcomp "--continue --skip --abort"
 808                 return
 809         fi
 810         case "${COMP_WORDS[COMP_CWORD-1]}" in
 811         -s|--strategy)
 812                 __gitcomp "$(__git_merge_strategies)"
 813                 return
 814         esac
 815         case "$cur" in
 816         --strategy=*)
 817                 __gitcomp "$(__git_merge_strategies)" "" "${cur##--strategy=}"
 818                 return
 819                 ;;
 820         --*)
 821                 __gitcomp "--onto --merge --strategy"
 822                 return
 823         esac
 824         __gitcomp "$(__git_refs)"
 825 }
 826
 827 _git_config ()
 828 {
 829         local cur="${COMP_WORDS[COMP_CWORD]}"
 830         local prv="${COMP_WORDS[COMP_CWORD-1]}"
 831         case "$prv" in
 832         branch.*.remote)
 833                 __gitcomp "$(__git_remotes)"
 834                 return
 835                 ;;
 836         branch.*.merge)
 837                 __gitcomp "$(__git_refs)"
 838                 return
 839                 ;;
 840         remote.*.fetch)
 841                 local remote="${prv#remote.}"
 842                 remote="${remote%.fetch}"
 843                 __gitcomp "$(__git_refs_remotes "$remote")"
 844                 return
 845                 ;;
 846         remote.*.push)
 847                 local remote="${prv#remote.}"
 848                 remote="${remote%.push}"
 849                 __gitcomp "$(git --git-dir="$(__gitdir)" \
 850                         for-each-ref --format='%(refname):%(refname)' \
 851                         refs/heads)"
 852                 return
 853                 ;;
 854         pull.twohead|pull.octopus)
 855                 __gitcomp "$(__git_merge_strategies)"
 856                 return
 857                 ;;
 858         color.branch|color.diff|color.status)
 859                 __gitcomp "always never auto"
 860                 return
 861                 ;;
 862         color.*.*)
 863                 __gitcomp "
 864                         black red green yellow blue magenta cyan white
 865                         bold dim ul blink reverse
 866                         "
 867                 return
 868                 ;;
 869         *.*)
 870                 COMPREPLY=()
 871                 return
 872                 ;;
 873         esac
 874         case "$cur" in
 875         --*)
 876                 __gitcomp "
 877                         --global --system --file=
 878                         --list --replace-all
 879                         --get --get-all --get-regexp
 880                         --add --unset --unset-all
 881                         --remove-section --rename-section
 882                         "
 883                 return
 884                 ;;
 885         branch.*.*)
 886                 local pfx="${cur%.*}."
 887                 cur="${cur##*.}"
 888                 __gitcomp "remote merge" "$pfx" "$cur"
 889                 return
 890                 ;;
 891         branch.*)
 892                 local pfx="${cur%.*}."
 893                 cur="${cur#*.}"
 894                 __gitcomp "$(__git_heads)" "$pfx" "$cur" "."
 895                 return
 896                 ;;
 897         remote.*.*)
 898                 local pfx="${cur%.*}."
 899                 cur="${cur##*.}"
 900                 __gitcomp "
 901                         url fetch push skipDefaultUpdate
 902                         receivepack uploadpack tagopt
 903                         " "$pfx" "$cur"
 904                 return
 905                 ;;
 906         remote.*)
 907                 local pfx="${cur%.*}."
 908                 cur="${cur#*.}"
 909                 __gitcomp "$(__git_remotes)" "$pfx" "$cur" "."
 910                 return
 911                 ;;
 912         esac
 913         __gitcomp "
 914                 apply.whitespace
 915                 core.fileMode
 916                 core.gitProxy
 917                 core.ignoreStat
 918                 core.preferSymlinkRefs
 919                 core.logAllRefUpdates
 920                 core.loosecompression
 921                 core.repositoryFormatVersion
 922                 core.sharedRepository
 923                 core.warnAmbiguousRefs
 924                 core.compression
 925                 core.legacyHeaders
 926                 core.packedGitWindowSize
 927                 core.packedGitLimit
 928                 clean.requireForce
 929                 color.branch
 930                 color.branch.current
 931                 color.branch.local
 932                 color.branch.remote
 933                 color.branch.plain
 934                 color.diff
 935                 color.diff.plain
 936                 color.diff.meta
 937                 color.diff.frag
 938                 color.diff.old
 939                 color.diff.new
 940                 color.diff.commit
 941                 color.diff.whitespace
 942                 color.pager
 943                 color.status
 944                 color.status.header
 945                 color.status.added
 946                 color.status.changed
 947                 color.status.untracked
 948                 diff.renameLimit
 949                 diff.renames
 950                 fetch.unpackLimit
 951                 format.headers
 952                 format.subjectprefix
 953                 gitcvs.enabled
 954                 gitcvs.logfile
 955                 gitcvs.allbinary
 956                 gitcvs.dbname gitcvs.dbdriver gitcvs.dbuser gitcvs.dvpass
 957                 gc.packrefs
 958                 gc.reflogexpire
 959                 gc.reflogexpireunreachable
 960                 gc.rerereresolved
 961                 gc.rerereunresolved
 962                 http.sslVerify
 963                 http.sslCert
 964                 http.sslKey
 965                 http.sslCAInfo
 966                 http.sslCAPath
 967                 http.maxRequests
 968                 http.lowSpeedLimit
 969                 http.lowSpeedTime
 970                 http.noEPSV
 971                 i18n.commitEncoding
 972                 i18n.logOutputEncoding
 973                 log.showroot
 974                 merge.tool
 975                 merge.summary
 976                 merge.verbosity
 977                 pack.window
 978                 pack.depth
 979                 pack.windowMemory
 980                 pack.compression
 981                 pack.deltaCacheSize
 982                 pack.deltaCacheLimit
 983                 pull.octopus
 984                 pull.twohead
 985                 repack.useDeltaBaseOffset
 986                 show.difftree
 987                 showbranch.default
 988                 tar.umask
 989                 transfer.unpackLimit
 990                 receive.unpackLimit
 991                 receive.denyNonFastForwards
 992                 user.name
 993                 user.email
 994                 user.signingkey
 995                 whatchanged.difftree
 996                 branch. remote.
 997         "
 998 }
 999
1000 _git_remote ()
1001 {
1002         local i c=1 command
1003         while [ $c -lt $COMP_CWORD ]; do
1004                 i="${COMP_WORDS[c]}"
1005                 case "$i" in
1006                 add|rm|show|prune|update) command="$i"; break ;;
1007                 esac
1008                 c=$((++c))
1009         done
1010
1011         if [ $c -eq $COMP_CWORD -a -z "$command" ]; then
1012                 __gitcomp "add rm show prune update"
1013                 return
1014         fi
1015
1016         case "$command" in
1017         rm|show|prune)
1018                 __gitcomp "$(__git_remotes)"
1019                 ;;
1020         update)
1021                 local i c='' IFS=$'\n'
1022                 for i in $(git --git-dir="$(__gitdir)" config --list); do
1023                         case "$i" in
1024                         remotes.*)
1025                                 i="${i#remotes.}"
1026                                 c="$c ${i/=*/}"
1027                                 ;;
1028                         esac
1029                 done
1030                 __gitcomp "$c"
1031                 ;;
1032         *)
1033                 COMPREPLY=()
1034                 ;;
1035         esac
1036 }
1037
1038 _git_reset ()
1039 {
1040         local cur="${COMP_WORDS[COMP_CWORD]}"
1041         case "$cur" in
1042         --*)
1043                 __gitcomp "--mixed --hard --soft"
1044                 return
1045                 ;;
1046         esac
1047         __gitcomp "$(__git_refs)"
1048 }
1049
1050 _git_shortlog ()
1051 {
1052         local cur="${COMP_WORDS[COMP_CWORD]}"
1053         case "$cur" in
1054         --*)
1055                 __gitcomp "
1056                         --max-count= --max-age= --since= --after=
1057                         --min-age= --before= --until=
1058                         --no-merges
1059                         --author= --committer= --grep=
1060                         --all-match
1061                         --not --all
1062                         --numbered --summary
1063                         "
1064                 return
1065                 ;;
1066         esac
1067         __git_complete_revlist
1068 }
1069
1070 _git_show ()
1071 {
1072         local cur="${COMP_WORDS[COMP_CWORD]}"
1073         case "$cur" in
1074         --pretty=*)
1075                 __gitcomp "
1076                         oneline short medium full fuller email raw
1077                         " "" "${cur##--pretty=}"
1078                 return
1079                 ;;
1080         --*)
1081                 __gitcomp "--pretty="
1082                 return
1083                 ;;
1084         esac
1085         __git_complete_file
1086 }
1087
1088 _git_stash ()
1089 {
1090         __gitcomp 'list show apply clear'
1091 }
1092
1093 _git_submodule ()
1094 {
1095         local i c=1 command
1096         while [ $c -lt $COMP_CWORD ]; do
1097                 i="${COMP_WORDS[c]}"
1098                 case "$i" in
1099                 add|status|init|update) command="$i"; break ;;
1100                 esac
1101                 c=$((++c))
1102         done
1103
1104         if [ $c -eq $COMP_CWORD -a -z "$command" ]; then
1105                 local cur="${COMP_WORDS[COMP_CWORD]}"
1106                 case "$cur" in
1107                 --*)
1108                         __gitcomp "--quiet --cached"
1109                         ;;
1110                 *)
1111                         __gitcomp "add status init update"
1112                         ;;
1113                 esac
1114                 return
1115         fi
1116 }
1117
1118 _git_tag ()
1119 {
1120         local i c=1 f=0
1121         while [ $c -lt $COMP_CWORD ]; do
1122                 i="${COMP_WORDS[c]}"
1123                 case "$i" in
1124                 -d|-v)
1125                         __gitcomp "$(__git_tags)"
1126                         return
1127                         ;;
1128                 -f)
1129                         f=1
1130                         ;;
1131                 esac
1132                 c=$((++c))
1133         done
1134
1135         case "${COMP_WORDS[COMP_CWORD-1]}" in
1136         -m|-F)
1137                 COMPREPLY=()
1138                 ;;
1139         -*|tag|git-tag)
1140                 if [ $f = 1 ]; then
1141                         __gitcomp "$(__git_tags)"
1142                 else
1143                         COMPREPLY=()
1144                 fi
1145                 ;;
1146         *)
1147                 __gitcomp "$(__git_refs)"
1148                 ;;
1149         esac
1150 }
1151
1152 _git ()
1153 {
1154         local i c=1 command __git_dir
1155
1156         while [ $c -lt $COMP_CWORD ]; do
1157                 i="${COMP_WORDS[c]}"
1158                 case "$i" in
1159                 --git-dir=*) __git_dir="${i#--git-dir=}" ;;
1160                 --bare)      __git_dir="." ;;
1161                 --version|--help|-p|--paginate) ;;
1162                 *) command="$i"; break ;;
1163                 esac
1164                 c=$((++c))
1165         done
1166
1167         if [ $c -eq $COMP_CWORD -a -z "$command" ]; then
1168                 case "${COMP_WORDS[COMP_CWORD]}" in
1169                 --*=*) COMPREPLY=() ;;
1170                 --*)   __gitcomp "
1171                         --no-pager
1172                         --git-dir=
1173                         --bare
1174                         --version
1175                         --exec-path
1176                         "
1177                         ;;
1178                 *)     __gitcomp "$(__git_commands) $(__git_aliases)" ;;
1179                 esac
1180                 return
1181         fi
1182
1183         local expansion=$(__git_aliased_command "$command")
1184         [ "$expansion" ] && command="$expansion"
1185
1186         case "$command" in
1187         am)          _git_am ;;
1188         add)         _git_add ;;
1189         apply)       _git_apply ;;
1190         bisect)      _git_bisect ;;
1191         bundle)      _git_bundle ;;
1192         branch)      _git_branch ;;
1193         checkout)    _git_checkout ;;
1194         cherry)      _git_cherry ;;
1195         cherry-pick) _git_cherry_pick ;;
1196         commit)      _git_commit ;;
1197         config)      _git_config ;;
1198         describe)    _git_describe ;;
1199         diff)        _git_diff ;;
1200         fetch)       _git_fetch ;;
1201         format-patch) _git_format_patch ;;
1202         gc)          _git_gc ;;
1203         log)         _git_log ;;
1204         ls-remote)   _git_ls_remote ;;
1205         ls-tree)     _git_ls_tree ;;
1206         merge)       _git_merge;;
1207         merge-base)  _git_merge_base ;;
1208         name-rev)    _git_name_rev ;;
1209         pull)        _git_pull ;;
1210         push)        _git_push ;;
1211         rebase)      _git_rebase ;;
1212         remote)      _git_remote ;;
1213         reset)       _git_reset ;;
1214         shortlog)    _git_shortlog ;;
1215         show)        _git_show ;;
1216         show-branch) _git_log ;;
1217         stash)       _git_stash ;;
1218         submodule)   _git_submodule ;;
1219         tag)         _git_tag ;;
1220         whatchanged) _git_log ;;
1221         *)           COMPREPLY=() ;;
1222         esac
1223 }
1224
1225 _gitk ()
1226 {
1227         local cur="${COMP_WORDS[COMP_CWORD]}"
1228         case "$cur" in
1229         --*)
1230                 __gitcomp "--not --all"
1231                 return
1232                 ;;
1233         esac
1234         __git_complete_revlist
1235 }
1236
1237 complete -o default -o nospace -F _git git
1238 complete -o default -o nospace -F _gitk gitk
1239 complete -o default -o nospace -F _git_am git-am
1240 complete -o default -o nospace -F _git_apply git-apply
1241 complete -o default -o nospace -F _git_bisect git-bisect
1242 complete -o default -o nospace -F _git_branch git-branch
1243 complete -o default -o nospace -F _git_bundle git-bundle
1244 complete -o default -o nospace -F _git_checkout git-checkout
1245 complete -o default -o nospace -F _git_cherry git-cherry
1246 complete -o default -o nospace -F _git_cherry_pick git-cherry-pick
1247 complete -o default -o nospace -F _git_commit git-commit
1248 complete -o default -o nospace -F _git_describe git-describe
1249 complete -o default -o nospace -F _git_diff git-diff
1250 complete -o default -o nospace -F _git_fetch git-fetch
1251 complete -o default -o nospace -F _git_format_patch git-format-patch
1252 complete -o default -o nospace -F _git_gc git-gc
1253 complete -o default -o nospace -F _git_log git-log
1254 complete -o default -o nospace -F _git_ls_remote git-ls-remote
1255 complete -o default -o nospace -F _git_ls_tree git-ls-tree
1256 complete -o default -o nospace -F _git_merge git-merge
1257 complete -o default -o nospace -F _git_merge_base git-merge-base
1258 complete -o default -o nospace -F _git_name_rev git-name-rev
1259 complete -o default -o nospace -F _git_pull git-pull
1260 complete -o default -o nospace -F _git_push git-push
1261 complete -o default -o nospace -F _git_rebase git-rebase
1262 complete -o default -o nospace -F _git_config git-config
1263 complete -o default -o nospace -F _git_remote git-remote
1264 complete -o default -o nospace -F _git_reset git-reset
1265 complete -o default -o nospace -F _git_shortlog git-shortlog
1266 complete -o default -o nospace -F _git_show git-show
1267 complete -o default -o nospace -F _git_stash git-stash
1268 complete -o default -o nospace -F _git_submodule git-submodule
1269 complete -o default -o nospace -F _git_log git-show-branch
1270 complete -o default -o nospace -F _git_tag git-tag
1271 complete -o default -o nospace -F _git_log git-whatchanged
1272
1273 # The following are necessary only for Cygwin, and only are needed
1274 # when the user has tab-completed the executable name and consequently
1275 # included the '.exe' suffix.
1276 #
1277 if [ Cygwin = "$(uname -o 2>/dev/null)" ]; then
1278 complete -o default -o nospace -F _git_add git-add.exe
1279 complete -o default -o nospace -F _git_apply git-apply.exe
1280 complete -o default -o nospace -F _git git.exe
1281 complete -o default -o nospace -F _git_branch git-branch.exe
1282 complete -o default -o nospace -F _git_bundle git-bundle.exe
1283 complete -o default -o nospace -F _git_cherry git-cherry.exe
1284 complete -o default -o nospace -F _git_describe git-describe.exe
1285 complete -o default -o nospace -F _git_diff git-diff.exe
1286 complete -o default -o nospace -F _git_format_patch git-format-patch.exe
1287 complete -o default -o nospace -F _git_log git-log.exe
1288 complete -o default -o nospace -F _git_ls_tree git-ls-tree.exe
1289 complete -o default -o nospace -F _git_merge_base git-merge-base.exe
1290 complete -o default -o nospace -F _git_name_rev git-name-rev.exe
1291 complete -o default -o nospace -F _git_push git-push.exe
1292 complete -o default -o nospace -F _git_config git-config
1293 complete -o default -o nospace -F _git_shortlog git-shortlog.exe
1294 complete -o default -o nospace -F _git_show git-show.exe
1295 complete -o default -o nospace -F _git_log git-show-branch.exe
1296 complete -o default -o nospace -F _git_tag git-tag.exe
1297 complete -o default -o nospace -F _git_log git-whatchanged.exe
1298 fi