Code

Merge branch 'mh/show-branch-color' into sb/show-branch-parse-options
[git.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 #
55 case "$COMP_WORDBREAKS" in
56 *:*) : great ;;
57 *)   COMP_WORDBREAKS="$COMP_WORDBREAKS:"
58 esac
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 }
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="$(__gitdir)"
84         if [ -n "$g" ]; then
85                 local r
86                 local b
87                 if [ -d "$g/rebase-apply" ]; then
88                         if [ -f "$g/rebase-apply/rebasing" ]; then
89                                 r="|REBASE"
90                 elif [ -f "$g/rebase-apply/applying" ]; then
91                                 r="|AM"
92                         else
93                                 r="|AM/REBASE"
94                         fi
95                         b="$(git symbolic-ref HEAD 2>/dev/null)"
96                 elif [ -f "$g/rebase-merge/interactive" ]; then
97                         r="|REBASE-i"
98                         b="$(cat "$g/rebase-merge/head-name")"
99                 elif [ -d "$g/rebase-merge" ]; then
100                         r="|REBASE-m"
101                         b="$(cat "$g/rebase-merge/head-name")"
102                 else
103                         if [ -f "$g/MERGE_HEAD" ]; then
104                                 r="|MERGING"
105                         fi
106                         if [ -f "$g/BISECT_LOG" ]; then
107                                 r="|BISECTING"
108                         fi
110                         b="$(git symbolic-ref HEAD 2>/dev/null)" || {
112                                 b="$(
113                                 case "${GIT_PS1_DESCRIBE_STYLE-}" in
114                                 (contains)
115                                         git describe --contains HEAD ;;
116                                 (branch)
117                                         git describe --contains --all HEAD ;;
118                                 (describe)
119                                         git describe HEAD ;;
120                                 (* | default)
121                                         git describe --exact-match HEAD ;;
122                                 esac 2>/dev/null)" ||
124                                 b="$(cut -c1-7 "$g/HEAD" 2>/dev/null)..." ||
125                                 b="unknown"
126                                 b="($b)"
127                         }
128                 fi
130                 local w
131                 local i
132                 local c
134                 if [ "true" = "$(git rev-parse --is-inside-git-dir 2>/dev/null)" ]; then
135                         if [ "true" = "$(git config --bool core.bare 2>/dev/null)" ]; then
136                                 c="BARE:"
137                         else
138                                 b="GIT_DIR!"
139                         fi
140                 elif [ "true" = "$(git rev-parse --is-inside-work-tree 2>/dev/null)" ]; then
141                         if [ -n "${GIT_PS1_SHOWDIRTYSTATE-}" ]; then
142                                 if [ "$(git config --bool bash.showDirtyState)" != "false" ]; then
143                                         git diff --no-ext-diff --ignore-submodules \
144                                                 --quiet --exit-code || w="*"
145                                         if git rev-parse --quiet --verify HEAD >/dev/null; then
146                                                 git diff-index --cached --quiet \
147                                                         --ignore-submodules HEAD -- || i="+"
148                                         else
149                                                 i="#"
150                                         fi
151                                 fi
152                         fi
153                 fi
155                 if [ -n "$b" ]; then
156                         if [ -n "${1-}" ]; then
157                                 printf "$1" "$c${b##refs/heads/}$w$i$r"
158                         else
159                                 printf " (%s)" "$c${b##refs/heads/}$w$i$r"
160                         fi
161                 fi
162         fi
165 # __gitcomp_1 requires 2 arguments
166 __gitcomp_1 ()
168         local c IFS=' '$'\t'$'\n'
169         for c in $1; do
170                 case "$c$2" in
171                 --*=*) printf %s$'\n' "$c$2" ;;
172                 *.)    printf %s$'\n' "$c$2" ;;
173                 *)     printf %s$'\n' "$c$2 " ;;
174                 esac
175         done
178 # __gitcomp accepts 1, 2, 3, or 4 arguments
179 # generates completion reply with compgen
180 __gitcomp ()
182         local cur="${COMP_WORDS[COMP_CWORD]}"
183         if [ $# -gt 2 ]; then
184                 cur="$3"
185         fi
186         case "$cur" in
187         --*=)
188                 COMPREPLY=()
189                 ;;
190         *)
191                 local IFS=$'\n'
192                 COMPREPLY=($(compgen -P "${2-}" \
193                         -W "$(__gitcomp_1 "${1-}" "${4-}")" \
194                         -- "$cur"))
195                 ;;
196         esac
199 # __git_heads accepts 0 or 1 arguments (to pass to __gitdir)
200 __git_heads ()
202         local cmd i is_hash=y dir="$(__gitdir "${1-}")"
203         if [ -d "$dir" ]; then
204                 git --git-dir="$dir" for-each-ref --format='%(refname:short)' \
205                         refs/heads
206                 return
207         fi
208         for i in $(git ls-remote "${1-}" 2>/dev/null); do
209                 case "$is_hash,$i" in
210                 y,*) is_hash=n ;;
211                 n,*^{}) is_hash=y ;;
212                 n,refs/heads/*) is_hash=y; echo "${i#refs/heads/}" ;;
213                 n,*) is_hash=y; echo "$i" ;;
214                 esac
215         done
218 # __git_tags accepts 0 or 1 arguments (to pass to __gitdir)
219 __git_tags ()
221         local cmd i is_hash=y dir="$(__gitdir "${1-}")"
222         if [ -d "$dir" ]; then
223                 git --git-dir="$dir" for-each-ref --format='%(refname:short)' \
224                         refs/tags
225                 return
226         fi
227         for i in $(git ls-remote "${1-}" 2>/dev/null); do
228                 case "$is_hash,$i" in
229                 y,*) is_hash=n ;;
230                 n,*^{}) is_hash=y ;;
231                 n,refs/tags/*) is_hash=y; echo "${i#refs/tags/}" ;;
232                 n,*) is_hash=y; echo "$i" ;;
233                 esac
234         done
237 # __git_refs accepts 0 or 1 arguments (to pass to __gitdir)
238 __git_refs ()
240         local i is_hash=y dir="$(__gitdir "${1-}")"
241         local cur="${COMP_WORDS[COMP_CWORD]}" format refs
242         if [ -d "$dir" ]; then
243                 case "$cur" in
244                 refs|refs/*)
245                         format="refname"
246                         refs="${cur%/*}"
247                         ;;
248                 *)
249                         if [ -e "$dir/HEAD" ]; then echo HEAD; fi
250                         format="refname:short"
251                         refs="refs/tags refs/heads refs/remotes"
252                         ;;
253                 esac
254                 git --git-dir="$dir" for-each-ref --format="%($format)" \
255                         $refs
256                 return
257         fi
258         for i in $(git ls-remote "$dir" 2>/dev/null); do
259                 case "$is_hash,$i" in
260                 y,*) is_hash=n ;;
261                 n,*^{}) is_hash=y ;;
262                 n,refs/tags/*) is_hash=y; echo "${i#refs/tags/}" ;;
263                 n,refs/heads/*) is_hash=y; echo "${i#refs/heads/}" ;;
264                 n,refs/remotes/*) is_hash=y; echo "${i#refs/remotes/}" ;;
265                 n,*) is_hash=y; echo "$i" ;;
266                 esac
267         done
270 # __git_refs2 requires 1 argument (to pass to __git_refs)
271 __git_refs2 ()
273         local i
274         for i in $(__git_refs "$1"); do
275                 echo "$i:$i"
276         done
279 # __git_refs_remotes requires 1 argument (to pass to ls-remote)
280 __git_refs_remotes ()
282         local cmd i is_hash=y
283         for i in $(git ls-remote "$1" 2>/dev/null); do
284                 case "$is_hash,$i" in
285                 n,refs/heads/*)
286                         is_hash=y
287                         echo "$i:refs/remotes/$1/${i#refs/heads/}"
288                         ;;
289                 y,*) is_hash=n ;;
290                 n,*^{}) is_hash=y ;;
291                 n,refs/tags/*) is_hash=y;;
292                 n,*) is_hash=y; ;;
293                 esac
294         done
297 __git_remotes ()
299         local i ngoff IFS=$'\n' d="$(__gitdir)"
300         shopt -q nullglob || ngoff=1
301         shopt -s nullglob
302         for i in "$d/remotes"/*; do
303                 echo ${i#$d/remotes/}
304         done
305         [ "$ngoff" ] && shopt -u nullglob
306         for i in $(git --git-dir="$d" config --list); do
307                 case "$i" in
308                 remote.*.url=*)
309                         i="${i#remote.}"
310                         echo "${i/.url=*/}"
311                         ;;
312                 esac
313         done
316 __git_merge_strategies ()
318         if [ -n "${__git_merge_strategylist-}" ]; then
319                 echo "$__git_merge_strategylist"
320                 return
321         fi
322         git merge -s help 2>&1 |
323         sed -n -e '/[Aa]vailable strategies are: /,/^$/{
324                 s/\.$//
325                 s/.*://
326                 s/^[    ]*//
327                 s/[     ]*$//
328                 p
329         }'
331 __git_merge_strategylist=
332 __git_merge_strategylist=$(__git_merge_strategies 2>/dev/null)
334 __git_complete_file ()
336         local pfx ls ref cur="${COMP_WORDS[COMP_CWORD]}"
337         case "$cur" in
338         ?*:*)
339                 ref="${cur%%:*}"
340                 cur="${cur#*:}"
341                 case "$cur" in
342                 ?*/*)
343                         pfx="${cur%/*}"
344                         cur="${cur##*/}"
345                         ls="$ref:$pfx"
346                         pfx="$pfx/"
347                         ;;
348                 *)
349                         ls="$ref"
350                         ;;
351             esac
353                 case "$COMP_WORDBREAKS" in
354                 *:*) : great ;;
355                 *)   pfx="$ref:$pfx" ;;
356                 esac
358                 local IFS=$'\n'
359                 COMPREPLY=($(compgen -P "$pfx" \
360                         -W "$(git --git-dir="$(__gitdir)" ls-tree "$ls" \
361                                 | sed '/^100... blob /{
362                                            s,^.*        ,,
363                                            s,$, ,
364                                        }
365                                        /^120000 blob /{
366                                            s,^.*        ,,
367                                            s,$, ,
368                                        }
369                                        /^040000 tree /{
370                                            s,^.*        ,,
371                                            s,$,/,
372                                        }
373                                        s/^.*    //')" \
374                         -- "$cur"))
375                 ;;
376         *)
377                 __gitcomp "$(__git_refs)"
378                 ;;
379         esac
382 __git_complete_revlist ()
384         local pfx cur="${COMP_WORDS[COMP_CWORD]}"
385         case "$cur" in
386         *...*)
387                 pfx="${cur%...*}..."
388                 cur="${cur#*...}"
389                 __gitcomp "$(__git_refs)" "$pfx" "$cur"
390                 ;;
391         *..*)
392                 pfx="${cur%..*}.."
393                 cur="${cur#*..}"
394                 __gitcomp "$(__git_refs)" "$pfx" "$cur"
395                 ;;
396         *)
397                 __gitcomp "$(__git_refs)"
398                 ;;
399         esac
402 __git_complete_remote_or_refspec ()
404         local cmd="${COMP_WORDS[1]}"
405         local cur="${COMP_WORDS[COMP_CWORD]}"
406         local i c=2 remote="" pfx="" lhs=1 no_complete_refspec=0
407         while [ $c -lt $COMP_CWORD ]; do
408                 i="${COMP_WORDS[c]}"
409                 case "$i" in
410                 --all|--mirror) [ "$cmd" = "push" ] && no_complete_refspec=1 ;;
411                 -*) ;;
412                 *) remote="$i"; break ;;
413                 esac
414                 c=$((++c))
415         done
416         if [ -z "$remote" ]; then
417                 __gitcomp "$(__git_remotes)"
418                 return
419         fi
420         if [ $no_complete_refspec = 1 ]; then
421                 COMPREPLY=()
422                 return
423         fi
424         [ "$remote" = "." ] && remote=
425         case "$cur" in
426         *:*)
427                 case "$COMP_WORDBREAKS" in
428                 *:*) : great ;;
429                 *)   pfx="${cur%%:*}:" ;;
430                 esac
431                 cur="${cur#*:}"
432                 lhs=0
433                 ;;
434         +*)
435                 pfx="+"
436                 cur="${cur#+}"
437                 ;;
438         esac
439         case "$cmd" in
440         fetch)
441                 if [ $lhs = 1 ]; then
442                         __gitcomp "$(__git_refs2 "$remote")" "$pfx" "$cur"
443                 else
444                         __gitcomp "$(__git_refs)" "$pfx" "$cur"
445                 fi
446                 ;;
447         pull)
448                 if [ $lhs = 1 ]; then
449                         __gitcomp "$(__git_refs "$remote")" "$pfx" "$cur"
450                 else
451                         __gitcomp "$(__git_refs)" "$pfx" "$cur"
452                 fi
453                 ;;
454         push)
455                 if [ $lhs = 1 ]; then
456                         __gitcomp "$(__git_refs)" "$pfx" "$cur"
457                 else
458                         __gitcomp "$(__git_refs "$remote")" "$pfx" "$cur"
459                 fi
460                 ;;
461         esac
464 __git_complete_strategy ()
466         case "${COMP_WORDS[COMP_CWORD-1]}" in
467         -s|--strategy)
468                 __gitcomp "$(__git_merge_strategies)"
469                 return 0
470         esac
471         local cur="${COMP_WORDS[COMP_CWORD]}"
472         case "$cur" in
473         --strategy=*)
474                 __gitcomp "$(__git_merge_strategies)" "" "${cur##--strategy=}"
475                 return 0
476                 ;;
477         esac
478         return 1
481 __git_all_commands ()
483         if [ -n "${__git_all_commandlist-}" ]; then
484                 echo "$__git_all_commandlist"
485                 return
486         fi
487         local i IFS=" "$'\n'
488         for i in $(git help -a|egrep '^ ')
489         do
490                 case $i in
491                 *--*)             : helper pattern;;
492                 *) echo $i;;
493                 esac
494         done
496 __git_all_commandlist=
497 __git_all_commandlist="$(__git_all_commands 2>/dev/null)"
499 __git_porcelain_commands ()
501         if [ -n "${__git_porcelain_commandlist-}" ]; then
502                 echo "$__git_porcelain_commandlist"
503                 return
504         fi
505         local i IFS=" "$'\n'
506         for i in "help" $(__git_all_commands)
507         do
508                 case $i in
509                 *--*)             : helper pattern;;
510                 applymbox)        : ask gittus;;
511                 applypatch)       : ask gittus;;
512                 archimport)       : import;;
513                 cat-file)         : plumbing;;
514                 check-attr)       : plumbing;;
515                 check-ref-format) : plumbing;;
516                 checkout-index)   : plumbing;;
517                 commit-tree)      : plumbing;;
518                 count-objects)    : infrequent;;
519                 cvsexportcommit)  : export;;
520                 cvsimport)        : import;;
521                 cvsserver)        : daemon;;
522                 daemon)           : daemon;;
523                 diff-files)       : plumbing;;
524                 diff-index)       : plumbing;;
525                 diff-tree)        : plumbing;;
526                 fast-import)      : import;;
527                 fast-export)      : export;;
528                 fsck-objects)     : plumbing;;
529                 fetch-pack)       : plumbing;;
530                 fmt-merge-msg)    : plumbing;;
531                 for-each-ref)     : plumbing;;
532                 hash-object)      : plumbing;;
533                 http-*)           : transport;;
534                 index-pack)       : plumbing;;
535                 init-db)          : deprecated;;
536                 local-fetch)      : plumbing;;
537                 lost-found)       : infrequent;;
538                 ls-files)         : plumbing;;
539                 ls-remote)        : plumbing;;
540                 ls-tree)          : plumbing;;
541                 mailinfo)         : plumbing;;
542                 mailsplit)        : plumbing;;
543                 merge-*)          : plumbing;;
544                 mktree)           : plumbing;;
545                 mktag)            : plumbing;;
546                 pack-objects)     : plumbing;;
547                 pack-redundant)   : plumbing;;
548                 pack-refs)        : plumbing;;
549                 parse-remote)     : plumbing;;
550                 patch-id)         : plumbing;;
551                 peek-remote)      : plumbing;;
552                 prune)            : plumbing;;
553                 prune-packed)     : plumbing;;
554                 quiltimport)      : import;;
555                 read-tree)        : plumbing;;
556                 receive-pack)     : plumbing;;
557                 reflog)           : plumbing;;
558                 repo-config)      : deprecated;;
559                 rerere)           : plumbing;;
560                 rev-list)         : plumbing;;
561                 rev-parse)        : plumbing;;
562                 runstatus)        : plumbing;;
563                 sh-setup)         : internal;;
564                 shell)            : daemon;;
565                 show-ref)         : plumbing;;
566                 send-pack)        : plumbing;;
567                 show-index)       : plumbing;;
568                 ssh-*)            : transport;;
569                 stripspace)       : plumbing;;
570                 symbolic-ref)     : plumbing;;
571                 tar-tree)         : deprecated;;
572                 unpack-file)      : plumbing;;
573                 unpack-objects)   : plumbing;;
574                 update-index)     : plumbing;;
575                 update-ref)       : plumbing;;
576                 update-server-info) : daemon;;
577                 upload-archive)   : plumbing;;
578                 upload-pack)      : plumbing;;
579                 write-tree)       : plumbing;;
580                 var)              : infrequent;;
581                 verify-pack)      : infrequent;;
582                 verify-tag)       : plumbing;;
583                 *) echo $i;;
584                 esac
585         done
587 __git_porcelain_commandlist=
588 __git_porcelain_commandlist="$(__git_porcelain_commands 2>/dev/null)"
590 __git_aliases ()
592         local i IFS=$'\n'
593         for i in $(git --git-dir="$(__gitdir)" config --list); do
594                 case "$i" in
595                 alias.*)
596                         i="${i#alias.}"
597                         echo "${i/=*/}"
598                         ;;
599                 esac
600         done
603 # __git_aliased_command requires 1 argument
604 __git_aliased_command ()
606         local word cmdline=$(git --git-dir="$(__gitdir)" \
607                 config --get "alias.$1")
608         for word in $cmdline; do
609                 if [ "${word##-*}" ]; then
610                         echo $word
611                         return
612                 fi
613         done
616 # __git_find_subcommand requires 1 argument
617 __git_find_subcommand ()
619         local word subcommand c=1
621         while [ $c -lt $COMP_CWORD ]; do
622                 word="${COMP_WORDS[c]}"
623                 for subcommand in $1; do
624                         if [ "$subcommand" = "$word" ]; then
625                                 echo "$subcommand"
626                                 return
627                         fi
628                 done
629                 c=$((++c))
630         done
633 __git_has_doubledash ()
635         local c=1
636         while [ $c -lt $COMP_CWORD ]; do
637                 if [ "--" = "${COMP_WORDS[c]}" ]; then
638                         return 0
639                 fi
640                 c=$((++c))
641         done
642         return 1
645 __git_whitespacelist="nowarn warn error error-all fix"
647 _git_am ()
649         local cur="${COMP_WORDS[COMP_CWORD]}" dir="$(__gitdir)"
650         if [ -d "$dir"/rebase-apply ]; then
651                 __gitcomp "--skip --resolved --abort"
652                 return
653         fi
654         case "$cur" in
655         --whitespace=*)
656                 __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
657                 return
658                 ;;
659         --*)
660                 __gitcomp "
661                         --3way --committer-date-is-author-date --ignore-date
662                         --interactive --keep --no-utf8 --signoff --utf8
663                         --whitespace=
664                         "
665                 return
666         esac
667         COMPREPLY=()
670 _git_apply ()
672         local cur="${COMP_WORDS[COMP_CWORD]}"
673         case "$cur" in
674         --whitespace=*)
675                 __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
676                 return
677                 ;;
678         --*)
679                 __gitcomp "
680                         --stat --numstat --summary --check --index
681                         --cached --index-info --reverse --reject --unidiff-zero
682                         --apply --no-add --exclude=
683                         --whitespace= --inaccurate-eof --verbose
684                         "
685                 return
686         esac
687         COMPREPLY=()
690 _git_add ()
692         __git_has_doubledash && return
694         local cur="${COMP_WORDS[COMP_CWORD]}"
695         case "$cur" in
696         --*)
697                 __gitcomp "
698                         --interactive --refresh --patch --update --dry-run
699                         --ignore-errors --intent-to-add
700                         "
701                 return
702         esac
703         COMPREPLY=()
706 _git_archive ()
708         local cur="${COMP_WORDS[COMP_CWORD]}"
709         case "$cur" in
710         --format=*)
711                 __gitcomp "$(git archive --list)" "" "${cur##--format=}"
712                 return
713                 ;;
714         --remote=*)
715                 __gitcomp "$(__git_remotes)" "" "${cur##--remote=}"
716                 return
717                 ;;
718         --*)
719                 __gitcomp "
720                         --format= --list --verbose
721                         --prefix= --remote= --exec=
722                         "
723                 return
724                 ;;
725         esac
726         __git_complete_file
729 _git_bisect ()
731         __git_has_doubledash && return
733         local subcommands="start bad good skip reset visualize replay log run"
734         local subcommand="$(__git_find_subcommand "$subcommands")"
735         if [ -z "$subcommand" ]; then
736                 __gitcomp "$subcommands"
737                 return
738         fi
740         case "$subcommand" in
741         bad|good|reset|skip)
742                 __gitcomp "$(__git_refs)"
743                 ;;
744         *)
745                 COMPREPLY=()
746                 ;;
747         esac
750 _git_branch ()
752         local i c=1 only_local_ref="n" has_r="n"
754         while [ $c -lt $COMP_CWORD ]; do
755                 i="${COMP_WORDS[c]}"
756                 case "$i" in
757                 -d|-m)  only_local_ref="y" ;;
758                 -r)     has_r="y" ;;
759                 esac
760                 c=$((++c))
761         done
763         case "${COMP_WORDS[COMP_CWORD]}" in
764         --*)
765                 __gitcomp "
766                         --color --no-color --verbose --abbrev= --no-abbrev
767                         --track --no-track --contains --merged --no-merged
768                         "
769                 ;;
770         *)
771                 if [ $only_local_ref = "y" -a $has_r = "n" ]; then
772                         __gitcomp "$(__git_heads)"
773                 else
774                         __gitcomp "$(__git_refs)"
775                 fi
776                 ;;
777         esac
780 _git_bundle ()
782         local cmd="${COMP_WORDS[2]}"
783         case "$COMP_CWORD" in
784         2)
785                 __gitcomp "create list-heads verify unbundle"
786                 ;;
787         3)
788                 # looking for a file
789                 ;;
790         *)
791                 case "$cmd" in
792                         create)
793                                 __git_complete_revlist
794                         ;;
795                 esac
796                 ;;
797         esac
800 _git_checkout ()
802         __git_has_doubledash && return
804         __gitcomp "$(__git_refs)"
807 _git_cherry ()
809         __gitcomp "$(__git_refs)"
812 _git_cherry_pick ()
814         local cur="${COMP_WORDS[COMP_CWORD]}"
815         case "$cur" in
816         --*)
817                 __gitcomp "--edit --no-commit"
818                 ;;
819         *)
820                 __gitcomp "$(__git_refs)"
821                 ;;
822         esac
825 _git_clean ()
827         __git_has_doubledash && return
829         local cur="${COMP_WORDS[COMP_CWORD]}"
830         case "$cur" in
831         --*)
832                 __gitcomp "--dry-run --quiet"
833                 return
834                 ;;
835         esac
836         COMPREPLY=()
839 _git_clone ()
841         local cur="${COMP_WORDS[COMP_CWORD]}"
842         case "$cur" in
843         --*)
844                 __gitcomp "
845                         --local
846                         --no-hardlinks
847                         --shared
848                         --reference
849                         --quiet
850                         --no-checkout
851                         --bare
852                         --mirror
853                         --origin
854                         --upload-pack
855                         --template=
856                         --depth
857                         "
858                 return
859                 ;;
860         esac
861         COMPREPLY=()
864 _git_commit ()
866         __git_has_doubledash && return
868         local cur="${COMP_WORDS[COMP_CWORD]}"
869         case "$cur" in
870         --*)
871                 __gitcomp "
872                         --all --author= --signoff --verify --no-verify
873                         --edit --amend --include --only --interactive
874                         "
875                 return
876         esac
877         COMPREPLY=()
880 _git_describe ()
882         local cur="${COMP_WORDS[COMP_CWORD]}"
883         case "$cur" in
884         --*)
885                 __gitcomp "
886                         --all --tags --contains --abbrev= --candidates=
887                         --exact-match --debug --long --match --always
888                         "
889                 return
890         esac
891         __gitcomp "$(__git_refs)"
894 __git_diff_common_options="--stat --numstat --shortstat --summary
895                         --patch-with-stat --name-only --name-status --color
896                         --no-color --color-words --no-renames --check
897                         --full-index --binary --abbrev --diff-filter=
898                         --find-copies-harder
899                         --text --ignore-space-at-eol --ignore-space-change
900                         --ignore-all-space --exit-code --quiet --ext-diff
901                         --no-ext-diff
902                         --no-prefix --src-prefix= --dst-prefix=
903                         --inter-hunk-context=
904                         --patience
905                         --raw
908 _git_diff ()
910         __git_has_doubledash && return
912         local cur="${COMP_WORDS[COMP_CWORD]}"
913         case "$cur" in
914         --*)
915                 __gitcomp "--cached --staged --pickaxe-all --pickaxe-regex
916                         --base --ours --theirs
917                         $__git_diff_common_options
918                         "
919                 return
920                 ;;
921         esac
922         __git_complete_file
925 __git_mergetools_common="diffuse ecmerge emerge kdiff3 meld opendiff
926                         tkdiff vimdiff gvimdiff xxdiff
929 _git_difftool ()
931         local cur="${COMP_WORDS[COMP_CWORD]}"
932         case "$cur" in
933         --tool=*)
934                 __gitcomp "$__git_mergetools_common kompare" "" "${cur##--tool=}"
935                 return
936                 ;;
937         --*)
938                 __gitcomp "--tool="
939                 return
940                 ;;
941         esac
942         COMPREPLY=()
945 __git_fetch_options="
946         --quiet --verbose --append --upload-pack --force --keep --depth=
947         --tags --no-tags
950 _git_fetch ()
952         local cur="${COMP_WORDS[COMP_CWORD]}"
953         case "$cur" in
954         --*)
955                 __gitcomp "$__git_fetch_options"
956                 return
957                 ;;
958         esac
959         __git_complete_remote_or_refspec
962 _git_format_patch ()
964         local cur="${COMP_WORDS[COMP_CWORD]}"
965         case "$cur" in
966         --thread=*)
967                 __gitcomp "
968                         deep shallow
969                         " "" "${cur##--thread=}"
970                 return
971                 ;;
972         --*)
973                 __gitcomp "
974                         --stdout --attach --no-attach --thread --thread=
975                         --output-directory
976                         --numbered --start-number
977                         --numbered-files
978                         --keep-subject
979                         --signoff
980                         --in-reply-to= --cc=
981                         --full-index --binary
982                         --not --all
983                         --cover-letter
984                         --no-prefix --src-prefix= --dst-prefix=
985                         --inline --suffix= --ignore-if-in-upstream
986                         --subject-prefix=
987                         "
988                 return
989                 ;;
990         esac
991         __git_complete_revlist
994 _git_fsck ()
996         local cur="${COMP_WORDS[COMP_CWORD]}"
997         case "$cur" in
998         --*)
999                 __gitcomp "
1000                         --tags --root --unreachable --cache --no-reflogs --full
1001                         --strict --verbose --lost-found
1002                         "
1003                 return
1004                 ;;
1005         esac
1006         COMPREPLY=()
1009 _git_gc ()
1011         local cur="${COMP_WORDS[COMP_CWORD]}"
1012         case "$cur" in
1013         --*)
1014                 __gitcomp "--prune --aggressive"
1015                 return
1016                 ;;
1017         esac
1018         COMPREPLY=()
1021 _git_grep ()
1023         __git_has_doubledash && return
1025         local cur="${COMP_WORDS[COMP_CWORD]}"
1026         case "$cur" in
1027         --*)
1028                 __gitcomp "
1029                         --cached
1030                         --text --ignore-case --word-regexp --invert-match
1031                         --full-name
1032                         --extended-regexp --basic-regexp --fixed-strings
1033                         --files-with-matches --name-only
1034                         --files-without-match
1035                         --count
1036                         --and --or --not --all-match
1037                         "
1038                 return
1039                 ;;
1040         esac
1041         COMPREPLY=()
1044 _git_help ()
1046         local cur="${COMP_WORDS[COMP_CWORD]}"
1047         case "$cur" in
1048         --*)
1049                 __gitcomp "--all --info --man --web"
1050                 return
1051                 ;;
1052         esac
1053         __gitcomp "$(__git_all_commands)
1054                 attributes cli core-tutorial cvs-migration
1055                 diffcore gitk glossary hooks ignore modules
1056                 repository-layout tutorial tutorial-2
1057                 workflows
1058                 "
1061 _git_init ()
1063         local cur="${COMP_WORDS[COMP_CWORD]}"
1064         case "$cur" in
1065         --shared=*)
1066                 __gitcomp "
1067                         false true umask group all world everybody
1068                         " "" "${cur##--shared=}"
1069                 return
1070                 ;;
1071         --*)
1072                 __gitcomp "--quiet --bare --template= --shared --shared="
1073                 return
1074                 ;;
1075         esac
1076         COMPREPLY=()
1079 _git_ls_files ()
1081         __git_has_doubledash && return
1083         local cur="${COMP_WORDS[COMP_CWORD]}"
1084         case "$cur" in
1085         --*)
1086                 __gitcomp "--cached --deleted --modified --others --ignored
1087                         --stage --directory --no-empty-directory --unmerged
1088                         --killed --exclude= --exclude-from=
1089                         --exclude-per-directory= --exclude-standard
1090                         --error-unmatch --with-tree= --full-name
1091                         --abbrev --ignored --exclude-per-directory
1092                         "
1093                 return
1094                 ;;
1095         esac
1096         COMPREPLY=()
1099 _git_ls_remote ()
1101         __gitcomp "$(__git_remotes)"
1104 _git_ls_tree ()
1106         __git_complete_file
1109 # Options that go well for log, shortlog and gitk
1110 __git_log_common_options="
1111         --not --all
1112         --branches --tags --remotes
1113         --first-parent --no-merges
1114         --max-count=
1115         --max-age= --since= --after=
1116         --min-age= --until= --before=
1118 # Options that go well for log and gitk (not shortlog)
1119 __git_log_gitk_options="
1120         --dense --sparse --full-history
1121         --simplify-merges --simplify-by-decoration
1122         --left-right
1124 # Options that go well for log and shortlog (not gitk)
1125 __git_log_shortlog_options="
1126         --author= --committer= --grep=
1127         --all-match
1130 __git_log_pretty_formats="oneline short medium full fuller email raw format:"
1131 __git_log_date_formats="relative iso8601 rfc2822 short local default raw"
1133 _git_log ()
1135         __git_has_doubledash && return
1137         local cur="${COMP_WORDS[COMP_CWORD]}"
1138         local g="$(git rev-parse --git-dir 2>/dev/null)"
1139         local merge=""
1140         if [ -f "$g/MERGE_HEAD" ]; then
1141                 merge="--merge"
1142         fi
1143         case "$cur" in
1144         --pretty=*)
1145                 __gitcomp "$__git_log_pretty_formats
1146                         " "" "${cur##--pretty=}"
1147                 return
1148                 ;;
1149         --format=*)
1150                 __gitcomp "$__git_log_pretty_formats
1151                         " "" "${cur##--format=}"
1152                 return
1153                 ;;
1154         --date=*)
1155                 __gitcomp "$__git_log_date_formats" "" "${cur##--date=}"
1156                 return
1157                 ;;
1158         --*)
1159                 __gitcomp "
1160                         $__git_log_common_options
1161                         $__git_log_shortlog_options
1162                         $__git_log_gitk_options
1163                         --root --topo-order --date-order --reverse
1164                         --follow
1165                         --abbrev-commit --abbrev=
1166                         --relative-date --date=
1167                         --pretty= --format= --oneline
1168                         --cherry-pick
1169                         --graph
1170                         --decorate
1171                         --walk-reflogs
1172                         --parents --children
1173                         $merge
1174                         $__git_diff_common_options
1175                         --pickaxe-all --pickaxe-regex
1176                         "
1177                 return
1178                 ;;
1179         esac
1180         __git_complete_revlist
1183 __git_merge_options="
1184         --no-commit --no-stat --log --no-log --squash --strategy
1185         --commit --stat --no-squash --ff --no-ff
1188 _git_merge ()
1190         __git_complete_strategy && return
1192         local cur="${COMP_WORDS[COMP_CWORD]}"
1193         case "$cur" in
1194         --*)
1195                 __gitcomp "$__git_merge_options"
1196                 return
1197         esac
1198         __gitcomp "$(__git_refs)"
1201 _git_mergetool ()
1203         local cur="${COMP_WORDS[COMP_CWORD]}"
1204         case "$cur" in
1205         --tool=*)
1206                 __gitcomp "$__git_mergetools_common tortoisemerge" "" "${cur##--tool=}"
1207                 return
1208                 ;;
1209         --*)
1210                 __gitcomp "--tool="
1211                 return
1212                 ;;
1213         esac
1214         COMPREPLY=()
1217 _git_merge_base ()
1219         __gitcomp "$(__git_refs)"
1222 _git_mv ()
1224         local cur="${COMP_WORDS[COMP_CWORD]}"
1225         case "$cur" in
1226         --*)
1227                 __gitcomp "--dry-run"
1228                 return
1229                 ;;
1230         esac
1231         COMPREPLY=()
1234 _git_name_rev ()
1236         __gitcomp "--tags --all --stdin"
1239 _git_pull ()
1241         __git_complete_strategy && return
1243         local cur="${COMP_WORDS[COMP_CWORD]}"
1244         case "$cur" in
1245         --*)
1246                 __gitcomp "
1247                         --rebase --no-rebase
1248                         $__git_merge_options
1249                         $__git_fetch_options
1250                 "
1251                 return
1252                 ;;
1253         esac
1254         __git_complete_remote_or_refspec
1257 _git_push ()
1259         local cur="${COMP_WORDS[COMP_CWORD]}"
1260         case "${COMP_WORDS[COMP_CWORD-1]}" in
1261         --repo)
1262                 __gitcomp "$(__git_remotes)"
1263                 return
1264         esac
1265         case "$cur" in
1266         --repo=*)
1267                 __gitcomp "$(__git_remotes)" "" "${cur##--repo=}"
1268                 return
1269                 ;;
1270         --*)
1271                 __gitcomp "
1272                         --all --mirror --tags --dry-run --force --verbose
1273                         --receive-pack= --repo=
1274                 "
1275                 return
1276                 ;;
1277         esac
1278         __git_complete_remote_or_refspec
1281 _git_rebase ()
1283         local cur="${COMP_WORDS[COMP_CWORD]}" dir="$(__gitdir)"
1284         if [ -d "$dir"/rebase-apply ] || [ -d "$dir"/rebase-merge ]; then
1285                 __gitcomp "--continue --skip --abort"
1286                 return
1287         fi
1288         __git_complete_strategy && return
1289         case "$cur" in
1290         --*)
1291                 __gitcomp "--onto --merge --strategy --interactive"
1292                 return
1293         esac
1294         __gitcomp "$(__git_refs)"
1297 __git_send_email_confirm_options="always never auto cc compose"
1298 __git_send_email_suppresscc_options="author self cc ccbody sob cccmd body all"
1300 _git_send_email ()
1302         local cur="${COMP_WORDS[COMP_CWORD]}"
1303         case "$cur" in
1304         --confirm=*)
1305                 __gitcomp "
1306                         $__git_send_email_confirm_options
1307                         " "" "${cur##--confirm=}"
1308                 return
1309                 ;;
1310         --suppress-cc=*)
1311                 __gitcomp "
1312                         $__git_send_email_suppresscc_options
1313                         " "" "${cur##--suppress-cc=}"
1315                 return
1316                 ;;
1317         --smtp-encryption=*)
1318                 __gitcomp "ssl tls" "" "${cur##--smtp-encryption=}"
1319                 return
1320                 ;;
1321         --*)
1322                 __gitcomp "--annotate --bcc --cc --cc-cmd --chain-reply-to
1323                         --compose --confirm= --dry-run --envelope-sender
1324                         --from --identity
1325                         --in-reply-to --no-chain-reply-to --no-signed-off-by-cc
1326                         --no-suppress-from --no-thread --quiet
1327                         --signed-off-by-cc --smtp-pass --smtp-server
1328                         --smtp-server-port --smtp-encryption= --smtp-user
1329                         --subject --suppress-cc= --suppress-from --thread --to
1330                         --validate --no-validate"
1331                 return
1332                 ;;
1333         esac
1334         COMPREPLY=()
1337 _git_config ()
1339         local cur="${COMP_WORDS[COMP_CWORD]}"
1340         local prv="${COMP_WORDS[COMP_CWORD-1]}"
1341         case "$prv" in
1342         branch.*.remote)
1343                 __gitcomp "$(__git_remotes)"
1344                 return
1345                 ;;
1346         branch.*.merge)
1347                 __gitcomp "$(__git_refs)"
1348                 return
1349                 ;;
1350         remote.*.fetch)
1351                 local remote="${prv#remote.}"
1352                 remote="${remote%.fetch}"
1353                 __gitcomp "$(__git_refs_remotes "$remote")"
1354                 return
1355                 ;;
1356         remote.*.push)
1357                 local remote="${prv#remote.}"
1358                 remote="${remote%.push}"
1359                 __gitcomp "$(git --git-dir="$(__gitdir)" \
1360                         for-each-ref --format='%(refname):%(refname)' \
1361                         refs/heads)"
1362                 return
1363                 ;;
1364         pull.twohead|pull.octopus)
1365                 __gitcomp "$(__git_merge_strategies)"
1366                 return
1367                 ;;
1368         color.branch|color.diff|color.interactive|\
1369         color.showbranch|color.status|color.ui)
1370                 __gitcomp "always never auto"
1371                 return
1372                 ;;
1373         color.pager)
1374                 __gitcomp "false true"
1375                 return
1376                 ;;
1377         color.*.*)
1378                 __gitcomp "
1379                         normal black red green yellow blue magenta cyan white
1380                         bold dim ul blink reverse
1381                         "
1382                 return
1383                 ;;
1384         help.format)
1385                 __gitcomp "man info web html"
1386                 return
1387                 ;;
1388         log.date)
1389                 __gitcomp "$__git_log_date_formats"
1390                 return
1391                 ;;
1392         sendemail.aliasesfiletype)
1393                 __gitcomp "mutt mailrc pine elm gnus"
1394                 return
1395                 ;;
1396         sendemail.confirm)
1397                 __gitcomp "$__git_send_email_confirm_options"
1398                 return
1399                 ;;
1400         sendemail.suppresscc)
1401                 __gitcomp "$__git_send_email_suppresscc_options"
1402                 return
1403                 ;;
1404         *.*)
1405                 COMPREPLY=()
1406                 return
1407                 ;;
1408         esac
1409         case "$cur" in
1410         --*)
1411                 __gitcomp "
1412                         --global --system --file=
1413                         --list --replace-all
1414                         --get --get-all --get-regexp
1415                         --add --unset --unset-all
1416                         --remove-section --rename-section
1417                         "
1418                 return
1419                 ;;
1420         branch.*.*)
1421                 local pfx="${cur%.*}."
1422                 cur="${cur##*.}"
1423                 __gitcomp "remote merge mergeoptions" "$pfx" "$cur"
1424                 return
1425                 ;;
1426         branch.*)
1427                 local pfx="${cur%.*}."
1428                 cur="${cur#*.}"
1429                 __gitcomp "$(__git_heads)" "$pfx" "$cur" "."
1430                 return
1431                 ;;
1432         guitool.*.*)
1433                 local pfx="${cur%.*}."
1434                 cur="${cur##*.}"
1435                 __gitcomp "
1436                         argprompt cmd confirm needsfile noconsole norescan
1437                         prompt revprompt revunmerged title
1438                         " "$pfx" "$cur"
1439                 return
1440                 ;;
1441         difftool.*.*)
1442                 local pfx="${cur%.*}."
1443                 cur="${cur##*.}"
1444                 __gitcomp "cmd path" "$pfx" "$cur"
1445                 return
1446                 ;;
1447         man.*.*)
1448                 local pfx="${cur%.*}."
1449                 cur="${cur##*.}"
1450                 __gitcomp "cmd path" "$pfx" "$cur"
1451                 return
1452                 ;;
1453         mergetool.*.*)
1454                 local pfx="${cur%.*}."
1455                 cur="${cur##*.}"
1456                 __gitcomp "cmd path trustExitCode" "$pfx" "$cur"
1457                 return
1458                 ;;
1459         pager.*)
1460                 local pfx="${cur%.*}."
1461                 cur="${cur#*.}"
1462                 __gitcomp "$(__git_all_commands)" "$pfx" "$cur"
1463                 return
1464                 ;;
1465         remote.*.*)
1466                 local pfx="${cur%.*}."
1467                 cur="${cur##*.}"
1468                 __gitcomp "
1469                         url proxy fetch push mirror skipDefaultUpdate
1470                         receivepack uploadpack tagopt
1471                         " "$pfx" "$cur"
1472                 return
1473                 ;;
1474         remote.*)
1475                 local pfx="${cur%.*}."
1476                 cur="${cur#*.}"
1477                 __gitcomp "$(__git_remotes)" "$pfx" "$cur" "."
1478                 return
1479                 ;;
1480         url.*.*)
1481                 local pfx="${cur%.*}."
1482                 cur="${cur##*.}"
1483                 __gitcomp "insteadof" "$pfx" "$cur"
1484                 return
1485                 ;;
1486         esac
1487         __gitcomp "
1488                 alias.
1489                 apply.whitespace
1490                 branch.autosetupmerge
1491                 branch.autosetuprebase
1492                 clean.requireForce
1493                 color.branch
1494                 color.branch.current
1495                 color.branch.local
1496                 color.branch.plain
1497                 color.branch.remote
1498                 color.diff
1499                 color.diff.commit
1500                 color.diff.frag
1501                 color.diff.meta
1502                 color.diff.new
1503                 color.diff.old
1504                 color.diff.plain
1505                 color.diff.whitespace
1506                 color.grep
1507                 color.grep.external
1508                 color.grep.match
1509                 color.interactive
1510                 color.interactive.header
1511                 color.interactive.help
1512                 color.interactive.prompt
1513                 color.pager
1514                 color.showbranch
1515                 color.status
1516                 color.status.added
1517                 color.status.changed
1518                 color.status.header
1519                 color.status.nobranch
1520                 color.status.untracked
1521                 color.status.updated
1522                 color.ui
1523                 commit.template
1524                 core.autocrlf
1525                 core.bare
1526                 core.compression
1527                 core.createObject
1528                 core.deltaBaseCacheLimit
1529                 core.editor
1530                 core.excludesfile
1531                 core.fileMode
1532                 core.fsyncobjectfiles
1533                 core.gitProxy
1534                 core.ignoreCygwinFSTricks
1535                 core.ignoreStat
1536                 core.logAllRefUpdates
1537                 core.loosecompression
1538                 core.packedGitLimit
1539                 core.packedGitWindowSize
1540                 core.pager
1541                 core.preferSymlinkRefs
1542                 core.preloadindex
1543                 core.quotepath
1544                 core.repositoryFormatVersion
1545                 core.safecrlf
1546                 core.sharedRepository
1547                 core.symlinks
1548                 core.trustctime
1549                 core.warnAmbiguousRefs
1550                 core.whitespace
1551                 core.worktree
1552                 diff.autorefreshindex
1553                 diff.external
1554                 diff.mnemonicprefix
1555                 diff.renameLimit
1556                 diff.renameLimit.
1557                 diff.renames
1558                 diff.suppressBlankEmpty
1559                 diff.tool
1560                 diff.wordRegex
1561                 difftool.
1562                 difftool.prompt
1563                 fetch.unpackLimit
1564                 format.attach
1565                 format.cc
1566                 format.headers
1567                 format.numbered
1568                 format.pretty
1569                 format.signoff
1570                 format.subjectprefix
1571                 format.suffix
1572                 format.thread
1573                 gc.aggressiveWindow
1574                 gc.auto
1575                 gc.autopacklimit
1576                 gc.packrefs
1577                 gc.pruneexpire
1578                 gc.reflogexpire
1579                 gc.reflogexpireunreachable
1580                 gc.rerereresolved
1581                 gc.rerereunresolved
1582                 gitcvs.allbinary
1583                 gitcvs.commitmsgannotation
1584                 gitcvs.dbTableNamePrefix
1585                 gitcvs.dbdriver
1586                 gitcvs.dbname
1587                 gitcvs.dbpass
1588                 gitcvs.dbuser
1589                 gitcvs.enabled
1590                 gitcvs.logfile
1591                 gitcvs.usecrlfattr
1592                 guitool.
1593                 gui.blamehistoryctx
1594                 gui.commitmsgwidth
1595                 gui.copyblamethreshold
1596                 gui.diffcontext
1597                 gui.encoding
1598                 gui.fastcopyblame
1599                 gui.matchtrackingbranch
1600                 gui.newbranchtemplate
1601                 gui.pruneduringfetch
1602                 gui.spellingdictionary
1603                 gui.trustmtime
1604                 help.autocorrect
1605                 help.browser
1606                 help.format
1607                 http.lowSpeedLimit
1608                 http.lowSpeedTime
1609                 http.maxRequests
1610                 http.noEPSV
1611                 http.proxy
1612                 http.sslCAInfo
1613                 http.sslCAPath
1614                 http.sslCert
1615                 http.sslKey
1616                 http.sslVerify
1617                 i18n.commitEncoding
1618                 i18n.logOutputEncoding
1619                 imap.folder
1620                 imap.host
1621                 imap.pass
1622                 imap.port
1623                 imap.preformattedHTML
1624                 imap.sslverify
1625                 imap.tunnel
1626                 imap.user
1627                 instaweb.browser
1628                 instaweb.httpd
1629                 instaweb.local
1630                 instaweb.modulepath
1631                 instaweb.port
1632                 interactive.singlekey
1633                 log.date
1634                 log.showroot
1635                 mailmap.file
1636                 man.
1637                 man.viewer
1638                 merge.conflictstyle
1639                 merge.log
1640                 merge.renameLimit
1641                 merge.stat
1642                 merge.tool
1643                 merge.verbosity
1644                 mergetool.
1645                 mergetool.keepBackup
1646                 mergetool.prompt
1647                 pack.compression
1648                 pack.deltaCacheLimit
1649                 pack.deltaCacheSize
1650                 pack.depth
1651                 pack.indexVersion
1652                 pack.packSizeLimit
1653                 pack.threads
1654                 pack.window
1655                 pack.windowMemory
1656                 pager.
1657                 pull.octopus
1658                 pull.twohead
1659                 push.default
1660                 rebase.stat
1661                 receive.denyCurrentBranch
1662                 receive.denyDeletes
1663                 receive.denyNonFastForwards
1664                 receive.fsckObjects
1665                 receive.unpackLimit
1666                 repack.usedeltabaseoffset
1667                 rerere.autoupdate
1668                 rerere.enabled
1669                 sendemail.aliasesfile
1670                 sendemail.aliasesfiletype
1671                 sendemail.bcc
1672                 sendemail.cc
1673                 sendemail.cccmd
1674                 sendemail.chainreplyto
1675                 sendemail.confirm
1676                 sendemail.envelopesender
1677                 sendemail.multiedit
1678                 sendemail.signedoffbycc
1679                 sendemail.smtpencryption
1680                 sendemail.smtppass
1681                 sendemail.smtpserver
1682                 sendemail.smtpserverport
1683                 sendemail.smtpuser
1684                 sendemail.suppresscc
1685                 sendemail.suppressfrom
1686                 sendemail.thread
1687                 sendemail.to
1688                 sendemail.validate
1689                 showbranch.default
1690                 status.relativePaths
1691                 status.showUntrackedFiles
1692                 tar.umask
1693                 transfer.unpackLimit
1694                 url.
1695                 user.email
1696                 user.name
1697                 user.signingkey
1698                 web.browser
1699                 branch. remote.
1700         "
1703 _git_remote ()
1705         local subcommands="add rename rm show prune update set-head"
1706         local subcommand="$(__git_find_subcommand "$subcommands")"
1707         if [ -z "$subcommand" ]; then
1708                 __gitcomp "$subcommands"
1709                 return
1710         fi
1712         case "$subcommand" in
1713         rename|rm|show|prune)
1714                 __gitcomp "$(__git_remotes)"
1715                 ;;
1716         update)
1717                 local i c='' IFS=$'\n'
1718                 for i in $(git --git-dir="$(__gitdir)" config --list); do
1719                         case "$i" in
1720                         remotes.*)
1721                                 i="${i#remotes.}"
1722                                 c="$c ${i/=*/}"
1723                                 ;;
1724                         esac
1725                 done
1726                 __gitcomp "$c"
1727                 ;;
1728         *)
1729                 COMPREPLY=()
1730                 ;;
1731         esac
1734 _git_reset ()
1736         __git_has_doubledash && return
1738         local cur="${COMP_WORDS[COMP_CWORD]}"
1739         case "$cur" in
1740         --*)
1741                 __gitcomp "--merge --mixed --hard --soft"
1742                 return
1743                 ;;
1744         esac
1745         __gitcomp "$(__git_refs)"
1748 _git_revert ()
1750         local cur="${COMP_WORDS[COMP_CWORD]}"
1751         case "$cur" in
1752         --*)
1753                 __gitcomp "--edit --mainline --no-edit --no-commit --signoff"
1754                 return
1755                 ;;
1756         esac
1757         __gitcomp "$(__git_refs)"
1760 _git_rm ()
1762         __git_has_doubledash && return
1764         local cur="${COMP_WORDS[COMP_CWORD]}"
1765         case "$cur" in
1766         --*)
1767                 __gitcomp "--cached --dry-run --ignore-unmatch --quiet"
1768                 return
1769                 ;;
1770         esac
1771         COMPREPLY=()
1774 _git_shortlog ()
1776         __git_has_doubledash && return
1778         local cur="${COMP_WORDS[COMP_CWORD]}"
1779         case "$cur" in
1780         --*)
1781                 __gitcomp "
1782                         $__git_log_common_options
1783                         $__git_log_shortlog_options
1784                         --numbered --summary
1785                         "
1786                 return
1787                 ;;
1788         esac
1789         __git_complete_revlist
1792 _git_show ()
1794         __git_has_doubledash && return
1796         local cur="${COMP_WORDS[COMP_CWORD]}"
1797         case "$cur" in
1798         --pretty=*)
1799                 __gitcomp "$__git_log_pretty_formats
1800                         " "" "${cur##--pretty=}"
1801                 return
1802                 ;;
1803         --format=*)
1804                 __gitcomp "$__git_log_pretty_formats
1805                         " "" "${cur##--format=}"
1806                 return
1807                 ;;
1808         --*)
1809                 __gitcomp "--pretty= --format= --abbrev-commit --oneline
1810                         $__git_diff_common_options
1811                         "
1812                 return
1813                 ;;
1814         esac
1815         __git_complete_file
1818 _git_show_branch ()
1820         local cur="${COMP_WORDS[COMP_CWORD]}"
1821         case "$cur" in
1822         --*)
1823                 __gitcomp "
1824                         --all --remotes --topo-order --current --more=
1825                         --list --independent --merge-base --no-name
1826                         --color --no-color
1827                         --sha1-name --sparse --topics --reflog
1828                         "
1829                 return
1830                 ;;
1831         esac
1832         __git_complete_revlist
1835 _git_stash ()
1837         local subcommands='save list show apply clear drop pop create branch'
1838         local subcommand="$(__git_find_subcommand "$subcommands")"
1839         if [ -z "$subcommand" ]; then
1840                 __gitcomp "$subcommands"
1841         else
1842                 local cur="${COMP_WORDS[COMP_CWORD]}"
1843                 case "$subcommand,$cur" in
1844                 save,--*)
1845                         __gitcomp "--keep-index"
1846                         ;;
1847                 apply,--*)
1848                         __gitcomp "--index"
1849                         ;;
1850                 show,--*|drop,--*|pop,--*|branch,--*)
1851                         COMPREPLY=()
1852                         ;;
1853                 show,*|apply,*|drop,*|pop,*|branch,*)
1854                         __gitcomp "$(git --git-dir="$(__gitdir)" stash list \
1855                                         | sed -n -e 's/:.*//p')"
1856                         ;;
1857                 *)
1858                         COMPREPLY=()
1859                         ;;
1860                 esac
1861         fi
1864 _git_submodule ()
1866         __git_has_doubledash && return
1868         local subcommands="add status init update summary foreach sync"
1869         if [ -z "$(__git_find_subcommand "$subcommands")" ]; then
1870                 local cur="${COMP_WORDS[COMP_CWORD]}"
1871                 case "$cur" in
1872                 --*)
1873                         __gitcomp "--quiet --cached"
1874                         ;;
1875                 *)
1876                         __gitcomp "$subcommands"
1877                         ;;
1878                 esac
1879                 return
1880         fi
1883 _git_svn ()
1885         local subcommands="
1886                 init fetch clone rebase dcommit log find-rev
1887                 set-tree commit-diff info create-ignore propget
1888                 proplist show-ignore show-externals branch tag blame
1889                 migrate
1890                 "
1891         local subcommand="$(__git_find_subcommand "$subcommands")"
1892         if [ -z "$subcommand" ]; then
1893                 __gitcomp "$subcommands"
1894         else
1895                 local remote_opts="--username= --config-dir= --no-auth-cache"
1896                 local fc_opts="
1897                         --follow-parent --authors-file= --repack=
1898                         --no-metadata --use-svm-props --use-svnsync-props
1899                         --log-window-size= --no-checkout --quiet
1900                         --repack-flags --use-log-author --localtime
1901                         --ignore-paths= $remote_opts
1902                         "
1903                 local init_opts="
1904                         --template= --shared= --trunk= --tags=
1905                         --branches= --stdlayout --minimize-url
1906                         --no-metadata --use-svm-props --use-svnsync-props
1907                         --rewrite-root= --prefix= --use-log-author
1908                         --add-author-from $remote_opts
1909                         "
1910                 local cmt_opts="
1911                         --edit --rmdir --find-copies-harder --copy-similarity=
1912                         "
1914                 local cur="${COMP_WORDS[COMP_CWORD]}"
1915                 case "$subcommand,$cur" in
1916                 fetch,--*)
1917                         __gitcomp "--revision= --fetch-all $fc_opts"
1918                         ;;
1919                 clone,--*)
1920                         __gitcomp "--revision= $fc_opts $init_opts"
1921                         ;;
1922                 init,--*)
1923                         __gitcomp "$init_opts"
1924                         ;;
1925                 dcommit,--*)
1926                         __gitcomp "
1927                                 --merge --strategy= --verbose --dry-run
1928                                 --fetch-all --no-rebase --commit-url
1929                                 --revision $cmt_opts $fc_opts
1930                                 "
1931                         ;;
1932                 set-tree,--*)
1933                         __gitcomp "--stdin $cmt_opts $fc_opts"
1934                         ;;
1935                 create-ignore,--*|propget,--*|proplist,--*|show-ignore,--*|\
1936                 show-externals,--*)
1937                         __gitcomp "--revision="
1938                         ;;
1939                 log,--*)
1940                         __gitcomp "
1941                                 --limit= --revision= --verbose --incremental
1942                                 --oneline --show-commit --non-recursive
1943                                 --authors-file= --color
1944                                 "
1945                         ;;
1946                 rebase,--*)
1947                         __gitcomp "
1948                                 --merge --verbose --strategy= --local
1949                                 --fetch-all --dry-run $fc_opts
1950                                 "
1951                         ;;
1952                 commit-diff,--*)
1953                         __gitcomp "--message= --file= --revision= $cmt_opts"
1954                         ;;
1955                 info,--*)
1956                         __gitcomp "--url"
1957                         ;;
1958                 branch,--*)
1959                         __gitcomp "--dry-run --message --tag"
1960                         ;;
1961                 tag,--*)
1962                         __gitcomp "--dry-run --message"
1963                         ;;
1964                 blame,--*)
1965                         __gitcomp "--git-format"
1966                         ;;
1967                 migrate,--*)
1968                         __gitcomp "
1969                                 --config-dir= --ignore-paths= --minimize
1970                                 --no-auth-cache --username=
1971                                 "
1972                         ;;
1973                 *)
1974                         COMPREPLY=()
1975                         ;;
1976                 esac
1977         fi
1980 _git_tag ()
1982         local i c=1 f=0
1983         while [ $c -lt $COMP_CWORD ]; do
1984                 i="${COMP_WORDS[c]}"
1985                 case "$i" in
1986                 -d|-v)
1987                         __gitcomp "$(__git_tags)"
1988                         return
1989                         ;;
1990                 -f)
1991                         f=1
1992                         ;;
1993                 esac
1994                 c=$((++c))
1995         done
1997         case "${COMP_WORDS[COMP_CWORD-1]}" in
1998         -m|-F)
1999                 COMPREPLY=()
2000                 ;;
2001         -*|tag)
2002                 if [ $f = 1 ]; then
2003                         __gitcomp "$(__git_tags)"
2004                 else
2005                         COMPREPLY=()
2006                 fi
2007                 ;;
2008         *)
2009                 __gitcomp "$(__git_refs)"
2010                 ;;
2011         esac
2014 _git ()
2016         local i c=1 command __git_dir
2018         while [ $c -lt $COMP_CWORD ]; do
2019                 i="${COMP_WORDS[c]}"
2020                 case "$i" in
2021                 --git-dir=*) __git_dir="${i#--git-dir=}" ;;
2022                 --bare)      __git_dir="." ;;
2023                 --version|-p|--paginate) ;;
2024                 --help) command="help"; break ;;
2025                 *) command="$i"; break ;;
2026                 esac
2027                 c=$((++c))
2028         done
2030         if [ -z "$command" ]; then
2031                 case "${COMP_WORDS[COMP_CWORD]}" in
2032                 --*)   __gitcomp "
2033                         --paginate
2034                         --no-pager
2035                         --git-dir=
2036                         --bare
2037                         --version
2038                         --exec-path
2039                         --html-path
2040                         --work-tree=
2041                         --help
2042                         "
2043                         ;;
2044                 *)     __gitcomp "$(__git_porcelain_commands) $(__git_aliases)" ;;
2045                 esac
2046                 return
2047         fi
2049         local expansion=$(__git_aliased_command "$command")
2050         [ "$expansion" ] && command="$expansion"
2052         case "$command" in
2053         am)          _git_am ;;
2054         add)         _git_add ;;
2055         apply)       _git_apply ;;
2056         archive)     _git_archive ;;
2057         bisect)      _git_bisect ;;
2058         bundle)      _git_bundle ;;
2059         branch)      _git_branch ;;
2060         checkout)    _git_checkout ;;
2061         cherry)      _git_cherry ;;
2062         cherry-pick) _git_cherry_pick ;;
2063         clean)       _git_clean ;;
2064         clone)       _git_clone ;;
2065         commit)      _git_commit ;;
2066         config)      _git_config ;;
2067         describe)    _git_describe ;;
2068         diff)        _git_diff ;;
2069         difftool)    _git_difftool ;;
2070         fetch)       _git_fetch ;;
2071         format-patch) _git_format_patch ;;
2072         fsck)        _git_fsck ;;
2073         gc)          _git_gc ;;
2074         grep)        _git_grep ;;
2075         help)        _git_help ;;
2076         init)        _git_init ;;
2077         log)         _git_log ;;
2078         ls-files)    _git_ls_files ;;
2079         ls-remote)   _git_ls_remote ;;
2080         ls-tree)     _git_ls_tree ;;
2081         merge)       _git_merge;;
2082         mergetool)   _git_mergetool;;
2083         merge-base)  _git_merge_base ;;
2084         mv)          _git_mv ;;
2085         name-rev)    _git_name_rev ;;
2086         pull)        _git_pull ;;
2087         push)        _git_push ;;
2088         rebase)      _git_rebase ;;
2089         remote)      _git_remote ;;
2090         reset)       _git_reset ;;
2091         revert)      _git_revert ;;
2092         rm)          _git_rm ;;
2093         send-email)  _git_send_email ;;
2094         shortlog)    _git_shortlog ;;
2095         show)        _git_show ;;
2096         show-branch) _git_show_branch ;;
2097         stash)       _git_stash ;;
2098         stage)       _git_add ;;
2099         submodule)   _git_submodule ;;
2100         svn)         _git_svn ;;
2101         tag)         _git_tag ;;
2102         whatchanged) _git_log ;;
2103         *)           COMPREPLY=() ;;
2104         esac
2107 _gitk ()
2109         __git_has_doubledash && return
2111         local cur="${COMP_WORDS[COMP_CWORD]}"
2112         local g="$(__gitdir)"
2113         local merge=""
2114         if [ -f "$g/MERGE_HEAD" ]; then
2115                 merge="--merge"
2116         fi
2117         case "$cur" in
2118         --*)
2119                 __gitcomp "
2120                         $__git_log_common_options
2121                         $__git_log_gitk_options
2122                         $merge
2123                         "
2124                 return
2125                 ;;
2126         esac
2127         __git_complete_revlist
2130 complete -o bashdefault -o default -o nospace -F _git git 2>/dev/null \
2131         || complete -o default -o nospace -F _git git
2132 complete -o bashdefault -o default -o nospace -F _gitk gitk 2>/dev/null \
2133         || complete -o default -o nospace -F _gitk gitk
2135 # The following are necessary only for Cygwin, and only are needed
2136 # when the user has tab-completed the executable name and consequently
2137 # included the '.exe' suffix.
2139 if [ Cygwin = "$(uname -o 2>/dev/null)" ]; then
2140 complete -o bashdefault -o default -o nospace -F _git git.exe 2>/dev/null \
2141         || complete -o default -o nospace -F _git git.exe
2142 fi