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