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