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