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