Merge branch 'maint-1.6.1' into maint-1.6.2
[git] / contrib / completion / git-completion.bash
1 #!bash
2 #
3 # bash completion support for core Git.
4 #
5 # Copyright (C) 2006,2007 Shawn O. Pearce <spearce@spearce.org>
6 # Conceptually based on gitcompletion (http://gitweb.hawaga.org.uk/).
7 # Distributed under the GNU General Public License, version 2.0.
8 #
9 # The contained completion routines provide support for completing:
10 #
11 #    *) local and remote branch names
12 #    *) local and remote tag names
13 #    *) .git/remotes file names
14 #    *) git 'subcommands'
15 #    *) tree paths within 'ref:path/to/file' expressions
16 #    *) common --long-options
17 #
18 # To use these routines:
19 #
20 #    1) Copy this file to somewhere (e.g. ~/.git-completion.sh).
21 #    2) Added the following line to your .bashrc:
22 #        source ~/.git-completion.sh
23 #
24 #    3) You may want to make sure the git executable is available
25 #       in your PATH before this script is sourced, as some caching
26 #       is performed while the script loads.  If git isn't found
27 #       at source time then all lookups will be done on demand,
28 #       which may be slightly slower.
29 #
30 #    4) Consider changing your PS1 to also show the current branch:
31 #        PS1='[\u@\h \W$(__git_ps1 " (%s)")]\$ '
32 #
33 #       The argument to __git_ps1 will be displayed only if you
34 #       are currently in a git repository.  The %s token will be
35 #       the name of the current branch.
36 #
37 #       In addition, if you set GIT_PS1_SHOWDIRTYSTATE to a nonempty
38 #       value, unstaged (*) and staged (+) changes will be shown next
39 #       to the branch name.  You can configure this per-repository
40 #       with the bash.showDirtyState variable, which defaults to true
41 #       once GIT_PS1_SHOWDIRTYSTATE is enabled.
42 #
43 # To submit patches:
44 #
45 #    *) Read Documentation/SubmittingPatches
46 #    *) Send all patches to the current maintainer:
47 #
48 #       "Shawn O. Pearce" <spearce@spearce.org>
49 #
50 #    *) Always CC the Git mailing list:
51 #
52 #       git@vger.kernel.org
53 #
54
55 case "$COMP_WORDBREAKS" in
56 *:*) : great ;;
57 *)   COMP_WORDBREAKS="$COMP_WORDBREAKS:"
58 esac
59
60 # __gitdir accepts 0 or 1 arguments (i.e., location)
61 # returns location of .git repo
62 __gitdir ()
63 {
64         if [ -z "${1-}" ]; then
65                 if [ -n "$__git_dir" ]; then
66                         echo "$__git_dir"
67                 elif [ -d .git ]; then
68                         echo .git
69                 else
70                         git rev-parse --git-dir 2>/dev/null
71                 fi
72         elif [ -d "$1/.git" ]; then
73                 echo "$1/.git"
74         else
75                 echo "$1"
76         fi
77 }
78
79 # __git_ps1 accepts 0 or 1 arguments (i.e., format string)
80 # returns text to add to bash PS1 prompt (includes branch name)
81 __git_ps1 ()
82 {
83         local g="$(git rev-parse --git-dir 2>/dev/null)"
84         if [ -n "$g" ]; then
85                 local r
86                 local b
87                 if [ -d "$g/rebase-apply" ]
88                 then
89                         if test -f "$g/rebase-apply/rebasing"
90                         then
91                                 r="|REBASE"
92                         elif test -f "$g/rebase-apply/applying"
93                         then
94                                 r="|AM"
95                         else
96                                 r="|AM/REBASE"
97                         fi
98                         b="$(git symbolic-ref HEAD 2>/dev/null)"
99                 elif [ -f "$g/rebase-merge/interactive" ]
100                 then
101                         r="|REBASE-i"
102                         b="$(cat "$g/rebase-merge/head-name")"
103                 elif [ -d "$g/rebase-merge" ]
104                 then
105                         r="|REBASE-m"
106                         b="$(cat "$g/rebase-merge/head-name")"
107                 elif [ -f "$g/MERGE_HEAD" ]
108                 then
109                         r="|MERGING"
110                         b="$(git symbolic-ref HEAD 2>/dev/null)"
111                 else
112                         if [ -f "$g/BISECT_LOG" ]
113                         then
114                                 r="|BISECTING"
115                         fi
116                         if ! b="$(git symbolic-ref HEAD 2>/dev/null)"
117                         then
118                                 if ! b="$(git describe --exact-match HEAD 2>/dev/null)"
119                                 then
120                                         b="$(cut -c1-7 "$g/HEAD")..."
121                                 fi
122                         fi
123                 fi
124
125                 local w
126                 local i
127
128                 if test -n "${GIT_PS1_SHOWDIRTYSTATE-}"; then
129                         if test "$(git config --bool bash.showDirtyState)" != "false"; then
130                                 git diff --no-ext-diff --ignore-submodules \
131                                         --quiet --exit-code || w="*"
132                                 if git rev-parse --quiet --verify HEAD >/dev/null; then
133                                         git diff-index --cached --quiet \
134                                                 --ignore-submodules HEAD -- || i="+"
135                                 else
136                                         i="#"
137                                 fi
138                         fi
139                 fi
140
141                 if [ -n "${1-}" ]; then
142                         printf "$1" "${b##refs/heads/}$w$i$r"
143                 else
144                         printf " (%s)" "${b##refs/heads/}$w$i$r"
145                 fi
146         fi
147 }
148
149 # __gitcomp_1 requires 2 arguments
150 __gitcomp_1 ()
151 {
152         local c IFS=' '$'\t'$'\n'
153         for c in $1; do
154                 case "$c$2" in
155                 --*=*) printf %s$'\n' "$c$2" ;;
156                 *.)    printf %s$'\n' "$c$2" ;;
157                 *)     printf %s$'\n' "$c$2 " ;;
158                 esac
159         done
160 }
161
162 # __gitcomp accepts 1, 2, 3, or 4 arguments
163 # generates completion reply with compgen
164 __gitcomp ()
165 {
166         local cur="${COMP_WORDS[COMP_CWORD]}"
167         if [ $# -gt 2 ]; then
168                 cur="$3"
169         fi
170         case "$cur" in
171         --*=)
172                 COMPREPLY=()
173                 ;;
174         *)
175                 local IFS=$'\n'
176                 COMPREPLY=($(compgen -P "${2-}" \
177                         -W "$(__gitcomp_1 "${1-}" "${4-}")" \
178                         -- "$cur"))
179                 ;;
180         esac
181 }
182
183 # __git_heads accepts 0 or 1 arguments (to pass to __gitdir)
184 __git_heads ()
185 {
186         local cmd i is_hash=y dir="$(__gitdir "${1-}")"
187         if [ -d "$dir" ]; then
188                 git --git-dir="$dir" for-each-ref --format='%(refname:short)' \
189                         refs/heads
190                 return
191         fi
192         for i in $(git ls-remote "${1-}" 2>/dev/null); do
193                 case "$is_hash,$i" in
194                 y,*) is_hash=n ;;
195                 n,*^{}) is_hash=y ;;
196                 n,refs/heads/*) is_hash=y; echo "${i#refs/heads/}" ;;
197                 n,*) is_hash=y; echo "$i" ;;
198                 esac
199         done
200 }
201
202 # __git_tags accepts 0 or 1 arguments (to pass to __gitdir)
203 __git_tags ()
204 {
205         local cmd i is_hash=y dir="$(__gitdir "${1-}")"
206         if [ -d "$dir" ]; then
207                 git --git-dir="$dir" for-each-ref --format='%(refname:short)' \
208                         refs/tags
209                 return
210         fi
211         for i in $(git ls-remote "${1-}" 2>/dev/null); do
212                 case "$is_hash,$i" in
213                 y,*) is_hash=n ;;
214                 n,*^{}) is_hash=y ;;
215                 n,refs/tags/*) is_hash=y; echo "${i#refs/tags/}" ;;
216                 n,*) is_hash=y; echo "$i" ;;
217                 esac
218         done
219 }
220
221 # __git_refs accepts 0 or 1 arguments (to pass to __gitdir)
222 __git_refs ()
223 {
224         local i is_hash=y dir="$(__gitdir "${1-}")"
225         local cur="${COMP_WORDS[COMP_CWORD]}" format refs
226         if [ -d "$dir" ]; then
227                 case "$cur" in
228                 refs|refs/*)
229                         format="refname"
230                         refs="${cur%/*}"
231                         ;;
232                 *)
233                         if [ -e "$dir/HEAD" ]; then echo HEAD; fi
234                         format="refname:short"
235                         refs="refs/tags refs/heads refs/remotes"
236                         ;;
237                 esac
238                 git --git-dir="$dir" for-each-ref --format="%($format)" \
239                         $refs
240                 return
241         fi
242         for i in $(git ls-remote "$dir" 2>/dev/null); do
243                 case "$is_hash,$i" in
244                 y,*) is_hash=n ;;
245                 n,*^{}) is_hash=y ;;
246                 n,refs/tags/*) is_hash=y; echo "${i#refs/tags/}" ;;
247                 n,refs/heads/*) is_hash=y; echo "${i#refs/heads/}" ;;
248                 n,refs/remotes/*) is_hash=y; echo "${i#refs/remotes/}" ;;
249                 n,*) is_hash=y; echo "$i" ;;
250                 esac
251         done
252 }
253
254 # __git_refs2 requires 1 argument (to pass to __git_refs)
255 __git_refs2 ()
256 {
257         local i
258         for i in $(__git_refs "$1"); do
259                 echo "$i:$i"
260         done
261 }
262
263 # __git_refs_remotes requires 1 argument (to pass to ls-remote)
264 __git_refs_remotes ()
265 {
266         local cmd i is_hash=y
267         for i in $(git ls-remote "$1" 2>/dev/null); do
268                 case "$is_hash,$i" in
269                 n,refs/heads/*)
270                         is_hash=y
271                         echo "$i:refs/remotes/$1/${i#refs/heads/}"
272                         ;;
273                 y,*) is_hash=n ;;
274                 n,*^{}) is_hash=y ;;
275                 n,refs/tags/*) is_hash=y;;
276                 n,*) is_hash=y; ;;
277                 esac
278         done
279 }
280
281 __git_remotes ()
282 {
283         local i ngoff IFS=$'\n' d="$(__gitdir)"
284         shopt -q nullglob || ngoff=1
285         shopt -s nullglob
286         for i in "$d/remotes"/*; do
287                 echo ${i#$d/remotes/}
288         done
289         [ "$ngoff" ] && shopt -u nullglob
290         for i in $(git --git-dir="$d" config --list); do
291                 case "$i" in
292                 remote.*.url=*)
293                         i="${i#remote.}"
294                         echo "${i/.url=*/}"
295                         ;;
296                 esac
297         done
298 }
299
300 __git_merge_strategies ()
301 {
302         if [ -n "$__git_merge_strategylist" ]; then
303                 echo "$__git_merge_strategylist"
304                 return
305         fi
306         git merge -s help 2>&1 |
307         sed -n -e '/[Aa]vailable strategies are: /,/^$/{
308                 s/\.$//
309                 s/.*://
310                 s/^[    ]*//
311                 s/[     ]*$//
312                 p
313         }'
314 }
315 __git_merge_strategylist=
316 __git_merge_strategylist=$(__git_merge_strategies 2>/dev/null)
317
318 __git_complete_file ()
319 {
320         local pfx ls ref cur="${COMP_WORDS[COMP_CWORD]}"
321         case "$cur" in
322         ?*:*)
323                 ref="${cur%%:*}"
324                 cur="${cur#*:}"
325                 case "$cur" in
326                 ?*/*)
327                         pfx="${cur%/*}"
328                         cur="${cur##*/}"
329                         ls="$ref:$pfx"
330                         pfx="$pfx/"
331                         ;;
332                 *)
333                         ls="$ref"
334                         ;;
335             esac
336
337                 case "$COMP_WORDBREAKS" in
338                 *:*) : great ;;
339                 *)   pfx="$ref:$pfx" ;;
340                 esac
341
342                 local IFS=$'\n'
343                 COMPREPLY=($(compgen -P "$pfx" \
344                         -W "$(git --git-dir="$(__gitdir)" ls-tree "$ls" \
345                                 | sed '/^100... blob /{
346                                            s,^.*        ,,
347                                            s,$, ,
348                                        }
349                                        /^120000 blob /{
350                                            s,^.*        ,,
351                                            s,$, ,
352                                        }
353                                        /^040000 tree /{
354                                            s,^.*        ,,
355                                            s,$,/,
356                                        }
357                                        s/^.*    //')" \
358                         -- "$cur"))
359                 ;;
360         *)
361                 __gitcomp "$(__git_refs)"
362                 ;;
363         esac
364 }
365
366 __git_complete_revlist ()
367 {
368         local pfx cur="${COMP_WORDS[COMP_CWORD]}"
369         case "$cur" in
370         *...*)
371                 pfx="${cur%...*}..."
372                 cur="${cur#*...}"
373                 __gitcomp "$(__git_refs)" "$pfx" "$cur"
374                 ;;
375         *..*)
376                 pfx="${cur%..*}.."
377                 cur="${cur#*..}"
378                 __gitcomp "$(__git_refs)" "$pfx" "$cur"
379                 ;;
380         *)
381                 __gitcomp "$(__git_refs)"
382                 ;;
383         esac
384 }
385
386 __git_all_commands ()
387 {
388         if [ -n "$__git_all_commandlist" ]; then
389                 echo "$__git_all_commandlist"
390                 return
391         fi
392         local i IFS=" "$'\n'
393         for i in $(git help -a|egrep '^ ')
394         do
395                 case $i in
396                 *--*)             : helper pattern;;
397                 *) echo $i;;
398                 esac
399         done
400 }
401 __git_all_commandlist=
402 __git_all_commandlist="$(__git_all_commands 2>/dev/null)"
403
404 __git_porcelain_commands ()
405 {
406         if [ -n "$__git_porcelain_commandlist" ]; then
407                 echo "$__git_porcelain_commandlist"
408                 return
409         fi
410         local i IFS=" "$'\n'
411         for i in "help" $(__git_all_commands)
412         do
413                 case $i in
414                 *--*)             : helper pattern;;
415                 applymbox)        : ask gittus;;
416                 applypatch)       : ask gittus;;
417                 archimport)       : import;;
418                 cat-file)         : plumbing;;
419                 check-attr)       : plumbing;;
420                 check-ref-format) : plumbing;;
421                 checkout-index)   : plumbing;;
422                 commit-tree)      : plumbing;;
423                 count-objects)    : infrequent;;
424                 cvsexportcommit)  : export;;
425                 cvsimport)        : import;;
426                 cvsserver)        : daemon;;
427                 daemon)           : daemon;;
428                 diff-files)       : plumbing;;
429                 diff-index)       : plumbing;;
430                 diff-tree)        : plumbing;;
431                 fast-import)      : import;;
432                 fast-export)      : export;;
433                 fsck-objects)     : plumbing;;
434                 fetch-pack)       : plumbing;;
435                 fmt-merge-msg)    : plumbing;;
436                 for-each-ref)     : plumbing;;
437                 hash-object)      : plumbing;;
438                 http-*)           : transport;;
439                 index-pack)       : plumbing;;
440                 init-db)          : deprecated;;
441                 local-fetch)      : plumbing;;
442                 lost-found)       : infrequent;;
443                 ls-files)         : plumbing;;
444                 ls-remote)        : plumbing;;
445                 ls-tree)          : plumbing;;
446                 mailinfo)         : plumbing;;
447                 mailsplit)        : plumbing;;
448                 merge-*)          : plumbing;;
449                 mktree)           : plumbing;;
450                 mktag)            : plumbing;;
451                 pack-objects)     : plumbing;;
452                 pack-redundant)   : plumbing;;
453                 pack-refs)        : plumbing;;
454                 parse-remote)     : plumbing;;
455                 patch-id)         : plumbing;;
456                 peek-remote)      : plumbing;;
457                 prune)            : plumbing;;
458                 prune-packed)     : plumbing;;
459                 quiltimport)      : import;;
460                 read-tree)        : plumbing;;
461                 receive-pack)     : plumbing;;
462                 reflog)           : plumbing;;
463                 repo-config)      : deprecated;;
464                 rerere)           : plumbing;;
465                 rev-list)         : plumbing;;
466                 rev-parse)        : plumbing;;
467                 runstatus)        : plumbing;;
468                 sh-setup)         : internal;;
469                 shell)            : daemon;;
470                 show-ref)         : plumbing;;
471                 send-pack)        : plumbing;;
472                 show-index)       : plumbing;;
473                 ssh-*)            : transport;;
474                 stripspace)       : plumbing;;
475                 symbolic-ref)     : plumbing;;
476                 tar-tree)         : deprecated;;
477                 unpack-file)      : plumbing;;
478                 unpack-objects)   : plumbing;;
479                 update-index)     : plumbing;;
480                 update-ref)       : plumbing;;
481                 update-server-info) : daemon;;
482                 upload-archive)   : plumbing;;
483                 upload-pack)      : plumbing;;
484                 write-tree)       : plumbing;;
485                 var)              : infrequent;;
486                 verify-pack)      : infrequent;;
487                 verify-tag)       : plumbing;;
488                 *) echo $i;;
489                 esac
490         done
491 }
492 __git_porcelain_commandlist=
493 __git_porcelain_commandlist="$(__git_porcelain_commands 2>/dev/null)"
494
495 __git_aliases ()
496 {
497         local i IFS=$'\n'
498         for i in $(git --git-dir="$(__gitdir)" config --list); do
499                 case "$i" in
500                 alias.*)
501                         i="${i#alias.}"
502                         echo "${i/=*/}"
503                         ;;
504                 esac
505         done
506 }
507
508 # __git_aliased_command requires 1 argument
509 __git_aliased_command ()
510 {
511         local word cmdline=$(git --git-dir="$(__gitdir)" \
512                 config --get "alias.$1")
513         for word in $cmdline; do
514                 if [ "${word##-*}" ]; then
515                         echo $word
516                         return
517                 fi
518         done
519 }
520
521 # __git_find_subcommand requires 1 argument
522 __git_find_subcommand ()
523 {
524         local word subcommand c=1
525
526         while [ $c -lt $COMP_CWORD ]; do
527                 word="${COMP_WORDS[c]}"
528                 for subcommand in $1; do
529                         if [ "$subcommand" = "$word" ]; then
530                                 echo "$subcommand"
531                                 return
532                         fi
533                 done
534                 c=$((++c))
535         done
536 }
537
538 __git_has_doubledash ()
539 {
540         local c=1
541         while [ $c -lt $COMP_CWORD ]; do
542                 if [ "--" = "${COMP_WORDS[c]}" ]; then
543                         return 0
544                 fi
545                 c=$((++c))
546         done
547         return 1
548 }
549
550 __git_whitespacelist="nowarn warn error error-all fix"
551
552 _git_am ()
553 {
554         local cur="${COMP_WORDS[COMP_CWORD]}" dir="$(__gitdir)"
555         if [ -d "$dir"/rebase-apply ]; then
556                 __gitcomp "--skip --resolved --abort"
557                 return
558         fi
559         case "$cur" in
560         --whitespace=*)
561                 __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
562                 return
563                 ;;
564         --*)
565                 __gitcomp "
566                         --signoff --utf8 --binary --3way --interactive
567                         --whitespace=
568                         "
569                 return
570         esac
571         COMPREPLY=()
572 }
573
574 _git_apply ()
575 {
576         local cur="${COMP_WORDS[COMP_CWORD]}"
577         case "$cur" in
578         --whitespace=*)
579                 __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
580                 return
581                 ;;
582         --*)
583                 __gitcomp "
584                         --stat --numstat --summary --check --index
585                         --cached --index-info --reverse --reject --unidiff-zero
586                         --apply --no-add --exclude=
587                         --whitespace= --inaccurate-eof --verbose
588                         "
589                 return
590         esac
591         COMPREPLY=()
592 }
593
594 _git_add ()
595 {
596         __git_has_doubledash && return
597
598         local cur="${COMP_WORDS[COMP_CWORD]}"
599         case "$cur" in
600         --*)
601                 __gitcomp "
602                         --interactive --refresh --patch --update --dry-run
603                         --ignore-errors --intent-to-add
604                         "
605                 return
606         esac
607         COMPREPLY=()
608 }
609
610 _git_archive ()
611 {
612         local cur="${COMP_WORDS[COMP_CWORD]}"
613         case "$cur" in
614         --format=*)
615                 __gitcomp "$(git archive --list)" "" "${cur##--format=}"
616                 return
617                 ;;
618         --remote=*)
619                 __gitcomp "$(__git_remotes)" "" "${cur##--remote=}"
620                 return
621                 ;;
622         --*)
623                 __gitcomp "
624                         --format= --list --verbose
625                         --prefix= --remote= --exec=
626                         "
627                 return
628                 ;;
629         esac
630         __git_complete_file
631 }
632
633 _git_bisect ()
634 {
635         __git_has_doubledash && return
636
637         local subcommands="start bad good skip reset visualize replay log run"
638         local subcommand="$(__git_find_subcommand "$subcommands")"
639         if [ -z "$subcommand" ]; then
640                 __gitcomp "$subcommands"
641                 return
642         fi
643
644         case "$subcommand" in
645         bad|good|reset|skip)
646                 __gitcomp "$(__git_refs)"
647                 ;;
648         *)
649                 COMPREPLY=()
650                 ;;
651         esac
652 }
653
654 _git_branch ()
655 {
656         local i c=1 only_local_ref="n" has_r="n"
657
658         while [ $c -lt $COMP_CWORD ]; do
659                 i="${COMP_WORDS[c]}"
660                 case "$i" in
661                 -d|-m)  only_local_ref="y" ;;
662                 -r)     has_r="y" ;;
663                 esac
664                 c=$((++c))
665         done
666
667         case "${COMP_WORDS[COMP_CWORD]}" in
668         --*)
669                 __gitcomp "
670                         --color --no-color --verbose --abbrev= --no-abbrev
671                         --track --no-track --contains --merged --no-merged
672                         "
673                 ;;
674         *)
675                 if [ $only_local_ref = "y" -a $has_r = "n" ]; then
676                         __gitcomp "$(__git_heads)"
677                 else
678                         __gitcomp "$(__git_refs)"
679                 fi
680                 ;;
681         esac
682 }
683
684 _git_bundle ()
685 {
686         local cmd="${COMP_WORDS[2]}"
687         case "$COMP_CWORD" in
688         2)
689                 __gitcomp "create list-heads verify unbundle"
690                 ;;
691         3)
692                 # looking for a file
693                 ;;
694         *)
695                 case "$cmd" in
696                         create)
697                                 __git_complete_revlist
698                         ;;
699                 esac
700                 ;;
701         esac
702 }
703
704 _git_checkout ()
705 {
706         __git_has_doubledash && return
707
708         __gitcomp "$(__git_refs)"
709 }
710
711 _git_cherry ()
712 {
713         __gitcomp "$(__git_refs)"
714 }
715
716 _git_cherry_pick ()
717 {
718         local cur="${COMP_WORDS[COMP_CWORD]}"
719         case "$cur" in
720         --*)
721                 __gitcomp "--edit --no-commit"
722                 ;;
723         *)
724                 __gitcomp "$(__git_refs)"
725                 ;;
726         esac
727 }
728
729 _git_clean ()
730 {
731         __git_has_doubledash && return
732
733         local cur="${COMP_WORDS[COMP_CWORD]}"
734         case "$cur" in
735         --*)
736                 __gitcomp "--dry-run --quiet"
737                 return
738                 ;;
739         esac
740         COMPREPLY=()
741 }
742
743 _git_clone ()
744 {
745         local cur="${COMP_WORDS[COMP_CWORD]}"
746         case "$cur" in
747         --*)
748                 __gitcomp "
749                         --local
750                         --no-hardlinks
751                         --shared
752                         --reference
753                         --quiet
754                         --no-checkout
755                         --bare
756                         --mirror
757                         --origin
758                         --upload-pack
759                         --template=
760                         --depth
761                         "
762                 return
763                 ;;
764         esac
765         COMPREPLY=()
766 }
767
768 _git_commit ()
769 {
770         __git_has_doubledash && return
771
772         local cur="${COMP_WORDS[COMP_CWORD]}"
773         case "$cur" in
774         --*)
775                 __gitcomp "
776                         --all --author= --signoff --verify --no-verify
777                         --edit --amend --include --only --interactive
778                         "
779                 return
780         esac
781         COMPREPLY=()
782 }
783
784 _git_describe ()
785 {
786         local cur="${COMP_WORDS[COMP_CWORD]}"
787         case "$cur" in
788         --*)
789                 __gitcomp "
790                         --all --tags --contains --abbrev= --candidates=
791                         --exact-match --debug --long --match --always
792                         "
793                 return
794         esac
795         __gitcomp "$(__git_refs)"
796 }
797
798 __git_diff_common_options="--stat --numstat --shortstat --summary
799                         --patch-with-stat --name-only --name-status --color
800                         --no-color --color-words --no-renames --check
801                         --full-index --binary --abbrev --diff-filter=
802                         --find-copies-harder
803                         --text --ignore-space-at-eol --ignore-space-change
804                         --ignore-all-space --exit-code --quiet --ext-diff
805                         --no-ext-diff
806                         --no-prefix --src-prefix= --dst-prefix=
807                         --inter-hunk-context=
808                         --patience
809                         --raw
810 "
811
812 _git_diff ()
813 {
814         __git_has_doubledash && return
815
816         local cur="${COMP_WORDS[COMP_CWORD]}"
817         case "$cur" in
818         --*)
819                 __gitcomp "--cached --pickaxe-all --pickaxe-regex
820                         --base --ours --theirs
821                         $__git_diff_common_options
822                         "
823                 return
824                 ;;
825         esac
826         __git_complete_file
827 }
828
829 _git_fetch ()
830 {
831         local cur="${COMP_WORDS[COMP_CWORD]}"
832
833         if [ "$COMP_CWORD" = 2 ]; then
834                 __gitcomp "$(__git_remotes)"
835         else
836                 case "$cur" in
837                 *:*)
838                         local pfx=""
839                         case "$COMP_WORDBREAKS" in
840                         *:*) : great ;;
841                         *)   pfx="${cur%%:*}:" ;;
842                         esac
843                         __gitcomp "$(__git_refs)" "$pfx" "${cur#*:}"
844                         ;;
845                 *)
846                         __gitcomp "$(__git_refs2 "${COMP_WORDS[2]}")"
847                         ;;
848                 esac
849         fi
850 }
851
852 _git_format_patch ()
853 {
854         local cur="${COMP_WORDS[COMP_CWORD]}"
855         case "$cur" in
856         --*)
857                 __gitcomp "
858                         --stdout --attach --thread
859                         --output-directory
860                         --numbered --start-number
861                         --numbered-files
862                         --keep-subject
863                         --signoff
864                         --in-reply-to=
865                         --full-index --binary
866                         --not --all
867                         --cover-letter
868                         --no-prefix --src-prefix= --dst-prefix=
869                         --inline --suffix= --ignore-if-in-upstream
870                         --subject-prefix=
871                         "
872                 return
873                 ;;
874         esac
875         __git_complete_revlist
876 }
877
878 _git_gc ()
879 {
880         local cur="${COMP_WORDS[COMP_CWORD]}"
881         case "$cur" in
882         --*)
883                 __gitcomp "--prune --aggressive"
884                 return
885                 ;;
886         esac
887         COMPREPLY=()
888 }
889
890 _git_grep ()
891 {
892         __git_has_doubledash && return
893
894         local cur="${COMP_WORDS[COMP_CWORD]}"
895         case "$cur" in
896         --*)
897                 __gitcomp "
898                         --cached
899                         --text --ignore-case --word-regexp --invert-match
900                         --full-name
901                         --extended-regexp --basic-regexp --fixed-strings
902                         --files-with-matches --name-only
903                         --files-without-match
904                         --count
905                         --and --or --not --all-match
906                         "
907                 return
908                 ;;
909         esac
910         COMPREPLY=()
911 }
912
913 _git_help ()
914 {
915         local cur="${COMP_WORDS[COMP_CWORD]}"
916         case "$cur" in
917         --*)
918                 __gitcomp "--all --info --man --web"
919                 return
920                 ;;
921         esac
922         __gitcomp "$(__git_all_commands)
923                 attributes cli core-tutorial cvs-migration
924                 diffcore gitk glossary hooks ignore modules
925                 repository-layout tutorial tutorial-2
926                 workflows
927                 "
928 }
929
930 _git_init ()
931 {
932         local cur="${COMP_WORDS[COMP_CWORD]}"
933         case "$cur" in
934         --shared=*)
935                 __gitcomp "
936                         false true umask group all world everybody
937                         " "" "${cur##--shared=}"
938                 return
939                 ;;
940         --*)
941                 __gitcomp "--quiet --bare --template= --shared --shared="
942                 return
943                 ;;
944         esac
945         COMPREPLY=()
946 }
947
948 _git_ls_files ()
949 {
950         __git_has_doubledash && return
951
952         local cur="${COMP_WORDS[COMP_CWORD]}"
953         case "$cur" in
954         --*)
955                 __gitcomp "--cached --deleted --modified --others --ignored
956                         --stage --directory --no-empty-directory --unmerged
957                         --killed --exclude= --exclude-from=
958                         --exclude-per-directory= --exclude-standard
959                         --error-unmatch --with-tree= --full-name
960                         --abbrev --ignored --exclude-per-directory
961                         "
962                 return
963                 ;;
964         esac
965         COMPREPLY=()
966 }
967
968 _git_ls_remote ()
969 {
970         __gitcomp "$(__git_remotes)"
971 }
972
973 _git_ls_tree ()
974 {
975         __git_complete_file
976 }
977
978 # Options that go well for log, shortlog and gitk
979 __git_log_common_options="
980         --not --all
981         --branches --tags --remotes
982         --first-parent --no-merges
983         --max-count=
984         --max-age= --since= --after=
985         --min-age= --until= --before=
986 "
987 # Options that go well for log and gitk (not shortlog)
988 __git_log_gitk_options="
989         --dense --sparse --full-history
990         --simplify-merges --simplify-by-decoration
991         --left-right
992 "
993 # Options that go well for log and shortlog (not gitk)
994 __git_log_shortlog_options="
995         --author= --committer= --grep=
996         --all-match
997 "
998
999 __git_log_pretty_formats="oneline short medium full fuller email raw format:"
1000
1001 _git_log ()
1002 {
1003         __git_has_doubledash && return
1004
1005         local cur="${COMP_WORDS[COMP_CWORD]}"
1006         local g="$(git rev-parse --git-dir 2>/dev/null)"
1007         local merge=""
1008         if [ -f "$g/MERGE_HEAD" ]; then
1009                 merge="--merge"
1010         fi
1011         case "$cur" in
1012         --pretty=*)
1013                 __gitcomp "$__git_log_pretty_formats
1014                         " "" "${cur##--pretty=}"
1015                 return
1016                 ;;
1017         --date=*)
1018                 __gitcomp "
1019                         relative iso8601 rfc2822 short local default
1020                 " "" "${cur##--date=}"
1021                 return
1022                 ;;
1023         --*)
1024                 __gitcomp "
1025                         $__git_log_common_options
1026                         $__git_log_shortlog_options
1027                         $__git_log_gitk_options
1028                         --root --topo-order --date-order --reverse
1029                         --follow
1030                         --abbrev-commit --abbrev=
1031                         --relative-date --date=
1032                         --pretty=
1033                         --cherry-pick
1034                         --graph
1035                         --decorate
1036                         --walk-reflogs
1037                         --parents --children
1038                         $merge
1039                         $__git_diff_common_options
1040                         --pickaxe-all --pickaxe-regex
1041                         "
1042                 return
1043                 ;;
1044         esac
1045         __git_complete_revlist
1046 }
1047
1048 _git_merge ()
1049 {
1050         local cur="${COMP_WORDS[COMP_CWORD]}"
1051         case "${COMP_WORDS[COMP_CWORD-1]}" in
1052         -s|--strategy)
1053                 __gitcomp "$(__git_merge_strategies)"
1054                 return
1055         esac
1056         case "$cur" in
1057         --strategy=*)
1058                 __gitcomp "$(__git_merge_strategies)" "" "${cur##--strategy=}"
1059                 return
1060                 ;;
1061         --*)
1062                 __gitcomp "
1063                         --no-commit --no-stat --log --no-log --squash --strategy
1064                         --commit --stat --no-squash --ff --no-ff
1065                         "
1066                 return
1067         esac
1068         __gitcomp "$(__git_refs)"
1069 }
1070
1071 _git_mergetool ()
1072 {
1073         local cur="${COMP_WORDS[COMP_CWORD]}"
1074         case "$cur" in
1075         --tool=*)
1076                 __gitcomp "
1077                         kdiff3 tkdiff meld xxdiff emerge
1078                         vimdiff gvimdiff ecmerge opendiff
1079                         " "" "${cur##--tool=}"
1080                 return
1081                 ;;
1082         --*)
1083                 __gitcomp "--tool="
1084                 return
1085                 ;;
1086         esac
1087         COMPREPLY=()
1088 }
1089
1090 _git_merge_base ()
1091 {
1092         __gitcomp "$(__git_refs)"
1093 }
1094
1095 _git_mv ()
1096 {
1097         local cur="${COMP_WORDS[COMP_CWORD]}"
1098         case "$cur" in
1099         --*)
1100                 __gitcomp "--dry-run"
1101                 return
1102                 ;;
1103         esac
1104         COMPREPLY=()
1105 }
1106
1107 _git_name_rev ()
1108 {
1109         __gitcomp "--tags --all --stdin"
1110 }
1111
1112 _git_pull ()
1113 {
1114         local cur="${COMP_WORDS[COMP_CWORD]}"
1115
1116         if [ "$COMP_CWORD" = 2 ]; then
1117                 __gitcomp "$(__git_remotes)"
1118         else
1119                 __gitcomp "$(__git_refs "${COMP_WORDS[2]}")"
1120         fi
1121 }
1122
1123 _git_push ()
1124 {
1125         local cur="${COMP_WORDS[COMP_CWORD]}"
1126
1127         if [ "$COMP_CWORD" = 2 ]; then
1128                 __gitcomp "$(__git_remotes)"
1129         else
1130                 case "$cur" in
1131                 *:*)
1132                         local pfx=""
1133                         case "$COMP_WORDBREAKS" in
1134                         *:*) : great ;;
1135                         *)   pfx="${cur%%:*}:" ;;
1136                         esac
1137
1138                         __gitcomp "$(__git_refs "${COMP_WORDS[2]}")" "$pfx" "${cur#*:}"
1139                         ;;
1140                 +*)
1141                         __gitcomp "$(__git_refs)" + "${cur#+}"
1142                         ;;
1143                 *)
1144                         __gitcomp "$(__git_refs)"
1145                         ;;
1146                 esac
1147         fi
1148 }
1149
1150 _git_rebase ()
1151 {
1152         local cur="${COMP_WORDS[COMP_CWORD]}" dir="$(__gitdir)"
1153         if [ -d "$dir"/rebase-apply ] || [ -d "$dir"/rebase-merge ]; then
1154                 __gitcomp "--continue --skip --abort"
1155                 return
1156         fi
1157         case "${COMP_WORDS[COMP_CWORD-1]}" in
1158         -s|--strategy)
1159                 __gitcomp "$(__git_merge_strategies)"
1160                 return
1161         esac
1162         case "$cur" in
1163         --strategy=*)
1164                 __gitcomp "$(__git_merge_strategies)" "" "${cur##--strategy=}"
1165                 return
1166                 ;;
1167         --*)
1168                 __gitcomp "--onto --merge --strategy --interactive"
1169                 return
1170         esac
1171         __gitcomp "$(__git_refs)"
1172 }
1173
1174 _git_send_email ()
1175 {
1176         local cur="${COMP_WORDS[COMP_CWORD]}"
1177         case "$cur" in
1178         --*)
1179                 __gitcomp "--bcc --cc --cc-cmd --chain-reply-to --compose
1180                         --dry-run --envelope-sender --from --identity
1181                         --in-reply-to --no-chain-reply-to --no-signed-off-by-cc
1182                         --no-suppress-from --no-thread --quiet
1183                         --signed-off-by-cc --smtp-pass --smtp-server
1184                         --smtp-server-port --smtp-ssl --smtp-user --subject
1185                         --suppress-cc --suppress-from --thread --to
1186                         --validate --no-validate"
1187                 return
1188                 ;;
1189         esac
1190         COMPREPLY=()
1191 }
1192
1193 _git_config ()
1194 {
1195         local cur="${COMP_WORDS[COMP_CWORD]}"
1196         local prv="${COMP_WORDS[COMP_CWORD-1]}"
1197         case "$prv" in
1198         branch.*.remote)
1199                 __gitcomp "$(__git_remotes)"
1200                 return
1201                 ;;
1202         branch.*.merge)
1203                 __gitcomp "$(__git_refs)"
1204                 return
1205                 ;;
1206         remote.*.fetch)
1207                 local remote="${prv#remote.}"
1208                 remote="${remote%.fetch}"
1209                 __gitcomp "$(__git_refs_remotes "$remote")"
1210                 return
1211                 ;;
1212         remote.*.push)
1213                 local remote="${prv#remote.}"
1214                 remote="${remote%.push}"
1215                 __gitcomp "$(git --git-dir="$(__gitdir)" \
1216                         for-each-ref --format='%(refname):%(refname)' \
1217                         refs/heads)"
1218                 return
1219                 ;;
1220         pull.twohead|pull.octopus)
1221                 __gitcomp "$(__git_merge_strategies)"
1222                 return
1223                 ;;
1224         color.branch|color.diff|color.interactive|color.status|color.ui)
1225                 __gitcomp "always never auto"
1226                 return
1227                 ;;
1228         color.pager)
1229                 __gitcomp "false true"
1230                 return
1231                 ;;
1232         color.*.*)
1233                 __gitcomp "
1234                         normal black red green yellow blue magenta cyan white
1235                         bold dim ul blink reverse
1236                         "
1237                 return
1238                 ;;
1239         *.*)
1240                 COMPREPLY=()
1241                 return
1242                 ;;
1243         esac
1244         case "$cur" in
1245         --*)
1246                 __gitcomp "
1247                         --global --system --file=
1248                         --list --replace-all
1249                         --get --get-all --get-regexp
1250                         --add --unset --unset-all
1251                         --remove-section --rename-section
1252                         "
1253                 return
1254                 ;;
1255         branch.*.*)
1256                 local pfx="${cur%.*}."
1257                 cur="${cur##*.}"
1258                 __gitcomp "remote merge mergeoptions" "$pfx" "$cur"
1259                 return
1260                 ;;
1261         branch.*)
1262                 local pfx="${cur%.*}."
1263                 cur="${cur#*.}"
1264                 __gitcomp "$(__git_heads)" "$pfx" "$cur" "."
1265                 return
1266                 ;;
1267         remote.*.*)
1268                 local pfx="${cur%.*}."
1269                 cur="${cur##*.}"
1270                 __gitcomp "
1271                         url proxy fetch push mirror skipDefaultUpdate
1272                         receivepack uploadpack tagopt
1273                         " "$pfx" "$cur"
1274                 return
1275                 ;;
1276         remote.*)
1277                 local pfx="${cur%.*}."
1278                 cur="${cur#*.}"
1279                 __gitcomp "$(__git_remotes)" "$pfx" "$cur" "."
1280                 return
1281                 ;;
1282         esac
1283         __gitcomp "
1284                 apply.whitespace
1285                 branch.autosetupmerge
1286                 branch.autosetuprebase
1287                 clean.requireForce
1288                 color.branch
1289                 color.branch.current
1290                 color.branch.local
1291                 color.branch.plain
1292                 color.branch.remote
1293                 color.diff
1294                 color.diff.commit
1295                 color.diff.frag
1296                 color.diff.meta
1297                 color.diff.new
1298                 color.diff.old
1299                 color.diff.plain
1300                 color.diff.whitespace
1301                 color.interactive
1302                 color.interactive.header
1303                 color.interactive.help
1304                 color.interactive.prompt
1305                 color.pager
1306                 color.status
1307                 color.status.added
1308                 color.status.changed
1309                 color.status.header
1310                 color.status.nobranch
1311                 color.status.untracked
1312                 color.status.updated
1313                 color.ui
1314                 commit.template
1315                 core.autocrlf
1316                 core.bare
1317                 core.compression
1318                 core.deltaBaseCacheLimit
1319                 core.editor
1320                 core.excludesfile
1321                 core.fileMode
1322                 core.fsyncobjectfiles
1323                 core.gitProxy
1324                 core.ignoreCygwinFSTricks
1325                 core.ignoreStat
1326                 core.logAllRefUpdates
1327                 core.loosecompression
1328                 core.packedGitLimit
1329                 core.packedGitWindowSize
1330                 core.pager
1331                 core.preferSymlinkRefs
1332                 core.preloadindex
1333                 core.quotepath
1334                 core.repositoryFormatVersion
1335                 core.safecrlf
1336                 core.sharedRepository
1337                 core.symlinks
1338                 core.trustctime
1339                 core.warnAmbiguousRefs
1340                 core.whitespace
1341                 core.worktree
1342                 diff.autorefreshindex
1343                 diff.external
1344                 diff.mnemonicprefix
1345                 diff.renameLimit
1346                 diff.renameLimit.
1347                 diff.renames
1348                 fetch.unpackLimit
1349                 format.headers
1350                 format.numbered
1351                 format.pretty
1352                 format.suffix
1353                 gc.aggressiveWindow
1354                 gc.auto
1355                 gc.autopacklimit
1356                 gc.packrefs
1357                 gc.pruneexpire
1358                 gc.reflogexpire
1359                 gc.reflogexpireunreachable
1360                 gc.rerereresolved
1361                 gc.rerereunresolved
1362                 gitcvs.allbinary
1363                 gitcvs.dbTableNamePrefix
1364                 gitcvs.dbdriver
1365                 gitcvs.dbname
1366                 gitcvs.dbpass
1367                 gitcvs.dbuser
1368                 gitcvs.enabled
1369                 gitcvs.logfile
1370                 gitcvs.usecrlfattr
1371                 gui.blamehistoryctx
1372                 gui.commitmsgwidth
1373                 gui.copyblamethreshold
1374                 gui.diffcontext
1375                 gui.encoding
1376                 gui.fastcopyblame
1377                 gui.matchtrackingbranch
1378                 gui.newbranchtemplate
1379                 gui.pruneduringfetch
1380                 gui.spellingdictionary
1381                 gui.trustmtime
1382                 help.autocorrect
1383                 help.browser
1384                 help.format
1385                 http.lowSpeedLimit
1386                 http.lowSpeedTime
1387                 http.maxRequests
1388                 http.noEPSV
1389                 http.proxy
1390                 http.sslCAInfo
1391                 http.sslCAPath
1392                 http.sslCert
1393                 http.sslKey
1394                 http.sslVerify
1395                 i18n.commitEncoding
1396                 i18n.logOutputEncoding
1397                 instaweb.browser
1398                 instaweb.httpd
1399                 instaweb.local
1400                 instaweb.modulepath
1401                 instaweb.port
1402                 log.date
1403                 log.showroot
1404                 man.viewer
1405                 merge.conflictstyle
1406                 merge.log
1407                 merge.renameLimit
1408                 merge.stat
1409                 merge.tool
1410                 merge.verbosity
1411                 mergetool.keepBackup
1412                 pack.compression
1413                 pack.deltaCacheLimit
1414                 pack.deltaCacheSize
1415                 pack.depth
1416                 pack.indexVersion
1417                 pack.packSizeLimit
1418                 pack.threads
1419                 pack.window
1420                 pack.windowMemory
1421                 pull.octopus
1422                 pull.twohead
1423                 receive.denyCurrentBranch
1424                 receive.denyDeletes
1425                 receive.denyNonFastForwards
1426                 receive.fsckObjects
1427                 receive.unpackLimit
1428                 repack.usedeltabaseoffset
1429                 rerere.autoupdate
1430                 rerere.enabled
1431                 showbranch.default
1432                 status.relativePaths
1433                 status.showUntrackedFiles
1434                 tar.umask
1435                 transfer.unpackLimit
1436                 user.email
1437                 user.name
1438                 user.signingkey
1439                 web.browser
1440                 branch. remote.
1441         "
1442 }
1443
1444 _git_remote ()
1445 {
1446         local subcommands="add rename rm show prune update"
1447         local subcommand="$(__git_find_subcommand "$subcommands")"
1448         if [ -z "$subcommand" ]; then
1449                 __gitcomp "$subcommands"
1450                 return
1451         fi
1452
1453         case "$subcommand" in
1454         rename|rm|show|prune)
1455                 __gitcomp "$(__git_remotes)"
1456                 ;;
1457         update)
1458                 local i c='' IFS=$'\n'
1459                 for i in $(git --git-dir="$(__gitdir)" config --list); do
1460                         case "$i" in
1461                         remotes.*)
1462                                 i="${i#remotes.}"
1463                                 c="$c ${i/=*/}"
1464                                 ;;
1465                         esac
1466                 done
1467                 __gitcomp "$c"
1468                 ;;
1469         *)
1470                 COMPREPLY=()
1471                 ;;
1472         esac
1473 }
1474
1475 _git_reset ()
1476 {
1477         __git_has_doubledash && return
1478
1479         local cur="${COMP_WORDS[COMP_CWORD]}"
1480         case "$cur" in
1481         --*)
1482                 __gitcomp "--merge --mixed --hard --soft"
1483                 return
1484                 ;;
1485         esac
1486         __gitcomp "$(__git_refs)"
1487 }
1488
1489 _git_revert ()
1490 {
1491         local cur="${COMP_WORDS[COMP_CWORD]}"
1492         case "$cur" in
1493         --*)
1494                 __gitcomp "--edit --mainline --no-edit --no-commit --signoff"
1495                 return
1496                 ;;
1497         esac
1498         __gitcomp "$(__git_refs)"
1499 }
1500
1501 _git_rm ()
1502 {
1503         __git_has_doubledash && return
1504
1505         local cur="${COMP_WORDS[COMP_CWORD]}"
1506         case "$cur" in
1507         --*)
1508                 __gitcomp "--cached --dry-run --ignore-unmatch --quiet"
1509                 return
1510                 ;;
1511         esac
1512         COMPREPLY=()
1513 }
1514
1515 _git_shortlog ()
1516 {
1517         __git_has_doubledash && return
1518
1519         local cur="${COMP_WORDS[COMP_CWORD]}"
1520         case "$cur" in
1521         --*)
1522                 __gitcomp "
1523                         $__git_log_common_options
1524                         $__git_log_shortlog_options
1525                         --numbered --summary
1526                         "
1527                 return
1528                 ;;
1529         esac
1530         __git_complete_revlist
1531 }
1532
1533 _git_show ()
1534 {
1535         __git_has_doubledash && return
1536
1537         local cur="${COMP_WORDS[COMP_CWORD]}"
1538         case "$cur" in
1539         --pretty=*)
1540                 __gitcomp "$__git_log_pretty_formats
1541                         " "" "${cur##--pretty=}"
1542                 return
1543                 ;;
1544         --*)
1545                 __gitcomp "--pretty=
1546                         $__git_diff_common_options
1547                         "
1548                 return
1549                 ;;
1550         esac
1551         __git_complete_file
1552 }
1553
1554 _git_show_branch ()
1555 {
1556         local cur="${COMP_WORDS[COMP_CWORD]}"
1557         case "$cur" in
1558         --*)
1559                 __gitcomp "
1560                         --all --remotes --topo-order --current --more=
1561                         --list --independent --merge-base --no-name
1562                         --sha1-name --topics --reflog
1563                         "
1564                 return
1565                 ;;
1566         esac
1567         __git_complete_revlist
1568 }
1569
1570 _git_stash ()
1571 {
1572         local subcommands='save list show apply clear drop pop create branch'
1573         local subcommand="$(__git_find_subcommand "$subcommands")"
1574         if [ -z "$subcommand" ]; then
1575                 __gitcomp "$subcommands"
1576         else
1577                 local cur="${COMP_WORDS[COMP_CWORD]}"
1578                 case "$subcommand,$cur" in
1579                 save,--*)
1580                         __gitcomp "--keep-index"
1581                         ;;
1582                 apply,--*)
1583                         __gitcomp "--index"
1584                         ;;
1585                 show,--*|drop,--*|pop,--*|branch,--*)
1586                         COMPREPLY=()
1587                         ;;
1588                 show,*|apply,*|drop,*|pop,*|branch,*)
1589                         __gitcomp "$(git --git-dir="$(__gitdir)" stash list \
1590                                         | sed -n -e 's/:.*//p')"
1591                         ;;
1592                 *)
1593                         COMPREPLY=()
1594                         ;;
1595                 esac
1596         fi
1597 }
1598
1599 _git_submodule ()
1600 {
1601         __git_has_doubledash && return
1602
1603         local subcommands="add status init update summary foreach sync"
1604         if [ -z "$(__git_find_subcommand "$subcommands")" ]; then
1605                 local cur="${COMP_WORDS[COMP_CWORD]}"
1606                 case "$cur" in
1607                 --*)
1608                         __gitcomp "--quiet --cached"
1609                         ;;
1610                 *)
1611                         __gitcomp "$subcommands"
1612                         ;;
1613                 esac
1614                 return
1615         fi
1616 }
1617
1618 _git_svn ()
1619 {
1620         local subcommands="
1621                 init fetch clone rebase dcommit log find-rev
1622                 set-tree commit-diff info create-ignore propget
1623                 proplist show-ignore show-externals branch tag blame
1624                 migrate
1625                 "
1626         local subcommand="$(__git_find_subcommand "$subcommands")"
1627         if [ -z "$subcommand" ]; then
1628                 __gitcomp "$subcommands"
1629         else
1630                 local remote_opts="--username= --config-dir= --no-auth-cache"
1631                 local fc_opts="
1632                         --follow-parent --authors-file= --repack=
1633                         --no-metadata --use-svm-props --use-svnsync-props
1634                         --log-window-size= --no-checkout --quiet
1635                         --repack-flags --use-log-author --localtime
1636                         --ignore-paths= $remote_opts
1637                         "
1638                 local init_opts="
1639                         --template= --shared= --trunk= --tags=
1640                         --branches= --stdlayout --minimize-url
1641                         --no-metadata --use-svm-props --use-svnsync-props
1642                         --rewrite-root= --prefix= --use-log-author
1643                         --add-author-from $remote_opts
1644                         "
1645                 local cmt_opts="
1646                         --edit --rmdir --find-copies-harder --copy-similarity=
1647                         "
1648
1649                 local cur="${COMP_WORDS[COMP_CWORD]}"
1650                 case "$subcommand,$cur" in
1651                 fetch,--*)
1652                         __gitcomp "--revision= --fetch-all $fc_opts"
1653                         ;;
1654                 clone,--*)
1655                         __gitcomp "--revision= $fc_opts $init_opts"
1656                         ;;
1657                 init,--*)
1658                         __gitcomp "$init_opts"
1659                         ;;
1660                 dcommit,--*)
1661                         __gitcomp "
1662                                 --merge --strategy= --verbose --dry-run
1663                                 --fetch-all --no-rebase --commit-url
1664                                 --revision $cmt_opts $fc_opts
1665                                 "
1666                         ;;
1667                 set-tree,--*)
1668                         __gitcomp "--stdin $cmt_opts $fc_opts"
1669                         ;;
1670                 create-ignore,--*|propget,--*|proplist,--*|show-ignore,--*|\
1671                 show-externals,--*)
1672                         __gitcomp "--revision="
1673                         ;;
1674                 log,--*)
1675                         __gitcomp "
1676                                 --limit= --revision= --verbose --incremental
1677                                 --oneline --show-commit --non-recursive
1678                                 --authors-file= --color
1679                                 "
1680                         ;;
1681                 rebase,--*)
1682                         __gitcomp "
1683                                 --merge --verbose --strategy= --local
1684                                 --fetch-all --dry-run $fc_opts
1685                                 "
1686                         ;;
1687                 commit-diff,--*)
1688                         __gitcomp "--message= --file= --revision= $cmt_opts"
1689                         ;;
1690                 info,--*)
1691                         __gitcomp "--url"
1692                         ;;
1693                 branch,--*)
1694                         __gitcomp "--dry-run --message --tag"
1695                         ;;
1696                 tag,--*)
1697                         __gitcomp "--dry-run --message"
1698                         ;;
1699                 blame,--*)
1700                         __gitcomp "--git-format"
1701                         ;;
1702                 migrate,--*)
1703                         __gitcomp "
1704                                 --config-dir= --ignore-paths= --minimize
1705                                 --no-auth-cache --username=
1706                                 "
1707                         ;;
1708                 *)
1709                         COMPREPLY=()
1710                         ;;
1711                 esac
1712         fi
1713 }
1714
1715 _git_tag ()
1716 {
1717         local i c=1 f=0
1718         while [ $c -lt $COMP_CWORD ]; do
1719                 i="${COMP_WORDS[c]}"
1720                 case "$i" in
1721                 -d|-v)
1722                         __gitcomp "$(__git_tags)"
1723                         return
1724                         ;;
1725                 -f)
1726                         f=1
1727                         ;;
1728                 esac
1729                 c=$((++c))
1730         done
1731
1732         case "${COMP_WORDS[COMP_CWORD-1]}" in
1733         -m|-F)
1734                 COMPREPLY=()
1735                 ;;
1736         -*|tag)
1737                 if [ $f = 1 ]; then
1738                         __gitcomp "$(__git_tags)"
1739                 else
1740                         COMPREPLY=()
1741                 fi
1742                 ;;
1743         *)
1744                 __gitcomp "$(__git_refs)"
1745                 ;;
1746         esac
1747 }
1748
1749 _git ()
1750 {
1751         local i c=1 command __git_dir
1752
1753         while [ $c -lt $COMP_CWORD ]; do
1754                 i="${COMP_WORDS[c]}"
1755                 case "$i" in
1756                 --git-dir=*) __git_dir="${i#--git-dir=}" ;;
1757                 --bare)      __git_dir="." ;;
1758                 --version|-p|--paginate) ;;
1759                 --help) command="help"; break ;;
1760                 *) command="$i"; break ;;
1761                 esac
1762                 c=$((++c))
1763         done
1764
1765         if [ -z "$command" ]; then
1766                 case "${COMP_WORDS[COMP_CWORD]}" in
1767                 --*)   __gitcomp "
1768                         --paginate
1769                         --no-pager
1770                         --git-dir=
1771                         --bare
1772                         --version
1773                         --exec-path
1774                         --work-tree=
1775                         --help
1776                         "
1777                         ;;
1778                 *)     __gitcomp "$(__git_porcelain_commands) $(__git_aliases)" ;;
1779                 esac
1780                 return
1781         fi
1782
1783         local expansion=$(__git_aliased_command "$command")
1784         [ "$expansion" ] && command="$expansion"
1785
1786         case "$command" in
1787         am)          _git_am ;;
1788         add)         _git_add ;;
1789         apply)       _git_apply ;;
1790         archive)     _git_archive ;;
1791         bisect)      _git_bisect ;;
1792         bundle)      _git_bundle ;;
1793         branch)      _git_branch ;;
1794         checkout)    _git_checkout ;;
1795         cherry)      _git_cherry ;;
1796         cherry-pick) _git_cherry_pick ;;
1797         clean)       _git_clean ;;
1798         clone)       _git_clone ;;
1799         commit)      _git_commit ;;
1800         config)      _git_config ;;
1801         describe)    _git_describe ;;
1802         diff)        _git_diff ;;
1803         fetch)       _git_fetch ;;
1804         format-patch) _git_format_patch ;;
1805         gc)          _git_gc ;;
1806         grep)        _git_grep ;;
1807         help)        _git_help ;;
1808         init)        _git_init ;;
1809         log)         _git_log ;;
1810         ls-files)    _git_ls_files ;;
1811         ls-remote)   _git_ls_remote ;;
1812         ls-tree)     _git_ls_tree ;;
1813         merge)       _git_merge;;
1814         mergetool)   _git_mergetool;;
1815         merge-base)  _git_merge_base ;;
1816         mv)          _git_mv ;;
1817         name-rev)    _git_name_rev ;;
1818         pull)        _git_pull ;;
1819         push)        _git_push ;;
1820         rebase)      _git_rebase ;;
1821         remote)      _git_remote ;;
1822         reset)       _git_reset ;;
1823         revert)      _git_revert ;;
1824         rm)          _git_rm ;;
1825         send-email)  _git_send_email ;;
1826         shortlog)    _git_shortlog ;;
1827         show)        _git_show ;;
1828         show-branch) _git_show_branch ;;
1829         stash)       _git_stash ;;
1830         stage)       _git_add ;;
1831         submodule)   _git_submodule ;;
1832         svn)         _git_svn ;;
1833         tag)         _git_tag ;;
1834         whatchanged) _git_log ;;
1835         *)           COMPREPLY=() ;;
1836         esac
1837 }
1838
1839 _gitk ()
1840 {
1841         __git_has_doubledash && return
1842
1843         local cur="${COMP_WORDS[COMP_CWORD]}"
1844         local g="$(git rev-parse --git-dir 2>/dev/null)"
1845         local merge=""
1846         if [ -f "$g/MERGE_HEAD" ]; then
1847                 merge="--merge"
1848         fi
1849         case "$cur" in
1850         --*)
1851                 __gitcomp "
1852                         $__git_log_common_options
1853                         $__git_log_gitk_options
1854                         $merge
1855                         "
1856                 return
1857                 ;;
1858         esac
1859         __git_complete_revlist
1860 }
1861
1862 complete -o bashdefault -o default -o nospace -F _git git 2>/dev/null \
1863         || complete -o default -o nospace -F _git git
1864 complete -o bashdefault -o default -o nospace -F _gitk gitk 2>/dev/null \
1865         || complete -o default -o nospace -F _gitk gitk
1866
1867 # The following are necessary only for Cygwin, and only are needed
1868 # when the user has tab-completed the executable name and consequently
1869 # included the '.exe' suffix.
1870 #
1871 if [ Cygwin = "$(uname -o 2>/dev/null)" ]; then
1872 complete -o bashdefault -o default -o nospace -F _git git.exe 2>/dev/null \
1873         || complete -o default -o nospace -F _git git.exe
1874 fi