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