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