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