Code

b87f96d9eadb0b99fbe3ce2c1e1c0e38b9601b13
[git.git] / contrib / completion / git-completion.bash
1 #
2 # bash completion support for core Git.
3 #
4 # Copyright (C) 2006,2007 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) You may want to make sure the git executable is available
22 #       in your PATH before this script is sourced, as some caching
23 #       is performed while the script loads.  If git isn't found
24 #       at source time then all lookups will be done on demand,
25 #       which may be slightly slower.
26 #
27 #    4) Consider changing your PS1 to also show the current branch:
28 #        PS1='[\u@\h \W$(__git_ps1 " (%s)")]\$ '
29 #
30 #       The argument to __git_ps1 will be displayed only if you
31 #       are currently in a git repository.  The %s token will be
32 #       the name of the current branch.
33 #
35 __gitdir ()
36 {
37         if [ -z "$1" ]; then
38                 if [ -n "$__git_dir" ]; then
39                         echo "$__git_dir"
40                 elif [ -d .git ]; then
41                         echo .git
42                 else
43                         git rev-parse --git-dir 2>/dev/null
44                 fi
45         elif [ -d "$1/.git" ]; then
46                 echo "$1/.git"
47         else
48                 echo "$1"
49         fi
50 }
52 __git_ps1 ()
53 {
54         local b="$(git symbolic-ref HEAD 2>/dev/null)"
55         if [ -n "$b" ]; then
56                 if [ -n "$1" ]; then
57                         printf "$1" "${b##refs/heads/}"
58                 else
59                         printf " (%s)" "${b##refs/heads/}"
60                 fi
61         fi
62 }
64 __git_heads ()
65 {
66         local cmd i is_hash=y dir="$(__gitdir "$1")"
67         if [ -d "$dir" ]; then
68                 for i in $(git --git-dir="$dir" \
69                         for-each-ref --format='%(refname)' \
70                         refs/heads ); do
71                         echo "${i#refs/heads/}"
72                 done
73                 return
74         fi
75         for i in $(git-ls-remote "$1" 2>/dev/null); do
76                 case "$is_hash,$i" in
77                 y,*) is_hash=n ;;
78                 n,*^{}) is_hash=y ;;
79                 n,refs/heads/*) is_hash=y; echo "${i#refs/heads/}" ;;
80                 n,*) is_hash=y; echo "$i" ;;
81                 esac
82         done
83 }
85 __git_refs ()
86 {
87         local cmd i is_hash=y dir="$(__gitdir "$1")"
88         if [ -d "$dir" ]; then
89                 if [ -e "$dir/HEAD" ]; then echo HEAD; fi
90                 for i in $(git --git-dir="$dir" \
91                         for-each-ref --format='%(refname)' \
92                         refs/tags refs/heads refs/remotes); do
93                         case "$i" in
94                                 refs/tags/*)    echo "${i#refs/tags/}" ;;
95                                 refs/heads/*)   echo "${i#refs/heads/}" ;;
96                                 refs/remotes/*) echo "${i#refs/remotes/}" ;;
97                                 *)              echo "$i" ;;
98                         esac
99                 done
100                 return
101         fi
102         for i in $(git-ls-remote "$dir" 2>/dev/null); do
103                 case "$is_hash,$i" in
104                 y,*) is_hash=n ;;
105                 n,*^{}) is_hash=y ;;
106                 n,refs/tags/*) is_hash=y; echo "${i#refs/tags/}" ;;
107                 n,refs/heads/*) is_hash=y; echo "${i#refs/heads/}" ;;
108                 n,refs/remotes/*) is_hash=y; echo "${i#refs/remotes/}" ;;
109                 n,*) is_hash=y; echo "$i" ;;
110                 esac
111         done
114 __git_refs2 ()
116         local i
117         for i in $(__git_refs "$1"); do
118                 echo "$i:$i"
119         done
122 __git_refs_remotes ()
124         local cmd i is_hash=y
125         for i in $(git-ls-remote "$1" 2>/dev/null); do
126                 case "$is_hash,$i" in
127                 n,refs/heads/*)
128                         is_hash=y
129                         echo "$i:refs/remotes/$1/${i#refs/heads/}"
130                         ;;
131                 y,*) is_hash=n ;;
132                 n,*^{}) is_hash=y ;;
133                 n,refs/tags/*) is_hash=y;;
134                 n,*) is_hash=y; ;;
135                 esac
136         done
139 __git_remotes ()
141         local i ngoff IFS=$'\n' d="$(__gitdir)"
142         shopt -q nullglob || ngoff=1
143         shopt -s nullglob
144         for i in "$d/remotes"/*; do
145                 echo ${i#$d/remotes/}
146         done
147         [ "$ngoff" ] && shopt -u nullglob
148         for i in $(git --git-dir="$d" config --list); do
149                 case "$i" in
150                 remote.*.url=*)
151                         i="${i#remote.}"
152                         echo "${i/.url=*/}"
153                         ;;
154                 esac
155         done
158 __git_merge_strategies ()
160         if [ -n "$__git_merge_strategylist" ]; then
161                 echo "$__git_merge_strategylist"
162                 return
163         fi
164         sed -n "/^all_strategies='/{
165                 s/^all_strategies='//
166                 s/'//
167                 p
168                 q
169                 }" "$(git --exec-path)/git-merge"
171 __git_merge_strategylist=
172 __git_merge_strategylist="$(__git_merge_strategies 2>/dev/null)"
174 __git_complete_file ()
176         local pfx ls ref cur="${COMP_WORDS[COMP_CWORD]}"
177         case "$cur" in
178         ?*:*)
179                 ref="${cur%%:*}"
180                 cur="${cur#*:}"
181                 case "$cur" in
182                 ?*/*)
183                         pfx="${cur%/*}"
184                         cur="${cur##*/}"
185                         ls="$ref:$pfx"
186                         pfx="$pfx/"
187                         ;;
188                 *)
189                         ls="$ref"
190                         ;;
191             esac
192                 COMPREPLY=($(compgen -P "$pfx" \
193                         -W "$(git --git-dir="$(__gitdir)" ls-tree "$ls" \
194                                 | sed '/^100... blob /s,^.*     ,,
195                                        /^040000 tree /{
196                                            s,^.*        ,,
197                                            s,$,/,
198                                        }
199                                        s/^.*    //')" \
200                         -- "$cur"))
201                 ;;
202         *)
203                 COMPREPLY=($(compgen -W "$(__git_refs)" -- "$cur"))
204                 ;;
205         esac
208 __git_complete_revlist ()
210         local pfx cur="${COMP_WORDS[COMP_CWORD]}"
211         case "$cur" in
212         *...*)
213                 pfx="${cur%...*}..."
214                 cur="${cur#*...}"
215                 COMPREPLY=($(compgen -P "$pfx" -W "$(__git_refs)" -- "$cur"))
216                 ;;
217         *..*)
218                 pfx="${cur%..*}.."
219                 cur="${cur#*..}"
220                 COMPREPLY=($(compgen -P "$pfx" -W "$(__git_refs)" -- "$cur"))
221                 ;;
222         *)
223                 COMPREPLY=($(compgen -W "$(__git_refs)" -- "$cur"))
224                 ;;
225         esac
228 __git_commands ()
230         if [ -n "$__git_commandlist" ]; then
231                 echo "$__git_commandlist"
232                 return
233         fi
234         local i IFS=" "$'\n'
235         for i in $(git help -a|egrep '^ ')
236         do
237                 case $i in
238                 cat-file)         : plumbing;;
239                 check-ref-format) : plumbing;;
240                 commit-tree)      : plumbing;;
241                 convert-objects)  : plumbing;;
242                 cvsserver)        : daemon;;
243                 daemon)           : daemon;;
244                 fetch-pack)       : plumbing;;
245                 hash-object)      : plumbing;;
246                 http-*)           : transport;;
247                 index-pack)       : plumbing;;
248                 local-fetch)      : plumbing;;
249                 mailinfo)         : plumbing;;
250                 mailsplit)        : plumbing;;
251                 merge-*)          : plumbing;;
252                 mktree)           : plumbing;;
253                 mktag)            : plumbing;;
254                 pack-objects)     : plumbing;;
255                 pack-redundant)   : plumbing;;
256                 pack-refs)        : plumbing;;
257                 parse-remote)     : plumbing;;
258                 patch-id)         : plumbing;;
259                 peek-remote)      : plumbing;;
260                 read-tree)        : plumbing;;
261                 receive-pack)     : plumbing;;
262                 reflog)           : plumbing;;
263                 rerere)           : plumbing;;
264                 rev-list)         : plumbing;;
265                 rev-parse)        : plumbing;;
266                 runstatus)        : plumbing;;
267                 sh-setup)         : internal;;
268                 shell)            : daemon;;
269                 send-pack)        : plumbing;;
270                 show-index)       : plumbing;;
271                 ssh-*)            : transport;;
272                 stripspace)       : plumbing;;
273                 symbolic-ref)     : plumbing;;
274                 unpack-file)      : plumbing;;
275                 unpack-objects)   : plumbing;;
276                 update-ref)       : plumbing;;
277                 update-server-info) : daemon;;
278                 upload-archive)   : plumbing;;
279                 upload-pack)      : plumbing;;
280                 write-tree)       : plumbing;;
281                 *) echo $i;;
282                 esac
283         done
285 __git_commandlist=
286 __git_commandlist="$(__git_commands 2>/dev/null)"
288 __git_aliases ()
290         local i IFS=$'\n'
291         for i in $(git --git-dir="$(__gitdir)" config --list); do
292                 case "$i" in
293                 alias.*)
294                         i="${i#alias.}"
295                         echo "${i/=*/}"
296                         ;;
297                 esac
298         done
301 __git_aliased_command ()
303         local word cmdline=$(git --git-dir="$(__gitdir)" \
304                 config --get "alias.$1")
305         for word in $cmdline; do
306                 if [ "${word##-*}" ]; then
307                         echo $word
308                         return
309                 fi
310         done
313 __git_whitespacelist="nowarn warn error error-all strip"
315 _git_am ()
317         local cur="${COMP_WORDS[COMP_CWORD]}"
318         if [ -d .dotest ]; then
319                 COMPREPLY=($(compgen -W "
320                         --skip --resolved
321                         " -- "$cur"))
322                 return
323         fi
324         case "$cur" in
325         --whitespace=*)
326                 COMPREPLY=($(compgen -W "$__git_whitespacelist" \
327                         -- "${cur##--whitespace=}"))
328                 return
329                 ;;
330         --*)
331                 COMPREPLY=($(compgen -W "
332                         --signoff --utf8 --binary --3way --interactive
333                         --whitespace=
334                         " -- "$cur"))
335                 return
336         esac
337         COMPREPLY=()
340 _git_apply ()
342         local cur="${COMP_WORDS[COMP_CWORD]}"
343         case "$cur" in
344         --whitespace=*)
345                 COMPREPLY=($(compgen -W "$__git_whitespacelist" \
346                         -- "${cur##--whitespace=}"))
347                 return
348                 ;;
349         --*)
350                 COMPREPLY=($(compgen -W "
351                         --stat --numstat --summary --check --index
352                         --cached --index-info --reverse --reject --unidiff-zero
353                         --apply --no-add --exclude=
354                         --whitespace= --inaccurate-eof --verbose
355                         " -- "$cur"))
356                 return
357         esac
358         COMPREPLY=()
361 _git_branch ()
363         local cur="${COMP_WORDS[COMP_CWORD]}"
364         COMPREPLY=($(compgen -W "$(__git_refs)" -- "$cur"))
367 _git_checkout ()
369         local cur="${COMP_WORDS[COMP_CWORD]}"
370         COMPREPLY=($(compgen -W "$(__git_refs)" -- "$cur"))
373 _git_cherry_pick ()
375         local cur="${COMP_WORDS[COMP_CWORD]}"
376         case "$cur" in
377         --*)
378                 COMPREPLY=($(compgen -W "
379                         --edit --no-commit
380                         " -- "$cur"))
381                 ;;
382         *)
383                 COMPREPLY=($(compgen -W "$(__git_refs)" -- "$cur"))
384                 ;;
385         esac
388 _git_commit ()
390         local cur="${COMP_WORDS[COMP_CWORD]}"
391         case "$cur" in
392         --*)
393                 COMPREPLY=($(compgen -W "
394                         --all --author= --signoff --verify --no-verify
395                         --edit --amend --include --only
396                         " -- "$cur"))
397                 return
398         esac
399         COMPREPLY=()
402 _git_diff ()
404         __git_complete_file
407 _git_diff_tree ()
409         local cur="${COMP_WORDS[COMP_CWORD]}"
410         COMPREPLY=($(compgen -W "$(__git_refs)" -- "$cur"))
413 _git_fetch ()
415         local cur="${COMP_WORDS[COMP_CWORD]}"
417         case "${COMP_WORDS[0]},$COMP_CWORD" in
418         git-fetch*,1)
419                 COMPREPLY=($(compgen -W "$(__git_remotes)" -- "$cur"))
420                 ;;
421         git,2)
422                 COMPREPLY=($(compgen -W "$(__git_remotes)" -- "$cur"))
423                 ;;
424         *)
425                 case "$cur" in
426                 *:*)
427                         cur="${cur#*:}"
428                         COMPREPLY=($(compgen -W "$(__git_refs)" -- "$cur"))
429                         ;;
430                 *)
431                         local remote
432                         case "${COMP_WORDS[0]}" in
433                         git-fetch) remote="${COMP_WORDS[1]}" ;;
434                         git)       remote="${COMP_WORDS[2]}" ;;
435                         esac
436                         COMPREPLY=($(compgen -W "$(__git_refs2 "$remote")" -- "$cur"))
437                         ;;
438                 esac
439                 ;;
440         esac
443 _git_format_patch ()
445         local cur="${COMP_WORDS[COMP_CWORD]}"
446         case "$cur" in
447         --*)
448                 COMPREPLY=($(compgen -W "
449                         --stdout --attach --thread
450                         --output-directory
451                         --numbered --start-number
452                         --keep-subject
453                         --signoff
454                         --in-reply-to=
455                         --full-index --binary
456                         " -- "$cur"))
457                 return
458                 ;;
459         esac
460         __git_complete_revlist
463 _git_ls_remote ()
465         local cur="${COMP_WORDS[COMP_CWORD]}"
466         COMPREPLY=($(compgen -W "$(__git_remotes)" -- "$cur"))
469 _git_ls_tree ()
471         __git_complete_file
474 _git_log ()
476         local cur="${COMP_WORDS[COMP_CWORD]}"
477         case "$cur" in
478         --pretty=*)
479                 COMPREPLY=($(compgen -W "
480                         oneline short medium full fuller email raw
481                         " -- "${cur##--pretty=}"))
482                 return
483                 ;;
484         --*)
485                 COMPREPLY=($(compgen -W "
486                         --max-count= --max-age= --since= --after=
487                         --min-age= --before= --until=
488                         --root --not --topo-order --date-order
489                         --no-merges
490                         --abbrev-commit --abbrev=
491                         --relative-date
492                         --author= --committer= --grep=
493                         --all-match
494                         --pretty= --name-status --name-only
495                         " -- "$cur"))
496                 return
497                 ;;
498         esac
499         __git_complete_revlist
502 _git_merge ()
504         local cur="${COMP_WORDS[COMP_CWORD]}"
505         case "${COMP_WORDS[COMP_CWORD-1]}" in
506         -s|--strategy)
507                 COMPREPLY=($(compgen -W "$(__git_merge_strategies)" -- "$cur"))
508                 return
509         esac
510         case "$cur" in
511         --strategy=*)
512                 COMPREPLY=($(compgen -W "$(__git_merge_strategies)" \
513                         -- "${cur##--strategy=}"))
514                 return
515                 ;;
516         --*)
517                 COMPREPLY=($(compgen -W "
518                         --no-commit --no-summary --squash --strategy
519                         " -- "$cur"))
520                 return
521         esac
522         COMPREPLY=($(compgen -W "$(__git_refs)" -- "$cur"))
525 _git_merge_base ()
527         local cur="${COMP_WORDS[COMP_CWORD]}"
528         COMPREPLY=($(compgen -W "$(__git_refs)" -- "$cur"))
531 _git_name_rev ()
533         local cur="${COMP_WORDS[COMP_CWORD]}"
534         COMPREPLY=($(compgen -W "--tags --all --stdin" -- "$cur"))
537 _git_pull ()
539         local cur="${COMP_WORDS[COMP_CWORD]}"
541         case "${COMP_WORDS[0]},$COMP_CWORD" in
542         git-pull*,1)
543                 COMPREPLY=($(compgen -W "$(__git_remotes)" -- "$cur"))
544                 ;;
545         git,2)
546                 COMPREPLY=($(compgen -W "$(__git_remotes)" -- "$cur"))
547                 ;;
548         *)
549                 local remote
550                 case "${COMP_WORDS[0]}" in
551                 git-pull)  remote="${COMP_WORDS[1]}" ;;
552                 git)       remote="${COMP_WORDS[2]}" ;;
553                 esac
554                 COMPREPLY=($(compgen -W "$(__git_refs "$remote")" -- "$cur"))
555                 ;;
556         esac
559 _git_push ()
561         local cur="${COMP_WORDS[COMP_CWORD]}"
563         case "${COMP_WORDS[0]},$COMP_CWORD" in
564         git-push*,1)
565                 COMPREPLY=($(compgen -W "$(__git_remotes)" -- "$cur"))
566                 ;;
567         git,2)
568                 COMPREPLY=($(compgen -W "$(__git_remotes)" -- "$cur"))
569                 ;;
570         *)
571                 case "$cur" in
572                 *:*)
573                         local remote
574                         case "${COMP_WORDS[0]}" in
575                         git-push)  remote="${COMP_WORDS[1]}" ;;
576                         git)       remote="${COMP_WORDS[2]}" ;;
577                         esac
578                         cur="${cur#*:}"
579                         COMPREPLY=($(compgen -W "$(__git_refs "$remote")" -- "$cur"))
580                         ;;
581                 *)
582                         COMPREPLY=($(compgen -W "$(__git_refs2)" -- "$cur"))
583                         ;;
584                 esac
585                 ;;
586         esac
589 _git_rebase ()
591         local cur="${COMP_WORDS[COMP_CWORD]}"
592         if [ -d .dotest ]; then
593                 COMPREPLY=($(compgen -W "
594                         --continue --skip --abort
595                         " -- "$cur"))
596                 return
597         fi
598         case "${COMP_WORDS[COMP_CWORD-1]}" in
599         -s|--strategy)
600                 COMPREPLY=($(compgen -W "$(__git_merge_strategies)" -- "$cur"))
601                 return
602         esac
603         case "$cur" in
604         --strategy=*)
605                 COMPREPLY=($(compgen -W "$(__git_merge_strategies)" \
606                         -- "${cur##--strategy=}"))
607                 return
608                 ;;
609         --*)
610                 COMPREPLY=($(compgen -W "
611                         --onto --merge --strategy
612                         " -- "$cur"))
613                 return
614         esac
615         COMPREPLY=($(compgen -W "$(__git_refs)" -- "$cur"))
618 _git_config ()
620         local cur="${COMP_WORDS[COMP_CWORD]}"
621         local prv="${COMP_WORDS[COMP_CWORD-1]}"
622         case "$prv" in
623         branch.*.remote)
624                 COMPREPLY=($(compgen -W "$(__git_remotes)" -- "$cur"))
625                 return
626                 ;;
627         branch.*.merge)
628                 COMPREPLY=($(compgen -W "$(__git_refs)" -- "$cur"))
629                 return
630                 ;;
631         remote.*.fetch)
632                 local remote="${prv#remote.}"
633                 remote="${remote%.fetch}"
634                 COMPREPLY=($(compgen -W "$(__git_refs_remotes "$remote")" \
635                         -- "$cur"))
636                 return
637                 ;;
638         remote.*.push)
639                 local remote="${prv#remote.}"
640                 remote="${remote%.push}"
641                 COMPREPLY=($(compgen -W "$(git --git-dir="$(__gitdir)" \
642                         for-each-ref --format='%(refname):%(refname)' \
643                         refs/heads)" -- "$cur"))
644                 return
645                 ;;
646         *.*)
647                 COMPREPLY=()
648                 return
649                 ;;
650         esac
651         case "$cur" in
652         --*)
653                 COMPREPLY=($(compgen -W "
654                         --global --list --replace-all
655                         --get --get-all --get-regexp
656                         --unset --unset-all
657                         " -- "$cur"))
658                 return
659                 ;;
660         branch.*.*)
661                 local pfx="${cur%.*}."
662                 cur="${cur##*.}"
663                 COMPREPLY=($(compgen -P "$pfx" -W "remote merge" -- "$cur"))
664                 return
665                 ;;
666         branch.*)
667                 local pfx="${cur%.*}."
668                 cur="${cur#*.}"
669                 COMPREPLY=($(compgen -P "$pfx" -S . \
670                         -W "$(__git_heads)" -- "$cur"))
671                 return
672                 ;;
673         remote.*.*)
674                 local pfx="${cur%.*}."
675                 cur="${cur##*.}"
676                 COMPREPLY=($(compgen -P "$pfx" -W "url fetch push" -- "$cur"))
677                 return
678                 ;;
679         remote.*)
680                 local pfx="${cur%.*}."
681                 cur="${cur#*.}"
682                 COMPREPLY=($(compgen -P "$pfx" -S . \
683                         -W "$(__git_remotes)" -- "$cur"))
684                 return
685                 ;;
686         esac
687         COMPREPLY=($(compgen -W "
688                 apply.whitespace
689                 core.fileMode
690                 core.gitProxy
691                 core.ignoreStat
692                 core.preferSymlinkRefs
693                 core.logAllRefUpdates
694                 core.repositoryFormatVersion
695                 core.sharedRepository
696                 core.warnAmbiguousRefs
697                 core.compression
698                 core.legacyHeaders
699                 i18n.commitEncoding
700                 i18n.logOutputEncoding
701                 diff.color
702                 color.diff
703                 diff.renameLimit
704                 diff.renames
705                 pager.color
706                 color.pager
707                 status.color
708                 color.status
709                 log.showroot
710                 show.difftree
711                 showbranch.default
712                 whatchanged.difftree
713                 http.sslVerify
714                 http.sslCert
715                 http.sslKey
716                 http.sslCAInfo
717                 http.sslCAPath
718                 http.maxRequests
719                 http.lowSpeedLimit http.lowSpeedTime
720                 http.noEPSV
721                 pack.window
722                 repack.useDeltaBaseOffset
723                 pull.octopus pull.twohead
724                 merge.summary
725                 receive.unpackLimit
726                 receive.denyNonFastForwards
727                 user.name user.email
728                 tar.umask
729                 gitcvs.enabled
730                 gitcvs.logfile
731                 branch. remote.
732         " -- "$cur"))
735 _git_reset ()
737         local cur="${COMP_WORDS[COMP_CWORD]}"
738         local opt="--mixed --hard --soft"
739         COMPREPLY=($(compgen -W "$opt $(__git_refs)" -- "$cur"))
742 _git_show ()
744         local cur="${COMP_WORDS[COMP_CWORD]}"
745         case "$cur" in
746         --pretty=*)
747                 COMPREPLY=($(compgen -W "
748                         oneline short medium full fuller email raw
749                         " -- "${cur##--pretty=}"))
750                 return
751                 ;;
752         --*)
753                 COMPREPLY=($(compgen -W "--pretty=" -- "$cur"))
754                 return
755                 ;;
756         esac
757         __git_complete_file
760 _git ()
762         local i c=1 command __git_dir
764         while [ $c -lt $COMP_CWORD ]; do
765                 i="${COMP_WORDS[c]}"
766                 case "$i" in
767                 --git-dir=*) __git_dir="${i#--git-dir=}" ;;
768                 --bare)      __git_dir="." ;;
769                 --version|--help|-p|--paginate) ;;
770                 *) command="$i"; break ;;
771                 esac
772                 c=$((++c))
773         done
775         if [ $c -eq $COMP_CWORD -a -z "$command" ]; then
776                 COMPREPLY=($(compgen -W "
777                         --git-dir= --version --exec-path
778                         $(__git_commands)
779                         $(__git_aliases)
780                         " -- "${COMP_WORDS[COMP_CWORD]}"))
781                 return;
782         fi
784         local expansion=$(__git_aliased_command "$command")
785         [ "$expansion" ] && command="$expansion"
787         case "$command" in
788         am)          _git_am ;;
789         apply)       _git_apply ;;
790         branch)      _git_branch ;;
791         checkout)    _git_checkout ;;
792         cherry-pick) _git_cherry_pick ;;
793         commit)      _git_commit ;;
794         config)      _git_config ;;
795         diff)        _git_diff ;;
796         diff-tree)   _git_diff_tree ;;
797         fetch)       _git_fetch ;;
798         format-patch) _git_format_patch ;;
799         log)         _git_log ;;
800         ls-remote)   _git_ls_remote ;;
801         ls-tree)     _git_ls_tree ;;
802         merge)       _git_merge;;
803         merge-base)  _git_merge_base ;;
804         name-rev)    _git_name_rev ;;
805         pull)        _git_pull ;;
806         push)        _git_push ;;
807         rebase)      _git_rebase ;;
808         repo-config) _git_config ;;
809         reset)       _git_reset ;;
810         show)        _git_show ;;
811         show-branch) _git_log ;;
812         whatchanged) _git_log ;;
813         *)           COMPREPLY=() ;;
814         esac
817 _gitk ()
819         local cur="${COMP_WORDS[COMP_CWORD]}"
820         COMPREPLY=($(compgen -W "--all $(__git_refs)" -- "$cur"))
823 complete -o default -o nospace -F _git git
824 complete -o default            -F _gitk gitk
825 complete -o default            -F _git_am git-am
826 complete -o default            -F _git_apply git-apply
827 complete -o default            -F _git_branch git-branch
828 complete -o default            -F _git_checkout git-checkout
829 complete -o default            -F _git_cherry_pick git-cherry-pick
830 complete -o default            -F _git_commit git-commit
831 complete -o default -o nospace -F _git_diff git-diff
832 complete -o default            -F _git_diff_tree git-diff-tree
833 complete -o default -o nospace -F _git_fetch git-fetch
834 complete -o default -o nospace -F _git_format_patch git-format-patch
835 complete -o default -o nospace -F _git_log git-log
836 complete -o default            -F _git_ls_remote git-ls-remote
837 complete -o default -o nospace -F _git_ls_tree git-ls-tree
838 complete -o default            -F _git_merge git-merge
839 complete -o default            -F _git_merge_base git-merge-base
840 complete -o default            -F _git_name_rev git-name-rev
841 complete -o default -o nospace -F _git_pull git-pull
842 complete -o default -o nospace -F _git_push git-push
843 complete -o default            -F _git_rebase git-rebase
844 complete -o default            -F _git_config git-config
845 complete -o default            -F _git_reset git-reset
846 complete -o default -o nospace -F _git_show git-show
847 complete -o default -o nospace -F _git_log git-show-branch
848 complete -o default -o nospace -F _git_log git-whatchanged
850 # The following are necessary only for Cygwin, and only are needed
851 # when the user has tab-completed the executable name and consequently
852 # included the '.exe' suffix.
854 if [ Cygwin = "$(uname -o 2>/dev/null)" ]; then
855 complete -o default            -F _git_apply git-apply.exe
856 complete -o default -o nospace -F _git git.exe
857 complete -o default            -F _git_branch git-branch.exe
858 complete -o default -o nospace -F _git_diff git-diff.exe
859 complete -o default -o nospace -F _git_diff_tree git-diff-tree.exe
860 complete -o default -o nospace -F _git_format_patch git-format-patch.exe
861 complete -o default -o nospace -F _git_log git-log.exe
862 complete -o default -o nospace -F _git_ls_tree git-ls-tree.exe
863 complete -o default            -F _git_merge_base git-merge-base.exe
864 complete -o default            -F _git_name_rev git-name-rev.exe
865 complete -o default -o nospace -F _git_push git-push.exe
866 complete -o default            -F _git_config git-config
867 complete -o default -o nospace -F _git_show git-show.exe
868 complete -o default -o nospace -F _git_log git-show-branch.exe
869 complete -o default -o nospace -F _git_log git-whatchanged.exe
870 fi