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