]> Tony Duckles's Git Repositories (git.nynim.org) - dotfiles.git/blob - bin/git-sh
.vimrc: Remove 'nowrap'
[dotfiles.git] / bin / git-sh
1 #!/usr/bin/env bash
2 #
3 # A customized bash environment suitable for git work.
4 #
5 # Copyright (C) 2008 Ryan Tomayko <http://tomayko.com/>
6 # Copyright (C) 2008 Aristotle Pagaltzis <http://plasmasturm.org/>
7 #
8 # This program is free software; you can redistribute it and/or modify
9 # it under the terms of the GNU General Public License as published by
10 # the Free Software Foundation; either version 2 of the License, or
11 # (at your option) any later version.
12 #
13 # This program is distributed in the hope that it will be useful,
14 # but WITHOUT ANY WARRANTY; without even the implied warranty of
15 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 # GNU General Public License for more details.
17 #
18 # You should have received a copy of the GNU General Public License along
19 # with this program; if not, write to the Free Software Foundation, Inc.,
20 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
21 # Distributed under the GNU General Public License, version 2.0.
22
23 # use to install the sh alias
24 [[ $1 = '--configure' && $# = 1 ]] && {
25 set -e
26 git config --global alias.sh '!git-sh'
27 echo "alias 'sh' added to ~/.gitconfig"
28 exit 0
29 }
30
31 # we expect to be sourced into an interactive shell. when executed as a
32 # command, kick off a new shell and source us.
33 [ "$0" = 'bash' ] ||
34 exec /usr/bin/env bash --rcfile "$0" "$@"
35
36 # source the user's .bashrc file
37 [ -r ~/.bashrc ] && {
38 pushd ~ > /dev/null
39 . .bashrc
40 popd > /dev/null
41 }
42
43
44 # ALIASES + COMPLETION =========================================================
45
46 # gitcomp <alias> <command>
47 #
48 # Complete command named <alias> like standard git command named
49 # <command>. <command> must be a valid git command with completion.
50 #
51 # Examples:
52 # gitcomplete ci commit
53 # gitcomplete c checkout
54 gitcomplete() {
55 local alias="$1" command="$2"
56 complete -o default -o nospace -F _git_${command//-/_} $alias
57 }
58
59 # gitalias <alias>='<command> [<args>...]'
60 #
61 # Define a new shell alias (as with the alias builtin) named <alias>
62 # and enable command completion based on <command>. <command> must be
63 # a standard non-abbreviated git command name that has completion support.
64 #
65 # Examples:
66 # gitalias c=checkout
67 # gitalias ci='commit -v'
68 # gitalias r='rebase --interactive HEAD~10'
69 gitalias() {
70 local alias="${1%%=*}" command="${1#*=}"
71 local prog="${command##git }"
72 prog="${prog%% *}"
73 alias $alias="$command"
74 gitcomplete "$alias" "$prog"
75 }
76
77 # create aliases and configure bash completion for most porcelain commands
78
79 _git_cmd_cfg=(
80 'add alias'
81 'am alias stdcmpl'
82 'annotate alias'
83 'apply alias stdcmpl'
84 'archive alias'
85 'bisect alias stdcmpl'
86 'blame alias'
87 'branch alias stdcmpl'
88 'bundle alias stdcmpl'
89 'cat-file alias'
90 'checkout alias stdcmpl'
91 'cherry alias stdcmpl'
92 'cherry-pick alias stdcmpl'
93 'clean alias'
94 'clone alias'
95 'commit alias stdcmpl'
96 'config alias stdcmpl'
97 'describe alias stdcmpl'
98 'diff alias stdcmpl'
99 'fetch alias stdcmpl'
100 'format-patch alias stdcmpl'
101 'fsck alias'
102 'gc alias stdcmpl'
103 'gui alias'
104 'init alias'
105 'instaweb alias'
106 'log alias logcmpl'
107 'lost-found alias'
108 'ls-files alias'
109 'ls-remote alias stdcmpl'
110 'ls-tree alias stdcmpl'
111 'merge alias stdcmpl'
112 'merge-base stdcmpl'
113 'mergetool alias'
114 'mv alias'
115 'name-rev stdcmpl'
116 'patch-id alias'
117 'peek-remote alias'
118 'prune alias'
119 'pull alias stdcmpl'
120 'push alias stdcmpl'
121 'quiltimport alias'
122 'rebase alias stdcmpl'
123 'reflog alias'
124 'remote alias stdcmpl'
125 'repack alias'
126 'repo-config alias'
127 'request-pull alias'
128 'reset alias stdcmpl'
129 'rev-list alias'
130 'rev-parse alias'
131 'revert alias'
132 'rm alias'
133 'send-email alias'
134 'send-pack alias'
135 'shortlog stdcmpl'
136 'show alias stdcmpl'
137 'show-branch logcmpl'
138 'stash alias stdcmpl'
139 'status alias'
140 'stripspace alias'
141 'submodule alias stdcmpl'
142 'svn alias stdcmpl'
143 'symbolic-ref alias'
144 'tag alias stdcmpl'
145 'tar-tree alias'
146 'var alias'
147 'whatchanged alias logcmpl'
148 )
149
150 for cfg in "${_git_cmd_cfg[@]}" ; do
151 read cmd opts <<< $cfg
152 for opt in $opts ; do
153 case $opt in
154 alias) alias $cmd="git $cmd" ;;
155 stdcmpl) complete -o default -o nospace -F _git_${cmd//-/_} $cmd ;;
156 logcmpl) complete -o default -o nospace -F _git_log $cmd ;;
157 esac
158 done
159 done
160
161 # Create aliases for everything defined in the gitconfig [alias] section.
162 _git_import_aliases () {
163 eval "$(
164 git config --get-regexp 'alias\..*' |
165 sed 's/^alias\.//' |
166 while read key command
167 do
168 if expr -- "$command" : '!' >/dev/null
169 then echo "alias $key='${command#!}'"
170 else echo "gitalias $key='git $command'"
171 fi
172 done
173 )"
174 }
175
176 # PROMPT =======================================================================
177
178 PS1='`_git_headname`!`_git_workdir``_git_dirty`> '
179
180 ANSI_RESET="\001$(git config --get-color "" "reset")\002"
181
182 # detect whether the tree is in a dirty state. returns
183 _git_dirty() {
184 if git status 2>/dev/null | fgrep -q '(working directory clean)'; then
185 return 0
186 fi
187 local dirty_marker="`git config gitsh.dirty || echo ' *'`"
188 _git_apply_color "$dirty_marker" "color.sh.dirty" "red"
189 }
190
191 # detect the current branch; use 7-sha when not on branch
192 _git_headname() {
193 local br=`git symbolic-ref -q HEAD 2>/dev/null`
194 [ -n "$br" ] &&
195 br=${br#refs/heads/} ||
196 br=`git rev-parse --short HEAD 2>/dev/null`
197 _git_apply_color "$br" "color.sh.branch" "yellow reverse"
198 }
199
200 # detect working directory relative to working tree root
201 _git_workdir() {
202 subdir=`git rev-parse --show-prefix 2>/dev/null`
203 subdir="${subdir%/}"
204 workdir="${PWD%/$subdir}"
205 _git_apply_color "${workdir/*\/}${subdir:+/$subdir}" "color.sh.workdir" "blue bold"
206 }
207
208 # determine whether color should be enabled. this checks git's color.ui
209 # option and then color.sh.
210 _git_color_enabled() {
211 [ `git config --get-colorbool color.sh true` = "true" ]
212 }
213
214 # apply a color to the first argument
215 _git_apply_color() {
216 local output="$1" color="$2" default="$3"
217 if _git_color_enabled ; then
218 color=`_git_color "$color" "$default"`
219 echo -ne "${color}${output}${ANSI_RESET}"
220 else
221 echo -ne "$output"
222 fi
223 }
224
225 # retrieve an ANSI color escape sequence from git config
226 _git_color() {
227 local color
228 color=`git config --get-color "$1" "$2" 2>/dev/null`
229 [ -n "$color" ] && echo -ne "\001$color\002"
230 }
231
232 # HELP ========================================================================
233
234 _help_display() {
235 local name value
236 # show git's inbuilt help, after some tweaking...
237 git --help | grep -v "See 'git help"
238
239 # show aliases defined in ~/.gitconfig
240 echo "Command aliases:"
241 git config --get-regexp 'alias\..*' |
242 sed 's/^alias\.//' |
243 sort |
244 while read name value
245 do printf " %-10s %-65s\n" "$name" "$value"
246 done
247
248 printf "\nSee 'help COMMAND' for more information on a specific command.\n"
249 }
250
251 help() {
252 local _git_pager=$(git config core.pager)
253 if [ $# = 1 ];
254 then git help $1
255 else (_help_display | ${_git_pager:-${PAGER:-less}})
256 fi
257 }
258 complete -o default -o nospace -F _git help
259
260 # vim: tw=80 noexpandtab
261 #!bash
262 #
263 # bash completion support for core Git.
264 #
265 # Copyright (C) 2006,2007 Shawn O. Pearce <spearce@spearce.org>
266 # Conceptually based on gitcompletion (http://gitweb.hawaga.org.uk/).
267 # Distributed under the GNU General Public License, version 2.0.
268 #
269 # The contained completion routines provide support for completing:
270 #
271 # *) local and remote branch names
272 # *) local and remote tag names
273 # *) .git/remotes file names
274 # *) git 'subcommands'
275 # *) tree paths within 'ref:path/to/file' expressions
276 # *) common --long-options
277 #
278 # To use these routines:
279 #
280 # 1) Copy this file to somewhere (e.g. ~/.git-completion.sh).
281 # 2) Added the following line to your .bashrc:
282 # source ~/.git-completion.sh
283 #
284 # 3) You may want to make sure the git executable is available
285 # in your PATH before this script is sourced, as some caching
286 # is performed while the script loads. If git isn't found
287 # at source time then all lookups will be done on demand,
288 # which may be slightly slower.
289 #
290 # 4) Consider changing your PS1 to also show the current branch:
291 # PS1='[\u@\h \W$(__git_ps1 " (%s)")]\$ '
292 #
293 # The argument to __git_ps1 will be displayed only if you
294 # are currently in a git repository. The %s token will be
295 # the name of the current branch.
296 #
297 # In addition, if you set GIT_PS1_SHOWDIRTYSTATE to a nonempty
298 # value, unstaged (*) and staged (+) changes will be shown next
299 # to the branch name. You can configure this per-repository
300 # with the bash.showDirtyState variable, which defaults to true
301 # once GIT_PS1_SHOWDIRTYSTATE is enabled.
302 #
303 # You can also see if currently something is stashed, by setting
304 # GIT_PS1_SHOWSTASHSTATE to a nonempty value. If something is stashed,
305 # then a '$' will be shown next to the branch name.
306 #
307 # If you would like to see if there're untracked files, then you can
308 # set GIT_PS1_SHOWUNTRACKEDFILES to a nonempty value. If there're
309 # untracked files, then a '%' will be shown next to the branch name.
310 #
311 # To submit patches:
312 #
313 # *) Read Documentation/SubmittingPatches
314 # *) Send all patches to the current maintainer:
315 #
316 # "Shawn O. Pearce" <spearce@spearce.org>
317 #
318 # *) Always CC the Git mailing list:
319 #
320 # git@vger.kernel.org
321 #
322
323 case "$COMP_WORDBREAKS" in
324 *:*) : great ;;
325 *) COMP_WORDBREAKS="$COMP_WORDBREAKS:"
326 esac
327
328 # __gitdir accepts 0 or 1 arguments (i.e., location)
329 # returns location of .git repo
330 __gitdir ()
331 {
332 if [ -z "${1-}" ]; then
333 if [ -n "${__git_dir-}" ]; then
334 echo "$__git_dir"
335 elif [ -d .git ]; then
336 echo .git
337 else
338 git rev-parse --git-dir 2>/dev/null
339 fi
340 elif [ -d "$1/.git" ]; then
341 echo "$1/.git"
342 else
343 echo "$1"
344 fi
345 }
346
347 # __git_ps1 accepts 0 or 1 arguments (i.e., format string)
348 # returns text to add to bash PS1 prompt (includes branch name)
349 __git_ps1 ()
350 {
351 local g="$(__gitdir)"
352 if [ -n "$g" ]; then
353 local r
354 local b
355 if [ -f "$g/rebase-merge/interactive" ]; then
356 r="|REBASE-i"
357 b="$(cat "$g/rebase-merge/head-name")"
358 elif [ -d "$g/rebase-merge" ]; then
359 r="|REBASE-m"
360 b="$(cat "$g/rebase-merge/head-name")"
361 else
362 if [ -d "$g/rebase-apply" ]; then
363 if [ -f "$g/rebase-apply/rebasing" ]; then
364 r="|REBASE"
365 elif [ -f "$g/rebase-apply/applying" ]; then
366 r="|AM"
367 else
368 r="|AM/REBASE"
369 fi
370 elif [ -f "$g/MERGE_HEAD" ]; then
371 r="|MERGING"
372 elif [ -f "$g/BISECT_LOG" ]; then
373 r="|BISECTING"
374 fi
375
376 b="$(git symbolic-ref HEAD 2>/dev/null)" || {
377
378 b="$(
379 case "${GIT_PS1_DESCRIBE_STYLE-}" in
380 (contains)
381 git describe --contains HEAD ;;
382 (branch)
383 git describe --contains --all HEAD ;;
384 (describe)
385 git describe HEAD ;;
386 (* | default)
387 git describe --exact-match HEAD ;;
388 esac 2>/dev/null)" ||
389
390 b="$(cut -c1-7 "$g/HEAD" 2>/dev/null)..." ||
391 b="unknown"
392 b="($b)"
393 }
394 fi
395
396 local w
397 local i
398 local s
399 local u
400 local c
401
402 if [ "true" = "$(git rev-parse --is-inside-git-dir 2>/dev/null)" ]; then
403 if [ "true" = "$(git rev-parse --is-bare-repository 2>/dev/null)" ]; then
404 c="BARE:"
405 else
406 b="GIT_DIR!"
407 fi
408 elif [ "true" = "$(git rev-parse --is-inside-work-tree 2>/dev/null)" ]; then
409 if [ -n "${GIT_PS1_SHOWDIRTYSTATE-}" ]; then
410 if [ "$(git config --bool bash.showDirtyState)" != "false" ]; then
411 git diff --no-ext-diff --ignore-submodules \
412 --quiet --exit-code || w="*"
413 if git rev-parse --quiet --verify HEAD >/dev/null; then
414 git diff-index --cached --quiet \
415 --ignore-submodules HEAD -- || i="+"
416 else
417 i="#"
418 fi
419 fi
420 fi
421 if [ -n "${GIT_PS1_SHOWSTASHSTATE-}" ]; then
422 git rev-parse --verify refs/stash >/dev/null 2>&1 && s="$"
423 fi
424
425 if [ -n "${GIT_PS1_SHOWUNTRACKEDFILES-}" ]; then
426 if [ -n "$(git ls-files --others --exclude-standard)" ]; then
427 u="%"
428 fi
429 fi
430 fi
431
432 if [ -n "${1-}" ]; then
433 printf "$1" "$c${b##refs/heads/}$w$i$s$u$r"
434 else
435 printf " (%s)" "$c${b##refs/heads/}$w$i$s$u$r"
436 fi
437 fi
438 }
439
440 # __gitcomp_1 requires 2 arguments
441 __gitcomp_1 ()
442 {
443 local c IFS=' '$'\t'$'\n'
444 for c in $1; do
445 case "$c$2" in
446 --*=*) printf %s$'\n' "$c$2" ;;
447 *.) printf %s$'\n' "$c$2" ;;
448 *) printf %s$'\n' "$c$2 " ;;
449 esac
450 done
451 }
452
453 # __gitcomp accepts 1, 2, 3, or 4 arguments
454 # generates completion reply with compgen
455 __gitcomp ()
456 {
457 local cur="${COMP_WORDS[COMP_CWORD]}"
458 if [ $# -gt 2 ]; then
459 cur="$3"
460 fi
461 case "$cur" in
462 --*=)
463 COMPREPLY=()
464 ;;
465 *)
466 local IFS=$'\n'
467 COMPREPLY=($(compgen -P "${2-}" \
468 -W "$(__gitcomp_1 "${1-}" "${4-}")" \
469 -- "$cur"))
470 ;;
471 esac
472 }
473
474 # __git_heads accepts 0 or 1 arguments (to pass to __gitdir)
475 __git_heads ()
476 {
477 local cmd i is_hash=y dir="$(__gitdir "${1-}")"
478 if [ -d "$dir" ]; then
479 git --git-dir="$dir" for-each-ref --format='%(refname:short)' \
480 refs/heads
481 return
482 fi
483 for i in $(git ls-remote "${1-}" 2>/dev/null); do
484 case "$is_hash,$i" in
485 y,*) is_hash=n ;;
486 n,*^{}) is_hash=y ;;
487 n,refs/heads/*) is_hash=y; echo "${i#refs/heads/}" ;;
488 n,*) is_hash=y; echo "$i" ;;
489 esac
490 done
491 }
492
493 # __git_tags accepts 0 or 1 arguments (to pass to __gitdir)
494 __git_tags ()
495 {
496 local cmd i is_hash=y dir="$(__gitdir "${1-}")"
497 if [ -d "$dir" ]; then
498 git --git-dir="$dir" for-each-ref --format='%(refname:short)' \
499 refs/tags
500 return
501 fi
502 for i in $(git ls-remote "${1-}" 2>/dev/null); do
503 case "$is_hash,$i" in
504 y,*) is_hash=n ;;
505 n,*^{}) is_hash=y ;;
506 n,refs/tags/*) is_hash=y; echo "${i#refs/tags/}" ;;
507 n,*) is_hash=y; echo "$i" ;;
508 esac
509 done
510 }
511
512 # __git_refs accepts 0 or 1 arguments (to pass to __gitdir)
513 __git_refs ()
514 {
515 local i is_hash=y dir="$(__gitdir "${1-}")"
516 local cur="${COMP_WORDS[COMP_CWORD]}" format refs
517 if [ -d "$dir" ]; then
518 case "$cur" in
519 refs|refs/*)
520 format="refname"
521 refs="${cur%/*}"
522 ;;
523 *)
524 if [ -e "$dir/HEAD" ]; then echo HEAD; fi
525 format="refname:short"
526 refs="refs/tags refs/heads refs/remotes"
527 ;;
528 esac
529 git --git-dir="$dir" for-each-ref --format="%($format)" \
530 $refs
531 return
532 fi
533 for i in $(git ls-remote "$dir" 2>/dev/null); do
534 case "$is_hash,$i" in
535 y,*) is_hash=n ;;
536 n,*^{}) is_hash=y ;;
537 n,refs/tags/*) is_hash=y; echo "${i#refs/tags/}" ;;
538 n,refs/heads/*) is_hash=y; echo "${i#refs/heads/}" ;;
539 n,refs/remotes/*) is_hash=y; echo "${i#refs/remotes/}" ;;
540 n,*) is_hash=y; echo "$i" ;;
541 esac
542 done
543 }
544
545 # __git_refs2 requires 1 argument (to pass to __git_refs)
546 __git_refs2 ()
547 {
548 local i
549 for i in $(__git_refs "$1"); do
550 echo "$i:$i"
551 done
552 }
553
554 # __git_refs_remotes requires 1 argument (to pass to ls-remote)
555 __git_refs_remotes ()
556 {
557 local cmd i is_hash=y
558 for i in $(git ls-remote "$1" 2>/dev/null); do
559 case "$is_hash,$i" in
560 n,refs/heads/*)
561 is_hash=y
562 echo "$i:refs/remotes/$1/${i#refs/heads/}"
563 ;;
564 y,*) is_hash=n ;;
565 n,*^{}) is_hash=y ;;
566 n,refs/tags/*) is_hash=y;;
567 n,*) is_hash=y; ;;
568 esac
569 done
570 }
571
572 __git_remotes ()
573 {
574 local i ngoff IFS=$'\n' d="$(__gitdir)"
575 shopt -q nullglob || ngoff=1
576 shopt -s nullglob
577 for i in "$d/remotes"/*; do
578 echo ${i#$d/remotes/}
579 done
580 [ "$ngoff" ] && shopt -u nullglob
581 for i in $(git --git-dir="$d" config --get-regexp 'remote\..*\.url' 2>/dev/null); do
582 i="${i#remote.}"
583 echo "${i/.url*/}"
584 done
585 }
586
587 __git_merge_strategies ()
588 {
589 if [ -n "${__git_merge_strategylist-}" ]; then
590 echo "$__git_merge_strategylist"
591 return
592 fi
593 git merge -s help 2>&1 |
594 sed -n -e '/[Aa]vailable strategies are: /,/^$/{
595 s/\.$//
596 s/.*://
597 s/^[ ]*//
598 s/[ ]*$//
599 p
600 }'
601 }
602 __git_merge_strategylist=
603 __git_merge_strategylist=$(__git_merge_strategies 2>/dev/null)
604
605 __git_complete_file ()
606 {
607 local pfx ls ref cur="${COMP_WORDS[COMP_CWORD]}"
608 case "$cur" in
609 ?*:*)
610 ref="${cur%%:*}"
611 cur="${cur#*:}"
612 case "$cur" in
613 ?*/*)
614 pfx="${cur%/*}"
615 cur="${cur##*/}"
616 ls="$ref:$pfx"
617 pfx="$pfx/"
618 ;;
619 *)
620 ls="$ref"
621 ;;
622 esac
623
624 case "$COMP_WORDBREAKS" in
625 *:*) : great ;;
626 *) pfx="$ref:$pfx" ;;
627 esac
628
629 local IFS=$'\n'
630 COMPREPLY=($(compgen -P "$pfx" \
631 -W "$(git --git-dir="$(__gitdir)" ls-tree "$ls" \
632 | sed '/^100... blob /{
633 s,^.* ,,
634 s,$, ,
635 }
636 /^120000 blob /{
637 s,^.* ,,
638 s,$, ,
639 }
640 /^040000 tree /{
641 s,^.* ,,
642 s,$,/,
643 }
644 s/^.* //')" \
645 -- "$cur"))
646 ;;
647 *)
648 __gitcomp "$(__git_refs)"
649 ;;
650 esac
651 }
652
653 __git_complete_revlist ()
654 {
655 local pfx cur="${COMP_WORDS[COMP_CWORD]}"
656 case "$cur" in
657 *...*)
658 pfx="${cur%...*}..."
659 cur="${cur#*...}"
660 __gitcomp "$(__git_refs)" "$pfx" "$cur"
661 ;;
662 *..*)
663 pfx="${cur%..*}.."
664 cur="${cur#*..}"
665 __gitcomp "$(__git_refs)" "$pfx" "$cur"
666 ;;
667 *)
668 __gitcomp "$(__git_refs)"
669 ;;
670 esac
671 }
672
673 __git_complete_remote_or_refspec ()
674 {
675 local cmd="${COMP_WORDS[0]}"
676 local cur="${COMP_WORDS[COMP_CWORD]}"
677 local i c=1 remote="" pfx="" lhs=1 no_complete_refspec=0
678
679 # adjust args upward when completing git *
680 [ "$cmd" = "git" ] && {
681 cmd="${COMP_WORDS[1]}"
682 c=2
683 }
684
685 while [ $c -lt $COMP_CWORD ]; do
686 i="${COMP_WORDS[c]}"
687 case "$i" in
688 --all|--mirror) [ "$cmd" = "push" ] && no_complete_refspec=1 ;;
689 -*) ;;
690 *) remote="$i"; break ;;
691 esac
692 c=$((++c))
693 done
694 if [ -z "$remote" ]; then
695 __gitcomp "$(__git_remotes)"
696 return
697 fi
698 if [ $no_complete_refspec = 1 ]; then
699 COMPREPLY=()
700 return
701 fi
702 [ "$remote" = "." ] && remote=
703 case "$cur" in
704 *:*)
705 case "$COMP_WORDBREAKS" in
706 *:*) : great ;;
707 *) pfx="${cur%%:*}:" ;;
708 esac
709 cur="${cur#*:}"
710 lhs=0
711 ;;
712 +*)
713 pfx="+"
714 cur="${cur#+}"
715 ;;
716 esac
717 case "$cmd" in
718 fetch)
719 if [ $lhs = 1 ]; then
720 __gitcomp "$(__git_refs2 "$remote")" "$pfx" "$cur"
721 else
722 __gitcomp "$(__git_refs)" "$pfx" "$cur"
723 fi
724 ;;
725 pull)
726 if [ $lhs = 1 ]; then
727 __gitcomp "$(__git_refs "$remote")" "$pfx" "$cur"
728 else
729 __gitcomp "$(__git_refs)" "$pfx" "$cur"
730 fi
731 ;;
732 push)
733 if [ $lhs = 1 ]; then
734 __gitcomp "$(__git_refs)" "$pfx" "$cur"
735 else
736 __gitcomp "$(__git_refs "$remote")" "$pfx" "$cur"
737 fi
738 ;;
739 esac
740 }
741
742 __git_complete_strategy ()
743 {
744 case "${COMP_WORDS[COMP_CWORD-1]}" in
745 -s|--strategy)
746 __gitcomp "$(__git_merge_strategies)"
747 return 0
748 esac
749 local cur="${COMP_WORDS[COMP_CWORD]}"
750 case "$cur" in
751 --strategy=*)
752 __gitcomp "$(__git_merge_strategies)" "" "${cur##--strategy=}"
753 return 0
754 ;;
755 esac
756 return 1
757 }
758
759 __git_all_commands ()
760 {
761 if [ -n "${__git_all_commandlist-}" ]; then
762 echo "$__git_all_commandlist"
763 return
764 fi
765 local i IFS=" "$'\n'
766 for i in $(git help -a|egrep '^ [a-zA-Z0-9]')
767 do
768 case $i in
769 *--*) : helper pattern;;
770 *) echo $i;;
771 esac
772 done
773 }
774 __git_all_commandlist=
775 __git_all_commandlist="$(__git_all_commands 2>/dev/null)"
776
777 __git_porcelain_commands ()
778 {
779 if [ -n "${__git_porcelain_commandlist-}" ]; then
780 echo "$__git_porcelain_commandlist"
781 return
782 fi
783 local i IFS=" "$'\n'
784 for i in "help" $(__git_all_commands)
785 do
786 case $i in
787 *--*) : helper pattern;;
788 applymbox) : ask gittus;;
789 applypatch) : ask gittus;;
790 archimport) : import;;
791 cat-file) : plumbing;;
792 check-attr) : plumbing;;
793 check-ref-format) : plumbing;;
794 checkout-index) : plumbing;;
795 commit-tree) : plumbing;;
796 count-objects) : infrequent;;
797 cvsexportcommit) : export;;
798 cvsimport) : import;;
799 cvsserver) : daemon;;
800 daemon) : daemon;;
801 diff-files) : plumbing;;
802 diff-index) : plumbing;;
803 diff-tree) : plumbing;;
804 fast-import) : import;;
805 fast-export) : export;;
806 fsck-objects) : plumbing;;
807 fetch-pack) : plumbing;;
808 fmt-merge-msg) : plumbing;;
809 for-each-ref) : plumbing;;
810 hash-object) : plumbing;;
811 http-*) : transport;;
812 index-pack) : plumbing;;
813 init-db) : deprecated;;
814 local-fetch) : plumbing;;
815 lost-found) : infrequent;;
816 ls-files) : plumbing;;
817 ls-remote) : plumbing;;
818 ls-tree) : plumbing;;
819 mailinfo) : plumbing;;
820 mailsplit) : plumbing;;
821 merge-*) : plumbing;;
822 mktree) : plumbing;;
823 mktag) : plumbing;;
824 pack-objects) : plumbing;;
825 pack-redundant) : plumbing;;
826 pack-refs) : plumbing;;
827 parse-remote) : plumbing;;
828 patch-id) : plumbing;;
829 peek-remote) : plumbing;;
830 prune) : plumbing;;
831 prune-packed) : plumbing;;
832 quiltimport) : import;;
833 read-tree) : plumbing;;
834 receive-pack) : plumbing;;
835 reflog) : plumbing;;
836 repo-config) : deprecated;;
837 rerere) : plumbing;;
838 rev-list) : plumbing;;
839 rev-parse) : plumbing;;
840 runstatus) : plumbing;;
841 sh-setup) : internal;;
842 shell) : daemon;;
843 show-ref) : plumbing;;
844 send-pack) : plumbing;;
845 show-index) : plumbing;;
846 ssh-*) : transport;;
847 stripspace) : plumbing;;
848 symbolic-ref) : plumbing;;
849 tar-tree) : deprecated;;
850 unpack-file) : plumbing;;
851 unpack-objects) : plumbing;;
852 update-index) : plumbing;;
853 update-ref) : plumbing;;
854 update-server-info) : daemon;;
855 upload-archive) : plumbing;;
856 upload-pack) : plumbing;;
857 write-tree) : plumbing;;
858 var) : infrequent;;
859 verify-pack) : infrequent;;
860 verify-tag) : plumbing;;
861 *) echo $i;;
862 esac
863 done
864 }
865 __git_porcelain_commandlist=
866 __git_porcelain_commandlist="$(__git_porcelain_commands 2>/dev/null)"
867
868 __git_aliases ()
869 {
870 local i IFS=$'\n'
871 for i in $(git --git-dir="$(__gitdir)" config --get-regexp "alias\..*" 2>/dev/null); do
872 case "$i" in
873 alias.*)
874 i="${i#alias.}"
875 echo "${i/ */}"
876 ;;
877 esac
878 done
879 }
880
881 # __git_aliased_command requires 1 argument
882 __git_aliased_command ()
883 {
884 local word cmdline=$(git --git-dir="$(__gitdir)" \
885 config --get "alias.$1")
886 for word in $cmdline; do
887 if [ "${word##-*}" ]; then
888 echo $word
889 return
890 fi
891 done
892 }
893
894 # __git_find_on_cmdline requires 1 argument
895 __git_find_on_cmdline ()
896 {
897 local word subcommand c=1
898
899 while [ $c -lt $COMP_CWORD ]; do
900 word="${COMP_WORDS[c]}"
901 for subcommand in $1; do
902 if [ "$subcommand" = "$word" ]; then
903 echo "$subcommand"
904 return
905 fi
906 done
907 c=$((++c))
908 done
909 }
910
911 __git_has_doubledash ()
912 {
913 local c=1
914 while [ $c -lt $COMP_CWORD ]; do
915 if [ "--" = "${COMP_WORDS[c]}" ]; then
916 return 0
917 fi
918 c=$((++c))
919 done
920 return 1
921 }
922
923 __git_whitespacelist="nowarn warn error error-all fix"
924
925 _git_am ()
926 {
927 local cur="${COMP_WORDS[COMP_CWORD]}" dir="$(__gitdir)"
928 if [ -d "$dir"/rebase-apply ]; then
929 __gitcomp "--skip --resolved --abort"
930 return
931 fi
932 case "$cur" in
933 --whitespace=*)
934 __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
935 return
936 ;;
937 --*)
938 __gitcomp "
939 --3way --committer-date-is-author-date --ignore-date
940 --ignore-whitespace --ignore-space-change
941 --interactive --keep --no-utf8 --signoff --utf8
942 --whitespace= --scissors
943 "
944 return
945 esac
946 COMPREPLY=()
947 }
948
949 _git_apply ()
950 {
951 local cur="${COMP_WORDS[COMP_CWORD]}"
952 case "$cur" in
953 --whitespace=*)
954 __gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
955 return
956 ;;
957 --*)
958 __gitcomp "
959 --stat --numstat --summary --check --index
960 --cached --index-info --reverse --reject --unidiff-zero
961 --apply --no-add --exclude=
962 --ignore-whitespace --ignore-space-change
963 --whitespace= --inaccurate-eof --verbose
964 "
965 return
966 esac
967 COMPREPLY=()
968 }
969
970 _git_add ()
971 {
972 __git_has_doubledash && return
973
974 local cur="${COMP_WORDS[COMP_CWORD]}"
975 case "$cur" in
976 --*)
977 __gitcomp "
978 --interactive --refresh --patch --update --dry-run
979 --ignore-errors --intent-to-add
980 "
981 return
982 esac
983 COMPREPLY=()
984 }
985
986 _git_archive ()
987 {
988 local cur="${COMP_WORDS[COMP_CWORD]}"
989 case "$cur" in
990 --format=*)
991 __gitcomp "$(git archive --list)" "" "${cur##--format=}"
992 return
993 ;;
994 --remote=*)
995 __gitcomp "$(__git_remotes)" "" "${cur##--remote=}"
996 return
997 ;;
998 --*)
999 __gitcomp "
1000 --format= --list --verbose
1001 --prefix= --remote= --exec=
1002 "
1003 return
1004 ;;
1005 esac
1006 __git_complete_file
1007 }
1008
1009 _git_bisect ()
1010 {
1011 __git_has_doubledash && return
1012
1013 local subcommands="start bad good skip reset visualize replay log run"
1014 local subcommand="$(__git_find_on_cmdline "$subcommands")"
1015 if [ -z "$subcommand" ]; then
1016 __gitcomp "$subcommands"
1017 return
1018 fi
1019
1020 case "$subcommand" in
1021 bad|good|reset|skip)
1022 __gitcomp "$(__git_refs)"
1023 ;;
1024 *)
1025 COMPREPLY=()
1026 ;;
1027 esac
1028 }
1029
1030 _git_branch ()
1031 {
1032 local i c=1 only_local_ref="n" has_r="n"
1033
1034 while [ $c -lt $COMP_CWORD ]; do
1035 i="${COMP_WORDS[c]}"
1036 case "$i" in
1037 -d|-m) only_local_ref="y" ;;
1038 -r) has_r="y" ;;
1039 esac
1040 c=$((++c))
1041 done
1042
1043 case "${COMP_WORDS[COMP_CWORD]}" in
1044 --*)
1045 __gitcomp "
1046 --color --no-color --verbose --abbrev= --no-abbrev
1047 --track --no-track --contains --merged --no-merged
1048 "
1049 ;;
1050 *)
1051 if [ $only_local_ref = "y" -a $has_r = "n" ]; then
1052 __gitcomp "$(__git_heads)"
1053 else
1054 __gitcomp "$(__git_refs)"
1055 fi
1056 ;;
1057 esac
1058 }
1059
1060 _git_bundle ()
1061 {
1062 local cmd="${COMP_WORDS[1]}"
1063 case "$COMP_CWORD" in
1064 2)
1065 __gitcomp "create list-heads verify unbundle"
1066 ;;
1067 3)
1068 # looking for a file
1069 ;;
1070 *)
1071 case "$cmd" in
1072 create)
1073 __git_complete_revlist
1074 ;;
1075 esac
1076 ;;
1077 esac
1078 }
1079
1080 _git_checkout ()
1081 {
1082 __git_has_doubledash && return
1083
1084 local cur="${COMP_WORDS[COMP_CWORD]}"
1085 case "$cur" in
1086 --conflict=*)
1087 __gitcomp "diff3 merge" "" "${cur##--conflict=}"
1088 ;;
1089 --*)
1090 __gitcomp "
1091 --quiet --ours --theirs --track --no-track --merge
1092 --conflict= --patch
1093 "
1094 ;;
1095 *)
1096 __gitcomp "$(__git_refs)"
1097 ;;
1098 esac
1099 }
1100
1101 _git_cherry ()
1102 {
1103 __gitcomp "$(__git_refs)"
1104 }
1105
1106 _git_cherry_pick ()
1107 {
1108 local cur="${COMP_WORDS[COMP_CWORD]}"
1109 case "$cur" in
1110 --*)
1111 __gitcomp "--edit --no-commit"
1112 ;;
1113 *)
1114 __gitcomp "$(__git_refs)"
1115 ;;
1116 esac
1117 }
1118
1119 _git_clean ()
1120 {
1121 __git_has_doubledash && return
1122
1123 local cur="${COMP_WORDS[COMP_CWORD]}"
1124 case "$cur" in
1125 --*)
1126 __gitcomp "--dry-run --quiet"
1127 return
1128 ;;
1129 esac
1130 COMPREPLY=()
1131 }
1132
1133 _git_clone ()
1134 {
1135 local cur="${COMP_WORDS[COMP_CWORD]}"
1136 case "$cur" in
1137 --*)
1138 __gitcomp "
1139 --local
1140 --no-hardlinks
1141 --shared
1142 --reference
1143 --quiet
1144 --no-checkout
1145 --bare
1146 --mirror
1147 --origin
1148 --upload-pack
1149 --template=
1150 --depth
1151 "
1152 return
1153 ;;
1154 esac
1155 COMPREPLY=()
1156 }
1157
1158 _git_commit ()
1159 {
1160 __git_has_doubledash && return
1161
1162 local cur="${COMP_WORDS[COMP_CWORD]}"
1163 case "$cur" in
1164 --*)
1165 __gitcomp "
1166 --all --author= --signoff --verify --no-verify
1167 --edit --amend --include --only --interactive
1168 --dry-run
1169 "
1170 return
1171 esac
1172 COMPREPLY=()
1173 }
1174
1175 _git_describe ()
1176 {
1177 local cur="${COMP_WORDS[COMP_CWORD]}"
1178 case "$cur" in
1179 --*)
1180 __gitcomp "
1181 --all --tags --contains --abbrev= --candidates=
1182 --exact-match --debug --long --match --always
1183 "
1184 return
1185 esac
1186 __gitcomp "$(__git_refs)"
1187 }
1188
1189 __git_diff_common_options="--stat --numstat --shortstat --summary
1190 --patch-with-stat --name-only --name-status --color
1191 --no-color --color-words --no-renames --check
1192 --full-index --binary --abbrev --diff-filter=
1193 --find-copies-harder
1194 --text --ignore-space-at-eol --ignore-space-change
1195 --ignore-all-space --exit-code --quiet --ext-diff
1196 --no-ext-diff
1197 --no-prefix --src-prefix= --dst-prefix=
1198 --inter-hunk-context=
1199 --patience
1200 --raw
1201 --dirstat --dirstat= --dirstat-by-file
1202 --dirstat-by-file= --cumulative
1203 "
1204
1205 _git_diff ()
1206 {
1207 __git_has_doubledash && return
1208
1209 local cur="${COMP_WORDS[COMP_CWORD]}"
1210 case "$cur" in
1211 --*)
1212 __gitcomp "--cached --staged --pickaxe-all --pickaxe-regex
1213 --base --ours --theirs
1214 $__git_diff_common_options
1215 "
1216 return
1217 ;;
1218 esac
1219 __git_complete_file
1220 }
1221
1222 __git_mergetools_common="diffuse ecmerge emerge kdiff3 meld opendiff
1223 tkdiff vimdiff gvimdiff xxdiff araxis
1224 "
1225
1226 _git_difftool ()
1227 {
1228 local cur="${COMP_WORDS[COMP_CWORD]}"
1229 case "$cur" in
1230 --tool=*)
1231 __gitcomp "$__git_mergetools_common kompare" "" "${cur##--tool=}"
1232 return
1233 ;;
1234 --*)
1235 __gitcomp "--tool="
1236 return
1237 ;;
1238 esac
1239 COMPREPLY=()
1240 }
1241
1242 __git_fetch_options="
1243 --quiet --verbose --append --upload-pack --force --keep --depth=
1244 --tags --no-tags
1245 "
1246
1247 _git_fetch ()
1248 {
1249 local cur="${COMP_WORDS[COMP_CWORD]}"
1250 case "$cur" in
1251 --*)
1252 __gitcomp "$__git_fetch_options"
1253 return
1254 ;;
1255 esac
1256 __git_complete_remote_or_refspec
1257 }
1258
1259 _git_format_patch ()
1260 {
1261 local cur="${COMP_WORDS[COMP_CWORD]}"
1262 case "$cur" in
1263 --thread=*)
1264 __gitcomp "
1265 deep shallow
1266 " "" "${cur##--thread=}"
1267 return
1268 ;;
1269 --*)
1270 __gitcomp "
1271 --stdout --attach --no-attach --thread --thread=
1272 --output-directory
1273 --numbered --start-number
1274 --numbered-files
1275 --keep-subject
1276 --signoff
1277 --in-reply-to= --cc=
1278 --full-index --binary
1279 --not --all
1280 --cover-letter
1281 --no-prefix --src-prefix= --dst-prefix=
1282 --inline --suffix= --ignore-if-in-upstream
1283 --subject-prefix=
1284 "
1285 return
1286 ;;
1287 esac
1288 __git_complete_revlist
1289 }
1290
1291 _git_fsck ()
1292 {
1293 local cur="${COMP_WORDS[COMP_CWORD]}"
1294 case "$cur" in
1295 --*)
1296 __gitcomp "
1297 --tags --root --unreachable --cache --no-reflogs --full
1298 --strict --verbose --lost-found
1299 "
1300 return
1301 ;;
1302 esac
1303 COMPREPLY=()
1304 }
1305
1306 _git_gc ()
1307 {
1308 local cur="${COMP_WORDS[COMP_CWORD]}"
1309 case "$cur" in
1310 --*)
1311 __gitcomp "--prune --aggressive"
1312 return
1313 ;;
1314 esac
1315 COMPREPLY=()
1316 }
1317
1318 _git_grep ()
1319 {
1320 __git_has_doubledash && return
1321
1322 local cur="${COMP_WORDS[COMP_CWORD]}"
1323 case "$cur" in
1324 --*)
1325 __gitcomp "
1326 --cached
1327 --text --ignore-case --word-regexp --invert-match
1328 --full-name
1329 --extended-regexp --basic-regexp --fixed-strings
1330 --files-with-matches --name-only
1331 --files-without-match
1332 --max-depth
1333 --count
1334 --and --or --not --all-match
1335 "
1336 return
1337 ;;
1338 esac
1339 COMPREPLY=()
1340 }
1341
1342 _git_help ()
1343 {
1344 local cur="${COMP_WORDS[COMP_CWORD]}"
1345 case "$cur" in
1346 --*)
1347 __gitcomp "--all --info --man --web"
1348 return
1349 ;;
1350 esac
1351 __gitcomp "$(__git_all_commands)
1352 attributes cli core-tutorial cvs-migration
1353 diffcore gitk glossary hooks ignore modules
1354 repository-layout tutorial tutorial-2
1355 workflows
1356 "
1357 }
1358
1359 _git_init ()
1360 {
1361 local cur="${COMP_WORDS[COMP_CWORD]}"
1362 case "$cur" in
1363 --shared=*)
1364 __gitcomp "
1365 false true umask group all world everybody
1366 " "" "${cur##--shared=}"
1367 return
1368 ;;
1369 --*)
1370 __gitcomp "--quiet --bare --template= --shared --shared="
1371 return
1372 ;;
1373 esac
1374 COMPREPLY=()
1375 }
1376
1377 _git_ls_files ()
1378 {
1379 __git_has_doubledash && return
1380
1381 local cur="${COMP_WORDS[COMP_CWORD]}"
1382 case "$cur" in
1383 --*)
1384 __gitcomp "--cached --deleted --modified --others --ignored
1385 --stage --directory --no-empty-directory --unmerged
1386 --killed --exclude= --exclude-from=
1387 --exclude-per-directory= --exclude-standard
1388 --error-unmatch --with-tree= --full-name
1389 --abbrev --ignored --exclude-per-directory
1390 "
1391 return
1392 ;;
1393 esac
1394 COMPREPLY=()
1395 }
1396
1397 _git_ls_remote ()
1398 {
1399 __gitcomp "$(__git_remotes)"
1400 }
1401
1402 _git_ls_tree ()
1403 {
1404 __git_complete_file
1405 }
1406
1407 # Options that go well for log, shortlog and gitk
1408 __git_log_common_options="
1409 --not --all
1410 --branches --tags --remotes
1411 --first-parent --merges --no-merges
1412 --max-count=
1413 --max-age= --since= --after=
1414 --min-age= --until= --before=
1415 "
1416 # Options that go well for log and gitk (not shortlog)
1417 __git_log_gitk_options="
1418 --dense --sparse --full-history
1419 --simplify-merges --simplify-by-decoration
1420 --left-right
1421 "
1422 # Options that go well for log and shortlog (not gitk)
1423 __git_log_shortlog_options="
1424 --author= --committer= --grep=
1425 --all-match
1426 "
1427
1428 __git_log_pretty_formats="oneline short medium full fuller email raw format:"
1429 __git_log_date_formats="relative iso8601 rfc2822 short local default raw"
1430
1431 _git_log ()
1432 {
1433 __git_has_doubledash && return
1434
1435 local cur="${COMP_WORDS[COMP_CWORD]}"
1436 local g="$(git rev-parse --git-dir 2>/dev/null)"
1437 local merge=""
1438 if [ -f "$g/MERGE_HEAD" ]; then
1439 merge="--merge"
1440 fi
1441 case "$cur" in
1442 --pretty=*)
1443 __gitcomp "$__git_log_pretty_formats
1444 " "" "${cur##--pretty=}"
1445 return
1446 ;;
1447 --format=*)
1448 __gitcomp "$__git_log_pretty_formats
1449 " "" "${cur##--format=}"
1450 return
1451 ;;
1452 --date=*)
1453 __gitcomp "$__git_log_date_formats" "" "${cur##--date=}"
1454 return
1455 ;;
1456 --decorate=*)
1457 __gitcomp "long short" "" "${cur##--decorate=}"
1458 return
1459 ;;
1460 --*)
1461 __gitcomp "
1462 $__git_log_common_options
1463 $__git_log_shortlog_options
1464 $__git_log_gitk_options
1465 --root --topo-order --date-order --reverse
1466 --follow --full-diff
1467 --abbrev-commit --abbrev=
1468 --relative-date --date=
1469 --pretty= --format= --oneline
1470 --cherry-pick
1471 --graph
1472 --decorate --decorate=
1473 --walk-reflogs
1474 --parents --children
1475 $merge
1476 $__git_diff_common_options
1477 --pickaxe-all --pickaxe-regex
1478 "
1479 return
1480 ;;
1481 esac
1482 __git_complete_revlist
1483 }
1484
1485 __git_merge_options="
1486 --no-commit --no-stat --log --no-log --squash --strategy
1487 --commit --stat --no-squash --ff --no-ff
1488 "
1489
1490 _git_merge ()
1491 {
1492 __git_complete_strategy && return
1493
1494 local cur="${COMP_WORDS[COMP_CWORD]}"
1495 case "$cur" in
1496 --*)
1497 __gitcomp "$__git_merge_options"
1498 return
1499 esac
1500 __gitcomp "$(__git_refs)"
1501 }
1502
1503 _git_mergetool ()
1504 {
1505 local cur="${COMP_WORDS[COMP_CWORD]}"
1506 case "$cur" in
1507 --tool=*)
1508 __gitcomp "$__git_mergetools_common tortoisemerge" "" "${cur##--tool=}"
1509 return
1510 ;;
1511 --*)
1512 __gitcomp "--tool="
1513 return
1514 ;;
1515 esac
1516 COMPREPLY=()
1517 }
1518
1519 _git_merge_base ()
1520 {
1521 __gitcomp "$(__git_refs)"
1522 }
1523
1524 _git_mv ()
1525 {
1526 local cur="${COMP_WORDS[COMP_CWORD]}"
1527 case "$cur" in
1528 --*)
1529 __gitcomp "--dry-run"
1530 return
1531 ;;
1532 esac
1533 COMPREPLY=()
1534 }
1535
1536 _git_name_rev ()
1537 {
1538 __gitcomp "--tags --all --stdin"
1539 }
1540
1541 _git_pull ()
1542 {
1543 __git_complete_strategy && return
1544
1545 local cur="${COMP_WORDS[COMP_CWORD]}"
1546 case "$cur" in
1547 --*)
1548 __gitcomp "
1549 --rebase --no-rebase
1550 $__git_merge_options
1551 $__git_fetch_options
1552 "
1553 return
1554 ;;
1555 esac
1556 __git_complete_remote_or_refspec
1557 }
1558
1559 _git_push ()
1560 {
1561 local cur="${COMP_WORDS[COMP_CWORD]}"
1562 case "${COMP_WORDS[COMP_CWORD-1]}" in
1563 --repo)
1564 __gitcomp "$(__git_remotes)"
1565 return
1566 esac
1567 case "$cur" in
1568 --repo=*)
1569 __gitcomp "$(__git_remotes)" "" "${cur##--repo=}"
1570 return
1571 ;;
1572 --*)
1573 __gitcomp "
1574 --all --mirror --tags --dry-run --force --verbose
1575 --receive-pack= --repo=
1576 "
1577 return
1578 ;;
1579 esac
1580 __git_complete_remote_or_refspec
1581 }
1582
1583 _git_rebase ()
1584 {
1585 local cur="${COMP_WORDS[COMP_CWORD]}" dir="$(__gitdir)"
1586 if [ -d "$dir"/rebase-apply ] || [ -d "$dir"/rebase-merge ]; then
1587 __gitcomp "--continue --skip --abort"
1588 return
1589 fi
1590 __git_complete_strategy && return
1591 case "$cur" in
1592 --*)
1593 __gitcomp "--onto --merge --strategy --interactive"
1594 return
1595 esac
1596 __gitcomp "$(__git_refs)"
1597 }
1598
1599 __git_send_email_confirm_options="always never auto cc compose"
1600 __git_send_email_suppresscc_options="author self cc bodycc sob cccmd body all"
1601
1602 _git_send_email ()
1603 {
1604 local cur="${COMP_WORDS[COMP_CWORD]}"
1605 case "$cur" in
1606 --confirm=*)
1607 __gitcomp "
1608 $__git_send_email_confirm_options
1609 " "" "${cur##--confirm=}"
1610 return
1611 ;;
1612 --suppress-cc=*)
1613 __gitcomp "
1614 $__git_send_email_suppresscc_options
1615 " "" "${cur##--suppress-cc=}"
1616
1617 return
1618 ;;
1619 --smtp-encryption=*)
1620 __gitcomp "ssl tls" "" "${cur##--smtp-encryption=}"
1621 return
1622 ;;
1623 --*)
1624 __gitcomp "--annotate --bcc --cc --cc-cmd --chain-reply-to
1625 --compose --confirm= --dry-run --envelope-sender
1626 --from --identity
1627 --in-reply-to --no-chain-reply-to --no-signed-off-by-cc
1628 --no-suppress-from --no-thread --quiet
1629 --signed-off-by-cc --smtp-pass --smtp-server
1630 --smtp-server-port --smtp-encryption= --smtp-user
1631 --subject --suppress-cc= --suppress-from --thread --to
1632 --validate --no-validate"
1633 return
1634 ;;
1635 esac
1636 COMPREPLY=()
1637 }
1638
1639 __git_config_get_set_variables ()
1640 {
1641 local prevword word config_file= c=$COMP_CWORD
1642 while [ $c -gt 1 ]; do
1643 word="${COMP_WORDS[c]}"
1644 case "$word" in
1645 --global|--system|--file=*)
1646 config_file="$word"
1647 break
1648 ;;
1649 -f|--file)
1650 config_file="$word $prevword"
1651 break
1652 ;;
1653 esac
1654 prevword=$word
1655 c=$((--c))
1656 done
1657
1658 git --git-dir="$(__gitdir)" config $config_file --list 2>/dev/null |
1659 while read line
1660 do
1661 case "$line" in
1662 *.*=*)
1663 echo "${line/=*/}"
1664 ;;
1665 esac
1666 done
1667 }
1668
1669 _git_config ()
1670 {
1671 local cur="${COMP_WORDS[COMP_CWORD]}"
1672 local prv="${COMP_WORDS[COMP_CWORD-1]}"
1673 case "$prv" in
1674 branch.*.remote)
1675 __gitcomp "$(__git_remotes)"
1676 return
1677 ;;
1678 branch.*.merge)
1679 __gitcomp "$(__git_refs)"
1680 return
1681 ;;
1682 remote.*.fetch)
1683 local remote="${prv#remote.}"
1684 remote="${remote%.fetch}"
1685 __gitcomp "$(__git_refs_remotes "$remote")"
1686 return
1687 ;;
1688 remote.*.push)
1689 local remote="${prv#remote.}"
1690 remote="${remote%.push}"
1691 __gitcomp "$(git --git-dir="$(__gitdir)" \
1692 for-each-ref --format='%(refname):%(refname)' \
1693 refs/heads)"
1694 return
1695 ;;
1696 pull.twohead|pull.octopus)
1697 __gitcomp "$(__git_merge_strategies)"
1698 return
1699 ;;
1700 color.branch|color.diff|color.interactive|\
1701 color.showbranch|color.status|color.ui)
1702 __gitcomp "always never auto"
1703 return
1704 ;;
1705 color.pager)
1706 __gitcomp "false true"
1707 return
1708 ;;
1709 color.*.*)
1710 __gitcomp "
1711 normal black red green yellow blue magenta cyan white
1712 bold dim ul blink reverse
1713 "
1714 return
1715 ;;
1716 help.format)
1717 __gitcomp "man info web html"
1718 return
1719 ;;
1720 log.date)
1721 __gitcomp "$__git_log_date_formats"
1722 return
1723 ;;
1724 sendemail.aliasesfiletype)
1725 __gitcomp "mutt mailrc pine elm gnus"
1726 return
1727 ;;
1728 sendemail.confirm)
1729 __gitcomp "$__git_send_email_confirm_options"
1730 return
1731 ;;
1732 sendemail.suppresscc)
1733 __gitcomp "$__git_send_email_suppresscc_options"
1734 return
1735 ;;
1736 --get|--get-all|--unset|--unset-all)
1737 __gitcomp "$(__git_config_get_set_variables)"
1738 return
1739 ;;
1740 *.*)
1741 COMPREPLY=()
1742 return
1743 ;;
1744 esac
1745 case "$cur" in
1746 --*)
1747 __gitcomp "
1748 --global --system --file=
1749 --list --replace-all
1750 --get --get-all --get-regexp
1751 --add --unset --unset-all
1752 --remove-section --rename-section
1753 "
1754 return
1755 ;;
1756 branch.*.*)
1757 local pfx="${cur%.*}."
1758 cur="${cur##*.}"
1759 __gitcomp "remote merge mergeoptions rebase" "$pfx" "$cur"
1760 return
1761 ;;
1762 branch.*)
1763 local pfx="${cur%.*}."
1764 cur="${cur#*.}"
1765 __gitcomp "$(__git_heads)" "$pfx" "$cur" "."
1766 return
1767 ;;
1768 guitool.*.*)
1769 local pfx="${cur%.*}."
1770 cur="${cur##*.}"
1771 __gitcomp "
1772 argprompt cmd confirm needsfile noconsole norescan
1773 prompt revprompt revunmerged title
1774 " "$pfx" "$cur"
1775 return
1776 ;;
1777 difftool.*.*)
1778 local pfx="${cur%.*}."
1779 cur="${cur##*.}"
1780 __gitcomp "cmd path" "$pfx" "$cur"
1781 return
1782 ;;
1783 man.*.*)
1784 local pfx="${cur%.*}."
1785 cur="${cur##*.}"
1786 __gitcomp "cmd path" "$pfx" "$cur"
1787 return
1788 ;;
1789 mergetool.*.*)
1790 local pfx="${cur%.*}."
1791 cur="${cur##*.}"
1792 __gitcomp "cmd path trustExitCode" "$pfx" "$cur"
1793 return
1794 ;;
1795 pager.*)
1796 local pfx="${cur%.*}."
1797 cur="${cur#*.}"
1798 __gitcomp "$(__git_all_commands)" "$pfx" "$cur"
1799 return
1800 ;;
1801 remote.*.*)
1802 local pfx="${cur%.*}."
1803 cur="${cur##*.}"
1804 __gitcomp "
1805 url proxy fetch push mirror skipDefaultUpdate
1806 receivepack uploadpack tagopt pushurl
1807 " "$pfx" "$cur"
1808 return
1809 ;;
1810 remote.*)
1811 local pfx="${cur%.*}."
1812 cur="${cur#*.}"
1813 __gitcomp "$(__git_remotes)" "$pfx" "$cur" "."
1814 return
1815 ;;
1816 url.*.*)
1817 local pfx="${cur%.*}."
1818 cur="${cur##*.}"
1819 __gitcomp "insteadOf pushInsteadOf" "$pfx" "$cur"
1820 return
1821 ;;
1822 esac
1823 __gitcomp "
1824 add.ignore-errors
1825 alias.
1826 apply.ignorewhitespace
1827 apply.whitespace
1828 branch.autosetupmerge
1829 branch.autosetuprebase
1830 clean.requireForce
1831 color.branch
1832 color.branch.current
1833 color.branch.local
1834 color.branch.plain
1835 color.branch.remote
1836 color.diff
1837 color.diff.commit
1838 color.diff.frag
1839 color.diff.meta
1840 color.diff.new
1841 color.diff.old
1842 color.diff.plain
1843 color.diff.whitespace
1844 color.grep
1845 color.grep.external
1846 color.grep.match
1847 color.interactive
1848 color.interactive.header
1849 color.interactive.help
1850 color.interactive.prompt
1851 color.pager
1852 color.showbranch
1853 color.status
1854 color.status.added
1855 color.status.changed
1856 color.status.header
1857 color.status.nobranch
1858 color.status.untracked
1859 color.status.updated
1860 color.ui
1861 commit.template
1862 core.autocrlf
1863 core.bare
1864 core.compression
1865 core.createObject
1866 core.deltaBaseCacheLimit
1867 core.editor
1868 core.excludesfile
1869 core.fileMode
1870 core.fsyncobjectfiles
1871 core.gitProxy
1872 core.ignoreCygwinFSTricks
1873 core.ignoreStat
1874 core.logAllRefUpdates
1875 core.loosecompression
1876 core.packedGitLimit
1877 core.packedGitWindowSize
1878 core.pager
1879 core.preferSymlinkRefs
1880 core.preloadindex
1881 core.quotepath
1882 core.repositoryFormatVersion
1883 core.safecrlf
1884 core.sharedRepository
1885 core.symlinks
1886 core.trustctime
1887 core.warnAmbiguousRefs
1888 core.whitespace
1889 core.worktree
1890 diff.autorefreshindex
1891 diff.external
1892 diff.mnemonicprefix
1893 diff.renameLimit
1894 diff.renameLimit.
1895 diff.renames
1896 diff.suppressBlankEmpty
1897 diff.tool
1898 diff.wordRegex
1899 difftool.
1900 difftool.prompt
1901 fetch.unpackLimit
1902 format.attach
1903 format.cc
1904 format.headers
1905 format.numbered
1906 format.pretty
1907 format.signoff
1908 format.subjectprefix
1909 format.suffix
1910 format.thread
1911 gc.aggressiveWindow
1912 gc.auto
1913 gc.autopacklimit
1914 gc.packrefs
1915 gc.pruneexpire
1916 gc.reflogexpire
1917 gc.reflogexpireunreachable
1918 gc.rerereresolved
1919 gc.rerereunresolved
1920 gitcvs.allbinary
1921 gitcvs.commitmsgannotation
1922 gitcvs.dbTableNamePrefix
1923 gitcvs.dbdriver
1924 gitcvs.dbname
1925 gitcvs.dbpass
1926 gitcvs.dbuser
1927 gitcvs.enabled
1928 gitcvs.logfile
1929 gitcvs.usecrlfattr
1930 guitool.
1931 gui.blamehistoryctx
1932 gui.commitmsgwidth
1933 gui.copyblamethreshold
1934 gui.diffcontext
1935 gui.encoding
1936 gui.fastcopyblame
1937 gui.matchtrackingbranch
1938 gui.newbranchtemplate
1939 gui.pruneduringfetch
1940 gui.spellingdictionary
1941 gui.trustmtime
1942 help.autocorrect
1943 help.browser
1944 help.format
1945 http.lowSpeedLimit
1946 http.lowSpeedTime
1947 http.maxRequests
1948 http.noEPSV
1949 http.proxy
1950 http.sslCAInfo
1951 http.sslCAPath
1952 http.sslCert
1953 http.sslKey
1954 http.sslVerify
1955 i18n.commitEncoding
1956 i18n.logOutputEncoding
1957 imap.folder
1958 imap.host
1959 imap.pass
1960 imap.port
1961 imap.preformattedHTML
1962 imap.sslverify
1963 imap.tunnel
1964 imap.user
1965 instaweb.browser
1966 instaweb.httpd
1967 instaweb.local
1968 instaweb.modulepath
1969 instaweb.port
1970 interactive.singlekey
1971 log.date
1972 log.showroot
1973 mailmap.file
1974 man.
1975 man.viewer
1976 merge.conflictstyle
1977 merge.log
1978 merge.renameLimit
1979 merge.stat
1980 merge.tool
1981 merge.verbosity
1982 mergetool.
1983 mergetool.keepBackup
1984 mergetool.prompt
1985 pack.compression
1986 pack.deltaCacheLimit
1987 pack.deltaCacheSize
1988 pack.depth
1989 pack.indexVersion
1990 pack.packSizeLimit
1991 pack.threads
1992 pack.window
1993 pack.windowMemory
1994 pager.
1995 pull.octopus
1996 pull.twohead
1997 push.default
1998 rebase.stat
1999 receive.denyCurrentBranch
2000 receive.denyDeletes
2001 receive.denyNonFastForwards
2002 receive.fsckObjects
2003 receive.unpackLimit
2004 repack.usedeltabaseoffset
2005 rerere.autoupdate
2006 rerere.enabled
2007 sendemail.aliasesfile
2008 sendemail.aliasesfiletype
2009 sendemail.bcc
2010 sendemail.cc
2011 sendemail.cccmd
2012 sendemail.chainreplyto
2013 sendemail.confirm
2014 sendemail.envelopesender
2015 sendemail.multiedit
2016 sendemail.signedoffbycc
2017 sendemail.smtpencryption
2018 sendemail.smtppass
2019 sendemail.smtpserver
2020 sendemail.smtpserverport
2021 sendemail.smtpuser
2022 sendemail.suppresscc
2023 sendemail.suppressfrom
2024 sendemail.thread
2025 sendemail.to
2026 sendemail.validate
2027 showbranch.default
2028 status.relativePaths
2029 status.showUntrackedFiles
2030 tar.umask
2031 transfer.unpackLimit
2032 url.
2033 user.email
2034 user.name
2035 user.signingkey
2036 web.browser
2037 branch. remote.
2038 "
2039 }
2040
2041 _git_remote ()
2042 {
2043 local subcommands="add rename rm show prune update set-head"
2044 local subcommand="$(__git_find_on_cmdline "$subcommands")"
2045 if [ -z "$subcommand" ]; then
2046 __gitcomp "$subcommands"
2047 return
2048 fi
2049
2050 case "$subcommand" in
2051 rename|rm|show|prune)
2052 __gitcomp "$(__git_remotes)"
2053 ;;
2054 update)
2055 local i c='' IFS=$'\n'
2056 for i in $(git --git-dir="$(__gitdir)" config --get-regexp "remotes\..*" 2>/dev/null); do
2057 i="${i#remotes.}"
2058 c="$c ${i/ */}"
2059 done
2060 __gitcomp "$c"
2061 ;;
2062 *)
2063 COMPREPLY=()
2064 ;;
2065 esac
2066 }
2067
2068 _git_replace ()
2069 {
2070 __gitcomp "$(__git_refs)"
2071 }
2072
2073 _git_reset ()
2074 {
2075 __git_has_doubledash && return
2076
2077 local cur="${COMP_WORDS[COMP_CWORD]}"
2078 case "$cur" in
2079 --*)
2080 __gitcomp "--merge --mixed --hard --soft --patch"
2081 return
2082 ;;
2083 esac
2084 __gitcomp "$(__git_refs)"
2085 }
2086
2087 _git_revert ()
2088 {
2089 local cur="${COMP_WORDS[COMP_CWORD]}"
2090 case "$cur" in
2091 --*)
2092 __gitcomp "--edit --mainline --no-edit --no-commit --signoff"
2093 return
2094 ;;
2095 esac
2096 __gitcomp "$(__git_refs)"
2097 }
2098
2099 _git_rm ()
2100 {
2101 __git_has_doubledash && return
2102
2103 local cur="${COMP_WORDS[COMP_CWORD]}"
2104 case "$cur" in
2105 --*)
2106 __gitcomp "--cached --dry-run --ignore-unmatch --quiet"
2107 return
2108 ;;
2109 esac
2110 COMPREPLY=()
2111 }
2112
2113 _git_shortlog ()
2114 {
2115 __git_has_doubledash && return
2116
2117 local cur="${COMP_WORDS[COMP_CWORD]}"
2118 case "$cur" in
2119 --*)
2120 __gitcomp "
2121 $__git_log_common_options
2122 $__git_log_shortlog_options
2123 --numbered --summary
2124 "
2125 return
2126 ;;
2127 esac
2128 __git_complete_revlist
2129 }
2130
2131 _git_show ()
2132 {
2133 __git_has_doubledash && return
2134
2135 local cur="${COMP_WORDS[COMP_CWORD]}"
2136 case "$cur" in
2137 --pretty=*)
2138 __gitcomp "$__git_log_pretty_formats
2139 " "" "${cur##--pretty=}"
2140 return
2141 ;;
2142 --format=*)
2143 __gitcomp "$__git_log_pretty_formats
2144 " "" "${cur##--format=}"
2145 return
2146 ;;
2147 --*)
2148 __gitcomp "--pretty= --format= --abbrev-commit --oneline
2149 $__git_diff_common_options
2150 "
2151 return
2152 ;;
2153 esac
2154 __git_complete_file
2155 }
2156
2157 _git_show_branch ()
2158 {
2159 local cur="${COMP_WORDS[COMP_CWORD]}"
2160 case "$cur" in
2161 --*)
2162 __gitcomp "
2163 --all --remotes --topo-order --current --more=
2164 --list --independent --merge-base --no-name
2165 --color --no-color
2166 --sha1-name --sparse --topics --reflog
2167 "
2168 return
2169 ;;
2170 esac
2171 __git_complete_revlist
2172 }
2173
2174 _git_stash ()
2175 {
2176 local cur="${COMP_WORDS[COMP_CWORD]}"
2177 local save_opts='--keep-index --no-keep-index --quiet --patch'
2178 local subcommands='save list show apply clear drop pop create branch'
2179 local subcommand="$(__git_find_on_cmdline "$subcommands")"
2180 if [ -z "$subcommand" ]; then
2181 case "$cur" in
2182 --*)
2183 __gitcomp "$save_opts"
2184 ;;
2185 *)
2186 if [ -z "$(__git_find_on_cmdline "$save_opts")" ]; then
2187 __gitcomp "$subcommands"
2188 else
2189 COMPREPLY=()
2190 fi
2191 ;;
2192 esac
2193 else
2194 case "$subcommand,$cur" in
2195 save,--*)
2196 __gitcomp "$save_opts"
2197 ;;
2198 apply,--*|pop,--*)
2199 __gitcomp "--index --quiet"
2200 ;;
2201 show,--*|drop,--*|branch,--*)
2202 COMPREPLY=()
2203 ;;
2204 show,*|apply,*|drop,*|pop,*|branch,*)
2205 __gitcomp "$(git --git-dir="$(__gitdir)" stash list \
2206 | sed -n -e 's/:.*//p')"
2207 ;;
2208 *)
2209 COMPREPLY=()
2210 ;;
2211 esac
2212 fi
2213 }
2214
2215 _git_submodule ()
2216 {
2217 __git_has_doubledash && return
2218
2219 local subcommands="add status init update summary foreach sync"
2220 if [ -z "$(__git_find_on_cmdline "$subcommands")" ]; then
2221 local cur="${COMP_WORDS[COMP_CWORD]}"
2222 case "$cur" in
2223 --*)
2224 __gitcomp "--quiet --cached"
2225 ;;
2226 *)
2227 __gitcomp "$subcommands"
2228 ;;
2229 esac
2230 return
2231 fi
2232 }
2233
2234 _git_svn ()
2235 {
2236 local subcommands="
2237 init fetch clone rebase dcommit log find-rev
2238 set-tree commit-diff info create-ignore propget
2239 proplist show-ignore show-externals branch tag blame
2240 migrate
2241 "
2242 local subcommand="$(__git_find_on_cmdline "$subcommands")"
2243 if [ -z "$subcommand" ]; then
2244 __gitcomp "$subcommands"
2245 else
2246 local remote_opts="--username= --config-dir= --no-auth-cache"
2247 local fc_opts="
2248 --follow-parent --authors-file= --repack=
2249 --no-metadata --use-svm-props --use-svnsync-props
2250 --log-window-size= --no-checkout --quiet
2251 --repack-flags --use-log-author --localtime
2252 --ignore-paths= $remote_opts
2253 "
2254 local init_opts="
2255 --template= --shared= --trunk= --tags=
2256 --branches= --stdlayout --minimize-url
2257 --no-metadata --use-svm-props --use-svnsync-props
2258 --rewrite-root= --prefix= --use-log-author
2259 --add-author-from $remote_opts
2260 "
2261 local cmt_opts="
2262 --edit --rmdir --find-copies-harder --copy-similarity=
2263 "
2264
2265 local cur="${COMP_WORDS[COMP_CWORD]}"
2266 case "$subcommand,$cur" in
2267 fetch,--*)
2268 __gitcomp "--revision= --fetch-all $fc_opts"
2269 ;;
2270 clone,--*)
2271 __gitcomp "--revision= $fc_opts $init_opts"
2272 ;;
2273 init,--*)
2274 __gitcomp "$init_opts"
2275 ;;
2276 dcommit,--*)
2277 __gitcomp "
2278 --merge --strategy= --verbose --dry-run
2279 --fetch-all --no-rebase --commit-url
2280 --revision $cmt_opts $fc_opts
2281 "
2282 ;;
2283 set-tree,--*)
2284 __gitcomp "--stdin $cmt_opts $fc_opts"
2285 ;;
2286 create-ignore,--*|propget,--*|proplist,--*|show-ignore,--*|\
2287 show-externals,--*)
2288 __gitcomp "--revision="
2289 ;;
2290 log,--*)
2291 __gitcomp "
2292 --limit= --revision= --verbose --incremental
2293 --oneline --show-commit --non-recursive
2294 --authors-file= --color
2295 "
2296 ;;
2297 rebase,--*)
2298 __gitcomp "
2299 --merge --verbose --strategy= --local
2300 --fetch-all --dry-run $fc_opts
2301 "
2302 ;;
2303 commit-diff,--*)
2304 __gitcomp "--message= --file= --revision= $cmt_opts"
2305 ;;
2306 info,--*)
2307 __gitcomp "--url"
2308 ;;
2309 branch,--*)
2310 __gitcomp "--dry-run --message --tag"
2311 ;;
2312 tag,--*)
2313 __gitcomp "--dry-run --message"
2314 ;;
2315 blame,--*)
2316 __gitcomp "--git-format"
2317 ;;
2318 migrate,--*)
2319 __gitcomp "
2320 --config-dir= --ignore-paths= --minimize
2321 --no-auth-cache --username=
2322 "
2323 ;;
2324 *)
2325 COMPREPLY=()
2326 ;;
2327 esac
2328 fi
2329 }
2330
2331 _git_tag ()
2332 {
2333 local i c=1 f=0
2334 while [ $c -lt $COMP_CWORD ]; do
2335 i="${COMP_WORDS[c]}"
2336 case "$i" in
2337 -d|-v)
2338 __gitcomp "$(__git_tags)"
2339 return
2340 ;;
2341 -f)
2342 f=1
2343 ;;
2344 esac
2345 c=$((++c))
2346 done
2347
2348 case "${COMP_WORDS[COMP_CWORD-1]}" in
2349 -m|-F)
2350 COMPREPLY=()
2351 ;;
2352 -*|tag)
2353 if [ $f = 1 ]; then
2354 __gitcomp "$(__git_tags)"
2355 else
2356 COMPREPLY=()
2357 fi
2358 ;;
2359 *)
2360 __gitcomp "$(__git_refs)"
2361 ;;
2362 esac
2363 }
2364
2365 _git ()
2366 {
2367 local i c=1 command __git_dir
2368
2369 while [ $c -lt $COMP_CWORD ]; do
2370 i="${COMP_WORDS[c]}"
2371 case "$i" in
2372 --git-dir=*) __git_dir="${i#--git-dir=}" ;;
2373 --bare) __git_dir="." ;;
2374 --version|-p|--paginate) ;;
2375 --help) command="help"; break ;;
2376 *) command="$i"; break ;;
2377 esac
2378 c=$((++c))
2379 done
2380
2381 if [ -z "$command" ]; then
2382 case "${COMP_WORDS[COMP_CWORD]}" in
2383 --*) __gitcomp "
2384 --paginate
2385 --no-pager
2386 --git-dir=
2387 --bare
2388 --version
2389 --exec-path
2390 --html-path
2391 --work-tree=
2392 --help
2393 "
2394 ;;
2395 *) __gitcomp "$(__git_porcelain_commands) $(__git_aliases)" ;;
2396 esac
2397 return
2398 fi
2399
2400 local expansion=$(__git_aliased_command "$command")
2401 [ "$expansion" ] && command="$expansion"
2402
2403 case "$command" in
2404 am) _git_am ;;
2405 add) _git_add ;;
2406 apply) _git_apply ;;
2407 archive) _git_archive ;;
2408 bisect) _git_bisect ;;
2409 bundle) _git_bundle ;;
2410 branch) _git_branch ;;
2411 checkout) _git_checkout ;;
2412 cherry) _git_cherry ;;
2413 cherry-pick) _git_cherry_pick ;;
2414 clean) _git_clean ;;
2415 clone) _git_clone ;;
2416 commit) _git_commit ;;
2417 config) _git_config ;;
2418 describe) _git_describe ;;
2419 diff) _git_diff ;;
2420 difftool) _git_difftool ;;
2421 fetch) _git_fetch ;;
2422 format-patch) _git_format_patch ;;
2423 fsck) _git_fsck ;;
2424 gc) _git_gc ;;
2425 grep) _git_grep ;;
2426 help) _git_help ;;
2427 init) _git_init ;;
2428 log) _git_log ;;
2429 ls-files) _git_ls_files ;;
2430 ls-remote) _git_ls_remote ;;
2431 ls-tree) _git_ls_tree ;;
2432 merge) _git_merge;;
2433 mergetool) _git_mergetool;;
2434 merge-base) _git_merge_base ;;
2435 mv) _git_mv ;;
2436 name-rev) _git_name_rev ;;
2437 pull) _git_pull ;;
2438 push) _git_push ;;
2439 rebase) _git_rebase ;;
2440 remote) _git_remote ;;
2441 replace) _git_replace ;;
2442 reset) _git_reset ;;
2443 revert) _git_revert ;;
2444 rm) _git_rm ;;
2445 send-email) _git_send_email ;;
2446 shortlog) _git_shortlog ;;
2447 show) _git_show ;;
2448 show-branch) _git_show_branch ;;
2449 stash) _git_stash ;;
2450 stage) _git_add ;;
2451 submodule) _git_submodule ;;
2452 svn) _git_svn ;;
2453 tag) _git_tag ;;
2454 whatchanged) _git_log ;;
2455 *) COMPREPLY=() ;;
2456 esac
2457 }
2458
2459 _gitk ()
2460 {
2461 __git_has_doubledash && return
2462
2463 local cur="${COMP_WORDS[COMP_CWORD]}"
2464 local g="$(__gitdir)"
2465 local merge=""
2466 if [ -f "$g/MERGE_HEAD" ]; then
2467 merge="--merge"
2468 fi
2469 case "$cur" in
2470 --*)
2471 __gitcomp "
2472 $__git_log_common_options
2473 $__git_log_gitk_options
2474 $merge
2475 "
2476 return
2477 ;;
2478 esac
2479 __git_complete_revlist
2480 }
2481
2482 complete -o bashdefault -o default -o nospace -F _git git 2>/dev/null \
2483 || complete -o default -o nospace -F _git git
2484 complete -o bashdefault -o default -o nospace -F _gitk gitk 2>/dev/null \
2485 || complete -o default -o nospace -F _gitk gitk
2486
2487 # The following are necessary only for Cygwin, and only are needed
2488 # when the user has tab-completed the executable name and consequently
2489 # included the '.exe' suffix.
2490 #
2491 if [ Cygwin = "$(uname -o 2>/dev/null)" ]; then
2492 complete -o bashdefault -o default -o nospace -F _git git.exe 2>/dev/null \
2493 || complete -o default -o nospace -F _git git.exe
2494 fi
2495 #!/bin/bash
2496 # These are the standard set of aliases enabled by default in all
2497 # git-sh sessions. Aliases defined in the gitconfig [alias] section override
2498 # these.
2499
2500 gitalias a='git add'
2501 gitalias b='git branch'
2502 gitalias c='git checkout'
2503 gitalias d='git diff'
2504 gitalias f='git fetch --prune'
2505 gitalias k='git cherry-pick'
2506 gitalias l='git log --pretty=oneline --abbrev-commit'
2507 gitalias n='git commit --verbose --amend'
2508 gitalias r='git remote'
2509 gitalias s='git commit --dry-run --short'
2510 gitalias t='git diff --cached'
2511
2512 # git add and the staging area
2513 gitalias a='git add'
2514 gitalias aa='git add --update' # mnemonic: "add all"
2515 gitalias stage='git add'
2516 gitalias ap='git add --patch'
2517 gitalias p='git diff --cached' # mnemonic: "patch"
2518 gitalias ps='git diff --cached --stat' # mnemonic: "patch stat"
2519 gitalias unstage='git reset HEAD'
2520
2521 # commits and history
2522 gitalias ci='git commit --verbose'
2523 gitalias ca='git commit --verbose --all'
2524 gitalias amend='git commit --verbose --amend'
2525 gitalias n='git commit --verbose --amend'
2526 gitalias k='git cherry-pick'
2527 gitalias re='git rebase --interactive'
2528 gitalias pop='git reset --soft HEAD^'
2529 gitalias peek='git log -p --max-count=1'
2530
2531 # git fetch
2532 gitalias f='git fetch'
2533 gitalias pm='git pull' # mnemonic: pull merge
2534 gitalias pr='git pull --rebase' # mnemonic: pull rebase
2535
2536 # git diff
2537 gitalias d='git diff'
2538 gitalias ds='git diff --stat' # mnemonic: "diff stat"
2539
2540 # git reset
2541 gitalias hard='git reset --hard'
2542 gitalias soft='git reset --soft'
2543 gitalias scrap='git checkout HEAD'
2544
2545 # CONFIG ==============================================================
2546
2547 # load gitconfig [alias] section as top-level aliases.
2548 _git_import_aliases
2549
2550 # source the system-wide rc file
2551 [ -r /etc/gitshrc ] && . /etc/gitshrc
2552
2553 # source the user's rc file
2554 [ -r ~/.gitshrc ] && . ~/.gitshrc