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