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