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# Variation of __gitcomp_nl () that appends to the existing list of
284# completion candidates, COMPREPLY.
285__gitcomp_nl_append ()
286{
287 local IFS=$'\n'
288 __gitcompappend "$1" "${2-}" "${3-$cur}" "${4- }"
289}
290# Generates completion reply from newline-separated possible completion words
292# by appending a space to all of them.
293# It accepts 1 to 4 arguments:
294# 1: List of possible completion words, separated by a single newline.
295# 2: A prefix to be added to each possible completion word (optional).
296# 3: Generate possible completion matches for this word (optional).
297# 4: A suffix to be appended to each possible completion word instead of
298# the default space (optional). If specified but empty, nothing is
299# appended.
300__gitcomp_nl ()
301{
302 COMPREPLY=()
303 __gitcomp_nl_append "$@"
304}
305# Generates completion reply with compgen from newline-separated possible
307# completion filenames.
308# It accepts 1 to 3 arguments:
309# 1: List of possible completion filenames, separated by a single newline.
310# 2: A directory prefix to be added to each possible completion filename
311# (optional).
312# 3: Generate possible completion matches for this word (optional).
313__gitcomp_file ()
314{
315 local IFS=$'\n'
316 # XXX does not work when the directory prefix contains a tilde,
318 # since tilde expansion is not applied.
319 # This means that COMPREPLY will be empty and Bash default
320 # completion will be used.
321 __gitcompadd "$1" "${2-}" "${3-$cur}" ""
322 # use a hack to enable file mode in bash < 4
324 compopt -o filenames +o nospace 2>/dev/null ||
325 compgen -f /non-existing-dir/ > /dev/null
326}
327# Execute 'git ls-files', unless the --committable option is specified, in
329# which case it runs 'git diff-index' to find out the files that can be
330# committed. It return paths relative to the directory specified in the first
331# argument, and using the options specified in the second argument.
332__git_ls_files_helper ()
333{
334 if [ "$2" == "--committable" ]; then
335 __git -C "$1" diff-index --name-only --relative HEAD
336 else
337 # NOTE: $2 is not quoted in order to support multiple options
338 __git -C "$1" ls-files --exclude-standard $2
339 fi
340}
341# __git_index_files accepts 1 or 2 arguments:
344# 1: Options to pass to ls-files (required).
345# 2: A directory path (optional).
346# If provided, only files within the specified directory are listed.
347# Sub directories are never recursed. Path must have a trailing
348# slash.
349__git_index_files ()
350{
351 local root="${2-.}" file
352 __git_ls_files_helper "$root" "$1" |
354 while read -r file; do
355 case "$file" in
356 ?*/*) echo "${file%%/*}" ;;
357 *) echo "$file" ;;
358 esac
359 done | sort | uniq
360}
361# Lists branches from the local repository.
363# 1: A prefix to be added to each listed branch (optional).
364# 2: List only branches matching this word (optional; list all branches if
365# unset or empty).
366# 3: A suffix to be appended to each listed branch (optional).
367__git_heads ()
368{
369 local pfx="${1-}" cur_="${2-}" sfx="${3-}"
370 __git for-each-ref --format="${pfx//\%/%%}%(refname:strip=2)$sfx" \
372 "refs/heads/$cur_*" "refs/heads/$cur_*/**"
373}
374# Lists tags from the local repository.
376# Accepts the same positional parameters as __git_heads() above.
377__git_tags ()
378{
379 local pfx="${1-}" cur_="${2-}" sfx="${3-}"
380 __git for-each-ref --format="${pfx//\%/%%}%(refname:strip=2)$sfx" \
382 "refs/tags/$cur_*" "refs/tags/$cur_*/**"
383}
384# Lists refs from the local (by default) or from a remote repository.
386# It accepts 0, 1 or 2 arguments:
387# 1: The remote to list refs from (optional; ignored, if set but empty).
388# Can be the name of a configured remote, a path, or a URL.
389# 2: In addition to local refs, list unique branches from refs/remotes/ for
390# 'git checkout's tracking DWIMery (optional; ignored, if set but empty).
391# 3: A prefix to be added to each listed ref (optional).
392# 4: List only refs matching this word (optional; list all refs if unset or
393# empty).
394# 5: A suffix to be appended to each listed ref (optional; ignored, if set
395# but empty).
396#
397# Use __git_complete_refs() instead.
398__git_refs ()
399{
400 local i hash dir track="${2-}"
401 local list_refs_from=path remote="${1-}"
402 local format refs
403 local pfx="${3-}" cur_="${4-$cur}" sfx="${5-}"
404 local match="${4-}"
405 local fer_pfx="${pfx//\%/%%}" # "escape" for-each-ref format specifiers
406 __git_find_repo_path
408 dir="$__git_repo_path"
409 if [ -z "$remote" ]; then
411 if [ -z "$dir" ]; then
412 return
413 fi
414 else
415 if __git_is_configured_remote "$remote"; then
416 # configured remote takes precedence over a
417 # local directory with the same name
418 list_refs_from=remote
419 elif [ -d "$remote/.git" ]; then
420 dir="$remote/.git"
421 elif [ -d "$remote" ]; then
422 dir="$remote"
423 else
424 list_refs_from=url
425 fi
426 fi
427 if [ "$list_refs_from" = path ]; then
429 if [[ "$cur_" == ^* ]]; then
430 pfx="$pfx^"
431 fer_pfx="$fer_pfx^"
432 cur_=${cur_#^}
433 match=${match#^}
434 fi
435 case "$cur_" in
436 refs|refs/*)
437 format="refname"
438 refs=("$match*" "$match*/**")
439 track=""
440 ;;
441 *)
442 for i in HEAD FETCH_HEAD ORIG_HEAD MERGE_HEAD; do
443 case "$i" in
444 $match*)
445 if [ -e "$dir/$i" ]; then
446 echo "$pfx$i$sfx"
447 fi
448 ;;
449 esac
450 done
451 format="refname:strip=2"
452 refs=("refs/tags/$match*" "refs/tags/$match*/**"
453 "refs/heads/$match*" "refs/heads/$match*/**"
454 "refs/remotes/$match*" "refs/remotes/$match*/**")
455 ;;
456 esac
457 __git_dir="$dir" __git for-each-ref --format="$fer_pfx%($format)$sfx" \
458 "${refs[@]}"
459 if [ -n "$track" ]; then
460 # employ the heuristic used by git checkout
461 # Try to find a remote branch that matches the completion word
462 # but only output if the branch name is unique
463 __git for-each-ref --format="$fer_pfx%(refname:strip=3)$sfx" \
464 --sort="refname:strip=3" \
465 "refs/remotes/*/$match*" "refs/remotes/*/$match*/**" | \
466 uniq -u
467 fi
468 return
469 fi
470 case "$cur_" in
471 refs|refs/*)
472 __git ls-remote "$remote" "$match*" | \
473 while read -r hash i; do
474 case "$i" in
475 *^{}) ;;
476 *) echo "$pfx$i$sfx" ;;
477 esac
478 done
479 ;;
480 *)
481 if [ "$list_refs_from" = remote ]; then
482 case "HEAD" in
483 $match*) echo "${pfx}HEAD$sfx" ;;
484 esac
485 __git for-each-ref --format="$fer_pfx%(refname:strip=3)$sfx" \
486 "refs/remotes/$remote/$match*" \
487 "refs/remotes/$remote/$match*/**"
488 else
489 local query_symref
490 case "HEAD" in
491 $match*) query_symref="HEAD" ;;
492 esac
493 __git ls-remote "$remote" $query_symref \
494 "refs/tags/$match*" "refs/heads/$match*" \
495 "refs/remotes/$match*" |
496 while read -r hash i; do
497 case "$i" in
498 *^{}) ;;
499 refs/*) echo "$pfx${i#refs/*/}$sfx" ;;
500 *) echo "$pfx$i$sfx" ;; # symbolic refs
501 esac
502 done
503 fi
504 ;;
505 esac
506}
507# Completes refs, short and long, local and remote, symbolic and pseudo.
509#
510# Usage: __git_complete_refs [<option>]...
511# --remote=<remote>: The remote to list refs from, can be the name of a
512# configured remote, a path, or a URL.
513# --track: List unique remote branches for 'git checkout's tracking DWIMery.
514# --pfx=<prefix>: A prefix to be added to each ref.
515# --cur=<word>: The current ref to be completed. Defaults to the current
516# word to be completed.
517# --sfx=<suffix>: A suffix to be appended to each ref instead of the default
518# space.
519__git_complete_refs ()
520{
521 local remote track pfx cur_="$cur" sfx=" "
522 while test $# != 0; do
524 case "$1" in
525 --remote=*) remote="${1##--remote=}" ;;
526 --track) track="yes" ;;
527 --pfx=*) pfx="${1##--pfx=}" ;;
528 --cur=*) cur_="${1##--cur=}" ;;
529 --sfx=*) sfx="${1##--sfx=}" ;;
530 *) return 1 ;;
531 esac
532 shift
533 done
534 __gitcomp_direct "$(__git_refs "$remote" "$track" "$pfx" "$cur_" "$sfx")"
536}
537# __git_refs2 requires 1 argument (to pass to __git_refs)
539# Deprecated: use __git_complete_fetch_refspecs() instead.
540__git_refs2 ()
541{
542 local i
543 for i in $(__git_refs "$1"); do
544 echo "$i:$i"
545 done
546}
547# Completes refspecs for fetching from a remote repository.
549# 1: The remote repository.
550# 2: A prefix to be added to each listed refspec (optional).
551# 3: The ref to be completed as a refspec instead of the current word to be
552# completed (optional)
553# 4: A suffix to be appended to each listed refspec instead of the default
554# space (optional).
555__git_complete_fetch_refspecs ()
556{
557 local i remote="$1" pfx="${2-}" cur_="${3-$cur}" sfx="${4- }"
558 __gitcomp_direct "$(
560 for i in $(__git_refs "$remote" "" "" "$cur_") ; do
561 echo "$pfx$i:$i$sfx"
562 done
563 )"
564}
565# __git_refs_remotes requires 1 argument (to pass to ls-remote)
567__git_refs_remotes ()
568{
569 local i hash
570 __git ls-remote "$1" 'refs/heads/*' | \
571 while read -r hash i; do
572 echo "$i:refs/remotes/$1/${i#refs/heads/}"
573 done
574}
575__git_remotes ()
577{
578 __git_find_repo_path
579 test -d "$__git_repo_path/remotes" && ls -1 "$__git_repo_path/remotes"
580 __git remote
581}
582# Returns true if $1 matches the name of a configured remote, false otherwise.
584__git_is_configured_remote ()
585{
586 local remote
587 for remote in $(__git_remotes); do
588 if [ "$remote" = "$1" ]; then
589 return 0
590 fi
591 done
592 return 1
593}
594__git_list_merge_strategies ()
596{
597 LANG=C LC_ALL=C git merge -s help 2>&1 |
598 sed -n -e '/[Aa]vailable strategies are: /,/^$/{
599 s/\.$//
600 s/.*://
601 s/^[ ]*//
602 s/[ ]*$//
603 p
604 }'
605}
606__git_merge_strategies=
608# 'git merge -s help' (and thus detection of the merge strategy
609# list) fails, unfortunately, if run outside of any git working
610# tree. __git_merge_strategies is set to the empty string in
611# that case, and the detection will be repeated the next time it
612# is needed.
613__git_compute_merge_strategies ()
614{
615 test -n "$__git_merge_strategies" ||
616 __git_merge_strategies=$(__git_list_merge_strategies)
617}
618__git_complete_revlist_file ()
620{
621 local pfx ls ref cur_="$cur"
622 case "$cur_" in
623 *..?*:*)
624 return
625 ;;
626 ?*:*)
627 ref="${cur_%%:*}"
628 cur_="${cur_#*:}"
629 case "$cur_" in
630 ?*/*)
631 pfx="${cur_%/*}"
632 cur_="${cur_##*/}"
633 ls="$ref:$pfx"
634 pfx="$pfx/"
635 ;;
636 *)
637 ls="$ref"
638 ;;
639 esac
640 case "$COMP_WORDBREAKS" in
642 *:*) : great ;;
643 *) pfx="$ref:$pfx" ;;
644 esac
645 __gitcomp_nl "$(__git ls-tree "$ls" \
647 | sed '/^100... blob /{
648 s,^.* ,,
649 s,$, ,
650 }
651 /^120000 blob /{
652 s,^.* ,,
653 s,$, ,
654 }
655 /^040000 tree /{
656 s,^.* ,,
657 s,$,/,
658 }
659 s/^.* //')" \
660 "$pfx" "$cur_" ""
661 ;;
662 *...*)
663 pfx="${cur_%...*}..."
664 cur_="${cur_#*...}"
665 __git_complete_refs --pfx="$pfx" --cur="$cur_"
666 ;;
667 *..*)
668 pfx="${cur_%..*}.."
669 cur_="${cur_#*..}"
670 __git_complete_refs --pfx="$pfx" --cur="$cur_"
671 ;;
672 *)
673 __git_complete_refs
674 ;;
675 esac
676}
677# __git_complete_index_file requires 1 argument:
680# 1: the options to pass to ls-file
681#
682# The exception is --committable, which finds the files appropriate commit.
683__git_complete_index_file ()
684{
685 local pfx="" cur_="$cur"
686 case "$cur_" in
688 ?*/*)
689 pfx="${cur_%/*}"
690 cur_="${cur_##*/}"
691 pfx="${pfx}/"
692 ;;
693 esac
694 __gitcomp_file "$(__git_index_files "$1" ${pfx:+"$pfx"})" "$pfx" "$cur_"
696}
697__git_complete_file ()
699{
700 __git_complete_revlist_file
701}
702__git_complete_revlist ()
704{
705 __git_complete_revlist_file
706}
707__git_complete_remote_or_refspec ()
709{
710 local cur_="$cur" cmd="${words[1]}"
711 local i c=2 remote="" pfx="" lhs=1 no_complete_refspec=0
712 if [ "$cmd" = "remote" ]; then
713 ((c++))
714 fi
715 while [ $c -lt $cword ]; do
716 i="${words[c]}"
717 case "$i" in
718 --mirror) [ "$cmd" = "push" ] && no_complete_refspec=1 ;;
719 -d|--delete) [ "$cmd" = "push" ] && lhs=0 ;;
720 --all)
721 case "$cmd" in
722 push) no_complete_refspec=1 ;;
723 fetch)
724 return
725 ;;
726 *) ;;
727 esac
728 ;;
729 -*) ;;
730 *) remote="$i"; break ;;
731 esac
732 ((c++))
733 done
734 if [ -z "$remote" ]; then
735 __gitcomp_nl "$(__git_remotes)"
736 return
737 fi
738 if [ $no_complete_refspec = 1 ]; then
739 return
740 fi
741 [ "$remote" = "." ] && remote=
742 case "$cur_" in
743 *:*)
744 case "$COMP_WORDBREAKS" in
745 *:*) : great ;;
746 *) pfx="${cur_%%:*}:" ;;
747 esac
748 cur_="${cur_#*:}"
749 lhs=0
750 ;;
751 +*)
752 pfx="+"
753 cur_="${cur_#+}"
754 ;;
755 esac
756 case "$cmd" in
757 fetch)
758 if [ $lhs = 1 ]; then
759 __git_complete_fetch_refspecs "$remote" "$pfx" "$cur_"
760 else
761 __git_complete_refs --pfx="$pfx" --cur="$cur_"
762 fi
763 ;;
764 pull|remote)
765 if [ $lhs = 1 ]; then
766 __git_complete_refs --remote="$remote" --pfx="$pfx" --cur="$cur_"
767 else
768 __git_complete_refs --pfx="$pfx" --cur="$cur_"
769 fi
770 ;;
771 push)
772 if [ $lhs = 1 ]; then
773 __git_complete_refs --pfx="$pfx" --cur="$cur_"
774 else
775 __git_complete_refs --remote="$remote" --pfx="$pfx" --cur="$cur_"
776 fi
777 ;;
778 esac
779}
780__git_complete_strategy ()
782{
783 __git_compute_merge_strategies
784 case "$prev" in
785 -s|--strategy)
786 __gitcomp "$__git_merge_strategies"
787 return 0
788 esac
789 case "$cur" in
790 --strategy=*)
791 __gitcomp "$__git_merge_strategies" "" "${cur##--strategy=}"
792 return 0
793 ;;
794 esac
795 return 1
796}
797__git_commands () {
799 if test -n "${GIT_TESTING_COMMAND_COMPLETION:-}"
800 then
801 printf "%s" "${GIT_TESTING_COMMAND_COMPLETION}"
802 else
803 git help -a|egrep '^ [a-zA-Z0-9]'
804 fi
805}
806__git_list_all_commands ()
808{
809 local i IFS=" "$'\n'
810 for i in $(__git_commands)
811 do
812 case $i in
813 *--*) : helper pattern;;
814 *) echo $i;;
815 esac
816 done
817}
818__git_all_commands=
820__git_compute_all_commands ()
821{
822 test -n "$__git_all_commands" ||
823 __git_all_commands=$(__git_list_all_commands)
824}
825__git_list_porcelain_commands ()
827{
828 local i IFS=" "$'\n'
829 __git_compute_all_commands
830 for i in $__git_all_commands
831 do
832 case $i in
833 *--*) : helper pattern;;
834 applymbox) : ask gittus;;
835 applypatch) : ask gittus;;
836 archimport) : import;;
837 cat-file) : plumbing;;
838 check-attr) : plumbing;;
839 check-ignore) : plumbing;;
840 check-mailmap) : plumbing;;
841 check-ref-format) : plumbing;;
842 checkout-index) : plumbing;;
843 column) : internal helper;;
844 commit-graph) : plumbing;;
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 --copy --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 --ignore-cr-at-eol
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 --autostash --no-autostash
1927 $__git_merge_options
1928 $__git_fetch_options
1929 "
1930 return
1931 ;;
1932 esac
1933 __git_complete_remote_or_refspec
1934}
1935__git_push_recurse_submodules="check on-demand only"
1937__git_complete_force_with_lease ()
1939{
1940 local cur_=$1
1941 case "$cur_" in
1943 --*=)
1944 ;;
1945 *:*)
1946 __git_complete_refs --cur="${cur_#*:}"
1947 ;;
1948 *)
1949 __git_complete_refs --cur="$cur_"
1950 ;;
1951 esac
1952}
1953_git_push ()
1955{
1956 case "$prev" in
1957 --repo)
1958 __gitcomp_nl "$(__git_remotes)"
1959 return
1960 ;;
1961 --recurse-submodules)
1962 __gitcomp "$__git_push_recurse_submodules"
1963 return
1964 ;;
1965 esac
1966 case "$cur" in
1967 --repo=*)
1968 __gitcomp_nl "$(__git_remotes)" "" "${cur##--repo=}"
1969 return
1970 ;;
1971 --recurse-submodules=*)
1972 __gitcomp "$__git_push_recurse_submodules" "" "${cur##--recurse-submodules=}"
1973 return
1974 ;;
1975 --force-with-lease=*)
1976 __git_complete_force_with_lease "${cur##--force-with-lease=}"
1977 return
1978 ;;
1979 --*)
1980 __gitcomp "
1981 --all --mirror --tags --dry-run --force --verbose
1982 --quiet --prune --delete --follow-tags
1983 --receive-pack= --repo= --set-upstream
1984 --force-with-lease --force-with-lease= --recurse-submodules=
1985 "
1986 return
1987 ;;
1988 esac
1989 __git_complete_remote_or_refspec
1990}
1991_git_rebase ()
1993{
1994 __git_find_repo_path
1995 if [ -f "$__git_repo_path"/rebase-merge/interactive ]; then
1996 __gitcomp "--continue --skip --abort --quit --edit-todo"
1997 return
1998 elif [ -d "$__git_repo_path"/rebase-apply ] || \
1999 [ -d "$__git_repo_path"/rebase-merge ]; then
2000 __gitcomp "--continue --skip --abort --quit"
2001 return
2002 fi
2003 __git_complete_strategy && return
2004 case "$cur" in
2005 --whitespace=*)
2006 __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
2007 return
2008 ;;
2009 --*)
2010 __gitcomp "
2011 --onto --merge --strategy --interactive
2012 --preserve-merges --stat --no-stat
2013 --committer-date-is-author-date --ignore-date
2014 --ignore-whitespace --whitespace=
2015 --autosquash --no-autosquash
2016 --fork-point --no-fork-point
2017 --autostash --no-autostash
2018 --verify --no-verify
2019 --keep-empty --root --force-rebase --no-ff
2020 --exec
2021 "
2022 return
2024 esac
2025 __git_complete_refs
2026}
2027_git_reflog ()
2029{
2030 local subcommands="show delete expire"
2031 local subcommand="$(__git_find_on_cmdline "$subcommands")"
2032 if [ -z "$subcommand" ]; then
2034 __gitcomp "$subcommands"
2035 else
2036 __git_complete_refs
2037 fi
2038}
2039__git_send_email_confirm_options="always never auto cc compose"
2041__git_send_email_suppresscc_options="author self cc bodycc sob cccmd body all"
2042_git_send_email ()
2044{
2045 case "$prev" in
2046 --to|--cc|--bcc|--from)
2047 __gitcomp "$(__git send-email --dump-aliases)"
2048 return
2049 ;;
2050 esac
2051 case "$cur" in
2053 --confirm=*)
2054 __gitcomp "
2055 $__git_send_email_confirm_options
2056 " "" "${cur##--confirm=}"
2057 return
2058 ;;
2059 --suppress-cc=*)
2060 __gitcomp "
2061 $__git_send_email_suppresscc_options
2062 " "" "${cur##--suppress-cc=}"
2063 return
2065 ;;
2066 --smtp-encryption=*)
2067 __gitcomp "ssl tls" "" "${cur##--smtp-encryption=}"
2068 return
2069 ;;
2070 --thread=*)
2071 __gitcomp "
2072 deep shallow
2073 " "" "${cur##--thread=}"
2074 return
2075 ;;
2076 --to=*|--cc=*|--bcc=*|--from=*)
2077 __gitcomp "$(__git send-email --dump-aliases)" "" "${cur#--*=}"
2078 return
2079 ;;
2080 --*)
2081 __gitcomp "--annotate --bcc --cc --cc-cmd --chain-reply-to
2082 --compose --confirm= --dry-run --envelope-sender
2083 --from --identity
2084 --in-reply-to --no-chain-reply-to --no-signed-off-by-cc
2085 --no-suppress-from --no-thread --quiet
2086 --signed-off-by-cc --smtp-pass --smtp-server
2087 --smtp-server-port --smtp-encryption= --smtp-user
2088 --subject --suppress-cc= --suppress-from --thread --to
2089 --validate --no-validate
2090 $__git_format_patch_options"
2091 return
2092 ;;
2093 esac
2094 __git_complete_revlist
2095}
2096_git_stage ()
2098{
2099 _git_add
2100}
2101_git_status ()
2103{
2104 local complete_opt
2105 local untracked_state
2106 case "$cur" in
2108 --ignore-submodules=*)
2109 __gitcomp "none untracked dirty all" "" "${cur##--ignore-submodules=}"
2110 return
2111 ;;
2112 --untracked-files=*)
2113 __gitcomp "$__git_untracked_file_modes" "" "${cur##--untracked-files=}"
2114 return
2115 ;;
2116 --column=*)
2117 __gitcomp "
2118 always never auto column row plain dense nodense
2119 " "" "${cur##--column=}"
2120 return
2121 ;;
2122 --*)
2123 __gitcomp "
2124 --short --branch --porcelain --long --verbose
2125 --untracked-files= --ignore-submodules= --ignored
2126 --column= --no-column
2127 "
2128 return
2129 ;;
2130 esac
2131 untracked_state="$(__git_get_option_value "-u" "--untracked-files=" \
2133 "$__git_untracked_file_modes" "status.showUntrackedFiles")"
2134 case "$untracked_state" in
2136 no)
2137 # --ignored option does not matter
2138 complete_opt=
2139 ;;
2140 all|normal|*)
2141 complete_opt="--cached --directory --no-empty-directory --others"
2142 if [ -n "$(__git_find_on_cmdline "--ignored")" ]; then
2144 complete_opt="$complete_opt --ignored --exclude=*"
2145 fi
2146 ;;
2147 esac
2148 __git_complete_index_file "$complete_opt"
2150}
2151__git_config_get_set_variables ()
2153{
2154 local prevword word config_file= c=$cword
2155 while [ $c -gt 1 ]; do
2156 word="${words[c]}"
2157 case "$word" in
2158 --system|--global|--local|--file=*)
2159 config_file="$word"
2160 break
2161 ;;
2162 -f|--file)
2163 config_file="$word $prevword"
2164 break
2165 ;;
2166 esac
2167 prevword=$word
2168 c=$((--c))
2169 done
2170 __git config $config_file --name-only --list
2172}
2173_git_config ()
2175{
2176 case "$prev" in
2177 branch.*.remote|branch.*.pushremote)
2178 __gitcomp_nl "$(__git_remotes)"
2179 return
2180 ;;
2181 branch.*.merge)
2182 __git_complete_refs
2183 return
2184 ;;
2185 branch.*.rebase)
2186 __gitcomp "false true preserve interactive"
2187 return
2188 ;;
2189 remote.pushdefault)
2190 __gitcomp_nl "$(__git_remotes)"
2191 return
2192 ;;
2193 remote.*.fetch)
2194 local remote="${prev#remote.}"
2195 remote="${remote%.fetch}"
2196 if [ -z "$cur" ]; then
2197 __gitcomp_nl "refs/heads/" "" "" ""
2198 return
2199 fi
2200 __gitcomp_nl "$(__git_refs_remotes "$remote")"
2201 return
2202 ;;
2203 remote.*.push)
2204 local remote="${prev#remote.}"
2205 remote="${remote%.push}"
2206 __gitcomp_nl "$(__git for-each-ref \
2207 --format='%(refname):%(refname)' refs/heads)"
2208 return
2209 ;;
2210 pull.twohead|pull.octopus)
2211 __git_compute_merge_strategies
2212 __gitcomp "$__git_merge_strategies"
2213 return
2214 ;;
2215 color.branch|color.diff|color.interactive|\
2216 color.showbranch|color.status|color.ui)
2217 __gitcomp "always never auto"
2218 return
2219 ;;
2220 color.pager)
2221 __gitcomp "false true"
2222 return
2223 ;;
2224 color.*.*)
2225 __gitcomp "
2226 normal black red green yellow blue magenta cyan white
2227 bold dim ul blink reverse
2228 "
2229 return
2230 ;;
2231 diff.submodule)
2232 __gitcomp "log short"
2233 return
2234 ;;
2235 help.format)
2236 __gitcomp "man info web html"
2237 return
2238 ;;
2239 log.date)
2240 __gitcomp "$__git_log_date_formats"
2241 return
2242 ;;
2243 sendemail.aliasesfiletype)
2244 __gitcomp "mutt mailrc pine elm gnus"
2245 return
2246 ;;
2247 sendemail.confirm)
2248 __gitcomp "$__git_send_email_confirm_options"
2249 return
2250 ;;
2251 sendemail.suppresscc)
2252 __gitcomp "$__git_send_email_suppresscc_options"
2253 return
2254 ;;
2255 sendemail.transferencoding)
2256 __gitcomp "7bit 8bit quoted-printable base64"
2257 return
2258 ;;
2259 --get|--get-all|--unset|--unset-all)
2260 __gitcomp_nl "$(__git_config_get_set_variables)"
2261 return
2262 ;;
2263 *.*)
2264 return
2265 ;;
2266 esac
2267 case "$cur" in
2268 --*)
2269 __gitcomp "
2270 --system --global --local --file=
2271 --list --replace-all
2272 --get --get-all --get-regexp
2273 --add --unset --unset-all
2274 --remove-section --rename-section
2275 --name-only
2276 "
2277 return
2278 ;;
2279 branch.*.*)
2280 local pfx="${cur%.*}." cur_="${cur##*.}"
2281 __gitcomp "remote pushremote merge mergeoptions rebase" "$pfx" "$cur_"
2282 return
2283 ;;
2284 branch.*)
2285 local pfx="${cur%.*}." cur_="${cur#*.}"
2286 __gitcomp_direct "$(__git_heads "$pfx" "$cur_" ".")"
2287 __gitcomp_nl_append $'autosetupmerge\nautosetuprebase\n' "$pfx" "$cur_"
2288 return
2289 ;;
2290 guitool.*.*)
2291 local pfx="${cur%.*}." cur_="${cur##*.}"
2292 __gitcomp "
2293 argprompt cmd confirm needsfile noconsole norescan
2294 prompt revprompt revunmerged title
2295 " "$pfx" "$cur_"
2296 return
2297 ;;
2298 difftool.*.*)
2299 local pfx="${cur%.*}." cur_="${cur##*.}"
2300 __gitcomp "cmd path" "$pfx" "$cur_"
2301 return
2302 ;;
2303 man.*.*)
2304 local pfx="${cur%.*}." cur_="${cur##*.}"
2305 __gitcomp "cmd path" "$pfx" "$cur_"
2306 return
2307 ;;
2308 mergetool.*.*)
2309 local pfx="${cur%.*}." cur_="${cur##*.}"
2310 __gitcomp "cmd path trustExitCode" "$pfx" "$cur_"
2311 return
2312 ;;
2313 pager.*)
2314 local pfx="${cur%.*}." cur_="${cur#*.}"
2315 __git_compute_all_commands
2316 __gitcomp_nl "$__git_all_commands" "$pfx" "$cur_"
2317 return
2318 ;;
2319 remote.*.*)
2320 local pfx="${cur%.*}." cur_="${cur##*.}"
2321 __gitcomp "
2322 url proxy fetch push mirror skipDefaultUpdate
2323 receivepack uploadpack tagopt pushurl
2324 " "$pfx" "$cur_"
2325 return
2326 ;;
2327 remote.*)
2328 local pfx="${cur%.*}." cur_="${cur#*.}"
2329 __gitcomp_nl "$(__git_remotes)" "$pfx" "$cur_" "."
2330 __gitcomp_nl_append "pushdefault" "$pfx" "$cur_"
2331 return
2332 ;;
2333 url.*.*)
2334 local pfx="${cur%.*}." cur_="${cur##*.}"
2335 __gitcomp "insteadOf pushInsteadOf" "$pfx" "$cur_"
2336 return
2337 ;;
2338 esac
2339 __gitcomp "
2340 add.ignoreErrors
2341 advice.amWorkDir
2342 advice.commitBeforeMerge
2343 advice.detachedHead
2344 advice.implicitIdentity
2345 advice.pushAlreadyExists
2346 advice.pushFetchFirst
2347 advice.pushNeedsForce
2348 advice.pushNonFFCurrent
2349 advice.pushNonFFMatching
2350 advice.pushUpdateRejected
2351 advice.resolveConflict
2352 advice.rmHints
2353 advice.statusHints
2354 advice.statusUoption
2355 advice.ignoredHook
2356 alias.
2357 am.keepcr
2358 am.threeWay
2359 apply.ignorewhitespace
2360 apply.whitespace
2361 branch.autosetupmerge
2362 branch.autosetuprebase
2363 browser.
2364 clean.requireForce
2365 color.branch
2366 color.branch.current
2367 color.branch.local
2368 color.branch.plain
2369 color.branch.remote
2370 color.decorate.HEAD
2371 color.decorate.branch
2372 color.decorate.remoteBranch
2373 color.decorate.stash
2374 color.decorate.tag
2375 color.diff
2376 color.diff.commit
2377 color.diff.frag
2378 color.diff.func
2379 color.diff.meta
2380 color.diff.new
2381 color.diff.old
2382 color.diff.plain
2383 color.diff.whitespace
2384 color.grep
2385 color.grep.context
2386 color.grep.filename
2387 color.grep.function
2388 color.grep.linenumber
2389 color.grep.match
2390 color.grep.selected
2391 color.grep.separator
2392 color.interactive
2393 color.interactive.error
2394 color.interactive.header
2395 color.interactive.help
2396 color.interactive.prompt
2397 color.pager
2398 color.showbranch
2399 color.status
2400 color.status.added
2401 color.status.changed
2402 color.status.header
2403 color.status.localBranch
2404 color.status.nobranch
2405 color.status.remoteBranch
2406 color.status.unmerged
2407 color.status.untracked
2408 color.status.updated
2409 color.ui
2410 commit.cleanup
2411 commit.gpgSign
2412 commit.status
2413 commit.template
2414 commit.verbose
2415 core.abbrev
2416 core.askpass
2417 core.attributesfile
2418 core.autocrlf
2419 core.bare
2420 core.bigFileThreshold
2421 core.checkStat
2422 core.commentChar
2423 core.commitGraph
2424 core.compression
2425 core.createObject
2426 core.deltaBaseCacheLimit
2427 core.editor
2428 core.eol
2429 core.excludesfile
2430 core.fileMode
2431 core.fsyncobjectfiles
2432 core.gitProxy
2433 core.hideDotFiles
2434 core.hooksPath
2435 core.ignoreStat
2436 core.ignorecase
2437 core.logAllRefUpdates
2438 core.loosecompression
2439 core.notesRef
2440 core.packedGitLimit
2441 core.packedGitWindowSize
2442 core.packedRefsTimeout
2443 core.pager
2444 core.precomposeUnicode
2445 core.preferSymlinkRefs
2446 core.preloadindex
2447 core.protectHFS
2448 core.protectNTFS
2449 core.quotepath
2450 core.repositoryFormatVersion
2451 core.safecrlf
2452 core.sharedRepository
2453 core.sparseCheckout
2454 core.splitIndex
2455 core.sshCommand
2456 core.symlinks
2457 core.trustctime
2458 core.untrackedCache
2459 core.warnAmbiguousRefs
2460 core.whitespace
2461 core.worktree
2462 credential.helper
2463 credential.useHttpPath
2464 credential.username
2465 credentialCache.ignoreSIGHUP
2466 diff.autorefreshindex
2467 diff.external
2468 diff.ignoreSubmodules
2469 diff.mnemonicprefix
2470 diff.noprefix
2471 diff.renameLimit
2472 diff.renames
2473 diff.statGraphWidth
2474 diff.submodule
2475 diff.suppressBlankEmpty
2476 diff.tool
2477 diff.wordRegex
2478 diff.algorithm
2479 difftool.
2480 difftool.prompt
2481 fetch.recurseSubmodules
2482 fetch.unpackLimit
2483 format.attach
2484 format.cc
2485 format.coverLetter
2486 format.from
2487 format.headers
2488 format.numbered
2489 format.pretty
2490 format.signature
2491 format.signoff
2492 format.subjectprefix
2493 format.suffix
2494 format.thread
2495 format.to
2496 gc.
2497 gc.aggressiveDepth
2498 gc.aggressiveWindow
2499 gc.auto
2500 gc.autoDetach
2501 gc.autopacklimit
2502 gc.logExpiry
2503 gc.packrefs
2504 gc.pruneexpire
2505 gc.reflogexpire
2506 gc.reflogexpireunreachable
2507 gc.rerereresolved
2508 gc.rerereunresolved
2509 gc.worktreePruneExpire
2510 gitcvs.allbinary
2511 gitcvs.commitmsgannotation
2512 gitcvs.dbTableNamePrefix
2513 gitcvs.dbdriver
2514 gitcvs.dbname
2515 gitcvs.dbpass
2516 gitcvs.dbuser
2517 gitcvs.enabled
2518 gitcvs.logfile
2519 gitcvs.usecrlfattr
2520 guitool.
2521 gui.blamehistoryctx
2522 gui.commitmsgwidth
2523 gui.copyblamethreshold
2524 gui.diffcontext
2525 gui.encoding
2526 gui.fastcopyblame
2527 gui.matchtrackingbranch
2528 gui.newbranchtemplate
2529 gui.pruneduringfetch
2530 gui.spellingdictionary
2531 gui.trustmtime
2532 help.autocorrect
2533 help.browser
2534 help.format
2535 http.lowSpeedLimit
2536 http.lowSpeedTime
2537 http.maxRequests
2538 http.minSessions
2539 http.noEPSV
2540 http.postBuffer
2541 http.proxy
2542 http.sslCipherList
2543 http.sslVersion
2544 http.sslCAInfo
2545 http.sslCAPath
2546 http.sslCert
2547 http.sslCertPasswordProtected
2548 http.sslKey
2549 http.sslVerify
2550 http.useragent
2551 i18n.commitEncoding
2552 i18n.logOutputEncoding
2553 imap.authMethod
2554 imap.folder
2555 imap.host
2556 imap.pass
2557 imap.port
2558 imap.preformattedHTML
2559 imap.sslverify
2560 imap.tunnel
2561 imap.user
2562 init.templatedir
2563 instaweb.browser
2564 instaweb.httpd
2565 instaweb.local
2566 instaweb.modulepath
2567 instaweb.port
2568 interactive.singlekey
2569 log.date
2570 log.decorate
2571 log.showroot
2572 mailmap.file
2573 man.
2574 man.viewer
2575 merge.
2576 merge.conflictstyle
2577 merge.log
2578 merge.renameLimit
2579 merge.renormalize
2580 merge.stat
2581 merge.tool
2582 merge.verbosity
2583 mergetool.
2584 mergetool.keepBackup
2585 mergetool.keepTemporaries
2586 mergetool.prompt
2587 notes.displayRef
2588 notes.rewrite.
2589 notes.rewrite.amend
2590 notes.rewrite.rebase
2591 notes.rewriteMode
2592 notes.rewriteRef
2593 pack.compression
2594 pack.deltaCacheLimit
2595 pack.deltaCacheSize
2596 pack.depth
2597 pack.indexVersion
2598 pack.packSizeLimit
2599 pack.threads
2600 pack.window
2601 pack.windowMemory
2602 pager.
2603 pretty.
2604 pull.octopus
2605 pull.twohead
2606 push.default
2607 push.followTags
2608 rebase.autosquash
2609 rebase.stat
2610 receive.autogc
2611 receive.denyCurrentBranch
2612 receive.denyDeleteCurrent
2613 receive.denyDeletes
2614 receive.denyNonFastForwards
2615 receive.fsckObjects
2616 receive.unpackLimit
2617 receive.updateserverinfo
2618 remote.pushdefault
2619 remotes.
2620 repack.usedeltabaseoffset
2621 rerere.autoupdate
2622 rerere.enabled
2623 sendemail.
2624 sendemail.aliasesfile
2625 sendemail.aliasfiletype
2626 sendemail.bcc
2627 sendemail.cc
2628 sendemail.cccmd
2629 sendemail.chainreplyto
2630 sendemail.confirm
2631 sendemail.envelopesender
2632 sendemail.from
2633 sendemail.identity
2634 sendemail.multiedit
2635 sendemail.signedoffbycc
2636 sendemail.smtpdomain
2637 sendemail.smtpencryption
2638 sendemail.smtppass
2639 sendemail.smtpserver
2640 sendemail.smtpserveroption
2641 sendemail.smtpserverport
2642 sendemail.smtpuser
2643 sendemail.suppresscc
2644 sendemail.suppressfrom
2645 sendemail.thread
2646 sendemail.to
2647 sendemail.tocmd
2648 sendemail.validate
2649 sendemail.smtpbatchsize
2650 sendemail.smtprelogindelay
2651 showbranch.default
2652 status.relativePaths
2653 status.showUntrackedFiles
2654 status.submodulesummary
2655 submodule.
2656 tar.umask
2657 transfer.unpackLimit
2658 url.
2659 user.email
2660 user.name
2661 user.signingkey
2662 web.browser
2663 branch. remote.
2664 "
2665}
2666_git_remote ()
2668{
2669 local subcommands="
2670 add rename remove set-head set-branches
2671 get-url set-url show prune update
2672 "
2673 local subcommand="$(__git_find_on_cmdline "$subcommands")"
2674 if [ -z "$subcommand" ]; then
2675 case "$cur" in
2676 --*)
2677 __gitcomp "--verbose"
2678 ;;
2679 *)
2680 __gitcomp "$subcommands"
2681 ;;
2682 esac
2683 return
2684 fi
2685 case "$subcommand,$cur" in
2687 add,--*)
2688 __gitcomp "--track --master --fetch --tags --no-tags --mirror="
2689 ;;
2690 add,*)
2691 ;;
2692 set-head,--*)
2693 __gitcomp "--auto --delete"
2694 ;;
2695 set-branches,--*)
2696 __gitcomp "--add"
2697 ;;
2698 set-head,*|set-branches,*)
2699 __git_complete_remote_or_refspec
2700 ;;
2701 update,--*)
2702 __gitcomp "--prune"
2703 ;;
2704 update,*)
2705 __gitcomp "$(__git_get_config_variables "remotes")"
2706 ;;
2707 set-url,--*)
2708 __gitcomp "--push --add --delete"
2709 ;;
2710 get-url,--*)
2711 __gitcomp "--push --all"
2712 ;;
2713 prune,--*)
2714 __gitcomp "--dry-run"
2715 ;;
2716 *)
2717 __gitcomp_nl "$(__git_remotes)"
2718 ;;
2719 esac
2720}
2721_git_replace ()
2723{
2724 case "$cur" in
2725 --*)
2726 __gitcomp "--edit --graft --format= --list --delete"
2727 return
2728 ;;
2729 esac
2730 __git_complete_refs
2731}
2732_git_rerere ()
2734{
2735 local subcommands="clear forget diff remaining status gc"
2736 local subcommand="$(__git_find_on_cmdline "$subcommands")"
2737 if test -z "$subcommand"
2738 then
2739 __gitcomp "$subcommands"
2740 return
2741 fi
2742}
2743_git_reset ()
2745{
2746 __git_has_doubledash && return
2747 case "$cur" in
2749 --*)
2750 __gitcomp "--merge --mixed --hard --soft --patch --keep"
2751 return
2752 ;;
2753 esac
2754 __git_complete_refs
2755}
2756_git_revert ()
2758{
2759 __git_find_repo_path
2760 if [ -f "$__git_repo_path"/REVERT_HEAD ]; then
2761 __gitcomp "--continue --quit --abort"
2762 return
2763 fi
2764 case "$cur" in
2765 --*)
2766 __gitcomp "
2767 --edit --mainline --no-edit --no-commit --signoff
2768 --strategy= --strategy-option=
2769 "
2770 return
2771 ;;
2772 esac
2773 __git_complete_refs
2774}
2775_git_rm ()
2777{
2778 case "$cur" in
2779 --*)
2780 __gitcomp "--cached --dry-run --ignore-unmatch --quiet"
2781 return
2782 ;;
2783 esac
2784 __git_complete_index_file "--cached"
2786}
2787_git_shortlog ()
2789{
2790 __git_has_doubledash && return
2791 case "$cur" in
2793 --*)
2794 __gitcomp "
2795 $__git_log_common_options
2796 $__git_log_shortlog_options
2797 --numbered --summary --email
2798 "
2799 return
2800 ;;
2801 esac
2802 __git_complete_revlist
2803}
2804_git_show ()
2806{
2807 __git_has_doubledash && return
2808 case "$cur" in
2810 --pretty=*|--format=*)
2811 __gitcomp "$__git_log_pretty_formats $(__git_pretty_aliases)
2812 " "" "${cur#*=}"
2813 return
2814 ;;
2815 --diff-algorithm=*)
2816 __gitcomp "$__git_diff_algorithms" "" "${cur##--diff-algorithm=}"
2817 return
2818 ;;
2819 --submodule=*)
2820 __gitcomp "$__git_diff_submodule_formats" "" "${cur##--submodule=}"
2821 return
2822 ;;
2823 --*)
2824 __gitcomp "--pretty= --format= --abbrev-commit --oneline
2825 --show-signature
2826 $__git_diff_common_options
2827 "
2828 return
2829 ;;
2830 esac
2831 __git_complete_revlist_file
2832}
2833_git_show_branch ()
2835{
2836 case "$cur" in
2837 --*)
2838 __gitcomp "
2839 --all --remotes --topo-order --date-order --current --more=
2840 --list --independent --merge-base --no-name
2841 --color --no-color
2842 --sha1-name --sparse --topics --reflog
2843 "
2844 return
2845 ;;
2846 esac
2847 __git_complete_revlist
2848}
2849_git_stash ()
2851{
2852 local save_opts='--all --keep-index --no-keep-index --quiet --patch --include-untracked'
2853 local subcommands='push save list show apply clear drop pop create branch'
2854 local subcommand="$(__git_find_on_cmdline "$subcommands")"
2855 if [ -z "$subcommand" ]; then
2856 case "$cur" in
2857 --*)
2858 __gitcomp "$save_opts"
2859 ;;
2860 *)
2861 if [ -z "$(__git_find_on_cmdline "$save_opts")" ]; then
2862 __gitcomp "$subcommands"
2863 fi
2864 ;;
2865 esac
2866 else
2867 case "$subcommand,$cur" in
2868 push,--*)
2869 __gitcomp "$save_opts --message"
2870 ;;
2871 save,--*)
2872 __gitcomp "$save_opts"
2873 ;;
2874 apply,--*|pop,--*)
2875 __gitcomp "--index --quiet"
2876 ;;
2877 drop,--*)
2878 __gitcomp "--quiet"
2879 ;;
2880 show,--*|branch,--*)
2881 ;;
2882 branch,*)
2883 if [ $cword -eq 3 ]; then
2884 __git_complete_refs
2885 else
2886 __gitcomp_nl "$(__git stash list \
2887 | sed -n -e 's/:.*//p')"
2888 fi
2889 ;;
2890 show,*|apply,*|drop,*|pop,*)
2891 __gitcomp_nl "$(__git stash list \
2892 | sed -n -e 's/:.*//p')"
2893 ;;
2894 *)
2895 ;;
2896 esac
2897 fi
2898}
2899_git_submodule ()
2901{
2902 __git_has_doubledash && return
2903 local subcommands="add status init deinit update summary foreach sync"
2905 local subcommand="$(__git_find_on_cmdline "$subcommands")"
2906 if [ -z "$subcommand" ]; then
2907 case "$cur" in
2908 --*)
2909 __gitcomp "--quiet"
2910 ;;
2911 *)
2912 __gitcomp "$subcommands"
2913 ;;
2914 esac
2915 return
2916 fi
2917 case "$subcommand,$cur" in
2919 add,--*)
2920 __gitcomp "--branch --force --name --reference --depth"
2921 ;;
2922 status,--*)
2923 __gitcomp "--cached --recursive"
2924 ;;
2925 deinit,--*)
2926 __gitcomp "--force --all"
2927 ;;
2928 update,--*)
2929 __gitcomp "
2930 --init --remote --no-fetch
2931 --recommend-shallow --no-recommend-shallow
2932 --force --rebase --merge --reference --depth --recursive --jobs
2933 "
2934 ;;
2935 summary,--*)
2936 __gitcomp "--cached --files --summary-limit"
2937 ;;
2938 foreach,--*|sync,--*)
2939 __gitcomp "--recursive"
2940 ;;
2941 *)
2942 ;;
2943 esac
2944}
2945_git_svn ()
2947{
2948 local subcommands="
2949 init fetch clone rebase dcommit log find-rev
2950 set-tree commit-diff info create-ignore propget
2951 proplist show-ignore show-externals branch tag blame
2952 migrate mkdirs reset gc
2953 "
2954 local subcommand="$(__git_find_on_cmdline "$subcommands")"
2955 if [ -z "$subcommand" ]; then
2956 __gitcomp "$subcommands"
2957 else
2958 local remote_opts="--username= --config-dir= --no-auth-cache"
2959 local fc_opts="
2960 --follow-parent --authors-file= --repack=
2961 --no-metadata --use-svm-props --use-svnsync-props
2962 --log-window-size= --no-checkout --quiet
2963 --repack-flags --use-log-author --localtime
2964 --add-author-from
2965 --ignore-paths= --include-paths= $remote_opts
2966 "
2967 local init_opts="
2968 --template= --shared= --trunk= --tags=
2969 --branches= --stdlayout --minimize-url
2970 --no-metadata --use-svm-props --use-svnsync-props
2971 --rewrite-root= --prefix= $remote_opts
2972 "
2973 local cmt_opts="
2974 --edit --rmdir --find-copies-harder --copy-similarity=
2975 "
2976 case "$subcommand,$cur" in
2978 fetch,--*)
2979 __gitcomp "--revision= --fetch-all $fc_opts"
2980 ;;
2981 clone,--*)
2982 __gitcomp "--revision= $fc_opts $init_opts"
2983 ;;
2984 init,--*)
2985 __gitcomp "$init_opts"
2986 ;;
2987 dcommit,--*)
2988 __gitcomp "
2989 --merge --strategy= --verbose --dry-run
2990 --fetch-all --no-rebase --commit-url
2991 --revision --interactive $cmt_opts $fc_opts
2992 "
2993 ;;
2994 set-tree,--*)
2995 __gitcomp "--stdin $cmt_opts $fc_opts"
2996 ;;
2997 create-ignore,--*|propget,--*|proplist,--*|show-ignore,--*|\
2998 show-externals,--*|mkdirs,--*)
2999 __gitcomp "--revision="
3000 ;;
3001 log,--*)
3002 __gitcomp "
3003 --limit= --revision= --verbose --incremental
3004 --oneline --show-commit --non-recursive
3005 --authors-file= --color
3006 "
3007 ;;
3008 rebase,--*)
3009 __gitcomp "
3010 --merge --verbose --strategy= --local
3011 --fetch-all --dry-run $fc_opts
3012 "
3013 ;;
3014 commit-diff,--*)
3015 __gitcomp "--message= --file= --revision= $cmt_opts"
3016 ;;
3017 info,--*)
3018 __gitcomp "--url"
3019 ;;
3020 branch,--*)
3021 __gitcomp "--dry-run --message --tag"
3022 ;;
3023 tag,--*)
3024 __gitcomp "--dry-run --message"
3025 ;;
3026 blame,--*)
3027 __gitcomp "--git-format"
3028 ;;
3029 migrate,--*)
3030 __gitcomp "
3031 --config-dir= --ignore-paths= --minimize
3032 --no-auth-cache --username=
3033 "
3034 ;;
3035 reset,--*)
3036 __gitcomp "--revision= --parent"
3037 ;;
3038 *)
3039 ;;
3040 esac
3041 fi
3042}
3043_git_tag ()
3045{
3046 local i c=1 f=0
3047 while [ $c -lt $cword ]; do
3048 i="${words[c]}"
3049 case "$i" in
3050 -d|-v)
3051 __gitcomp_direct "$(__git_tags "" "$cur" " ")"
3052 return
3053 ;;
3054 -f)
3055 f=1
3056 ;;
3057 esac
3058 ((c++))
3059 done
3060 case "$prev" in
3062 -m|-F)
3063 ;;
3064 -*|tag)
3065 if [ $f = 1 ]; then
3066 __gitcomp_direct "$(__git_tags "" "$cur" " ")"
3067 fi
3068 ;;
3069 *)
3070 __git_complete_refs
3071 ;;
3072 esac
3073 case "$cur" in
3075 --*)
3076 __gitcomp "
3077 --list --delete --verify --annotate --message --file
3078 --sign --cleanup --local-user --force --column --sort=
3079 --contains --no-contains --points-at --merged --no-merged --create-reflog
3080 "
3081 ;;
3082 esac
3083}
3084_git_whatchanged ()
3086{
3087 _git_log
3088}
3089_git_worktree ()
3091{
3092 local subcommands="add list lock prune unlock"
3093 local subcommand="$(__git_find_on_cmdline "$subcommands")"
3094 if [ -z "$subcommand" ]; then
3095 __gitcomp "$subcommands"
3096 else
3097 case "$subcommand,$cur" in
3098 add,--*)
3099 __gitcomp "--detach"
3100 ;;
3101 list,--*)
3102 __gitcomp "--porcelain"
3103 ;;
3104 lock,--*)
3105 __gitcomp "--reason"
3106 ;;
3107 prune,--*)
3108 __gitcomp "--dry-run --expire --verbose"
3109 ;;
3110 *)
3111 ;;
3112 esac
3113 fi
3114}
3115__git_main ()
3117{
3118 local i c=1 command __git_dir __git_repo_path
3119 local __git_C_args C_args_count=0
3120 while [ $c -lt $cword ]; do
3122 i="${words[c]}"
3123 case "$i" in
3124 --git-dir=*) __git_dir="${i#--git-dir=}" ;;
3125 --git-dir) ((c++)) ; __git_dir="${words[c]}" ;;
3126 --bare) __git_dir="." ;;
3127 --help) command="help"; break ;;
3128 -c|--work-tree|--namespace) ((c++)) ;;
3129 -C) __git_C_args[C_args_count++]=-C
3130 ((c++))
3131 __git_C_args[C_args_count++]="${words[c]}"
3132 ;;
3133 -*) ;;
3134 *) command="$i"; break ;;
3135 esac
3136 ((c++))
3137 done
3138 if [ -z "$command" ]; then
3140 case "$prev" in
3141 --git-dir|-C|--work-tree)
3142 # these need a path argument, let's fall back to
3143 # Bash filename completion
3144 return
3145 ;;
3146 -c|--namespace)
3147 # we don't support completing these options' arguments
3148 return
3149 ;;
3150 esac
3151 case "$cur" in
3152 --*) __gitcomp "
3153 --paginate
3154 --no-pager
3155 --git-dir=
3156 --bare
3157 --version
3158 --exec-path
3159 --exec-path=
3160 --html-path
3161 --man-path
3162 --info-path
3163 --work-tree=
3164 --namespace=
3165 --no-replace-objects
3166 --help
3167 "
3168 ;;
3169 *) __git_compute_porcelain_commands
3170 __gitcomp "$__git_porcelain_commands $(__git_aliases)" ;;
3171 esac
3172 return
3173 fi
3174 local completion_func="_git_${command//-/_}"
3176 declare -f $completion_func >/dev/null 2>/dev/null && $completion_func && return
3177 local expansion=$(__git_aliased_command "$command")
3179 if [ -n "$expansion" ]; then
3180 words[1]=$expansion
3181 completion_func="_git_${expansion//-/_}"
3182 declare -f $completion_func >/dev/null 2>/dev/null && $completion_func
3183 fi
3184}
3185__gitk_main ()
3187{
3188 __git_has_doubledash && return
3189 local __git_repo_path
3191 __git_find_repo_path
3192 local merge=""
3194 if [ -f "$__git_repo_path/MERGE_HEAD" ]; then
3195 merge="--merge"
3196 fi
3197 case "$cur" in
3198 --*)
3199 __gitcomp "
3200 $__git_log_common_options
3201 $__git_log_gitk_options
3202 $merge
3203 "
3204 return
3205 ;;
3206 esac
3207 __git_complete_revlist
3208}
3209if [[ -n ${ZSH_VERSION-} ]]; then
3211 echo "WARNING: this script is deprecated, please see git-completion.zsh" 1>&2
3212 autoload -U +X compinit && compinit
3214 __gitcomp ()
3216 {
3217 emulate -L zsh
3218 local cur_="${3-$cur}"
3220 case "$cur_" in
3222 --*=)
3223 ;;
3224 *)
3225 local c IFS=$' \t\n'
3226 local -a array
3227 for c in ${=1}; do
3228 c="$c${4-}"
3229 case $c in
3230 --*=*|*.) ;;
3231 *) c="$c " ;;
3232 esac
3233 array[${#array[@]}+1]="$c"
3234 done
3235 compset -P '*[=:]'
3236 compadd -Q -S '' -p "${2-}" -a -- array && _ret=0
3237 ;;
3238 esac
3239 }
3240 __gitcomp_direct ()
3242 {
3243 emulate -L zsh
3244 local IFS=$'\n'
3246 compset -P '*[=:]'
3247 compadd -Q -- ${=1} && _ret=0
3248 }
3249 __gitcomp_nl ()
3251 {
3252 emulate -L zsh
3253 local IFS=$'\n'
3255 compset -P '*[=:]'
3256 compadd -Q -S "${4- }" -p "${2-}" -- ${=1} && _ret=0
3257 }
3258 __gitcomp_file ()
3260 {
3261 emulate -L zsh
3262 local IFS=$'\n'
3264 compset -P '*[=:]'
3265 compadd -Q -p "${2-}" -f -- ${=1} && _ret=0
3266 }
3267 _git ()
3269 {
3270 local _ret=1 cur cword prev
3271 cur=${words[CURRENT]}
3272 prev=${words[CURRENT-1]}
3273 let cword=CURRENT-1
3274 emulate ksh -c __${service}_main
3275 let _ret && _default && _ret=0
3276 return _ret
3277 }
3278 compdef _git git gitk
3280 return
3281fi
3282__git_func_wrap ()
3284{
3285 local cur words cword prev
3286 _get_comp_words_by_ref -n =: cur words cword prev
3287 $1
3288}
3289# Setup completion for certain functions defined above by setting common
3291# variables and workarounds.
3292# This is NOT a public function; use at your own risk.
3293__git_complete ()
3294{
3295 local wrapper="__git_wrap${2}"
3296 eval "$wrapper () { __git_func_wrap $2 ; }"
3297 complete -o bashdefault -o default -o nospace -F $wrapper $1 2>/dev/null \
3298 || complete -o default -o nospace -F $wrapper $1
3299}
3300# wrapper for backwards compatibility
3302_git ()
3303{
3304 __git_wrap__git_main
3305}
3306# wrapper for backwards compatibility
3308_gitk ()
3309{
3310 __git_wrap__gitk_main
3311}
3312__git_complete git __git_main
3314__git_complete gitk __gitk_main
3315# The following are necessary only for Cygwin, and only are needed
3317# when the user has tab-completed the executable name and consequently
3318# included the '.exe' suffix.
3319#
3320if [ Cygwin = "$(uname -o 2>/dev/null)" ]; then
3321__git_complete git.exe __git_main
3322fi