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