1# bash/zsh completion support for core Git.
2#
3# Copyright (C) 2006,2007 Shawn O. Pearce <spearce@spearce.org>
4# Conceptually based on gitcompletion (http://gitweb.hawaga.org.uk/).
5# Distributed under the GNU General Public License, version 2.0.
6#
7# The contained completion routines provide support for completing:
8#
9# *) local and remote branch names
10# *) local and remote tag names
11# *) .git/remotes file names
12# *) git 'subcommands'
13# *) git email aliases for git-send-email
14# *) tree paths within 'ref:path/to/file' expressions
15# *) file paths within current working directory and index
16# *) common --long-options
17#
18# To use these routines:
19#
20# 1) Copy this file to somewhere (e.g. ~/.git-completion.bash).
21# 2) Add the following line to your .bashrc/.zshrc:
22# source ~/.git-completion.bash
23# 3) Consider changing your PS1 to also show the current branch,
24# see git-prompt.sh for details.
25#
26# If you use complex aliases of form '!f() { ... }; f', you can use the null
27# command ':' as the first command in the function body to declare the desired
28# completion style. For example '!f() { : git commit ; ... }; f' will
29# tell the completion to use commit completion. This also works with aliases
30# of form "!sh -c '...'". For example, "!sh -c ': git commit ; ... '".
31case "$COMP_WORDBREAKS" in
33*:*) : great ;;
34*) COMP_WORDBREAKS="$COMP_WORDBREAKS:"
35esac
36# __gitdir accepts 0 or 1 arguments (i.e., location)
38# returns location of .git repo
39__gitdir ()
40{
41 if [ -z "${1-}" ]; then
42 if [ -n "${__git_dir-}" ]; then
43 echo "$__git_dir"
44 elif [ -n "${GIT_DIR-}" ]; then
45 test -d "${GIT_DIR-}" || return 1
46 echo "$GIT_DIR"
47 elif [ -d .git ]; then
48 echo .git
49 else
50 git rev-parse --git-dir 2>/dev/null
51 fi
52 elif [ -d "$1/.git" ]; then
53 echo "$1/.git"
54 else
55 echo "$1"
56 fi
57}
58# The following function is based on code from:
60#
61# bash_completion - programmable completion functions for bash 3.2+
62#
63# Copyright © 2006-2008, Ian Macdonald <ian@caliban.org>
64# © 2009-2010, Bash Completion Maintainers
65# <bash-completion-devel@lists.alioth.debian.org>
66#
67# This program is free software; you can redistribute it and/or modify
68# it under the terms of the GNU General Public License as published by
69# the Free Software Foundation; either version 2, or (at your option)
70# any later version.
71#
72# This program is distributed in the hope that it will be useful,
73# but WITHOUT ANY WARRANTY; without even the implied warranty of
74# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
75# GNU General Public License for more details.
76#
77# You should have received a copy of the GNU General Public License
78# along with this program; if not, write to the Free Software Foundation,
79# Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
80#
81# The latest version of this software can be obtained here:
82#
83# http://bash-completion.alioth.debian.org/
84#
85# RELEASE: 2.x
86# This function can be used to access a tokenized list of words
88# on the command line:
89#
90# __git_reassemble_comp_words_by_ref '=:'
91# if test "${words_[cword_-1]}" = -w
92# then
93# ...
94# fi
95#
96# The argument should be a collection of characters from the list of
97# word completion separators (COMP_WORDBREAKS) to treat as ordinary
98# characters.
99#
100# This is roughly equivalent to going back in time and setting
101# COMP_WORDBREAKS to exclude those characters. The intent is to
102# make option types like --date=<type> and <rev>:<path> easy to
103# recognize by treating each shell word as a single token.
104#
105# It is best not to set COMP_WORDBREAKS directly because the value is
106# shared with other completion scripts. By the time the completion
107# function gets called, COMP_WORDS has already been populated so local
108# changes to COMP_WORDBREAKS have no effect.
109#
110# Output: words_, cword_, cur_.
111__git_reassemble_comp_words_by_ref()
113{
114 local exclude i j first
115 # Which word separators to exclude?
116 exclude="${1//[^$COMP_WORDBREAKS]}"
117 cword_=$COMP_CWORD
118 if [ -z "$exclude" ]; then
119 words_=("${COMP_WORDS[@]}")
120 return
121 fi
122 # List of word completion separators has shrunk;
123 # re-assemble words to complete.
124 for ((i=0, j=0; i < ${#COMP_WORDS[@]}; i++, j++)); do
125 # Append each nonempty word consisting of just
126 # word separator characters to the current word.
127 first=t
128 while
129 [ $i -gt 0 ] &&
130 [ -n "${COMP_WORDS[$i]}" ] &&
131 # word consists of excluded word separators
132 [ "${COMP_WORDS[$i]//[^$exclude]}" = "${COMP_WORDS[$i]}" ]
133 do
134 # Attach to the previous token,
135 # unless the previous token is the command name.
136 if [ $j -ge 2 ] && [ -n "$first" ]; then
137 ((j--))
138 fi
139 first=
140 words_[$j]=${words_[j]}${COMP_WORDS[i]}
141 if [ $i = $COMP_CWORD ]; then
142 cword_=$j
143 fi
144 if (($i < ${#COMP_WORDS[@]} - 1)); then
145 ((i++))
146 else
147 # Done.
148 return
149 fi
150 done
151 words_[$j]=${words_[j]}${COMP_WORDS[i]}
152 if [ $i = $COMP_CWORD ]; then
153 cword_=$j
154 fi
155 done
156}
157if ! type _get_comp_words_by_ref >/dev/null 2>&1; then
159_get_comp_words_by_ref ()
160{
161 local exclude cur_ words_ cword_
162 if [ "$1" = "-n" ]; then
163 exclude=$2
164 shift 2
165 fi
166 __git_reassemble_comp_words_by_ref "$exclude"
167 cur_=${words_[cword_]}
168 while [ $# -gt 0 ]; do
169 case "$1" in
170 cur)
171 cur=$cur_
172 ;;
173 prev)
174 prev=${words_[$cword_-1]}
175 ;;
176 words)
177 words=("${words_[@]}")
178 ;;
179 cword)
180 cword=$cword_
181 ;;
182 esac
183 shift
184 done
185}
186fi
187__gitcompappend ()
189{
190 local x i=${#COMPREPLY[@]}
191 for x in $1; do
192 if [[ "$x" == "$3"* ]]; then
193 COMPREPLY[i++]="$2$x$4"
194 fi
195 done
196}
197__gitcompadd ()
199{
200 COMPREPLY=()
201 __gitcompappend "$@"
202}
203# Generates completion reply, appending a space to possible completion words,
205# if necessary.
206# It accepts 1 to 4 arguments:
207# 1: List of possible completion words.
208# 2: A prefix to be added to each possible completion word (optional).
209# 3: Generate possible completion matches for this word (optional).
210# 4: A suffix to be appended to each possible completion word (optional).
211__gitcomp ()
212{
213 local cur_="${3-$cur}"
214 case "$cur_" in
216 --*=)
217 ;;
218 *)
219 local c i=0 IFS=$' \t\n'
220 for c in $1; do
221 c="$c${4-}"
222 if [[ $c == "$cur_"* ]]; then
223 case $c in
224 --*=*|*.) ;;
225 *) c="$c " ;;
226 esac
227 COMPREPLY[i++]="${2-}$c"
228 fi
229 done
230 ;;
231 esac
232}
233# Variation of __gitcomp_nl () that appends to the existing list of
235# completion candidates, COMPREPLY.
236__gitcomp_nl_append ()
237{
238 local IFS=$'\n'
239 __gitcompappend "$1" "${2-}" "${3-$cur}" "${4- }"
240}
241# Generates completion reply from newline-separated possible completion words
243# by appending a space to all of them.
244# It accepts 1 to 4 arguments:
245# 1: List of possible completion words, separated by a single newline.
246# 2: A prefix to be added to each possible completion word (optional).
247# 3: Generate possible completion matches for this word (optional).
248# 4: A suffix to be appended to each possible completion word instead of
249# the default space (optional). If specified but empty, nothing is
250# appended.
251__gitcomp_nl ()
252{
253 COMPREPLY=()
254 __gitcomp_nl_append "$@"
255}
256# Generates completion reply with compgen from newline-separated possible
258# completion filenames.
259# It accepts 1 to 3 arguments:
260# 1: List of possible completion filenames, separated by a single newline.
261# 2: A directory prefix to be added to each possible completion filename
262# (optional).
263# 3: Generate possible completion matches for this word (optional).
264__gitcomp_file ()
265{
266 local IFS=$'\n'
267 # XXX does not work when the directory prefix contains a tilde,
269 # since tilde expansion is not applied.
270 # This means that COMPREPLY will be empty and Bash default
271 # completion will be used.
272 __gitcompadd "$1" "${2-}" "${3-$cur}" ""
273 # use a hack to enable file mode in bash < 4
275 compopt -o filenames +o nospace 2>/dev/null ||
276 compgen -f /non-existing-dir/ > /dev/null
277}
278# Execute 'git ls-files', unless the --committable option is specified, in
280# which case it runs 'git diff-index' to find out the files that can be
281# committed. It return paths relative to the directory specified in the first
282# argument, and using the options specified in the second argument.
283__git_ls_files_helper ()
284{
285 if [ "$2" == "--committable" ]; then
286 git -C "$1" diff-index --name-only --relative HEAD
287 else
288 # NOTE: $2 is not quoted in order to support multiple options
289 git -C "$1" ls-files --exclude-standard $2
290 fi 2>/dev/null
291}
292# __git_index_files accepts 1 or 2 arguments:
295# 1: Options to pass to ls-files (required).
296# 2: A directory path (optional).
297# If provided, only files within the specified directory are listed.
298# Sub directories are never recursed. Path must have a trailing
299# slash.
300__git_index_files ()
301{
302 local dir="$(__gitdir)" root="${2-.}" file
303 if [ -d "$dir" ]; then
305 __git_ls_files_helper "$root" "$1" |
306 while read -r file; do
307 case "$file" in
308 ?*/*) echo "${file%%/*}" ;;
309 *) echo "$file" ;;
310 esac
311 done | sort | uniq
312 fi
313}
314__git_heads ()
316{
317 local dir="$(__gitdir)"
318 if [ -d "$dir" ]; then
319 git --git-dir="$dir" for-each-ref --format='%(refname:short)' \
320 refs/heads
321 return
322 fi
323}
324__git_tags ()
326{
327 local dir="$(__gitdir)"
328 if [ -d "$dir" ]; then
329 git --git-dir="$dir" for-each-ref --format='%(refname:short)' \
330 refs/tags
331 return
332 fi
333}
334# __git_refs accepts 0, 1 (to pass to __gitdir), or 2 arguments
336# presence of 2nd argument means use the guess heuristic employed
337# by checkout for tracking branches
338__git_refs ()
339{
340 local i hash dir="$(__gitdir "${1-}")" track="${2-}"
341 local format refs
342 if [ -d "$dir" ]; then
343 case "$cur" in
344 refs|refs/*)
345 format="refname"
346 refs="${cur%/*}"
347 track=""
348 ;;
349 *)
350 for i in HEAD FETCH_HEAD ORIG_HEAD MERGE_HEAD; do
351 if [ -e "$dir/$i" ]; then echo $i; fi
352 done
353 format="refname:short"
354 refs="refs/tags refs/heads refs/remotes"
355 ;;
356 esac
357 git --git-dir="$dir" for-each-ref --format="%($format)" \
358 $refs
359 if [ -n "$track" ]; then
360 # employ the heuristic used by git checkout
361 # Try to find a remote branch that matches the completion word
362 # but only output if the branch name is unique
363 local ref entry
364 git --git-dir="$dir" for-each-ref --shell --format="ref=%(refname:short)" \
365 "refs/remotes/" | \
366 while read -r entry; do
367 eval "$entry"
368 ref="${ref#*/}"
369 if [[ "$ref" == "$cur"* ]]; then
370 echo "$ref"
371 fi
372 done | sort | uniq -u
373 fi
374 return
375 fi
376 case "$cur" in
377 refs|refs/*)
378 git ls-remote "$dir" "$cur*" 2>/dev/null | \
379 while read -r hash i; do
380 case "$i" in
381 *^{}) ;;
382 *) echo "$i" ;;
383 esac
384 done
385 ;;
386 *)
387 echo "HEAD"
388 git for-each-ref --format="%(refname:short)" -- \
389 "refs/remotes/$dir/" 2>/dev/null | sed -e "s#^$dir/##"
390 ;;
391 esac
392}
393# __git_refs2 requires 1 argument (to pass to __git_refs)
395__git_refs2 ()
396{
397 local i
398 for i in $(__git_refs "$1"); do
399 echo "$i:$i"
400 done
401}
402# __git_refs_remotes requires 1 argument (to pass to ls-remote)
404__git_refs_remotes ()
405{
406 local i hash
407 git ls-remote "$1" 'refs/heads/*' 2>/dev/null | \
408 while read -r hash i; do
409 echo "$i:refs/remotes/$1/${i#refs/heads/}"
410 done
411}
412__git_remotes ()
414{
415 local d="$(__gitdir)"
416 test -d "$d/remotes" && ls -1 "$d/remotes"
417 git --git-dir="$d" remote
418}
419__git_list_merge_strategies ()
421{
422 git merge -s help 2>&1 |
423 sed -n -e '/[Aa]vailable strategies are: /,/^$/{
424 s/\.$//
425 s/.*://
426 s/^[ ]*//
427 s/[ ]*$//
428 p
429 }'
430}
431__git_merge_strategies=
433# 'git merge -s help' (and thus detection of the merge strategy
434# list) fails, unfortunately, if run outside of any git working
435# tree. __git_merge_strategies is set to the empty string in
436# that case, and the detection will be repeated the next time it
437# is needed.
438__git_compute_merge_strategies ()
439{
440 test -n "$__git_merge_strategies" ||
441 __git_merge_strategies=$(__git_list_merge_strategies)
442}
443__git_complete_revlist_file ()
445{
446 local pfx ls ref cur_="$cur"
447 case "$cur_" in
448 *..?*:*)
449 return
450 ;;
451 ?*:*)
452 ref="${cur_%%:*}"
453 cur_="${cur_#*:}"
454 case "$cur_" in
455 ?*/*)
456 pfx="${cur_%/*}"
457 cur_="${cur_##*/}"
458 ls="$ref:$pfx"
459 pfx="$pfx/"
460 ;;
461 *)
462 ls="$ref"
463 ;;
464 esac
465 case "$COMP_WORDBREAKS" in
467 *:*) : great ;;
468 *) pfx="$ref:$pfx" ;;
469 esac
470 __gitcomp_nl "$(git --git-dir="$(__gitdir)" ls-tree "$ls" 2>/dev/null \
472 | sed '/^100... blob /{
473 s,^.* ,,
474 s,$, ,
475 }
476 /^120000 blob /{
477 s,^.* ,,
478 s,$, ,
479 }
480 /^040000 tree /{
481 s,^.* ,,
482 s,$,/,
483 }
484 s/^.* //')" \
485 "$pfx" "$cur_" ""
486 ;;
487 *...*)
488 pfx="${cur_%...*}..."
489 cur_="${cur_#*...}"
490 __gitcomp_nl "$(__git_refs)" "$pfx" "$cur_"
491 ;;
492 *..*)
493 pfx="${cur_%..*}.."
494 cur_="${cur_#*..}"
495 __gitcomp_nl "$(__git_refs)" "$pfx" "$cur_"
496 ;;
497 *)
498 __gitcomp_nl "$(__git_refs)"
499 ;;
500 esac
501}
502# __git_complete_index_file requires 1 argument:
505# 1: the options to pass to ls-file
506#
507# The exception is --committable, which finds the files appropriate commit.
508__git_complete_index_file ()
509{
510 local pfx="" cur_="$cur"
511 case "$cur_" in
513 ?*/*)
514 pfx="${cur_%/*}"
515 cur_="${cur_##*/}"
516 pfx="${pfx}/"
517 ;;
518 esac
519 __gitcomp_file "$(__git_index_files "$1" ${pfx:+"$pfx"})" "$pfx" "$cur_"
521}
522__git_complete_file ()
524{
525 __git_complete_revlist_file
526}
527__git_complete_revlist ()
529{
530 __git_complete_revlist_file
531}
532__git_complete_remote_or_refspec ()
534{
535 local cur_="$cur" cmd="${words[1]}"
536 local i c=2 remote="" pfx="" lhs=1 no_complete_refspec=0
537 if [ "$cmd" = "remote" ]; then
538 ((c++))
539 fi
540 while [ $c -lt $cword ]; do
541 i="${words[c]}"
542 case "$i" in
543 --mirror) [ "$cmd" = "push" ] && no_complete_refspec=1 ;;
544 --all)
545 case "$cmd" in
546 push) no_complete_refspec=1 ;;
547 fetch)
548 return
549 ;;
550 *) ;;
551 esac
552 ;;
553 -*) ;;
554 *) remote="$i"; break ;;
555 esac
556 ((c++))
557 done
558 if [ -z "$remote" ]; then
559 __gitcomp_nl "$(__git_remotes)"
560 return
561 fi
562 if [ $no_complete_refspec = 1 ]; then
563 return
564 fi
565 [ "$remote" = "." ] && remote=
566 case "$cur_" in
567 *:*)
568 case "$COMP_WORDBREAKS" in
569 *:*) : great ;;
570 *) pfx="${cur_%%:*}:" ;;
571 esac
572 cur_="${cur_#*:}"
573 lhs=0
574 ;;
575 +*)
576 pfx="+"
577 cur_="${cur_#+}"
578 ;;
579 esac
580 case "$cmd" in
581 fetch)
582 if [ $lhs = 1 ]; then
583 __gitcomp_nl "$(__git_refs2 "$remote")" "$pfx" "$cur_"
584 else
585 __gitcomp_nl "$(__git_refs)" "$pfx" "$cur_"
586 fi
587 ;;
588 pull|remote)
589 if [ $lhs = 1 ]; then
590 __gitcomp_nl "$(__git_refs "$remote")" "$pfx" "$cur_"
591 else
592 __gitcomp_nl "$(__git_refs)" "$pfx" "$cur_"
593 fi
594 ;;
595 push)
596 if [ $lhs = 1 ]; then
597 __gitcomp_nl "$(__git_refs)" "$pfx" "$cur_"
598 else
599 __gitcomp_nl "$(__git_refs "$remote")" "$pfx" "$cur_"
600 fi
601 ;;
602 esac
603}
604__git_complete_strategy ()
606{
607 __git_compute_merge_strategies
608 case "$prev" in
609 -s|--strategy)
610 __gitcomp "$__git_merge_strategies"
611 return 0
612 esac
613 case "$cur" in
614 --strategy=*)
615 __gitcomp "$__git_merge_strategies" "" "${cur##--strategy=}"
616 return 0
617 ;;
618 esac
619 return 1
620}
621__git_commands () {
623 if test -n "${GIT_TESTING_COMMAND_COMPLETION:-}"
624 then
625 printf "%s" "${GIT_TESTING_COMMAND_COMPLETION}"
626 else
627 git help -a|egrep '^ [a-zA-Z0-9]'
628 fi
629}
630__git_list_all_commands ()
632{
633 local i IFS=" "$'\n'
634 for i in $(__git_commands)
635 do
636 case $i in
637 *--*) : helper pattern;;
638 *) echo $i;;
639 esac
640 done
641}
642__git_all_commands=
644__git_compute_all_commands ()
645{
646 test -n "$__git_all_commands" ||
647 __git_all_commands=$(__git_list_all_commands)
648}
649__git_list_porcelain_commands ()
651{
652 local i IFS=" "$'\n'
653 __git_compute_all_commands
654 for i in $__git_all_commands
655 do
656 case $i in
657 *--*) : helper pattern;;
658 applymbox) : ask gittus;;
659 applypatch) : ask gittus;;
660 archimport) : import;;
661 cat-file) : plumbing;;
662 check-attr) : plumbing;;
663 check-ignore) : plumbing;;
664 check-mailmap) : plumbing;;
665 check-ref-format) : plumbing;;
666 checkout-index) : plumbing;;
667 column) : internal helper;;
668 commit-tree) : plumbing;;
669 count-objects) : infrequent;;
670 credential) : credentials;;
671 credential-*) : credentials helper;;
672 cvsexportcommit) : export;;
673 cvsimport) : import;;
674 cvsserver) : daemon;;
675 daemon) : daemon;;
676 diff-files) : plumbing;;
677 diff-index) : plumbing;;
678 diff-tree) : plumbing;;
679 fast-import) : import;;
680 fast-export) : export;;
681 fsck-objects) : plumbing;;
682 fetch-pack) : plumbing;;
683 fmt-merge-msg) : plumbing;;
684 for-each-ref) : plumbing;;
685 hash-object) : plumbing;;
686 http-*) : transport;;
687 index-pack) : plumbing;;
688 init-db) : deprecated;;
689 local-fetch) : plumbing;;
690 ls-files) : plumbing;;
691 ls-remote) : plumbing;;
692 ls-tree) : plumbing;;
693 mailinfo) : plumbing;;
694 mailsplit) : plumbing;;
695 merge-*) : plumbing;;
696 mktree) : plumbing;;
697 mktag) : plumbing;;
698 pack-objects) : plumbing;;
699 pack-redundant) : plumbing;;
700 pack-refs) : plumbing;;
701 parse-remote) : plumbing;;
702 patch-id) : plumbing;;
703 prune) : plumbing;;
704 prune-packed) : plumbing;;
705 quiltimport) : import;;
706 read-tree) : plumbing;;
707 receive-pack) : plumbing;;
708 remote-*) : transport;;
709 rerere) : plumbing;;
710 rev-list) : plumbing;;
711 rev-parse) : plumbing;;
712 runstatus) : plumbing;;
713 sh-setup) : internal;;
714 shell) : daemon;;
715 show-ref) : plumbing;;
716 send-pack) : plumbing;;
717 show-index) : plumbing;;
718 ssh-*) : transport;;
719 stripspace) : plumbing;;
720 symbolic-ref) : plumbing;;
721 unpack-file) : plumbing;;
722 unpack-objects) : plumbing;;
723 update-index) : plumbing;;
724 update-ref) : plumbing;;
725 update-server-info) : daemon;;
726 upload-archive) : plumbing;;
727 upload-pack) : plumbing;;
728 write-tree) : plumbing;;
729 var) : infrequent;;
730 verify-pack) : infrequent;;
731 verify-tag) : plumbing;;
732 *) echo $i;;
733 esac
734 done
735}
736__git_porcelain_commands=
738__git_compute_porcelain_commands ()
739{
740 test -n "$__git_porcelain_commands" ||
741 __git_porcelain_commands=$(__git_list_porcelain_commands)
742}
743# Lists all set config variables starting with the given section prefix,
745# with the prefix removed.
746__git_get_config_variables ()
747{
748 local section="$1" i IFS=$'\n'
749 for i in $(git --git-dir="$(__gitdir)" config --name-only --get-regexp "^$section\..*" 2>/dev/null); do
750 echo "${i#$section.}"
751 done
752}
753__git_pretty_aliases ()
755{
756 __git_get_config_variables "pretty"
757}
758__git_aliases ()
760{
761 __git_get_config_variables "alias"
762}
763# __git_aliased_command requires 1 argument
765__git_aliased_command ()
766{
767 local word cmdline=$(git --git-dir="$(__gitdir)" \
768 config --get "alias.$1")
769 for word in $cmdline; do
770 case "$word" in
771 \!gitk|gitk)
772 echo "gitk"
773 return
774 ;;
775 \!*) : shell command alias ;;
776 -*) : option ;;
777 *=*) : setting env ;;
778 git) : git itself ;;
779 \(\)) : skip parens of shell function definition ;;
780 {) : skip start of shell helper function ;;
781 :) : skip null command ;;
782 \'*) : skip opening quote after sh -c ;;
783 *)
784 echo "$word"
785 return
786 esac
787 done
788}
789# __git_find_on_cmdline requires 1 argument
791__git_find_on_cmdline ()
792{
793 local word subcommand c=1
794 while [ $c -lt $cword ]; do
795 word="${words[c]}"
796 for subcommand in $1; do
797 if [ "$subcommand" = "$word" ]; then
798 echo "$subcommand"
799 return
800 fi
801 done
802 ((c++))
803 done
804}
805__git_has_doubledash ()
807{
808 local c=1
809 while [ $c -lt $cword ]; do
810 if [ "--" = "${words[c]}" ]; then
811 return 0
812 fi
813 ((c++))
814 done
815 return 1
816}
817# Try to count non option arguments passed on the command line for the
819# specified git command.
820# When options are used, it is necessary to use the special -- option to
821# tell the implementation were non option arguments begin.
822# XXX this can not be improved, since options can appear everywhere, as
823# an example:
824# git mv x -n y
825#
826# __git_count_arguments requires 1 argument: the git command executed.
827__git_count_arguments ()
828{
829 local word i c=0
830 # Skip "git" (first argument)
832 for ((i=1; i < ${#words[@]}; i++)); do
833 word="${words[i]}"
834 case "$word" in
836 --)
837 # Good; we can assume that the following are only non
838 # option arguments.
839 ((c = 0))
840 ;;
841 "$1")
842 # Skip the specified git command and discard git
843 # main options
844 ((c = 0))
845 ;;
846 ?*)
847 ((c++))
848 ;;
849 esac
850 done
851 printf "%d" $c
853}
854__git_whitespacelist="nowarn warn error error-all fix"
856_git_am ()
858{
859 local dir="$(__gitdir)"
860 if [ -d "$dir"/rebase-apply ]; then
861 __gitcomp "--skip --continue --resolved --abort"
862 return
863 fi
864 case "$cur" in
865 --whitespace=*)
866 __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
867 return
868 ;;
869 --*)
870 __gitcomp "
871 --3way --committer-date-is-author-date --ignore-date
872 --ignore-whitespace --ignore-space-change
873 --interactive --keep --no-utf8 --signoff --utf8
874 --whitespace= --scissors
875 "
876 return
877 esac
878}
879_git_apply ()
881{
882 case "$cur" in
883 --whitespace=*)
884 __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
885 return
886 ;;
887 --*)
888 __gitcomp "
889 --stat --numstat --summary --check --index
890 --cached --index-info --reverse --reject --unidiff-zero
891 --apply --no-add --exclude=
892 --ignore-whitespace --ignore-space-change
893 --whitespace= --inaccurate-eof --verbose
894 "
895 return
896 esac
897}
898_git_add ()
900{
901 case "$cur" in
902 --*)
903 __gitcomp "
904 --interactive --refresh --patch --update --dry-run
905 --ignore-errors --intent-to-add
906 "
907 return
908 esac
909 # XXX should we check for --update and --all options ?
911 __git_complete_index_file "--others --modified --directory --no-empty-directory"
912}
913_git_archive ()
915{
916 case "$cur" in
917 --format=*)
918 __gitcomp "$(git archive --list)" "" "${cur##--format=}"
919 return
920 ;;
921 --remote=*)
922 __gitcomp_nl "$(__git_remotes)" "" "${cur##--remote=}"
923 return
924 ;;
925 --*)
926 __gitcomp "
927 --format= --list --verbose
928 --prefix= --remote= --exec=
929 "
930 return
931 ;;
932 esac
933 __git_complete_file
934}
935_git_bisect ()
937{
938 __git_has_doubledash && return
939 local subcommands="start bad good skip reset visualize replay log run"
941 local subcommand="$(__git_find_on_cmdline "$subcommands")"
942 if [ -z "$subcommand" ]; then
943 if [ -f "$(__gitdir)"/BISECT_START ]; then
944 __gitcomp "$subcommands"
945 else
946 __gitcomp "replay start"
947 fi
948 return
949 fi
950 case "$subcommand" in
952 bad|good|reset|skip|start)
953 __gitcomp_nl "$(__git_refs)"
954 ;;
955 *)
956 ;;
957 esac
958}
959_git_branch ()
961{
962 local i c=1 only_local_ref="n" has_r="n"
963 while [ $c -lt $cword ]; do
965 i="${words[c]}"
966 case "$i" in
967 -d|-m) only_local_ref="y" ;;
968 -r) has_r="y" ;;
969 esac
970 ((c++))
971 done
972 case "$cur" in
974 --set-upstream-to=*)
975 __gitcomp_nl "$(__git_refs)" "" "${cur##--set-upstream-to=}"
976 ;;
977 --*)
978 __gitcomp "
979 --color --no-color --verbose --abbrev= --no-abbrev
980 --track --no-track --contains --merged --no-merged
981 --set-upstream-to= --edit-description --list
982 --unset-upstream
983 "
984 ;;
985 *)
986 if [ $only_local_ref = "y" -a $has_r = "n" ]; then
987 __gitcomp_nl "$(__git_heads)"
988 else
989 __gitcomp_nl "$(__git_refs)"
990 fi
991 ;;
992 esac
993}
994_git_bundle ()
996{
997 local cmd="${words[2]}"
998 case "$cword" in
999 2)
1000 __gitcomp "create list-heads verify unbundle"
1001 ;;
1002 3)
1003 # looking for a file
1004 ;;
1005 *)
1006 case "$cmd" in
1007 create)
1008 __git_complete_revlist
1009 ;;
1010 esac
1011 ;;
1012 esac
1013}
1014_git_checkout ()
1016{
1017 __git_has_doubledash && return
1018 case "$cur" in
1020 --conflict=*)
1021 __gitcomp "diff3 merge" "" "${cur##--conflict=}"
1022 ;;
1023 --*)
1024 __gitcomp "
1025 --quiet --ours --theirs --track --no-track --merge
1026 --conflict= --orphan --patch
1027 "
1028 ;;
1029 *)
1030 # check if --track, --no-track, or --no-guess was specified
1031 # if so, disable DWIM mode
1032 local flags="--track --no-track --no-guess" track=1
1033 if [ -n "$(__git_find_on_cmdline "$flags")" ]; then
1034 track=''
1035 fi
1036 __gitcomp_nl "$(__git_refs '' $track)"
1037 ;;
1038 esac
1039}
1040_git_cherry ()
1042{
1043 __gitcomp_nl "$(__git_refs)"
1044}
1045_git_cherry_pick ()
1047{
1048 local dir="$(__gitdir)"
1049 if [ -f "$dir"/CHERRY_PICK_HEAD ]; then
1050 __gitcomp "--continue --quit --abort"
1051 return
1052 fi
1053 case "$cur" in
1054 --*)
1055 __gitcomp "--edit --no-commit --signoff --strategy= --mainline"
1056 ;;
1057 *)
1058 __gitcomp_nl "$(__git_refs)"
1059 ;;
1060 esac
1061}
1062_git_clean ()
1064{
1065 case "$cur" in
1066 --*)
1067 __gitcomp "--dry-run --quiet"
1068 return
1069 ;;
1070 esac
1071 # XXX should we check for -x option ?
1073 __git_complete_index_file "--others --directory"
1074}
1075_git_clone ()
1077{
1078 case "$cur" in
1079 --*)
1080 __gitcomp "
1081 --local
1082 --no-hardlinks
1083 --shared
1084 --reference
1085 --quiet
1086 --no-checkout
1087 --bare
1088 --mirror
1089 --origin
1090 --upload-pack
1091 --template=
1092 --depth
1093 --single-branch
1094 --branch
1095 "
1096 return
1097 ;;
1098 esac
1099}
1100_git_commit ()
1102{
1103 case "$prev" in
1104 -c|-C)
1105 __gitcomp_nl "$(__git_refs)" "" "${cur}"
1106 return
1107 ;;
1108 esac
1109 case "$cur" in
1111 --cleanup=*)
1112 __gitcomp "default scissors strip verbatim whitespace
1113 " "" "${cur##--cleanup=}"
1114 return
1115 ;;
1116 --reuse-message=*|--reedit-message=*|\
1117 --fixup=*|--squash=*)
1118 __gitcomp_nl "$(__git_refs)" "" "${cur#*=}"
1119 return
1120 ;;
1121 --untracked-files=*)
1122 __gitcomp "all no normal" "" "${cur##--untracked-files=}"
1123 return
1124 ;;
1125 --*)
1126 __gitcomp "
1127 --all --author= --signoff --verify --no-verify
1128 --edit --no-edit
1129 --amend --include --only --interactive
1130 --dry-run --reuse-message= --reedit-message=
1131 --reset-author --file= --message= --template=
1132 --cleanup= --untracked-files --untracked-files=
1133 --verbose --quiet --fixup= --squash=
1134 "
1135 return
1136 esac
1137 if git rev-parse --verify --quiet HEAD >/dev/null; then
1139 __git_complete_index_file "--committable"
1140 else
1141 # This is the first commit
1142 __git_complete_index_file "--cached"
1143 fi
1144}
1145_git_describe ()
1147{
1148 case "$cur" in
1149 --*)
1150 __gitcomp "
1151 --all --tags --contains --abbrev= --candidates=
1152 --exact-match --debug --long --match --always
1153 "
1154 return
1155 esac
1156 __gitcomp_nl "$(__git_refs)"
1157}
1158__git_diff_algorithms="myers minimal patience histogram"
1160__git_diff_common_options="--stat --numstat --shortstat --summary
1162 --patch-with-stat --name-only --name-status --color
1163 --no-color --color-words --no-renames --check
1164 --full-index --binary --abbrev --diff-filter=
1165 --find-copies-harder
1166 --text --ignore-space-at-eol --ignore-space-change
1167 --ignore-all-space --ignore-blank-lines --exit-code
1168 --quiet --ext-diff --no-ext-diff
1169 --no-prefix --src-prefix= --dst-prefix=
1170 --inter-hunk-context=
1171 --patience --histogram --minimal
1172 --raw --word-diff
1173 --dirstat --dirstat= --dirstat-by-file
1174 --dirstat-by-file= --cumulative
1175 --diff-algorithm=
1176"
1177_git_diff ()
1179{
1180 __git_has_doubledash && return
1181 case "$cur" in
1183 --diff-algorithm=*)
1184 __gitcomp "$__git_diff_algorithms" "" "${cur##--diff-algorithm=}"
1185 return
1186 ;;
1187 --*)
1188 __gitcomp "--cached --staged --pickaxe-all --pickaxe-regex
1189 --base --ours --theirs --no-index
1190 $__git_diff_common_options
1191 "
1192 return
1193 ;;
1194 esac
1195 __git_complete_revlist_file
1196}
1197__git_mergetools_common="diffuse diffmerge ecmerge emerge kdiff3 meld opendiff
1199 tkdiff vimdiff gvimdiff xxdiff araxis p4merge bc codecompare
1200"
1201_git_difftool ()
1203{
1204 __git_has_doubledash && return
1205 case "$cur" in
1207 --tool=*)
1208 __gitcomp "$__git_mergetools_common kompare" "" "${cur##--tool=}"
1209 return
1210 ;;
1211 --*)
1212 __gitcomp "--cached --staged --pickaxe-all --pickaxe-regex
1213 --base --ours --theirs
1214 --no-renames --diff-filter= --find-copies-harder
1215 --relative --ignore-submodules
1216 --tool="
1217 return
1218 ;;
1219 esac
1220 __git_complete_revlist_file
1221}
1222__git_fetch_recurse_submodules="yes on-demand no"
1224__git_fetch_options="
1226 --quiet --verbose --append --upload-pack --force --keep --depth=
1227 --tags --no-tags --all --prune --dry-run --recurse-submodules=
1228"
1229_git_fetch ()
1231{
1232 case "$cur" in
1233 --recurse-submodules=*)
1234 __gitcomp "$__git_fetch_recurse_submodules" "" "${cur##--recurse-submodules=}"
1235 return
1236 ;;
1237 --*)
1238 __gitcomp "$__git_fetch_options"
1239 return
1240 ;;
1241 esac
1242 __git_complete_remote_or_refspec
1243}
1244__git_format_patch_options="
1246 --stdout --attach --no-attach --thread --thread= --no-thread
1247 --numbered --start-number --numbered-files --keep-subject --signoff
1248 --signature --no-signature --in-reply-to= --cc= --full-index --binary
1249 --not --all --cover-letter --no-prefix --src-prefix= --dst-prefix=
1250 --inline --suffix= --ignore-if-in-upstream --subject-prefix=
1251 --output-directory --reroll-count --to= --quiet --notes
1252"
1253_git_format_patch ()
1255{
1256 case "$cur" in
1257 --thread=*)
1258 __gitcomp "
1259 deep shallow
1260 " "" "${cur##--thread=}"
1261 return
1262 ;;
1263 --*)
1264 __gitcomp "$__git_format_patch_options"
1265 return
1266 ;;
1267 esac
1268 __git_complete_revlist
1269}
1270_git_fsck ()
1272{
1273 case "$cur" in
1274 --*)
1275 __gitcomp "
1276 --tags --root --unreachable --cache --no-reflogs --full
1277 --strict --verbose --lost-found
1278 "
1279 return
1280 ;;
1281 esac
1282}
1283_git_gc ()
1285{
1286 case "$cur" in
1287 --*)
1288 __gitcomp "--prune --aggressive"
1289 return
1290 ;;
1291 esac
1292}
1293_git_gitk ()
1295{
1296 _gitk
1297}
1298__git_match_ctag() {
1300 awk "/^${1//\//\\/}/ { print \$1 }" "$2"
1301}
1302_git_grep ()
1304{
1305 __git_has_doubledash && return
1306 case "$cur" in
1308 --*)
1309 __gitcomp "
1310 --cached
1311 --text --ignore-case --word-regexp --invert-match
1312 --full-name --line-number
1313 --extended-regexp --basic-regexp --fixed-strings
1314 --perl-regexp
1315 --threads
1316 --files-with-matches --name-only
1317 --files-without-match
1318 --max-depth
1319 --count
1320 --and --or --not --all-match
1321 "
1322 return
1323 ;;
1324 esac
1325 case "$cword,$prev" in
1327 2,*|*,-*)
1328 if test -r tags; then
1329 __gitcomp_nl "$(__git_match_ctag "$cur" tags)"
1330 return
1331 fi
1332 ;;
1333 esac
1334 __gitcomp_nl "$(__git_refs)"
1336}
1337_git_help ()
1339{
1340 case "$cur" in
1341 --*)
1342 __gitcomp "--all --info --man --web"
1343 return
1344 ;;
1345 esac
1346 __git_compute_all_commands
1347 __gitcomp "$__git_all_commands $(__git_aliases)
1348 attributes cli core-tutorial cvs-migration
1349 diffcore gitk glossary hooks ignore modules
1350 namespaces repository-layout tutorial tutorial-2
1351 workflows
1352 "
1353}
1354_git_init ()
1356{
1357 case "$cur" in
1358 --shared=*)
1359 __gitcomp "
1360 false true umask group all world everybody
1361 " "" "${cur##--shared=}"
1362 return
1363 ;;
1364 --*)
1365 __gitcomp "--quiet --bare --template= --shared --shared="
1366 return
1367 ;;
1368 esac
1369}
1370_git_ls_files ()
1372{
1373 case "$cur" in
1374 --*)
1375 __gitcomp "--cached --deleted --modified --others --ignored
1376 --stage --directory --no-empty-directory --unmerged
1377 --killed --exclude= --exclude-from=
1378 --exclude-per-directory= --exclude-standard
1379 --error-unmatch --with-tree= --full-name
1380 --abbrev --ignored --exclude-per-directory
1381 "
1382 return
1383 ;;
1384 esac
1385 # XXX ignore options like --modified and always suggest all cached
1387 # files.
1388 __git_complete_index_file "--cached"
1389}
1390_git_ls_remote ()
1392{
1393 __gitcomp_nl "$(__git_remotes)"
1394}
1395_git_ls_tree ()
1397{
1398 __git_complete_file
1399}
1400# Options that go well for log, shortlog and gitk
1402__git_log_common_options="
1403 --not --all
1404 --branches --tags --remotes
1405 --first-parent --merges --no-merges
1406 --max-count=
1407 --max-age= --since= --after=
1408 --min-age= --until= --before=
1409 --min-parents= --max-parents=
1410 --no-min-parents --no-max-parents
1411"
1412# Options that go well for log and gitk (not shortlog)
1413__git_log_gitk_options="
1414 --dense --sparse --full-history
1415 --simplify-merges --simplify-by-decoration
1416 --left-right --notes --no-notes
1417"
1418# Options that go well for log and shortlog (not gitk)
1419__git_log_shortlog_options="
1420 --author= --committer= --grep=
1421 --all-match --invert-grep
1422"
1423__git_log_pretty_formats="oneline short medium full fuller email raw format:"
1425__git_log_date_formats="relative iso8601 rfc2822 short local default raw"
1426_git_log ()
1428{
1429 __git_has_doubledash && return
1430 local g="$(git rev-parse --git-dir 2>/dev/null)"
1432 local merge=""
1433 if [ -f "$g/MERGE_HEAD" ]; then
1434 merge="--merge"
1435 fi
1436 case "$cur" in
1437 --pretty=*|--format=*)
1438 __gitcomp "$__git_log_pretty_formats $(__git_pretty_aliases)
1439 " "" "${cur#*=}"
1440 return
1441 ;;
1442 --date=*)
1443 __gitcomp "$__git_log_date_formats" "" "${cur##--date=}"
1444 return
1445 ;;
1446 --decorate=*)
1447 __gitcomp "full short no" "" "${cur##--decorate=}"
1448 return
1449 ;;
1450 --*)
1451 __gitcomp "
1452 $__git_log_common_options
1453 $__git_log_shortlog_options
1454 $__git_log_gitk_options
1455 --root --topo-order --date-order --reverse
1456 --follow --full-diff
1457 --abbrev-commit --abbrev=
1458 --relative-date --date=
1459 --pretty= --format= --oneline
1460 --show-signature
1461 --cherry-pick
1462 --graph
1463 --decorate --decorate=
1464 --walk-reflogs
1465 --parents --children
1466 $merge
1467 $__git_diff_common_options
1468 --pickaxe-all --pickaxe-regex
1469 "
1470 return
1471 ;;
1472 esac
1473 __git_complete_revlist
1474}
1475# Common merge options shared by git-merge(1) and git-pull(1).
1477__git_merge_options="
1478 --no-commit --no-stat --log --no-log --squash --strategy
1479 --commit --stat --no-squash --ff --no-ff --ff-only --edit --no-edit
1480 --verify-signatures --no-verify-signatures --gpg-sign
1481 --quiet --verbose --progress --no-progress
1482"
1483_git_merge ()
1485{
1486 __git_complete_strategy && return
1487 case "$cur" in
1489 --*)
1490 __gitcomp "$__git_merge_options
1491 --rerere-autoupdate --no-rerere-autoupdate --abort"
1492 return
1493 esac
1494 __gitcomp_nl "$(__git_refs)"
1495}
1496_git_mergetool ()
1498{
1499 case "$cur" in
1500 --tool=*)
1501 __gitcomp "$__git_mergetools_common tortoisemerge" "" "${cur##--tool=}"
1502 return
1503 ;;
1504 --*)
1505 __gitcomp "--tool="
1506 return
1507 ;;
1508 esac
1509}
1510_git_merge_base ()
1512{
1513 case "$cur" in
1514 --*)
1515 __gitcomp "--octopus --independent --is-ancestor --fork-point"
1516 return
1517 ;;
1518 esac
1519 __gitcomp_nl "$(__git_refs)"
1520}
1521_git_mv ()
1523{
1524 case "$cur" in
1525 --*)
1526 __gitcomp "--dry-run"
1527 return
1528 ;;
1529 esac
1530 if [ $(__git_count_arguments "mv") -gt 0 ]; then
1532 # We need to show both cached and untracked files (including
1533 # empty directories) since this may not be the last argument.
1534 __git_complete_index_file "--cached --others --directory"
1535 else
1536 __git_complete_index_file "--cached"
1537 fi
1538}
1539_git_name_rev ()
1541{
1542 __gitcomp "--tags --all --stdin"
1543}
1544_git_notes ()
1546{
1547 local subcommands='add append copy edit list prune remove show'
1548 local subcommand="$(__git_find_on_cmdline "$subcommands")"
1549 case "$subcommand,$cur" in
1551 ,--*)
1552 __gitcomp '--ref'
1553 ;;
1554 ,*)
1555 case "$prev" in
1556 --ref)
1557 __gitcomp_nl "$(__git_refs)"
1558 ;;
1559 *)
1560 __gitcomp "$subcommands --ref"
1561 ;;
1562 esac
1563 ;;
1564 add,--reuse-message=*|append,--reuse-message=*|\
1565 add,--reedit-message=*|append,--reedit-message=*)
1566 __gitcomp_nl "$(__git_refs)" "" "${cur#*=}"
1567 ;;
1568 add,--*|append,--*)
1569 __gitcomp '--file= --message= --reedit-message=
1570 --reuse-message='
1571 ;;
1572 copy,--*)
1573 __gitcomp '--stdin'
1574 ;;
1575 prune,--*)
1576 __gitcomp '--dry-run --verbose'
1577 ;;
1578 prune,*)
1579 ;;
1580 *)
1581 case "$prev" in
1582 -m|-F)
1583 ;;
1584 *)
1585 __gitcomp_nl "$(__git_refs)"
1586 ;;
1587 esac
1588 ;;
1589 esac
1590}
1591_git_pull ()
1593{
1594 __git_complete_strategy && return
1595 case "$cur" in
1597 --recurse-submodules=*)
1598 __gitcomp "$__git_fetch_recurse_submodules" "" "${cur##--recurse-submodules=}"
1599 return
1600 ;;
1601 --*)
1602 __gitcomp "
1603 --rebase --no-rebase
1604 $__git_merge_options
1605 $__git_fetch_options
1606 "
1607 return
1608 ;;
1609 esac
1610 __git_complete_remote_or_refspec
1611}
1612__git_push_recurse_submodules="check on-demand"
1614__git_complete_force_with_lease ()
1616{
1617 local cur_=$1
1618 case "$cur_" in
1620 --*=)
1621 ;;
1622 *:*)
1623 __gitcomp_nl "$(__git_refs)" "" "${cur_#*:}"
1624 ;;
1625 *)
1626 __gitcomp_nl "$(__git_refs)" "" "$cur_"
1627 ;;
1628 esac
1629}
1630_git_push ()
1632{
1633 case "$prev" in
1634 --repo)
1635 __gitcomp_nl "$(__git_remotes)"
1636 return
1637 ;;
1638 --recurse-submodules)
1639 __gitcomp "$__git_push_recurse_submodules"
1640 return
1641 ;;
1642 esac
1643 case "$cur" in
1644 --repo=*)
1645 __gitcomp_nl "$(__git_remotes)" "" "${cur##--repo=}"
1646 return
1647 ;;
1648 --recurse-submodules=*)
1649 __gitcomp "$__git_push_recurse_submodules" "" "${cur##--recurse-submodules=}"
1650 return
1651 ;;
1652 --force-with-lease=*)
1653 __git_complete_force_with_lease "${cur##--force-with-lease=}"
1654 return
1655 ;;
1656 --*)
1657 __gitcomp "
1658 --all --mirror --tags --dry-run --force --verbose
1659 --quiet --prune --delete --follow-tags
1660 --receive-pack= --repo= --set-upstream
1661 --force-with-lease --force-with-lease= --recurse-submodules=
1662 "
1663 return
1664 ;;
1665 esac
1666 __git_complete_remote_or_refspec
1667}
1668_git_rebase ()
1670{
1671 local dir="$(__gitdir)"
1672 if [ -f "$dir"/rebase-merge/interactive ]; then
1673 __gitcomp "--continue --skip --abort --edit-todo"
1674 return
1675 elif [ -d "$dir"/rebase-apply ] || [ -d "$dir"/rebase-merge ]; then
1676 __gitcomp "--continue --skip --abort"
1677 return
1678 fi
1679 __git_complete_strategy && return
1680 case "$cur" in
1681 --whitespace=*)
1682 __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
1683 return
1684 ;;
1685 --*)
1686 __gitcomp "
1687 --onto --merge --strategy --interactive
1688 --preserve-merges --stat --no-stat
1689 --committer-date-is-author-date --ignore-date
1690 --ignore-whitespace --whitespace=
1691 --autosquash --fork-point --no-fork-point
1692 --autostash
1693 "
1694 return
1696 esac
1697 __gitcomp_nl "$(__git_refs)"
1698}
1699_git_reflog ()
1701{
1702 local subcommands="show delete expire"
1703 local subcommand="$(__git_find_on_cmdline "$subcommands")"
1704 if [ -z "$subcommand" ]; then
1706 __gitcomp "$subcommands"
1707 else
1708 __gitcomp_nl "$(__git_refs)"
1709 fi
1710}
1711__git_send_email_confirm_options="always never auto cc compose"
1713__git_send_email_suppresscc_options="author self cc bodycc sob cccmd body all"
1714_git_send_email ()
1716{
1717 case "$prev" in
1718 --to|--cc|--bcc|--from)
1719 __gitcomp "
1720 $(git --git-dir="$(__gitdir)" send-email --dump-aliases 2>/dev/null)
1721 "
1722 return
1723 ;;
1724 esac
1725 case "$cur" in
1727 --confirm=*)
1728 __gitcomp "
1729 $__git_send_email_confirm_options
1730 " "" "${cur##--confirm=}"
1731 return
1732 ;;
1733 --suppress-cc=*)
1734 __gitcomp "
1735 $__git_send_email_suppresscc_options
1736 " "" "${cur##--suppress-cc=}"
1737 return
1739 ;;
1740 --smtp-encryption=*)
1741 __gitcomp "ssl tls" "" "${cur##--smtp-encryption=}"
1742 return
1743 ;;
1744 --thread=*)
1745 __gitcomp "
1746 deep shallow
1747 " "" "${cur##--thread=}"
1748 return
1749 ;;
1750 --to=*|--cc=*|--bcc=*|--from=*)
1751 __gitcomp "
1752 $(git --git-dir="$(__gitdir)" send-email --dump-aliases 2>/dev/null)
1753 " "" "${cur#--*=}"
1754 return
1755 ;;
1756 --*)
1757 __gitcomp "--annotate --bcc --cc --cc-cmd --chain-reply-to
1758 --compose --confirm= --dry-run --envelope-sender
1759 --from --identity
1760 --in-reply-to --no-chain-reply-to --no-signed-off-by-cc
1761 --no-suppress-from --no-thread --quiet
1762 --signed-off-by-cc --smtp-pass --smtp-server
1763 --smtp-server-port --smtp-encryption= --smtp-user
1764 --subject --suppress-cc= --suppress-from --thread --to
1765 --validate --no-validate
1766 $__git_format_patch_options"
1767 return
1768 ;;
1769 esac
1770 __git_complete_revlist
1771}
1772_git_stage ()
1774{
1775 _git_add
1776}
1777__git_config_get_set_variables ()
1779{
1780 local prevword word config_file= c=$cword
1781 while [ $c -gt 1 ]; do
1782 word="${words[c]}"
1783 case "$word" in
1784 --system|--global|--local|--file=*)
1785 config_file="$word"
1786 break
1787 ;;
1788 -f|--file)
1789 config_file="$word $prevword"
1790 break
1791 ;;
1792 esac
1793 prevword=$word
1794 c=$((--c))
1795 done
1796 git --git-dir="$(__gitdir)" config $config_file --name-only --list 2>/dev/null
1798}
1799_git_config ()
1801{
1802 case "$prev" in
1803 branch.*.remote|branch.*.pushremote)
1804 __gitcomp_nl "$(__git_remotes)"
1805 return
1806 ;;
1807 branch.*.merge)
1808 __gitcomp_nl "$(__git_refs)"
1809 return
1810 ;;
1811 branch.*.rebase)
1812 __gitcomp "false true preserve interactive"
1813 return
1814 ;;
1815 remote.pushdefault)
1816 __gitcomp_nl "$(__git_remotes)"
1817 return
1818 ;;
1819 remote.*.fetch)
1820 local remote="${prev#remote.}"
1821 remote="${remote%.fetch}"
1822 if [ -z "$cur" ]; then
1823 __gitcomp_nl "refs/heads/" "" "" ""
1824 return
1825 fi
1826 __gitcomp_nl "$(__git_refs_remotes "$remote")"
1827 return
1828 ;;
1829 remote.*.push)
1830 local remote="${prev#remote.}"
1831 remote="${remote%.push}"
1832 __gitcomp_nl "$(git --git-dir="$(__gitdir)" \
1833 for-each-ref --format='%(refname):%(refname)' \
1834 refs/heads)"
1835 return
1836 ;;
1837 pull.twohead|pull.octopus)
1838 __git_compute_merge_strategies
1839 __gitcomp "$__git_merge_strategies"
1840 return
1841 ;;
1842 color.branch|color.diff|color.interactive|\
1843 color.showbranch|color.status|color.ui)
1844 __gitcomp "always never auto"
1845 return
1846 ;;
1847 color.pager)
1848 __gitcomp "false true"
1849 return
1850 ;;
1851 color.*.*)
1852 __gitcomp "
1853 normal black red green yellow blue magenta cyan white
1854 bold dim ul blink reverse
1855 "
1856 return
1857 ;;
1858 diff.submodule)
1859 __gitcomp "log short"
1860 return
1861 ;;
1862 help.format)
1863 __gitcomp "man info web html"
1864 return
1865 ;;
1866 log.date)
1867 __gitcomp "$__git_log_date_formats"
1868 return
1869 ;;
1870 sendemail.aliasesfiletype)
1871 __gitcomp "mutt mailrc pine elm gnus"
1872 return
1873 ;;
1874 sendemail.confirm)
1875 __gitcomp "$__git_send_email_confirm_options"
1876 return
1877 ;;
1878 sendemail.suppresscc)
1879 __gitcomp "$__git_send_email_suppresscc_options"
1880 return
1881 ;;
1882 sendemail.transferencoding)
1883 __gitcomp "7bit 8bit quoted-printable base64"
1884 return
1885 ;;
1886 --get|--get-all|--unset|--unset-all)
1887 __gitcomp_nl "$(__git_config_get_set_variables)"
1888 return
1889 ;;
1890 *.*)
1891 return
1892 ;;
1893 esac
1894 case "$cur" in
1895 --*)
1896 __gitcomp "
1897 --system --global --local --file=
1898 --list --replace-all
1899 --get --get-all --get-regexp
1900 --add --unset --unset-all
1901 --remove-section --rename-section
1902 --name-only
1903 "
1904 return
1905 ;;
1906 branch.*.*)
1907 local pfx="${cur%.*}." cur_="${cur##*.}"
1908 __gitcomp "remote pushremote merge mergeoptions rebase" "$pfx" "$cur_"
1909 return
1910 ;;
1911 branch.*)
1912 local pfx="${cur%.*}." cur_="${cur#*.}"
1913 __gitcomp_nl "$(__git_heads)" "$pfx" "$cur_" "."
1914 __gitcomp_nl_append $'autosetupmerge\nautosetuprebase\n' "$pfx" "$cur_"
1915 return
1916 ;;
1917 guitool.*.*)
1918 local pfx="${cur%.*}." cur_="${cur##*.}"
1919 __gitcomp "
1920 argprompt cmd confirm needsfile noconsole norescan
1921 prompt revprompt revunmerged title
1922 " "$pfx" "$cur_"
1923 return
1924 ;;
1925 difftool.*.*)
1926 local pfx="${cur%.*}." cur_="${cur##*.}"
1927 __gitcomp "cmd path" "$pfx" "$cur_"
1928 return
1929 ;;
1930 man.*.*)
1931 local pfx="${cur%.*}." cur_="${cur##*.}"
1932 __gitcomp "cmd path" "$pfx" "$cur_"
1933 return
1934 ;;
1935 mergetool.*.*)
1936 local pfx="${cur%.*}." cur_="${cur##*.}"
1937 __gitcomp "cmd path trustExitCode" "$pfx" "$cur_"
1938 return
1939 ;;
1940 pager.*)
1941 local pfx="${cur%.*}." cur_="${cur#*.}"
1942 __git_compute_all_commands
1943 __gitcomp_nl "$__git_all_commands" "$pfx" "$cur_"
1944 return
1945 ;;
1946 remote.*.*)
1947 local pfx="${cur%.*}." cur_="${cur##*.}"
1948 __gitcomp "
1949 url proxy fetch push mirror skipDefaultUpdate
1950 receivepack uploadpack tagopt pushurl
1951 " "$pfx" "$cur_"
1952 return
1953 ;;
1954 remote.*)
1955 local pfx="${cur%.*}." cur_="${cur#*.}"
1956 __gitcomp_nl "$(__git_remotes)" "$pfx" "$cur_" "."
1957 __gitcomp_nl_append "pushdefault" "$pfx" "$cur_"
1958 return
1959 ;;
1960 url.*.*)
1961 local pfx="${cur%.*}." cur_="${cur##*.}"
1962 __gitcomp "insteadOf pushInsteadOf" "$pfx" "$cur_"
1963 return
1964 ;;
1965 esac
1966 __gitcomp "
1967 add.ignoreErrors
1968 advice.commitBeforeMerge
1969 advice.detachedHead
1970 advice.implicitIdentity
1971 advice.pushNonFastForward
1972 advice.resolveConflict
1973 advice.statusHints
1974 alias.
1975 am.keepcr
1976 apply.ignorewhitespace
1977 apply.whitespace
1978 branch.autosetupmerge
1979 branch.autosetuprebase
1980 browser.
1981 clean.requireForce
1982 color.branch
1983 color.branch.current
1984 color.branch.local
1985 color.branch.plain
1986 color.branch.remote
1987 color.decorate.HEAD
1988 color.decorate.branch
1989 color.decorate.remoteBranch
1990 color.decorate.stash
1991 color.decorate.tag
1992 color.diff
1993 color.diff.commit
1994 color.diff.frag
1995 color.diff.func
1996 color.diff.meta
1997 color.diff.new
1998 color.diff.old
1999 color.diff.plain
2000 color.diff.whitespace
2001 color.grep
2002 color.grep.context
2003 color.grep.filename
2004 color.grep.function
2005 color.grep.linenumber
2006 color.grep.match
2007 color.grep.selected
2008 color.grep.separator
2009 color.interactive
2010 color.interactive.error
2011 color.interactive.header
2012 color.interactive.help
2013 color.interactive.prompt
2014 color.pager
2015 color.showbranch
2016 color.status
2017 color.status.added
2018 color.status.changed
2019 color.status.header
2020 color.status.nobranch
2021 color.status.unmerged
2022 color.status.untracked
2023 color.status.updated
2024 color.ui
2025 commit.status
2026 commit.template
2027 core.abbrev
2028 core.askpass
2029 core.attributesfile
2030 core.autocrlf
2031 core.bare
2032 core.bigFileThreshold
2033 core.compression
2034 core.createObject
2035 core.deltaBaseCacheLimit
2036 core.editor
2037 core.eol
2038 core.excludesfile
2039 core.fileMode
2040 core.fsyncobjectfiles
2041 core.gitProxy
2042 core.ignoreStat
2043 core.ignorecase
2044 core.logAllRefUpdates
2045 core.loosecompression
2046 core.notesRef
2047 core.packedGitLimit
2048 core.packedGitWindowSize
2049 core.pager
2050 core.preferSymlinkRefs
2051 core.preloadindex
2052 core.quotepath
2053 core.repositoryFormatVersion
2054 core.safecrlf
2055 core.sharedRepository
2056 core.sparseCheckout
2057 core.symlinks
2058 core.trustctime
2059 core.warnAmbiguousRefs
2060 core.whitespace
2061 core.worktree
2062 diff.autorefreshindex
2063 diff.external
2064 diff.ignoreSubmodules
2065 diff.mnemonicprefix
2066 diff.noprefix
2067 diff.renameLimit
2068 diff.renames
2069 diff.statGraphWidth
2070 diff.submodule
2071 diff.suppressBlankEmpty
2072 diff.tool
2073 diff.wordRegex
2074 diff.algorithm
2075 difftool.
2076 difftool.prompt
2077 fetch.recurseSubmodules
2078 fetch.unpackLimit
2079 format.attach
2080 format.cc
2081 format.coverLetter
2082 format.headers
2083 format.numbered
2084 format.pretty
2085 format.signature
2086 format.signoff
2087 format.subjectprefix
2088 format.suffix
2089 format.thread
2090 format.to
2091 gc.
2092 gc.aggressiveWindow
2093 gc.auto
2094 gc.autopacklimit
2095 gc.packrefs
2096 gc.pruneexpire
2097 gc.reflogexpire
2098 gc.reflogexpireunreachable
2099 gc.rerereresolved
2100 gc.rerereunresolved
2101 gitcvs.allbinary
2102 gitcvs.commitmsgannotation
2103 gitcvs.dbTableNamePrefix
2104 gitcvs.dbdriver
2105 gitcvs.dbname
2106 gitcvs.dbpass
2107 gitcvs.dbuser
2108 gitcvs.enabled
2109 gitcvs.logfile
2110 gitcvs.usecrlfattr
2111 guitool.
2112 gui.blamehistoryctx
2113 gui.commitmsgwidth
2114 gui.copyblamethreshold
2115 gui.diffcontext
2116 gui.encoding
2117 gui.fastcopyblame
2118 gui.matchtrackingbranch
2119 gui.newbranchtemplate
2120 gui.pruneduringfetch
2121 gui.spellingdictionary
2122 gui.trustmtime
2123 help.autocorrect
2124 help.browser
2125 help.format
2126 http.lowSpeedLimit
2127 http.lowSpeedTime
2128 http.maxRequests
2129 http.minSessions
2130 http.noEPSV
2131 http.postBuffer
2132 http.proxy
2133 http.sslCipherList
2134 http.sslVersion
2135 http.sslCAInfo
2136 http.sslCAPath
2137 http.sslCert
2138 http.sslCertPasswordProtected
2139 http.sslKey
2140 http.sslVerify
2141 http.useragent
2142 i18n.commitEncoding
2143 i18n.logOutputEncoding
2144 imap.authMethod
2145 imap.folder
2146 imap.host
2147 imap.pass
2148 imap.port
2149 imap.preformattedHTML
2150 imap.sslverify
2151 imap.tunnel
2152 imap.user
2153 init.templatedir
2154 instaweb.browser
2155 instaweb.httpd
2156 instaweb.local
2157 instaweb.modulepath
2158 instaweb.port
2159 interactive.singlekey
2160 log.date
2161 log.decorate
2162 log.showroot
2163 mailmap.file
2164 man.
2165 man.viewer
2166 merge.
2167 merge.conflictstyle
2168 merge.log
2169 merge.renameLimit
2170 merge.renormalize
2171 merge.stat
2172 merge.tool
2173 merge.verbosity
2174 mergetool.
2175 mergetool.keepBackup
2176 mergetool.keepTemporaries
2177 mergetool.prompt
2178 notes.displayRef
2179 notes.rewrite.
2180 notes.rewrite.amend
2181 notes.rewrite.rebase
2182 notes.rewriteMode
2183 notes.rewriteRef
2184 pack.compression
2185 pack.deltaCacheLimit
2186 pack.deltaCacheSize
2187 pack.depth
2188 pack.indexVersion
2189 pack.packSizeLimit
2190 pack.threads
2191 pack.window
2192 pack.windowMemory
2193 pager.
2194 pretty.
2195 pull.octopus
2196 pull.twohead
2197 push.default
2198 push.followTags
2199 rebase.autosquash
2200 rebase.stat
2201 receive.autogc
2202 receive.denyCurrentBranch
2203 receive.denyDeleteCurrent
2204 receive.denyDeletes
2205 receive.denyNonFastForwards
2206 receive.fsckObjects
2207 receive.unpackLimit
2208 receive.updateserverinfo
2209 remote.pushdefault
2210 remotes.
2211 repack.usedeltabaseoffset
2212 rerere.autoupdate
2213 rerere.enabled
2214 sendemail.
2215 sendemail.aliasesfile
2216 sendemail.aliasfiletype
2217 sendemail.bcc
2218 sendemail.cc
2219 sendemail.cccmd
2220 sendemail.chainreplyto
2221 sendemail.confirm
2222 sendemail.envelopesender
2223 sendemail.from
2224 sendemail.identity
2225 sendemail.multiedit
2226 sendemail.signedoffbycc
2227 sendemail.smtpdomain
2228 sendemail.smtpencryption
2229 sendemail.smtppass
2230 sendemail.smtpserver
2231 sendemail.smtpserveroption
2232 sendemail.smtpserverport
2233 sendemail.smtpuser
2234 sendemail.suppresscc
2235 sendemail.suppressfrom
2236 sendemail.thread
2237 sendemail.to
2238 sendemail.validate
2239 showbranch.default
2240 status.relativePaths
2241 status.showUntrackedFiles
2242 status.submodulesummary
2243 submodule.
2244 tar.umask
2245 transfer.unpackLimit
2246 url.
2247 user.email
2248 user.name
2249 user.signingkey
2250 web.browser
2251 branch. remote.
2252 "
2253}
2254_git_remote ()
2256{
2257 local subcommands="add rename remove set-head set-branches set-url show prune update"
2258 local subcommand="$(__git_find_on_cmdline "$subcommands")"
2259 if [ -z "$subcommand" ]; then
2260 __gitcomp "$subcommands"
2261 return
2262 fi
2263 case "$subcommand" in
2265 rename|remove|set-url|show|prune)
2266 __gitcomp_nl "$(__git_remotes)"
2267 ;;
2268 set-head|set-branches)
2269 __git_complete_remote_or_refspec
2270 ;;
2271 update)
2272 __gitcomp "$(__git_get_config_variables "remotes")"
2273 ;;
2274 *)
2275 ;;
2276 esac
2277}
2278_git_replace ()
2280{
2281 __gitcomp_nl "$(__git_refs)"
2282}
2283_git_reset ()
2285{
2286 __git_has_doubledash && return
2287 case "$cur" in
2289 --*)
2290 __gitcomp "--merge --mixed --hard --soft --patch"
2291 return
2292 ;;
2293 esac
2294 __gitcomp_nl "$(__git_refs)"
2295}
2296_git_revert ()
2298{
2299 local dir="$(__gitdir)"
2300 if [ -f "$dir"/REVERT_HEAD ]; then
2301 __gitcomp "--continue --quit --abort"
2302 return
2303 fi
2304 case "$cur" in
2305 --*)
2306 __gitcomp "--edit --mainline --no-edit --no-commit --signoff"
2307 return
2308 ;;
2309 esac
2310 __gitcomp_nl "$(__git_refs)"
2311}
2312_git_rm ()
2314{
2315 case "$cur" in
2316 --*)
2317 __gitcomp "--cached --dry-run --ignore-unmatch --quiet"
2318 return
2319 ;;
2320 esac
2321 __git_complete_index_file "--cached"
2323}
2324_git_shortlog ()
2326{
2327 __git_has_doubledash && return
2328 case "$cur" in
2330 --*)
2331 __gitcomp "
2332 $__git_log_common_options
2333 $__git_log_shortlog_options
2334 --numbered --summary
2335 "
2336 return
2337 ;;
2338 esac
2339 __git_complete_revlist
2340}
2341_git_show ()
2343{
2344 __git_has_doubledash && return
2345 case "$cur" in
2347 --pretty=*|--format=*)
2348 __gitcomp "$__git_log_pretty_formats $(__git_pretty_aliases)
2349 " "" "${cur#*=}"
2350 return
2351 ;;
2352 --diff-algorithm=*)
2353 __gitcomp "$__git_diff_algorithms" "" "${cur##--diff-algorithm=}"
2354 return
2355 ;;
2356 --*)
2357 __gitcomp "--pretty= --format= --abbrev-commit --oneline
2358 --show-signature
2359 $__git_diff_common_options
2360 "
2361 return
2362 ;;
2363 esac
2364 __git_complete_revlist_file
2365}
2366_git_show_branch ()
2368{
2369 case "$cur" in
2370 --*)
2371 __gitcomp "
2372 --all --remotes --topo-order --current --more=
2373 --list --independent --merge-base --no-name
2374 --color --no-color
2375 --sha1-name --sparse --topics --reflog
2376 "
2377 return
2378 ;;
2379 esac
2380 __git_complete_revlist
2381}
2382_git_stash ()
2384{
2385 local save_opts='--keep-index --no-keep-index --quiet --patch'
2386 local subcommands='save list show apply clear drop pop create branch'
2387 local subcommand="$(__git_find_on_cmdline "$subcommands")"
2388 if [ -z "$subcommand" ]; then
2389 case "$cur" in
2390 --*)
2391 __gitcomp "$save_opts"
2392 ;;
2393 *)
2394 if [ -z "$(__git_find_on_cmdline "$save_opts")" ]; then
2395 __gitcomp "$subcommands"
2396 fi
2397 ;;
2398 esac
2399 else
2400 case "$subcommand,$cur" in
2401 save,--*)
2402 __gitcomp "$save_opts"
2403 ;;
2404 apply,--*|pop,--*)
2405 __gitcomp "--index --quiet"
2406 ;;
2407 show,--*|drop,--*|branch,--*)
2408 ;;
2409 show,*|apply,*|drop,*|pop,*|branch,*)
2410 __gitcomp_nl "$(git --git-dir="$(__gitdir)" stash list \
2411 | sed -n -e 's/:.*//p')"
2412 ;;
2413 *)
2414 ;;
2415 esac
2416 fi
2417}
2418_git_submodule ()
2420{
2421 __git_has_doubledash && return
2422 local subcommands="add status init deinit update summary foreach sync"
2424 if [ -z "$(__git_find_on_cmdline "$subcommands")" ]; then
2425 case "$cur" in
2426 --*)
2427 __gitcomp "--quiet --cached"
2428 ;;
2429 *)
2430 __gitcomp "$subcommands"
2431 ;;
2432 esac
2433 return
2434 fi
2435}
2436_git_svn ()
2438{
2439 local subcommands="
2440 init fetch clone rebase dcommit log find-rev
2441 set-tree commit-diff info create-ignore propget
2442 proplist show-ignore show-externals branch tag blame
2443 migrate mkdirs reset gc
2444 "
2445 local subcommand="$(__git_find_on_cmdline "$subcommands")"
2446 if [ -z "$subcommand" ]; then
2447 __gitcomp "$subcommands"
2448 else
2449 local remote_opts="--username= --config-dir= --no-auth-cache"
2450 local fc_opts="
2451 --follow-parent --authors-file= --repack=
2452 --no-metadata --use-svm-props --use-svnsync-props
2453 --log-window-size= --no-checkout --quiet
2454 --repack-flags --use-log-author --localtime
2455 --ignore-paths= --include-paths= $remote_opts
2456 "
2457 local init_opts="
2458 --template= --shared= --trunk= --tags=
2459 --branches= --stdlayout --minimize-url
2460 --no-metadata --use-svm-props --use-svnsync-props
2461 --rewrite-root= --prefix= --use-log-author
2462 --add-author-from $remote_opts
2463 "
2464 local cmt_opts="
2465 --edit --rmdir --find-copies-harder --copy-similarity=
2466 "
2467 case "$subcommand,$cur" in
2469 fetch,--*)
2470 __gitcomp "--revision= --fetch-all $fc_opts"
2471 ;;
2472 clone,--*)
2473 __gitcomp "--revision= $fc_opts $init_opts"
2474 ;;
2475 init,--*)
2476 __gitcomp "$init_opts"
2477 ;;
2478 dcommit,--*)
2479 __gitcomp "
2480 --merge --strategy= --verbose --dry-run
2481 --fetch-all --no-rebase --commit-url
2482 --revision --interactive $cmt_opts $fc_opts
2483 "
2484 ;;
2485 set-tree,--*)
2486 __gitcomp "--stdin $cmt_opts $fc_opts"
2487 ;;
2488 create-ignore,--*|propget,--*|proplist,--*|show-ignore,--*|\
2489 show-externals,--*|mkdirs,--*)
2490 __gitcomp "--revision="
2491 ;;
2492 log,--*)
2493 __gitcomp "
2494 --limit= --revision= --verbose --incremental
2495 --oneline --show-commit --non-recursive
2496 --authors-file= --color
2497 "
2498 ;;
2499 rebase,--*)
2500 __gitcomp "
2501 --merge --verbose --strategy= --local
2502 --fetch-all --dry-run $fc_opts
2503 "
2504 ;;
2505 commit-diff,--*)
2506 __gitcomp "--message= --file= --revision= $cmt_opts"
2507 ;;
2508 info,--*)
2509 __gitcomp "--url"
2510 ;;
2511 branch,--*)
2512 __gitcomp "--dry-run --message --tag"
2513 ;;
2514 tag,--*)
2515 __gitcomp "--dry-run --message"
2516 ;;
2517 blame,--*)
2518 __gitcomp "--git-format"
2519 ;;
2520 migrate,--*)
2521 __gitcomp "
2522 --config-dir= --ignore-paths= --minimize
2523 --no-auth-cache --username=
2524 "
2525 ;;
2526 reset,--*)
2527 __gitcomp "--revision= --parent"
2528 ;;
2529 *)
2530 ;;
2531 esac
2532 fi
2533}
2534_git_tag ()
2536{
2537 local i c=1 f=0
2538 while [ $c -lt $cword ]; do
2539 i="${words[c]}"
2540 case "$i" in
2541 -d|-v)
2542 __gitcomp_nl "$(__git_tags)"
2543 return
2544 ;;
2545 -f)
2546 f=1
2547 ;;
2548 esac
2549 ((c++))
2550 done
2551 case "$prev" in
2553 -m|-F)
2554 ;;
2555 -*|tag)
2556 if [ $f = 1 ]; then
2557 __gitcomp_nl "$(__git_tags)"
2558 fi
2559 ;;
2560 *)
2561 __gitcomp_nl "$(__git_refs)"
2562 ;;
2563 esac
2564 case "$cur" in
2566 --*)
2567 __gitcomp "
2568 --list --delete --verify --annotate --message --file
2569 --sign --cleanup --local-user --force --column --sort
2570 --contains --points-at
2571 "
2572 ;;
2573 esac
2574}
2575_git_whatchanged ()
2577{
2578 _git_log
2579}
2580__git_main ()
2582{
2583 local i c=1 command __git_dir
2584 while [ $c -lt $cword ]; do
2586 i="${words[c]}"
2587 case "$i" in
2588 --git-dir=*) __git_dir="${i#--git-dir=}" ;;
2589 --git-dir) ((c++)) ; __git_dir="${words[c]}" ;;
2590 --bare) __git_dir="." ;;
2591 --help) command="help"; break ;;
2592 -c|--work-tree|--namespace) ((c++)) ;;
2593 -*) ;;
2594 *) command="$i"; break ;;
2595 esac
2596 ((c++))
2597 done
2598 if [ -z "$command" ]; then
2600 case "$cur" in
2601 --*) __gitcomp "
2602 --paginate
2603 --no-pager
2604 --git-dir=
2605 --bare
2606 --version
2607 --exec-path
2608 --exec-path=
2609 --html-path
2610 --man-path
2611 --info-path
2612 --work-tree=
2613 --namespace=
2614 --no-replace-objects
2615 --help
2616 "
2617 ;;
2618 *) __git_compute_porcelain_commands
2619 __gitcomp "$__git_porcelain_commands $(__git_aliases)" ;;
2620 esac
2621 return
2622 fi
2623 local completion_func="_git_${command//-/_}"
2625 declare -f $completion_func >/dev/null && $completion_func && return
2626 local expansion=$(__git_aliased_command "$command")
2628 if [ -n "$expansion" ]; then
2629 words[1]=$expansion
2630 completion_func="_git_${expansion//-/_}"
2631 declare -f $completion_func >/dev/null && $completion_func
2632 fi
2633}
2634__gitk_main ()
2636{
2637 __git_has_doubledash && return
2638 local g="$(__gitdir)"
2640 local merge=""
2641 if [ -f "$g/MERGE_HEAD" ]; then
2642 merge="--merge"
2643 fi
2644 case "$cur" in
2645 --*)
2646 __gitcomp "
2647 $__git_log_common_options
2648 $__git_log_gitk_options
2649 $merge
2650 "
2651 return
2652 ;;
2653 esac
2654 __git_complete_revlist
2655}
2656if [[ -n ${ZSH_VERSION-} ]]; then
2658 echo "WARNING: this script is deprecated, please see git-completion.zsh" 1>&2
2659 autoload -U +X compinit && compinit
2661 __gitcomp ()
2663 {
2664 emulate -L zsh
2665 local cur_="${3-$cur}"
2667 case "$cur_" in
2669 --*=)
2670 ;;
2671 *)
2672 local c IFS=$' \t\n'
2673 local -a array
2674 for c in ${=1}; do
2675 c="$c${4-}"
2676 case $c in
2677 --*=*|*.) ;;
2678 *) c="$c " ;;
2679 esac
2680 array[${#array[@]}+1]="$c"
2681 done
2682 compset -P '*[=:]'
2683 compadd -Q -S '' -p "${2-}" -a -- array && _ret=0
2684 ;;
2685 esac
2686 }
2687 __gitcomp_nl ()
2689 {
2690 emulate -L zsh
2691 local IFS=$'\n'
2693 compset -P '*[=:]'
2694 compadd -Q -S "${4- }" -p "${2-}" -- ${=1} && _ret=0
2695 }
2696 __gitcomp_file ()
2698 {
2699 emulate -L zsh
2700 local IFS=$'\n'
2702 compset -P '*[=:]'
2703 compadd -Q -p "${2-}" -f -- ${=1} && _ret=0
2704 }
2705 _git ()
2707 {
2708 local _ret=1 cur cword prev
2709 cur=${words[CURRENT]}
2710 prev=${words[CURRENT-1]}
2711 let cword=CURRENT-1
2712 emulate ksh -c __${service}_main
2713 let _ret && _default && _ret=0
2714 return _ret
2715 }
2716 compdef _git git gitk
2718 return
2719fi
2720__git_func_wrap ()
2722{
2723 local cur words cword prev
2724 _get_comp_words_by_ref -n =: cur words cword prev
2725 $1
2726}
2727# Setup completion for certain functions defined above by setting common
2729# variables and workarounds.
2730# This is NOT a public function; use at your own risk.
2731__git_complete ()
2732{
2733 local wrapper="__git_wrap${2}"
2734 eval "$wrapper () { __git_func_wrap $2 ; }"
2735 complete -o bashdefault -o default -o nospace -F $wrapper $1 2>/dev/null \
2736 || complete -o default -o nospace -F $wrapper $1
2737}
2738# wrapper for backwards compatibility
2740_git ()
2741{
2742 __git_wrap__git_main
2743}
2744# wrapper for backwards compatibility
2746_gitk ()
2747{
2748 __git_wrap__gitk_main
2749}
2750__git_complete git __git_main
2752__git_complete gitk __gitk_main
2753# The following are necessary only for Cygwin, and only are needed
2755# when the user has tab-completed the executable name and consequently
2756# included the '.exe' suffix.
2757#
2758if [ Cygwin = "$(uname -o 2>/dev/null)" ]; then
2759__git_complete git.exe __git_main
2760fi