Code

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