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                         --no-prefix --src-prefix= --dst-prefix=
 644                         --base --ours --theirs
 645                         "
 646                 return
 647                 ;;
 648         esac
 649         __git_complete_file
 650 }
 651
 652 _git_diff_tree ()
 653 {
 654         __gitcomp "$(__git_refs)"
 655 }
 656
 657 _git_fetch ()
 658 {
 659         local cur="${COMP_WORDS[COMP_CWORD]}"
 660
 661         case "${COMP_WORDS[0]},$COMP_CWORD" in
 662         git-fetch*,1)
 663                 __gitcomp "$(__git_remotes)"
 664                 ;;
 665         git,2)
 666                 __gitcomp "$(__git_remotes)"
 667                 ;;
 668         *)
 669                 case "$cur" in
 670                 *:*)
 671                         __gitcomp "$(__git_refs)" "" "${cur#*:}"
 672                         ;;
 673                 *)
 674                         local remote
 675                         case "${COMP_WORDS[0]}" in
 676                         git-fetch) remote="${COMP_WORDS[1]}" ;;
 677                         git)       remote="${COMP_WORDS[2]}" ;;
 678                         esac
 679                         __gitcomp "$(__git_refs2 "$remote")"
 680                         ;;
 681                 esac
 682                 ;;
 683         esac
 684 }
 685
 686 _git_format_patch ()
 687 {
 688         local cur="${COMP_WORDS[COMP_CWORD]}"
 689         case "$cur" in
 690         --*)
 691                 __gitcomp "
 692                         --stdout --attach --thread
 693                         --output-directory
 694                         --numbered --start-number
 695                         --numbered-files
 696                         --keep-subject
 697                         --signoff
 698                         --in-reply-to=
 699                         --full-index --binary
 700                         --not --all
 701                         --cover-letter
 702                         --no-prefix --src-prefix= --dst-prefix=
 703                         "
 704                 return
 705                 ;;
 706         esac
 707         __git_complete_revlist
 708 }
 709
 710 _git_gc ()
 711 {
 712         local cur="${COMP_WORDS[COMP_CWORD]}"
 713         case "$cur" in
 714         --*)
 715                 __gitcomp "--prune --aggressive"
 716                 return
 717                 ;;
 718         esac
 719         COMPREPLY=()
 720 }
 721
 722 _git_ls_remote ()
 723 {
 724         __gitcomp "$(__git_remotes)"
 725 }
 726
 727 _git_ls_tree ()
 728 {
 729         __git_complete_file
 730 }
 731
 732 _git_log ()
 733 {
 734         local cur="${COMP_WORDS[COMP_CWORD]}"
 735         case "$cur" in
 736         --pretty=*)
 737                 __gitcomp "
 738                         oneline short medium full fuller email raw
 739                         " "" "${cur##--pretty=}"
 740                 return
 741                 ;;
 742         --date=*)
 743                 __gitcomp "
 744                         relative iso8601 rfc2822 short local default
 745                 " "" "${cur##--date=}"
 746                 return
 747                 ;;
 748         --*)
 749                 __gitcomp "
 750                         --max-count= --max-age= --since= --after=
 751                         --min-age= --before= --until=
 752                         --root --topo-order --date-order --reverse
 753                         --no-merges --follow
 754                         --abbrev-commit --abbrev=
 755                         --relative-date --date=
 756                         --author= --committer= --grep=
 757                         --all-match
 758                         --pretty= --name-status --name-only --raw
 759                         --not --all
 760                         --left-right --cherry-pick
 761                         "
 762                 return
 763                 ;;
 764         esac
 765         __git_complete_revlist
 766 }
 767
 768 _git_merge ()
 769 {
 770         local cur="${COMP_WORDS[COMP_CWORD]}"
 771         case "${COMP_WORDS[COMP_CWORD-1]}" in
 772         -s|--strategy)
 773                 __gitcomp "$(__git_merge_strategies)"
 774                 return
 775         esac
 776         case "$cur" in
 777         --strategy=*)
 778                 __gitcomp "$(__git_merge_strategies)" "" "${cur##--strategy=}"
 779                 return
 780                 ;;
 781         --*)
 782                 __gitcomp "
 783                         --no-commit --no-stat --log --no-log --squash --strategy
 784                         "
 785                 return
 786         esac
 787         __gitcomp "$(__git_refs)"
 788 }
 789
 790 _git_merge_base ()
 791 {
 792         __gitcomp "$(__git_refs)"
 793 }
 794
 795 _git_name_rev ()
 796 {
 797         __gitcomp "--tags --all --stdin"
 798 }
 799
 800 _git_pull ()
 801 {
 802         local cur="${COMP_WORDS[COMP_CWORD]}"
 803
 804         case "${COMP_WORDS[0]},$COMP_CWORD" in
 805         git-pull*,1)
 806                 __gitcomp "$(__git_remotes)"
 807                 ;;
 808         git,2)
 809                 __gitcomp "$(__git_remotes)"
 810                 ;;
 811         *)
 812                 local remote
 813                 case "${COMP_WORDS[0]}" in
 814                 git-pull)  remote="${COMP_WORDS[1]}" ;;
 815                 git)       remote="${COMP_WORDS[2]}" ;;
 816                 esac
 817                 __gitcomp "$(__git_refs "$remote")"
 818                 ;;
 819         esac
 820 }
 821
 822 _git_push ()
 823 {
 824         local cur="${COMP_WORDS[COMP_CWORD]}"
 825
 826         case "${COMP_WORDS[0]},$COMP_CWORD" in
 827         git-push*,1)
 828                 __gitcomp "$(__git_remotes)"
 829                 ;;
 830         git,2)
 831                 __gitcomp "$(__git_remotes)"
 832                 ;;
 833         *)
 834                 case "$cur" in
 835                 *:*)
 836                         local remote
 837                         case "${COMP_WORDS[0]}" in
 838                         git-push)  remote="${COMP_WORDS[1]}" ;;
 839                         git)       remote="${COMP_WORDS[2]}" ;;
 840                         esac
 841                         __gitcomp "$(__git_refs "$remote")" "" "${cur#*:}"
 842                         ;;
 843                 +*)
 844                         __gitcomp "$(__git_refs)" + "${cur#+}"
 845                         ;;
 846                 *)
 847                         __gitcomp "$(__git_refs)"
 848                         ;;
 849                 esac
 850                 ;;
 851         esac
 852 }
 853
 854 _git_rebase ()
 855 {
 856         local cur="${COMP_WORDS[COMP_CWORD]}" dir="$(__gitdir)"
 857         if [ -d .dotest ] || [ -d "$dir"/.dotest-merge ]; then
 858                 __gitcomp "--continue --skip --abort"
 859                 return
 860         fi
 861         case "${COMP_WORDS[COMP_CWORD-1]}" in
 862         -s|--strategy)
 863                 __gitcomp "$(__git_merge_strategies)"
 864                 return
 865         esac
 866         case "$cur" in
 867         --strategy=*)
 868                 __gitcomp "$(__git_merge_strategies)" "" "${cur##--strategy=}"
 869                 return
 870                 ;;
 871         --*)
 872                 __gitcomp "--onto --merge --strategy --interactive"
 873                 return
 874         esac
 875         __gitcomp "$(__git_refs)"
 876 }
 877
 878 _git_config ()
 879 {
 880         local cur="${COMP_WORDS[COMP_CWORD]}"
 881         local prv="${COMP_WORDS[COMP_CWORD-1]}"
 882         case "$prv" in
 883         branch.*.remote)
 884                 __gitcomp "$(__git_remotes)"
 885                 return
 886                 ;;
 887         branch.*.merge)
 888                 __gitcomp "$(__git_refs)"
 889                 return
 890                 ;;
 891         remote.*.fetch)
 892                 local remote="${prv#remote.}"
 893                 remote="${remote%.fetch}"
 894                 __gitcomp "$(__git_refs_remotes "$remote")"
 895                 return
 896                 ;;
 897         remote.*.push)
 898                 local remote="${prv#remote.}"
 899                 remote="${remote%.push}"
 900                 __gitcomp "$(git --git-dir="$(__gitdir)" \
 901                         for-each-ref --format='%(refname):%(refname)' \
 902                         refs/heads)"
 903                 return
 904                 ;;
 905         pull.twohead|pull.octopus)
 906                 __gitcomp "$(__git_merge_strategies)"
 907                 return
 908                 ;;
 909         color.branch|color.diff|color.status)
 910                 __gitcomp "always never auto"
 911                 return
 912                 ;;
 913         color.*.*)
 914                 __gitcomp "
 915                         black red green yellow blue magenta cyan white
 916                         bold dim ul blink reverse
 917                         "
 918                 return
 919                 ;;
 920         *.*)
 921                 COMPREPLY=()
 922                 return
 923                 ;;
 924         esac
 925         case "$cur" in
 926         --*)
 927                 __gitcomp "
 928                         --global --system --file=
 929                         --list --replace-all
 930                         --get --get-all --get-regexp
 931                         --add --unset --unset-all
 932                         --remove-section --rename-section
 933                         "
 934                 return
 935                 ;;
 936         branch.*.*)
 937                 local pfx="${cur%.*}."
 938                 cur="${cur##*.}"
 939                 __gitcomp "remote merge" "$pfx" "$cur"
 940                 return
 941                 ;;
 942         branch.*)
 943                 local pfx="${cur%.*}."
 944                 cur="${cur#*.}"
 945                 __gitcomp "$(__git_heads)" "$pfx" "$cur" "."
 946                 return
 947                 ;;
 948         remote.*.*)
 949                 local pfx="${cur%.*}."
 950                 cur="${cur##*.}"
 951                 __gitcomp "
 952                         url fetch push skipDefaultUpdate
 953                         receivepack uploadpack tagopt
 954                         " "$pfx" "$cur"
 955                 return
 956                 ;;
 957         remote.*)
 958                 local pfx="${cur%.*}."
 959                 cur="${cur#*.}"
 960                 __gitcomp "$(__git_remotes)" "$pfx" "$cur" "."
 961                 return
 962                 ;;
 963         esac
 964         __gitcomp "
 965                 apply.whitespace
 966                 core.fileMode
 967                 core.gitProxy
 968                 core.ignoreStat
 969                 core.preferSymlinkRefs
 970                 core.logAllRefUpdates
 971                 core.loosecompression
 972                 core.repositoryFormatVersion
 973                 core.sharedRepository
 974                 core.warnAmbiguousRefs
 975                 core.compression
 976                 core.packedGitWindowSize
 977                 core.packedGitLimit
 978                 clean.requireForce
 979                 color.branch
 980                 color.branch.current
 981                 color.branch.local
 982                 color.branch.remote
 983                 color.branch.plain
 984                 color.diff
 985                 color.diff.plain
 986                 color.diff.meta
 987                 color.diff.frag
 988                 color.diff.old
 989                 color.diff.new
 990                 color.diff.commit
 991                 color.diff.whitespace
 992                 color.pager
 993                 color.status
 994                 color.status.header
 995                 color.status.added
 996                 color.status.changed
 997                 color.status.untracked
 998                 diff.renameLimit
 999                 diff.renames
1000                 fetch.unpackLimit
1001                 format.headers
1002                 format.subjectprefix
1003                 gitcvs.enabled
1004                 gitcvs.logfile
1005                 gitcvs.allbinary
1006                 gitcvs.dbname gitcvs.dbdriver gitcvs.dbuser gitcvs.dbpass
1007                 gitcvs.dbtablenameprefix
1008                 gc.packrefs
1009                 gc.reflogexpire
1010                 gc.reflogexpireunreachable
1011                 gc.rerereresolved
1012                 gc.rerereunresolved
1013                 http.sslVerify
1014                 http.sslCert
1015                 http.sslKey
1016                 http.sslCAInfo
1017                 http.sslCAPath
1018                 http.maxRequests
1019                 http.lowSpeedLimit
1020                 http.lowSpeedTime
1021                 http.noEPSV
1022                 i18n.commitEncoding
1023                 i18n.logOutputEncoding
1024                 log.showroot
1025                 merge.tool
1026                 merge.summary
1027                 merge.verbosity
1028                 pack.window
1029                 pack.depth
1030                 pack.windowMemory
1031                 pack.compression
1032                 pack.deltaCacheSize
1033                 pack.deltaCacheLimit
1034                 pull.octopus
1035                 pull.twohead
1036                 repack.useDeltaBaseOffset
1037                 show.difftree
1038                 showbranch.default
1039                 tar.umask
1040                 transfer.unpackLimit
1041                 receive.unpackLimit
1042                 receive.denyNonFastForwards
1043                 user.name
1044                 user.email
1045                 user.signingkey
1046                 whatchanged.difftree
1047                 branch. remote.
1048         "
1049 }
1050
1051 _git_remote ()
1052 {
1053         local subcommands="add rm show prune update"
1054         local subcommand="$(__git_find_subcommand "$subcommands")"
1055         if [ -z "$subcommand" ]; then
1056                 __gitcomp "$subcommands"
1057                 return
1058         fi
1059
1060         case "$subcommand" in
1061         rm|show|prune)
1062                 __gitcomp "$(__git_remotes)"
1063                 ;;
1064         update)
1065                 local i c='' IFS=$'\n'
1066                 for i in $(git --git-dir="$(__gitdir)" config --list); do
1067                         case "$i" in
1068                         remotes.*)
1069                                 i="${i#remotes.}"
1070                                 c="$c ${i/=*/}"
1071                                 ;;
1072                         esac
1073                 done
1074                 __gitcomp "$c"
1075                 ;;
1076         *)
1077                 COMPREPLY=()
1078                 ;;
1079         esac
1080 }
1081
1082 _git_reset ()
1083 {
1084         local cur="${COMP_WORDS[COMP_CWORD]}"
1085         case "$cur" in
1086         --*)
1087                 __gitcomp "--mixed --hard --soft"
1088                 return
1089                 ;;
1090         esac
1091         __gitcomp "$(__git_refs)"
1092 }
1093
1094 _git_shortlog ()
1095 {
1096         local cur="${COMP_WORDS[COMP_CWORD]}"
1097         case "$cur" in
1098         --*)
1099                 __gitcomp "
1100                         --max-count= --max-age= --since= --after=
1101                         --min-age= --before= --until=
1102                         --no-merges
1103                         --author= --committer= --grep=
1104                         --all-match
1105                         --not --all
1106                         --numbered --summary
1107                         "
1108                 return
1109                 ;;
1110         esac
1111         __git_complete_revlist
1112 }
1113
1114 _git_show ()
1115 {
1116         local cur="${COMP_WORDS[COMP_CWORD]}"
1117         case "$cur" in
1118         --pretty=*)
1119                 __gitcomp "
1120                         oneline short medium full fuller email raw
1121                         " "" "${cur##--pretty=}"
1122                 return
1123                 ;;
1124         --*)
1125                 __gitcomp "--pretty="
1126                 return
1127                 ;;
1128         esac
1129         __git_complete_file
1130 }
1131
1132 _git_stash ()
1133 {
1134         local subcommands='save list show apply clear drop pop create'
1135         if [ -z "$(__git_find_subcommand "$subcommands")" ]; then
1136                 __gitcomp "$subcommands"
1137         fi
1138 }
1139
1140 _git_submodule ()
1141 {
1142         local subcommands="add status init update"
1143         if [ -z "$(__git_find_subcommand "$subcommands")" ]; then
1144                 local cur="${COMP_WORDS[COMP_CWORD]}"
1145                 case "$cur" in
1146                 --*)
1147                         __gitcomp "--quiet --cached"
1148                         ;;
1149                 *)
1150                         __gitcomp "$subcommands"
1151                         ;;
1152                 esac
1153                 return
1154         fi
1155 }
1156
1157 _git_svn ()
1158 {
1159         local subcommands="
1160                 init fetch clone rebase dcommit log find-rev
1161                 set-tree commit-diff info create-ignore propget
1162                 proplist show-ignore show-externals
1163                 "
1164         local subcommand="$(__git_find_subcommand "$subcommands")"
1165         if [ -z "$subcommand" ]; then
1166                 __gitcomp "$subcommands"
1167         else
1168                 local remote_opts="--username= --config-dir= --no-auth-cache"
1169                 local fc_opts="
1170                         --follow-parent --authors-file= --repack=
1171                         --no-metadata --use-svm-props --use-svnsync-props
1172                         --log-window-size= --no-checkout --quiet
1173                         --repack-flags --user-log-author $remote_opts
1174                         "
1175                 local init_opts="
1176                         --template= --shared= --trunk= --tags=
1177                         --branches= --stdlayout --minimize-url
1178                         --no-metadata --use-svm-props --use-svnsync-props
1179                         --rewrite-root= $remote_opts
1180                         "
1181                 local cmt_opts="
1182                         --edit --rmdir --find-copies-harder --copy-similarity=
1183                         "
1184
1185                 local cur="${COMP_WORDS[COMP_CWORD]}"
1186                 case "$subcommand,$cur" in
1187                 fetch,--*)
1188                         __gitcomp "--revision= --fetch-all $fc_opts"
1189                         ;;
1190                 clone,--*)
1191                         __gitcomp "--revision= $fc_opts $init_opts"
1192                         ;;
1193                 init,--*)
1194                         __gitcomp "$init_opts"
1195                         ;;
1196                 dcommit,--*)
1197                         __gitcomp "
1198                                 --merge --strategy= --verbose --dry-run
1199                                 --fetch-all --no-rebase $cmt_opts $fc_opts
1200                                 "
1201                         ;;
1202                 set-tree,--*)
1203                         __gitcomp "--stdin $cmt_opts $fc_opts"
1204                         ;;
1205                 create-ignore,--*|propget,--*|proplist,--*|show-ignore,--*|\
1206                 show-externals,--*)
1207                         __gitcomp "--revision="
1208                         ;;
1209                 log,--*)
1210                         __gitcomp "
1211                                 --limit= --revision= --verbose --incremental
1212                                 --oneline --show-commit --non-recursive
1213                                 --authors-file=
1214                                 "
1215                         ;;
1216                 rebase,--*)
1217                         __gitcomp "
1218                                 --merge --verbose --strategy= --local
1219                                 --fetch-all $fc_opts
1220                                 "
1221                         ;;
1222                 commit-diff,--*)
1223                         __gitcomp "--message= --file= --revision= $cmt_opts"
1224                         ;;
1225                 info,--*)
1226                         __gitcomp "--url"
1227                         ;;
1228                 *)
1229                         COMPREPLY=()
1230                         ;;
1231                 esac
1232         fi
1233 }
1234
1235 _git_tag ()
1236 {
1237         local i c=1 f=0
1238         while [ $c -lt $COMP_CWORD ]; do
1239                 i="${COMP_WORDS[c]}"
1240                 case "$i" in
1241                 -d|-v)
1242                         __gitcomp "$(__git_tags)"
1243                         return
1244                         ;;
1245                 -f)
1246                         f=1
1247                         ;;
1248                 esac
1249                 c=$((++c))
1250         done
1251
1252         case "${COMP_WORDS[COMP_CWORD-1]}" in
1253         -m|-F)
1254                 COMPREPLY=()
1255                 ;;
1256         -*|tag|git-tag)
1257                 if [ $f = 1 ]; then
1258                         __gitcomp "$(__git_tags)"
1259                 else
1260                         COMPREPLY=()
1261                 fi
1262                 ;;
1263         *)
1264                 __gitcomp "$(__git_refs)"
1265                 ;;
1266         esac
1267 }
1268
1269 _git ()
1270 {
1271         local i c=1 command __git_dir
1272
1273         while [ $c -lt $COMP_CWORD ]; do
1274                 i="${COMP_WORDS[c]}"
1275                 case "$i" in
1276                 --git-dir=*) __git_dir="${i#--git-dir=}" ;;
1277                 --bare)      __git_dir="." ;;
1278                 --version|--help|-p|--paginate) ;;
1279                 *) command="$i"; break ;;
1280                 esac
1281                 c=$((++c))
1282         done
1283
1284         if [ -z "$command" ]; then
1285                 case "${COMP_WORDS[COMP_CWORD]}" in
1286                 --*=*) COMPREPLY=() ;;
1287                 --*)   __gitcomp "
1288                         --paginate
1289                         --no-pager
1290                         --git-dir=
1291                         --bare
1292                         --version
1293                         --exec-path
1294                         --work-tree=
1295                         --help
1296                         "
1297                         ;;
1298                 *)     __gitcomp "$(__git_commands) $(__git_aliases)" ;;
1299                 esac
1300                 return
1301         fi
1302
1303         local expansion=$(__git_aliased_command "$command")
1304         [ "$expansion" ] && command="$expansion"
1305
1306         case "$command" in
1307         am)          _git_am ;;
1308         add)         _git_add ;;
1309         apply)       _git_apply ;;
1310         bisect)      _git_bisect ;;
1311         bundle)      _git_bundle ;;
1312         branch)      _git_branch ;;
1313         checkout)    _git_checkout ;;
1314         cherry)      _git_cherry ;;
1315         cherry-pick) _git_cherry_pick ;;
1316         commit)      _git_commit ;;
1317         config)      _git_config ;;
1318         describe)    _git_describe ;;
1319         diff)        _git_diff ;;
1320         fetch)       _git_fetch ;;
1321         format-patch) _git_format_patch ;;
1322         gc)          _git_gc ;;
1323         log)         _git_log ;;
1324         ls-remote)   _git_ls_remote ;;
1325         ls-tree)     _git_ls_tree ;;
1326         merge)       _git_merge;;
1327         merge-base)  _git_merge_base ;;
1328         name-rev)    _git_name_rev ;;
1329         pull)        _git_pull ;;
1330         push)        _git_push ;;
1331         rebase)      _git_rebase ;;
1332         remote)      _git_remote ;;
1333         reset)       _git_reset ;;
1334         shortlog)    _git_shortlog ;;
1335         show)        _git_show ;;
1336         show-branch) _git_log ;;
1337         stash)       _git_stash ;;
1338         submodule)   _git_submodule ;;
1339         svn)         _git_svn ;;
1340         tag)         _git_tag ;;
1341         whatchanged) _git_log ;;
1342         *)           COMPREPLY=() ;;
1343         esac
1344 }
1345
1346 _gitk ()
1347 {
1348         local cur="${COMP_WORDS[COMP_CWORD]}"
1349         local g="$(git rev-parse --git-dir 2>/dev/null)"
1350         local merge=""
1351         if [ -f $g/MERGE_HEAD ]; then
1352                 merge="--merge"
1353         fi
1354         case "$cur" in
1355         --*)
1356                 __gitcomp "--not --all $merge"
1357                 return
1358                 ;;
1359         esac
1360         __git_complete_revlist
1361 }
1362
1363 complete -o default -o nospace -F _git git
1364 complete -o default -o nospace -F _gitk gitk
1365 complete -o default -o nospace -F _git_am git-am
1366 complete -o default -o nospace -F _git_apply git-apply
1367 complete -o default -o nospace -F _git_bisect git-bisect
1368 complete -o default -o nospace -F _git_branch git-branch
1369 complete -o default -o nospace -F _git_bundle git-bundle
1370 complete -o default -o nospace -F _git_checkout git-checkout
1371 complete -o default -o nospace -F _git_cherry git-cherry
1372 complete -o default -o nospace -F _git_cherry_pick git-cherry-pick
1373 complete -o default -o nospace -F _git_commit git-commit
1374 complete -o default -o nospace -F _git_describe git-describe
1375 complete -o default -o nospace -F _git_diff git-diff
1376 complete -o default -o nospace -F _git_fetch git-fetch
1377 complete -o default -o nospace -F _git_format_patch git-format-patch
1378 complete -o default -o nospace -F _git_gc git-gc
1379 complete -o default -o nospace -F _git_log git-log
1380 complete -o default -o nospace -F _git_ls_remote git-ls-remote
1381 complete -o default -o nospace -F _git_ls_tree git-ls-tree
1382 complete -o default -o nospace -F _git_merge git-merge
1383 complete -o default -o nospace -F _git_merge_base git-merge-base
1384 complete -o default -o nospace -F _git_name_rev git-name-rev
1385 complete -o default -o nospace -F _git_pull git-pull
1386 complete -o default -o nospace -F _git_push git-push
1387 complete -o default -o nospace -F _git_rebase git-rebase
1388 complete -o default -o nospace -F _git_config git-config
1389 complete -o default -o nospace -F _git_remote git-remote
1390 complete -o default -o nospace -F _git_reset git-reset
1391 complete -o default -o nospace -F _git_shortlog git-shortlog
1392 complete -o default -o nospace -F _git_show git-show
1393 complete -o default -o nospace -F _git_stash git-stash
1394 complete -o default -o nospace -F _git_submodule git-submodule
1395 complete -o default -o nospace -F _git_svn git-svn
1396 complete -o default -o nospace -F _git_log git-show-branch
1397 complete -o default -o nospace -F _git_tag git-tag
1398 complete -o default -o nospace -F _git_log git-whatchanged
1399
1400 # The following are necessary only for Cygwin, and only are needed
1401 # when the user has tab-completed the executable name and consequently
1402 # included the '.exe' suffix.
1403 #
1404 if [ Cygwin = "$(uname -o 2>/dev/null)" ]; then
1405 complete -o default -o nospace -F _git_add git-add.exe
1406 complete -o default -o nospace -F _git_apply git-apply.exe
1407 complete -o default -o nospace -F _git git.exe
1408 complete -o default -o nospace -F _git_branch git-branch.exe
1409 complete -o default -o nospace -F _git_bundle git-bundle.exe
1410 complete -o default -o nospace -F _git_cherry git-cherry.exe
1411 complete -o default -o nospace -F _git_describe git-describe.exe
1412 complete -o default -o nospace -F _git_diff git-diff.exe
1413 complete -o default -o nospace -F _git_format_patch git-format-patch.exe
1414 complete -o default -o nospace -F _git_log git-log.exe
1415 complete -o default -o nospace -F _git_ls_tree git-ls-tree.exe
1416 complete -o default -o nospace -F _git_merge_base git-merge-base.exe
1417 complete -o default -o nospace -F _git_name_rev git-name-rev.exe
1418 complete -o default -o nospace -F _git_push git-push.exe
1419 complete -o default -o nospace -F _git_config git-config
1420 complete -o default -o nospace -F _git_shortlog git-shortlog.exe
1421 complete -o default -o nospace -F _git_show git-show.exe
1422 complete -o default -o nospace -F _git_log git-show-branch.exe
1423 complete -o default -o nospace -F _git_tag git-tag.exe
1424 complete -o default -o nospace -F _git_log git-whatchanged.exe
1425 fi