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