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