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