5dc54a340f5b2fd57e48088b5bc2741f25517d67
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 COMPREPLY=($(compgen -P "${2-}" -W "$1" -- "${3-$cur}"))
256 # Tell Bash that compspec generates filenames.
258 compopt -o filenames 2>/dev/null
259}
260__git_index_file_list_filter_compat ()
262{
263 local path
264 while read -r path; do
266 case "$path" in
267 ?*/*) echo "${path%%/*}/" ;;
268 *) echo "$path" ;;
269 esac
270 done
271}
272__git_index_file_list_filter_bash ()
274{
275 local path
276 while read -r path; do
278 case "$path" in
279 ?*/*)
280 # XXX if we append a slash to directory names when using
281 # `compopt -o filenames`, Bash will append another slash.
282 # This is pretty stupid, and this the reason why we have to
283 # define a compatible version for this function.
284 echo "${path%%/*}" ;;
285 *)
286 echo "$path" ;;
287 esac
288 done
289}
290# Process path list returned by "ls-files" and "diff-index --name-only"
292# commands, in order to list only file names relative to a specified
293# directory, and append a slash to directory names.
294__git_index_file_list_filter ()
295{
296 # Default to Bash >= 4.x
297 __git_index_file_list_filter_bash
298}
299# Execute git ls-files, returning paths relative to the directory
301# specified in the first argument, and using the options specified in
302# the second argument.
303__git_ls_files_helper ()
304{
305 (
306 test -n "${CDPATH+set}" && unset CDPATH
307 # NOTE: $2 is not quoted in order to support multiple options
308 cd "$1" && git ls-files --exclude-standard $2
309 ) 2>/dev/null
310}
311# Execute git diff-index, returning paths relative to the directory
314# specified in the first argument, and using the tree object id
315# specified in the second argument.
316__git_diff_index_helper ()
317{
318 (
319 test -n "${CDPATH+set}" && unset CDPATH
320 cd "$1" && git diff-index --name-only --relative "$2"
321 ) 2>/dev/null
322}
323# __git_index_files accepts 1 or 2 arguments:
325# 1: Options to pass to ls-files (required).
326# Supported options are --cached, --modified, --deleted, --others,
327# and --directory.
328# 2: A directory path (optional).
329# If provided, only files within the specified directory are listed.
330# Sub directories are never recursed. Path must have a trailing
331# slash.
332__git_index_files ()
333{
334 local dir="$(__gitdir)" root="${2-.}"
335 if [ -d "$dir" ]; then
337 __git_ls_files_helper "$root" "$1" | __git_index_file_list_filter |
338 sort | uniq
339 fi
340}
341# __git_diff_index_files accepts 1 or 2 arguments:
343# 1) The id of a tree object.
344# 2) A directory path (optional).
345# If provided, only files within the specified directory are listed.
346# Sub directories are never recursed. Path must have a trailing
347# slash.
348__git_diff_index_files ()
349{
350 local dir="$(__gitdir)" root="${2-.}"
351 if [ -d "$dir" ]; then
353 __git_diff_index_helper "$root" "$1" | __git_index_file_list_filter |
354 sort | uniq
355 fi
356}
357__git_heads ()
359{
360 local dir="$(__gitdir)"
361 if [ -d "$dir" ]; then
362 git --git-dir="$dir" for-each-ref --format='%(refname:short)' \
363 refs/heads
364 return
365 fi
366}
367__git_tags ()
369{
370 local dir="$(__gitdir)"
371 if [ -d "$dir" ]; then
372 git --git-dir="$dir" for-each-ref --format='%(refname:short)' \
373 refs/tags
374 return
375 fi
376}
377# __git_refs accepts 0, 1 (to pass to __gitdir), or 2 arguments
379# presence of 2nd argument means use the guess heuristic employed
380# by checkout for tracking branches
381__git_refs ()
382{
383 local i hash dir="$(__gitdir "${1-}")" track="${2-}"
384 local format refs
385 if [ -d "$dir" ]; then
386 case "$cur" in
387 refs|refs/*)
388 format="refname"
389 refs="${cur%/*}"
390 track=""
391 ;;
392 *)
393 for i in HEAD FETCH_HEAD ORIG_HEAD MERGE_HEAD; do
394 if [ -e "$dir/$i" ]; then echo $i; fi
395 done
396 format="refname:short"
397 refs="refs/tags refs/heads refs/remotes"
398 ;;
399 esac
400 git --git-dir="$dir" for-each-ref --format="%($format)" \
401 $refs
402 if [ -n "$track" ]; then
403 # employ the heuristic used by git checkout
404 # Try to find a remote branch that matches the completion word
405 # but only output if the branch name is unique
406 local ref entry
407 git --git-dir="$dir" for-each-ref --shell --format="ref=%(refname:short)" \
408 "refs/remotes/" | \
409 while read -r entry; do
410 eval "$entry"
411 ref="${ref#*/}"
412 if [[ "$ref" == "$cur"* ]]; then
413 echo "$ref"
414 fi
415 done | sort | uniq -u
416 fi
417 return
418 fi
419 case "$cur" in
420 refs|refs/*)
421 git ls-remote "$dir" "$cur*" 2>/dev/null | \
422 while read -r hash i; do
423 case "$i" in
424 *^{}) ;;
425 *) echo "$i" ;;
426 esac
427 done
428 ;;
429 *)
430 git ls-remote "$dir" HEAD ORIG_HEAD 'refs/tags/*' 'refs/heads/*' 'refs/remotes/*' 2>/dev/null | \
431 while read -r hash i; do
432 case "$i" in
433 *^{}) ;;
434 refs/*) echo "${i#refs/*/}" ;;
435 *) echo "$i" ;;
436 esac
437 done
438 ;;
439 esac
440}
441# __git_refs2 requires 1 argument (to pass to __git_refs)
443__git_refs2 ()
444{
445 local i
446 for i in $(__git_refs "$1"); do
447 echo "$i:$i"
448 done
449}
450# __git_refs_remotes requires 1 argument (to pass to ls-remote)
452__git_refs_remotes ()
453{
454 local i hash
455 git ls-remote "$1" 'refs/heads/*' 2>/dev/null | \
456 while read -r hash i; do
457 echo "$i:refs/remotes/$1/${i#refs/heads/}"
458 done
459}
460__git_remotes ()
462{
463 local i IFS=$'\n' d="$(__gitdir)"
464 test -d "$d/remotes" && ls -1 "$d/remotes"
465 for i in $(git --git-dir="$d" config --get-regexp 'remote\..*\.url' 2>/dev/null); do
466 i="${i#remote.}"
467 echo "${i/.url*/}"
468 done
469}
470__git_list_merge_strategies ()
472{
473 git merge -s help 2>&1 |
474 sed -n -e '/[Aa]vailable strategies are: /,/^$/{
475 s/\.$//
476 s/.*://
477 s/^[ ]*//
478 s/[ ]*$//
479 p
480 }'
481}
482__git_merge_strategies=
484# 'git merge -s help' (and thus detection of the merge strategy
485# list) fails, unfortunately, if run outside of any git working
486# tree. __git_merge_strategies is set to the empty string in
487# that case, and the detection will be repeated the next time it
488# is needed.
489__git_compute_merge_strategies ()
490{
491 test -n "$__git_merge_strategies" ||
492 __git_merge_strategies=$(__git_list_merge_strategies)
493}
494__git_complete_revlist_file ()
496{
497 local pfx ls ref cur_="$cur"
498 case "$cur_" in
499 *..?*:*)
500 return
501 ;;
502 ?*:*)
503 ref="${cur_%%:*}"
504 cur_="${cur_#*:}"
505 case "$cur_" in
506 ?*/*)
507 pfx="${cur_%/*}"
508 cur_="${cur_##*/}"
509 ls="$ref:$pfx"
510 pfx="$pfx/"
511 ;;
512 *)
513 ls="$ref"
514 ;;
515 esac
516 case "$COMP_WORDBREAKS" in
518 *:*) : great ;;
519 *) pfx="$ref:$pfx" ;;
520 esac
521 __gitcomp_nl "$(git --git-dir="$(__gitdir)" ls-tree "$ls" 2>/dev/null \
523 | sed '/^100... blob /{
524 s,^.* ,,
525 s,$, ,
526 }
527 /^120000 blob /{
528 s,^.* ,,
529 s,$, ,
530 }
531 /^040000 tree /{
532 s,^.* ,,
533 s,$,/,
534 }
535 s/^.* //')" \
536 "$pfx" "$cur_" ""
537 ;;
538 *...*)
539 pfx="${cur_%...*}..."
540 cur_="${cur_#*...}"
541 __gitcomp_nl "$(__git_refs)" "$pfx" "$cur_"
542 ;;
543 *..*)
544 pfx="${cur_%..*}.."
545 cur_="${cur_#*..}"
546 __gitcomp_nl "$(__git_refs)" "$pfx" "$cur_"
547 ;;
548 *)
549 __gitcomp_nl "$(__git_refs)"
550 ;;
551 esac
552}
553# __git_complete_index_file requires 1 argument: the options to pass to
556# ls-file
557__git_complete_index_file ()
558{
559 local pfx cur_="$cur"
560 case "$cur_" in
562 ?*/*)
563 pfx="${cur_%/*}"
564 cur_="${cur_##*/}"
565 pfx="${pfx}/"
566 __gitcomp_file "$(__git_index_files "$1" "$pfx")" "$pfx" "$cur_"
568 ;;
569 *)
570 __gitcomp_file "$(__git_index_files "$1")" "" "$cur_"
571 ;;
572 esac
573}
574# __git_complete_diff_index_file requires 1 argument: the id of a tree
576# object
577__git_complete_diff_index_file ()
578{
579 local pfx cur_="$cur"
580 case "$cur_" in
582 ?*/*)
583 pfx="${cur_%/*}"
584 cur_="${cur_##*/}"
585 pfx="${pfx}/"
586 __gitcomp_file "$(__git_diff_index_files "$1" "$pfx")" "$pfx" "$cur_"
588 ;;
589 *)
590 __gitcomp_file "$(__git_diff_index_files "$1")" "" "$cur_"
591 ;;
592 esac
593}
594__git_complete_file ()
596{
597 __git_complete_revlist_file
598}
599__git_complete_revlist ()
601{
602 __git_complete_revlist_file
603}
604__git_complete_remote_or_refspec ()
606{
607 local cur_="$cur" cmd="${words[1]}"
608 local i c=2 remote="" pfx="" lhs=1 no_complete_refspec=0
609 if [ "$cmd" = "remote" ]; then
610 ((c++))
611 fi
612 while [ $c -lt $cword ]; do
613 i="${words[c]}"
614 case "$i" in
615 --mirror) [ "$cmd" = "push" ] && no_complete_refspec=1 ;;
616 --all)
617 case "$cmd" in
618 push) no_complete_refspec=1 ;;
619 fetch)
620 return
621 ;;
622 *) ;;
623 esac
624 ;;
625 -*) ;;
626 *) remote="$i"; break ;;
627 esac
628 ((c++))
629 done
630 if [ -z "$remote" ]; then
631 __gitcomp_nl "$(__git_remotes)"
632 return
633 fi
634 if [ $no_complete_refspec = 1 ]; then
635 return
636 fi
637 [ "$remote" = "." ] && remote=
638 case "$cur_" in
639 *:*)
640 case "$COMP_WORDBREAKS" in
641 *:*) : great ;;
642 *) pfx="${cur_%%:*}:" ;;
643 esac
644 cur_="${cur_#*:}"
645 lhs=0
646 ;;
647 +*)
648 pfx="+"
649 cur_="${cur_#+}"
650 ;;
651 esac
652 case "$cmd" in
653 fetch)
654 if [ $lhs = 1 ]; then
655 __gitcomp_nl "$(__git_refs2 "$remote")" "$pfx" "$cur_"
656 else
657 __gitcomp_nl "$(__git_refs)" "$pfx" "$cur_"
658 fi
659 ;;
660 pull|remote)
661 if [ $lhs = 1 ]; then
662 __gitcomp_nl "$(__git_refs "$remote")" "$pfx" "$cur_"
663 else
664 __gitcomp_nl "$(__git_refs)" "$pfx" "$cur_"
665 fi
666 ;;
667 push)
668 if [ $lhs = 1 ]; then
669 __gitcomp_nl "$(__git_refs)" "$pfx" "$cur_"
670 else
671 __gitcomp_nl "$(__git_refs "$remote")" "$pfx" "$cur_"
672 fi
673 ;;
674 esac
675}
676__git_complete_strategy ()
678{
679 __git_compute_merge_strategies
680 case "$prev" in
681 -s|--strategy)
682 __gitcomp "$__git_merge_strategies"
683 return 0
684 esac
685 case "$cur" in
686 --strategy=*)
687 __gitcomp "$__git_merge_strategies" "" "${cur##--strategy=}"
688 return 0
689 ;;
690 esac
691 return 1
692}
693__git_commands () {
695 if test -n "${GIT_TESTING_COMMAND_COMPLETION:-}"
696 then
697 printf "%s" "${GIT_TESTING_COMMAND_COMPLETION}"
698 else
699 git help -a|egrep '^ [a-zA-Z0-9]'
700 fi
701}
702__git_list_all_commands ()
704{
705 local i IFS=" "$'\n'
706 for i in $(__git_commands)
707 do
708 case $i in
709 *--*) : helper pattern;;
710 *) echo $i;;
711 esac
712 done
713}
714__git_all_commands=
716__git_compute_all_commands ()
717{
718 test -n "$__git_all_commands" ||
719 __git_all_commands=$(__git_list_all_commands)
720}
721__git_list_porcelain_commands ()
723{
724 local i IFS=" "$'\n'
725 __git_compute_all_commands
726 for i in $__git_all_commands
727 do
728 case $i in
729 *--*) : helper pattern;;
730 applymbox) : ask gittus;;
731 applypatch) : ask gittus;;
732 archimport) : import;;
733 cat-file) : plumbing;;
734 check-attr) : plumbing;;
735 check-ignore) : plumbing;;
736 check-ref-format) : plumbing;;
737 checkout-index) : plumbing;;
738 commit-tree) : plumbing;;
739 count-objects) : infrequent;;
740 credential-cache) : credentials helper;;
741 credential-store) : credentials helper;;
742 cvsexportcommit) : export;;
743 cvsimport) : import;;
744 cvsserver) : daemon;;
745 daemon) : daemon;;
746 diff-files) : plumbing;;
747 diff-index) : plumbing;;
748 diff-tree) : plumbing;;
749 fast-import) : import;;
750 fast-export) : export;;
751 fsck-objects) : plumbing;;
752 fetch-pack) : plumbing;;
753 fmt-merge-msg) : plumbing;;
754 for-each-ref) : plumbing;;
755 hash-object) : plumbing;;
756 http-*) : transport;;
757 index-pack) : plumbing;;
758 init-db) : deprecated;;
759 local-fetch) : plumbing;;
760 lost-found) : infrequent;;
761 ls-files) : plumbing;;
762 ls-remote) : plumbing;;
763 ls-tree) : plumbing;;
764 mailinfo) : plumbing;;
765 mailsplit) : plumbing;;
766 merge-*) : plumbing;;
767 mktree) : plumbing;;
768 mktag) : plumbing;;
769 pack-objects) : plumbing;;
770 pack-redundant) : plumbing;;
771 pack-refs) : plumbing;;
772 parse-remote) : plumbing;;
773 patch-id) : plumbing;;
774 peek-remote) : plumbing;;
775 prune) : plumbing;;
776 prune-packed) : plumbing;;
777 quiltimport) : import;;
778 read-tree) : plumbing;;
779 receive-pack) : plumbing;;
780 remote-*) : transport;;
781 repo-config) : deprecated;;
782 rerere) : plumbing;;
783 rev-list) : plumbing;;
784 rev-parse) : plumbing;;
785 runstatus) : plumbing;;
786 sh-setup) : internal;;
787 shell) : daemon;;
788 show-ref) : plumbing;;
789 send-pack) : plumbing;;
790 show-index) : plumbing;;
791 ssh-*) : transport;;
792 stripspace) : plumbing;;
793 symbolic-ref) : plumbing;;
794 tar-tree) : deprecated;;
795 unpack-file) : plumbing;;
796 unpack-objects) : plumbing;;
797 update-index) : plumbing;;
798 update-ref) : plumbing;;
799 update-server-info) : daemon;;
800 upload-archive) : plumbing;;
801 upload-pack) : plumbing;;
802 write-tree) : plumbing;;
803 var) : infrequent;;
804 verify-pack) : infrequent;;
805 verify-tag) : plumbing;;
806 *) echo $i;;
807 esac
808 done
809}
810__git_porcelain_commands=
812__git_compute_porcelain_commands ()
813{
814 __git_compute_all_commands
815 test -n "$__git_porcelain_commands" ||
816 __git_porcelain_commands=$(__git_list_porcelain_commands)
817}
818__git_pretty_aliases ()
820{
821 local i IFS=$'\n'
822 for i in $(git --git-dir="$(__gitdir)" config --get-regexp "pretty\..*" 2>/dev/null); do
823 case "$i" in
824 pretty.*)
825 i="${i#pretty.}"
826 echo "${i/ */}"
827 ;;
828 esac
829 done
830}
831__git_aliases ()
833{
834 local i IFS=$'\n'
835 for i in $(git --git-dir="$(__gitdir)" config --get-regexp "alias\..*" 2>/dev/null); do
836 case "$i" in
837 alias.*)
838 i="${i#alias.}"
839 echo "${i/ */}"
840 ;;
841 esac
842 done
843}
844# __git_aliased_command requires 1 argument
846__git_aliased_command ()
847{
848 local word cmdline=$(git --git-dir="$(__gitdir)" \
849 config --get "alias.$1")
850 for word in $cmdline; do
851 case "$word" in
852 \!gitk|gitk)
853 echo "gitk"
854 return
855 ;;
856 \!*) : shell command alias ;;
857 -*) : option ;;
858 *=*) : setting env ;;
859 git) : git itself ;;
860 *)
861 echo "$word"
862 return
863 esac
864 done
865}
866# __git_find_on_cmdline requires 1 argument
868__git_find_on_cmdline ()
869{
870 local word subcommand c=1
871 while [ $c -lt $cword ]; do
872 word="${words[c]}"
873 for subcommand in $1; do
874 if [ "$subcommand" = "$word" ]; then
875 echo "$subcommand"
876 return
877 fi
878 done
879 ((c++))
880 done
881}
882__git_has_doubledash ()
884{
885 local c=1
886 while [ $c -lt $cword ]; do
887 if [ "--" = "${words[c]}" ]; then
888 return 0
889 fi
890 ((c++))
891 done
892 return 1
893}
894# Try to count non option arguments passed on the command line for the
896# specified git command.
897# When options are used, it is necessary to use the special -- option to
898# tell the implementation were non option arguments begin.
899# XXX this can not be improved, since options can appear everywhere, as
900# an example:
901# git mv x -n y
902#
903# __git_count_arguments requires 1 argument: the git command executed.
904__git_count_arguments ()
905{
906 local word i c=0
907 # Skip "git" (first argument)
909 for ((i=1; i < ${#words[@]}; i++)); do
910 word="${words[i]}"
911 case "$word" in
913 --)
914 # Good; we can assume that the following are only non
915 # option arguments.
916 ((c = 0))
917 ;;
918 "$1")
919 # Skip the specified git command and discard git
920 # main options
921 ((c = 0))
922 ;;
923 ?*)
924 ((c++))
925 ;;
926 esac
927 done
928 printf "%d" $c
930}
931__git_whitespacelist="nowarn warn error error-all fix"
933_git_am ()
935{
936 local dir="$(__gitdir)"
937 if [ -d "$dir"/rebase-apply ]; then
938 __gitcomp "--skip --continue --resolved --abort"
939 return
940 fi
941 case "$cur" in
942 --whitespace=*)
943 __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
944 return
945 ;;
946 --*)
947 __gitcomp "
948 --3way --committer-date-is-author-date --ignore-date
949 --ignore-whitespace --ignore-space-change
950 --interactive --keep --no-utf8 --signoff --utf8
951 --whitespace= --scissors
952 "
953 return
954 esac
955}
956_git_apply ()
958{
959 case "$cur" in
960 --whitespace=*)
961 __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
962 return
963 ;;
964 --*)
965 __gitcomp "
966 --stat --numstat --summary --check --index
967 --cached --index-info --reverse --reject --unidiff-zero
968 --apply --no-add --exclude=
969 --ignore-whitespace --ignore-space-change
970 --whitespace= --inaccurate-eof --verbose
971 "
972 return
973 esac
974}
975_git_add ()
977{
978 case "$cur" in
979 --*)
980 __gitcomp "
981 --interactive --refresh --patch --update --dry-run
982 --ignore-errors --intent-to-add
983 "
984 return
985 esac
986 # XXX should we check for --update and --all options ?
988 __git_complete_index_file "--others --modified"
989}
990_git_archive ()
992{
993 case "$cur" in
994 --format=*)
995 __gitcomp "$(git archive --list)" "" "${cur##--format=}"
996 return
997 ;;
998 --remote=*)
999 __gitcomp_nl "$(__git_remotes)" "" "${cur##--remote=}"
1000 return
1001 ;;
1002 --*)
1003 __gitcomp "
1004 --format= --list --verbose
1005 --prefix= --remote= --exec=
1006 "
1007 return
1008 ;;
1009 esac
1010 __git_complete_file
1011}
1012_git_bisect ()
1014{
1015 __git_has_doubledash && return
1016 local subcommands="start bad good skip reset visualize replay log run"
1018 local subcommand="$(__git_find_on_cmdline "$subcommands")"
1019 if [ -z "$subcommand" ]; then
1020 if [ -f "$(__gitdir)"/BISECT_START ]; then
1021 __gitcomp "$subcommands"
1022 else
1023 __gitcomp "replay start"
1024 fi
1025 return
1026 fi
1027 case "$subcommand" in
1029 bad|good|reset|skip|start)
1030 __gitcomp_nl "$(__git_refs)"
1031 ;;
1032 *)
1033 ;;
1034 esac
1035}
1036_git_branch ()
1038{
1039 local i c=1 only_local_ref="n" has_r="n"
1040 while [ $c -lt $cword ]; do
1042 i="${words[c]}"
1043 case "$i" in
1044 -d|-m) only_local_ref="y" ;;
1045 -r) has_r="y" ;;
1046 esac
1047 ((c++))
1048 done
1049 case "$cur" in
1051 --set-upstream-to=*)
1052 __gitcomp "$(__git_refs)" "" "${cur##--set-upstream-to=}"
1053 ;;
1054 --*)
1055 __gitcomp "
1056 --color --no-color --verbose --abbrev= --no-abbrev
1057 --track --no-track --contains --merged --no-merged
1058 --set-upstream-to= --edit-description --list
1059 --unset-upstream
1060 "
1061 ;;
1062 *)
1063 if [ $only_local_ref = "y" -a $has_r = "n" ]; then
1064 __gitcomp_nl "$(__git_heads)"
1065 else
1066 __gitcomp_nl "$(__git_refs)"
1067 fi
1068 ;;
1069 esac
1070}
1071_git_bundle ()
1073{
1074 local cmd="${words[2]}"
1075 case "$cword" in
1076 2)
1077 __gitcomp "create list-heads verify unbundle"
1078 ;;
1079 3)
1080 # looking for a file
1081 ;;
1082 *)
1083 case "$cmd" in
1084 create)
1085 __git_complete_revlist
1086 ;;
1087 esac
1088 ;;
1089 esac
1090}
1091_git_checkout ()
1093{
1094 __git_has_doubledash && return
1095 case "$cur" in
1097 --conflict=*)
1098 __gitcomp "diff3 merge" "" "${cur##--conflict=}"
1099 ;;
1100 --*)
1101 __gitcomp "
1102 --quiet --ours --theirs --track --no-track --merge
1103 --conflict= --orphan --patch
1104 "
1105 ;;
1106 *)
1107 # check if --track, --no-track, or --no-guess was specified
1108 # if so, disable DWIM mode
1109 local flags="--track --no-track --no-guess" track=1
1110 if [ -n "$(__git_find_on_cmdline "$flags")" ]; then
1111 track=''
1112 fi
1113 __gitcomp_nl "$(__git_refs '' $track)"
1114 ;;
1115 esac
1116}
1117_git_cherry ()
1119{
1120 __gitcomp "$(__git_refs)"
1121}
1122_git_cherry_pick ()
1124{
1125 local dir="$(__gitdir)"
1126 if [ -f "$dir"/CHERRY_PICK_HEAD ]; then
1127 __gitcomp "--continue --quit --abort"
1128 return
1129 fi
1130 case "$cur" in
1131 --*)
1132 __gitcomp "--edit --no-commit --signoff --strategy= --mainline"
1133 ;;
1134 *)
1135 __gitcomp_nl "$(__git_refs)"
1136 ;;
1137 esac
1138}
1139_git_clean ()
1141{
1142 case "$cur" in
1143 --*)
1144 __gitcomp "--dry-run --quiet"
1145 return
1146 ;;
1147 esac
1148 # XXX should we check for -x option ?
1150 __git_complete_index_file "--others"
1151}
1152_git_clone ()
1154{
1155 case "$cur" in
1156 --*)
1157 __gitcomp "
1158 --local
1159 --no-hardlinks
1160 --shared
1161 --reference
1162 --quiet
1163 --no-checkout
1164 --bare
1165 --mirror
1166 --origin
1167 --upload-pack
1168 --template=
1169 --depth
1170 --single-branch
1171 --branch
1172 "
1173 return
1174 ;;
1175 esac
1176}
1177_git_commit ()
1179{
1180 case "$prev" in
1181 -c|-C)
1182 __gitcomp_nl "$(__git_refs)" "" "${cur}"
1183 return
1184 ;;
1185 esac
1186 case "$cur" in
1188 --cleanup=*)
1189 __gitcomp "default strip verbatim whitespace
1190 " "" "${cur##--cleanup=}"
1191 return
1192 ;;
1193 --reuse-message=*|--reedit-message=*|\
1194 --fixup=*|--squash=*)
1195 __gitcomp_nl "$(__git_refs)" "" "${cur#*=}"
1196 return
1197 ;;
1198 --untracked-files=*)
1199 __gitcomp "all no normal" "" "${cur##--untracked-files=}"
1200 return
1201 ;;
1202 --*)
1203 __gitcomp "
1204 --all --author= --signoff --verify --no-verify
1205 --edit --no-edit
1206 --amend --include --only --interactive
1207 --dry-run --reuse-message= --reedit-message=
1208 --reset-author --file= --message= --template=
1209 --cleanup= --untracked-files --untracked-files=
1210 --verbose --quiet --fixup= --squash=
1211 "
1212 return
1213 esac
1214 if git rev-parse --verify --quiet HEAD >/dev/null; then
1216 __git_complete_diff_index_file "HEAD"
1217 else
1218 # This is the first commit
1219 __git_complete_index_file "--cached"
1220 fi
1221}
1222_git_describe ()
1224{
1225 case "$cur" in
1226 --*)
1227 __gitcomp "
1228 --all --tags --contains --abbrev= --candidates=
1229 --exact-match --debug --long --match --always
1230 "
1231 return
1232 esac
1233 __gitcomp_nl "$(__git_refs)"
1234}
1235__git_diff_algorithms="myers minimal patience histogram"
1237__git_diff_common_options="--stat --numstat --shortstat --summary
1239 --patch-with-stat --name-only --name-status --color
1240 --no-color --color-words --no-renames --check
1241 --full-index --binary --abbrev --diff-filter=
1242 --find-copies-harder
1243 --text --ignore-space-at-eol --ignore-space-change
1244 --ignore-all-space --exit-code --quiet --ext-diff
1245 --no-ext-diff
1246 --no-prefix --src-prefix= --dst-prefix=
1247 --inter-hunk-context=
1248 --patience --histogram --minimal
1249 --raw
1250 --dirstat --dirstat= --dirstat-by-file
1251 --dirstat-by-file= --cumulative
1252 --diff-algorithm=
1253"
1254_git_diff ()
1256{
1257 __git_has_doubledash && return
1258 case "$cur" in
1260 --diff-algorithm=*)
1261 __gitcomp "$__git_diff_algorithms" "" "${cur##--diff-algorithm=}"
1262 return
1263 ;;
1264 --*)
1265 __gitcomp "--cached --staged --pickaxe-all --pickaxe-regex
1266 --base --ours --theirs --no-index
1267 $__git_diff_common_options
1268 "
1269 return
1270 ;;
1271 esac
1272 __git_complete_revlist_file
1273}
1274__git_mergetools_common="diffuse ecmerge emerge kdiff3 meld opendiff
1276 tkdiff vimdiff gvimdiff xxdiff araxis p4merge bc3 codecompare
1277"
1278_git_difftool ()
1280{
1281 __git_has_doubledash && return
1282 case "$cur" in
1284 --tool=*)
1285 __gitcomp "$__git_mergetools_common kompare" "" "${cur##--tool=}"
1286 return
1287 ;;
1288 --*)
1289 __gitcomp "--cached --staged --pickaxe-all --pickaxe-regex
1290 --base --ours --theirs
1291 --no-renames --diff-filter= --find-copies-harder
1292 --relative --ignore-submodules
1293 --tool="
1294 return
1295 ;;
1296 esac
1297 __git_complete_file
1298}
1299__git_fetch_options="
1301 --quiet --verbose --append --upload-pack --force --keep --depth=
1302 --tags --no-tags --all --prune --dry-run
1303"
1304_git_fetch ()
1306{
1307 case "$cur" in
1308 --*)
1309 __gitcomp "$__git_fetch_options"
1310 return
1311 ;;
1312 esac
1313 __git_complete_remote_or_refspec
1314}
1315__git_format_patch_options="
1317 --stdout --attach --no-attach --thread --thread= --no-thread
1318 --numbered --start-number --numbered-files --keep-subject --signoff
1319 --signature --no-signature --in-reply-to= --cc= --full-index --binary
1320 --not --all --cover-letter --no-prefix --src-prefix= --dst-prefix=
1321 --inline --suffix= --ignore-if-in-upstream --subject-prefix=
1322 --output-directory --reroll-count --to= --quiet --notes
1323"
1324_git_format_patch ()
1326{
1327 case "$cur" in
1328 --thread=*)
1329 __gitcomp "
1330 deep shallow
1331 " "" "${cur##--thread=}"
1332 return
1333 ;;
1334 --*)
1335 __gitcomp "$__git_format_patch_options"
1336 return
1337 ;;
1338 esac
1339 __git_complete_revlist
1340}
1341_git_fsck ()
1343{
1344 case "$cur" in
1345 --*)
1346 __gitcomp "
1347 --tags --root --unreachable --cache --no-reflogs --full
1348 --strict --verbose --lost-found
1349 "
1350 return
1351 ;;
1352 esac
1353}
1354_git_gc ()
1356{
1357 case "$cur" in
1358 --*)
1359 __gitcomp "--prune --aggressive"
1360 return
1361 ;;
1362 esac
1363}
1364_git_gitk ()
1366{
1367 _gitk
1368}
1369__git_match_ctag() {
1371 awk "/^${1////\\/}/ { print \$1 }" "$2"
1372}
1373_git_grep ()
1375{
1376 __git_has_doubledash && return
1377 case "$cur" in
1379 --*)
1380 __gitcomp "
1381 --cached
1382 --text --ignore-case --word-regexp --invert-match
1383 --full-name --line-number
1384 --extended-regexp --basic-regexp --fixed-strings
1385 --perl-regexp
1386 --files-with-matches --name-only
1387 --files-without-match
1388 --max-depth
1389 --count
1390 --and --or --not --all-match
1391 "
1392 return
1393 ;;
1394 esac
1395 case "$cword,$prev" in
1397 2,*|*,-*)
1398 if test -r tags; then
1399 __gitcomp_nl "$(__git_match_ctag "$cur" tags)"
1400 return
1401 fi
1402 ;;
1403 esac
1404 __gitcomp_nl "$(__git_refs)"
1406}
1407_git_help ()
1409{
1410 case "$cur" in
1411 --*)
1412 __gitcomp "--all --info --man --web"
1413 return
1414 ;;
1415 esac
1416 __git_compute_all_commands
1417 __gitcomp "$__git_all_commands $(__git_aliases)
1418 attributes cli core-tutorial cvs-migration
1419 diffcore gitk glossary hooks ignore modules
1420 namespaces repository-layout tutorial tutorial-2
1421 workflows
1422 "
1423}
1424_git_init ()
1426{
1427 case "$cur" in
1428 --shared=*)
1429 __gitcomp "
1430 false true umask group all world everybody
1431 " "" "${cur##--shared=}"
1432 return
1433 ;;
1434 --*)
1435 __gitcomp "--quiet --bare --template= --shared --shared="
1436 return
1437 ;;
1438 esac
1439}
1440_git_ls_files ()
1442{
1443 case "$cur" in
1444 --*)
1445 __gitcomp "--cached --deleted --modified --others --ignored
1446 --stage --directory --no-empty-directory --unmerged
1447 --killed --exclude= --exclude-from=
1448 --exclude-per-directory= --exclude-standard
1449 --error-unmatch --with-tree= --full-name
1450 --abbrev --ignored --exclude-per-directory
1451 "
1452 return
1453 ;;
1454 esac
1455 # XXX ignore options like --modified and always suggest all cached
1457 # files.
1458 __git_complete_index_file "--cached"
1459}
1460_git_ls_remote ()
1462{
1463 __gitcomp_nl "$(__git_remotes)"
1464}
1465_git_ls_tree ()
1467{
1468 __git_complete_file
1469}
1470# Options that go well for log, shortlog and gitk
1472__git_log_common_options="
1473 --not --all
1474 --branches --tags --remotes
1475 --first-parent --merges --no-merges
1476 --max-count=
1477 --max-age= --since= --after=
1478 --min-age= --until= --before=
1479 --min-parents= --max-parents=
1480 --no-min-parents --no-max-parents
1481"
1482# Options that go well for log and gitk (not shortlog)
1483__git_log_gitk_options="
1484 --dense --sparse --full-history
1485 --simplify-merges --simplify-by-decoration
1486 --left-right --notes --no-notes
1487"
1488# Options that go well for log and shortlog (not gitk)
1489__git_log_shortlog_options="
1490 --author= --committer= --grep=
1491 --all-match
1492"
1493__git_log_pretty_formats="oneline short medium full fuller email raw format:"
1495__git_log_date_formats="relative iso8601 rfc2822 short local default raw"
1496_git_log ()
1498{
1499 __git_has_doubledash && return
1500 local g="$(git rev-parse --git-dir 2>/dev/null)"
1502 local merge=""
1503 if [ -f "$g/MERGE_HEAD" ]; then
1504 merge="--merge"
1505 fi
1506 case "$cur" in
1507 --pretty=*|--format=*)
1508 __gitcomp "$__git_log_pretty_formats $(__git_pretty_aliases)
1509 " "" "${cur#*=}"
1510 return
1511 ;;
1512 --date=*)
1513 __gitcomp "$__git_log_date_formats" "" "${cur##--date=}"
1514 return
1515 ;;
1516 --decorate=*)
1517 __gitcomp "long short" "" "${cur##--decorate=}"
1518 return
1519 ;;
1520 --*)
1521 __gitcomp "
1522 $__git_log_common_options
1523 $__git_log_shortlog_options
1524 $__git_log_gitk_options
1525 --root --topo-order --date-order --reverse
1526 --follow --full-diff
1527 --abbrev-commit --abbrev=
1528 --relative-date --date=
1529 --pretty= --format= --oneline
1530 --cherry-pick
1531 --graph
1532 --decorate --decorate=
1533 --walk-reflogs
1534 --parents --children
1535 $merge
1536 $__git_diff_common_options
1537 --pickaxe-all --pickaxe-regex
1538 "
1539 return
1540 ;;
1541 esac
1542 __git_complete_revlist
1543}
1544__git_merge_options="
1546 --no-commit --no-stat --log --no-log --squash --strategy
1547 --commit --stat --no-squash --ff --no-ff --ff-only --edit --no-edit
1548"
1549_git_merge ()
1551{
1552 __git_complete_strategy && return
1553 case "$cur" in
1555 --*)
1556 __gitcomp "$__git_merge_options"
1557 return
1558 esac
1559 __gitcomp_nl "$(__git_refs)"
1560}
1561_git_mergetool ()
1563{
1564 case "$cur" in
1565 --tool=*)
1566 __gitcomp "$__git_mergetools_common tortoisemerge" "" "${cur##--tool=}"
1567 return
1568 ;;
1569 --*)
1570 __gitcomp "--tool="
1571 return
1572 ;;
1573 esac
1574}
1575_git_merge_base ()
1577{
1578 __gitcomp_nl "$(__git_refs)"
1579}
1580_git_mv ()
1582{
1583 case "$cur" in
1584 --*)
1585 __gitcomp "--dry-run"
1586 return
1587 ;;
1588 esac
1589 if [ $(__git_count_arguments "mv") -gt 0 ]; then
1591 # We need to show both cached and untracked files (including
1592 # empty directories) since this may not be the last argument.
1593 __git_complete_index_file "--cached --others --directory"
1594 else
1595 __git_complete_index_file "--cached"
1596 fi
1597}
1598_git_name_rev ()
1600{
1601 __gitcomp "--tags --all --stdin"
1602}
1603_git_notes ()
1605{
1606 local subcommands='add append copy edit list prune remove show'
1607 local subcommand="$(__git_find_on_cmdline "$subcommands")"
1608 case "$subcommand,$cur" in
1610 ,--*)
1611 __gitcomp '--ref'
1612 ;;
1613 ,*)
1614 case "$prev" in
1615 --ref)
1616 __gitcomp_nl "$(__git_refs)"
1617 ;;
1618 *)
1619 __gitcomp "$subcommands --ref"
1620 ;;
1621 esac
1622 ;;
1623 add,--reuse-message=*|append,--reuse-message=*|\
1624 add,--reedit-message=*|append,--reedit-message=*)
1625 __gitcomp_nl "$(__git_refs)" "" "${cur#*=}"
1626 ;;
1627 add,--*|append,--*)
1628 __gitcomp '--file= --message= --reedit-message=
1629 --reuse-message='
1630 ;;
1631 copy,--*)
1632 __gitcomp '--stdin'
1633 ;;
1634 prune,--*)
1635 __gitcomp '--dry-run --verbose'
1636 ;;
1637 prune,*)
1638 ;;
1639 *)
1640 case "$prev" in
1641 -m|-F)
1642 ;;
1643 *)
1644 __gitcomp_nl "$(__git_refs)"
1645 ;;
1646 esac
1647 ;;
1648 esac
1649}
1650_git_pull ()
1652{
1653 __git_complete_strategy && return
1654 case "$cur" in
1656 --*)
1657 __gitcomp "
1658 --rebase --no-rebase
1659 $__git_merge_options
1660 $__git_fetch_options
1661 "
1662 return
1663 ;;
1664 esac
1665 __git_complete_remote_or_refspec
1666}
1667_git_push ()
1669{
1670 case "$prev" in
1671 --repo)
1672 __gitcomp_nl "$(__git_remotes)"
1673 return
1674 esac
1675 case "$cur" in
1676 --repo=*)
1677 __gitcomp_nl "$(__git_remotes)" "" "${cur##--repo=}"
1678 return
1679 ;;
1680 --*)
1681 __gitcomp "
1682 --all --mirror --tags --dry-run --force --verbose
1683 --receive-pack= --repo= --set-upstream
1684 "
1685 return
1686 ;;
1687 esac
1688 __git_complete_remote_or_refspec
1689}
1690_git_rebase ()
1692{
1693 local dir="$(__gitdir)"
1694 if [ -d "$dir"/rebase-apply ] || [ -d "$dir"/rebase-merge ]; then
1695 __gitcomp "--continue --skip --abort"
1696 return
1697 fi
1698 __git_complete_strategy && return
1699 case "$cur" in
1700 --whitespace=*)
1701 __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
1702 return
1703 ;;
1704 --*)
1705 __gitcomp "
1706 --onto --merge --strategy --interactive
1707 --preserve-merges --stat --no-stat
1708 --committer-date-is-author-date --ignore-date
1709 --ignore-whitespace --whitespace=
1710 --autosquash
1711 "
1712 return
1714 esac
1715 __gitcomp_nl "$(__git_refs)"
1716}
1717_git_reflog ()
1719{
1720 local subcommands="show delete expire"
1721 local subcommand="$(__git_find_on_cmdline "$subcommands")"
1722 if [ -z "$subcommand" ]; then
1724 __gitcomp "$subcommands"
1725 else
1726 __gitcomp_nl "$(__git_refs)"
1727 fi
1728}
1729__git_send_email_confirm_options="always never auto cc compose"
1731__git_send_email_suppresscc_options="author self cc bodycc sob cccmd body all"
1732_git_send_email ()
1734{
1735 case "$cur" in
1736 --confirm=*)
1737 __gitcomp "
1738 $__git_send_email_confirm_options
1739 " "" "${cur##--confirm=}"
1740 return
1741 ;;
1742 --suppress-cc=*)
1743 __gitcomp "
1744 $__git_send_email_suppresscc_options
1745 " "" "${cur##--suppress-cc=}"
1746 return
1748 ;;
1749 --smtp-encryption=*)
1750 __gitcomp "ssl tls" "" "${cur##--smtp-encryption=}"
1751 return
1752 ;;
1753 --thread=*)
1754 __gitcomp "
1755 deep shallow
1756 " "" "${cur##--thread=}"
1757 return
1758 ;;
1759 --*)
1760 __gitcomp "--annotate --bcc --cc --cc-cmd --chain-reply-to
1761 --compose --confirm= --dry-run --envelope-sender
1762 --from --identity
1763 --in-reply-to --no-chain-reply-to --no-signed-off-by-cc
1764 --no-suppress-from --no-thread --quiet
1765 --signed-off-by-cc --smtp-pass --smtp-server
1766 --smtp-server-port --smtp-encryption= --smtp-user
1767 --subject --suppress-cc= --suppress-from --thread --to
1768 --validate --no-validate
1769 $__git_format_patch_options"
1770 return
1771 ;;
1772 esac
1773 __git_complete_revlist
1774}
1775_git_stage ()
1777{
1778 _git_add
1779}
1780__git_config_get_set_variables ()
1782{
1783 local prevword word config_file= c=$cword
1784 while [ $c -gt 1 ]; do
1785 word="${words[c]}"
1786 case "$word" in
1787 --system|--global|--local|--file=*)
1788 config_file="$word"
1789 break
1790 ;;
1791 -f|--file)
1792 config_file="$word $prevword"
1793 break
1794 ;;
1795 esac
1796 prevword=$word
1797 c=$((--c))
1798 done
1799 git --git-dir="$(__gitdir)" config $config_file --list 2>/dev/null |
1801 while read -r line
1802 do
1803 case "$line" in
1804 *.*=*)
1805 echo "${line/=*/}"
1806 ;;
1807 esac
1808 done
1809}
1810_git_config ()
1812{
1813 case "$prev" in
1814 branch.*.remote)
1815 __gitcomp_nl "$(__git_remotes)"
1816 return
1817 ;;
1818 branch.*.merge)
1819 __gitcomp_nl "$(__git_refs)"
1820 return
1821 ;;
1822 branch.*.rebase)
1823 __gitcomp "false true"
1824 return
1825 ;;
1826 remote.*.fetch)
1827 local remote="${prev#remote.}"
1828 remote="${remote%.fetch}"
1829 if [ -z "$cur" ]; then
1830 __gitcompadd "refs/heads/" "" "" ""
1831 return
1832 fi
1833 __gitcomp_nl "$(__git_refs_remotes "$remote")"
1834 return
1835 ;;
1836 remote.*.push)
1837 local remote="${prev#remote.}"
1838 remote="${remote%.push}"
1839 __gitcomp_nl "$(git --git-dir="$(__gitdir)" \
1840 for-each-ref --format='%(refname):%(refname)' \
1841 refs/heads)"
1842 return
1843 ;;
1844 pull.twohead|pull.octopus)
1845 __git_compute_merge_strategies
1846 __gitcomp "$__git_merge_strategies"
1847 return
1848 ;;
1849 color.branch|color.diff|color.interactive|\
1850 color.showbranch|color.status|color.ui)
1851 __gitcomp "always never auto"
1852 return
1853 ;;
1854 color.pager)
1855 __gitcomp "false true"
1856 return
1857 ;;
1858 color.*.*)
1859 __gitcomp "
1860 normal black red green yellow blue magenta cyan white
1861 bold dim ul blink reverse
1862 "
1863 return
1864 ;;
1865 diff.submodule)
1866 __gitcomp "log short"
1867 return
1868 ;;
1869 help.format)
1870 __gitcomp "man info web html"
1871 return
1872 ;;
1873 log.date)
1874 __gitcomp "$__git_log_date_formats"
1875 return
1876 ;;
1877 sendemail.aliasesfiletype)
1878 __gitcomp "mutt mailrc pine elm gnus"
1879 return
1880 ;;
1881 sendemail.confirm)
1882 __gitcomp "$__git_send_email_confirm_options"
1883 return
1884 ;;
1885 sendemail.suppresscc)
1886 __gitcomp "$__git_send_email_suppresscc_options"
1887 return
1888 ;;
1889 --get|--get-all|--unset|--unset-all)
1890 __gitcomp_nl "$(__git_config_get_set_variables)"
1891 return
1892 ;;
1893 *.*)
1894 return
1895 ;;
1896 esac
1897 case "$cur" in
1898 --*)
1899 __gitcomp "
1900 --system --global --local --file=
1901 --list --replace-all
1902 --get --get-all --get-regexp
1903 --add --unset --unset-all
1904 --remove-section --rename-section
1905 "
1906 return
1907 ;;
1908 branch.*.*)
1909 local pfx="${cur%.*}." cur_="${cur##*.}"
1910 __gitcomp "remote merge mergeoptions rebase" "$pfx" "$cur_"
1911 return
1912 ;;
1913 branch.*)
1914 local pfx="${cur%.*}." cur_="${cur#*.}"
1915 __gitcomp_nl "$(__git_heads)" "$pfx" "$cur_" "."
1916 return
1917 ;;
1918 guitool.*.*)
1919 local pfx="${cur%.*}." cur_="${cur##*.}"
1920 __gitcomp "
1921 argprompt cmd confirm needsfile noconsole norescan
1922 prompt revprompt revunmerged title
1923 " "$pfx" "$cur_"
1924 return
1925 ;;
1926 difftool.*.*)
1927 local pfx="${cur%.*}." cur_="${cur##*.}"
1928 __gitcomp "cmd path" "$pfx" "$cur_"
1929 return
1930 ;;
1931 man.*.*)
1932 local pfx="${cur%.*}." cur_="${cur##*.}"
1933 __gitcomp "cmd path" "$pfx" "$cur_"
1934 return
1935 ;;
1936 mergetool.*.*)
1937 local pfx="${cur%.*}." cur_="${cur##*.}"
1938 __gitcomp "cmd path trustExitCode" "$pfx" "$cur_"
1939 return
1940 ;;
1941 pager.*)
1942 local pfx="${cur%.*}." cur_="${cur#*.}"
1943 __git_compute_all_commands
1944 __gitcomp_nl "$__git_all_commands" "$pfx" "$cur_"
1945 return
1946 ;;
1947 remote.*.*)
1948 local pfx="${cur%.*}." cur_="${cur##*.}"
1949 __gitcomp "
1950 url proxy fetch push mirror skipDefaultUpdate
1951 receivepack uploadpack tagopt pushurl
1952 " "$pfx" "$cur_"
1953 return
1954 ;;
1955 remote.*)
1956 local pfx="${cur%.*}." cur_="${cur#*.}"
1957 __gitcomp_nl "$(__git_remotes)" "$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.untracked
2022 color.status.updated
2023 color.ui
2024 commit.status
2025 commit.template
2026 core.abbrev
2027 core.askpass
2028 core.attributesfile
2029 core.autocrlf
2030 core.bare
2031 core.bigFileThreshold
2032 core.compression
2033 core.createObject
2034 core.deltaBaseCacheLimit
2035 core.editor
2036 core.eol
2037 core.excludesfile
2038 core.fileMode
2039 core.fsyncobjectfiles
2040 core.gitProxy
2041 core.ignoreCygwinFSTricks
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.headers
2082 format.numbered
2083 format.pretty
2084 format.signature
2085 format.signoff
2086 format.subjectprefix
2087 format.suffix
2088 format.thread
2089 format.to
2090 gc.
2091 gc.aggressiveWindow
2092 gc.auto
2093 gc.autopacklimit
2094 gc.packrefs
2095 gc.pruneexpire
2096 gc.reflogexpire
2097 gc.reflogexpireunreachable
2098 gc.rerereresolved
2099 gc.rerereunresolved
2100 gitcvs.allbinary
2101 gitcvs.commitmsgannotation
2102 gitcvs.dbTableNamePrefix
2103 gitcvs.dbdriver
2104 gitcvs.dbname
2105 gitcvs.dbpass
2106 gitcvs.dbuser
2107 gitcvs.enabled
2108 gitcvs.logfile
2109 gitcvs.usecrlfattr
2110 guitool.
2111 gui.blamehistoryctx
2112 gui.commitmsgwidth
2113 gui.copyblamethreshold
2114 gui.diffcontext
2115 gui.encoding
2116 gui.fastcopyblame
2117 gui.matchtrackingbranch
2118 gui.newbranchtemplate
2119 gui.pruneduringfetch
2120 gui.spellingdictionary
2121 gui.trustmtime
2122 help.autocorrect
2123 help.browser
2124 help.format
2125 http.lowSpeedLimit
2126 http.lowSpeedTime
2127 http.maxRequests
2128 http.minSessions
2129 http.noEPSV
2130 http.postBuffer
2131 http.proxy
2132 http.sslCAInfo
2133 http.sslCAPath
2134 http.sslCert
2135 http.sslCertPasswordProtected
2136 http.sslKey
2137 http.sslVerify
2138 http.useragent
2139 i18n.commitEncoding
2140 i18n.logOutputEncoding
2141 imap.authMethod
2142 imap.folder
2143 imap.host
2144 imap.pass
2145 imap.port
2146 imap.preformattedHTML
2147 imap.sslverify
2148 imap.tunnel
2149 imap.user
2150 init.templatedir
2151 instaweb.browser
2152 instaweb.httpd
2153 instaweb.local
2154 instaweb.modulepath
2155 instaweb.port
2156 interactive.singlekey
2157 log.date
2158 log.decorate
2159 log.showroot
2160 mailmap.file
2161 man.
2162 man.viewer
2163 merge.
2164 merge.conflictstyle
2165 merge.log
2166 merge.renameLimit
2167 merge.renormalize
2168 merge.stat
2169 merge.tool
2170 merge.verbosity
2171 mergetool.
2172 mergetool.keepBackup
2173 mergetool.keepTemporaries
2174 mergetool.prompt
2175 notes.displayRef
2176 notes.rewrite.
2177 notes.rewrite.amend
2178 notes.rewrite.rebase
2179 notes.rewriteMode
2180 notes.rewriteRef
2181 pack.compression
2182 pack.deltaCacheLimit
2183 pack.deltaCacheSize
2184 pack.depth
2185 pack.indexVersion
2186 pack.packSizeLimit
2187 pack.threads
2188 pack.window
2189 pack.windowMemory
2190 pager.
2191 pretty.
2192 pull.octopus
2193 pull.twohead
2194 push.default
2195 rebase.autosquash
2196 rebase.stat
2197 receive.autogc
2198 receive.denyCurrentBranch
2199 receive.denyDeleteCurrent
2200 receive.denyDeletes
2201 receive.denyNonFastForwards
2202 receive.fsckObjects
2203 receive.unpackLimit
2204 receive.updateserverinfo
2205 remotes.
2206 repack.usedeltabaseoffset
2207 rerere.autoupdate
2208 rerere.enabled
2209 sendemail.
2210 sendemail.aliasesfile
2211 sendemail.aliasfiletype
2212 sendemail.bcc
2213 sendemail.cc
2214 sendemail.cccmd
2215 sendemail.chainreplyto
2216 sendemail.confirm
2217 sendemail.envelopesender
2218 sendemail.from
2219 sendemail.identity
2220 sendemail.multiedit
2221 sendemail.signedoffbycc
2222 sendemail.smtpdomain
2223 sendemail.smtpencryption
2224 sendemail.smtppass
2225 sendemail.smtpserver
2226 sendemail.smtpserveroption
2227 sendemail.smtpserverport
2228 sendemail.smtpuser
2229 sendemail.suppresscc
2230 sendemail.suppressfrom
2231 sendemail.thread
2232 sendemail.to
2233 sendemail.validate
2234 showbranch.default
2235 status.relativePaths
2236 status.showUntrackedFiles
2237 status.submodulesummary
2238 submodule.
2239 tar.umask
2240 transfer.unpackLimit
2241 url.
2242 user.email
2243 user.name
2244 user.signingkey
2245 web.browser
2246 branch. remote.
2247 "
2248}
2249_git_remote ()
2251{
2252 local subcommands="add rename remove set-head set-branches set-url show prune update"
2253 local subcommand="$(__git_find_on_cmdline "$subcommands")"
2254 if [ -z "$subcommand" ]; then
2255 __gitcomp "$subcommands"
2256 return
2257 fi
2258 case "$subcommand" in
2260 rename|remove|set-url|show|prune)
2261 __gitcomp_nl "$(__git_remotes)"
2262 ;;
2263 set-head|set-branches)
2264 __git_complete_remote_or_refspec
2265 ;;
2266 update)
2267 local i c='' IFS=$'\n'
2268 for i in $(git --git-dir="$(__gitdir)" config --get-regexp "remotes\..*" 2>/dev/null); do
2269 i="${i#remotes.}"
2270 c="$c ${i/ */}"
2271 done
2272 __gitcomp "$c"
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 case "$cur" in
2300 --*)
2301 __gitcomp "--edit --mainline --no-edit --no-commit --signoff"
2302 return
2303 ;;
2304 esac
2305 __gitcomp_nl "$(__git_refs)"
2306}
2307_git_rm ()
2309{
2310 case "$cur" in
2311 --*)
2312 __gitcomp "--cached --dry-run --ignore-unmatch --quiet"
2313 return
2314 ;;
2315 esac
2316 __git_complete_index_file "--cached"
2318}
2319_git_shortlog ()
2321{
2322 __git_has_doubledash && return
2323 case "$cur" in
2325 --*)
2326 __gitcomp "
2327 $__git_log_common_options
2328 $__git_log_shortlog_options
2329 --numbered --summary
2330 "
2331 return
2332 ;;
2333 esac
2334 __git_complete_revlist
2335}
2336_git_show ()
2338{
2339 __git_has_doubledash && return
2340 case "$cur" in
2342 --pretty=*|--format=*)
2343 __gitcomp "$__git_log_pretty_formats $(__git_pretty_aliases)
2344 " "" "${cur#*=}"
2345 return
2346 ;;
2347 --diff-algorithm=*)
2348 __gitcomp "$__git_diff_algorithms" "" "${cur##--diff-algorithm=}"
2349 return
2350 ;;
2351 --*)
2352 __gitcomp "--pretty= --format= --abbrev-commit --oneline
2353 $__git_diff_common_options
2354 "
2355 return
2356 ;;
2357 esac
2358 __git_complete_file
2359}
2360_git_show_branch ()
2362{
2363 case "$cur" in
2364 --*)
2365 __gitcomp "
2366 --all --remotes --topo-order --current --more=
2367 --list --independent --merge-base --no-name
2368 --color --no-color
2369 --sha1-name --sparse --topics --reflog
2370 "
2371 return
2372 ;;
2373 esac
2374 __git_complete_revlist
2375}
2376_git_stash ()
2378{
2379 local save_opts='--keep-index --no-keep-index --quiet --patch'
2380 local subcommands='save list show apply clear drop pop create branch'
2381 local subcommand="$(__git_find_on_cmdline "$subcommands")"
2382 if [ -z "$subcommand" ]; then
2383 case "$cur" in
2384 --*)
2385 __gitcomp "$save_opts"
2386 ;;
2387 *)
2388 if [ -z "$(__git_find_on_cmdline "$save_opts")" ]; then
2389 __gitcomp "$subcommands"
2390 fi
2391 ;;
2392 esac
2393 else
2394 case "$subcommand,$cur" in
2395 save,--*)
2396 __gitcomp "$save_opts"
2397 ;;
2398 apply,--*|pop,--*)
2399 __gitcomp "--index --quiet"
2400 ;;
2401 show,--*|drop,--*|branch,--*)
2402 ;;
2403 show,*|apply,*|drop,*|pop,*|branch,*)
2404 __gitcomp_nl "$(git --git-dir="$(__gitdir)" stash list \
2405 | sed -n -e 's/:.*//p')"
2406 ;;
2407 *)
2408 ;;
2409 esac
2410 fi
2411}
2412_git_submodule ()
2414{
2415 __git_has_doubledash && return
2416 local subcommands="add status init deinit update summary foreach sync"
2418 if [ -z "$(__git_find_on_cmdline "$subcommands")" ]; then
2419 case "$cur" in
2420 --*)
2421 __gitcomp "--quiet --cached"
2422 ;;
2423 *)
2424 __gitcomp "$subcommands"
2425 ;;
2426 esac
2427 return
2428 fi
2429}
2430_git_svn ()
2432{
2433 local subcommands="
2434 init fetch clone rebase dcommit log find-rev
2435 set-tree commit-diff info create-ignore propget
2436 proplist show-ignore show-externals branch tag blame
2437 migrate mkdirs reset gc
2438 "
2439 local subcommand="$(__git_find_on_cmdline "$subcommands")"
2440 if [ -z "$subcommand" ]; then
2441 __gitcomp "$subcommands"
2442 else
2443 local remote_opts="--username= --config-dir= --no-auth-cache"
2444 local fc_opts="
2445 --follow-parent --authors-file= --repack=
2446 --no-metadata --use-svm-props --use-svnsync-props
2447 --log-window-size= --no-checkout --quiet
2448 --repack-flags --use-log-author --localtime
2449 --ignore-paths= $remote_opts
2450 "
2451 local init_opts="
2452 --template= --shared= --trunk= --tags=
2453 --branches= --stdlayout --minimize-url
2454 --no-metadata --use-svm-props --use-svnsync-props
2455 --rewrite-root= --prefix= --use-log-author
2456 --add-author-from $remote_opts
2457 "
2458 local cmt_opts="
2459 --edit --rmdir --find-copies-harder --copy-similarity=
2460 "
2461 case "$subcommand,$cur" in
2463 fetch,--*)
2464 __gitcomp "--revision= --fetch-all $fc_opts"
2465 ;;
2466 clone,--*)
2467 __gitcomp "--revision= $fc_opts $init_opts"
2468 ;;
2469 init,--*)
2470 __gitcomp "$init_opts"
2471 ;;
2472 dcommit,--*)
2473 __gitcomp "
2474 --merge --strategy= --verbose --dry-run
2475 --fetch-all --no-rebase --commit-url
2476 --revision --interactive $cmt_opts $fc_opts
2477 "
2478 ;;
2479 set-tree,--*)
2480 __gitcomp "--stdin $cmt_opts $fc_opts"
2481 ;;
2482 create-ignore,--*|propget,--*|proplist,--*|show-ignore,--*|\
2483 show-externals,--*|mkdirs,--*)
2484 __gitcomp "--revision="
2485 ;;
2486 log,--*)
2487 __gitcomp "
2488 --limit= --revision= --verbose --incremental
2489 --oneline --show-commit --non-recursive
2490 --authors-file= --color
2491 "
2492 ;;
2493 rebase,--*)
2494 __gitcomp "
2495 --merge --verbose --strategy= --local
2496 --fetch-all --dry-run $fc_opts
2497 "
2498 ;;
2499 commit-diff,--*)
2500 __gitcomp "--message= --file= --revision= $cmt_opts"
2501 ;;
2502 info,--*)
2503 __gitcomp "--url"
2504 ;;
2505 branch,--*)
2506 __gitcomp "--dry-run --message --tag"
2507 ;;
2508 tag,--*)
2509 __gitcomp "--dry-run --message"
2510 ;;
2511 blame,--*)
2512 __gitcomp "--git-format"
2513 ;;
2514 migrate,--*)
2515 __gitcomp "
2516 --config-dir= --ignore-paths= --minimize
2517 --no-auth-cache --username=
2518 "
2519 ;;
2520 reset,--*)
2521 __gitcomp "--revision= --parent"
2522 ;;
2523 *)
2524 ;;
2525 esac
2526 fi
2527}
2528_git_tag ()
2530{
2531 local i c=1 f=0
2532 while [ $c -lt $cword ]; do
2533 i="${words[c]}"
2534 case "$i" in
2535 -d|-v)
2536 __gitcomp_nl "$(__git_tags)"
2537 return
2538 ;;
2539 -f)
2540 f=1
2541 ;;
2542 esac
2543 ((c++))
2544 done
2545 case "$prev" in
2547 -m|-F)
2548 ;;
2549 -*|tag)
2550 if [ $f = 1 ]; then
2551 __gitcomp_nl "$(__git_tags)"
2552 fi
2553 ;;
2554 *)
2555 __gitcomp_nl "$(__git_refs)"
2556 ;;
2557 esac
2558}
2559_git_whatchanged ()
2561{
2562 _git_log
2563}
2564__git_main ()
2566{
2567 local i c=1 command __git_dir
2568 while [ $c -lt $cword ]; do
2570 i="${words[c]}"
2571 case "$i" in
2572 --git-dir=*) __git_dir="${i#--git-dir=}" ;;
2573 --bare) __git_dir="." ;;
2574 --help) command="help"; break ;;
2575 -c) c=$((++c)) ;;
2576 -*) ;;
2577 *) command="$i"; break ;;
2578 esac
2579 ((c++))
2580 done
2581 if [ -z "$command" ]; then
2583 case "$cur" in
2584 --*) __gitcomp "
2585 --paginate
2586 --no-pager
2587 --git-dir=
2588 --bare
2589 --version
2590 --exec-path
2591 --exec-path=
2592 --html-path
2593 --info-path
2594 --work-tree=
2595 --namespace=
2596 --no-replace-objects
2597 --help
2598 "
2599 ;;
2600 *) __git_compute_porcelain_commands
2601 __gitcomp "$__git_porcelain_commands $(__git_aliases)" ;;
2602 esac
2603 return
2604 fi
2605 local completion_func="_git_${command//-/_}"
2607 declare -f $completion_func >/dev/null && $completion_func && return
2608 local expansion=$(__git_aliased_command "$command")
2610 if [ -n "$expansion" ]; then
2611 completion_func="_git_${expansion//-/_}"
2612 declare -f $completion_func >/dev/null && $completion_func
2613 fi
2614}
2615__gitk_main ()
2617{
2618 __git_has_doubledash && return
2619 local g="$(__gitdir)"
2621 local merge=""
2622 if [ -f "$g/MERGE_HEAD" ]; then
2623 merge="--merge"
2624 fi
2625 case "$cur" in
2626 --*)
2627 __gitcomp "
2628 $__git_log_common_options
2629 $__git_log_gitk_options
2630 $merge
2631 "
2632 return
2633 ;;
2634 esac
2635 __git_complete_revlist
2636}
2637if [[ -n ${ZSH_VERSION-} ]]; then
2639 echo "WARNING: this script is deprecated, please see git-completion.zsh" 1>&2
2640 autoload -U +X compinit && compinit
2642 __gitcomp ()
2644 {
2645 emulate -L zsh
2646 local cur_="${3-$cur}"
2648 case "$cur_" in
2650 --*=)
2651 ;;
2652 *)
2653 local c IFS=$' \t\n'
2654 local -a array
2655 for c in ${=1}; do
2656 c="$c${4-}"
2657 case $c in
2658 --*=*|*.) ;;
2659 *) c="$c " ;;
2660 esac
2661 array[$#array+1]="$c"
2662 done
2663 compset -P '*[=:]'
2664 compadd -Q -S '' -p "${2-}" -a -- array && _ret=0
2665 ;;
2666 esac
2667 }
2668 __gitcomp_nl ()
2670 {
2671 emulate -L zsh
2672 local IFS=$'\n'
2674 compset -P '*[=:]'
2675 compadd -Q -S "${4- }" -p "${2-}" -- ${=1} && _ret=0
2676 }
2677 __gitcomp_file ()
2679 {
2680 emulate -L zsh
2681 local IFS=$'\n'
2683 compset -P '*[=:]'
2684 compadd -Q -p "${2-}" -f -- ${=1} && _ret=0
2685 }
2686 __git_zsh_helper ()
2688 {
2689 emulate -L ksh
2690 local cur cword prev
2691 cur=${words[CURRENT-1]}
2692 prev=${words[CURRENT-2]}
2693 let cword=CURRENT-1
2694 __${service}_main
2695 }
2696 _git ()
2698 {
2699 emulate -L zsh
2700 local _ret=1
2701 __git_zsh_helper
2702 let _ret && _default -S '' && _ret=0
2703 return _ret
2704 }
2705 compdef _git git gitk
2707 return
2708elif [[ -n ${BASH_VERSION-} ]]; then
2709 if ((${BASH_VERSINFO[0]} < 4)); then
2710 # compopt is not supported
2711 __git_index_file_list_filter ()
2712 {
2713 __git_index_file_list_filter_compat
2714 }
2715 fi
2716fi
2717__git_func_wrap ()
2719{
2720 local cur words cword prev
2721 _get_comp_words_by_ref -n =: cur words cword prev
2722 $1
2723}
2724# Setup completion for certain functions defined above by setting common
2726# variables and workarounds.
2727# This is NOT a public function; use at your own risk.
2728__git_complete ()
2729{
2730 local wrapper="__git_wrap${2}"
2731 eval "$wrapper () { __git_func_wrap $2 ; }"
2732 complete -o bashdefault -o default -o nospace -F $wrapper $1 2>/dev/null \
2733 || complete -o default -o nospace -F $wrapper $1
2734}
2735# wrapper for backwards compatibility
2737_git ()
2738{
2739 __git_wrap__git_main
2740}
2741# wrapper for backwards compatibility
2743_gitk ()
2744{
2745 __git_wrap__gitk_main
2746}
2747__git_complete git __git_main
2749__git_complete gitk __gitk_main
2750# The following are necessary only for Cygwin, and only are needed
2752# when the user has tab-completed the executable name and consequently
2753# included the '.exe' suffix.
2754#
2755if [ Cygwin = "$(uname -o 2>/dev/null)" ]; then
2756__git_complete git.exe __git_main
2757fi