b192a5c0a13c3a05c24455ef9c7d51032df3090a
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 "--dry-run"
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 "--tags --all --stdin"
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 '--ref'
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,--*|append,--*)
1855 __gitcomp '--file= --message= --reedit-message=
1856 --reuse-message='
1857 ;;
1858 copy,--*)
1859 __gitcomp '--stdin'
1860 ;;
1861 prune,--*)
1862 __gitcomp '--dry-run --verbose'
1863 ;;
1864 prune,*)
1865 ;;
1866 *)
1867 case "$prev" in
1868 -m|-F)
1869 ;;
1870 *)
1871 __git_complete_refs
1872 ;;
1873 esac
1874 ;;
1875 esac
1876}
1877_git_pull ()
1879{
1880 __git_complete_strategy && return
1881 case "$cur" in
1883 --recurse-submodules=*)
1884 __gitcomp "$__git_fetch_recurse_submodules" "" "${cur##--recurse-submodules=}"
1885 return
1886 ;;
1887 --*)
1888 __gitcomp "
1889 --rebase --no-rebase
1890 --autostash --no-autostash
1891 $__git_merge_options
1892 $__git_fetch_options
1893 "
1894 return
1895 ;;
1896 esac
1897 __git_complete_remote_or_refspec
1898}
1899__git_push_recurse_submodules="check on-demand only"
1901__git_complete_force_with_lease ()
1903{
1904 local cur_=$1
1905 case "$cur_" in
1907 --*=)
1908 ;;
1909 *:*)
1910 __git_complete_refs --cur="${cur_#*:}"
1911 ;;
1912 *)
1913 __git_complete_refs --cur="$cur_"
1914 ;;
1915 esac
1916}
1917_git_push ()
1919{
1920 case "$prev" in
1921 --repo)
1922 __gitcomp_nl "$(__git_remotes)"
1923 return
1924 ;;
1925 --recurse-submodules)
1926 __gitcomp "$__git_push_recurse_submodules"
1927 return
1928 ;;
1929 esac
1930 case "$cur" in
1931 --repo=*)
1932 __gitcomp_nl "$(__git_remotes)" "" "${cur##--repo=}"
1933 return
1934 ;;
1935 --recurse-submodules=*)
1936 __gitcomp "$__git_push_recurse_submodules" "" "${cur##--recurse-submodules=}"
1937 return
1938 ;;
1939 --force-with-lease=*)
1940 __git_complete_force_with_lease "${cur##--force-with-lease=}"
1941 return
1942 ;;
1943 --*)
1944 __gitcomp "
1945 --all --mirror --tags --dry-run --force --verbose
1946 --quiet --prune --delete --follow-tags
1947 --receive-pack= --repo= --set-upstream
1948 --force-with-lease --force-with-lease= --recurse-submodules=
1949 "
1950 return
1951 ;;
1952 esac
1953 __git_complete_remote_or_refspec
1954}
1955_git_rebase ()
1957{
1958 __git_find_repo_path
1959 if [ -f "$__git_repo_path"/rebase-merge/interactive ]; then
1960 __gitcomp "--continue --skip --abort --quit --edit-todo"
1961 return
1962 elif [ -d "$__git_repo_path"/rebase-apply ] || \
1963 [ -d "$__git_repo_path"/rebase-merge ]; then
1964 __gitcomp "--continue --skip --abort --quit"
1965 return
1966 fi
1967 __git_complete_strategy && return
1968 case "$cur" in
1969 --whitespace=*)
1970 __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
1971 return
1972 ;;
1973 --*)
1974 __gitcomp "
1975 --onto --merge --strategy --interactive
1976 --preserve-merges --stat --no-stat
1977 --committer-date-is-author-date --ignore-date
1978 --ignore-whitespace --whitespace=
1979 --autosquash --no-autosquash
1980 --fork-point --no-fork-point
1981 --autostash --no-autostash
1982 --verify --no-verify
1983 --keep-empty --root --force-rebase --no-ff
1984 --exec
1985 "
1986 return
1988 esac
1989 __git_complete_refs
1990}
1991_git_reflog ()
1993{
1994 local subcommands="show delete expire"
1995 local subcommand="$(__git_find_on_cmdline "$subcommands")"
1996 if [ -z "$subcommand" ]; then
1998 __gitcomp "$subcommands"
1999 else
2000 __git_complete_refs
2001 fi
2002}
2003__git_send_email_confirm_options="always never auto cc compose"
2005__git_send_email_suppresscc_options="author self cc bodycc sob cccmd body all"
2006_git_send_email ()
2008{
2009 case "$prev" in
2010 --to|--cc|--bcc|--from)
2011 __gitcomp "$(__git send-email --dump-aliases)"
2012 return
2013 ;;
2014 esac
2015 case "$cur" in
2017 --confirm=*)
2018 __gitcomp "
2019 $__git_send_email_confirm_options
2020 " "" "${cur##--confirm=}"
2021 return
2022 ;;
2023 --suppress-cc=*)
2024 __gitcomp "
2025 $__git_send_email_suppresscc_options
2026 " "" "${cur##--suppress-cc=}"
2027 return
2029 ;;
2030 --smtp-encryption=*)
2031 __gitcomp "ssl tls" "" "${cur##--smtp-encryption=}"
2032 return
2033 ;;
2034 --thread=*)
2035 __gitcomp "
2036 deep shallow
2037 " "" "${cur##--thread=}"
2038 return
2039 ;;
2040 --to=*|--cc=*|--bcc=*|--from=*)
2041 __gitcomp "$(__git send-email --dump-aliases)" "" "${cur#--*=}"
2042 return
2043 ;;
2044 --*)
2045 __gitcomp "--annotate --bcc --cc --cc-cmd --chain-reply-to
2046 --compose --confirm= --dry-run --envelope-sender
2047 --from --identity
2048 --in-reply-to --no-chain-reply-to --no-signed-off-by-cc
2049 --no-suppress-from --no-thread --quiet
2050 --signed-off-by-cc --smtp-pass --smtp-server
2051 --smtp-server-port --smtp-encryption= --smtp-user
2052 --subject --suppress-cc= --suppress-from --thread --to
2053 --validate --no-validate
2054 $__git_format_patch_options"
2055 return
2056 ;;
2057 esac
2058 __git_complete_revlist
2059}
2060_git_stage ()
2062{
2063 _git_add
2064}
2065_git_status ()
2067{
2068 local complete_opt
2069 local untracked_state
2070 case "$cur" in
2072 --ignore-submodules=*)
2073 __gitcomp "none untracked dirty all" "" "${cur##--ignore-submodules=}"
2074 return
2075 ;;
2076 --untracked-files=*)
2077 __gitcomp "$__git_untracked_file_modes" "" "${cur##--untracked-files=}"
2078 return
2079 ;;
2080 --column=*)
2081 __gitcomp "
2082 always never auto column row plain dense nodense
2083 " "" "${cur##--column=}"
2084 return
2085 ;;
2086 --*)
2087 __gitcomp "
2088 --short --branch --porcelain --long --verbose
2089 --untracked-files= --ignore-submodules= --ignored
2090 --column= --no-column
2091 "
2092 return
2093 ;;
2094 esac
2095 untracked_state="$(__git_get_option_value "-u" "--untracked-files=" \
2097 "$__git_untracked_file_modes" "status.showUntrackedFiles")"
2098 case "$untracked_state" in
2100 no)
2101 # --ignored option does not matter
2102 complete_opt=
2103 ;;
2104 all|normal|*)
2105 complete_opt="--cached --directory --no-empty-directory --others"
2106 if [ -n "$(__git_find_on_cmdline "--ignored")" ]; then
2108 complete_opt="$complete_opt --ignored --exclude=*"
2109 fi
2110 ;;
2111 esac
2112 __git_complete_index_file "$complete_opt"
2114}
2115__git_config_get_set_variables ()
2117{
2118 local prevword word config_file= c=$cword
2119 while [ $c -gt 1 ]; do
2120 word="${words[c]}"
2121 case "$word" in
2122 --system|--global|--local|--file=*)
2123 config_file="$word"
2124 break
2125 ;;
2126 -f|--file)
2127 config_file="$word $prevword"
2128 break
2129 ;;
2130 esac
2131 prevword=$word
2132 c=$((--c))
2133 done
2134 __git config $config_file --name-only --list
2136}
2137_git_config ()
2139{
2140 case "$prev" in
2141 branch.*.remote|branch.*.pushremote)
2142 __gitcomp_nl "$(__git_remotes)"
2143 return
2144 ;;
2145 branch.*.merge)
2146 __git_complete_refs
2147 return
2148 ;;
2149 branch.*.rebase)
2150 __gitcomp "false true preserve interactive"
2151 return
2152 ;;
2153 remote.pushdefault)
2154 __gitcomp_nl "$(__git_remotes)"
2155 return
2156 ;;
2157 remote.*.fetch)
2158 local remote="${prev#remote.}"
2159 remote="${remote%.fetch}"
2160 if [ -z "$cur" ]; then
2161 __gitcomp_nl "refs/heads/" "" "" ""
2162 return
2163 fi
2164 __gitcomp_nl "$(__git_refs_remotes "$remote")"
2165 return
2166 ;;
2167 remote.*.push)
2168 local remote="${prev#remote.}"
2169 remote="${remote%.push}"
2170 __gitcomp_nl "$(__git for-each-ref \
2171 --format='%(refname):%(refname)' refs/heads)"
2172 return
2173 ;;
2174 pull.twohead|pull.octopus)
2175 __git_compute_merge_strategies
2176 __gitcomp "$__git_merge_strategies"
2177 return
2178 ;;
2179 color.branch|color.diff|color.interactive|\
2180 color.showbranch|color.status|color.ui)
2181 __gitcomp "always never auto"
2182 return
2183 ;;
2184 color.pager)
2185 __gitcomp "false true"
2186 return
2187 ;;
2188 color.*.*)
2189 __gitcomp "
2190 normal black red green yellow blue magenta cyan white
2191 bold dim ul blink reverse
2192 "
2193 return
2194 ;;
2195 diff.submodule)
2196 __gitcomp "log short"
2197 return
2198 ;;
2199 help.format)
2200 __gitcomp "man info web html"
2201 return
2202 ;;
2203 log.date)
2204 __gitcomp "$__git_log_date_formats"
2205 return
2206 ;;
2207 sendemail.aliasesfiletype)
2208 __gitcomp "mutt mailrc pine elm gnus"
2209 return
2210 ;;
2211 sendemail.confirm)
2212 __gitcomp "$__git_send_email_confirm_options"
2213 return
2214 ;;
2215 sendemail.suppresscc)
2216 __gitcomp "$__git_send_email_suppresscc_options"
2217 return
2218 ;;
2219 sendemail.transferencoding)
2220 __gitcomp "7bit 8bit quoted-printable base64"
2221 return
2222 ;;
2223 --get|--get-all|--unset|--unset-all)
2224 __gitcomp_nl "$(__git_config_get_set_variables)"
2225 return
2226 ;;
2227 *.*)
2228 return
2229 ;;
2230 esac
2231 case "$cur" in
2232 --*)
2233 __gitcomp_builtin config
2234 return
2235 ;;
2236 branch.*.*)
2237 local pfx="${cur%.*}." cur_="${cur##*.}"
2238 __gitcomp "remote pushremote merge mergeoptions rebase" "$pfx" "$cur_"
2239 return
2240 ;;
2241 branch.*)
2242 local pfx="${cur%.*}." cur_="${cur#*.}"
2243 __gitcomp_direct "$(__git_heads "$pfx" "$cur_" ".")"
2244 __gitcomp_nl_append $'autosetupmerge\nautosetuprebase\n' "$pfx" "$cur_"
2245 return
2246 ;;
2247 guitool.*.*)
2248 local pfx="${cur%.*}." cur_="${cur##*.}"
2249 __gitcomp "
2250 argprompt cmd confirm needsfile noconsole norescan
2251 prompt revprompt revunmerged title
2252 " "$pfx" "$cur_"
2253 return
2254 ;;
2255 difftool.*.*)
2256 local pfx="${cur%.*}." cur_="${cur##*.}"
2257 __gitcomp "cmd path" "$pfx" "$cur_"
2258 return
2259 ;;
2260 man.*.*)
2261 local pfx="${cur%.*}." cur_="${cur##*.}"
2262 __gitcomp "cmd path" "$pfx" "$cur_"
2263 return
2264 ;;
2265 mergetool.*.*)
2266 local pfx="${cur%.*}." cur_="${cur##*.}"
2267 __gitcomp "cmd path trustExitCode" "$pfx" "$cur_"
2268 return
2269 ;;
2270 pager.*)
2271 local pfx="${cur%.*}." cur_="${cur#*.}"
2272 __git_compute_all_commands
2273 __gitcomp_nl "$__git_all_commands" "$pfx" "$cur_"
2274 return
2275 ;;
2276 remote.*.*)
2277 local pfx="${cur%.*}." cur_="${cur##*.}"
2278 __gitcomp "
2279 url proxy fetch push mirror skipDefaultUpdate
2280 receivepack uploadpack tagopt pushurl
2281 " "$pfx" "$cur_"
2282 return
2283 ;;
2284 remote.*)
2285 local pfx="${cur%.*}." cur_="${cur#*.}"
2286 __gitcomp_nl "$(__git_remotes)" "$pfx" "$cur_" "."
2287 __gitcomp_nl_append "pushdefault" "$pfx" "$cur_"
2288 return
2289 ;;
2290 url.*.*)
2291 local pfx="${cur%.*}." cur_="${cur##*.}"
2292 __gitcomp "insteadOf pushInsteadOf" "$pfx" "$cur_"
2293 return
2294 ;;
2295 esac
2296 __gitcomp "
2297 add.ignoreErrors
2298 advice.amWorkDir
2299 advice.commitBeforeMerge
2300 advice.detachedHead
2301 advice.implicitIdentity
2302 advice.pushAlreadyExists
2303 advice.pushFetchFirst
2304 advice.pushNeedsForce
2305 advice.pushNonFFCurrent
2306 advice.pushNonFFMatching
2307 advice.pushUpdateRejected
2308 advice.resolveConflict
2309 advice.rmHints
2310 advice.statusHints
2311 advice.statusUoption
2312 advice.ignoredHook
2313 alias.
2314 am.keepcr
2315 am.threeWay
2316 apply.ignorewhitespace
2317 apply.whitespace
2318 branch.autosetupmerge
2319 branch.autosetuprebase
2320 browser.
2321 clean.requireForce
2322 color.branch
2323 color.branch.current
2324 color.branch.local
2325 color.branch.plain
2326 color.branch.remote
2327 color.decorate.HEAD
2328 color.decorate.branch
2329 color.decorate.remoteBranch
2330 color.decorate.stash
2331 color.decorate.tag
2332 color.diff
2333 color.diff.commit
2334 color.diff.frag
2335 color.diff.func
2336 color.diff.meta
2337 color.diff.new
2338 color.diff.old
2339 color.diff.plain
2340 color.diff.whitespace
2341 color.grep
2342 color.grep.context
2343 color.grep.filename
2344 color.grep.function
2345 color.grep.linenumber
2346 color.grep.match
2347 color.grep.selected
2348 color.grep.separator
2349 color.interactive
2350 color.interactive.error
2351 color.interactive.header
2352 color.interactive.help
2353 color.interactive.prompt
2354 color.pager
2355 color.showbranch
2356 color.status
2357 color.status.added
2358 color.status.changed
2359 color.status.header
2360 color.status.localBranch
2361 color.status.nobranch
2362 color.status.remoteBranch
2363 color.status.unmerged
2364 color.status.untracked
2365 color.status.updated
2366 color.ui
2367 commit.cleanup
2368 commit.gpgSign
2369 commit.status
2370 commit.template
2371 commit.verbose
2372 core.abbrev
2373 core.askpass
2374 core.attributesfile
2375 core.autocrlf
2376 core.bare
2377 core.bigFileThreshold
2378 core.checkStat
2379 core.commentChar
2380 core.compression
2381 core.createObject
2382 core.deltaBaseCacheLimit
2383 core.editor
2384 core.eol
2385 core.excludesfile
2386 core.fileMode
2387 core.fsyncobjectfiles
2388 core.gitProxy
2389 core.hideDotFiles
2390 core.hooksPath
2391 core.ignoreStat
2392 core.ignorecase
2393 core.logAllRefUpdates
2394 core.loosecompression
2395 core.notesRef
2396 core.packedGitLimit
2397 core.packedGitWindowSize
2398 core.packedRefsTimeout
2399 core.pager
2400 core.precomposeUnicode
2401 core.preferSymlinkRefs
2402 core.preloadindex
2403 core.protectHFS
2404 core.protectNTFS
2405 core.quotepath
2406 core.repositoryFormatVersion
2407 core.safecrlf
2408 core.sharedRepository
2409 core.sparseCheckout
2410 core.splitIndex
2411 core.sshCommand
2412 core.symlinks
2413 core.trustctime
2414 core.untrackedCache
2415 core.warnAmbiguousRefs
2416 core.whitespace
2417 core.worktree
2418 credential.helper
2419 credential.useHttpPath
2420 credential.username
2421 credentialCache.ignoreSIGHUP
2422 diff.autorefreshindex
2423 diff.external
2424 diff.ignoreSubmodules
2425 diff.mnemonicprefix
2426 diff.noprefix
2427 diff.renameLimit
2428 diff.renames
2429 diff.statGraphWidth
2430 diff.submodule
2431 diff.suppressBlankEmpty
2432 diff.tool
2433 diff.wordRegex
2434 diff.algorithm
2435 difftool.
2436 difftool.prompt
2437 fetch.recurseSubmodules
2438 fetch.unpackLimit
2439 format.attach
2440 format.cc
2441 format.coverLetter
2442 format.from
2443 format.headers
2444 format.numbered
2445 format.pretty
2446 format.signature
2447 format.signoff
2448 format.subjectprefix
2449 format.suffix
2450 format.thread
2451 format.to
2452 gc.
2453 gc.aggressiveDepth
2454 gc.aggressiveWindow
2455 gc.auto
2456 gc.autoDetach
2457 gc.autopacklimit
2458 gc.logExpiry
2459 gc.packrefs
2460 gc.pruneexpire
2461 gc.reflogexpire
2462 gc.reflogexpireunreachable
2463 gc.rerereresolved
2464 gc.rerereunresolved
2465 gc.worktreePruneExpire
2466 gitcvs.allbinary
2467 gitcvs.commitmsgannotation
2468 gitcvs.dbTableNamePrefix
2469 gitcvs.dbdriver
2470 gitcvs.dbname
2471 gitcvs.dbpass
2472 gitcvs.dbuser
2473 gitcvs.enabled
2474 gitcvs.logfile
2475 gitcvs.usecrlfattr
2476 guitool.
2477 gui.blamehistoryctx
2478 gui.commitmsgwidth
2479 gui.copyblamethreshold
2480 gui.diffcontext
2481 gui.encoding
2482 gui.fastcopyblame
2483 gui.matchtrackingbranch
2484 gui.newbranchtemplate
2485 gui.pruneduringfetch
2486 gui.spellingdictionary
2487 gui.trustmtime
2488 help.autocorrect
2489 help.browser
2490 help.format
2491 http.lowSpeedLimit
2492 http.lowSpeedTime
2493 http.maxRequests
2494 http.minSessions
2495 http.noEPSV
2496 http.postBuffer
2497 http.proxy
2498 http.sslCipherList
2499 http.sslVersion
2500 http.sslCAInfo
2501 http.sslCAPath
2502 http.sslCert
2503 http.sslCertPasswordProtected
2504 http.sslKey
2505 http.sslVerify
2506 http.useragent
2507 i18n.commitEncoding
2508 i18n.logOutputEncoding
2509 imap.authMethod
2510 imap.folder
2511 imap.host
2512 imap.pass
2513 imap.port
2514 imap.preformattedHTML
2515 imap.sslverify
2516 imap.tunnel
2517 imap.user
2518 init.templatedir
2519 instaweb.browser
2520 instaweb.httpd
2521 instaweb.local
2522 instaweb.modulepath
2523 instaweb.port
2524 interactive.singlekey
2525 log.date
2526 log.decorate
2527 log.showroot
2528 mailmap.file
2529 man.
2530 man.viewer
2531 merge.
2532 merge.conflictstyle
2533 merge.log
2534 merge.renameLimit
2535 merge.renormalize
2536 merge.stat
2537 merge.tool
2538 merge.verbosity
2539 mergetool.
2540 mergetool.keepBackup
2541 mergetool.keepTemporaries
2542 mergetool.prompt
2543 notes.displayRef
2544 notes.rewrite.
2545 notes.rewrite.amend
2546 notes.rewrite.rebase
2547 notes.rewriteMode
2548 notes.rewriteRef
2549 pack.compression
2550 pack.deltaCacheLimit
2551 pack.deltaCacheSize
2552 pack.depth
2553 pack.indexVersion
2554 pack.packSizeLimit
2555 pack.threads
2556 pack.window
2557 pack.windowMemory
2558 pager.
2559 pretty.
2560 pull.octopus
2561 pull.twohead
2562 push.default
2563 push.followTags
2564 rebase.autosquash
2565 rebase.stat
2566 receive.autogc
2567 receive.denyCurrentBranch
2568 receive.denyDeleteCurrent
2569 receive.denyDeletes
2570 receive.denyNonFastForwards
2571 receive.fsckObjects
2572 receive.unpackLimit
2573 receive.updateserverinfo
2574 remote.pushdefault
2575 remotes.
2576 repack.usedeltabaseoffset
2577 rerere.autoupdate
2578 rerere.enabled
2579 sendemail.
2580 sendemail.aliasesfile
2581 sendemail.aliasfiletype
2582 sendemail.bcc
2583 sendemail.cc
2584 sendemail.cccmd
2585 sendemail.chainreplyto
2586 sendemail.confirm
2587 sendemail.envelopesender
2588 sendemail.from
2589 sendemail.identity
2590 sendemail.multiedit
2591 sendemail.signedoffbycc
2592 sendemail.smtpdomain
2593 sendemail.smtpencryption
2594 sendemail.smtppass
2595 sendemail.smtpserver
2596 sendemail.smtpserveroption
2597 sendemail.smtpserverport
2598 sendemail.smtpuser
2599 sendemail.suppresscc
2600 sendemail.suppressfrom
2601 sendemail.thread
2602 sendemail.to
2603 sendemail.tocmd
2604 sendemail.validate
2605 sendemail.smtpbatchsize
2606 sendemail.smtprelogindelay
2607 showbranch.default
2608 status.relativePaths
2609 status.showUntrackedFiles
2610 status.submodulesummary
2611 submodule.
2612 tar.umask
2613 transfer.unpackLimit
2614 url.
2615 user.email
2616 user.name
2617 user.signingkey
2618 web.browser
2619 branch. remote.
2620 "
2621}
2622_git_remote ()
2624{
2625 local subcommands="
2626 add rename remove set-head set-branches
2627 get-url set-url show prune update
2628 "
2629 local subcommand="$(__git_find_on_cmdline "$subcommands")"
2630 if [ -z "$subcommand" ]; then
2631 case "$cur" in
2632 --*)
2633 __gitcomp "--verbose"
2634 ;;
2635 *)
2636 __gitcomp "$subcommands"
2637 ;;
2638 esac
2639 return
2640 fi
2641 case "$subcommand,$cur" in
2643 add,--*)
2644 __gitcomp "--track --master --fetch --tags --no-tags --mirror="
2645 ;;
2646 add,*)
2647 ;;
2648 set-head,--*)
2649 __gitcomp "--auto --delete"
2650 ;;
2651 set-branches,--*)
2652 __gitcomp "--add"
2653 ;;
2654 set-head,*|set-branches,*)
2655 __git_complete_remote_or_refspec
2656 ;;
2657 update,--*)
2658 __gitcomp "--prune"
2659 ;;
2660 update,*)
2661 __gitcomp "$(__git_get_config_variables "remotes")"
2662 ;;
2663 set-url,--*)
2664 __gitcomp "--push --add --delete"
2665 ;;
2666 get-url,--*)
2667 __gitcomp "--push --all"
2668 ;;
2669 prune,--*)
2670 __gitcomp "--dry-run"
2671 ;;
2672 *)
2673 __gitcomp_nl "$(__git_remotes)"
2674 ;;
2675 esac
2676}
2677_git_replace ()
2679{
2680 case "$cur" in
2681 --*)
2682 __gitcomp "--edit --graft --format= --list --delete"
2683 return
2684 ;;
2685 esac
2686 __git_complete_refs
2687}
2688_git_rerere ()
2690{
2691 local subcommands="clear forget diff remaining status gc"
2692 local subcommand="$(__git_find_on_cmdline "$subcommands")"
2693 if test -z "$subcommand"
2694 then
2695 __gitcomp "$subcommands"
2696 return
2697 fi
2698}
2699_git_reset ()
2701{
2702 __git_has_doubledash && return
2703 case "$cur" in
2705 --*)
2706 __gitcomp "--merge --mixed --hard --soft --patch --keep"
2707 return
2708 ;;
2709 esac
2710 __git_complete_refs
2711}
2712_git_revert ()
2714{
2715 __git_find_repo_path
2716 if [ -f "$__git_repo_path"/REVERT_HEAD ]; then
2717 __gitcomp "--continue --quit --abort"
2718 return
2719 fi
2720 case "$cur" in
2721 --*)
2722 __gitcomp "
2723 --edit --mainline --no-edit --no-commit --signoff
2724 --strategy= --strategy-option=
2725 "
2726 return
2727 ;;
2728 esac
2729 __git_complete_refs
2730}
2731_git_rm ()
2733{
2734 case "$cur" in
2735 --*)
2736 __gitcomp "--cached --dry-run --ignore-unmatch --quiet"
2737 return
2738 ;;
2739 esac
2740 __git_complete_index_file "--cached"
2742}
2743_git_shortlog ()
2745{
2746 __git_has_doubledash && return
2747 case "$cur" in
2749 --*)
2750 __gitcomp "
2751 $__git_log_common_options
2752 $__git_log_shortlog_options
2753 --numbered --summary --email
2754 "
2755 return
2756 ;;
2757 esac
2758 __git_complete_revlist
2759}
2760_git_show ()
2762{
2763 __git_has_doubledash && return
2764 case "$cur" in
2766 --pretty=*|--format=*)
2767 __gitcomp "$__git_log_pretty_formats $(__git_pretty_aliases)
2768 " "" "${cur#*=}"
2769 return
2770 ;;
2771 --diff-algorithm=*)
2772 __gitcomp "$__git_diff_algorithms" "" "${cur##--diff-algorithm=}"
2773 return
2774 ;;
2775 --submodule=*)
2776 __gitcomp "$__git_diff_submodule_formats" "" "${cur##--submodule=}"
2777 return
2778 ;;
2779 --*)
2780 __gitcomp "--pretty= --format= --abbrev-commit --oneline
2781 --show-signature
2782 $__git_diff_common_options
2783 "
2784 return
2785 ;;
2786 esac
2787 __git_complete_revlist_file
2788}
2789_git_show_branch ()
2791{
2792 case "$cur" in
2793 --*)
2794 __gitcomp "
2795 --all --remotes --topo-order --date-order --current --more=
2796 --list --independent --merge-base --no-name
2797 --color --no-color
2798 --sha1-name --sparse --topics --reflog
2799 "
2800 return
2801 ;;
2802 esac
2803 __git_complete_revlist
2804}
2805_git_stash ()
2807{
2808 local save_opts='--all --keep-index --no-keep-index --quiet --patch --include-untracked'
2809 local subcommands='push save list show apply clear drop pop create branch'
2810 local subcommand="$(__git_find_on_cmdline "$subcommands")"
2811 if [ -z "$subcommand" ]; then
2812 case "$cur" in
2813 --*)
2814 __gitcomp "$save_opts"
2815 ;;
2816 *)
2817 if [ -z "$(__git_find_on_cmdline "$save_opts")" ]; then
2818 __gitcomp "$subcommands"
2819 fi
2820 ;;
2821 esac
2822 else
2823 case "$subcommand,$cur" in
2824 push,--*)
2825 __gitcomp "$save_opts --message"
2826 ;;
2827 save,--*)
2828 __gitcomp "$save_opts"
2829 ;;
2830 apply,--*|pop,--*)
2831 __gitcomp "--index --quiet"
2832 ;;
2833 drop,--*)
2834 __gitcomp "--quiet"
2835 ;;
2836 show,--*|branch,--*)
2837 ;;
2838 branch,*)
2839 if [ $cword -eq 3 ]; then
2840 __git_complete_refs
2841 else
2842 __gitcomp_nl "$(__git stash list \
2843 | sed -n -e 's/:.*//p')"
2844 fi
2845 ;;
2846 show,*|apply,*|drop,*|pop,*)
2847 __gitcomp_nl "$(__git stash list \
2848 | sed -n -e 's/:.*//p')"
2849 ;;
2850 *)
2851 ;;
2852 esac
2853 fi
2854}
2855_git_submodule ()
2857{
2858 __git_has_doubledash && return
2859 local subcommands="add status init deinit update summary foreach sync"
2861 local subcommand="$(__git_find_on_cmdline "$subcommands")"
2862 if [ -z "$subcommand" ]; then
2863 case "$cur" in
2864 --*)
2865 __gitcomp "--quiet"
2866 ;;
2867 *)
2868 __gitcomp "$subcommands"
2869 ;;
2870 esac
2871 return
2872 fi
2873 case "$subcommand,$cur" in
2875 add,--*)
2876 __gitcomp "--branch --force --name --reference --depth"
2877 ;;
2878 status,--*)
2879 __gitcomp "--cached --recursive"
2880 ;;
2881 deinit,--*)
2882 __gitcomp "--force --all"
2883 ;;
2884 update,--*)
2885 __gitcomp "
2886 --init --remote --no-fetch
2887 --recommend-shallow --no-recommend-shallow
2888 --force --rebase --merge --reference --depth --recursive --jobs
2889 "
2890 ;;
2891 summary,--*)
2892 __gitcomp "--cached --files --summary-limit"
2893 ;;
2894 foreach,--*|sync,--*)
2895 __gitcomp "--recursive"
2896 ;;
2897 *)
2898 ;;
2899 esac
2900}
2901_git_svn ()
2903{
2904 local subcommands="
2905 init fetch clone rebase dcommit log find-rev
2906 set-tree commit-diff info create-ignore propget
2907 proplist show-ignore show-externals branch tag blame
2908 migrate mkdirs reset gc
2909 "
2910 local subcommand="$(__git_find_on_cmdline "$subcommands")"
2911 if [ -z "$subcommand" ]; then
2912 __gitcomp "$subcommands"
2913 else
2914 local remote_opts="--username= --config-dir= --no-auth-cache"
2915 local fc_opts="
2916 --follow-parent --authors-file= --repack=
2917 --no-metadata --use-svm-props --use-svnsync-props
2918 --log-window-size= --no-checkout --quiet
2919 --repack-flags --use-log-author --localtime
2920 --add-author-from
2921 --ignore-paths= --include-paths= $remote_opts
2922 "
2923 local init_opts="
2924 --template= --shared= --trunk= --tags=
2925 --branches= --stdlayout --minimize-url
2926 --no-metadata --use-svm-props --use-svnsync-props
2927 --rewrite-root= --prefix= $remote_opts
2928 "
2929 local cmt_opts="
2930 --edit --rmdir --find-copies-harder --copy-similarity=
2931 "
2932 case "$subcommand,$cur" in
2934 fetch,--*)
2935 __gitcomp "--revision= --fetch-all $fc_opts"
2936 ;;
2937 clone,--*)
2938 __gitcomp "--revision= $fc_opts $init_opts"
2939 ;;
2940 init,--*)
2941 __gitcomp "$init_opts"
2942 ;;
2943 dcommit,--*)
2944 __gitcomp "
2945 --merge --strategy= --verbose --dry-run
2946 --fetch-all --no-rebase --commit-url
2947 --revision --interactive $cmt_opts $fc_opts
2948 "
2949 ;;
2950 set-tree,--*)
2951 __gitcomp "--stdin $cmt_opts $fc_opts"
2952 ;;
2953 create-ignore,--*|propget,--*|proplist,--*|show-ignore,--*|\
2954 show-externals,--*|mkdirs,--*)
2955 __gitcomp "--revision="
2956 ;;
2957 log,--*)
2958 __gitcomp "
2959 --limit= --revision= --verbose --incremental
2960 --oneline --show-commit --non-recursive
2961 --authors-file= --color
2962 "
2963 ;;
2964 rebase,--*)
2965 __gitcomp "
2966 --merge --verbose --strategy= --local
2967 --fetch-all --dry-run $fc_opts
2968 "
2969 ;;
2970 commit-diff,--*)
2971 __gitcomp "--message= --file= --revision= $cmt_opts"
2972 ;;
2973 info,--*)
2974 __gitcomp "--url"
2975 ;;
2976 branch,--*)
2977 __gitcomp "--dry-run --message --tag"
2978 ;;
2979 tag,--*)
2980 __gitcomp "--dry-run --message"
2981 ;;
2982 blame,--*)
2983 __gitcomp "--git-format"
2984 ;;
2985 migrate,--*)
2986 __gitcomp "
2987 --config-dir= --ignore-paths= --minimize
2988 --no-auth-cache --username=
2989 "
2990 ;;
2991 reset,--*)
2992 __gitcomp "--revision= --parent"
2993 ;;
2994 *)
2995 ;;
2996 esac
2997 fi
2998}
2999_git_tag ()
3001{
3002 local i c=1 f=0
3003 while [ $c -lt $cword ]; do
3004 i="${words[c]}"
3005 case "$i" in
3006 -d|-v)
3007 __gitcomp_direct "$(__git_tags "" "$cur" " ")"
3008 return
3009 ;;
3010 -f)
3011 f=1
3012 ;;
3013 esac
3014 ((c++))
3015 done
3016 case "$prev" in
3018 -m|-F)
3019 ;;
3020 -*|tag)
3021 if [ $f = 1 ]; then
3022 __gitcomp_direct "$(__git_tags "" "$cur" " ")"
3023 fi
3024 ;;
3025 *)
3026 __git_complete_refs
3027 ;;
3028 esac
3029 case "$cur" in
3031 --*)
3032 __gitcomp "
3033 --list --delete --verify --annotate --message --file
3034 --sign --cleanup --local-user --force --column --sort=
3035 --contains --no-contains --points-at --merged --no-merged --create-reflog
3036 "
3037 ;;
3038 esac
3039}
3040_git_whatchanged ()
3042{
3043 _git_log
3044}
3045_git_worktree ()
3047{
3048 local subcommands="add list lock prune unlock"
3049 local subcommand="$(__git_find_on_cmdline "$subcommands")"
3050 if [ -z "$subcommand" ]; then
3051 __gitcomp "$subcommands"
3052 else
3053 case "$subcommand,$cur" in
3054 add,--*)
3055 __gitcomp "--detach"
3056 ;;
3057 list,--*)
3058 __gitcomp "--porcelain"
3059 ;;
3060 lock,--*)
3061 __gitcomp "--reason"
3062 ;;
3063 prune,--*)
3064 __gitcomp "--dry-run --expire --verbose"
3065 ;;
3066 *)
3067 ;;
3068 esac
3069 fi
3070}
3071__git_main ()
3073{
3074 local i c=1 command __git_dir __git_repo_path
3075 local __git_C_args C_args_count=0
3076 while [ $c -lt $cword ]; do
3078 i="${words[c]}"
3079 case "$i" in
3080 --git-dir=*) __git_dir="${i#--git-dir=}" ;;
3081 --git-dir) ((c++)) ; __git_dir="${words[c]}" ;;
3082 --bare) __git_dir="." ;;
3083 --help) command="help"; break ;;
3084 -c|--work-tree|--namespace) ((c++)) ;;
3085 -C) __git_C_args[C_args_count++]=-C
3086 ((c++))
3087 __git_C_args[C_args_count++]="${words[c]}"
3088 ;;
3089 -*) ;;
3090 *) command="$i"; break ;;
3091 esac
3092 ((c++))
3093 done
3094 if [ -z "$command" ]; then
3096 case "$prev" in
3097 --git-dir|-C|--work-tree)
3098 # these need a path argument, let's fall back to
3099 # Bash filename completion
3100 return
3101 ;;
3102 -c|--namespace)
3103 # we don't support completing these options' arguments
3104 return
3105 ;;
3106 esac
3107 case "$cur" in
3108 --*) __gitcomp "
3109 --paginate
3110 --no-pager
3111 --git-dir=
3112 --bare
3113 --version
3114 --exec-path
3115 --exec-path=
3116 --html-path
3117 --man-path
3118 --info-path
3119 --work-tree=
3120 --namespace=
3121 --no-replace-objects
3122 --help
3123 "
3124 ;;
3125 *) __git_compute_porcelain_commands
3126 __gitcomp "$__git_porcelain_commands $(__git_aliases)" ;;
3127 esac
3128 return
3129 fi
3130 local completion_func="_git_${command//-/_}"
3132 declare -f $completion_func >/dev/null 2>/dev/null && $completion_func && return
3133 local expansion=$(__git_aliased_command "$command")
3135 if [ -n "$expansion" ]; then
3136 words[1]=$expansion
3137 completion_func="_git_${expansion//-/_}"
3138 declare -f $completion_func >/dev/null 2>/dev/null && $completion_func
3139 fi
3140}
3141__gitk_main ()
3143{
3144 __git_has_doubledash && return
3145 local __git_repo_path
3147 __git_find_repo_path
3148 local merge=""
3150 if [ -f "$__git_repo_path/MERGE_HEAD" ]; then
3151 merge="--merge"
3152 fi
3153 case "$cur" in
3154 --*)
3155 __gitcomp "
3156 $__git_log_common_options
3157 $__git_log_gitk_options
3158 $merge
3159 "
3160 return
3161 ;;
3162 esac
3163 __git_complete_revlist
3164}
3165if [[ -n ${ZSH_VERSION-} ]]; then
3167 echo "WARNING: this script is deprecated, please see git-completion.zsh" 1>&2
3168 autoload -U +X compinit && compinit
3170 __gitcomp ()
3172 {
3173 emulate -L zsh
3174 local cur_="${3-$cur}"
3176 case "$cur_" in
3178 --*=)
3179 ;;
3180 *)
3181 local c IFS=$' \t\n'
3182 local -a array
3183 for c in ${=1}; do
3184 c="$c${4-}"
3185 case $c in
3186 --*=*|*.) ;;
3187 *) c="$c " ;;
3188 esac
3189 array[${#array[@]}+1]="$c"
3190 done
3191 compset -P '*[=:]'
3192 compadd -Q -S '' -p "${2-}" -a -- array && _ret=0
3193 ;;
3194 esac
3195 }
3196 __gitcomp_direct ()
3198 {
3199 emulate -L zsh
3200 local IFS=$'\n'
3202 compset -P '*[=:]'
3203 compadd -Q -- ${=1} && _ret=0
3204 }
3205 __gitcomp_nl ()
3207 {
3208 emulate -L zsh
3209 local IFS=$'\n'
3211 compset -P '*[=:]'
3212 compadd -Q -S "${4- }" -p "${2-}" -- ${=1} && _ret=0
3213 }
3214 __gitcomp_file ()
3216 {
3217 emulate -L zsh
3218 local IFS=$'\n'
3220 compset -P '*[=:]'
3221 compadd -Q -p "${2-}" -f -- ${=1} && _ret=0
3222 }
3223 _git ()
3225 {
3226 local _ret=1 cur cword prev
3227 cur=${words[CURRENT]}
3228 prev=${words[CURRENT-1]}
3229 let cword=CURRENT-1
3230 emulate ksh -c __${service}_main
3231 let _ret && _default && _ret=0
3232 return _ret
3233 }
3234 compdef _git git gitk
3236 return
3237fi
3238__git_func_wrap ()
3240{
3241 local cur words cword prev
3242 _get_comp_words_by_ref -n =: cur words cword prev
3243 $1
3244}
3245# Setup completion for certain functions defined above by setting common
3247# variables and workarounds.
3248# This is NOT a public function; use at your own risk.
3249__git_complete ()
3250{
3251 local wrapper="__git_wrap${2}"
3252 eval "$wrapper () { __git_func_wrap $2 ; }"
3253 complete -o bashdefault -o default -o nospace -F $wrapper $1 2>/dev/null \
3254 || complete -o default -o nospace -F $wrapper $1
3255}
3256# wrapper for backwards compatibility
3258_git ()
3259{
3260 __git_wrap__git_main
3261}
3262# wrapper for backwards compatibility
3264_gitk ()
3265{
3266 __git_wrap__gitk_main
3267}
3268__git_complete git __git_main
3270__git_complete gitk __gitk_main
3271# The following are necessary only for Cygwin, and only are needed
3273# when the user has tab-completed the executable name and consequently
3274# included the '.exe' suffix.
3275#
3276if [ Cygwin = "$(uname -o 2>/dev/null)" ]; then
3277__git_complete git.exe __git_main
3278fi