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