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