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