contrib/completion/git-completion.bash

   1 #
   2 # bash completion support for core Git.
   3 #
   4 # Copyright (C) 2006 Shawn Pearce
   5 # Conceptually based on gitcompletion (http://gitweb.hawaga.org.uk/).
   6 #
   7 # The contained completion routines provide support for completing:
   8 #
   9 #    *) local and remote branch names
  10 #    *) local and remote tag names
  11 #    *) .git/remotes file names
  12 #    *) git 'subcommands'
  13 #    *) tree paths within 'ref:path/to/file' expressions
  14 #
  15 # To use these routines:
  16 #
  17 #    1) Copy this file to somewhere (e.g. ~/.git-completion.sh).
  18 #    2) Added the following line to your .bashrc:
  19 #        source ~/.git-completion.sh
  20 #
  21 #    3) Consider changing your PS1 to also show the current branch:
  22 #        PS1='[\u@\h \W$(__git_ps1 " (%s)")]\$ '
  23 #
  24 #       The argument to __git_ps1 will be displayed only if you
  25 #       are currently in a git repository.  The %s token will be
  26 #       the name of the current branch.
  27 #
  28
  29 __gitdir ()
  30 {
  31         echo "${__git_dir:-$(git rev-parse --git-dir 2>/dev/null)}"
  32 }
  33
  34 __git_ps1 ()
  35 {
  36         local b="$(git symbolic-ref HEAD 2>/dev/null)"
  37         if [ -n "$b" ]; then
  38                 if [ -n "$1" ]; then
  39                         printf "$1" "${b##refs/heads/}"
  40                 else
  41                         printf " (%s)" "${b##refs/heads/}"
  42                 fi
  43         fi
  44 }
  45
  46 __git_heads ()
  47 {
  48         local cmd i is_hash=y dir="${1:-$(__gitdir)}"
  49         if [ -d "$dir" ]; then
  50                 for i in $(git --git-dir="$dir" \
  51                         for-each-ref --format='%(refname)' \
  52                         refs/heads ); do
  53                         echo "${i#refs/heads/}"
  54                 done
  55                 return
  56         fi
  57         for i in $(git-ls-remote "$dir" 2>/dev/null); do
  58                 case "$is_hash,$i" in
  59                 y,*) is_hash=n ;;
  60                 n,*^{}) is_hash=y ;;
  61                 n,refs/heads/*) is_hash=y; echo "${i#refs/heads/}" ;;
  62                 n,*) is_hash=y; echo "$i" ;;
  63                 esac
  64         done
  65 }
  66
  67 __git_refs ()
  68 {
  69         local cmd i is_hash=y dir="${1:-$(__gitdir)}"
  70         if [ -d "$dir" ]; then
  71                 if [ -e "$dir/HEAD" ]; then echo HEAD; fi
  72                 for i in $(git --git-dir="$dir" \
  73                         for-each-ref --format='%(refname)' \
  74                         refs/tags refs/heads refs/remotes); do
  75                         case "$i" in
  76                                 refs/tags/*)    echo "${i#refs/tags/}" ;;
  77                                 refs/heads/*)   echo "${i#refs/heads/}" ;;
  78                                 refs/remotes/*) echo "${i#refs/remotes/}" ;;
  79                                 *)              echo "$i" ;;
  80                         esac
  81                 done
  82                 return
  83         fi
  84         for i in $(git-ls-remote "$dir" 2>/dev/null); do
  85                 case "$is_hash,$i" in
  86                 y,*) is_hash=n ;;
  87                 n,*^{}) is_hash=y ;;
  88                 n,refs/tags/*) is_hash=y; echo "${i#refs/tags/}" ;;
  89                 n,refs/heads/*) is_hash=y; echo "${i#refs/heads/}" ;;
  90                 n,refs/remotes/*) is_hash=y; echo "${i#refs/remotes/}" ;;
  91                 n,*) is_hash=y; echo "$i" ;;
  92                 esac
  93         done
  94 }
  95
  96 __git_refs2 ()
  97 {
  98         local cmd i is_hash=y dir="${1:-$(__gitdir)}"
  99         if [ -d "$dir" ]; then
 100                 cmd=git-peek-remote
 101         else
 102                 cmd=git-ls-remote
 103         fi
 104         for i in $($cmd "$dir" 2>/dev/null); do
 105                 case "$is_hash,$i" in
 106                 y,*) is_hash=n ;;
 107                 n,*^{}) is_hash=y ;;
 108                 n,refs/tags/*) is_hash=y; echo "${i#refs/tags/}:${i#refs/tags/}" ;;
 109                 n,refs/heads/*) is_hash=y; echo "${i#refs/heads/}:${i#refs/heads/}" ;;
 110                 n,*) is_hash=y; echo "$i:$i" ;;
 111                 esac
 112         done
 113 }
 114
 115 __git_refs_remotes ()
 116 {
 117         local cmd i is_hash=y
 118         for i in $(git-ls-remote "$1" 2>/dev/null); do
 119                 case "$is_hash,$i" in
 120                 n,refs/heads/*)
 121                         is_hash=y
 122                         echo "$i:refs/remotes/$1/${i#refs/heads/}"
 123                         ;;
 124                 y,*) is_hash=n ;;
 125                 n,*^{}) is_hash=y ;;
 126                 n,refs/tags/*) is_hash=y;;
 127                 n,*) is_hash=y; ;;
 128                 esac
 129         done
 130 }
 131
 132 __git_remotes ()
 133 {
 134         local i ngoff IFS=$'\n' d="$(__gitdir)"
 135         shopt -q nullglob || ngoff=1
 136         shopt -s nullglob
 137         for i in "$d/remotes"/*; do
 138                 echo ${i#$d/remotes/}
 139         done
 140         [ "$ngoff" ] && shopt -u nullglob
 141         for i in $(git --git-dir="$d" repo-config --list); do
 142                 case "$i" in
 143                 remote.*.url=*)
 144                         i="${i#remote.}"
 145                         echo "${i/.url=*/}"
 146                         ;;
 147                 esac
 148         done
 149 }
 150
 151 __git_merge_strategies ()
 152 {
 153         sed -n "/^all_strategies='/{
 154                 s/^all_strategies='//
 155                 s/'//
 156                 p
 157                 q
 158                 }" "$(git --exec-path)/git-merge"
 159 }
 160
 161 __git_complete_file ()
 162 {
 163         local pfx ls ref cur="${COMP_WORDS[COMP_CWORD]}"
 164         case "$cur" in
 165         ?*:*)
 166                 ref="${cur%%:*}"
 167                 cur="${cur#*:}"
 168                 case "$cur" in
 169                 ?*/*)
 170                         pfx="${cur%/*}"
 171                         cur="${cur##*/}"
 172                         ls="$ref:$pfx"
 173                         pfx="$pfx/"
 174                         ;;
 175                 *)
 176                         ls="$ref"
 177                         ;;
 178             esac
 179                 COMPREPLY=($(compgen -P "$pfx" \
 180                         -W "$(git --git-dir="$(__gitdir)" ls-tree "$ls" \
 181                                 | sed '/^100... blob /s,^.*     ,,
 182                                        /^040000 tree /{
 183                                            s,^.*        ,,
 184                                            s,$,/,
 185                                        }
 186                                        s/^.*    //')" \
 187                         -- "$cur"))
 188                 ;;
 189         *)
 190                 COMPREPLY=($(compgen -W "$(__git_refs)" -- "$cur"))
 191                 ;;
 192         esac
 193 }
 194
 195 __git_complete_revlist ()
 196 {
 197         local pfx cur="${COMP_WORDS[COMP_CWORD]}"
 198         case "$cur" in
 199         *...*)
 200                 pfx="${cur%...*}..."
 201                 cur="${cur#*...}"
 202                 COMPREPLY=($(compgen -P "$pfx" -W "$(__git_refs)" -- "$cur"))
 203                 ;;
 204         *..*)
 205                 pfx="${cur%..*}.."
 206                 cur="${cur#*..}"
 207                 COMPREPLY=($(compgen -P "$pfx" -W "$(__git_refs)" -- "$cur"))
 208                 ;;
 209         *)
 210                 COMPREPLY=($(compgen -W "$(__git_refs)" -- "$cur"))
 211                 ;;
 212         esac
 213 }
 214
 215 __git_commands ()
 216 {
 217         local i IFS=" "$'\n'
 218         for i in $(git help -a|egrep '^ ')
 219         do
 220                 case $i in
 221                 check-ref-format) : plumbing;;
 222                 commit-tree)      : plumbing;;
 223                 convert-objects)  : plumbing;;
 224                 cvsserver)        : daemon;;
 225                 daemon)           : daemon;;
 226                 fetch-pack)       : plumbing;;
 227                 hash-object)      : plumbing;;
 228                 http-*)           : transport;;
 229                 index-pack)       : plumbing;;
 230                 local-fetch)      : plumbing;;
 231                 mailinfo)         : plumbing;;
 232                 mailsplit)        : plumbing;;
 233                 merge-*)          : plumbing;;
 234                 mktree)           : plumbing;;
 235                 mktag)            : plumbing;;
 236                 pack-objects)     : plumbing;;
 237                 pack-redundant)   : plumbing;;
 238                 pack-refs)        : plumbing;;
 239                 parse-remote)     : plumbing;;
 240                 patch-id)         : plumbing;;
 241                 peek-remote)      : plumbing;;
 242                 read-tree)        : plumbing;;
 243                 receive-pack)     : plumbing;;
 244                 rerere)           : plumbing;;
 245                 rev-list)         : plumbing;;
 246                 rev-parse)        : plumbing;;
 247                 runstatus)        : plumbing;;
 248                 sh-setup)         : internal;;
 249                 shell)            : daemon;;
 250                 send-pack)        : plumbing;;
 251                 show-index)       : plumbing;;
 252                 ssh-*)            : transport;;
 253                 stripspace)       : plumbing;;
 254                 symbolic-ref)     : plumbing;;
 255                 unpack-file)      : plumbing;;
 256                 unpack-objects)   : plumbing;;
 257                 update-ref)       : plumbing;;
 258                 update-server-info) : daemon;;
 259                 upload-archive)   : plumbing;;
 260                 upload-pack)      : plumbing;;
 261                 write-tree)       : plumbing;;
 262                 *) echo $i;;
 263                 esac
 264         done
 265 }
 266
 267 __git_aliases ()
 268 {
 269         local i IFS=$'\n'
 270         for i in $(git --git-dir="$(__gitdir)" repo-config --list); do
 271                 case "$i" in
 272                 alias.*)
 273                         i="${i#alias.}"
 274                         echo "${i/=*/}"
 275                         ;;
 276                 esac
 277         done
 278 }
 279
 280 __git_aliased_command ()
 281 {
 282         local word cmdline=$(git --git-dir="$(__gitdir)" \
 283                 repo-config --get "alias.$1")
 284         for word in $cmdline; do
 285                 if [ "${word##-*}" ]; then
 286                         echo $word
 287                         return
 288                 fi
 289         done
 290 }
 291
 292 _git_branch ()
 293 {
 294         local cur="${COMP_WORDS[COMP_CWORD]}"
 295         COMPREPLY=($(compgen -W "-l -f -d -D $(__git_refs)" -- "$cur"))
 296 }
 297
 298 _git_cat_file ()
 299 {
 300         local cur="${COMP_WORDS[COMP_CWORD]}"
 301         case "${COMP_WORDS[0]},$COMP_CWORD" in
 302         git-cat-file*,1)
 303                 COMPREPLY=($(compgen -W "-p -t blob tree commit tag" -- "$cur"))
 304                 ;;
 305         git,2)
 306                 COMPREPLY=($(compgen -W "-p -t blob tree commit tag" -- "$cur"))
 307                 ;;
 308         *)
 309                 __git_complete_file
 310                 ;;
 311         esac
 312 }
 313
 314 _git_checkout ()
 315 {
 316         local cur="${COMP_WORDS[COMP_CWORD]}"
 317         COMPREPLY=($(compgen -W "-l -b $(__git_refs)" -- "$cur"))
 318 }
 319
 320 _git_cherry_pick ()
 321 {
 322         local cur="${COMP_WORDS[COMP_CWORD]}"
 323         case "$cur" in
 324         --*)
 325                 COMPREPLY=($(compgen -W "
 326                         --edit --no-commit
 327                         " -- "$cur"))
 328                 ;;
 329         *)
 330                 COMPREPLY=($(compgen -W "$(__git_refs)" -- "$cur"))
 331                 ;;
 332         esac
 333 }
 334
 335 _git_diff ()
 336 {
 337         __git_complete_file
 338 }
 339
 340 _git_diff_tree ()
 341 {
 342         local cur="${COMP_WORDS[COMP_CWORD]}"
 343         COMPREPLY=($(compgen -W "-r -p -M $(__git_refs)" -- "$cur"))
 344 }
 345
 346 _git_fetch ()
 347 {
 348         local cur="${COMP_WORDS[COMP_CWORD]}"
 349
 350         case "${COMP_WORDS[0]},$COMP_CWORD" in
 351         git-fetch*,1)
 352                 COMPREPLY=($(compgen -W "$(__git_remotes)" -- "$cur"))
 353                 ;;
 354         git,2)
 355                 COMPREPLY=($(compgen -W "$(__git_remotes)" -- "$cur"))
 356                 ;;
 357         *)
 358                 case "$cur" in
 359                 *:*)
 360                         cur="${cur#*:}"
 361                         COMPREPLY=($(compgen -W "$(__git_refs)" -- "$cur"))
 362                         ;;
 363                 *)
 364                         local remote
 365                         case "${COMP_WORDS[0]}" in
 366                         git-fetch) remote="${COMP_WORDS[1]}" ;;
 367                         git)       remote="${COMP_WORDS[2]}" ;;
 368                         esac
 369                         COMPREPLY=($(compgen -W "$(__git_refs2 "$remote")" -- "$cur"))
 370                         ;;
 371                 esac
 372                 ;;
 373         esac
 374 }
 375
 376 _git_format_patch ()
 377 {
 378         local cur="${COMP_WORDS[COMP_CWORD]}"
 379         case "$cur" in
 380         --*)
 381                 COMPREPLY=($(compgen -W "
 382                         --stdout --attach --thread
 383                         --output-directory
 384                         --numbered --start-number
 385                         --keep-subject
 386                         --signoff
 387                         --in-reply-to=
 388                         --full-index --binary
 389                         " -- "$cur"))
 390                 return
 391                 ;;
 392         esac
 393         __git_complete_revlist
 394 }
 395
 396 _git_ls_remote ()
 397 {
 398         local cur="${COMP_WORDS[COMP_CWORD]}"
 399         COMPREPLY=($(compgen -W "$(__git_remotes)" -- "$cur"))
 400 }
 401
 402 _git_ls_tree ()
 403 {
 404         __git_complete_file
 405 }
 406
 407 _git_log ()
 408 {
 409         local cur="${COMP_WORDS[COMP_CWORD]}"
 410         case "$cur" in
 411         --pretty=*)
 412                 COMPREPLY=($(compgen -W "
 413                         oneline short medium full fuller email raw
 414                         " -- "${cur##--pretty=}"))
 415                 return
 416                 ;;
 417         --*)
 418                 COMPREPLY=($(compgen -W "
 419                         --max-count= --max-age= --since= --after=
 420                         --min-age= --before= --until=
 421                         --root --not --topo-order --date-order
 422                         --no-merges
 423                         --abbrev-commit --abbrev=
 424                         --relative-date
 425                         --author= --committer= --grep=
 426                         --all-match
 427                         --pretty= --name-status --name-only
 428                         " -- "$cur"))
 429                 return
 430                 ;;
 431         esac
 432         __git_complete_revlist
 433 }
 434
 435 _git_merge ()
 436 {
 437         local cur="${COMP_WORDS[COMP_CWORD]}"
 438         case "$cur" in
 439         --*)
 440                 COMPREPLY=($(compgen -W "
 441                         --no-commit --no-summary --squash --strategy
 442                         " -- "$cur"))
 443                 return
 444         esac
 445         case "${COMP_WORDS[COMP_CWORD-1]}" in
 446         -s|--strategy)
 447                 COMPREPLY=($(compgen -W "$(__git_merge_strategies)" -- "$cur"))
 448                 return
 449         esac
 450         COMPREPLY=($(compgen -W "$(__git_refs)" -- "$cur"))
 451 }
 452
 453 _git_merge_base ()
 454 {
 455         local cur="${COMP_WORDS[COMP_CWORD]}"
 456         COMPREPLY=($(compgen -W "$(__git_refs)" -- "$cur"))
 457 }
 458
 459 _git_name_rev ()
 460 {
 461         local cur="${COMP_WORDS[COMP_CWORD]}"
 462         COMPREPLY=($(compgen -W "--tags --all --stdin" -- "$cur"))
 463 }
 464
 465 _git_pull ()
 466 {
 467         local cur="${COMP_WORDS[COMP_CWORD]}"
 468
 469         case "${COMP_WORDS[0]},$COMP_CWORD" in
 470         git-pull*,1)
 471                 COMPREPLY=($(compgen -W "$(__git_remotes)" -- "$cur"))
 472                 ;;
 473         git,2)
 474                 COMPREPLY=($(compgen -W "$(__git_remotes)" -- "$cur"))
 475                 ;;
 476         *)
 477                 local remote
 478                 case "${COMP_WORDS[0]}" in
 479                 git-pull)  remote="${COMP_WORDS[1]}" ;;
 480                 git)       remote="${COMP_WORDS[2]}" ;;
 481                 esac
 482                 COMPREPLY=($(compgen -W "$(__git_refs "$remote")" -- "$cur"))
 483                 ;;
 484         esac
 485 }
 486
 487 _git_push ()
 488 {
 489         local cur="${COMP_WORDS[COMP_CWORD]}"
 490
 491         case "${COMP_WORDS[0]},$COMP_CWORD" in
 492         git-push*,1)
 493                 COMPREPLY=($(compgen -W "$(__git_remotes)" -- "$cur"))
 494                 ;;
 495         git,2)
 496                 COMPREPLY=($(compgen -W "$(__git_remotes)" -- "$cur"))
 497                 ;;
 498         *)
 499                 case "$cur" in
 500                 *:*)
 501                         local remote
 502                         case "${COMP_WORDS[0]}" in
 503                         git-push)  remote="${COMP_WORDS[1]}" ;;
 504                         git)       remote="${COMP_WORDS[2]}" ;;
 505                         esac
 506                         cur="${cur#*:}"
 507                         COMPREPLY=($(compgen -W "$(__git_refs "$remote")" -- "$cur"))
 508                         ;;
 509                 *)
 510                         COMPREPLY=($(compgen -W "$(__git_refs2)" -- "$cur"))
 511                         ;;
 512                 esac
 513                 ;;
 514         esac
 515 }
 516
 517 _git_rebase ()
 518 {
 519         local cur="${COMP_WORDS[COMP_CWORD]}"
 520         if [ -d .dotest ]; then
 521                 COMPREPLY=($(compgen -W "
 522                         --continue --skip --abort
 523                         " -- "$cur"))
 524                 return
 525         fi
 526         case "$cur" in
 527         --*)
 528                 COMPREPLY=($(compgen -W "
 529                         --onto --merge --strategy
 530                         " -- "$cur"))
 531                 return
 532         esac
 533         case "${COMP_WORDS[COMP_CWORD-1]}" in
 534         -s|--strategy)
 535                 COMPREPLY=($(compgen -W "$(__git_merge_strategies)" -- "$cur"))
 536                 return
 537         esac
 538         COMPREPLY=($(compgen -W "$(__git_refs)" -- "$cur"))
 539 }
 540
 541 _git_repo_config ()
 542 {
 543         local cur="${COMP_WORDS[COMP_CWORD]}"
 544         local prv="${COMP_WORDS[COMP_CWORD-1]}"
 545         case "$prv" in
 546         branch.*.remote)
 547                 COMPREPLY=($(compgen -W "$(__git_remotes)" -- "$cur"))
 548                 return
 549                 ;;
 550         branch.*.merge)
 551                 COMPREPLY=($(compgen -W "$(__git_refs)" -- "$cur"))
 552                 return
 553                 ;;
 554         remote.*.fetch)
 555                 local remote="${prv#remote.}"
 556                 remote="${remote%.fetch}"
 557                 COMPREPLY=($(compgen -W "$(__git_refs_remotes "$remote")" \
 558                         -- "$cur"))
 559                 return
 560                 ;;
 561         remote.*.push)
 562                 local remote="${prv#remote.}"
 563                 remote="${remote%.push}"
 564                 COMPREPLY=($(compgen -W "$(git --git-dir="$(__gitdir)" \
 565                         for-each-ref --format='%(refname):%(refname)' \
 566                         refs/heads)" -- "$cur"))
 567                 return
 568                 ;;
 569         *.*)
 570                 COMPREPLY=()
 571                 return
 572                 ;;
 573         esac
 574         case "$cur" in
 575         --*)
 576                 COMPREPLY=($(compgen -W "
 577                         --global --list --replace-all
 578                         --get --get-all --get-regexp
 579                         --unset --unset-all
 580                         " -- "$cur"))
 581                 return
 582                 ;;
 583         branch.*.*)
 584                 local pfx="${cur%.*}."
 585                 cur="${cur##*.}"
 586                 COMPREPLY=($(compgen -P "$pfx" -W "remote merge" -- "$cur"))
 587                 return
 588                 ;;
 589         branch.*)
 590                 local pfx="${cur%.*}."
 591                 cur="${cur#*.}"
 592                 COMPREPLY=($(compgen -P "$pfx" -S . \
 593                         -W "$(__git_heads)" -- "$cur"))
 594                 return
 595                 ;;
 596         remote.*.*)
 597                 local pfx="${cur%.*}."
 598                 cur="${cur##*.}"
 599                 COMPREPLY=($(compgen -P "$pfx" -W "url fetch push" -- "$cur"))
 600                 return
 601                 ;;
 602         remote.*)
 603                 local pfx="${cur%.*}."
 604                 cur="${cur#*.}"
 605                 COMPREPLY=($(compgen -P "$pfx" -S . \
 606                         -W "$(__git_remotes)" -- "$cur"))
 607                 return
 608                 ;;
 609         esac
 610         COMPREPLY=($(compgen -W "
 611                 apply.whitespace
 612                 core.fileMode
 613                 core.gitProxy
 614                 core.ignoreStat
 615                 core.preferSymlinkRefs
 616                 core.logAllRefUpdates
 617                 core.repositoryFormatVersion
 618                 core.sharedRepository
 619                 core.warnAmbiguousRefs
 620                 core.compression
 621                 core.legacyHeaders
 622                 i18n.commitEncoding
 623                 diff.color
 624                 diff.renameLimit
 625                 diff.renames
 626                 pager.color
 627                 status.color
 628                 log.showroot
 629                 show.difftree
 630                 showbranch.default
 631                 whatchanged.difftree
 632                 http.sslVerify
 633                 http.sslCert
 634                 http.sslKey
 635                 http.sslCAInfo
 636                 http.sslCAPath
 637                 http.maxRequests
 638                 http.lowSpeedLimit http.lowSpeedTime
 639                 http.noEPSV
 640                 pack.window
 641                 repack.useDeltaBaseOffset
 642                 pull.octopus pull.twohead
 643                 merge.summary
 644                 receive.unpackLimit
 645                 receive.denyNonFastForwards
 646                 user.name user.email
 647                 tar.umask
 648                 gitcvs.enabled
 649                 gitcvs.logfile
 650                 branch. remote.
 651         " -- "$cur"))
 652 }
 653
 654 _git_reset ()
 655 {
 656         local cur="${COMP_WORDS[COMP_CWORD]}"
 657         local opt="--mixed --hard --soft"
 658         COMPREPLY=($(compgen -W "$opt $(__git_refs)" -- "$cur"))
 659 }
 660
 661 _git ()
 662 {
 663         local i c=1 command __git_dir
 664
 665         while [ $c -lt $COMP_CWORD ]; do
 666                 i="${COMP_WORDS[c]}"
 667                 case "$i" in
 668                 --git-dir=*) __git_dir="${i#--git-dir=}" ;;
 669                 --bare)      __git_dir="." ;;
 670                 --version|--help|-p|--paginate) ;;
 671                 *) command="$i"; break ;;
 672                 esac
 673                 c=$((++c))
 674         done
 675
 676         if [ $c -eq $COMP_CWORD -a -z "$command" ]; then
 677                 COMPREPLY=($(compgen -W "
 678                         --git-dir= --version --exec-path
 679                         $(__git_commands)
 680                         $(__git_aliases)
 681                         " -- "${COMP_WORDS[COMP_CWORD]}"))
 682                 return;
 683         fi
 684
 685         local expansion=$(__git_aliased_command "$command")
 686         [ "$expansion" ] && command="$expansion"
 687
 688         case "$command" in
 689         branch)      _git_branch ;;
 690         cat-file)    _git_cat_file ;;
 691         checkout)    _git_checkout ;;
 692         cherry-pick) _git_cherry_pick ;;
 693         diff)        _git_diff ;;
 694         diff-tree)   _git_diff_tree ;;
 695         fetch)       _git_fetch ;;
 696         format-patch) _git_format_patch ;;
 697         log)         _git_log ;;
 698         ls-remote)   _git_ls_remote ;;
 699         ls-tree)     _git_ls_tree ;;
 700         merge)       _git_merge;;
 701         merge-base)  _git_merge_base ;;
 702         name-rev)    _git_name_rev ;;
 703         pull)        _git_pull ;;
 704         push)        _git_push ;;
 705         rebase)      _git_rebase ;;
 706         repo-config) _git_repo_config ;;
 707         reset)       _git_reset ;;
 708         show)        _git_log ;;
 709         show-branch) _git_log ;;
 710         whatchanged) _git_log ;;
 711         *)           COMPREPLY=() ;;
 712         esac
 713 }
 714
 715 _gitk ()
 716 {
 717         local cur="${COMP_WORDS[COMP_CWORD]}"
 718         COMPREPLY=($(compgen -W "--all $(__git_refs)" -- "$cur"))
 719 }
 720
 721 complete -o default -o nospace -F _git git
 722 complete -o default            -F _gitk gitk
 723 complete -o default            -F _git_branch git-branch
 724 complete -o default -o nospace -F _git_cat_file git-cat-file
 725 complete -o default            -F _git_checkout git-checkout
 726 complete -o default            -F _git_cherry_pick git-cherry-pick
 727 complete -o default -o nospace -F _git_diff git-diff
 728 complete -o default            -F _git_diff_tree git-diff-tree
 729 complete -o default -o nospace -F _git_fetch git-fetch
 730 complete -o default -o nospace -F _git_format_patch git-format-patch
 731 complete -o default -o nospace -F _git_log git-log
 732 complete -o default            -F _git_ls_remote git-ls-remote
 733 complete -o default -o nospace -F _git_ls_tree git-ls-tree
 734 complete -o default            -F _git_merge git-merge
 735 complete -o default            -F _git_merge_base git-merge-base
 736 complete -o default            -F _git_name_rev git-name-rev
 737 complete -o default -o nospace -F _git_pull git-pull
 738 complete -o default -o nospace -F _git_push git-push
 739 complete -o default            -F _git_rebase git-rebase
 740 complete -o default            -F _git_repo_config git-repo-config
 741 complete -o default            -F _git_reset git-reset
 742 complete -o default            -F _git_log git-show
 743 complete -o default -o nospace -F _git_log git-show-branch
 744 complete -o default -o nospace -F _git_log git-whatchanged
 745
 746 # The following are necessary only for Cygwin, and only are needed
 747 # when the user has tab-completed the executable name and consequently
 748 # included the '.exe' suffix.
 749 #
 750 if [ Cygwin = "$(uname -o 2>/dev/null)" ]; then
 751 complete -o default -o nospace -F _git git.exe
 752 complete -o default            -F _git_branch git-branch.exe
 753 complete -o default -o nospace -F _git_cat_file git-cat-file.exe
 754 complete -o default -o nospace -F _git_diff git-diff.exe
 755 complete -o default -o nospace -F _git_diff_tree git-diff-tree.exe
 756 complete -o default -o nospace -F _git_format_patch git-format-patch.exe
 757 complete -o default -o nospace -F _git_log git-log.exe
 758 complete -o default -o nospace -F _git_ls_tree git-ls-tree.exe
 759 complete -o default            -F _git_merge_base git-merge-base.exe
 760 complete -o default            -F _git_name_rev git-name-rev.exe
 761 complete -o default -o nospace -F _git_push git-push.exe
 762 complete -o default            -F _git_repo_config git-repo-config
 763 complete -o default -o nospace -F _git_log git-show.exe
 764 complete -o default -o nospace -F _git_log git-show-branch.exe
 765 complete -o default -o nospace -F _git_log git-whatchanged.exe
 766 fi