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