Git 2.18
[git.git] / contrib / completion / git-completion.bash
blobdd3e925843acf53c439e504101d46d8606ea5d69
1 # bash/zsh completion support for core Git.
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.
7 # The contained completion routines provide support for completing:
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
18 # To use these routines:
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.
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 ; ... '".
32 # Compatible with bash 3.2.57.
34 # You can set the following environment variables to influence the behavior of
35 # the completion routines:
37 # GIT_COMPLETION_CHECKOUT_NO_GUESS
39 # When set to "1", do not include "DWIM" suggestions in git-checkout
40 # completion (e.g., completing "foo" when "origin/foo" exists).
42 case "$COMP_WORDBREAKS" in
43 *:*) : great ;;
44 *) COMP_WORDBREAKS="$COMP_WORDBREAKS:"
45 esac
47 # 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 ()
52 if [ -n "$__git_repo_path" ]; then
53 # we already know where it is
54 return
57 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)"
74 # 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 ()
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"
89 # 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 ()
93 git ${__git_C_args:+"${__git_C_args[@]}"} \
94 ${__git_dir:+--git-dir="$__git_dir"} "$@" 2>/dev/null
97 # 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 ()
102 local rest="$1" len ch
104 dequoted_word=""
106 while test -n "$rest"; do
107 len=${#dequoted_word}
108 dequoted_word="$dequoted_word${rest%%[\\\'\"]*}"
109 rest="${rest:$((${#dequoted_word}-$len))}"
111 case "${rest:0:1}" in
113 ch="${rest:1:1}"
114 case "$ch" in
115 $'\n')
118 dequoted_word="$dequoted_word$ch"
120 esac
121 rest="${rest:2}"
124 rest="${rest:1}"
125 len=${#dequoted_word}
126 dequoted_word="$dequoted_word${rest%%\'*}"
127 rest="${rest:$((${#dequoted_word}-$len+1))}"
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
137 ch="${rest:1:1}"
138 case "$ch" in
139 \"|\\|\$|\`)
140 dequoted_word="$dequoted_word$ch"
142 $'\n')
145 dequoted_word="$dequoted_word\\$ch"
147 esac
148 rest="${rest:2}"
151 rest="${rest:1}"
152 break
154 esac
155 done
157 esac
158 done
161 # The following function is based on code from:
163 # bash_completion - programmable completion functions for bash 3.2+
165 # Copyright © 2006-2008, Ian Macdonald <ian@caliban.org>
166 # © 2009-2010, Bash Completion Maintainers
167 # <bash-completion-devel@lists.alioth.debian.org>
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.
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.
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/>.
182 # The latest version of this software can be obtained here:
184 # http://bash-completion.alioth.debian.org/
186 # RELEASE: 2.x
188 # This function can be used to access a tokenized list of words
189 # on the command line:
191 # __git_reassemble_comp_words_by_ref '=:'
192 # if test "${words_[cword_-1]}" = -w
193 # then
194 # ...
195 # fi
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.
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.
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.
211 # Output: words_, cword_, cur_.
213 __git_reassemble_comp_words_by_ref()
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
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]}" ]
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--))
240 first=
241 words_[$j]=${words_[j]}${COMP_WORDS[i]}
242 if [ $i = $COMP_CWORD ]; then
243 cword_=$j
245 if (($i < ${#COMP_WORDS[@]} - 1)); then
246 ((i++))
247 else
248 # Done.
249 return
251 done
252 words_[$j]=${words_[j]}${COMP_WORDS[i]}
253 if [ $i = $COMP_CWORD ]; then
254 cword_=$j
256 done
259 if ! type _get_comp_words_by_ref >/dev/null 2>&1; then
260 _get_comp_words_by_ref ()
262 local exclude cur_ words_ cword_
263 if [ "$1" = "-n" ]; then
264 exclude=$2
265 shift 2
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_
274 prev)
275 prev=${words_[$cword_-1]}
277 words)
278 words=("${words_[@]}")
280 cword)
281 cword=$cword_
283 esac
284 shift
285 done
289 # 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 ()
298 local IFS=$'\n'
300 COMPREPLY=($1)
303 __gitcompappend ()
305 local x i=${#COMPREPLY[@]}
306 for x in $1; do
307 if [[ "$x" == "$3"* ]]; then
308 COMPREPLY[i++]="$2$x$4"
310 done
313 __gitcompadd ()
315 COMPREPLY=()
316 __gitcompappend "$@"
319 # 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 ()
328 local cur_="${3-$cur}"
330 case "$cur_" in
331 --*=)
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"
344 done
346 esac
349 # Clear the variables caching builtins' options when (re-)sourcing
350 # the completion script.
351 if [[ -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
353 else
354 unset $(compgen -v __gitcomp_builtin_)
357 # This function is equivalent to
359 # __gitcomp "$(git xxx --git-completion-helper) ..."
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 ()
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"
373 local var=__gitcomp_builtin_"${cmd/-/_}"
374 local options
375 eval "options=\$$var"
377 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\""
387 __gitcomp "$options"
390 # Variation of __gitcomp_nl () that appends to the existing list of
391 # completion candidates, COMPREPLY.
392 __gitcomp_nl_append ()
394 local IFS=$'\n'
395 __gitcompappend "$1" "${2-}" "${3-$cur}" "${4- }"
398 # 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 ()
409 COMPREPLY=()
410 __gitcomp_nl_append "$@"
413 # 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 ()
421 local IFS=$'\n'
423 COMPREPLY=($1)
425 # 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
431 # 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 ()
440 local IFS=$'\n'
442 # 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}" ""
448 # 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
454 # 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 ()
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//\\/\\\\}*"
471 # __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 ()
480 local root="$2" match="$3"
482 __git_ls_files_helper "$root" "$1" "$match" |
483 awk -F / -v pfx="${2//\\/\\\\}" '{
484 paths[$1] = 1
486 END {
487 for (p in paths) {
488 if (substr(p, 1, 1) != "\"") {
489 # No special characters, easy!
490 print pfx p
491 continue
494 # The path is quoted.
495 p = dequote(p)
496 if (p == "")
497 continue
499 # 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
512 function dequote(p, bs_idx, out, esc, esc_idx, dec) {
513 # Skip opening double quote.
514 p = substr(p, 2)
516 # 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)
522 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)
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
550 return out
554 # __git_complete_index_file requires 1 argument:
555 # 1: the options to pass to ls-file
557 # The exception is --committable, which finds the files appropriate commit.
558 __git_complete_index_file ()
560 local dequoted_word pfx="" cur_
562 __git_dequote "$cur"
564 case "$dequoted_word" in
565 ?*/*)
566 pfx="${dequoted_word%/*}/"
567 cur_="${dequoted_word##*/}"
570 cur_="$dequoted_word"
571 esac
573 __gitcomp_file_direct "$(__git_index_files "$1" "$pfx" "$cur_")"
576 # 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 ()
583 local pfx="${1-}" cur_="${2-}" sfx="${3-}"
585 __git for-each-ref --format="${pfx//\%/%%}%(refname:strip=2)$sfx" \
586 "refs/heads/$cur_*" "refs/heads/$cur_*/**"
589 # Lists tags from the local repository.
590 # Accepts the same positional parameters as __git_heads() above.
591 __git_tags ()
593 local pfx="${1-}" cur_="${2-}" sfx="${3-}"
595 __git for-each-ref --format="${pfx//\%/%%}%(refname:strip=2)$sfx" \
596 "refs/tags/$cur_*" "refs/tags/$cur_*/**"
599 # 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).
611 # Use __git_complete_refs() instead.
612 __git_refs ()
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
621 __git_find_repo_path
622 dir="$__git_repo_path"
624 if [ -z "$remote" ]; then
625 if [ -z "$dir" ]; then
626 return
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
642 if [ "$list_refs_from" = path ]; then
643 if [[ "$cur_" == ^* ]]; then
644 pfx="$pfx^"
645 fer_pfx="$fer_pfx^"
646 cur_=${cur_#^}
647 match=${match#^}
649 case "$cur_" in
650 refs|refs/*)
651 format="refname"
652 refs=("$match*" "$match*/**")
653 track=""
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"
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*/**")
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
682 return
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
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
719 esac
722 # Completes refs, short and long, local and remote, symbolic and pseudo.
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 ()
735 local remote track pfx cur_="$cur" sfx=" "
737 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
749 __gitcomp_direct "$(__git_refs "$remote" "$track" "$pfx" "$cur_" "$sfx")"
752 # __git_refs2 requires 1 argument (to pass to __git_refs)
753 # Deprecated: use __git_complete_fetch_refspecs() instead.
754 __git_refs2 ()
756 local i
757 for i in $(__git_refs "$1"); do
758 echo "$i:$i"
759 done
762 # 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 ()
771 local i remote="$1" pfx="${2-}" cur_="${3-$cur}" sfx="${4- }"
773 __gitcomp_direct "$(
774 for i in $(__git_refs "$remote" "" "" "$cur_") ; do
775 echo "$pfx$i:$i$sfx"
776 done
780 # __git_refs_remotes requires 1 argument (to pass to ls-remote)
781 __git_refs_remotes ()
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
790 __git_remotes ()
792 __git_find_repo_path
793 test -d "$__git_repo_path/remotes" && ls -1 "$__git_repo_path/remotes"
794 __git remote
797 # Returns true if $1 matches the name of a configured remote, false otherwise.
798 __git_is_configured_remote ()
800 local remote
801 for remote in $(__git_remotes); do
802 if [ "$remote" = "$1" ]; then
803 return 0
805 done
806 return 1
809 __git_list_merge_strategies ()
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/[ ]*$//
821 __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 ()
829 test -n "$__git_merge_strategies" ||
830 __git_merge_strategies=$(__git_list_merge_strategies)
833 __git_complete_revlist_file ()
835 local pfx ls ref cur_="$cur"
836 case "$cur_" in
837 *..?*:*)
838 return
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/"
851 ls="$ref"
853 esac
855 case "$COMP_WORDBREAKS" in
856 *:*) : great ;;
857 *) pfx="$ref:$pfx" ;;
858 esac
860 __gitcomp_nl "$(__git ls-tree "$ls" \
861 | sed '/^100... blob /{
862 s,^.* ,,
863 s,$, ,
865 /^120000 blob /{
866 s,^.* ,,
867 s,$, ,
869 /^040000 tree /{
870 s,^.* ,,
871 s,$,/,
873 s/^.* //')" \
874 "$pfx" "$cur_" ""
876 *...*)
877 pfx="${cur_%...*}..."
878 cur_="${cur_#*...}"
879 __git_complete_refs --pfx="$pfx" --cur="$cur_"
881 *..*)
882 pfx="${cur_%..*}.."
883 cur_="${cur_#*..}"
884 __git_complete_refs --pfx="$pfx" --cur="$cur_"
887 __git_complete_refs
889 esac
892 __git_complete_file ()
894 __git_complete_revlist_file
897 __git_complete_revlist ()
899 __git_complete_revlist_file
902 __git_complete_remote_or_refspec ()
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++))
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
920 *) ;;
921 esac
923 -*) ;;
924 *) remote="$i"; break ;;
925 esac
926 ((c++))
927 done
928 if [ -z "$remote" ]; then
929 __gitcomp_nl "$(__git_remotes)"
930 return
932 if [ $no_complete_refspec = 1 ]; then
933 return
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
946 pfx="+"
947 cur_="${cur_#+}"
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_"
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_"
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_"
972 esac
975 __git_complete_strategy ()
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
988 esac
989 return 1
992 __git_all_commands=
993 __git_compute_all_commands ()
995 test -n "$__git_all_commands" ||
996 __git_all_commands=$(git --list-cmds=main,others,alias,nohelpers)
999 # Lists all set config variables starting with the given section prefix,
1000 # with the prefix removed.
1001 __git_get_config_variables ()
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
1009 __git_pretty_aliases ()
1011 __git_get_config_variables "pretty"
1014 # __git_aliased_command requires 1 argument
1015 __git_aliased_command ()
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
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 ;;
1033 echo "$word"
1034 return
1035 esac
1036 done
1039 # __git_find_on_cmdline requires 1 argument
1040 __git_find_on_cmdline ()
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
1050 done
1051 ((c++))
1052 done
1055 # Echo the value of an option set on the command line or config
1057 # $1: short option name
1058 # $2: long option name including =
1059 # $3: list of possible values
1060 # $4: config string (optional)
1062 # example:
1063 # result="$(__git_get_option_value "-d" "--do-something=" \
1064 # "yes no" "core.doSomething")"
1066 # result is then either empty (no option set) or "yes" or "no"
1068 # __git_get_option_value requires 3 arguments
1069 __git_get_option_value ()
1071 local c short_opt long_opt val
1072 local result= values config_key word
1074 short_opt="$1"
1075 long_opt="$2"
1076 values="$3"
1077 config_key="$4"
1079 ((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
1088 done
1089 ((c--))
1090 done
1092 if [ -n "$config_key" ] && [ -z "$result" ]; then
1093 result="$(__git config "$config_key")"
1096 echo "$result"
1099 __git_has_doubledash ()
1101 local c=1
1102 while [ $c -lt $cword ]; do
1103 if [ "--" = "${words[c]}" ]; then
1104 return 0
1106 ((c++))
1107 done
1108 return 1
1111 # 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
1119 # __git_count_arguments requires 1 argument: the git command executed.
1120 __git_count_arguments ()
1122 local word i c=0
1124 # Skip "git" (first argument)
1125 for ((i=1; i < ${#words[@]}; i++)); do
1126 word="${words[i]}"
1128 case "$word" in
1130 # Good; we can assume that the following are only non
1131 # option arguments.
1132 ((c = 0))
1134 "$1")
1135 # Skip the specified git command and discard git
1136 # main options
1137 ((c = 0))
1140 ((c++))
1142 esac
1143 done
1145 printf "%d" $c
1148 __git_whitespacelist="nowarn warn error error-all fix"
1149 __git_am_inprogress_options="--skip --continue --resolved --abort --quit --show-current-patch"
1151 _git_am ()
1153 __git_find_repo_path
1154 if [ -d "$__git_repo_path"/rebase-apply ]; then
1155 __gitcomp "$__git_am_inprogress_options"
1156 return
1158 case "$cur" in
1159 --whitespace=*)
1160 __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
1161 return
1163 --*)
1164 __gitcomp_builtin am "--no-utf8" \
1165 "$__git_am_inprogress_options"
1166 return
1167 esac
1170 _git_apply ()
1172 case "$cur" in
1173 --whitespace=*)
1174 __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
1175 return
1177 --*)
1178 __gitcomp_builtin apply
1179 return
1180 esac
1183 _git_add ()
1185 case "$cur" in
1186 --*)
1187 __gitcomp_builtin add
1188 return
1189 esac
1191 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"
1196 __git_complete_index_file "$complete_opt"
1199 _git_archive ()
1201 case "$cur" in
1202 --format=*)
1203 __gitcomp "$(git archive --list)" "" "${cur##--format=}"
1204 return
1206 --remote=*)
1207 __gitcomp_nl "$(__git_remotes)" "" "${cur##--remote=}"
1208 return
1210 --*)
1211 __gitcomp "
1212 --format= --list --verbose
1213 --prefix= --remote= --exec= --output
1215 return
1217 esac
1218 __git_complete_file
1221 _git_bisect ()
1223 __git_has_doubledash && return
1225 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"
1234 return
1237 case "$subcommand" in
1238 bad|good|reset|skip|start)
1239 __git_complete_refs
1243 esac
1246 _git_branch ()
1248 local i c=1 only_local_ref="n" has_r="n"
1250 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
1259 case "$cur" in
1260 --set-upstream-to=*)
1261 __git_complete_refs --cur="${cur##--set-upstream-to=}"
1263 --*)
1264 __gitcomp_builtin branch "--no-color --no-abbrev
1265 --no-track --no-column
1269 if [ $only_local_ref = "y" -a $has_r = "n" ]; then
1270 __gitcomp_direct "$(__git_heads "" "$cur" " ")"
1271 else
1272 __git_complete_refs
1275 esac
1278 _git_bundle ()
1280 local cmd="${words[2]}"
1281 case "$cword" in
1283 __gitcomp "create list-heads verify unbundle"
1286 # looking for a file
1289 case "$cmd" in
1290 create)
1291 __git_complete_revlist
1293 esac
1295 esac
1298 _git_checkout ()
1300 __git_has_doubledash && return
1302 case "$cur" in
1303 --conflict=*)
1304 __gitcomp "diff3 merge" "" "${cur##--conflict=}"
1306 --*)
1307 __gitcomp_builtin checkout "--no-track --no-recurse-submodules"
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=''
1317 __git_complete_refs $track_opt
1319 esac
1322 _git_cherry ()
1324 case "$cur" in
1325 --*)
1326 __gitcomp_builtin cherry
1327 return
1328 esac
1330 __git_complete_refs
1333 __git_cherry_pick_inprogress_options="--continue --quit --abort"
1335 _git_cherry_pick ()
1337 __git_find_repo_path
1338 if [ -f "$__git_repo_path"/CHERRY_PICK_HEAD ]; then
1339 __gitcomp "$__git_cherry_pick_inprogress_options"
1340 return
1342 case "$cur" in
1343 --*)
1344 __gitcomp_builtin cherry-pick "" \
1345 "$__git_cherry_pick_inprogress_options"
1348 __git_complete_refs
1350 esac
1353 _git_clean ()
1355 case "$cur" in
1356 --*)
1357 __gitcomp_builtin clean
1358 return
1360 esac
1362 # XXX should we check for -x option ?
1363 __git_complete_index_file "--others --directory"
1366 _git_clone ()
1368 case "$cur" in
1369 --*)
1370 __gitcomp_builtin clone "--no-single-branch"
1371 return
1373 esac
1376 __git_untracked_file_modes="all no normal"
1378 _git_commit ()
1380 case "$prev" in
1381 -c|-C)
1382 __git_complete_refs
1383 return
1385 esac
1387 case "$cur" in
1388 --cleanup=*)
1389 __gitcomp "default scissors strip verbatim whitespace
1390 " "" "${cur##--cleanup=}"
1391 return
1393 --reuse-message=*|--reedit-message=*|\
1394 --fixup=*|--squash=*)
1395 __git_complete_refs --cur="${cur#*=}"
1396 return
1398 --untracked-files=*)
1399 __gitcomp "$__git_untracked_file_modes" "" "${cur##--untracked-files=}"
1400 return
1402 --*)
1403 __gitcomp_builtin commit "--no-edit --verify"
1404 return
1405 esac
1407 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"
1415 _git_describe ()
1417 case "$cur" in
1418 --*)
1419 __gitcomp_builtin describe
1420 return
1421 esac
1422 __git_complete_refs
1425 __git_diff_algorithms="myers minimal patience histogram"
1427 __git_diff_submodule_formats="diff log short"
1429 __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
1447 _git_diff ()
1449 __git_has_doubledash && return
1451 case "$cur" in
1452 --diff-algorithm=*)
1453 __gitcomp "$__git_diff_algorithms" "" "${cur##--diff-algorithm=}"
1454 return
1456 --submodule=*)
1457 __gitcomp "$__git_diff_submodule_formats" "" "${cur##--submodule=}"
1458 return
1460 --*)
1461 __gitcomp "--cached --staged --pickaxe-all --pickaxe-regex
1462 --base --ours --theirs --no-index
1463 $__git_diff_common_options
1465 return
1467 esac
1468 __git_complete_revlist_file
1471 __git_mergetools_common="diffuse diffmerge ecmerge emerge kdiff3 meld opendiff
1472 tkdiff vimdiff gvimdiff xxdiff araxis p4merge bc codecompare
1475 _git_difftool ()
1477 __git_has_doubledash && return
1479 case "$cur" in
1480 --tool=*)
1481 __gitcomp "$__git_mergetools_common kompare" "" "${cur##--tool=}"
1482 return
1484 --*)
1485 __gitcomp_builtin difftool "$__git_diff_common_options
1486 --base --cached --ours --theirs
1487 --pickaxe-all --pickaxe-regex
1488 --relative --staged
1490 return
1492 esac
1493 __git_complete_revlist_file
1496 __git_fetch_recurse_submodules="yes on-demand no"
1498 _git_fetch ()
1500 case "$cur" in
1501 --recurse-submodules=*)
1502 __gitcomp "$__git_fetch_recurse_submodules" "" "${cur##--recurse-submodules=}"
1503 return
1505 --*)
1506 __gitcomp_builtin fetch "--no-tags"
1507 return
1509 esac
1510 __git_complete_remote_or_refspec
1513 __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
1522 _git_format_patch ()
1524 case "$cur" in
1525 --thread=*)
1526 __gitcomp "
1527 deep shallow
1528 " "" "${cur##--thread=}"
1529 return
1531 --*)
1532 __gitcomp "$__git_format_patch_options"
1533 return
1535 esac
1536 __git_complete_revlist
1539 _git_fsck ()
1541 case "$cur" in
1542 --*)
1543 __gitcomp_builtin fsck "--no-reflogs"
1544 return
1546 esac
1549 _git_gitk ()
1551 _gitk
1554 # 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"
1565 # 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=" "
1577 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
1588 if test -r "$tags"; then
1589 __gitcomp_direct "$(__git_match_ctag "$cur_" "$tags" "$pfx" "$sfx")"
1593 _git_grep ()
1595 __git_has_doubledash && return
1597 case "$cur" in
1598 --*)
1599 __gitcomp_builtin grep
1600 return
1602 esac
1604 case "$cword,$prev" in
1605 2,*|*,-*)
1606 __git_complete_symbol && return
1608 esac
1610 __git_complete_refs
1613 _git_help ()
1615 case "$cur" in
1616 --*)
1617 __gitcomp_builtin help
1618 return
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"
1629 _git_init ()
1631 case "$cur" in
1632 --shared=*)
1633 __gitcomp "
1634 false true umask group all world everybody
1635 " "" "${cur##--shared=}"
1636 return
1638 --*)
1639 __gitcomp_builtin init
1640 return
1642 esac
1645 _git_ls_files ()
1647 case "$cur" in
1648 --*)
1649 __gitcomp_builtin ls-files "--no-empty-directory"
1650 return
1652 esac
1654 # XXX ignore options like --modified and always suggest all cached
1655 # files.
1656 __git_complete_index_file "--cached"
1659 _git_ls_remote ()
1661 case "$cur" in
1662 --*)
1663 __gitcomp_builtin ls-remote
1664 return
1666 esac
1667 __gitcomp_nl "$(__git_remotes)"
1670 _git_ls_tree ()
1672 case "$cur" in
1673 --*)
1674 __gitcomp_builtin ls-tree
1675 return
1677 esac
1679 __git_complete_file
1682 # 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
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
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
1705 __git_log_pretty_formats="oneline short medium full fuller email raw format:"
1706 __git_log_date_formats="relative iso8601 rfc2822 short local default raw"
1708 _git_log ()
1710 __git_has_doubledash && return
1711 __git_find_repo_path
1713 local merge=""
1714 if [ -f "$__git_repo_path/MERGE_HEAD" ]; then
1715 merge="--merge"
1717 case "$prev,$cur" in
1718 -L,:*:*)
1719 return # fall back to Bash filename completion
1721 -L,:*)
1722 __git_complete_symbol --cur="${cur#:}" --sfx=":"
1723 return
1725 -G,*|-S,*)
1726 __git_complete_symbol
1727 return
1729 esac
1730 case "$cur" in
1731 --pretty=*|--format=*)
1732 __gitcomp "$__git_log_pretty_formats $(__git_pretty_aliases)
1733 " "" "${cur#*=}"
1734 return
1736 --date=*)
1737 __gitcomp "$__git_log_date_formats" "" "${cur##--date=}"
1738 return
1740 --decorate=*)
1741 __gitcomp "full short no" "" "${cur##--decorate=}"
1742 return
1744 --diff-algorithm=*)
1745 __gitcomp "$__git_diff_algorithms" "" "${cur##--diff-algorithm=}"
1746 return
1748 --submodule=*)
1749 __gitcomp "$__git_diff_submodule_formats" "" "${cur##--submodule=}"
1750 return
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
1773 return
1775 -L:*:*)
1776 return # fall back to Bash filename completion
1778 -L:*)
1779 __git_complete_symbol --cur="${cur#-L:}" --sfx=":"
1780 return
1782 -G*)
1783 __git_complete_symbol --pfx="-G" --cur="${cur#-G}"
1784 return
1786 -S*)
1787 __git_complete_symbol --pfx="-S" --cur="${cur#-S}"
1788 return
1790 esac
1791 __git_complete_revlist
1794 _git_merge ()
1796 __git_complete_strategy && return
1798 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
1806 return
1807 esac
1808 __git_complete_refs
1811 _git_mergetool ()
1813 case "$cur" in
1814 --tool=*)
1815 __gitcomp "$__git_mergetools_common tortoisemerge" "" "${cur##--tool=}"
1816 return
1818 --*)
1819 __gitcomp "--tool= --prompt --no-prompt"
1820 return
1822 esac
1825 _git_merge_base ()
1827 case "$cur" in
1828 --*)
1829 __gitcomp_builtin merge-base
1830 return
1832 esac
1833 __git_complete_refs
1836 _git_mv ()
1838 case "$cur" in
1839 --*)
1840 __gitcomp_builtin mv
1841 return
1843 esac
1845 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"
1854 _git_notes ()
1856 local subcommands='add append copy edit get-ref list merge prune remove show'
1857 local subcommand="$(__git_find_on_cmdline "$subcommands")"
1859 case "$subcommand,$cur" in
1860 ,--*)
1861 __gitcomp_builtin notes
1864 case "$prev" in
1865 --ref)
1866 __git_complete_refs
1869 __gitcomp "$subcommands --ref"
1871 esac
1873 *,--reuse-message=*|*,--reedit-message=*)
1874 __git_complete_refs --cur="${cur#*=}"
1876 *,--*)
1877 __gitcomp_builtin notes_$subcommand
1879 prune,*|get-ref,*)
1880 # this command does not take a ref, do not complete it
1883 case "$prev" in
1884 -m|-F)
1887 __git_complete_refs
1889 esac
1891 esac
1894 _git_pull ()
1896 __git_complete_strategy && return
1898 case "$cur" in
1899 --recurse-submodules=*)
1900 __gitcomp "$__git_fetch_recurse_submodules" "" "${cur##--recurse-submodules=}"
1901 return
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"
1909 return
1911 esac
1912 __git_complete_remote_or_refspec
1915 __git_push_recurse_submodules="check on-demand only"
1917 __git_complete_force_with_lease ()
1919 local cur_=$1
1921 case "$cur_" in
1922 --*=)
1924 *:*)
1925 __git_complete_refs --cur="${cur_#*:}"
1928 __git_complete_refs --cur="$cur_"
1930 esac
1933 _git_push ()
1935 case "$prev" in
1936 --repo)
1937 __gitcomp_nl "$(__git_remotes)"
1938 return
1940 --recurse-submodules)
1941 __gitcomp "$__git_push_recurse_submodules"
1942 return
1944 esac
1945 case "$cur" in
1946 --repo=*)
1947 __gitcomp_nl "$(__git_remotes)" "" "${cur##--repo=}"
1948 return
1950 --recurse-submodules=*)
1951 __gitcomp "$__git_push_recurse_submodules" "" "${cur##--recurse-submodules=}"
1952 return
1954 --force-with-lease=*)
1955 __git_complete_force_with_lease "${cur##--force-with-lease=}"
1956 return
1958 --*)
1959 __gitcomp_builtin push
1960 return
1962 esac
1963 __git_complete_remote_or_refspec
1966 _git_rebase ()
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
1977 __git_complete_strategy && return
1978 case "$cur" in
1979 --whitespace=*)
1980 __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
1981 return
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
1998 return
1999 esac
2000 __git_complete_refs
2003 _git_reflog ()
2005 local subcommands="show delete expire"
2006 local subcommand="$(__git_find_on_cmdline "$subcommands")"
2008 if [ -z "$subcommand" ]; then
2009 __gitcomp "$subcommands"
2010 else
2011 __git_complete_refs
2015 __git_send_email_confirm_options="always never auto cc compose"
2016 __git_send_email_suppresscc_options="author self cc bodycc sob cccmd body all"
2018 _git_send_email ()
2020 case "$prev" in
2021 --to|--cc|--bcc|--from)
2022 __gitcomp "$(__git send-email --dump-aliases)"
2023 return
2025 esac
2027 case "$cur" in
2028 --confirm=*)
2029 __gitcomp "
2030 $__git_send_email_confirm_options
2031 " "" "${cur##--confirm=}"
2032 return
2034 --suppress-cc=*)
2035 __gitcomp "
2036 $__git_send_email_suppresscc_options
2037 " "" "${cur##--suppress-cc=}"
2039 return
2041 --smtp-encryption=*)
2042 __gitcomp "ssl tls" "" "${cur##--smtp-encryption=}"
2043 return
2045 --thread=*)
2046 __gitcomp "
2047 deep shallow
2048 " "" "${cur##--thread=}"
2049 return
2051 --to=*|--cc=*|--bcc=*|--from=*)
2052 __gitcomp "$(__git send-email --dump-aliases)" "" "${cur#--*=}"
2053 return
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
2068 esac
2069 __git_complete_revlist
2072 _git_stage ()
2074 _git_add
2077 _git_status ()
2079 local complete_opt
2080 local untracked_state
2082 case "$cur" in
2083 --ignore-submodules=*)
2084 __gitcomp "none untracked dirty all" "" "${cur##--ignore-submodules=}"
2085 return
2087 --untracked-files=*)
2088 __gitcomp "$__git_untracked_file_modes" "" "${cur##--untracked-files=}"
2089 return
2091 --column=*)
2092 __gitcomp "
2093 always never auto column row plain dense nodense
2094 " "" "${cur##--column=}"
2095 return
2097 --*)
2098 __gitcomp_builtin status "--no-column"
2099 return
2101 esac
2103 untracked_state="$(__git_get_option_value "-u" "--untracked-files=" \
2104 "$__git_untracked_file_modes" "status.showUntrackedFiles")"
2106 case "$untracked_state" in
2108 # --ignored option does not matter
2109 complete_opt=
2111 all|normal|*)
2112 complete_opt="--cached --directory --no-empty-directory --others"
2114 if [ -n "$(__git_find_on_cmdline "--ignored")" ]; then
2115 complete_opt="$complete_opt --ignored --exclude=*"
2118 esac
2120 __git_complete_index_file "$complete_opt"
2123 __git_config_get_set_variables ()
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
2133 -f|--file)
2134 config_file="$word $prevword"
2135 break
2137 esac
2138 prevword=$word
2139 c=$((--c))
2140 done
2142 __git config $config_file --name-only --list
2145 _git_config ()
2147 case "$prev" in
2148 branch.*.remote|branch.*.pushremote)
2149 __gitcomp_nl "$(__git_remotes)"
2150 return
2152 branch.*.merge)
2153 __git_complete_refs
2154 return
2156 branch.*.rebase)
2157 __gitcomp "false true merges preserve interactive"
2158 return
2160 remote.pushdefault)
2161 __gitcomp_nl "$(__git_remotes)"
2162 return
2164 remote.*.fetch)
2165 local remote="${prev#remote.}"
2166 remote="${remote%.fetch}"
2167 if [ -z "$cur" ]; then
2168 __gitcomp_nl "refs/heads/" "" "" ""
2169 return
2171 __gitcomp_nl "$(__git_refs_remotes "$remote")"
2172 return
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
2181 pull.twohead|pull.octopus)
2182 __git_compute_merge_strategies
2183 __gitcomp "$__git_merge_strategies"
2184 return
2186 color.branch|color.diff|color.interactive|\
2187 color.showbranch|color.status|color.ui)
2188 __gitcomp "always never auto"
2189 return
2191 color.pager)
2192 __gitcomp "false true"
2193 return
2195 color.*.*)
2196 __gitcomp "
2197 normal black red green yellow blue magenta cyan white
2198 bold dim ul blink reverse
2200 return
2202 diff.submodule)
2203 __gitcomp "log short"
2204 return
2206 help.format)
2207 __gitcomp "man info web html"
2208 return
2210 log.date)
2211 __gitcomp "$__git_log_date_formats"
2212 return
2214 sendemail.aliasfiletype)
2215 __gitcomp "mutt mailrc pine elm gnus"
2216 return
2218 sendemail.confirm)
2219 __gitcomp "$__git_send_email_confirm_options"
2220 return
2222 sendemail.suppresscc)
2223 __gitcomp "$__git_send_email_suppresscc_options"
2224 return
2226 sendemail.transferencoding)
2227 __gitcomp "7bit 8bit quoted-printable base64"
2228 return
2230 --get|--get-all|--unset|--unset-all)
2231 __gitcomp_nl "$(__git_config_get_set_variables)"
2232 return
2234 *.*)
2235 return
2237 esac
2238 case "$cur" in
2239 --*)
2240 __gitcomp_builtin config
2241 return
2243 branch.*.*)
2244 local pfx="${cur%.*}." cur_="${cur##*.}"
2245 __gitcomp "remote pushremote merge mergeoptions rebase" "$pfx" "$cur_"
2246 return
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
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
2262 difftool.*.*)
2263 local pfx="${cur%.*}." cur_="${cur##*.}"
2264 __gitcomp "cmd path" "$pfx" "$cur_"
2265 return
2267 man.*.*)
2268 local pfx="${cur%.*}." cur_="${cur##*.}"
2269 __gitcomp "cmd path" "$pfx" "$cur_"
2270 return
2272 mergetool.*.*)
2273 local pfx="${cur%.*}." cur_="${cur##*.}"
2274 __gitcomp "cmd path trustExitCode" "$pfx" "$cur_"
2275 return
2277 pager.*)
2278 local pfx="${cur%.*}." cur_="${cur#*.}"
2279 __git_compute_all_commands
2280 __gitcomp_nl "$__git_all_commands" "$pfx" "$cur_"
2281 return
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
2291 remote.*)
2292 local pfx="${cur%.*}." cur_="${cur#*.}"
2293 __gitcomp_nl "$(__git_remotes)" "$pfx" "$cur_" "."
2294 __gitcomp_nl_append "pushdefault" "$pfx" "$cur_"
2295 return
2297 url.*.*)
2298 local pfx="${cur%.*}." cur_="${cur##*.}"
2299 __gitcomp "insteadOf pushInsteadOf" "$pfx" "$cur_"
2300 return
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
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.
2631 _git_remote ()
2633 local subcommands="
2634 add rename remove set-head set-branches
2635 get-url set-url show prune update
2637 local subcommand="$(__git_find_on_cmdline "$subcommands")"
2638 if [ -z "$subcommand" ]; then
2639 case "$cur" in
2640 --*)
2641 __gitcomp_builtin remote
2644 __gitcomp "$subcommands"
2646 esac
2647 return
2650 case "$subcommand,$cur" in
2651 add,--*)
2652 __gitcomp_builtin remote_add "--no-tags"
2654 add,*)
2656 set-head,--*)
2657 __gitcomp_builtin remote_set-head
2659 set-branches,--*)
2660 __gitcomp_builtin remote_set-branches
2662 set-head,*|set-branches,*)
2663 __git_complete_remote_or_refspec
2665 update,--*)
2666 __gitcomp_builtin remote_update
2668 update,*)
2669 __gitcomp "$(__git_get_config_variables "remotes")"
2671 set-url,--*)
2672 __gitcomp_builtin remote_set-url
2674 get-url,--*)
2675 __gitcomp_builtin remote_get-url
2677 prune,--*)
2678 __gitcomp_builtin remote_prune
2681 __gitcomp_nl "$(__git_remotes)"
2683 esac
2686 _git_replace ()
2688 case "$cur" in
2689 --*)
2690 __gitcomp_builtin replace
2691 return
2693 esac
2694 __git_complete_refs
2697 _git_rerere ()
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
2708 _git_reset ()
2710 __git_has_doubledash && return
2712 case "$cur" in
2713 --*)
2714 __gitcomp_builtin reset
2715 return
2717 esac
2718 __git_complete_refs
2721 __git_revert_inprogress_options="--continue --quit --abort"
2723 _git_revert ()
2725 __git_find_repo_path
2726 if [ -f "$__git_repo_path"/REVERT_HEAD ]; then
2727 __gitcomp "$__git_revert_inprogress_options"
2728 return
2730 case "$cur" in
2731 --*)
2732 __gitcomp_builtin revert "--no-edit" \
2733 "$__git_revert_inprogress_options"
2734 return
2736 esac
2737 __git_complete_refs
2740 _git_rm ()
2742 case "$cur" in
2743 --*)
2744 __gitcomp_builtin rm
2745 return
2747 esac
2749 __git_complete_index_file "--cached"
2752 _git_shortlog ()
2754 __git_has_doubledash && return
2756 case "$cur" in
2757 --*)
2758 __gitcomp "
2759 $__git_log_common_options
2760 $__git_log_shortlog_options
2761 --numbered --summary --email
2763 return
2765 esac
2766 __git_complete_revlist
2769 _git_show ()
2771 __git_has_doubledash && return
2773 case "$cur" in
2774 --pretty=*|--format=*)
2775 __gitcomp "$__git_log_pretty_formats $(__git_pretty_aliases)
2776 " "" "${cur#*=}"
2777 return
2779 --diff-algorithm=*)
2780 __gitcomp "$__git_diff_algorithms" "" "${cur##--diff-algorithm=}"
2781 return
2783 --submodule=*)
2784 __gitcomp "$__git_diff_submodule_formats" "" "${cur##--submodule=}"
2785 return
2787 --*)
2788 __gitcomp "--pretty= --format= --abbrev-commit --oneline
2789 --show-signature
2790 $__git_diff_common_options
2792 return
2794 esac
2795 __git_complete_revlist_file
2798 _git_show_branch ()
2800 case "$cur" in
2801 --*)
2802 __gitcomp_builtin show-branch "--no-color"
2803 return
2805 esac
2806 __git_complete_revlist
2809 _git_stash ()
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"
2817 if [ -z "$subcommand" ]; then
2818 case "$cur" in
2819 --*)
2820 __gitcomp "$save_opts"
2822 sa*)
2823 if [ -z "$(__git_find_on_cmdline "$save_opts")" ]; then
2824 __gitcomp "save"
2828 if [ -z "$(__git_find_on_cmdline "$save_opts")" ]; then
2829 __gitcomp "$subcommands"
2832 esac
2833 else
2834 case "$subcommand,$cur" in
2835 push,--*)
2836 __gitcomp "$save_opts --message"
2838 save,--*)
2839 __gitcomp "$save_opts"
2841 apply,--*|pop,--*)
2842 __gitcomp "--index --quiet"
2844 drop,--*)
2845 __gitcomp "--quiet"
2847 show,--*|branch,--*)
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')"
2857 show,*|apply,*|drop,*|pop,*)
2858 __gitcomp_nl "$(__git stash list \
2859 | sed -n -e 's/:.*//p')"
2863 esac
2867 _git_submodule ()
2869 __git_has_doubledash && return
2871 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"
2879 __gitcomp "$subcommands"
2881 esac
2882 return
2885 case "$subcommand,$cur" in
2886 add,--*)
2887 __gitcomp "--branch --force --name --reference --depth"
2889 status,--*)
2890 __gitcomp "--cached --recursive"
2892 deinit,--*)
2893 __gitcomp "--force --all"
2895 update,--*)
2896 __gitcomp "
2897 --init --remote --no-fetch
2898 --recommend-shallow --no-recommend-shallow
2899 --force --rebase --merge --reference --depth --recursive --jobs
2902 summary,--*)
2903 __gitcomp "--cached --files --summary-limit"
2905 foreach,--*|sync,--*)
2906 __gitcomp "--recursive"
2910 esac
2913 _git_svn ()
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
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
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
2940 local cmt_opts="
2941 --edit --rmdir --find-copies-harder --copy-similarity=
2944 case "$subcommand,$cur" in
2945 fetch,--*)
2946 __gitcomp "--revision= --fetch-all $fc_opts"
2948 clone,--*)
2949 __gitcomp "--revision= $fc_opts $init_opts"
2951 init,--*)
2952 __gitcomp "$init_opts"
2954 dcommit,--*)
2955 __gitcomp "
2956 --merge --strategy= --verbose --dry-run
2957 --fetch-all --no-rebase --commit-url
2958 --revision --interactive $cmt_opts $fc_opts
2961 set-tree,--*)
2962 __gitcomp "--stdin $cmt_opts $fc_opts"
2964 create-ignore,--*|propget,--*|proplist,--*|show-ignore,--*|\
2965 show-externals,--*|mkdirs,--*)
2966 __gitcomp "--revision="
2968 log,--*)
2969 __gitcomp "
2970 --limit= --revision= --verbose --incremental
2971 --oneline --show-commit --non-recursive
2972 --authors-file= --color
2975 rebase,--*)
2976 __gitcomp "
2977 --merge --verbose --strategy= --local
2978 --fetch-all --dry-run $fc_opts
2981 commit-diff,--*)
2982 __gitcomp "--message= --file= --revision= $cmt_opts"
2984 info,--*)
2985 __gitcomp "--url"
2987 branch,--*)
2988 __gitcomp "--dry-run --message --tag"
2990 tag,--*)
2991 __gitcomp "--dry-run --message"
2993 blame,--*)
2994 __gitcomp "--git-format"
2996 migrate,--*)
2997 __gitcomp "
2998 --config-dir= --ignore-paths= --minimize
2999 --no-auth-cache --username=
3002 reset,--*)
3003 __gitcomp "--revision= --parent"
3007 esac
3011 _git_tag ()
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
3024 esac
3025 ((c++))
3026 done
3028 case "$prev" in
3029 -m|-F)
3031 -*|tag)
3032 if [ $f = 1 ]; then
3033 __gitcomp_direct "$(__git_tags "" "$cur" " ")"
3037 __git_complete_refs
3039 esac
3041 case "$cur" in
3042 --*)
3043 __gitcomp_builtin tag
3045 esac
3048 _git_whatchanged ()
3050 _git_log
3053 _git_worktree ()
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
3064 list,--*)
3065 __gitcomp_builtin worktree_list
3067 lock,--*)
3068 __gitcomp_builtin worktree_lock
3070 prune,--*)
3071 __gitcomp_builtin worktree_prune
3073 remove,--*)
3074 __gitcomp "--force"
3078 esac
3082 __git_complete_common () {
3083 local command="$1"
3085 case "$cur" in
3086 --*)
3087 __gitcomp_builtin "$command"
3089 esac
3092 __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)"
3097 case " $__git_cmds_with_parseopt_helper " in
3098 *" $1 "*)
3099 return 0
3102 return 1
3104 esac
3107 __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"
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
3128 __git_main ()
3130 local i c=1 command __git_dir __git_repo_path
3131 local __git_C_args C_args_count=0
3133 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]}"
3145 -*) ;;
3146 *) command="$i"; break ;;
3147 esac
3148 ((c++))
3149 done
3151 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
3158 -c|--namespace)
3159 # we don't support completing these options' arguments
3160 return
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
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)"
3189 esac
3190 return
3193 __git_complete_command "$command" && return
3195 local expansion=$(__git_aliased_command "$command")
3196 if [ -n "$expansion" ]; then
3197 words[1]=$expansion
3198 __git_complete_command "$expansion"
3202 __gitk_main ()
3204 __git_has_doubledash && return
3206 local __git_repo_path
3207 __git_find_repo_path
3209 local merge=""
3210 if [ -f "$__git_repo_path/MERGE_HEAD" ]; then
3211 merge="--merge"
3213 case "$cur" in
3214 --*)
3215 __gitcomp "
3216 $__git_log_common_options
3217 $__git_log_gitk_options
3218 $merge
3220 return
3222 esac
3223 __git_complete_revlist
3226 if [[ -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
3232 autoload -U +X compinit && compinit
3234 __gitcomp ()
3236 emulate -L zsh
3238 local cur_="${3-$cur}"
3240 case "$cur_" in
3241 --*=)
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
3257 esac
3260 __gitcomp_direct ()
3262 emulate -L zsh
3264 local IFS=$'\n'
3265 compset -P '*[=:]'
3266 compadd -Q -- ${=1} && _ret=0
3269 __gitcomp_nl ()
3271 emulate -L zsh
3273 local IFS=$'\n'
3274 compset -P '*[=:]'
3275 compadd -Q -S "${4- }" -p "${2-}" -- ${=1} && _ret=0
3278 __gitcomp_file_direct ()
3280 emulate -L zsh
3282 local IFS=$'\n'
3283 compset -P '*[=:]'
3284 compadd -Q -f -- ${=1} && _ret=0
3287 __gitcomp_file ()
3289 emulate -L zsh
3291 local IFS=$'\n'
3292 compset -P '*[=:]'
3293 compadd -Q -p "${2-}" -f -- ${=1} && _ret=0
3296 _git ()
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
3307 compdef _git git gitk
3308 return
3311 __git_func_wrap ()
3313 local cur words cword prev
3314 _get_comp_words_by_ref -n =: cur words cword prev
3318 # 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 ()
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
3329 # wrapper for backwards compatibility
3330 _git ()
3332 __git_wrap__git_main
3335 # wrapper for backwards compatibility
3336 _gitk ()
3338 __git_wrap__gitk_main
3341 __git_complete git __git_main
3342 __git_complete gitk __gitk_main
3344 # 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.
3348 if [ Cygwin = "$(uname -o 2>/dev/null)" ]; then
3349 __git_complete git.exe __git_main