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