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