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