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