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