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