952e660f06742270e84fb26afb3c98932787d432
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 "" \
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
1230 ;;
1231 *)
1232 if [ $only_local_ref = "y" -a $has_r = "n" ]; then
1233 __gitcomp_direct "$(__git_heads "" "$cur" " ")"
1234 else
1235 __git_complete_refs
1236 fi
1237 ;;
1238 esac
1239}
1240_git_bundle ()
1242{
1243 local cmd="${words[2]}"
1244 case "$cword" in
1245 2)
1246 __gitcomp "create list-heads verify unbundle"
1247 ;;
1248 3)
1249 # looking for a file
1250 ;;
1251 *)
1252 case "$cmd" in
1253 create)
1254 __git_complete_revlist
1255 ;;
1256 esac
1257 ;;
1258 esac
1259}
1260_git_checkout ()
1262{
1263 __git_has_doubledash && return
1264 case "$cur" in
1266 --conflict=*)
1267 __gitcomp "diff3 merge" "" "${cur##--conflict=}"
1268 ;;
1269 --*)
1270 __gitcomp_builtin checkout
1271 ;;
1272 *)
1273 # check if --track, --no-track, or --no-guess was specified
1274 # if so, disable DWIM mode
1275 local flags="--track --no-track --no-guess" track_opt="--track"
1276 if [ "$GIT_COMPLETION_CHECKOUT_NO_GUESS" = "1" ] ||
1277 [ -n "$(__git_find_on_cmdline "$flags")" ]; then
1278 track_opt=''
1279 fi
1280 __git_complete_refs $track_opt
1281 ;;
1282 esac
1283}
1284_git_cherry ()
1286{
1287 case "$cur" in
1288 --*)
1289 __gitcomp_builtin cherry
1290 return
1291 esac
1292 __git_complete_refs
1294}
1295__git_cherry_pick_inprogress_options="--continue --quit --abort"
1297_git_cherry_pick ()
1299{
1300 __git_find_repo_path
1301 if [ -f "$__git_repo_path"/CHERRY_PICK_HEAD ]; then
1302 __gitcomp "$__git_cherry_pick_inprogress_options"
1303 return
1304 fi
1305 case "$cur" in
1306 --*)
1307 __gitcomp_builtin cherry-pick "" \
1308 "$__git_cherry_pick_inprogress_options"
1309 ;;
1310 *)
1311 __git_complete_refs
1312 ;;
1313 esac
1314}
1315_git_clean ()
1317{
1318 case "$cur" in
1319 --*)
1320 __gitcomp_builtin clean
1321 return
1322 ;;
1323 esac
1324 # XXX should we check for -x option ?
1326 __git_complete_index_file "--others --directory"
1327}
1328_git_clone ()
1330{
1331 case "$cur" in
1332 --*)
1333 __gitcomp_builtin clone
1334 return
1335 ;;
1336 esac
1337}
1338__git_untracked_file_modes="all no normal"
1340_git_commit ()
1342{
1343 case "$prev" in
1344 -c|-C)
1345 __git_complete_refs
1346 return
1347 ;;
1348 esac
1349 case "$cur" in
1351 --cleanup=*)
1352 __gitcomp "default scissors strip verbatim whitespace
1353 " "" "${cur##--cleanup=}"
1354 return
1355 ;;
1356 --reuse-message=*|--reedit-message=*|\
1357 --fixup=*|--squash=*)
1358 __git_complete_refs --cur="${cur#*=}"
1359 return
1360 ;;
1361 --untracked-files=*)
1362 __gitcomp "$__git_untracked_file_modes" "" "${cur##--untracked-files=}"
1363 return
1364 ;;
1365 --*)
1366 __gitcomp_builtin commit
1367 return
1368 esac
1369 if __git rev-parse --verify --quiet HEAD >/dev/null; then
1371 __git_complete_index_file "--committable"
1372 else
1373 # This is the first commit
1374 __git_complete_index_file "--cached"
1375 fi
1376}
1377_git_describe ()
1379{
1380 case "$cur" in
1381 --*)
1382 __gitcomp_builtin describe
1383 return
1384 esac
1385 __git_complete_refs
1386}
1387__git_diff_algorithms="myers minimal patience histogram"
1389__git_diff_submodule_formats="diff log short"
1391__git_diff_common_options="--stat --numstat --shortstat --summary
1393 --patch-with-stat --name-only --name-status --color
1394 --no-color --color-words --no-renames --check
1395 --full-index --binary --abbrev --diff-filter=
1396 --find-copies-harder --ignore-cr-at-eol
1397 --text --ignore-space-at-eol --ignore-space-change
1398 --ignore-all-space --ignore-blank-lines --exit-code
1399 --quiet --ext-diff --no-ext-diff
1400 --no-prefix --src-prefix= --dst-prefix=
1401 --inter-hunk-context=
1402 --patience --histogram --minimal
1403 --raw --word-diff --word-diff-regex=
1404 --dirstat --dirstat= --dirstat-by-file
1405 --dirstat-by-file= --cumulative
1406 --diff-algorithm=
1407 --submodule --submodule= --ignore-submodules
1408"
1409_git_diff ()
1411{
1412 __git_has_doubledash && return
1413 case "$cur" in
1415 --diff-algorithm=*)
1416 __gitcomp "$__git_diff_algorithms" "" "${cur##--diff-algorithm=}"
1417 return
1418 ;;
1419 --submodule=*)
1420 __gitcomp "$__git_diff_submodule_formats" "" "${cur##--submodule=}"
1421 return
1422 ;;
1423 --*)
1424 __gitcomp "--cached --staged --pickaxe-all --pickaxe-regex
1425 --base --ours --theirs --no-index
1426 $__git_diff_common_options
1427 "
1428 return
1429 ;;
1430 esac
1431 __git_complete_revlist_file
1432}
1433__git_mergetools_common="diffuse diffmerge ecmerge emerge kdiff3 meld opendiff
1435 tkdiff vimdiff gvimdiff xxdiff araxis p4merge bc codecompare
1436"
1437_git_difftool ()
1439{
1440 __git_has_doubledash && return
1441 case "$cur" in
1443 --tool=*)
1444 __gitcomp "$__git_mergetools_common kompare" "" "${cur##--tool=}"
1445 return
1446 ;;
1447 --*)
1448 __gitcomp_builtin difftool "$__git_diff_common_options
1449 --base --cached --ours --theirs
1450 --pickaxe-all --pickaxe-regex
1451 --relative --staged
1452 "
1453 return
1454 ;;
1455 esac
1456 __git_complete_revlist_file
1457}
1458__git_fetch_recurse_submodules="yes on-demand no"
1460_git_fetch ()
1462{
1463 case "$cur" in
1464 --recurse-submodules=*)
1465 __gitcomp "$__git_fetch_recurse_submodules" "" "${cur##--recurse-submodules=}"
1466 return
1467 ;;
1468 --*)
1469 __gitcomp_builtin fetch
1470 return
1471 ;;
1472 esac
1473 __git_complete_remote_or_refspec
1474}
1475__git_format_patch_options="
1477 --stdout --attach --no-attach --thread --thread= --no-thread
1478 --numbered --start-number --numbered-files --keep-subject --signoff
1479 --signature --no-signature --in-reply-to= --cc= --full-index --binary
1480 --not --all --cover-letter --no-prefix --src-prefix= --dst-prefix=
1481 --inline --suffix= --ignore-if-in-upstream --subject-prefix=
1482 --output-directory --reroll-count --to= --quiet --notes
1483"
1484_git_format_patch ()
1486{
1487 case "$cur" in
1488 --thread=*)
1489 __gitcomp "
1490 deep shallow
1491 " "" "${cur##--thread=}"
1492 return
1493 ;;
1494 --*)
1495 __gitcomp "$__git_format_patch_options"
1496 return
1497 ;;
1498 esac
1499 __git_complete_revlist
1500}
1501_git_fsck ()
1503{
1504 case "$cur" in
1505 --*)
1506 __gitcomp_builtin fsck
1507 return
1508 ;;
1509 esac
1510}
1511_git_gitk ()
1513{
1514 _gitk
1515}
1516# Lists matching symbol names from a tag (as in ctags) file.
1518# 1: List symbol names matching this word.
1519# 2: The tag file to list symbol names from.
1520# 3: A prefix to be added to each listed symbol name (optional).
1521# 4: A suffix to be appended to each listed symbol name (optional).
1522__git_match_ctag () {
1523 awk -v pfx="${3-}" -v sfx="${4-}" "
1524 /^${1//\//\\/}/ { print pfx \$1 sfx }
1525 " "$2"
1526}
1527# Complete symbol names from a tag file.
1529# Usage: __git_complete_symbol [<option>]...
1530# --tags=<file>: The tag file to list symbol names from instead of the
1531# default "tags".
1532# --pfx=<prefix>: A prefix to be added to each symbol name.
1533# --cur=<word>: The current symbol name to be completed. Defaults to
1534# the current word to be completed.
1535# --sfx=<suffix>: A suffix to be appended to each symbol name instead
1536# of the default space.
1537__git_complete_symbol () {
1538 local tags=tags pfx="" cur_="${cur-}" sfx=" "
1539 while test $# != 0; do
1541 case "$1" in
1542 --tags=*) tags="${1##--tags=}" ;;
1543 --pfx=*) pfx="${1##--pfx=}" ;;
1544 --cur=*) cur_="${1##--cur=}" ;;
1545 --sfx=*) sfx="${1##--sfx=}" ;;
1546 *) return 1 ;;
1547 esac
1548 shift
1549 done
1550 if test -r "$tags"; then
1552 __gitcomp_direct "$(__git_match_ctag "$cur_" "$tags" "$pfx" "$sfx")"
1553 fi
1554}
1555_git_grep ()
1557{
1558 __git_has_doubledash && return
1559 case "$cur" in
1561 --*)
1562 __gitcomp_builtin grep
1563 return
1564 ;;
1565 esac
1566 case "$cword,$prev" in
1568 2,*|*,-*)
1569 __git_complete_symbol && return
1570 ;;
1571 esac
1572 __git_complete_refs
1574}
1575_git_help ()
1577{
1578 case "$cur" in
1579 --*)
1580 __gitcomp_builtin help
1581 return
1582 ;;
1583 esac
1584 __git_compute_all_commands
1585 __gitcomp "$__git_all_commands $(__git_aliases)
1586 attributes cli core-tutorial cvs-migration
1587 diffcore everyday gitk glossary hooks ignore modules
1588 namespaces repository-layout revisions tutorial tutorial-2
1589 workflows
1590 "
1591}
1592_git_init ()
1594{
1595 case "$cur" in
1596 --shared=*)
1597 __gitcomp "
1598 false true umask group all world everybody
1599 " "" "${cur##--shared=}"
1600 return
1601 ;;
1602 --*)
1603 __gitcomp_builtin init
1604 return
1605 ;;
1606 esac
1607}
1608_git_ls_files ()
1610{
1611 case "$cur" in
1612 --*)
1613 __gitcomp_builtin ls-files
1614 return
1615 ;;
1616 esac
1617 # XXX ignore options like --modified and always suggest all cached
1619 # files.
1620 __git_complete_index_file "--cached"
1621}
1622_git_ls_remote ()
1624{
1625 case "$cur" in
1626 --*)
1627 __gitcomp_builtin ls-remote
1628 return
1629 ;;
1630 esac
1631 __gitcomp_nl "$(__git_remotes)"
1632}
1633_git_ls_tree ()
1635{
1636 case "$cur" in
1637 --*)
1638 __gitcomp_builtin ls-tree
1639 return
1640 ;;
1641 esac
1642 __git_complete_file
1644}
1645# Options that go well for log, shortlog and gitk
1647__git_log_common_options="
1648 --not --all
1649 --branches --tags --remotes
1650 --first-parent --merges --no-merges
1651 --max-count=
1652 --max-age= --since= --after=
1653 --min-age= --until= --before=
1654 --min-parents= --max-parents=
1655 --no-min-parents --no-max-parents
1656"
1657# Options that go well for log and gitk (not shortlog)
1658__git_log_gitk_options="
1659 --dense --sparse --full-history
1660 --simplify-merges --simplify-by-decoration
1661 --left-right --notes --no-notes
1662"
1663# Options that go well for log and shortlog (not gitk)
1664__git_log_shortlog_options="
1665 --author= --committer= --grep=
1666 --all-match --invert-grep
1667"
1668__git_log_pretty_formats="oneline short medium full fuller email raw format:"
1670__git_log_date_formats="relative iso8601 rfc2822 short local default raw"
1671_git_log ()
1673{
1674 __git_has_doubledash && return
1675 __git_find_repo_path
1676 local merge=""
1678 if [ -f "$__git_repo_path/MERGE_HEAD" ]; then
1679 merge="--merge"
1680 fi
1681 case "$prev,$cur" in
1682 -L,:*:*)
1683 return # fall back to Bash filename completion
1684 ;;
1685 -L,:*)
1686 __git_complete_symbol --cur="${cur#:}" --sfx=":"
1687 return
1688 ;;
1689 -G,*|-S,*)
1690 __git_complete_symbol
1691 return
1692 ;;
1693 esac
1694 case "$cur" in
1695 --pretty=*|--format=*)
1696 __gitcomp "$__git_log_pretty_formats $(__git_pretty_aliases)
1697 " "" "${cur#*=}"
1698 return
1699 ;;
1700 --date=*)
1701 __gitcomp "$__git_log_date_formats" "" "${cur##--date=}"
1702 return
1703 ;;
1704 --decorate=*)
1705 __gitcomp "full short no" "" "${cur##--decorate=}"
1706 return
1707 ;;
1708 --diff-algorithm=*)
1709 __gitcomp "$__git_diff_algorithms" "" "${cur##--diff-algorithm=}"
1710 return
1711 ;;
1712 --submodule=*)
1713 __gitcomp "$__git_diff_submodule_formats" "" "${cur##--submodule=}"
1714 return
1715 ;;
1716 --*)
1717 __gitcomp "
1718 $__git_log_common_options
1719 $__git_log_shortlog_options
1720 $__git_log_gitk_options
1721 --root --topo-order --date-order --reverse
1722 --follow --full-diff
1723 --abbrev-commit --abbrev=
1724 --relative-date --date=
1725 --pretty= --format= --oneline
1726 --show-signature
1727 --cherry-mark
1728 --cherry-pick
1729 --graph
1730 --decorate --decorate=
1731 --walk-reflogs
1732 --parents --children
1733 $merge
1734 $__git_diff_common_options
1735 --pickaxe-all --pickaxe-regex
1736 "
1737 return
1738 ;;
1739 -L:*:*)
1740 return # fall back to Bash filename completion
1741 ;;
1742 -L:*)
1743 __git_complete_symbol --cur="${cur#-L:}" --sfx=":"
1744 return
1745 ;;
1746 -G*)
1747 __git_complete_symbol --pfx="-G" --cur="${cur#-G}"
1748 return
1749 ;;
1750 -S*)
1751 __git_complete_symbol --pfx="-S" --cur="${cur#-S}"
1752 return
1753 ;;
1754 esac
1755 __git_complete_revlist
1756}
1757_git_merge ()
1759{
1760 __git_complete_strategy && return
1761 case "$cur" in
1763 --*)
1764 __gitcomp_builtin merge
1765 return
1766 esac
1767 __git_complete_refs
1768}
1769_git_mergetool ()
1771{
1772 case "$cur" in
1773 --tool=*)
1774 __gitcomp "$__git_mergetools_common tortoisemerge" "" "${cur##--tool=}"
1775 return
1776 ;;
1777 --*)
1778 __gitcomp "--tool= --prompt --no-prompt"
1779 return
1780 ;;
1781 esac
1782}
1783_git_merge_base ()
1785{
1786 case "$cur" in
1787 --*)
1788 __gitcomp_builtin merge-base
1789 return
1790 ;;
1791 esac
1792 __git_complete_refs
1793}
1794_git_mv ()
1796{
1797 case "$cur" in
1798 --*)
1799 __gitcomp_builtin mv
1800 return
1801 ;;
1802 esac
1803 if [ $(__git_count_arguments "mv") -gt 0 ]; then
1805 # We need to show both cached and untracked files (including
1806 # empty directories) since this may not be the last argument.
1807 __git_complete_index_file "--cached --others --directory"
1808 else
1809 __git_complete_index_file "--cached"
1810 fi
1811}
1812_git_notes ()
1814{
1815 local subcommands='add append copy edit get-ref list merge prune remove show'
1816 local subcommand="$(__git_find_on_cmdline "$subcommands")"
1817 case "$subcommand,$cur" in
1819 ,--*)
1820 __gitcomp_builtin notes
1821 ;;
1822 ,*)
1823 case "$prev" in
1824 --ref)
1825 __git_complete_refs
1826 ;;
1827 *)
1828 __gitcomp "$subcommands --ref"
1829 ;;
1830 esac
1831 ;;
1832 *,--reuse-message=*|*,--reedit-message=*)
1833 __git_complete_refs --cur="${cur#*=}"
1834 ;;
1835 *,--*)
1836 __gitcomp_builtin notes_$subcommand
1837 ;;
1838 prune,*|get-ref,*)
1839 # this command does not take a ref, do not complete it
1840 ;;
1841 *)
1842 case "$prev" in
1843 -m|-F)
1844 ;;
1845 *)
1846 __git_complete_refs
1847 ;;
1848 esac
1849 ;;
1850 esac
1851}
1852_git_pull ()
1854{
1855 __git_complete_strategy && return
1856 case "$cur" in
1858 --recurse-submodules=*)
1859 __gitcomp "$__git_fetch_recurse_submodules" "" "${cur##--recurse-submodules=}"
1860 return
1861 ;;
1862 --*)
1863 __gitcomp_builtin pull
1864 return
1866 ;;
1867 esac
1868 __git_complete_remote_or_refspec
1869}
1870__git_push_recurse_submodules="check on-demand only"
1872__git_complete_force_with_lease ()
1874{
1875 local cur_=$1
1876 case "$cur_" in
1878 --*=)
1879 ;;
1880 *:*)
1881 __git_complete_refs --cur="${cur_#*:}"
1882 ;;
1883 *)
1884 __git_complete_refs --cur="$cur_"
1885 ;;
1886 esac
1887}
1888_git_push ()
1890{
1891 case "$prev" in
1892 --repo)
1893 __gitcomp_nl "$(__git_remotes)"
1894 return
1895 ;;
1896 --recurse-submodules)
1897 __gitcomp "$__git_push_recurse_submodules"
1898 return
1899 ;;
1900 esac
1901 case "$cur" in
1902 --repo=*)
1903 __gitcomp_nl "$(__git_remotes)" "" "${cur##--repo=}"
1904 return
1905 ;;
1906 --recurse-submodules=*)
1907 __gitcomp "$__git_push_recurse_submodules" "" "${cur##--recurse-submodules=}"
1908 return
1909 ;;
1910 --force-with-lease=*)
1911 __git_complete_force_with_lease "${cur##--force-with-lease=}"
1912 return
1913 ;;
1914 --*)
1915 __gitcomp_builtin push
1916 return
1917 ;;
1918 esac
1919 __git_complete_remote_or_refspec
1920}
1921_git_rebase ()
1923{
1924 __git_find_repo_path
1925 if [ -f "$__git_repo_path"/rebase-merge/interactive ]; then
1926 __gitcomp "--continue --skip --abort --quit --edit-todo --show-current-patch"
1927 return
1928 elif [ -d "$__git_repo_path"/rebase-apply ] || \
1929 [ -d "$__git_repo_path"/rebase-merge ]; then
1930 __gitcomp "--continue --skip --abort --quit --show-current-patch"
1931 return
1932 fi
1933 __git_complete_strategy && return
1934 case "$cur" in
1935 --whitespace=*)
1936 __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
1937 return
1938 ;;
1939 --*)
1940 __gitcomp "
1941 --onto --merge --strategy --interactive
1942 --rebase-merges --preserve-merges --stat --no-stat
1943 --committer-date-is-author-date --ignore-date
1944 --ignore-whitespace --whitespace=
1945 --autosquash --no-autosquash
1946 --fork-point --no-fork-point
1947 --autostash --no-autostash
1948 --verify --no-verify
1949 --keep-empty --root --force-rebase --no-ff
1950 --rerere-autoupdate
1951 --exec
1952 "
1953 return
1955 esac
1956 __git_complete_refs
1957}
1958_git_reflog ()
1960{
1961 local subcommands="show delete expire"
1962 local subcommand="$(__git_find_on_cmdline "$subcommands")"
1963 if [ -z "$subcommand" ]; then
1965 __gitcomp "$subcommands"
1966 else
1967 __git_complete_refs
1968 fi
1969}
1970__git_send_email_confirm_options="always never auto cc compose"
1972__git_send_email_suppresscc_options="author self cc bodycc sob cccmd body all"
1973_git_send_email ()
1975{
1976 case "$prev" in
1977 --to|--cc|--bcc|--from)
1978 __gitcomp "$(__git send-email --dump-aliases)"
1979 return
1980 ;;
1981 esac
1982 case "$cur" in
1984 --confirm=*)
1985 __gitcomp "
1986 $__git_send_email_confirm_options
1987 " "" "${cur##--confirm=}"
1988 return
1989 ;;
1990 --suppress-cc=*)
1991 __gitcomp "
1992 $__git_send_email_suppresscc_options
1993 " "" "${cur##--suppress-cc=}"
1994 return
1996 ;;
1997 --smtp-encryption=*)
1998 __gitcomp "ssl tls" "" "${cur##--smtp-encryption=}"
1999 return
2000 ;;
2001 --thread=*)
2002 __gitcomp "
2003 deep shallow
2004 " "" "${cur##--thread=}"
2005 return
2006 ;;
2007 --to=*|--cc=*|--bcc=*|--from=*)
2008 __gitcomp "$(__git send-email --dump-aliases)" "" "${cur#--*=}"
2009 return
2010 ;;
2011 --*)
2012 __gitcomp "--annotate --bcc --cc --cc-cmd --chain-reply-to
2013 --compose --confirm= --dry-run --envelope-sender
2014 --from --identity
2015 --in-reply-to --no-chain-reply-to --no-signed-off-by-cc
2016 --no-suppress-from --no-thread --quiet --reply-to
2017 --signed-off-by-cc --smtp-pass --smtp-server
2018 --smtp-server-port --smtp-encryption= --smtp-user
2019 --subject --suppress-cc= --suppress-from --thread --to
2020 --validate --no-validate
2021 $__git_format_patch_options"
2022 return
2023 ;;
2024 esac
2025 __git_complete_revlist
2026}
2027_git_stage ()
2029{
2030 _git_add
2031}
2032_git_status ()
2034{
2035 local complete_opt
2036 local untracked_state
2037 case "$cur" in
2039 --ignore-submodules=*)
2040 __gitcomp "none untracked dirty all" "" "${cur##--ignore-submodules=}"
2041 return
2042 ;;
2043 --untracked-files=*)
2044 __gitcomp "$__git_untracked_file_modes" "" "${cur##--untracked-files=}"
2045 return
2046 ;;
2047 --column=*)
2048 __gitcomp "
2049 always never auto column row plain dense nodense
2050 " "" "${cur##--column=}"
2051 return
2052 ;;
2053 --*)
2054 __gitcomp_builtin status
2055 return
2056 ;;
2057 esac
2058 untracked_state="$(__git_get_option_value "-u" "--untracked-files=" \
2060 "$__git_untracked_file_modes" "status.showUntrackedFiles")"
2061 case "$untracked_state" in
2063 no)
2064 # --ignored option does not matter
2065 complete_opt=
2066 ;;
2067 all|normal|*)
2068 complete_opt="--cached --directory --no-empty-directory --others"
2069 if [ -n "$(__git_find_on_cmdline "--ignored")" ]; then
2071 complete_opt="$complete_opt --ignored --exclude=*"
2072 fi
2073 ;;
2074 esac
2075 __git_complete_index_file "$complete_opt"
2077}
2078__git_config_get_set_variables ()
2080{
2081 local prevword word config_file= c=$cword
2082 while [ $c -gt 1 ]; do
2083 word="${words[c]}"
2084 case "$word" in
2085 --system|--global|--local|--file=*)
2086 config_file="$word"
2087 break
2088 ;;
2089 -f|--file)
2090 config_file="$word $prevword"
2091 break
2092 ;;
2093 esac
2094 prevword=$word
2095 c=$((--c))
2096 done
2097 __git config $config_file --name-only --list
2099}
2100_git_config ()
2102{
2103 case "$prev" in
2104 branch.*.remote|branch.*.pushremote)
2105 __gitcomp_nl "$(__git_remotes)"
2106 return
2107 ;;
2108 branch.*.merge)
2109 __git_complete_refs
2110 return
2111 ;;
2112 branch.*.rebase)
2113 __gitcomp "false true merges preserve interactive"
2114 return
2115 ;;
2116 remote.pushdefault)
2117 __gitcomp_nl "$(__git_remotes)"
2118 return
2119 ;;
2120 remote.*.fetch)
2121 local remote="${prev#remote.}"
2122 remote="${remote%.fetch}"
2123 if [ -z "$cur" ]; then
2124 __gitcomp_nl "refs/heads/" "" "" ""
2125 return
2126 fi
2127 __gitcomp_nl "$(__git_refs_remotes "$remote")"
2128 return
2129 ;;
2130 remote.*.push)
2131 local remote="${prev#remote.}"
2132 remote="${remote%.push}"
2133 __gitcomp_nl "$(__git for-each-ref \
2134 --format='%(refname):%(refname)' refs/heads)"
2135 return
2136 ;;
2137 pull.twohead|pull.octopus)
2138 __git_compute_merge_strategies
2139 __gitcomp "$__git_merge_strategies"
2140 return
2141 ;;
2142 color.branch|color.diff|color.interactive|\
2143 color.showbranch|color.status|color.ui)
2144 __gitcomp "always never auto"
2145 return
2146 ;;
2147 color.pager)
2148 __gitcomp "false true"
2149 return
2150 ;;
2151 color.*.*)
2152 __gitcomp "
2153 normal black red green yellow blue magenta cyan white
2154 bold dim ul blink reverse
2155 "
2156 return
2157 ;;
2158 diff.submodule)
2159 __gitcomp "log short"
2160 return
2161 ;;
2162 help.format)
2163 __gitcomp "man info web html"
2164 return
2165 ;;
2166 log.date)
2167 __gitcomp "$__git_log_date_formats"
2168 return
2169 ;;
2170 sendemail.aliasfiletype)
2171 __gitcomp "mutt mailrc pine elm gnus"
2172 return
2173 ;;
2174 sendemail.confirm)
2175 __gitcomp "$__git_send_email_confirm_options"
2176 return
2177 ;;
2178 sendemail.suppresscc)
2179 __gitcomp "$__git_send_email_suppresscc_options"
2180 return
2181 ;;
2182 sendemail.transferencoding)
2183 __gitcomp "7bit 8bit quoted-printable base64"
2184 return
2185 ;;
2186 --get|--get-all|--unset|--unset-all)
2187 __gitcomp_nl "$(__git_config_get_set_variables)"
2188 return
2189 ;;
2190 *.*)
2191 return
2192 ;;
2193 esac
2194 case "$cur" in
2195 --*)
2196 __gitcomp_builtin config
2197 return
2198 ;;
2199 branch.*.*)
2200 local pfx="${cur%.*}." cur_="${cur##*.}"
2201 __gitcomp "remote pushremote merge mergeoptions rebase" "$pfx" "$cur_"
2202 return
2203 ;;
2204 branch.*)
2205 local pfx="${cur%.*}." cur_="${cur#*.}"
2206 __gitcomp_direct "$(__git_heads "$pfx" "$cur_" ".")"
2207 __gitcomp_nl_append $'autosetupmerge\nautosetuprebase\n' "$pfx" "$cur_"
2208 return
2209 ;;
2210 guitool.*.*)
2211 local pfx="${cur%.*}." cur_="${cur##*.}"
2212 __gitcomp "
2213 argprompt cmd confirm needsfile noconsole norescan
2214 prompt revprompt revunmerged title
2215 " "$pfx" "$cur_"
2216 return
2217 ;;
2218 difftool.*.*)
2219 local pfx="${cur%.*}." cur_="${cur##*.}"
2220 __gitcomp "cmd path" "$pfx" "$cur_"
2221 return
2222 ;;
2223 man.*.*)
2224 local pfx="${cur%.*}." cur_="${cur##*.}"
2225 __gitcomp "cmd path" "$pfx" "$cur_"
2226 return
2227 ;;
2228 mergetool.*.*)
2229 local pfx="${cur%.*}." cur_="${cur##*.}"
2230 __gitcomp "cmd path trustExitCode" "$pfx" "$cur_"
2231 return
2232 ;;
2233 pager.*)
2234 local pfx="${cur%.*}." cur_="${cur#*.}"
2235 __git_compute_all_commands
2236 __gitcomp_nl "$__git_all_commands" "$pfx" "$cur_"
2237 return
2238 ;;
2239 remote.*.*)
2240 local pfx="${cur%.*}." cur_="${cur##*.}"
2241 __gitcomp "
2242 url proxy fetch push mirror skipDefaultUpdate
2243 receivepack uploadpack tagopt pushurl
2244 " "$pfx" "$cur_"
2245 return
2246 ;;
2247 remote.*)
2248 local pfx="${cur%.*}." cur_="${cur#*.}"
2249 __gitcomp_nl "$(__git_remotes)" "$pfx" "$cur_" "."
2250 __gitcomp_nl_append "pushdefault" "$pfx" "$cur_"
2251 return
2252 ;;
2253 url.*.*)
2254 local pfx="${cur%.*}." cur_="${cur##*.}"
2255 __gitcomp "insteadOf pushInsteadOf" "$pfx" "$cur_"
2256 return
2257 ;;
2258 esac
2259 __gitcomp "
2260 add.ignoreErrors
2261 advice.amWorkDir
2262 advice.commitBeforeMerge
2263 advice.detachedHead
2264 advice.implicitIdentity
2265 advice.pushAlreadyExists
2266 advice.pushFetchFirst
2267 advice.pushNeedsForce
2268 advice.pushNonFFCurrent
2269 advice.pushNonFFMatching
2270 advice.pushUpdateRejected
2271 advice.resolveConflict
2272 advice.rmHints
2273 advice.statusHints
2274 advice.statusUoption
2275 advice.ignoredHook
2276 alias.
2277 am.keepcr
2278 am.threeWay
2279 apply.ignorewhitespace
2280 apply.whitespace
2281 branch.autosetupmerge
2282 branch.autosetuprebase
2283 browser.
2284 clean.requireForce
2285 color.branch
2286 color.branch.current
2287 color.branch.local
2288 color.branch.plain
2289 color.branch.remote
2290 color.decorate.HEAD
2291 color.decorate.branch
2292 color.decorate.remoteBranch
2293 color.decorate.stash
2294 color.decorate.tag
2295 color.diff
2296 color.diff.commit
2297 color.diff.frag
2298 color.diff.func
2299 color.diff.meta
2300 color.diff.new
2301 color.diff.old
2302 color.diff.plain
2303 color.diff.whitespace
2304 color.grep
2305 color.grep.context
2306 color.grep.filename
2307 color.grep.function
2308 color.grep.linenumber
2309 color.grep.match
2310 color.grep.selected
2311 color.grep.separator
2312 color.interactive
2313 color.interactive.error
2314 color.interactive.header
2315 color.interactive.help
2316 color.interactive.prompt
2317 color.pager
2318 color.showbranch
2319 color.status
2320 color.status.added
2321 color.status.changed
2322 color.status.header
2323 color.status.localBranch
2324 color.status.nobranch
2325 color.status.remoteBranch
2326 color.status.unmerged
2327 color.status.untracked
2328 color.status.updated
2329 color.ui
2330 commit.cleanup
2331 commit.gpgSign
2332 commit.status
2333 commit.template
2334 commit.verbose
2335 core.abbrev
2336 core.askpass
2337 core.attributesfile
2338 core.autocrlf
2339 core.bare
2340 core.bigFileThreshold
2341 core.checkStat
2342 core.commentChar
2343 core.commitGraph
2344 core.compression
2345 core.createObject
2346 core.deltaBaseCacheLimit
2347 core.editor
2348 core.eol
2349 core.excludesfile
2350 core.fileMode
2351 core.fsyncobjectfiles
2352 core.gitProxy
2353 core.hideDotFiles
2354 core.hooksPath
2355 core.ignoreStat
2356 core.ignorecase
2357 core.logAllRefUpdates
2358 core.loosecompression
2359 core.notesRef
2360 core.packedGitLimit
2361 core.packedGitWindowSize
2362 core.packedRefsTimeout
2363 core.pager
2364 core.precomposeUnicode
2365 core.preferSymlinkRefs
2366 core.preloadindex
2367 core.protectHFS
2368 core.protectNTFS
2369 core.quotepath
2370 core.repositoryFormatVersion
2371 core.safecrlf
2372 core.sharedRepository
2373 core.sparseCheckout
2374 core.splitIndex
2375 core.sshCommand
2376 core.symlinks
2377 core.trustctime
2378 core.untrackedCache
2379 core.warnAmbiguousRefs
2380 core.whitespace
2381 core.worktree
2382 credential.helper
2383 credential.useHttpPath
2384 credential.username
2385 credentialCache.ignoreSIGHUP
2386 diff.autorefreshindex
2387 diff.external
2388 diff.ignoreSubmodules
2389 diff.mnemonicprefix
2390 diff.noprefix
2391 diff.renameLimit
2392 diff.renames
2393 diff.statGraphWidth
2394 diff.submodule
2395 diff.suppressBlankEmpty
2396 diff.tool
2397 diff.wordRegex
2398 diff.algorithm
2399 difftool.
2400 difftool.prompt
2401 fetch.recurseSubmodules
2402 fetch.unpackLimit
2403 format.attach
2404 format.cc
2405 format.coverLetter
2406 format.from
2407 format.headers
2408 format.numbered
2409 format.pretty
2410 format.signature
2411 format.signoff
2412 format.subjectprefix
2413 format.suffix
2414 format.thread
2415 format.to
2416 gc.
2417 gc.aggressiveDepth
2418 gc.aggressiveWindow
2419 gc.auto
2420 gc.autoDetach
2421 gc.autopacklimit
2422 gc.logExpiry
2423 gc.packrefs
2424 gc.pruneexpire
2425 gc.reflogexpire
2426 gc.reflogexpireunreachable
2427 gc.rerereresolved
2428 gc.rerereunresolved
2429 gc.worktreePruneExpire
2430 gitcvs.allbinary
2431 gitcvs.commitmsgannotation
2432 gitcvs.dbTableNamePrefix
2433 gitcvs.dbdriver
2434 gitcvs.dbname
2435 gitcvs.dbpass
2436 gitcvs.dbuser
2437 gitcvs.enabled
2438 gitcvs.logfile
2439 gitcvs.usecrlfattr
2440 guitool.
2441 gui.blamehistoryctx
2442 gui.commitmsgwidth
2443 gui.copyblamethreshold
2444 gui.diffcontext
2445 gui.encoding
2446 gui.fastcopyblame
2447 gui.matchtrackingbranch
2448 gui.newbranchtemplate
2449 gui.pruneduringfetch
2450 gui.spellingdictionary
2451 gui.trustmtime
2452 help.autocorrect
2453 help.browser
2454 help.format
2455 http.lowSpeedLimit
2456 http.lowSpeedTime
2457 http.maxRequests
2458 http.minSessions
2459 http.noEPSV
2460 http.postBuffer
2461 http.proxy
2462 http.sslCipherList
2463 http.sslVersion
2464 http.sslCAInfo
2465 http.sslCAPath
2466 http.sslCert
2467 http.sslCertPasswordProtected
2468 http.sslKey
2469 http.sslVerify
2470 http.useragent
2471 i18n.commitEncoding
2472 i18n.logOutputEncoding
2473 imap.authMethod
2474 imap.folder
2475 imap.host
2476 imap.pass
2477 imap.port
2478 imap.preformattedHTML
2479 imap.sslverify
2480 imap.tunnel
2481 imap.user
2482 init.templatedir
2483 instaweb.browser
2484 instaweb.httpd
2485 instaweb.local
2486 instaweb.modulepath
2487 instaweb.port
2488 interactive.singlekey
2489 log.date
2490 log.decorate
2491 log.showroot
2492 mailmap.file
2493 man.
2494 man.viewer
2495 merge.
2496 merge.conflictstyle
2497 merge.log
2498 merge.renameLimit
2499 merge.renormalize
2500 merge.stat
2501 merge.tool
2502 merge.verbosity
2503 mergetool.
2504 mergetool.keepBackup
2505 mergetool.keepTemporaries
2506 mergetool.prompt
2507 notes.displayRef
2508 notes.rewrite.
2509 notes.rewrite.amend
2510 notes.rewrite.rebase
2511 notes.rewriteMode
2512 notes.rewriteRef
2513 pack.compression
2514 pack.deltaCacheLimit
2515 pack.deltaCacheSize
2516 pack.depth
2517 pack.indexVersion
2518 pack.packSizeLimit
2519 pack.threads
2520 pack.window
2521 pack.windowMemory
2522 pager.
2523 pretty.
2524 pull.octopus
2525 pull.twohead
2526 push.default
2527 push.followTags
2528 rebase.autosquash
2529 rebase.stat
2530 receive.autogc
2531 receive.denyCurrentBranch
2532 receive.denyDeleteCurrent
2533 receive.denyDeletes
2534 receive.denyNonFastForwards
2535 receive.fsckObjects
2536 receive.unpackLimit
2537 receive.updateserverinfo
2538 remote.pushdefault
2539 remotes.
2540 repack.usedeltabaseoffset
2541 rerere.autoupdate
2542 rerere.enabled
2543 sendemail.
2544 sendemail.aliasesfile
2545 sendemail.aliasfiletype
2546 sendemail.bcc
2547 sendemail.cc
2548 sendemail.cccmd
2549 sendemail.chainreplyto
2550 sendemail.confirm
2551 sendemail.envelopesender
2552 sendemail.from
2553 sendemail.identity
2554 sendemail.multiedit
2555 sendemail.signedoffbycc
2556 sendemail.smtpdomain
2557 sendemail.smtpencryption
2558 sendemail.smtppass
2559 sendemail.smtpserver
2560 sendemail.smtpserveroption
2561 sendemail.smtpserverport
2562 sendemail.smtpuser
2563 sendemail.suppresscc
2564 sendemail.suppressfrom
2565 sendemail.thread
2566 sendemail.to
2567 sendemail.tocmd
2568 sendemail.validate
2569 sendemail.smtpbatchsize
2570 sendemail.smtprelogindelay
2571 showbranch.default
2572 status.relativePaths
2573 status.showUntrackedFiles
2574 status.submodulesummary
2575 submodule.
2576 tar.umask
2577 transfer.unpackLimit
2578 url.
2579 user.email
2580 user.name
2581 user.signingkey
2582 web.browser
2583 branch. remote.
2584 "
2585}
2586_git_remote ()
2588{
2589 local subcommands="
2590 add rename remove set-head set-branches
2591 get-url set-url show prune update
2592 "
2593 local subcommand="$(__git_find_on_cmdline "$subcommands")"
2594 if [ -z "$subcommand" ]; then
2595 case "$cur" in
2596 --*)
2597 __gitcomp_builtin remote
2598 ;;
2599 *)
2600 __gitcomp "$subcommands"
2601 ;;
2602 esac
2603 return
2604 fi
2605 case "$subcommand,$cur" in
2607 add,--*)
2608 __gitcomp_builtin remote_add
2609 ;;
2610 add,*)
2611 ;;
2612 set-head,--*)
2613 __gitcomp_builtin remote_set-head
2614 ;;
2615 set-branches,--*)
2616 __gitcomp_builtin remote_set-branches
2617 ;;
2618 set-head,*|set-branches,*)
2619 __git_complete_remote_or_refspec
2620 ;;
2621 update,--*)
2622 __gitcomp_builtin remote_update
2623 ;;
2624 update,*)
2625 __gitcomp "$(__git_get_config_variables "remotes")"
2626 ;;
2627 set-url,--*)
2628 __gitcomp_builtin remote_set-url
2629 ;;
2630 get-url,--*)
2631 __gitcomp_builtin remote_get-url
2632 ;;
2633 prune,--*)
2634 __gitcomp_builtin remote_prune
2635 ;;
2636 *)
2637 __gitcomp_nl "$(__git_remotes)"
2638 ;;
2639 esac
2640}
2641_git_replace ()
2643{
2644 case "$cur" in
2645 --*)
2646 __gitcomp_builtin replace
2647 return
2648 ;;
2649 esac
2650 __git_complete_refs
2651}
2652_git_rerere ()
2654{
2655 local subcommands="clear forget diff remaining status gc"
2656 local subcommand="$(__git_find_on_cmdline "$subcommands")"
2657 if test -z "$subcommand"
2658 then
2659 __gitcomp "$subcommands"
2660 return
2661 fi
2662}
2663_git_reset ()
2665{
2666 __git_has_doubledash && return
2667 case "$cur" in
2669 --*)
2670 __gitcomp_builtin reset
2671 return
2672 ;;
2673 esac
2674 __git_complete_refs
2675}
2676__git_revert_inprogress_options="--continue --quit --abort"
2678_git_revert ()
2680{
2681 __git_find_repo_path
2682 if [ -f "$__git_repo_path"/REVERT_HEAD ]; then
2683 __gitcomp "$__git_revert_inprogress_options"
2684 return
2685 fi
2686 case "$cur" in
2687 --*)
2688 __gitcomp_builtin revert "" \
2689 "$__git_revert_inprogress_options"
2690 return
2691 ;;
2692 esac
2693 __git_complete_refs
2694}
2695_git_rm ()
2697{
2698 case "$cur" in
2699 --*)
2700 __gitcomp_builtin rm
2701 return
2702 ;;
2703 esac
2704 __git_complete_index_file "--cached"
2706}
2707_git_shortlog ()
2709{
2710 __git_has_doubledash && return
2711 case "$cur" in
2713 --*)
2714 __gitcomp "
2715 $__git_log_common_options
2716 $__git_log_shortlog_options
2717 --numbered --summary --email
2718 "
2719 return
2720 ;;
2721 esac
2722 __git_complete_revlist
2723}
2724_git_show ()
2726{
2727 __git_has_doubledash && return
2728 case "$cur" in
2730 --pretty=*|--format=*)
2731 __gitcomp "$__git_log_pretty_formats $(__git_pretty_aliases)
2732 " "" "${cur#*=}"
2733 return
2734 ;;
2735 --diff-algorithm=*)
2736 __gitcomp "$__git_diff_algorithms" "" "${cur##--diff-algorithm=}"
2737 return
2738 ;;
2739 --submodule=*)
2740 __gitcomp "$__git_diff_submodule_formats" "" "${cur##--submodule=}"
2741 return
2742 ;;
2743 --*)
2744 __gitcomp "--pretty= --format= --abbrev-commit --oneline
2745 --show-signature
2746 $__git_diff_common_options
2747 "
2748 return
2749 ;;
2750 esac
2751 __git_complete_revlist_file
2752}
2753_git_show_branch ()
2755{
2756 case "$cur" in
2757 --*)
2758 __gitcomp_builtin show-branch
2759 return
2760 ;;
2761 esac
2762 __git_complete_revlist
2763}
2764_git_stash ()
2766{
2767 local save_opts='--all --keep-index --no-keep-index --quiet --patch --include-untracked'
2768 local subcommands='push list show apply clear drop pop create branch'
2769 local subcommand="$(__git_find_on_cmdline "$subcommands save")"
2770 if [ -n "$(__git_find_on_cmdline "-p")" ]; then
2771 subcommand="push"
2772 fi
2773 if [ -z "$subcommand" ]; then
2774 case "$cur" in
2775 --*)
2776 __gitcomp "$save_opts"
2777 ;;
2778 sa*)
2779 if [ -z "$(__git_find_on_cmdline "$save_opts")" ]; then
2780 __gitcomp "save"
2781 fi
2782 ;;
2783 *)
2784 if [ -z "$(__git_find_on_cmdline "$save_opts")" ]; then
2785 __gitcomp "$subcommands"
2786 fi
2787 ;;
2788 esac
2789 else
2790 case "$subcommand,$cur" in
2791 push,--*)
2792 __gitcomp "$save_opts --message"
2793 ;;
2794 save,--*)
2795 __gitcomp "$save_opts"
2796 ;;
2797 apply,--*|pop,--*)
2798 __gitcomp "--index --quiet"
2799 ;;
2800 drop,--*)
2801 __gitcomp "--quiet"
2802 ;;
2803 show,--*|branch,--*)
2804 ;;
2805 branch,*)
2806 if [ $cword -eq 3 ]; then
2807 __git_complete_refs
2808 else
2809 __gitcomp_nl "$(__git stash list \
2810 | sed -n -e 's/:.*//p')"
2811 fi
2812 ;;
2813 show,*|apply,*|drop,*|pop,*)
2814 __gitcomp_nl "$(__git stash list \
2815 | sed -n -e 's/:.*//p')"
2816 ;;
2817 *)
2818 ;;
2819 esac
2820 fi
2821}
2822_git_submodule ()
2824{
2825 __git_has_doubledash && return
2826 local subcommands="add status init deinit update summary foreach sync"
2828 local subcommand="$(__git_find_on_cmdline "$subcommands")"
2829 if [ -z "$subcommand" ]; then
2830 case "$cur" in
2831 --*)
2832 __gitcomp "--quiet"
2833 ;;
2834 *)
2835 __gitcomp "$subcommands"
2836 ;;
2837 esac
2838 return
2839 fi
2840 case "$subcommand,$cur" in
2842 add,--*)
2843 __gitcomp "--branch --force --name --reference --depth"
2844 ;;
2845 status,--*)
2846 __gitcomp "--cached --recursive"
2847 ;;
2848 deinit,--*)
2849 __gitcomp "--force --all"
2850 ;;
2851 update,--*)
2852 __gitcomp "
2853 --init --remote --no-fetch
2854 --recommend-shallow --no-recommend-shallow
2855 --force --rebase --merge --reference --depth --recursive --jobs
2856 "
2857 ;;
2858 summary,--*)
2859 __gitcomp "--cached --files --summary-limit"
2860 ;;
2861 foreach,--*|sync,--*)
2862 __gitcomp "--recursive"
2863 ;;
2864 *)
2865 ;;
2866 esac
2867}
2868_git_svn ()
2870{
2871 local subcommands="
2872 init fetch clone rebase dcommit log find-rev
2873 set-tree commit-diff info create-ignore propget
2874 proplist show-ignore show-externals branch tag blame
2875 migrate mkdirs reset gc
2876 "
2877 local subcommand="$(__git_find_on_cmdline "$subcommands")"
2878 if [ -z "$subcommand" ]; then
2879 __gitcomp "$subcommands"
2880 else
2881 local remote_opts="--username= --config-dir= --no-auth-cache"
2882 local fc_opts="
2883 --follow-parent --authors-file= --repack=
2884 --no-metadata --use-svm-props --use-svnsync-props
2885 --log-window-size= --no-checkout --quiet
2886 --repack-flags --use-log-author --localtime
2887 --add-author-from
2888 --ignore-paths= --include-paths= $remote_opts
2889 "
2890 local init_opts="
2891 --template= --shared= --trunk= --tags=
2892 --branches= --stdlayout --minimize-url
2893 --no-metadata --use-svm-props --use-svnsync-props
2894 --rewrite-root= --prefix= $remote_opts
2895 "
2896 local cmt_opts="
2897 --edit --rmdir --find-copies-harder --copy-similarity=
2898 "
2899 case "$subcommand,$cur" in
2901 fetch,--*)
2902 __gitcomp "--revision= --fetch-all $fc_opts"
2903 ;;
2904 clone,--*)
2905 __gitcomp "--revision= $fc_opts $init_opts"
2906 ;;
2907 init,--*)
2908 __gitcomp "$init_opts"
2909 ;;
2910 dcommit,--*)
2911 __gitcomp "
2912 --merge --strategy= --verbose --dry-run
2913 --fetch-all --no-rebase --commit-url
2914 --revision --interactive $cmt_opts $fc_opts
2915 "
2916 ;;
2917 set-tree,--*)
2918 __gitcomp "--stdin $cmt_opts $fc_opts"
2919 ;;
2920 create-ignore,--*|propget,--*|proplist,--*|show-ignore,--*|\
2921 show-externals,--*|mkdirs,--*)
2922 __gitcomp "--revision="
2923 ;;
2924 log,--*)
2925 __gitcomp "
2926 --limit= --revision= --verbose --incremental
2927 --oneline --show-commit --non-recursive
2928 --authors-file= --color
2929 "
2930 ;;
2931 rebase,--*)
2932 __gitcomp "
2933 --merge --verbose --strategy= --local
2934 --fetch-all --dry-run $fc_opts
2935 "
2936 ;;
2937 commit-diff,--*)
2938 __gitcomp "--message= --file= --revision= $cmt_opts"
2939 ;;
2940 info,--*)
2941 __gitcomp "--url"
2942 ;;
2943 branch,--*)
2944 __gitcomp "--dry-run --message --tag"
2945 ;;
2946 tag,--*)
2947 __gitcomp "--dry-run --message"
2948 ;;
2949 blame,--*)
2950 __gitcomp "--git-format"
2951 ;;
2952 migrate,--*)
2953 __gitcomp "
2954 --config-dir= --ignore-paths= --minimize
2955 --no-auth-cache --username=
2956 "
2957 ;;
2958 reset,--*)
2959 __gitcomp "--revision= --parent"
2960 ;;
2961 *)
2962 ;;
2963 esac
2964 fi
2965}
2966_git_tag ()
2968{
2969 local i c=1 f=0
2970 while [ $c -lt $cword ]; do
2971 i="${words[c]}"
2972 case "$i" in
2973 -d|--delete|-v|--verify)
2974 __gitcomp_direct "$(__git_tags "" "$cur" " ")"
2975 return
2976 ;;
2977 -f)
2978 f=1
2979 ;;
2980 esac
2981 ((c++))
2982 done
2983 case "$prev" in
2985 -m|-F)
2986 ;;
2987 -*|tag)
2988 if [ $f = 1 ]; then
2989 __gitcomp_direct "$(__git_tags "" "$cur" " ")"
2990 fi
2991 ;;
2992 *)
2993 __git_complete_refs
2994 ;;
2995 esac
2996 case "$cur" in
2998 --*)
2999 __gitcomp_builtin tag
3000 ;;
3001 esac
3002}
3003_git_whatchanged ()
3005{
3006 _git_log
3007}
3008_git_worktree ()
3010{
3011 local subcommands="add list lock move prune remove unlock"
3012 local subcommand="$(__git_find_on_cmdline "$subcommands")"
3013 if [ -z "$subcommand" ]; then
3014 __gitcomp "$subcommands"
3015 else
3016 case "$subcommand,$cur" in
3017 add,--*)
3018 __gitcomp_builtin worktree_add
3019 ;;
3020 list,--*)
3021 __gitcomp_builtin worktree_list
3022 ;;
3023 lock,--*)
3024 __gitcomp_builtin worktree_lock
3025 ;;
3026 prune,--*)
3027 __gitcomp_builtin worktree_prune
3028 ;;
3029 remove,--*)
3030 __gitcomp "--force"
3031 ;;
3032 *)
3033 ;;
3034 esac
3035 fi
3036}
3037__git_complete_common () {
3039 local command="$1"
3040 case "$cur" in
3042 --*)
3043 __gitcomp_builtin "$command"
3044 ;;
3045 esac
3046}
3047__git_cmds_with_parseopt_helper=
3049__git_support_parseopt_helper () {
3050 test -n "$__git_cmds_with_parseopt_helper" ||
3051 __git_cmds_with_parseopt_helper="$(__git --list-parseopt-builtins)"
3052 case " $__git_cmds_with_parseopt_helper " in
3054 *" $1 "*)
3055 return 0
3056 ;;
3057 *)
3058 return 1
3059 ;;
3060 esac
3061}
3062__git_complete_command () {
3064 local command="$1"
3065 local completion_func="_git_${command//-/_}"
3066 if ! declare -f $completion_func >/dev/null 2>/dev/null &&
3067 declare -f _completion_loader >/dev/null 2>/dev/null
3068 then
3069 _completion_loader "git-$command"
3070 fi
3071 if declare -f $completion_func >/dev/null 2>/dev/null
3072 then
3073 $completion_func
3074 return 0
3075 elif __git_support_parseopt_helper "$command"
3076 then
3077 __git_complete_common "$command"
3078 return 0
3079 else
3080 return 1
3081 fi
3082}
3083__git_main ()
3085{
3086 local i c=1 command __git_dir __git_repo_path
3087 local __git_C_args C_args_count=0
3088 while [ $c -lt $cword ]; do
3090 i="${words[c]}"
3091 case "$i" in
3092 --git-dir=*) __git_dir="${i#--git-dir=}" ;;
3093 --git-dir) ((c++)) ; __git_dir="${words[c]}" ;;
3094 --bare) __git_dir="." ;;
3095 --help) command="help"; break ;;
3096 -c|--work-tree|--namespace) ((c++)) ;;
3097 -C) __git_C_args[C_args_count++]=-C
3098 ((c++))
3099 __git_C_args[C_args_count++]="${words[c]}"
3100 ;;
3101 -*) ;;
3102 *) command="$i"; break ;;
3103 esac
3104 ((c++))
3105 done
3106 if [ -z "$command" ]; then
3108 case "$prev" in
3109 --git-dir|-C|--work-tree)
3110 # these need a path argument, let's fall back to
3111 # Bash filename completion
3112 return
3113 ;;
3114 -c|--namespace)
3115 # we don't support completing these options' arguments
3116 return
3117 ;;
3118 esac
3119 case "$cur" in
3120 --*) __gitcomp "
3121 --paginate
3122 --no-pager
3123 --git-dir=
3124 --bare
3125 --version
3126 --exec-path
3127 --exec-path=
3128 --html-path
3129 --man-path
3130 --info-path
3131 --work-tree=
3132 --namespace=
3133 --no-replace-objects
3134 --help
3135 "
3136 ;;
3137 *) __git_compute_porcelain_commands
3138 __gitcomp "$__git_porcelain_commands $(__git_aliases)" ;;
3139 esac
3140 return
3141 fi
3142 __git_complete_command "$command" && return
3144 local expansion=$(__git_aliased_command "$command")
3146 if [ -n "$expansion" ]; then
3147 words[1]=$expansion
3148 __git_complete_command "$expansion"
3149 fi
3150}
3151__gitk_main ()
3153{
3154 __git_has_doubledash && return
3155 local __git_repo_path
3157 __git_find_repo_path
3158 local merge=""
3160 if [ -f "$__git_repo_path/MERGE_HEAD" ]; then
3161 merge="--merge"
3162 fi
3163 case "$cur" in
3164 --*)
3165 __gitcomp "
3166 $__git_log_common_options
3167 $__git_log_gitk_options
3168 $merge
3169 "
3170 return
3171 ;;
3172 esac
3173 __git_complete_revlist
3174}
3175if [[ -n ${ZSH_VERSION-} ]]; then
3177 echo "WARNING: this script is deprecated, please see git-completion.zsh" 1>&2
3178 autoload -U +X compinit && compinit
3180 __gitcomp ()
3182 {
3183 emulate -L zsh
3184 local cur_="${3-$cur}"
3186 case "$cur_" in
3188 --*=)
3189 ;;
3190 *)
3191 local c IFS=$' \t\n'
3192 local -a array
3193 for c in ${=1}; do
3194 c="$c${4-}"
3195 case $c in
3196 --*=*|*.) ;;
3197 *) c="$c " ;;
3198 esac
3199 array[${#array[@]}+1]="$c"
3200 done
3201 compset -P '*[=:]'
3202 compadd -Q -S '' -p "${2-}" -a -- array && _ret=0
3203 ;;
3204 esac
3205 }
3206 __gitcomp_direct ()
3208 {
3209 emulate -L zsh
3210 local IFS=$'\n'
3212 compset -P '*[=:]'
3213 compadd -Q -- ${=1} && _ret=0
3214 }
3215 __gitcomp_nl ()
3217 {
3218 emulate -L zsh
3219 local IFS=$'\n'
3221 compset -P '*[=:]'
3222 compadd -Q -S "${4- }" -p "${2-}" -- ${=1} && _ret=0
3223 }
3224 __gitcomp_file ()
3226 {
3227 emulate -L zsh
3228 local IFS=$'\n'
3230 compset -P '*[=:]'
3231 compadd -Q -p "${2-}" -f -- ${=1} && _ret=0
3232 }
3233 _git ()
3235 {
3236 local _ret=1 cur cword prev
3237 cur=${words[CURRENT]}
3238 prev=${words[CURRENT-1]}
3239 let cword=CURRENT-1
3240 emulate ksh -c __${service}_main
3241 let _ret && _default && _ret=0
3242 return _ret
3243 }
3244 compdef _git git gitk
3246 return
3247fi
3248__git_func_wrap ()
3250{
3251 local cur words cword prev
3252 _get_comp_words_by_ref -n =: cur words cword prev
3253 $1
3254}
3255# Setup completion for certain functions defined above by setting common
3257# variables and workarounds.
3258# This is NOT a public function; use at your own risk.
3259__git_complete ()
3260{
3261 local wrapper="__git_wrap${2}"
3262 eval "$wrapper () { __git_func_wrap $2 ; }"
3263 complete -o bashdefault -o default -o nospace -F $wrapper $1 2>/dev/null \
3264 || complete -o default -o nospace -F $wrapper $1
3265}
3266# wrapper for backwards compatibility
3268_git ()
3269{
3270 __git_wrap__git_main
3271}
3272# wrapper for backwards compatibility
3274_gitk ()
3275{
3276 __git_wrap__gitk_main
3277}
3278__git_complete git __git_main
3280__git_complete gitk __gitk_main
3281# The following are necessary only for Cygwin, and only are needed
3283# when the user has tab-completed the executable name and consequently
3284# included the '.exe' suffix.
3285#
3286if [ Cygwin = "$(uname -o 2>/dev/null)" ]; then
3287__git_complete git.exe __git_main
3288fi