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