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