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