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