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# You can set the following environment variables to influence the behavior of
33# the completion routines:
34#
35# GIT_COMPLETION_CHECKOUT_NO_GUESS
36#
37# When set to "1", do not include "DWIM" suggestions in git-checkout
38# completion (e.g., completing "foo" when "origin/foo" exists).
39case "$COMP_WORDBREAKS" in
41*:*) : great ;;
42*) COMP_WORDBREAKS="$COMP_WORDBREAKS:"
43esac
44# Discovers the path to the git repository taking any '--git-dir=<path>' and
46# '-C <path>' options into account and stores it in the $__git_repo_path
47# variable.
48__git_find_repo_path ()
49{
50 if [ -n "$__git_repo_path" ]; then
51 # we already know where it is
52 return
53 fi
54 if [ -n "${__git_C_args-}" ]; then
56 __git_repo_path="$(git "${__git_C_args[@]}" \
57 ${__git_dir:+--git-dir="$__git_dir"} \
58 rev-parse --absolute-git-dir 2>/dev/null)"
59 elif [ -n "${__git_dir-}" ]; then
60 test -d "$__git_dir" &&
61 __git_repo_path="$__git_dir"
62 elif [ -n "${GIT_DIR-}" ]; then
63 test -d "${GIT_DIR-}" &&
64 __git_repo_path="$GIT_DIR"
65 elif [ -d .git ]; then
66 __git_repo_path=.git
67 else
68 __git_repo_path="$(git rev-parse --git-dir 2>/dev/null)"
69 fi
70}
71# Deprecated: use __git_find_repo_path() and $__git_repo_path instead
73# __gitdir accepts 0 or 1 arguments (i.e., location)
74# returns location of .git repo
75__gitdir ()
76{
77 if [ -z "${1-}" ]; then
78 __git_find_repo_path || return 1
79 echo "$__git_repo_path"
80 elif [ -d "$1/.git" ]; then
81 echo "$1/.git"
82 else
83 echo "$1"
84 fi
85}
86# Runs git with all the options given as argument, respecting any
88# '--git-dir=<path>' and '-C <path>' options present on the command line
89__git ()
90{
91 git ${__git_C_args:+"${__git_C_args[@]}"} \
92 ${__git_dir:+--git-dir="$__git_dir"} "$@" 2>/dev/null
93}
94# The following function is based on code from:
96#
97# bash_completion - programmable completion functions for bash 3.2+
98#
99# Copyright © 2006-2008, Ian Macdonald <ian@caliban.org>
100# © 2009-2010, Bash Completion Maintainers
101# <bash-completion-devel@lists.alioth.debian.org>
102#
103# This program is free software; you can redistribute it and/or modify
104# it under the terms of the GNU General Public License as published by
105# the Free Software Foundation; either version 2, or (at your option)
106# any later version.
107#
108# This program is distributed in the hope that it will be useful,
109# but WITHOUT ANY WARRANTY; without even the implied warranty of
110# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
111# GNU General Public License for more details.
112#
113# You should have received a copy of the GNU General Public License
114# along with this program; if not, see <http://www.gnu.org/licenses/>.
115#
116# The latest version of this software can be obtained here:
117#
118# http://bash-completion.alioth.debian.org/
119#
120# RELEASE: 2.x
121# This function can be used to access a tokenized list of words
123# on the command line:
124#
125# __git_reassemble_comp_words_by_ref '=:'
126# if test "${words_[cword_-1]}" = -w
127# then
128# ...
129# fi
130#
131# The argument should be a collection of characters from the list of
132# word completion separators (COMP_WORDBREAKS) to treat as ordinary
133# characters.
134#
135# This is roughly equivalent to going back in time and setting
136# COMP_WORDBREAKS to exclude those characters. The intent is to
137# make option types like --date=<type> and <rev>:<path> easy to
138# recognize by treating each shell word as a single token.
139#
140# It is best not to set COMP_WORDBREAKS directly because the value is
141# shared with other completion scripts. By the time the completion
142# function gets called, COMP_WORDS has already been populated so local
143# changes to COMP_WORDBREAKS have no effect.
144#
145# Output: words_, cword_, cur_.
146__git_reassemble_comp_words_by_ref()
148{
149 local exclude i j first
150 # Which word separators to exclude?
151 exclude="${1//[^$COMP_WORDBREAKS]}"
152 cword_=$COMP_CWORD
153 if [ -z "$exclude" ]; then
154 words_=("${COMP_WORDS[@]}")
155 return
156 fi
157 # List of word completion separators has shrunk;
158 # re-assemble words to complete.
159 for ((i=0, j=0; i < ${#COMP_WORDS[@]}; i++, j++)); do
160 # Append each nonempty word consisting of just
161 # word separator characters to the current word.
162 first=t
163 while
164 [ $i -gt 0 ] &&
165 [ -n "${COMP_WORDS[$i]}" ] &&
166 # word consists of excluded word separators
167 [ "${COMP_WORDS[$i]//[^$exclude]}" = "${COMP_WORDS[$i]}" ]
168 do
169 # Attach to the previous token,
170 # unless the previous token is the command name.
171 if [ $j -ge 2 ] && [ -n "$first" ]; then
172 ((j--))
173 fi
174 first=
175 words_[$j]=${words_[j]}${COMP_WORDS[i]}
176 if [ $i = $COMP_CWORD ]; then
177 cword_=$j
178 fi
179 if (($i < ${#COMP_WORDS[@]} - 1)); then
180 ((i++))
181 else
182 # Done.
183 return
184 fi
185 done
186 words_[$j]=${words_[j]}${COMP_WORDS[i]}
187 if [ $i = $COMP_CWORD ]; then
188 cword_=$j
189 fi
190 done
191}
192if ! type _get_comp_words_by_ref >/dev/null 2>&1; then
194_get_comp_words_by_ref ()
195{
196 local exclude cur_ words_ cword_
197 if [ "$1" = "-n" ]; then
198 exclude=$2
199 shift 2
200 fi
201 __git_reassemble_comp_words_by_ref "$exclude"
202 cur_=${words_[cword_]}
203 while [ $# -gt 0 ]; do
204 case "$1" in
205 cur)
206 cur=$cur_
207 ;;
208 prev)
209 prev=${words_[$cword_-1]}
210 ;;
211 words)
212 words=("${words_[@]}")
213 ;;
214 cword)
215 cword=$cword_
216 ;;
217 esac
218 shift
219 done
220}
221fi
222# Fills the COMPREPLY array with prefiltered words without any additional
224# processing.
225# Callers must take care of providing only words that match the current word
226# to be completed and adding any prefix and/or suffix (trailing space!), if
227# necessary.
228# 1: List of newline-separated matching completion words, complete with
229# prefix and suffix.
230__gitcomp_direct ()
231{
232 local IFS=$'\n'
233 COMPREPLY=($1)
235}
236__gitcompappend ()
238{
239 local x i=${#COMPREPLY[@]}
240 for x in $1; do
241 if [[ "$x" == "$3"* ]]; then
242 COMPREPLY[i++]="$2$x$4"
243 fi
244 done
245}
246__gitcompadd ()
248{
249 COMPREPLY=()
250 __gitcompappend "$@"
251}
252# Generates completion reply, appending a space to possible completion words,
254# if necessary.
255# It accepts 1 to 4 arguments:
256# 1: List of possible completion words.
257# 2: A prefix to be added to each possible completion word (optional).
258# 3: Generate possible completion matches for this word (optional).
259# 4: A suffix to be appended to each possible completion word (optional).
260__gitcomp ()
261{
262 local cur_="${3-$cur}"
263 case "$cur_" in
265 --*=)
266 ;;
267 *)
268 local c i=0 IFS=$' \t\n'
269 for c in $1; do
270 c="$c${4-}"
271 if [[ $c == "$cur_"* ]]; then
272 case $c in
273 --*=*|*.) ;;
274 *) c="$c " ;;
275 esac
276 COMPREPLY[i++]="${2-}$c"
277 fi
278 done
279 ;;
280 esac
281}
282# Clear the variables caching builtins' options when (re-)sourcing
284# the completion script.
285unset $(set |sed -ne 's/^\(__gitcomp_builtin_[a-zA-Z0-9_][a-zA-Z0-9_]*\)=.*/\1/p') 2>/dev/null
286# This function is equivalent to
288#
289# __gitcomp "$(git xxx --git-completion-helper) ..."
290#
291# except that the output is cached. Accept 1-3 arguments:
292# 1: the git command to execute, this is also the cache key
293# 2: extra options to be added on top (e.g. negative forms)
294# 3: options to be excluded
295__gitcomp_builtin ()
296{
297 # spaces must be replaced with underscore for multi-word
298 # commands, e.g. "git remote add" becomes remote_add.
299 local cmd="$1"
300 local incl="$2"
301 local excl="$3"
302 local var=__gitcomp_builtin_"${cmd/-/_}"
304 local options
305 eval "options=\$$var"
306 if [ -z "$options" ]; then
308 # leading and trailing spaces are significant to make
309 # option removal work correctly.
310 options=" $(__git ${cmd/_/ } --git-completion-helper) $incl "
311 for i in $excl; do
312 options="${options/ $i / }"
313 done
314 eval "$var=\"$options\""
315 fi
316 __gitcomp "$options"
318}
319# Variation of __gitcomp_nl () that appends to the existing list of
321# completion candidates, COMPREPLY.
322__gitcomp_nl_append ()
323{
324 local IFS=$'\n'
325 __gitcompappend "$1" "${2-}" "${3-$cur}" "${4- }"
326}
327# Generates completion reply from newline-separated possible completion words
329# by appending a space to all of them.
330# It accepts 1 to 4 arguments:
331# 1: List of possible completion words, separated by a single newline.
332# 2: A prefix to be added to each possible completion word (optional).
333# 3: Generate possible completion matches for this word (optional).
334# 4: A suffix to be appended to each possible completion word instead of
335# the default space (optional). If specified but empty, nothing is
336# appended.
337__gitcomp_nl ()
338{
339 COMPREPLY=()
340 __gitcomp_nl_append "$@"
341}
342# Generates completion reply with compgen from newline-separated possible
344# completion filenames.
345# It accepts 1 to 3 arguments:
346# 1: List of possible completion filenames, separated by a single newline.
347# 2: A directory prefix to be added to each possible completion filename
348# (optional).
349# 3: Generate possible completion matches for this word (optional).
350__gitcomp_file ()
351{
352 local IFS=$'\n'
353 # XXX does not work when the directory prefix contains a tilde,
355 # since tilde expansion is not applied.
356 # This means that COMPREPLY will be empty and Bash default
357 # completion will be used.
358 __gitcompadd "$1" "${2-}" "${3-$cur}" ""
359 # use a hack to enable file mode in bash < 4
361 compopt -o filenames +o nospace 2>/dev/null ||
362 compgen -f /non-existing-dir/ > /dev/null
363}
364# Execute 'git ls-files', unless the --committable option is specified, in
366# which case it runs 'git diff-index' to find out the files that can be
367# committed. It return paths relative to the directory specified in the first
368# argument, and using the options specified in the second argument.
369__git_ls_files_helper ()
370{
371 if [ "$2" == "--committable" ]; then
372 __git -C "$1" diff-index --name-only --relative HEAD
373 else
374 # NOTE: $2 is not quoted in order to support multiple options
375 __git -C "$1" ls-files --exclude-standard $2
376 fi
377}
378# __git_index_files accepts 1 or 2 arguments:
381# 1: Options to pass to ls-files (required).
382# 2: A directory path (optional).
383# If provided, only files within the specified directory are listed.
384# Sub directories are never recursed. Path must have a trailing
385# slash.
386__git_index_files ()
387{
388 local root="${2-.}" file
389 __git_ls_files_helper "$root" "$1" |
391 while read -r file; do
392 case "$file" in
393 ?*/*) echo "${file%%/*}" ;;
394 *) echo "$file" ;;
395 esac
396 done | sort | uniq
397}
398# Lists branches from the local repository.
400# 1: A prefix to be added to each listed branch (optional).
401# 2: List only branches matching this word (optional; list all branches if
402# unset or empty).
403# 3: A suffix to be appended to each listed branch (optional).
404__git_heads ()
405{
406 local pfx="${1-}" cur_="${2-}" sfx="${3-}"
407 __git for-each-ref --format="${pfx//\%/%%}%(refname:strip=2)$sfx" \
409 "refs/heads/$cur_*" "refs/heads/$cur_*/**"
410}
411# Lists tags from the local repository.
413# Accepts the same positional parameters as __git_heads() above.
414__git_tags ()
415{
416 local pfx="${1-}" cur_="${2-}" sfx="${3-}"
417 __git for-each-ref --format="${pfx//\%/%%}%(refname:strip=2)$sfx" \
419 "refs/tags/$cur_*" "refs/tags/$cur_*/**"
420}
421# Lists refs from the local (by default) or from a remote repository.
423# It accepts 0, 1 or 2 arguments:
424# 1: The remote to list refs from (optional; ignored, if set but empty).
425# Can be the name of a configured remote, a path, or a URL.
426# 2: In addition to local refs, list unique branches from refs/remotes/ for
427# 'git checkout's tracking DWIMery (optional; ignored, if set but empty).
428# 3: A prefix to be added to each listed ref (optional).
429# 4: List only refs matching this word (optional; list all refs if unset or
430# empty).
431# 5: A suffix to be appended to each listed ref (optional; ignored, if set
432# but empty).
433#
434# Use __git_complete_refs() instead.
435__git_refs ()
436{
437 local i hash dir track="${2-}"
438 local list_refs_from=path remote="${1-}"
439 local format refs
440 local pfx="${3-}" cur_="${4-$cur}" sfx="${5-}"
441 local match="${4-}"
442 local fer_pfx="${pfx//\%/%%}" # "escape" for-each-ref format specifiers
443 __git_find_repo_path
445 dir="$__git_repo_path"
446 if [ -z "$remote" ]; then
448 if [ -z "$dir" ]; then
449 return
450 fi
451 else
452 if __git_is_configured_remote "$remote"; then
453 # configured remote takes precedence over a
454 # local directory with the same name
455 list_refs_from=remote
456 elif [ -d "$remote/.git" ]; then
457 dir="$remote/.git"
458 elif [ -d "$remote" ]; then
459 dir="$remote"
460 else
461 list_refs_from=url
462 fi
463 fi
464 if [ "$list_refs_from" = path ]; then
466 if [[ "$cur_" == ^* ]]; then
467 pfx="$pfx^"
468 fer_pfx="$fer_pfx^"
469 cur_=${cur_#^}
470 match=${match#^}
471 fi
472 case "$cur_" in
473 refs|refs/*)
474 format="refname"
475 refs=("$match*" "$match*/**")
476 track=""
477 ;;
478 *)
479 for i in HEAD FETCH_HEAD ORIG_HEAD MERGE_HEAD REBASE_HEAD; do
480 case "$i" in
481 $match*)
482 if [ -e "$dir/$i" ]; then
483 echo "$pfx$i$sfx"
484 fi
485 ;;
486 esac
487 done
488 format="refname:strip=2"
489 refs=("refs/tags/$match*" "refs/tags/$match*/**"
490 "refs/heads/$match*" "refs/heads/$match*/**"
491 "refs/remotes/$match*" "refs/remotes/$match*/**")
492 ;;
493 esac
494 __git_dir="$dir" __git for-each-ref --format="$fer_pfx%($format)$sfx" \
495 "${refs[@]}"
496 if [ -n "$track" ]; then
497 # employ the heuristic used by git checkout
498 # Try to find a remote branch that matches the completion word
499 # but only output if the branch name is unique
500 __git for-each-ref --format="$fer_pfx%(refname:strip=3)$sfx" \
501 --sort="refname:strip=3" \
502 "refs/remotes/*/$match*" "refs/remotes/*/$match*/**" | \
503 uniq -u
504 fi
505 return
506 fi
507 case "$cur_" in
508 refs|refs/*)
509 __git ls-remote "$remote" "$match*" | \
510 while read -r hash i; do
511 case "$i" in
512 *^{}) ;;
513 *) echo "$pfx$i$sfx" ;;
514 esac
515 done
516 ;;
517 *)
518 if [ "$list_refs_from" = remote ]; then
519 case "HEAD" in
520 $match*) echo "${pfx}HEAD$sfx" ;;
521 esac
522 __git for-each-ref --format="$fer_pfx%(refname:strip=3)$sfx" \
523 "refs/remotes/$remote/$match*" \
524 "refs/remotes/$remote/$match*/**"
525 else
526 local query_symref
527 case "HEAD" in
528 $match*) query_symref="HEAD" ;;
529 esac
530 __git ls-remote "$remote" $query_symref \
531 "refs/tags/$match*" "refs/heads/$match*" \
532 "refs/remotes/$match*" |
533 while read -r hash i; do
534 case "$i" in
535 *^{}) ;;
536 refs/*) echo "$pfx${i#refs/*/}$sfx" ;;
537 *) echo "$pfx$i$sfx" ;; # symbolic refs
538 esac
539 done
540 fi
541 ;;
542 esac
543}
544# Completes refs, short and long, local and remote, symbolic and pseudo.
546#
547# Usage: __git_complete_refs [<option>]...
548# --remote=<remote>: The remote to list refs from, can be the name of a
549# configured remote, a path, or a URL.
550# --track: List unique remote branches for 'git checkout's tracking DWIMery.
551# --pfx=<prefix>: A prefix to be added to each ref.
552# --cur=<word>: The current ref to be completed. Defaults to the current
553# word to be completed.
554# --sfx=<suffix>: A suffix to be appended to each ref instead of the default
555# space.
556__git_complete_refs ()
557{
558 local remote track pfx cur_="$cur" sfx=" "
559 while test $# != 0; do
561 case "$1" in
562 --remote=*) remote="${1##--remote=}" ;;
563 --track) track="yes" ;;
564 --pfx=*) pfx="${1##--pfx=}" ;;
565 --cur=*) cur_="${1##--cur=}" ;;
566 --sfx=*) sfx="${1##--sfx=}" ;;
567 *) return 1 ;;
568 esac
569 shift
570 done
571 __gitcomp_direct "$(__git_refs "$remote" "$track" "$pfx" "$cur_" "$sfx")"
573}
574# __git_refs2 requires 1 argument (to pass to __git_refs)
576# Deprecated: use __git_complete_fetch_refspecs() instead.
577__git_refs2 ()
578{
579 local i
580 for i in $(__git_refs "$1"); do
581 echo "$i:$i"
582 done
583}
584# Completes refspecs for fetching from a remote repository.
586# 1: The remote repository.
587# 2: A prefix to be added to each listed refspec (optional).
588# 3: The ref to be completed as a refspec instead of the current word to be
589# completed (optional)
590# 4: A suffix to be appended to each listed refspec instead of the default
591# space (optional).
592__git_complete_fetch_refspecs ()
593{
594 local i remote="$1" pfx="${2-}" cur_="${3-$cur}" sfx="${4- }"
595 __gitcomp_direct "$(
597 for i in $(__git_refs "$remote" "" "" "$cur_") ; do
598 echo "$pfx$i:$i$sfx"
599 done
600 )"
601}
602# __git_refs_remotes requires 1 argument (to pass to ls-remote)
604__git_refs_remotes ()
605{
606 local i hash
607 __git ls-remote "$1" 'refs/heads/*' | \
608 while read -r hash i; do
609 echo "$i:refs/remotes/$1/${i#refs/heads/}"
610 done
611}
612__git_remotes ()
614{
615 __git_find_repo_path
616 test -d "$__git_repo_path/remotes" && ls -1 "$__git_repo_path/remotes"
617 __git remote
618}
619# Returns true if $1 matches the name of a configured remote, false otherwise.
621__git_is_configured_remote ()
622{
623 local remote
624 for remote in $(__git_remotes); do
625 if [ "$remote" = "$1" ]; then
626 return 0
627 fi
628 done
629 return 1
630}
631__git_list_merge_strategies ()
633{
634 LANG=C LC_ALL=C git merge -s help 2>&1 |
635 sed -n -e '/[Aa]vailable strategies are: /,/^$/{
636 s/\.$//
637 s/.*://
638 s/^[ ]*//
639 s/[ ]*$//
640 p
641 }'
642}
643__git_merge_strategies=
645# 'git merge -s help' (and thus detection of the merge strategy
646# list) fails, unfortunately, if run outside of any git working
647# tree. __git_merge_strategies is set to the empty string in
648# that case, and the detection will be repeated the next time it
649# is needed.
650__git_compute_merge_strategies ()
651{
652 test -n "$__git_merge_strategies" ||
653 __git_merge_strategies=$(__git_list_merge_strategies)
654}
655__git_complete_revlist_file ()
657{
658 local pfx ls ref cur_="$cur"
659 case "$cur_" in
660 *..?*:*)
661 return
662 ;;
663 ?*:*)
664 ref="${cur_%%:*}"
665 cur_="${cur_#*:}"
666 case "$cur_" in
667 ?*/*)
668 pfx="${cur_%/*}"
669 cur_="${cur_##*/}"
670 ls="$ref:$pfx"
671 pfx="$pfx/"
672 ;;
673 *)
674 ls="$ref"
675 ;;
676 esac
677 case "$COMP_WORDBREAKS" in
679 *:*) : great ;;
680 *) pfx="$ref:$pfx" ;;
681 esac
682 __gitcomp_nl "$(__git ls-tree "$ls" \
684 | sed '/^100... blob /{
685 s,^.* ,,
686 s,$, ,
687 }
688 /^120000 blob /{
689 s,^.* ,,
690 s,$, ,
691 }
692 /^040000 tree /{
693 s,^.* ,,
694 s,$,/,
695 }
696 s/^.* //')" \
697 "$pfx" "$cur_" ""
698 ;;
699 *...*)
700 pfx="${cur_%...*}..."
701 cur_="${cur_#*...}"
702 __git_complete_refs --pfx="$pfx" --cur="$cur_"
703 ;;
704 *..*)
705 pfx="${cur_%..*}.."
706 cur_="${cur_#*..}"
707 __git_complete_refs --pfx="$pfx" --cur="$cur_"
708 ;;
709 *)
710 __git_complete_refs
711 ;;
712 esac
713}
714# __git_complete_index_file requires 1 argument:
717# 1: the options to pass to ls-file
718#
719# The exception is --committable, which finds the files appropriate commit.
720__git_complete_index_file ()
721{
722 local pfx="" cur_="$cur"
723 case "$cur_" in
725 ?*/*)
726 pfx="${cur_%/*}"
727 cur_="${cur_##*/}"
728 pfx="${pfx}/"
729 ;;
730 esac
731 __gitcomp_file "$(__git_index_files "$1" ${pfx:+"$pfx"})" "$pfx" "$cur_"
733}
734__git_complete_file ()
736{
737 __git_complete_revlist_file
738}
739__git_complete_revlist ()
741{
742 __git_complete_revlist_file
743}
744__git_complete_remote_or_refspec ()
746{
747 local cur_="$cur" cmd="${words[1]}"
748 local i c=2 remote="" pfx="" lhs=1 no_complete_refspec=0
749 if [ "$cmd" = "remote" ]; then
750 ((c++))
751 fi
752 while [ $c -lt $cword ]; do
753 i="${words[c]}"
754 case "$i" in
755 --mirror) [ "$cmd" = "push" ] && no_complete_refspec=1 ;;
756 -d|--delete) [ "$cmd" = "push" ] && lhs=0 ;;
757 --all)
758 case "$cmd" in
759 push) no_complete_refspec=1 ;;
760 fetch)
761 return
762 ;;
763 *) ;;
764 esac
765 ;;
766 -*) ;;
767 *) remote="$i"; break ;;
768 esac
769 ((c++))
770 done
771 if [ -z "$remote" ]; then
772 __gitcomp_nl "$(__git_remotes)"
773 return
774 fi
775 if [ $no_complete_refspec = 1 ]; then
776 return
777 fi
778 [ "$remote" = "." ] && remote=
779 case "$cur_" in
780 *:*)
781 case "$COMP_WORDBREAKS" in
782 *:*) : great ;;
783 *) pfx="${cur_%%:*}:" ;;
784 esac
785 cur_="${cur_#*:}"
786 lhs=0
787 ;;
788 +*)
789 pfx="+"
790 cur_="${cur_#+}"
791 ;;
792 esac
793 case "$cmd" in
794 fetch)
795 if [ $lhs = 1 ]; then
796 __git_complete_fetch_refspecs "$remote" "$pfx" "$cur_"
797 else
798 __git_complete_refs --pfx="$pfx" --cur="$cur_"
799 fi
800 ;;
801 pull|remote)
802 if [ $lhs = 1 ]; then
803 __git_complete_refs --remote="$remote" --pfx="$pfx" --cur="$cur_"
804 else
805 __git_complete_refs --pfx="$pfx" --cur="$cur_"
806 fi
807 ;;
808 push)
809 if [ $lhs = 1 ]; then
810 __git_complete_refs --pfx="$pfx" --cur="$cur_"
811 else
812 __git_complete_refs --remote="$remote" --pfx="$pfx" --cur="$cur_"
813 fi
814 ;;
815 esac
816}
817__git_complete_strategy ()
819{
820 __git_compute_merge_strategies
821 case "$prev" in
822 -s|--strategy)
823 __gitcomp "$__git_merge_strategies"
824 return 0
825 esac
826 case "$cur" in
827 --strategy=*)
828 __gitcomp "$__git_merge_strategies" "" "${cur##--strategy=}"
829 return 0
830 ;;
831 esac
832 return 1
833}
834__git_commands () {
836 if test -n "${GIT_TESTING_COMMAND_COMPLETION:-}"
837 then
838 printf "%s" "${GIT_TESTING_COMMAND_COMPLETION}"
839 else
840 git help -a|egrep '^ [a-zA-Z0-9]'
841 fi
842}
843__git_list_all_commands ()
845{
846 local i IFS=" "$'\n'
847 for i in $(__git_commands)
848 do
849 case $i in
850 *--*) : helper pattern;;
851 *) echo $i;;
852 esac
853 done
854}
855__git_all_commands=
857__git_compute_all_commands ()
858{
859 test -n "$__git_all_commands" ||
860 __git_all_commands=$(__git_list_all_commands)
861}
862__git_list_porcelain_commands ()
864{
865 local i IFS=" "$'\n'
866 __git_compute_all_commands
867 for i in $__git_all_commands
868 do
869 case $i in
870 *--*) : helper pattern;;
871 applymbox) : ask gittus;;
872 applypatch) : ask gittus;;
873 archimport) : import;;
874 cat-file) : plumbing;;
875 check-attr) : plumbing;;
876 check-ignore) : plumbing;;
877 check-mailmap) : plumbing;;
878 check-ref-format) : plumbing;;
879 checkout-index) : plumbing;;
880 column) : internal helper;;
881 commit-tree) : plumbing;;
882 count-objects) : infrequent;;
883 credential) : credentials;;
884 credential-*) : credentials helper;;
885 cvsexportcommit) : export;;
886 cvsimport) : import;;
887 cvsserver) : daemon;;
888 daemon) : daemon;;
889 diff-files) : plumbing;;
890 diff-index) : plumbing;;
891 diff-tree) : plumbing;;
892 fast-import) : import;;
893 fast-export) : export;;
894 fsck-objects) : plumbing;;
895 fetch-pack) : plumbing;;
896 fmt-merge-msg) : plumbing;;
897 for-each-ref) : plumbing;;
898 hash-object) : plumbing;;
899 http-*) : transport;;
900 index-pack) : plumbing;;
901 init-db) : deprecated;;
902 local-fetch) : plumbing;;
903 ls-files) : plumbing;;
904 ls-remote) : plumbing;;
905 ls-tree) : plumbing;;
906 mailinfo) : plumbing;;
907 mailsplit) : plumbing;;
908 merge-*) : plumbing;;
909 mktree) : plumbing;;
910 mktag) : plumbing;;
911 pack-objects) : plumbing;;
912 pack-redundant) : plumbing;;
913 pack-refs) : plumbing;;
914 parse-remote) : plumbing;;
915 patch-id) : plumbing;;
916 prune) : plumbing;;
917 prune-packed) : plumbing;;
918 quiltimport) : import;;
919 read-tree) : plumbing;;
920 receive-pack) : plumbing;;
921 remote-*) : transport;;
922 rerere) : plumbing;;
923 rev-list) : plumbing;;
924 rev-parse) : plumbing;;
925 runstatus) : plumbing;;
926 sh-setup) : internal;;
927 shell) : daemon;;
928 show-ref) : plumbing;;
929 send-pack) : plumbing;;
930 show-index) : plumbing;;
931 ssh-*) : transport;;
932 stripspace) : plumbing;;
933 symbolic-ref) : plumbing;;
934 unpack-file) : plumbing;;
935 unpack-objects) : plumbing;;
936 update-index) : plumbing;;
937 update-ref) : plumbing;;
938 update-server-info) : daemon;;
939 upload-archive) : plumbing;;
940 upload-pack) : plumbing;;
941 write-tree) : plumbing;;
942 var) : infrequent;;
943 verify-pack) : infrequent;;
944 verify-tag) : plumbing;;
945 *) echo $i;;
946 esac
947 done
948}
949__git_porcelain_commands=
951__git_compute_porcelain_commands ()
952{
953 test -n "$__git_porcelain_commands" ||
954 __git_porcelain_commands=$(__git_list_porcelain_commands)
955}
956# Lists all set config variables starting with the given section prefix,
958# with the prefix removed.
959__git_get_config_variables ()
960{
961 local section="$1" i IFS=$'\n'
962 for i in $(__git config --name-only --get-regexp "^$section\..*"); do
963 echo "${i#$section.}"
964 done
965}
966__git_pretty_aliases ()
968{
969 __git_get_config_variables "pretty"
970}
971__git_aliases ()
973{
974 __git_get_config_variables "alias"
975}
976# __git_aliased_command requires 1 argument
978__git_aliased_command ()
979{
980 local word cmdline=$(__git config --get "alias.$1")
981 for word in $cmdline; do
982 case "$word" in
983 \!gitk|gitk)
984 echo "gitk"
985 return
986 ;;
987 \!*) : shell command alias ;;
988 -*) : option ;;
989 *=*) : setting env ;;
990 git) : git itself ;;
991 \(\)) : skip parens of shell function definition ;;
992 {) : skip start of shell helper function ;;
993 :) : skip null command ;;
994 \'*) : skip opening quote after sh -c ;;
995 *)
996 echo "$word"
997 return
998 esac
999 done
1000}
1001# __git_find_on_cmdline requires 1 argument
1003__git_find_on_cmdline ()
1004{
1005 local word subcommand c=1
1006 while [ $c -lt $cword ]; do
1007 word="${words[c]}"
1008 for subcommand in $1; do
1009 if [ "$subcommand" = "$word" ]; then
1010 echo "$subcommand"
1011 return
1012 fi
1013 done
1014 ((c++))
1015 done
1016}
1017# Echo the value of an option set on the command line or config
1019#
1020# $1: short option name
1021# $2: long option name including =
1022# $3: list of possible values
1023# $4: config string (optional)
1024#
1025# example:
1026# result="$(__git_get_option_value "-d" "--do-something=" \
1027# "yes no" "core.doSomething")"
1028#
1029# result is then either empty (no option set) or "yes" or "no"
1030#
1031# __git_get_option_value requires 3 arguments
1032__git_get_option_value ()
1033{
1034 local c short_opt long_opt val
1035 local result= values config_key word
1036 short_opt="$1"
1038 long_opt="$2"
1039 values="$3"
1040 config_key="$4"
1041 ((c = $cword - 1))
1043 while [ $c -ge 0 ]; do
1044 word="${words[c]}"
1045 for val in $values; do
1046 if [ "$short_opt$val" = "$word" ] ||
1047 [ "$long_opt$val" = "$word" ]; then
1048 result="$val"
1049 break 2
1050 fi
1051 done
1052 ((c--))
1053 done
1054 if [ -n "$config_key" ] && [ -z "$result" ]; then
1056 result="$(__git config "$config_key")"
1057 fi
1058 echo "$result"
1060}
1061__git_has_doubledash ()
1063{
1064 local c=1
1065 while [ $c -lt $cword ]; do
1066 if [ "--" = "${words[c]}" ]; then
1067 return 0
1068 fi
1069 ((c++))
1070 done
1071 return 1
1072}
1073# Try to count non option arguments passed on the command line for the
1075# specified git command.
1076# When options are used, it is necessary to use the special -- option to
1077# tell the implementation were non option arguments begin.
1078# XXX this can not be improved, since options can appear everywhere, as
1079# an example:
1080# git mv x -n y
1081#
1082# __git_count_arguments requires 1 argument: the git command executed.
1083__git_count_arguments ()
1084{
1085 local word i c=0
1086 # Skip "git" (first argument)
1088 for ((i=1; i < ${#words[@]}; i++)); do
1089 word="${words[i]}"
1090 case "$word" in
1092 --)
1093 # Good; we can assume that the following are only non
1094 # option arguments.
1095 ((c = 0))
1096 ;;
1097 "$1")
1098 # Skip the specified git command and discard git
1099 # main options
1100 ((c = 0))
1101 ;;
1102 ?*)
1103 ((c++))
1104 ;;
1105 esac
1106 done
1107 printf "%d" $c
1109}
1110__git_whitespacelist="nowarn warn error error-all fix"
1112__git_am_inprogress_options="--skip --continue --resolved --abort --quit --show-current-patch"
1113_git_am ()
1115{
1116 __git_find_repo_path
1117 if [ -d "$__git_repo_path"/rebase-apply ]; then
1118 __gitcomp "$__git_am_inprogress_options"
1119 return
1120 fi
1121 case "$cur" in
1122 --whitespace=*)
1123 __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
1124 return
1125 ;;
1126 --*)
1127 __gitcomp_builtin am "--no-utf8" \
1128 "$__git_am_inprogress_options"
1129 return
1130 esac
1131}
1132_git_apply ()
1134{
1135 case "$cur" in
1136 --whitespace=*)
1137 __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
1138 return
1139 ;;
1140 --*)
1141 __gitcomp_builtin apply
1142 return
1143 esac
1144}
1145_git_add ()
1147{
1148 case "$cur" in
1149 --*)
1150 __gitcomp_builtin add
1151 return
1152 esac
1153 local complete_opt="--others --modified --directory --no-empty-directory"
1155 if test -n "$(__git_find_on_cmdline "-u --update")"
1156 then
1157 complete_opt="--modified"
1158 fi
1159 __git_complete_index_file "$complete_opt"
1160}
1161_git_archive ()
1163{
1164 case "$cur" in
1165 --format=*)
1166 __gitcomp "$(git archive --list)" "" "${cur##--format=}"
1167 return
1168 ;;
1169 --remote=*)
1170 __gitcomp_nl "$(__git_remotes)" "" "${cur##--remote=}"
1171 return
1172 ;;
1173 --*)
1174 __gitcomp "
1175 --format= --list --verbose
1176 --prefix= --remote= --exec= --output
1177 "
1178 return
1179 ;;
1180 esac
1181 __git_complete_file
1182}
1183_git_bisect ()
1185{
1186 __git_has_doubledash && return
1187 local subcommands="start bad good skip reset visualize replay log run"
1189 local subcommand="$(__git_find_on_cmdline "$subcommands")"
1190 if [ -z "$subcommand" ]; then
1191 __git_find_repo_path
1192 if [ -f "$__git_repo_path"/BISECT_START ]; then
1193 __gitcomp "$subcommands"
1194 else
1195 __gitcomp "replay start"
1196 fi
1197 return
1198 fi
1199 case "$subcommand" in
1201 bad|good|reset|skip|start)
1202 __git_complete_refs
1203 ;;
1204 *)
1205 ;;
1206 esac
1207}
1208_git_branch ()
1210{
1211 local i c=1 only_local_ref="n" has_r="n"
1212 while [ $c -lt $cword ]; do
1214 i="${words[c]}"
1215 case "$i" in
1216 -d|--delete|-m|--move) only_local_ref="y" ;;
1217 -r|--remotes) has_r="y" ;;
1218 esac
1219 ((c++))
1220 done
1221 case "$cur" in
1223 --set-upstream-to=*)
1224 __git_complete_refs --cur="${cur##--set-upstream-to=}"
1225 ;;
1226 --*)
1227 __gitcomp_builtin branch "--no-color --no-abbrev
1228 --no-track --no-column
1229 "
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 "--no-track --no-recurse-submodules"
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 __git_complete_refs
1288}
1289__git_cherry_pick_inprogress_options="--continue --quit --abort"
1291_git_cherry_pick ()
1293{
1294 __git_find_repo_path
1295 if [ -f "$__git_repo_path"/CHERRY_PICK_HEAD ]; then
1296 __gitcomp "$__git_cherry_pick_inprogress_options"
1297 return
1298 fi
1299 case "$cur" in
1300 --*)
1301 __gitcomp_builtin cherry-pick "" \
1302 "$__git_cherry_pick_inprogress_options"
1303 ;;
1304 *)
1305 __git_complete_refs
1306 ;;
1307 esac
1308}
1309_git_clean ()
1311{
1312 case "$cur" in
1313 --*)
1314 __gitcomp_builtin clean
1315 return
1316 ;;
1317 esac
1318 # XXX should we check for -x option ?
1320 __git_complete_index_file "--others --directory"
1321}
1322_git_clone ()
1324{
1325 case "$cur" in
1326 --*)
1327 __gitcomp_builtin clone "--no-single-branch"
1328 return
1329 ;;
1330 esac
1331}
1332__git_untracked_file_modes="all no normal"
1334_git_commit ()
1336{
1337 case "$prev" in
1338 -c|-C)
1339 __git_complete_refs
1340 return
1341 ;;
1342 esac
1343 case "$cur" in
1345 --cleanup=*)
1346 __gitcomp "default scissors strip verbatim whitespace
1347 " "" "${cur##--cleanup=}"
1348 return
1349 ;;
1350 --reuse-message=*|--reedit-message=*|\
1351 --fixup=*|--squash=*)
1352 __git_complete_refs --cur="${cur#*=}"
1353 return
1354 ;;
1355 --untracked-files=*)
1356 __gitcomp "$__git_untracked_file_modes" "" "${cur##--untracked-files=}"
1357 return
1358 ;;
1359 --*)
1360 __gitcomp_builtin commit "--no-edit --verify"
1361 return
1362 esac
1363 if __git rev-parse --verify --quiet HEAD >/dev/null; then
1365 __git_complete_index_file "--committable"
1366 else
1367 # This is the first commit
1368 __git_complete_index_file "--cached"
1369 fi
1370}
1371_git_describe ()
1373{
1374 case "$cur" in
1375 --*)
1376 __gitcomp_builtin describe
1377 return
1378 esac
1379 __git_complete_refs
1380}
1381__git_diff_algorithms="myers minimal patience histogram"
1383__git_diff_submodule_formats="diff log short"
1385__git_diff_common_options="--stat --numstat --shortstat --summary
1387 --patch-with-stat --name-only --name-status --color
1388 --no-color --color-words --no-renames --check
1389 --full-index --binary --abbrev --diff-filter=
1390 --find-copies-harder --ignore-cr-at-eol
1391 --text --ignore-space-at-eol --ignore-space-change
1392 --ignore-all-space --ignore-blank-lines --exit-code
1393 --quiet --ext-diff --no-ext-diff
1394 --no-prefix --src-prefix= --dst-prefix=
1395 --inter-hunk-context=
1396 --patience --histogram --minimal
1397 --raw --word-diff --word-diff-regex=
1398 --dirstat --dirstat= --dirstat-by-file
1399 --dirstat-by-file= --cumulative
1400 --diff-algorithm=
1401 --submodule --submodule= --ignore-submodules
1402"
1403_git_diff ()
1405{
1406 __git_has_doubledash && return
1407 case "$cur" in
1409 --diff-algorithm=*)
1410 __gitcomp "$__git_diff_algorithms" "" "${cur##--diff-algorithm=}"
1411 return
1412 ;;
1413 --submodule=*)
1414 __gitcomp "$__git_diff_submodule_formats" "" "${cur##--submodule=}"
1415 return
1416 ;;
1417 --*)
1418 __gitcomp "--cached --staged --pickaxe-all --pickaxe-regex
1419 --base --ours --theirs --no-index
1420 $__git_diff_common_options
1421 "
1422 return
1423 ;;
1424 esac
1425 __git_complete_revlist_file
1426}
1427__git_mergetools_common="diffuse diffmerge ecmerge emerge kdiff3 meld opendiff
1429 tkdiff vimdiff gvimdiff xxdiff araxis p4merge bc codecompare
1430"
1431_git_difftool ()
1433{
1434 __git_has_doubledash && return
1435 case "$cur" in
1437 --tool=*)
1438 __gitcomp "$__git_mergetools_common kompare" "" "${cur##--tool=}"
1439 return
1440 ;;
1441 --*)
1442 __gitcomp_builtin difftool "$__git_diff_common_options
1443 --base --cached --ours --theirs
1444 --pickaxe-all --pickaxe-regex
1445 --relative --staged
1446 "
1447 return
1448 ;;
1449 esac
1450 __git_complete_revlist_file
1451}
1452__git_fetch_recurse_submodules="yes on-demand no"
1454_git_fetch ()
1456{
1457 case "$cur" in
1458 --recurse-submodules=*)
1459 __gitcomp "$__git_fetch_recurse_submodules" "" "${cur##--recurse-submodules=}"
1460 return
1461 ;;
1462 --*)
1463 __gitcomp_builtin fetch "--no-tags"
1464 return
1465 ;;
1466 esac
1467 __git_complete_remote_or_refspec
1468}
1469__git_format_patch_options="
1471 --stdout --attach --no-attach --thread --thread= --no-thread
1472 --numbered --start-number --numbered-files --keep-subject --signoff
1473 --signature --no-signature --in-reply-to= --cc= --full-index --binary
1474 --not --all --cover-letter --no-prefix --src-prefix= --dst-prefix=
1475 --inline --suffix= --ignore-if-in-upstream --subject-prefix=
1476 --output-directory --reroll-count --to= --quiet --notes
1477"
1478_git_format_patch ()
1480{
1481 case "$cur" in
1482 --thread=*)
1483 __gitcomp "
1484 deep shallow
1485 " "" "${cur##--thread=}"
1486 return
1487 ;;
1488 --*)
1489 __gitcomp "$__git_format_patch_options"
1490 return
1491 ;;
1492 esac
1493 __git_complete_revlist
1494}
1495_git_fsck ()
1497{
1498 case "$cur" in
1499 --*)
1500 __gitcomp_builtin fsck "--no-reflogs"
1501 return
1502 ;;
1503 esac
1504}
1505_git_gc ()
1507{
1508 case "$cur" in
1509 --*)
1510 __gitcomp_builtin gc
1511 return
1512 ;;
1513 esac
1514}
1515_git_gitk ()
1517{
1518 _gitk
1519}
1520# Lists matching symbol names from a tag (as in ctags) file.
1522# 1: List symbol names matching this word.
1523# 2: The tag file to list symbol names from.
1524# 3: A prefix to be added to each listed symbol name (optional).
1525# 4: A suffix to be appended to each listed symbol name (optional).
1526__git_match_ctag () {
1527 awk -v pfx="${3-}" -v sfx="${4-}" "
1528 /^${1//\//\\/}/ { print pfx \$1 sfx }
1529 " "$2"
1530}
1531# Complete symbol names from a tag file.
1533# Usage: __git_complete_symbol [<option>]...
1534# --tags=<file>: The tag file to list symbol names from instead of the
1535# default "tags".
1536# --pfx=<prefix>: A prefix to be added to each symbol name.
1537# --cur=<word>: The current symbol name to be completed. Defaults to
1538# the current word to be completed.
1539# --sfx=<suffix>: A suffix to be appended to each symbol name instead
1540# of the default space.
1541__git_complete_symbol () {
1542 local tags=tags pfx="" cur_="${cur-}" sfx=" "
1543 while test $# != 0; do
1545 case "$1" in
1546 --tags=*) tags="${1##--tags=}" ;;
1547 --pfx=*) pfx="${1##--pfx=}" ;;
1548 --cur=*) cur_="${1##--cur=}" ;;
1549 --sfx=*) sfx="${1##--sfx=}" ;;
1550 *) return 1 ;;
1551 esac
1552 shift
1553 done
1554 if test -r "$tags"; then
1556 __gitcomp_direct "$(__git_match_ctag "$cur_" "$tags" "$pfx" "$sfx")"
1557 fi
1558}
1559_git_grep ()
1561{
1562 __git_has_doubledash && return
1563 case "$cur" in
1565 --*)
1566 __gitcomp_builtin grep
1567 return
1568 ;;
1569 esac
1570 case "$cword,$prev" in
1572 2,*|*,-*)
1573 __git_complete_symbol && return
1574 ;;
1575 esac
1576 __git_complete_refs
1578}
1579_git_help ()
1581{
1582 case "$cur" in
1583 --*)
1584 __gitcomp_builtin help
1585 return
1586 ;;
1587 esac
1588 __git_compute_all_commands
1589 __gitcomp "$__git_all_commands $(__git_aliases)
1590 attributes cli core-tutorial cvs-migration
1591 diffcore everyday gitk glossary hooks ignore modules
1592 namespaces repository-layout revisions tutorial tutorial-2
1593 workflows
1594 "
1595}
1596_git_init ()
1598{
1599 case "$cur" in
1600 --shared=*)
1601 __gitcomp "
1602 false true umask group all world everybody
1603 " "" "${cur##--shared=}"
1604 return
1605 ;;
1606 --*)
1607 __gitcomp_builtin init
1608 return
1609 ;;
1610 esac
1611}
1612_git_ls_files ()
1614{
1615 case "$cur" in
1616 --*)
1617 __gitcomp_builtin ls-files "--no-empty-directory"
1618 return
1619 ;;
1620 esac
1621 # XXX ignore options like --modified and always suggest all cached
1623 # files.
1624 __git_complete_index_file "--cached"
1625}
1626_git_ls_remote ()
1628{
1629 case "$cur" in
1630 --*)
1631 __gitcomp_builtin ls-remote
1632 return
1633 ;;
1634 esac
1635 __gitcomp_nl "$(__git_remotes)"
1636}
1637_git_ls_tree ()
1639{
1640 __git_complete_file
1641}
1642# Options that go well for log, shortlog and gitk
1644__git_log_common_options="
1645 --not --all
1646 --branches --tags --remotes
1647 --first-parent --merges --no-merges
1648 --max-count=
1649 --max-age= --since= --after=
1650 --min-age= --until= --before=
1651 --min-parents= --max-parents=
1652 --no-min-parents --no-max-parents
1653"
1654# Options that go well for log and gitk (not shortlog)
1655__git_log_gitk_options="
1656 --dense --sparse --full-history
1657 --simplify-merges --simplify-by-decoration
1658 --left-right --notes --no-notes
1659"
1660# Options that go well for log and shortlog (not gitk)
1661__git_log_shortlog_options="
1662 --author= --committer= --grep=
1663 --all-match --invert-grep
1664"
1665__git_log_pretty_formats="oneline short medium full fuller email raw format:"
1667__git_log_date_formats="relative iso8601 rfc2822 short local default raw"
1668_git_log ()
1670{
1671 __git_has_doubledash && return
1672 __git_find_repo_path
1673 local merge=""
1675 if [ -f "$__git_repo_path/MERGE_HEAD" ]; then
1676 merge="--merge"
1677 fi
1678 case "$prev,$cur" in
1679 -L,:*:*)
1680 return # fall back to Bash filename completion
1681 ;;
1682 -L,:*)
1683 __git_complete_symbol --cur="${cur#:}" --sfx=":"
1684 return
1685 ;;
1686 -G,*|-S,*)
1687 __git_complete_symbol
1688 return
1689 ;;
1690 esac
1691 case "$cur" in
1692 --pretty=*|--format=*)
1693 __gitcomp "$__git_log_pretty_formats $(__git_pretty_aliases)
1694 " "" "${cur#*=}"
1695 return
1696 ;;
1697 --date=*)
1698 __gitcomp "$__git_log_date_formats" "" "${cur##--date=}"
1699 return
1700 ;;
1701 --decorate=*)
1702 __gitcomp "full short no" "" "${cur##--decorate=}"
1703 return
1704 ;;
1705 --diff-algorithm=*)
1706 __gitcomp "$__git_diff_algorithms" "" "${cur##--diff-algorithm=}"
1707 return
1708 ;;
1709 --submodule=*)
1710 __gitcomp "$__git_diff_submodule_formats" "" "${cur##--submodule=}"
1711 return
1712 ;;
1713 --*)
1714 __gitcomp "
1715 $__git_log_common_options
1716 $__git_log_shortlog_options
1717 $__git_log_gitk_options
1718 --root --topo-order --date-order --reverse
1719 --follow --full-diff
1720 --abbrev-commit --abbrev=
1721 --relative-date --date=
1722 --pretty= --format= --oneline
1723 --show-signature
1724 --cherry-mark
1725 --cherry-pick
1726 --graph
1727 --decorate --decorate=
1728 --walk-reflogs
1729 --parents --children
1730 $merge
1731 $__git_diff_common_options
1732 --pickaxe-all --pickaxe-regex
1733 "
1734 return
1735 ;;
1736 -L:*:*)
1737 return # fall back to Bash filename completion
1738 ;;
1739 -L:*)
1740 __git_complete_symbol --cur="${cur#-L:}" --sfx=":"
1741 return
1742 ;;
1743 -G*)
1744 __git_complete_symbol --pfx="-G" --cur="${cur#-G}"
1745 return
1746 ;;
1747 -S*)
1748 __git_complete_symbol --pfx="-S" --cur="${cur#-S}"
1749 return
1750 ;;
1751 esac
1752 __git_complete_revlist
1753}
1754_git_merge ()
1756{
1757 __git_complete_strategy && return
1758 case "$cur" in
1760 --*)
1761 __gitcomp_builtin merge "--no-rerere-autoupdate
1762 --no-commit --no-edit --no-ff
1763 --no-log --no-progress
1764 --no-squash --no-stat
1765 --no-verify-signatures
1766 "
1767 return
1768 esac
1769 __git_complete_refs
1770}
1771_git_mergetool ()
1773{
1774 case "$cur" in
1775 --tool=*)
1776 __gitcomp "$__git_mergetools_common tortoisemerge" "" "${cur##--tool=}"
1777 return
1778 ;;
1779 --*)
1780 __gitcomp "--tool= --prompt --no-prompt"
1781 return
1782 ;;
1783 esac
1784}
1785_git_merge_base ()
1787{
1788 case "$cur" in
1789 --*)
1790 __gitcomp_builtin merge-base
1791 return
1792 ;;
1793 esac
1794 __git_complete_refs
1795}
1796_git_mv ()
1798{
1799 case "$cur" in
1800 --*)
1801 __gitcomp_builtin mv
1802 return
1803 ;;
1804 esac
1805 if [ $(__git_count_arguments "mv") -gt 0 ]; then
1807 # We need to show both cached and untracked files (including
1808 # empty directories) since this may not be the last argument.
1809 __git_complete_index_file "--cached --others --directory"
1810 else
1811 __git_complete_index_file "--cached"
1812 fi
1813}
1814_git_name_rev ()
1816{
1817 __gitcomp_builtin name-rev
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 --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 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.compression
2354 core.createObject
2355 core.deltaBaseCacheLimit
2356 core.editor
2357 core.eol
2358 core.excludesfile
2359 core.fileMode
2360 core.fsyncobjectfiles
2361 core.gitProxy
2362 core.hideDotFiles
2363 core.hooksPath
2364 core.ignoreStat
2365 core.ignorecase
2366 core.logAllRefUpdates
2367 core.loosecompression
2368 core.notesRef
2369 core.packedGitLimit
2370 core.packedGitWindowSize
2371 core.packedRefsTimeout
2372 core.pager
2373 core.precomposeUnicode
2374 core.preferSymlinkRefs
2375 core.preloadindex
2376 core.protectHFS
2377 core.protectNTFS
2378 core.quotepath
2379 core.repositoryFormatVersion
2380 core.safecrlf
2381 core.sharedRepository
2382 core.sparseCheckout
2383 core.splitIndex
2384 core.sshCommand
2385 core.symlinks
2386 core.trustctime
2387 core.untrackedCache
2388 core.warnAmbiguousRefs
2389 core.whitespace
2390 core.worktree
2391 credential.helper
2392 credential.useHttpPath
2393 credential.username
2394 credentialCache.ignoreSIGHUP
2395 diff.autorefreshindex
2396 diff.external
2397 diff.ignoreSubmodules
2398 diff.mnemonicprefix
2399 diff.noprefix
2400 diff.renameLimit
2401 diff.renames
2402 diff.statGraphWidth
2403 diff.submodule
2404 diff.suppressBlankEmpty
2405 diff.tool
2406 diff.wordRegex
2407 diff.algorithm
2408 difftool.
2409 difftool.prompt
2410 fetch.recurseSubmodules
2411 fetch.unpackLimit
2412 format.attach
2413 format.cc
2414 format.coverLetter
2415 format.from
2416 format.headers
2417 format.numbered
2418 format.pretty
2419 format.signature
2420 format.signoff
2421 format.subjectprefix
2422 format.suffix
2423 format.thread
2424 format.to
2425 gc.
2426 gc.aggressiveDepth
2427 gc.aggressiveWindow
2428 gc.auto
2429 gc.autoDetach
2430 gc.autopacklimit
2431 gc.logExpiry
2432 gc.packrefs
2433 gc.pruneexpire
2434 gc.reflogexpire
2435 gc.reflogexpireunreachable
2436 gc.rerereresolved
2437 gc.rerereunresolved
2438 gc.worktreePruneExpire
2439 gitcvs.allbinary
2440 gitcvs.commitmsgannotation
2441 gitcvs.dbTableNamePrefix
2442 gitcvs.dbdriver
2443 gitcvs.dbname
2444 gitcvs.dbpass
2445 gitcvs.dbuser
2446 gitcvs.enabled
2447 gitcvs.logfile
2448 gitcvs.usecrlfattr
2449 guitool.
2450 gui.blamehistoryctx
2451 gui.commitmsgwidth
2452 gui.copyblamethreshold
2453 gui.diffcontext
2454 gui.encoding
2455 gui.fastcopyblame
2456 gui.matchtrackingbranch
2457 gui.newbranchtemplate
2458 gui.pruneduringfetch
2459 gui.spellingdictionary
2460 gui.trustmtime
2461 help.autocorrect
2462 help.browser
2463 help.format
2464 http.lowSpeedLimit
2465 http.lowSpeedTime
2466 http.maxRequests
2467 http.minSessions
2468 http.noEPSV
2469 http.postBuffer
2470 http.proxy
2471 http.sslCipherList
2472 http.sslVersion
2473 http.sslCAInfo
2474 http.sslCAPath
2475 http.sslCert
2476 http.sslCertPasswordProtected
2477 http.sslKey
2478 http.sslVerify
2479 http.useragent
2480 i18n.commitEncoding
2481 i18n.logOutputEncoding
2482 imap.authMethod
2483 imap.folder
2484 imap.host
2485 imap.pass
2486 imap.port
2487 imap.preformattedHTML
2488 imap.sslverify
2489 imap.tunnel
2490 imap.user
2491 init.templatedir
2492 instaweb.browser
2493 instaweb.httpd
2494 instaweb.local
2495 instaweb.modulepath
2496 instaweb.port
2497 interactive.singlekey
2498 log.date
2499 log.decorate
2500 log.showroot
2501 mailmap.file
2502 man.
2503 man.viewer
2504 merge.
2505 merge.conflictstyle
2506 merge.log
2507 merge.renameLimit
2508 merge.renormalize
2509 merge.stat
2510 merge.tool
2511 merge.verbosity
2512 mergetool.
2513 mergetool.keepBackup
2514 mergetool.keepTemporaries
2515 mergetool.prompt
2516 notes.displayRef
2517 notes.rewrite.
2518 notes.rewrite.amend
2519 notes.rewrite.rebase
2520 notes.rewriteMode
2521 notes.rewriteRef
2522 pack.compression
2523 pack.deltaCacheLimit
2524 pack.deltaCacheSize
2525 pack.depth
2526 pack.indexVersion
2527 pack.packSizeLimit
2528 pack.threads
2529 pack.window
2530 pack.windowMemory
2531 pager.
2532 pretty.
2533 pull.octopus
2534 pull.twohead
2535 push.default
2536 push.followTags
2537 rebase.autosquash
2538 rebase.stat
2539 receive.autogc
2540 receive.denyCurrentBranch
2541 receive.denyDeleteCurrent
2542 receive.denyDeletes
2543 receive.denyNonFastForwards
2544 receive.fsckObjects
2545 receive.unpackLimit
2546 receive.updateserverinfo
2547 remote.pushdefault
2548 remotes.
2549 repack.usedeltabaseoffset
2550 rerere.autoupdate
2551 rerere.enabled
2552 sendemail.
2553 sendemail.aliasesfile
2554 sendemail.aliasfiletype
2555 sendemail.bcc
2556 sendemail.cc
2557 sendemail.cccmd
2558 sendemail.chainreplyto
2559 sendemail.confirm
2560 sendemail.envelopesender
2561 sendemail.from
2562 sendemail.identity
2563 sendemail.multiedit
2564 sendemail.signedoffbycc
2565 sendemail.smtpdomain
2566 sendemail.smtpencryption
2567 sendemail.smtppass
2568 sendemail.smtpserver
2569 sendemail.smtpserveroption
2570 sendemail.smtpserverport
2571 sendemail.smtpuser
2572 sendemail.suppresscc
2573 sendemail.suppressfrom
2574 sendemail.thread
2575 sendemail.to
2576 sendemail.tocmd
2577 sendemail.validate
2578 sendemail.smtpbatchsize
2579 sendemail.smtprelogindelay
2580 showbranch.default
2581 status.relativePaths
2582 status.showUntrackedFiles
2583 status.submodulesummary
2584 submodule.
2585 tar.umask
2586 transfer.unpackLimit
2587 url.
2588 user.email
2589 user.name
2590 user.signingkey
2591 web.browser
2592 branch. remote.
2593 "
2594}
2595_git_remote ()
2597{
2598 local subcommands="
2599 add rename remove set-head set-branches
2600 get-url set-url show prune update
2601 "
2602 local subcommand="$(__git_find_on_cmdline "$subcommands")"
2603 if [ -z "$subcommand" ]; then
2604 case "$cur" in
2605 --*)
2606 __gitcomp_builtin remote
2607 ;;
2608 *)
2609 __gitcomp "$subcommands"
2610 ;;
2611 esac
2612 return
2613 fi
2614 case "$subcommand,$cur" in
2616 add,--*)
2617 __gitcomp_builtin remote_add "--no-tags"
2618 ;;
2619 add,*)
2620 ;;
2621 set-head,--*)
2622 __gitcomp_builtin remote_set-head
2623 ;;
2624 set-branches,--*)
2625 __gitcomp_builtin remote_set-branches
2626 ;;
2627 set-head,*|set-branches,*)
2628 __git_complete_remote_or_refspec
2629 ;;
2630 update,--*)
2631 __gitcomp_builtin remote_update
2632 ;;
2633 update,*)
2634 __gitcomp "$(__git_get_config_variables "remotes")"
2635 ;;
2636 set-url,--*)
2637 __gitcomp_builtin remote_set-url
2638 ;;
2639 get-url,--*)
2640 __gitcomp_builtin remote_get-url
2641 ;;
2642 prune,--*)
2643 __gitcomp_builtin remote_prune
2644 ;;
2645 *)
2646 __gitcomp_nl "$(__git_remotes)"
2647 ;;
2648 esac
2649}
2650_git_replace ()
2652{
2653 case "$cur" in
2654 --*)
2655 __gitcomp_builtin replace
2656 return
2657 ;;
2658 esac
2659 __git_complete_refs
2660}
2661_git_rerere ()
2663{
2664 local subcommands="clear forget diff remaining status gc"
2665 local subcommand="$(__git_find_on_cmdline "$subcommands")"
2666 if test -z "$subcommand"
2667 then
2668 __gitcomp "$subcommands"
2669 return
2670 fi
2671}
2672_git_reset ()
2674{
2675 __git_has_doubledash && return
2676 case "$cur" in
2678 --*)
2679 __gitcomp_builtin reset
2680 return
2681 ;;
2682 esac
2683 __git_complete_refs
2684}
2685__git_revert_inprogress_options="--continue --quit --abort"
2687_git_revert ()
2689{
2690 __git_find_repo_path
2691 if [ -f "$__git_repo_path"/REVERT_HEAD ]; then
2692 __gitcomp "$__git_revert_inprogress_options"
2693 return
2694 fi
2695 case "$cur" in
2696 --*)
2697 __gitcomp_builtin revert "--no-edit" \
2698 "$__git_revert_inprogress_options"
2699 return
2700 ;;
2701 esac
2702 __git_complete_refs
2703}
2704_git_rm ()
2706{
2707 case "$cur" in
2708 --*)
2709 __gitcomp_builtin rm
2710 return
2711 ;;
2712 esac
2713 __git_complete_index_file "--cached"
2715}
2716_git_shortlog ()
2718{
2719 __git_has_doubledash && return
2720 case "$cur" in
2722 --*)
2723 __gitcomp "
2724 $__git_log_common_options
2725 $__git_log_shortlog_options
2726 --numbered --summary --email
2727 "
2728 return
2729 ;;
2730 esac
2731 __git_complete_revlist
2732}
2733_git_show ()
2735{
2736 __git_has_doubledash && return
2737 case "$cur" in
2739 --pretty=*|--format=*)
2740 __gitcomp "$__git_log_pretty_formats $(__git_pretty_aliases)
2741 " "" "${cur#*=}"
2742 return
2743 ;;
2744 --diff-algorithm=*)
2745 __gitcomp "$__git_diff_algorithms" "" "${cur##--diff-algorithm=}"
2746 return
2747 ;;
2748 --submodule=*)
2749 __gitcomp "$__git_diff_submodule_formats" "" "${cur##--submodule=}"
2750 return
2751 ;;
2752 --*)
2753 __gitcomp "--pretty= --format= --abbrev-commit --oneline
2754 --show-signature
2755 $__git_diff_common_options
2756 "
2757 return
2758 ;;
2759 esac
2760 __git_complete_revlist_file
2761}
2762_git_show_branch ()
2764{
2765 case "$cur" in
2766 --*)
2767 __gitcomp_builtin show-branch "--no-color"
2768 return
2769 ;;
2770 esac
2771 __git_complete_revlist
2772}
2773_git_stash ()
2775{
2776 local save_opts='--all --keep-index --no-keep-index --quiet --patch --include-untracked'
2777 local subcommands='push save list show apply clear drop pop create branch'
2778 local subcommand="$(__git_find_on_cmdline "$subcommands")"
2779 if [ -z "$subcommand" ]; then
2780 case "$cur" in
2781 --*)
2782 __gitcomp "$save_opts"
2783 ;;
2784 *)
2785 if [ -z "$(__git_find_on_cmdline "$save_opts")" ]; then
2786 __gitcomp "$subcommands"
2787 fi
2788 ;;
2789 esac
2790 else
2791 case "$subcommand,$cur" in
2792 push,--*)
2793 __gitcomp "$save_opts --message"
2794 ;;
2795 save,--*)
2796 __gitcomp "$save_opts"
2797 ;;
2798 apply,--*|pop,--*)
2799 __gitcomp "--index --quiet"
2800 ;;
2801 drop,--*)
2802 __gitcomp "--quiet"
2803 ;;
2804 show,--*|branch,--*)
2805 ;;
2806 branch,*)
2807 if [ $cword -eq 3 ]; then
2808 __git_complete_refs
2809 else
2810 __gitcomp_nl "$(__git stash list \
2811 | sed -n -e 's/:.*//p')"
2812 fi
2813 ;;
2814 show,*|apply,*|drop,*|pop,*)
2815 __gitcomp_nl "$(__git stash list \
2816 | sed -n -e 's/:.*//p')"
2817 ;;
2818 *)
2819 ;;
2820 esac
2821 fi
2822}
2823_git_submodule ()
2825{
2826 __git_has_doubledash && return
2827 local subcommands="add status init deinit update summary foreach sync"
2829 local subcommand="$(__git_find_on_cmdline "$subcommands")"
2830 if [ -z "$subcommand" ]; then
2831 case "$cur" in
2832 --*)
2833 __gitcomp "--quiet"
2834 ;;
2835 *)
2836 __gitcomp "$subcommands"
2837 ;;
2838 esac
2839 return
2840 fi
2841 case "$subcommand,$cur" in
2843 add,--*)
2844 __gitcomp "--branch --force --name --reference --depth"
2845 ;;
2846 status,--*)
2847 __gitcomp "--cached --recursive"
2848 ;;
2849 deinit,--*)
2850 __gitcomp "--force --all"
2851 ;;
2852 update,--*)
2853 __gitcomp "
2854 --init --remote --no-fetch
2855 --recommend-shallow --no-recommend-shallow
2856 --force --rebase --merge --reference --depth --recursive --jobs
2857 "
2858 ;;
2859 summary,--*)
2860 __gitcomp "--cached --files --summary-limit"
2861 ;;
2862 foreach,--*|sync,--*)
2863 __gitcomp "--recursive"
2864 ;;
2865 *)
2866 ;;
2867 esac
2868}
2869_git_svn ()
2871{
2872 local subcommands="
2873 init fetch clone rebase dcommit log find-rev
2874 set-tree commit-diff info create-ignore propget
2875 proplist show-ignore show-externals branch tag blame
2876 migrate mkdirs reset gc
2877 "
2878 local subcommand="$(__git_find_on_cmdline "$subcommands")"
2879 if [ -z "$subcommand" ]; then
2880 __gitcomp "$subcommands"
2881 else
2882 local remote_opts="--username= --config-dir= --no-auth-cache"
2883 local fc_opts="
2884 --follow-parent --authors-file= --repack=
2885 --no-metadata --use-svm-props --use-svnsync-props
2886 --log-window-size= --no-checkout --quiet
2887 --repack-flags --use-log-author --localtime
2888 --add-author-from
2889 --ignore-paths= --include-paths= $remote_opts
2890 "
2891 local init_opts="
2892 --template= --shared= --trunk= --tags=
2893 --branches= --stdlayout --minimize-url
2894 --no-metadata --use-svm-props --use-svnsync-props
2895 --rewrite-root= --prefix= $remote_opts
2896 "
2897 local cmt_opts="
2898 --edit --rmdir --find-copies-harder --copy-similarity=
2899 "
2900 case "$subcommand,$cur" in
2902 fetch,--*)
2903 __gitcomp "--revision= --fetch-all $fc_opts"
2904 ;;
2905 clone,--*)
2906 __gitcomp "--revision= $fc_opts $init_opts"
2907 ;;
2908 init,--*)
2909 __gitcomp "$init_opts"
2910 ;;
2911 dcommit,--*)
2912 __gitcomp "
2913 --merge --strategy= --verbose --dry-run
2914 --fetch-all --no-rebase --commit-url
2915 --revision --interactive $cmt_opts $fc_opts
2916 "
2917 ;;
2918 set-tree,--*)
2919 __gitcomp "--stdin $cmt_opts $fc_opts"
2920 ;;
2921 create-ignore,--*|propget,--*|proplist,--*|show-ignore,--*|\
2922 show-externals,--*|mkdirs,--*)
2923 __gitcomp "--revision="
2924 ;;
2925 log,--*)
2926 __gitcomp "
2927 --limit= --revision= --verbose --incremental
2928 --oneline --show-commit --non-recursive
2929 --authors-file= --color
2930 "
2931 ;;
2932 rebase,--*)
2933 __gitcomp "
2934 --merge --verbose --strategy= --local
2935 --fetch-all --dry-run $fc_opts
2936 "
2937 ;;
2938 commit-diff,--*)
2939 __gitcomp "--message= --file= --revision= $cmt_opts"
2940 ;;
2941 info,--*)
2942 __gitcomp "--url"
2943 ;;
2944 branch,--*)
2945 __gitcomp "--dry-run --message --tag"
2946 ;;
2947 tag,--*)
2948 __gitcomp "--dry-run --message"
2949 ;;
2950 blame,--*)
2951 __gitcomp "--git-format"
2952 ;;
2953 migrate,--*)
2954 __gitcomp "
2955 --config-dir= --ignore-paths= --minimize
2956 --no-auth-cache --username=
2957 "
2958 ;;
2959 reset,--*)
2960 __gitcomp "--revision= --parent"
2961 ;;
2962 *)
2963 ;;
2964 esac
2965 fi
2966}
2967_git_tag ()
2969{
2970 local i c=1 f=0
2971 while [ $c -lt $cword ]; do
2972 i="${words[c]}"
2973 case "$i" in
2974 -d|--delete|-v|--verify)
2975 __gitcomp_direct "$(__git_tags "" "$cur" " ")"
2976 return
2977 ;;
2978 -f)
2979 f=1
2980 ;;
2981 esac
2982 ((c++))
2983 done
2984 case "$prev" in
2986 -m|-F)
2987 ;;
2988 -*|tag)
2989 if [ $f = 1 ]; then
2990 __gitcomp_direct "$(__git_tags "" "$cur" " ")"
2991 fi
2992 ;;
2993 *)
2994 __git_complete_refs
2995 ;;
2996 esac
2997 case "$cur" in
2999 --*)
3000 __gitcomp_builtin tag
3001 ;;
3002 esac
3003}
3004_git_whatchanged ()
3006{
3007 _git_log
3008}
3009_git_worktree ()
3011{
3012 local subcommands="add list lock move prune remove unlock"
3013 local subcommand="$(__git_find_on_cmdline "$subcommands")"
3014 if [ -z "$subcommand" ]; then
3015 __gitcomp "$subcommands"
3016 else
3017 case "$subcommand,$cur" in
3018 add,--*)
3019 __gitcomp_builtin worktree_add
3020 ;;
3021 list,--*)
3022 __gitcomp_builtin worktree_list
3023 ;;
3024 lock,--*)
3025 __gitcomp_builtin worktree_lock
3026 ;;
3027 prune,--*)
3028 __gitcomp_builtin worktree_prune
3029 ;;
3030 remove,--*)
3031 __gitcomp "--force"
3032 ;;
3033 *)
3034 ;;
3035 esac
3036 fi
3037}
3038__git_main ()
3040{
3041 local i c=1 command __git_dir __git_repo_path
3042 local __git_C_args C_args_count=0
3043 while [ $c -lt $cword ]; do
3045 i="${words[c]}"
3046 case "$i" in
3047 --git-dir=*) __git_dir="${i#--git-dir=}" ;;
3048 --git-dir) ((c++)) ; __git_dir="${words[c]}" ;;
3049 --bare) __git_dir="." ;;
3050 --help) command="help"; break ;;
3051 -c|--work-tree|--namespace) ((c++)) ;;
3052 -C) __git_C_args[C_args_count++]=-C
3053 ((c++))
3054 __git_C_args[C_args_count++]="${words[c]}"
3055 ;;
3056 -*) ;;
3057 *) command="$i"; break ;;
3058 esac
3059 ((c++))
3060 done
3061 if [ -z "$command" ]; then
3063 case "$prev" in
3064 --git-dir|-C|--work-tree)
3065 # these need a path argument, let's fall back to
3066 # Bash filename completion
3067 return
3068 ;;
3069 -c|--namespace)
3070 # we don't support completing these options' arguments
3071 return
3072 ;;
3073 esac
3074 case "$cur" in
3075 --*) __gitcomp "
3076 --paginate
3077 --no-pager
3078 --git-dir=
3079 --bare
3080 --version
3081 --exec-path
3082 --exec-path=
3083 --html-path
3084 --man-path
3085 --info-path
3086 --work-tree=
3087 --namespace=
3088 --no-replace-objects
3089 --help
3090 "
3091 ;;
3092 *) __git_compute_porcelain_commands
3093 __gitcomp "$__git_porcelain_commands $(__git_aliases)" ;;
3094 esac
3095 return
3096 fi
3097 local completion_func="_git_${command//-/_}"
3099 declare -f $completion_func >/dev/null 2>/dev/null && $completion_func && return
3100 local expansion=$(__git_aliased_command "$command")
3102 if [ -n "$expansion" ]; then
3103 words[1]=$expansion
3104 completion_func="_git_${expansion//-/_}"
3105 declare -f $completion_func >/dev/null 2>/dev/null && $completion_func
3106 fi
3107}
3108__gitk_main ()
3110{
3111 __git_has_doubledash && return
3112 local __git_repo_path
3114 __git_find_repo_path
3115 local merge=""
3117 if [ -f "$__git_repo_path/MERGE_HEAD" ]; then
3118 merge="--merge"
3119 fi
3120 case "$cur" in
3121 --*)
3122 __gitcomp "
3123 $__git_log_common_options
3124 $__git_log_gitk_options
3125 $merge
3126 "
3127 return
3128 ;;
3129 esac
3130 __git_complete_revlist
3131}
3132if [[ -n ${ZSH_VERSION-} ]]; then
3134 echo "WARNING: this script is deprecated, please see git-completion.zsh" 1>&2
3135 autoload -U +X compinit && compinit
3137 __gitcomp ()
3139 {
3140 emulate -L zsh
3141 local cur_="${3-$cur}"
3143 case "$cur_" in
3145 --*=)
3146 ;;
3147 *)
3148 local c IFS=$' \t\n'
3149 local -a array
3150 for c in ${=1}; do
3151 c="$c${4-}"
3152 case $c in
3153 --*=*|*.) ;;
3154 *) c="$c " ;;
3155 esac
3156 array[${#array[@]}+1]="$c"
3157 done
3158 compset -P '*[=:]'
3159 compadd -Q -S '' -p "${2-}" -a -- array && _ret=0
3160 ;;
3161 esac
3162 }
3163 __gitcomp_direct ()
3165 {
3166 emulate -L zsh
3167 local IFS=$'\n'
3169 compset -P '*[=:]'
3170 compadd -Q -- ${=1} && _ret=0
3171 }
3172 __gitcomp_nl ()
3174 {
3175 emulate -L zsh
3176 local IFS=$'\n'
3178 compset -P '*[=:]'
3179 compadd -Q -S "${4- }" -p "${2-}" -- ${=1} && _ret=0
3180 }
3181 __gitcomp_file ()
3183 {
3184 emulate -L zsh
3185 local IFS=$'\n'
3187 compset -P '*[=:]'
3188 compadd -Q -p "${2-}" -f -- ${=1} && _ret=0
3189 }
3190 _git ()
3192 {
3193 local _ret=1 cur cword prev
3194 cur=${words[CURRENT]}
3195 prev=${words[CURRENT-1]}
3196 let cword=CURRENT-1
3197 emulate ksh -c __${service}_main
3198 let _ret && _default && _ret=0
3199 return _ret
3200 }
3201 compdef _git git gitk
3203 return
3204fi
3205__git_func_wrap ()
3207{
3208 local cur words cword prev
3209 _get_comp_words_by_ref -n =: cur words cword prev
3210 $1
3211}
3212# Setup completion for certain functions defined above by setting common
3214# variables and workarounds.
3215# This is NOT a public function; use at your own risk.
3216__git_complete ()
3217{
3218 local wrapper="__git_wrap${2}"
3219 eval "$wrapper () { __git_func_wrap $2 ; }"
3220 complete -o bashdefault -o default -o nospace -F $wrapper $1 2>/dev/null \
3221 || complete -o default -o nospace -F $wrapper $1
3222}
3223# wrapper for backwards compatibility
3225_git ()
3226{
3227 __git_wrap__git_main
3228}
3229# wrapper for backwards compatibility
3231_gitk ()
3232{
3233 __git_wrap__gitk_main
3234}
3235__git_complete git __git_main
3237__git_complete gitk __gitk_main
3238# The following are necessary only for Cygwin, and only are needed
3240# when the user has tab-completed the executable name and consequently
3241# included the '.exe' suffix.
3242#
3243if [ Cygwin = "$(uname -o 2>/dev/null)" ]; then
3244__git_complete git.exe __git_main
3245fi