2009-01-15 17:02:23 +01:00
|
|
|
#!bash
|
2006-09-28 11:31:25 +02:00
|
|
|
#
|
|
|
|
# bash completion support for core Git.
|
|
|
|
#
|
2007-05-24 07:36:46 +02:00
|
|
|
# Copyright (C) 2006,2007 Shawn O. Pearce <spearce@spearce.org>
|
2006-09-28 11:31:25 +02:00
|
|
|
# Conceptually based on gitcompletion (http://gitweb.hawaga.org.uk/).
|
2007-05-24 07:36:46 +02:00
|
|
|
# Distributed under the GNU General Public License, version 2.0.
|
2006-09-28 11:31:25 +02:00
|
|
|
#
|
|
|
|
# The contained completion routines provide support for completing:
|
|
|
|
#
|
|
|
|
# *) local and remote branch names
|
|
|
|
# *) local and remote tag names
|
|
|
|
# *) .git/remotes file names
|
|
|
|
# *) git 'subcommands'
|
|
|
|
# *) tree paths within 'ref:path/to/file' expressions
|
2007-05-24 07:36:46 +02:00
|
|
|
# *) common --long-options
|
2006-09-28 11:31:25 +02:00
|
|
|
#
|
|
|
|
# To use these routines:
|
|
|
|
#
|
|
|
|
# 1) Copy this file to somewhere (e.g. ~/.git-completion.sh).
|
|
|
|
# 2) Added the following line to your .bashrc:
|
|
|
|
# source ~/.git-completion.sh
|
|
|
|
#
|
2009-11-18 01:49:10 +01:00
|
|
|
# 3) Consider changing your PS1 to also show the current branch:
|
2006-11-27 09:41:28 +01:00
|
|
|
# PS1='[\u@\h \W$(__git_ps1 " (%s)")]\$ '
|
|
|
|
#
|
|
|
|
# The argument to __git_ps1 will be displayed only if you
|
|
|
|
# are currently in a git repository. The %s token will be
|
|
|
|
# the name of the current branch.
|
|
|
|
#
|
2009-02-06 17:05:38 +01:00
|
|
|
# In addition, if you set GIT_PS1_SHOWDIRTYSTATE to a nonempty
|
|
|
|
# value, unstaged (*) and staged (+) changes will be shown next
|
|
|
|
# to the branch name. You can configure this per-repository
|
|
|
|
# with the bash.showDirtyState variable, which defaults to true
|
|
|
|
# once GIT_PS1_SHOWDIRTYSTATE is enabled.
|
2009-02-03 10:20:54 +01:00
|
|
|
#
|
2009-06-02 20:03:22 +02:00
|
|
|
# You can also see if currently something is stashed, by setting
|
|
|
|
# GIT_PS1_SHOWSTASHSTATE to a nonempty value. If something is stashed,
|
|
|
|
# then a '$' will be shown next to the branch name.
|
|
|
|
#
|
2009-07-22 10:31:34 +02:00
|
|
|
# If you would like to see if there're untracked files, then you can
|
|
|
|
# set GIT_PS1_SHOWUNTRACKEDFILES to a nonempty value. If there're
|
|
|
|
# untracked files, then a '%' will be shown next to the branch name.
|
|
|
|
#
|
2007-05-24 07:36:46 +02:00
|
|
|
# To submit patches:
|
|
|
|
#
|
|
|
|
# *) Read Documentation/SubmittingPatches
|
|
|
|
# *) Send all patches to the current maintainer:
|
|
|
|
#
|
|
|
|
# "Shawn O. Pearce" <spearce@spearce.org>
|
|
|
|
#
|
|
|
|
# *) Always CC the Git mailing list:
|
|
|
|
#
|
|
|
|
# git@vger.kernel.org
|
|
|
|
#
|
2006-09-28 11:31:25 +02:00
|
|
|
|
2008-07-15 07:52:04 +02:00
|
|
|
case "$COMP_WORDBREAKS" in
|
|
|
|
*:*) : great ;;
|
|
|
|
*) COMP_WORDBREAKS="$COMP_WORDBREAKS:"
|
|
|
|
esac
|
|
|
|
|
2009-01-15 17:02:23 +01:00
|
|
|
# __gitdir accepts 0 or 1 arguments (i.e., location)
|
|
|
|
# returns location of .git repo
|
2006-11-05 12:21:57 +01:00
|
|
|
__gitdir ()
|
|
|
|
{
|
2009-01-15 17:02:21 +01:00
|
|
|
if [ -z "${1-}" ]; then
|
2009-02-11 19:03:26 +01:00
|
|
|
if [ -n "${__git_dir-}" ]; then
|
2006-11-28 18:12:26 +01:00
|
|
|
echo "$__git_dir"
|
|
|
|
elif [ -d .git ]; then
|
|
|
|
echo .git
|
|
|
|
else
|
|
|
|
git rev-parse --git-dir 2>/dev/null
|
|
|
|
fi
|
|
|
|
elif [ -d "$1/.git" ]; then
|
|
|
|
echo "$1/.git"
|
|
|
|
else
|
|
|
|
echo "$1"
|
|
|
|
fi
|
2006-11-05 12:21:57 +01:00
|
|
|
}
|
|
|
|
|
2009-01-15 17:02:23 +01:00
|
|
|
# __git_ps1 accepts 0 or 1 arguments (i.e., format string)
|
|
|
|
# returns text to add to bash PS1 prompt (includes branch name)
|
2006-11-27 09:41:28 +01:00
|
|
|
__git_ps1 ()
|
|
|
|
{
|
2009-02-11 19:03:23 +01:00
|
|
|
local g="$(__gitdir)"
|
2007-09-30 02:20:45 +02:00
|
|
|
if [ -n "$g" ]; then
|
|
|
|
local r
|
|
|
|
local b
|
2009-05-26 07:56:03 +02:00
|
|
|
if [ -f "$g/rebase-merge/interactive" ]; then
|
2007-09-30 02:20:45 +02:00
|
|
|
r="|REBASE-i"
|
2008-07-16 03:33:44 +02:00
|
|
|
b="$(cat "$g/rebase-merge/head-name")"
|
2009-02-11 19:03:24 +01:00
|
|
|
elif [ -d "$g/rebase-merge" ]; then
|
2007-09-30 02:20:45 +02:00
|
|
|
r="|REBASE-m"
|
2008-07-16 03:33:44 +02:00
|
|
|
b="$(cat "$g/rebase-merge/head-name")"
|
2007-09-30 02:20:45 +02:00
|
|
|
else
|
2009-05-26 07:56:03 +02:00
|
|
|
if [ -d "$g/rebase-apply" ]; then
|
|
|
|
if [ -f "$g/rebase-apply/rebasing" ]; then
|
|
|
|
r="|REBASE"
|
|
|
|
elif [ -f "$g/rebase-apply/applying" ]; then
|
|
|
|
r="|AM"
|
|
|
|
else
|
|
|
|
r="|AM/REBASE"
|
|
|
|
fi
|
|
|
|
elif [ -f "$g/MERGE_HEAD" ]; then
|
2009-05-16 20:46:22 +02:00
|
|
|
r="|MERGING"
|
2009-05-26 07:56:03 +02:00
|
|
|
elif [ -f "$g/BISECT_LOG" ]; then
|
2007-09-30 02:20:45 +02:00
|
|
|
r="|BISECTING"
|
|
|
|
fi
|
2009-05-10 10:53:19 +02:00
|
|
|
|
|
|
|
b="$(git symbolic-ref HEAD 2>/dev/null)" || {
|
2009-05-10 10:56:21 +02:00
|
|
|
|
|
|
|
b="$(
|
|
|
|
case "${GIT_PS1_DESCRIBE_STYLE-}" in
|
|
|
|
(contains)
|
|
|
|
git describe --contains HEAD ;;
|
|
|
|
(branch)
|
|
|
|
git describe --contains --all HEAD ;;
|
|
|
|
(describe)
|
|
|
|
git describe HEAD ;;
|
|
|
|
(* | default)
|
|
|
|
git describe --exact-match HEAD ;;
|
|
|
|
esac 2>/dev/null)" ||
|
|
|
|
|
2009-05-10 10:53:19 +02:00
|
|
|
b="$(cut -c1-7 "$g/HEAD" 2>/dev/null)..." ||
|
|
|
|
b="unknown"
|
|
|
|
b="($b)"
|
|
|
|
}
|
2007-09-30 02:20:45 +02:00
|
|
|
fi
|
|
|
|
|
2009-02-03 10:20:54 +01:00
|
|
|
local w
|
|
|
|
local i
|
2009-06-02 20:03:22 +02:00
|
|
|
local s
|
2009-07-22 10:31:34 +02:00
|
|
|
local u
|
2009-02-21 15:48:43 +01:00
|
|
|
local c
|
2009-02-03 10:20:54 +01:00
|
|
|
|
2009-02-11 19:03:25 +01:00
|
|
|
if [ "true" = "$(git rev-parse --is-inside-git-dir 2>/dev/null)" ]; then
|
2009-05-18 18:24:30 +02:00
|
|
|
if [ "true" = "$(git rev-parse --is-bare-repository 2>/dev/null)" ]; then
|
2009-02-21 15:48:43 +01:00
|
|
|
c="BARE:"
|
|
|
|
else
|
|
|
|
b="GIT_DIR!"
|
|
|
|
fi
|
2009-02-11 19:03:25 +01:00
|
|
|
elif [ "true" = "$(git rev-parse --is-inside-work-tree 2>/dev/null)" ]; then
|
|
|
|
if [ -n "${GIT_PS1_SHOWDIRTYSTATE-}" ]; then
|
|
|
|
if [ "$(git config --bool bash.showDirtyState)" != "false" ]; then
|
2009-12-31 12:48:41 +01:00
|
|
|
git diff --no-ext-diff --quiet --exit-code || w="*"
|
2009-02-11 19:03:25 +01:00
|
|
|
if git rev-parse --quiet --verify HEAD >/dev/null; then
|
2009-12-31 12:48:41 +01:00
|
|
|
git diff-index --cached --quiet HEAD -- || i="+"
|
2009-02-11 19:03:25 +01:00
|
|
|
else
|
|
|
|
i="#"
|
|
|
|
fi
|
2009-02-03 10:20:54 +01:00
|
|
|
fi
|
|
|
|
fi
|
2009-06-02 20:03:22 +02:00
|
|
|
if [ -n "${GIT_PS1_SHOWSTASHSTATE-}" ]; then
|
|
|
|
git rev-parse --verify refs/stash >/dev/null 2>&1 && s="$"
|
|
|
|
fi
|
2009-07-22 10:31:34 +02:00
|
|
|
|
|
|
|
if [ -n "${GIT_PS1_SHOWUNTRACKEDFILES-}" ]; then
|
|
|
|
if [ -n "$(git ls-files --others --exclude-standard)" ]; then
|
|
|
|
u="%"
|
|
|
|
fi
|
|
|
|
fi
|
2009-02-03 10:20:54 +01:00
|
|
|
fi
|
|
|
|
|
2009-12-31 04:04:38 +01:00
|
|
|
local f="$w$i$s$u"
|
|
|
|
printf "${1:- (%s)}" "$c${b##refs/heads/}${f:+ $f}$r"
|
2006-11-27 09:41:28 +01:00
|
|
|
fi
|
|
|
|
}
|
|
|
|
|
2009-01-15 17:02:23 +01:00
|
|
|
# __gitcomp_1 requires 2 arguments
|
2008-07-13 04:37:42 +02:00
|
|
|
__gitcomp_1 ()
|
|
|
|
{
|
|
|
|
local c IFS=' '$'\t'$'\n'
|
|
|
|
for c in $1; do
|
|
|
|
case "$c$2" in
|
|
|
|
--*=*) printf %s$'\n' "$c$2" ;;
|
|
|
|
*.) printf %s$'\n' "$c$2" ;;
|
|
|
|
*) printf %s$'\n' "$c$2 " ;;
|
|
|
|
esac
|
|
|
|
done
|
|
|
|
}
|
|
|
|
|
2009-01-15 17:02:23 +01:00
|
|
|
# __gitcomp accepts 1, 2, 3, or 4 arguments
|
|
|
|
# generates completion reply with compgen
|
2007-02-04 08:38:27 +01:00
|
|
|
__gitcomp ()
|
|
|
|
{
|
2007-02-04 08:38:37 +01:00
|
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
2007-02-04 08:38:43 +01:00
|
|
|
if [ $# -gt 2 ]; then
|
2007-02-04 08:38:37 +01:00
|
|
|
cur="$3"
|
|
|
|
fi
|
2008-03-05 20:07:49 +01:00
|
|
|
case "$cur" in
|
|
|
|
--*=)
|
|
|
|
COMPREPLY=()
|
|
|
|
;;
|
|
|
|
*)
|
2008-07-13 04:37:42 +02:00
|
|
|
local IFS=$'\n'
|
2009-01-15 17:02:21 +01:00
|
|
|
COMPREPLY=($(compgen -P "${2-}" \
|
|
|
|
-W "$(__gitcomp_1 "${1-}" "${4-}")" \
|
2008-07-13 04:37:42 +02:00
|
|
|
-- "$cur"))
|
2008-03-05 20:07:49 +01:00
|
|
|
;;
|
|
|
|
esac
|
2007-02-04 08:38:27 +01:00
|
|
|
}
|
|
|
|
|
2009-01-15 17:02:23 +01:00
|
|
|
# __git_heads accepts 0 or 1 arguments (to pass to __gitdir)
|
2006-11-27 10:44:47 +01:00
|
|
|
__git_heads ()
|
|
|
|
{
|
2009-01-15 17:02:21 +01:00
|
|
|
local cmd i is_hash=y dir="$(__gitdir "${1-}")"
|
2006-11-27 10:44:47 +01:00
|
|
|
if [ -d "$dir" ]; then
|
2008-09-20 00:15:25 +02:00
|
|
|
git --git-dir="$dir" for-each-ref --format='%(refname:short)' \
|
|
|
|
refs/heads
|
2006-11-27 10:44:47 +01:00
|
|
|
return
|
|
|
|
fi
|
2009-01-15 17:02:21 +01:00
|
|
|
for i in $(git ls-remote "${1-}" 2>/dev/null); do
|
2006-11-27 10:44:47 +01:00
|
|
|
case "$is_hash,$i" in
|
|
|
|
y,*) is_hash=n ;;
|
|
|
|
n,*^{}) is_hash=y ;;
|
|
|
|
n,refs/heads/*) is_hash=y; echo "${i#refs/heads/}" ;;
|
|
|
|
n,*) is_hash=y; echo "$i" ;;
|
|
|
|
esac
|
|
|
|
done
|
|
|
|
}
|
|
|
|
|
2009-01-15 17:02:23 +01:00
|
|
|
# __git_tags accepts 0 or 1 arguments (to pass to __gitdir)
|
2007-09-01 05:47:01 +02:00
|
|
|
__git_tags ()
|
|
|
|
{
|
2009-01-15 17:02:21 +01:00
|
|
|
local cmd i is_hash=y dir="$(__gitdir "${1-}")"
|
2007-09-01 05:47:01 +02:00
|
|
|
if [ -d "$dir" ]; then
|
2008-09-20 00:15:25 +02:00
|
|
|
git --git-dir="$dir" for-each-ref --format='%(refname:short)' \
|
|
|
|
refs/tags
|
2007-09-01 05:47:01 +02:00
|
|
|
return
|
|
|
|
fi
|
2009-01-15 17:02:21 +01:00
|
|
|
for i in $(git ls-remote "${1-}" 2>/dev/null); do
|
2007-09-01 05:47:01 +02:00
|
|
|
case "$is_hash,$i" in
|
|
|
|
y,*) is_hash=n ;;
|
|
|
|
n,*^{}) is_hash=y ;;
|
|
|
|
n,refs/tags/*) is_hash=y; echo "${i#refs/tags/}" ;;
|
|
|
|
n,*) is_hash=y; echo "$i" ;;
|
|
|
|
esac
|
|
|
|
done
|
|
|
|
}
|
|
|
|
|
2009-01-15 17:02:23 +01:00
|
|
|
# __git_refs accepts 0 or 1 arguments (to pass to __gitdir)
|
2006-09-28 11:31:25 +02:00
|
|
|
__git_refs ()
|
|
|
|
{
|
2009-01-15 17:02:21 +01:00
|
|
|
local i is_hash=y dir="$(__gitdir "${1-}")"
|
2008-11-28 01:46:38 +01:00
|
|
|
local cur="${COMP_WORDS[COMP_CWORD]}" format refs
|
2006-11-05 12:21:57 +01:00
|
|
|
if [ -d "$dir" ]; then
|
2008-11-28 01:46:38 +01:00
|
|
|
case "$cur" in
|
|
|
|
refs|refs/*)
|
|
|
|
format="refname"
|
|
|
|
refs="${cur%/*}"
|
|
|
|
;;
|
|
|
|
*)
|
2010-03-17 10:20:35 +01:00
|
|
|
for i in HEAD FETCH_HEAD ORIG_HEAD MERGE_HEAD; do
|
|
|
|
if [ -e "$dir/$i" ]; then echo $i; fi
|
|
|
|
done
|
2008-11-28 01:46:38 +01:00
|
|
|
format="refname:short"
|
|
|
|
refs="refs/tags refs/heads refs/remotes"
|
|
|
|
;;
|
|
|
|
esac
|
|
|
|
git --git-dir="$dir" for-each-ref --format="%($format)" \
|
|
|
|
$refs
|
2006-11-27 09:42:32 +01:00
|
|
|
return
|
2006-09-28 11:31:25 +02:00
|
|
|
fi
|
2008-04-20 19:28:44 +02:00
|
|
|
for i in $(git ls-remote "$dir" 2>/dev/null); do
|
2006-09-28 11:31:25 +02:00
|
|
|
case "$is_hash,$i" in
|
|
|
|
y,*) is_hash=n ;;
|
|
|
|
n,*^{}) is_hash=y ;;
|
|
|
|
n,refs/tags/*) is_hash=y; echo "${i#refs/tags/}" ;;
|
|
|
|
n,refs/heads/*) is_hash=y; echo "${i#refs/heads/}" ;;
|
2006-11-27 09:42:32 +01:00
|
|
|
n,refs/remotes/*) is_hash=y; echo "${i#refs/remotes/}" ;;
|
2006-09-28 11:31:25 +02:00
|
|
|
n,*) is_hash=y; echo "$i" ;;
|
|
|
|
esac
|
|
|
|
done
|
|
|
|
}
|
|
|
|
|
2009-01-15 17:02:23 +01:00
|
|
|
# __git_refs2 requires 1 argument (to pass to __git_refs)
|
2006-09-28 11:31:25 +02:00
|
|
|
__git_refs2 ()
|
|
|
|
{
|
2006-11-28 18:12:26 +01:00
|
|
|
local i
|
|
|
|
for i in $(__git_refs "$1"); do
|
|
|
|
echo "$i:$i"
|
2006-09-28 11:31:25 +02:00
|
|
|
done
|
|
|
|
}
|
|
|
|
|
2009-01-15 17:02:23 +01:00
|
|
|
# __git_refs_remotes requires 1 argument (to pass to ls-remote)
|
2006-11-27 10:44:47 +01:00
|
|
|
__git_refs_remotes ()
|
|
|
|
{
|
|
|
|
local cmd i is_hash=y
|
2008-04-20 19:28:44 +02:00
|
|
|
for i in $(git ls-remote "$1" 2>/dev/null); do
|
2006-11-27 10:44:47 +01:00
|
|
|
case "$is_hash,$i" in
|
|
|
|
n,refs/heads/*)
|
|
|
|
is_hash=y
|
|
|
|
echo "$i:refs/remotes/$1/${i#refs/heads/}"
|
|
|
|
;;
|
|
|
|
y,*) is_hash=n ;;
|
|
|
|
n,*^{}) is_hash=y ;;
|
|
|
|
n,refs/tags/*) is_hash=y;;
|
|
|
|
n,*) is_hash=y; ;;
|
|
|
|
esac
|
|
|
|
done
|
|
|
|
}
|
|
|
|
|
2006-09-28 11:31:25 +02:00
|
|
|
__git_remotes ()
|
|
|
|
{
|
2006-11-05 12:21:57 +01:00
|
|
|
local i ngoff IFS=$'\n' d="$(__gitdir)"
|
2006-11-05 12:21:03 +01:00
|
|
|
shopt -q nullglob || ngoff=1
|
2006-09-28 11:31:25 +02:00
|
|
|
shopt -s nullglob
|
2006-11-05 12:21:57 +01:00
|
|
|
for i in "$d/remotes"/*; do
|
|
|
|
echo ${i#$d/remotes/}
|
2006-09-28 11:31:25 +02:00
|
|
|
done
|
2006-11-05 12:21:03 +01:00
|
|
|
[ "$ngoff" ] && shopt -u nullglob
|
2009-09-12 01:23:45 +02:00
|
|
|
for i in $(git --git-dir="$d" config --get-regexp 'remote\..*\.url' 2>/dev/null); do
|
|
|
|
i="${i#remote.}"
|
|
|
|
echo "${i/.url*/}"
|
2006-11-05 12:21:03 +01:00
|
|
|
done
|
2006-09-28 11:31:25 +02:00
|
|
|
}
|
|
|
|
|
2009-11-18 01:49:10 +01:00
|
|
|
__git_list_merge_strategies ()
|
2006-11-27 09:40:47 +01:00
|
|
|
{
|
2008-08-20 23:13:42 +02:00
|
|
|
git merge -s help 2>&1 |
|
|
|
|
sed -n -e '/[Aa]vailable strategies are: /,/^$/{
|
|
|
|
s/\.$//
|
|
|
|
s/.*://
|
|
|
|
s/^[ ]*//
|
|
|
|
s/[ ]*$//
|
2006-11-27 09:40:47 +01:00
|
|
|
p
|
2008-08-20 23:13:42 +02:00
|
|
|
}'
|
2006-11-27 09:40:47 +01:00
|
|
|
}
|
2009-11-18 01:49:10 +01:00
|
|
|
|
|
|
|
__git_merge_strategies=
|
|
|
|
# 'git merge -s help' (and thus detection of the merge strategy
|
|
|
|
# list) fails, unfortunately, if run outside of any git working
|
|
|
|
# tree. __git_merge_strategies is set to the empty string in
|
|
|
|
# that case, and the detection will be repeated the next time it
|
|
|
|
# is needed.
|
|
|
|
__git_compute_merge_strategies ()
|
|
|
|
{
|
|
|
|
: ${__git_merge_strategies:=$(__git_list_merge_strategies)}
|
|
|
|
}
|
2006-11-27 09:40:47 +01:00
|
|
|
|
2006-09-28 11:31:25 +02:00
|
|
|
__git_complete_file ()
|
|
|
|
{
|
2006-11-05 12:25:25 +01:00
|
|
|
local pfx ls ref cur="${COMP_WORDS[COMP_CWORD]}"
|
2006-09-28 11:31:25 +02:00
|
|
|
case "$cur" in
|
|
|
|
?*:*)
|
2006-11-05 12:25:25 +01:00
|
|
|
ref="${cur%%:*}"
|
|
|
|
cur="${cur#*:}"
|
2006-09-28 11:31:25 +02:00
|
|
|
case "$cur" in
|
|
|
|
?*/*)
|
2006-11-05 12:25:25 +01:00
|
|
|
pfx="${cur%/*}"
|
|
|
|
cur="${cur##*/}"
|
2006-09-28 11:31:25 +02:00
|
|
|
ls="$ref:$pfx"
|
|
|
|
pfx="$pfx/"
|
|
|
|
;;
|
|
|
|
*)
|
|
|
|
ls="$ref"
|
|
|
|
;;
|
|
|
|
esac
|
2008-07-15 07:52:04 +02:00
|
|
|
|
|
|
|
case "$COMP_WORDBREAKS" in
|
|
|
|
*:*) : great ;;
|
|
|
|
*) pfx="$ref:$pfx" ;;
|
|
|
|
esac
|
|
|
|
|
2008-07-14 02:22:03 +02:00
|
|
|
local IFS=$'\n'
|
2006-09-28 11:31:25 +02:00
|
|
|
COMPREPLY=($(compgen -P "$pfx" \
|
2006-11-05 12:21:57 +01:00
|
|
|
-W "$(git --git-dir="$(__gitdir)" ls-tree "$ls" \
|
2008-07-14 02:22:03 +02:00
|
|
|
| sed '/^100... blob /{
|
|
|
|
s,^.* ,,
|
|
|
|
s,$, ,
|
|
|
|
}
|
|
|
|
/^120000 blob /{
|
|
|
|
s,^.* ,,
|
|
|
|
s,$, ,
|
|
|
|
}
|
2006-09-28 11:31:25 +02:00
|
|
|
/^040000 tree /{
|
|
|
|
s,^.* ,,
|
|
|
|
s,$,/,
|
|
|
|
}
|
|
|
|
s/^.* //')" \
|
|
|
|
-- "$cur"))
|
|
|
|
;;
|
|
|
|
*)
|
2007-02-04 08:38:43 +01:00
|
|
|
__gitcomp "$(__git_refs)"
|
2006-09-28 11:31:25 +02:00
|
|
|
;;
|
|
|
|
esac
|
|
|
|
}
|
|
|
|
|
2006-11-27 09:41:43 +01:00
|
|
|
__git_complete_revlist ()
|
|
|
|
{
|
|
|
|
local pfx cur="${COMP_WORDS[COMP_CWORD]}"
|
|
|
|
case "$cur" in
|
|
|
|
*...*)
|
|
|
|
pfx="${cur%...*}..."
|
|
|
|
cur="${cur#*...}"
|
2007-02-04 08:38:43 +01:00
|
|
|
__gitcomp "$(__git_refs)" "$pfx" "$cur"
|
2006-11-27 09:41:43 +01:00
|
|
|
;;
|
|
|
|
*..*)
|
|
|
|
pfx="${cur%..*}.."
|
|
|
|
cur="${cur#*..}"
|
2007-02-04 08:38:43 +01:00
|
|
|
__gitcomp "$(__git_refs)" "$pfx" "$cur"
|
|
|
|
;;
|
2006-11-27 09:41:43 +01:00
|
|
|
*)
|
2007-02-04 08:38:43 +01:00
|
|
|
__gitcomp "$(__git_refs)"
|
2006-11-27 09:41:43 +01:00
|
|
|
;;
|
|
|
|
esac
|
|
|
|
}
|
|
|
|
|
2009-03-06 05:39:31 +01:00
|
|
|
__git_complete_remote_or_refspec ()
|
|
|
|
{
|
|
|
|
local cmd="${COMP_WORDS[1]}"
|
|
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
2009-03-06 05:39:33 +01:00
|
|
|
local i c=2 remote="" pfx="" lhs=1 no_complete_refspec=0
|
2009-03-06 05:39:31 +01:00
|
|
|
while [ $c -lt $COMP_CWORD ]; do
|
|
|
|
i="${COMP_WORDS[c]}"
|
|
|
|
case "$i" in
|
2009-12-12 11:21:46 +01:00
|
|
|
--mirror) [ "$cmd" = "push" ] && no_complete_refspec=1 ;;
|
|
|
|
--all)
|
|
|
|
case "$cmd" in
|
|
|
|
push) no_complete_refspec=1 ;;
|
|
|
|
fetch)
|
|
|
|
COMPREPLY=()
|
|
|
|
return
|
|
|
|
;;
|
|
|
|
*) ;;
|
|
|
|
esac
|
|
|
|
;;
|
2009-03-06 05:39:31 +01:00
|
|
|
-*) ;;
|
|
|
|
*) remote="$i"; break ;;
|
|
|
|
esac
|
|
|
|
c=$((++c))
|
|
|
|
done
|
|
|
|
if [ -z "$remote" ]; then
|
|
|
|
__gitcomp "$(__git_remotes)"
|
|
|
|
return
|
|
|
|
fi
|
2009-03-06 05:39:33 +01:00
|
|
|
if [ $no_complete_refspec = 1 ]; then
|
|
|
|
COMPREPLY=()
|
|
|
|
return
|
|
|
|
fi
|
2009-03-06 05:39:31 +01:00
|
|
|
[ "$remote" = "." ] && remote=
|
|
|
|
case "$cur" in
|
|
|
|
*:*)
|
|
|
|
case "$COMP_WORDBREAKS" in
|
|
|
|
*:*) : great ;;
|
|
|
|
*) pfx="${cur%%:*}:" ;;
|
|
|
|
esac
|
|
|
|
cur="${cur#*:}"
|
|
|
|
lhs=0
|
|
|
|
;;
|
|
|
|
+*)
|
|
|
|
pfx="+"
|
|
|
|
cur="${cur#+}"
|
|
|
|
;;
|
|
|
|
esac
|
|
|
|
case "$cmd" in
|
|
|
|
fetch)
|
|
|
|
if [ $lhs = 1 ]; then
|
|
|
|
__gitcomp "$(__git_refs2 "$remote")" "$pfx" "$cur"
|
|
|
|
else
|
|
|
|
__gitcomp "$(__git_refs)" "$pfx" "$cur"
|
|
|
|
fi
|
|
|
|
;;
|
|
|
|
pull)
|
|
|
|
if [ $lhs = 1 ]; then
|
|
|
|
__gitcomp "$(__git_refs "$remote")" "$pfx" "$cur"
|
|
|
|
else
|
|
|
|
__gitcomp "$(__git_refs)" "$pfx" "$cur"
|
|
|
|
fi
|
|
|
|
;;
|
|
|
|
push)
|
|
|
|
if [ $lhs = 1 ]; then
|
|
|
|
__gitcomp "$(__git_refs)" "$pfx" "$cur"
|
|
|
|
else
|
|
|
|
__gitcomp "$(__git_refs "$remote")" "$pfx" "$cur"
|
|
|
|
fi
|
|
|
|
;;
|
|
|
|
esac
|
|
|
|
}
|
|
|
|
|
2009-03-06 17:30:44 +01:00
|
|
|
__git_complete_strategy ()
|
|
|
|
{
|
2009-11-18 01:49:10 +01:00
|
|
|
__git_compute_merge_strategies
|
2009-03-06 17:30:44 +01:00
|
|
|
case "${COMP_WORDS[COMP_CWORD-1]}" in
|
|
|
|
-s|--strategy)
|
2009-11-18 01:49:10 +01:00
|
|
|
__gitcomp "$__git_merge_strategies"
|
2009-03-06 17:30:44 +01:00
|
|
|
return 0
|
|
|
|
esac
|
|
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
|
|
case "$cur" in
|
|
|
|
--strategy=*)
|
2009-11-18 01:49:10 +01:00
|
|
|
__gitcomp "$__git_merge_strategies" "" "${cur##--strategy=}"
|
2009-03-06 17:30:44 +01:00
|
|
|
return 0
|
|
|
|
;;
|
|
|
|
esac
|
|
|
|
return 1
|
|
|
|
}
|
|
|
|
|
2009-11-18 01:49:10 +01:00
|
|
|
__git_list_all_commands ()
|
2006-11-27 09:41:01 +01:00
|
|
|
{
|
|
|
|
local i IFS=" "$'\n'
|
2009-10-09 08:21:43 +02:00
|
|
|
for i in $(git help -a|egrep '^ [a-zA-Z0-9]')
|
2008-07-24 02:07:23 +02:00
|
|
|
do
|
|
|
|
case $i in
|
|
|
|
*--*) : helper pattern;;
|
|
|
|
*) echo $i;;
|
|
|
|
esac
|
|
|
|
done
|
|
|
|
}
|
|
|
|
|
2009-11-18 01:49:10 +01:00
|
|
|
__git_all_commands=
|
|
|
|
__git_compute_all_commands ()
|
|
|
|
{
|
|
|
|
: ${__git_all_commands:=$(__git_list_all_commands)}
|
|
|
|
}
|
|
|
|
|
|
|
|
__git_list_porcelain_commands ()
|
2008-07-24 02:07:23 +02:00
|
|
|
{
|
|
|
|
local i IFS=" "$'\n'
|
2009-11-18 01:49:10 +01:00
|
|
|
__git_compute_all_commands
|
|
|
|
for i in "help" $__git_all_commands
|
2006-11-27 09:41:01 +01:00
|
|
|
do
|
|
|
|
case $i in
|
2007-12-15 12:11:54 +01:00
|
|
|
*--*) : helper pattern;;
|
2007-02-04 08:38:30 +01:00
|
|
|
applymbox) : ask gittus;;
|
|
|
|
applypatch) : ask gittus;;
|
|
|
|
archimport) : import;;
|
2007-02-04 08:38:21 +01:00
|
|
|
cat-file) : plumbing;;
|
2007-05-19 23:35:21 +02:00
|
|
|
check-attr) : plumbing;;
|
2006-11-27 09:41:01 +01:00
|
|
|
check-ref-format) : plumbing;;
|
2008-08-26 19:11:44 +02:00
|
|
|
checkout-index) : plumbing;;
|
2006-11-27 09:41:01 +01:00
|
|
|
commit-tree) : plumbing;;
|
2008-08-26 19:11:44 +02:00
|
|
|
count-objects) : infrequent;;
|
2007-02-04 08:38:30 +01:00
|
|
|
cvsexportcommit) : export;;
|
|
|
|
cvsimport) : import;;
|
2006-11-27 09:41:01 +01:00
|
|
|
cvsserver) : daemon;;
|
|
|
|
daemon) : daemon;;
|
2007-05-24 07:01:02 +02:00
|
|
|
diff-files) : plumbing;;
|
|
|
|
diff-index) : plumbing;;
|
|
|
|
diff-tree) : plumbing;;
|
2007-02-12 01:55:22 +01:00
|
|
|
fast-import) : import;;
|
2008-08-26 19:11:44 +02:00
|
|
|
fast-export) : export;;
|
2007-02-04 08:38:30 +01:00
|
|
|
fsck-objects) : plumbing;;
|
2006-11-27 09:41:01 +01:00
|
|
|
fetch-pack) : plumbing;;
|
2007-02-04 08:38:30 +01:00
|
|
|
fmt-merge-msg) : plumbing;;
|
2007-05-19 23:35:21 +02:00
|
|
|
for-each-ref) : plumbing;;
|
2006-11-27 09:41:01 +01:00
|
|
|
hash-object) : plumbing;;
|
|
|
|
http-*) : transport;;
|
|
|
|
index-pack) : plumbing;;
|
2007-02-04 08:38:30 +01:00
|
|
|
init-db) : deprecated;;
|
2006-11-27 09:41:01 +01:00
|
|
|
local-fetch) : plumbing;;
|
2008-08-26 19:11:44 +02:00
|
|
|
lost-found) : infrequent;;
|
|
|
|
ls-files) : plumbing;;
|
|
|
|
ls-remote) : plumbing;;
|
|
|
|
ls-tree) : plumbing;;
|
2006-11-27 09:41:01 +01:00
|
|
|
mailinfo) : plumbing;;
|
|
|
|
mailsplit) : plumbing;;
|
|
|
|
merge-*) : plumbing;;
|
|
|
|
mktree) : plumbing;;
|
|
|
|
mktag) : plumbing;;
|
|
|
|
pack-objects) : plumbing;;
|
|
|
|
pack-redundant) : plumbing;;
|
|
|
|
pack-refs) : plumbing;;
|
|
|
|
parse-remote) : plumbing;;
|
|
|
|
patch-id) : plumbing;;
|
|
|
|
peek-remote) : plumbing;;
|
2007-02-04 08:38:30 +01:00
|
|
|
prune) : plumbing;;
|
|
|
|
prune-packed) : plumbing;;
|
|
|
|
quiltimport) : import;;
|
2006-11-27 09:41:01 +01:00
|
|
|
read-tree) : plumbing;;
|
|
|
|
receive-pack) : plumbing;;
|
2007-02-04 08:38:21 +01:00
|
|
|
reflog) : plumbing;;
|
2010-01-22 11:54:51 +01:00
|
|
|
remote-*) : transport;;
|
2008-01-18 07:52:40 +01:00
|
|
|
repo-config) : deprecated;;
|
2006-11-27 09:41:01 +01:00
|
|
|
rerere) : plumbing;;
|
|
|
|
rev-list) : plumbing;;
|
|
|
|
rev-parse) : plumbing;;
|
|
|
|
runstatus) : plumbing;;
|
|
|
|
sh-setup) : internal;;
|
|
|
|
shell) : daemon;;
|
2008-08-26 19:11:44 +02:00
|
|
|
show-ref) : plumbing;;
|
2006-11-27 09:41:01 +01:00
|
|
|
send-pack) : plumbing;;
|
|
|
|
show-index) : plumbing;;
|
|
|
|
ssh-*) : transport;;
|
|
|
|
stripspace) : plumbing;;
|
|
|
|
symbolic-ref) : plumbing;;
|
2007-02-04 08:38:30 +01:00
|
|
|
tar-tree) : deprecated;;
|
2006-11-27 09:41:01 +01:00
|
|
|
unpack-file) : plumbing;;
|
|
|
|
unpack-objects) : plumbing;;
|
2007-02-04 08:38:30 +01:00
|
|
|
update-index) : plumbing;;
|
2006-11-27 09:41:01 +01:00
|
|
|
update-ref) : plumbing;;
|
|
|
|
update-server-info) : daemon;;
|
|
|
|
upload-archive) : plumbing;;
|
|
|
|
upload-pack) : plumbing;;
|
|
|
|
write-tree) : plumbing;;
|
2008-08-26 19:11:44 +02:00
|
|
|
var) : infrequent;;
|
|
|
|
verify-pack) : infrequent;;
|
2007-02-04 08:38:30 +01:00
|
|
|
verify-tag) : plumbing;;
|
2006-11-27 09:41:01 +01:00
|
|
|
*) echo $i;;
|
|
|
|
esac
|
|
|
|
done
|
|
|
|
}
|
2009-11-18 01:49:10 +01:00
|
|
|
|
|
|
|
__git_porcelain_commands=
|
|
|
|
__git_compute_porcelain_commands ()
|
|
|
|
{
|
|
|
|
__git_compute_all_commands
|
|
|
|
: ${__git_porcelain_commands:=$(__git_list_porcelain_commands)}
|
|
|
|
}
|
2006-11-27 09:41:01 +01:00
|
|
|
|
2006-10-28 14:12:20 +02:00
|
|
|
__git_aliases ()
|
|
|
|
{
|
2006-11-05 12:21:03 +01:00
|
|
|
local i IFS=$'\n'
|
2009-09-12 01:23:45 +02:00
|
|
|
for i in $(git --git-dir="$(__gitdir)" config --get-regexp "alias\..*" 2>/dev/null); do
|
2009-10-09 08:21:44 +02:00
|
|
|
case "$i" in
|
|
|
|
alias.*)
|
|
|
|
i="${i#alias.}"
|
|
|
|
echo "${i/ */}"
|
|
|
|
;;
|
|
|
|
esac
|
2006-11-05 12:21:03 +01:00
|
|
|
done
|
2006-10-28 14:12:20 +02:00
|
|
|
}
|
|
|
|
|
2009-01-15 17:02:23 +01:00
|
|
|
# __git_aliased_command requires 1 argument
|
2006-10-28 14:12:20 +02:00
|
|
|
__git_aliased_command ()
|
|
|
|
{
|
2006-11-05 12:21:57 +01:00
|
|
|
local word cmdline=$(git --git-dir="$(__gitdir)" \
|
2007-01-29 01:16:53 +01:00
|
|
|
config --get "alias.$1")
|
2006-10-28 14:12:20 +02:00
|
|
|
for word in $cmdline; do
|
bash: improve aliased command recognition
To support completion for aliases, the completion script tries to
figure out which git command is invoked by an alias. Its
implementation in __git_aliased_command() is rather straightforward:
it returns the first word from the alias. For simple aliases starting
with the git command (e.g. alias.last = cat-file commit HEAD) this
gives the right results. Unfortunately, it does not work with shell
command aliases, which can get rather complex, as illustrated by one
of Junio's aliases:
[alias]
lgm = "!sh -c 'GIT_NOTES_REF=refs/notes/amlog git log \"$@\" || :' -"
In this case the current implementation returns "!sh" as the aliased
git command, which is obviosly wrong.
The full parsing of a shell command alias like that in the completion
code is clearly unfeasible. However, we can easily improve on aliased
command recognition by eleminating stuff that is definitely not a git
command: shell commands (anything starting with '!'), command line
options (anything starting with '-'), environment variables (anything
with a '=' in it), and git itself. This way the above alias would be
handled correctly, and the completion script would correctly recognize
"log" as the aliased git command.
Of course, this solution is not perfect either, and could be fooled
easily. It's not hard to construct an alias, in which a word does not
match any of these filter patterns, but is still not a git command
(e.g. by setting an environment variable to a value which contains
spaces). It may even return false positives, when the output of a git
command is piped into an other git command, and the second gets the
command line options via $@, but options for the first one are
offered. However, the following patches will enable the user to
supply custom completion scripts for aliases, which can be used to
remedy these problematic cases.
Signed-off-by: SZEDER Gábor <szeder@ira.uka.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-02-23 22:02:57 +01:00
|
|
|
case "$word" in
|
2010-02-23 22:03:00 +01:00
|
|
|
\!gitk|gitk)
|
|
|
|
echo "gitk"
|
2006-10-28 14:12:20 +02:00
|
|
|
return
|
2010-02-23 22:03:00 +01:00
|
|
|
;;
|
bash: improve aliased command recognition
To support completion for aliases, the completion script tries to
figure out which git command is invoked by an alias. Its
implementation in __git_aliased_command() is rather straightforward:
it returns the first word from the alias. For simple aliases starting
with the git command (e.g. alias.last = cat-file commit HEAD) this
gives the right results. Unfortunately, it does not work with shell
command aliases, which can get rather complex, as illustrated by one
of Junio's aliases:
[alias]
lgm = "!sh -c 'GIT_NOTES_REF=refs/notes/amlog git log \"$@\" || :' -"
In this case the current implementation returns "!sh" as the aliased
git command, which is obviosly wrong.
The full parsing of a shell command alias like that in the completion
code is clearly unfeasible. However, we can easily improve on aliased
command recognition by eleminating stuff that is definitely not a git
command: shell commands (anything starting with '!'), command line
options (anything starting with '-'), environment variables (anything
with a '=' in it), and git itself. This way the above alias would be
handled correctly, and the completion script would correctly recognize
"log" as the aliased git command.
Of course, this solution is not perfect either, and could be fooled
easily. It's not hard to construct an alias, in which a word does not
match any of these filter patterns, but is still not a git command
(e.g. by setting an environment variable to a value which contains
spaces). It may even return false positives, when the output of a git
command is piped into an other git command, and the second gets the
command line options via $@, but options for the first one are
offered. However, the following patches will enable the user to
supply custom completion scripts for aliases, which can be used to
remedy these problematic cases.
Signed-off-by: SZEDER Gábor <szeder@ira.uka.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-02-23 22:02:57 +01:00
|
|
|
\!*) : shell command alias ;;
|
|
|
|
-*) : option ;;
|
|
|
|
*=*) : setting env ;;
|
|
|
|
git) : git itself ;;
|
|
|
|
*)
|
|
|
|
echo "$word"
|
2006-10-28 14:12:20 +02:00
|
|
|
return
|
bash: improve aliased command recognition
To support completion for aliases, the completion script tries to
figure out which git command is invoked by an alias. Its
implementation in __git_aliased_command() is rather straightforward:
it returns the first word from the alias. For simple aliases starting
with the git command (e.g. alias.last = cat-file commit HEAD) this
gives the right results. Unfortunately, it does not work with shell
command aliases, which can get rather complex, as illustrated by one
of Junio's aliases:
[alias]
lgm = "!sh -c 'GIT_NOTES_REF=refs/notes/amlog git log \"$@\" || :' -"
In this case the current implementation returns "!sh" as the aliased
git command, which is obviosly wrong.
The full parsing of a shell command alias like that in the completion
code is clearly unfeasible. However, we can easily improve on aliased
command recognition by eleminating stuff that is definitely not a git
command: shell commands (anything starting with '!'), command line
options (anything starting with '-'), environment variables (anything
with a '=' in it), and git itself. This way the above alias would be
handled correctly, and the completion script would correctly recognize
"log" as the aliased git command.
Of course, this solution is not perfect either, and could be fooled
easily. It's not hard to construct an alias, in which a word does not
match any of these filter patterns, but is still not a git command
(e.g. by setting an environment variable to a value which contains
spaces). It may even return false positives, when the output of a git
command is piped into an other git command, and the second gets the
command line options via $@, but options for the first one are
offered. However, the following patches will enable the user to
supply custom completion scripts for aliases, which can be used to
remedy these problematic cases.
Signed-off-by: SZEDER Gábor <szeder@ira.uka.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-02-23 22:02:57 +01:00
|
|
|
esac
|
2006-10-28 14:12:20 +02:00
|
|
|
done
|
|
|
|
}
|
|
|
|
|
2009-09-15 12:21:43 +02:00
|
|
|
# __git_find_on_cmdline requires 1 argument
|
|
|
|
__git_find_on_cmdline ()
|
2008-03-10 16:02:23 +01:00
|
|
|
{
|
|
|
|
local word subcommand c=1
|
|
|
|
|
|
|
|
while [ $c -lt $COMP_CWORD ]; do
|
|
|
|
word="${COMP_WORDS[c]}"
|
|
|
|
for subcommand in $1; do
|
|
|
|
if [ "$subcommand" = "$word" ]; then
|
|
|
|
echo "$subcommand"
|
|
|
|
return
|
|
|
|
fi
|
|
|
|
done
|
|
|
|
c=$((++c))
|
|
|
|
done
|
|
|
|
}
|
|
|
|
|
bash: offer only paths after '--'
Many git commands use '--' to separate subcommands, options, and refs
from paths. However, the programmable completion for several of these
commands does not respect the '--', and offer subcommands, options, or
refs after a '--', although only paths are permitted. e.g. 'git bisect
-- <TAB>' offers subcommands, 'git log -- --<TAB>' offers options and
'git log -- git<TAB>' offers all gitgui tags.
The completion for the following commands share this wrong behaviour:
am add bisect commit diff log reset shortlog submodule gitk.
To avoid this, we check the presence of a '--' on the command line first
and let the shell do filename completion, if one is found.
Signed-off-by: SZEDER Gábor <szeder@ira.uka.de>
Acked-by: Shawn O. Pearce <spearce@spearce.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-07-08 18:56:14 +02:00
|
|
|
__git_has_doubledash ()
|
|
|
|
{
|
|
|
|
local c=1
|
|
|
|
while [ $c -lt $COMP_CWORD ]; do
|
|
|
|
if [ "--" = "${COMP_WORDS[c]}" ]; then
|
|
|
|
return 0
|
|
|
|
fi
|
|
|
|
c=$((++c))
|
|
|
|
done
|
|
|
|
return 1
|
|
|
|
}
|
|
|
|
|
2008-08-14 19:12:54 +02:00
|
|
|
__git_whitespacelist="nowarn warn error error-all fix"
|
2006-11-27 21:12:03 +01:00
|
|
|
|
|
|
|
_git_am ()
|
|
|
|
{
|
2008-07-16 03:33:44 +02:00
|
|
|
local cur="${COMP_WORDS[COMP_CWORD]}" dir="$(__gitdir)"
|
2008-07-21 12:51:02 +02:00
|
|
|
if [ -d "$dir"/rebase-apply ]; then
|
2010-02-12 15:11:47 +01:00
|
|
|
__gitcomp "--skip --continue --resolved --abort"
|
2006-11-27 21:12:03 +01:00
|
|
|
return
|
|
|
|
fi
|
|
|
|
case "$cur" in
|
|
|
|
--whitespace=*)
|
2007-02-04 08:38:43 +01:00
|
|
|
__gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
|
2006-11-27 21:12:03 +01:00
|
|
|
return
|
|
|
|
;;
|
|
|
|
--*)
|
2007-02-04 08:38:43 +01:00
|
|
|
__gitcomp "
|
2009-04-05 18:33:38 +02:00
|
|
|
--3way --committer-date-is-author-date --ignore-date
|
2009-08-04 13:16:49 +02:00
|
|
|
--ignore-whitespace --ignore-space-change
|
2009-04-05 18:33:38 +02:00
|
|
|
--interactive --keep --no-utf8 --signoff --utf8
|
2009-10-07 10:48:50 +02:00
|
|
|
--whitespace= --scissors
|
2007-02-04 08:38:43 +01:00
|
|
|
"
|
2006-11-27 21:12:03 +01:00
|
|
|
return
|
|
|
|
esac
|
|
|
|
COMPREPLY=()
|
|
|
|
}
|
|
|
|
|
|
|
|
_git_apply ()
|
|
|
|
{
|
|
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
|
|
case "$cur" in
|
|
|
|
--whitespace=*)
|
2007-02-04 08:38:43 +01:00
|
|
|
__gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
|
2006-11-27 21:12:03 +01:00
|
|
|
return
|
|
|
|
;;
|
|
|
|
--*)
|
2007-02-04 08:38:43 +01:00
|
|
|
__gitcomp "
|
2006-11-27 21:12:03 +01:00
|
|
|
--stat --numstat --summary --check --index
|
|
|
|
--cached --index-info --reverse --reject --unidiff-zero
|
|
|
|
--apply --no-add --exclude=
|
2009-08-04 13:16:49 +02:00
|
|
|
--ignore-whitespace --ignore-space-change
|
2006-11-27 21:12:03 +01:00
|
|
|
--whitespace= --inaccurate-eof --verbose
|
2007-02-04 08:38:43 +01:00
|
|
|
"
|
2006-11-27 21:12:03 +01:00
|
|
|
return
|
|
|
|
esac
|
|
|
|
COMPREPLY=()
|
|
|
|
}
|
|
|
|
|
2007-02-04 08:38:23 +01:00
|
|
|
_git_add ()
|
|
|
|
{
|
bash: offer only paths after '--'
Many git commands use '--' to separate subcommands, options, and refs
from paths. However, the programmable completion for several of these
commands does not respect the '--', and offer subcommands, options, or
refs after a '--', although only paths are permitted. e.g. 'git bisect
-- <TAB>' offers subcommands, 'git log -- --<TAB>' offers options and
'git log -- git<TAB>' offers all gitgui tags.
The completion for the following commands share this wrong behaviour:
am add bisect commit diff log reset shortlog submodule gitk.
To avoid this, we check the presence of a '--' on the command line first
and let the shell do filename completion, if one is found.
Signed-off-by: SZEDER Gábor <szeder@ira.uka.de>
Acked-by: Shawn O. Pearce <spearce@spearce.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-07-08 18:56:14 +02:00
|
|
|
__git_has_doubledash && return
|
|
|
|
|
2007-02-04 08:38:23 +01:00
|
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
|
|
case "$cur" in
|
|
|
|
--*)
|
2008-06-14 11:48:01 +02:00
|
|
|
__gitcomp "
|
|
|
|
--interactive --refresh --patch --update --dry-run
|
2008-12-10 20:39:17 +01:00
|
|
|
--ignore-errors --intent-to-add
|
2008-06-14 11:48:01 +02:00
|
|
|
"
|
2007-02-04 08:38:23 +01:00
|
|
|
return
|
|
|
|
esac
|
|
|
|
COMPREPLY=()
|
|
|
|
}
|
|
|
|
|
2008-08-05 07:50:36 +02:00
|
|
|
_git_archive ()
|
|
|
|
{
|
|
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
|
|
case "$cur" in
|
|
|
|
--format=*)
|
|
|
|
__gitcomp "$(git archive --list)" "" "${cur##--format=}"
|
|
|
|
return
|
|
|
|
;;
|
|
|
|
--remote=*)
|
|
|
|
__gitcomp "$(__git_remotes)" "" "${cur##--remote=}"
|
|
|
|
return
|
|
|
|
;;
|
|
|
|
--*)
|
|
|
|
__gitcomp "
|
|
|
|
--format= --list --verbose
|
|
|
|
--prefix= --remote= --exec=
|
|
|
|
"
|
|
|
|
return
|
|
|
|
;;
|
|
|
|
esac
|
|
|
|
__git_complete_file
|
|
|
|
}
|
|
|
|
|
2007-02-05 21:44:37 +01:00
|
|
|
_git_bisect ()
|
|
|
|
{
|
bash: offer only paths after '--'
Many git commands use '--' to separate subcommands, options, and refs
from paths. However, the programmable completion for several of these
commands does not respect the '--', and offer subcommands, options, or
refs after a '--', although only paths are permitted. e.g. 'git bisect
-- <TAB>' offers subcommands, 'git log -- --<TAB>' offers options and
'git log -- git<TAB>' offers all gitgui tags.
The completion for the following commands share this wrong behaviour:
am add bisect commit diff log reset shortlog submodule gitk.
To avoid this, we check the presence of a '--' on the command line first
and let the shell do filename completion, if one is found.
Signed-off-by: SZEDER Gábor <szeder@ira.uka.de>
Acked-by: Shawn O. Pearce <spearce@spearce.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-07-08 18:56:14 +02:00
|
|
|
__git_has_doubledash && return
|
|
|
|
|
2008-07-02 15:29:50 +02:00
|
|
|
local subcommands="start bad good skip reset visualize replay log run"
|
2009-09-15 12:21:43 +02:00
|
|
|
local subcommand="$(__git_find_on_cmdline "$subcommands")"
|
2008-03-10 16:02:23 +01:00
|
|
|
if [ -z "$subcommand" ]; then
|
|
|
|
__gitcomp "$subcommands"
|
2007-02-05 21:44:37 +01:00
|
|
|
return
|
|
|
|
fi
|
|
|
|
|
2008-03-10 16:02:23 +01:00
|
|
|
case "$subcommand" in
|
2008-07-02 15:29:50 +02:00
|
|
|
bad|good|reset|skip)
|
2007-02-05 21:44:37 +01:00
|
|
|
__gitcomp "$(__git_refs)"
|
|
|
|
;;
|
|
|
|
*)
|
|
|
|
COMPREPLY=()
|
|
|
|
;;
|
|
|
|
esac
|
|
|
|
}
|
|
|
|
|
2006-09-28 11:31:25 +02:00
|
|
|
_git_branch ()
|
|
|
|
{
|
2008-03-04 19:00:59 +01:00
|
|
|
local i c=1 only_local_ref="n" has_r="n"
|
|
|
|
|
|
|
|
while [ $c -lt $COMP_CWORD ]; do
|
|
|
|
i="${COMP_WORDS[c]}"
|
|
|
|
case "$i" in
|
|
|
|
-d|-m) only_local_ref="y" ;;
|
|
|
|
-r) has_r="y" ;;
|
|
|
|
esac
|
|
|
|
c=$((++c))
|
|
|
|
done
|
|
|
|
|
2008-03-04 19:00:58 +01:00
|
|
|
case "${COMP_WORDS[COMP_CWORD]}" in
|
|
|
|
--*)
|
|
|
|
__gitcomp "
|
|
|
|
--color --no-color --verbose --abbrev= --no-abbrev
|
2008-07-07 22:41:54 +02:00
|
|
|
--track --no-track --contains --merged --no-merged
|
2008-03-04 19:00:58 +01:00
|
|
|
"
|
|
|
|
;;
|
2008-03-04 19:00:59 +01:00
|
|
|
*)
|
|
|
|
if [ $only_local_ref = "y" -a $has_r = "n" ]; then
|
|
|
|
__gitcomp "$(__git_heads)"
|
|
|
|
else
|
|
|
|
__gitcomp "$(__git_refs)"
|
|
|
|
fi
|
|
|
|
;;
|
2008-03-04 19:00:58 +01:00
|
|
|
esac
|
2006-09-28 11:31:25 +02:00
|
|
|
}
|
|
|
|
|
2007-08-12 20:46:12 +02:00
|
|
|
_git_bundle ()
|
|
|
|
{
|
2008-11-27 14:35:38 +01:00
|
|
|
local cmd="${COMP_WORDS[2]}"
|
|
|
|
case "$COMP_CWORD" in
|
|
|
|
2)
|
2007-08-12 20:46:12 +02:00
|
|
|
__gitcomp "create list-heads verify unbundle"
|
|
|
|
;;
|
2008-11-27 14:35:38 +01:00
|
|
|
3)
|
2007-08-12 20:46:12 +02:00
|
|
|
# looking for a file
|
|
|
|
;;
|
|
|
|
*)
|
|
|
|
case "$cmd" in
|
|
|
|
create)
|
|
|
|
__git_complete_revlist
|
|
|
|
;;
|
|
|
|
esac
|
|
|
|
;;
|
|
|
|
esac
|
|
|
|
}
|
|
|
|
|
2006-09-28 11:31:25 +02:00
|
|
|
_git_checkout ()
|
|
|
|
{
|
2008-07-23 13:49:22 +02:00
|
|
|
__git_has_doubledash && return
|
|
|
|
|
2009-09-24 14:23:15 +02:00
|
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
|
|
case "$cur" in
|
|
|
|
--conflict=*)
|
|
|
|
__gitcomp "diff3 merge" "" "${cur##--conflict=}"
|
|
|
|
;;
|
|
|
|
--*)
|
|
|
|
__gitcomp "
|
|
|
|
--quiet --ours --theirs --track --no-track --merge
|
|
|
|
--conflict= --patch
|
|
|
|
"
|
|
|
|
;;
|
|
|
|
*)
|
|
|
|
__gitcomp "$(__git_refs)"
|
|
|
|
;;
|
|
|
|
esac
|
2006-09-28 11:31:25 +02:00
|
|
|
}
|
|
|
|
|
2007-02-05 21:44:22 +01:00
|
|
|
_git_cherry ()
|
|
|
|
{
|
|
|
|
__gitcomp "$(__git_refs)"
|
|
|
|
}
|
|
|
|
|
2006-11-27 09:41:59 +01:00
|
|
|
_git_cherry_pick ()
|
|
|
|
{
|
|
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
|
|
case "$cur" in
|
|
|
|
--*)
|
2007-02-04 08:38:43 +01:00
|
|
|
__gitcomp "--edit --no-commit"
|
2006-11-27 09:41:59 +01:00
|
|
|
;;
|
|
|
|
*)
|
2007-02-04 08:38:43 +01:00
|
|
|
__gitcomp "$(__git_refs)"
|
2006-11-27 09:41:59 +01:00
|
|
|
;;
|
|
|
|
esac
|
|
|
|
}
|
|
|
|
|
2008-08-05 07:50:32 +02:00
|
|
|
_git_clean ()
|
|
|
|
{
|
|
|
|
__git_has_doubledash && return
|
|
|
|
|
|
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
|
|
case "$cur" in
|
|
|
|
--*)
|
|
|
|
__gitcomp "--dry-run --quiet"
|
|
|
|
return
|
|
|
|
;;
|
|
|
|
esac
|
|
|
|
COMPREPLY=()
|
|
|
|
}
|
|
|
|
|
2008-08-05 07:50:31 +02:00
|
|
|
_git_clone ()
|
|
|
|
{
|
|
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
|
|
case "$cur" in
|
|
|
|
--*)
|
|
|
|
__gitcomp "
|
|
|
|
--local
|
|
|
|
--no-hardlinks
|
|
|
|
--shared
|
|
|
|
--reference
|
|
|
|
--quiet
|
|
|
|
--no-checkout
|
|
|
|
--bare
|
|
|
|
--mirror
|
|
|
|
--origin
|
|
|
|
--upload-pack
|
|
|
|
--template=
|
|
|
|
--depth
|
|
|
|
"
|
|
|
|
return
|
|
|
|
;;
|
|
|
|
esac
|
|
|
|
COMPREPLY=()
|
|
|
|
}
|
|
|
|
|
2006-11-28 18:12:08 +01:00
|
|
|
_git_commit ()
|
|
|
|
{
|
bash: offer only paths after '--'
Many git commands use '--' to separate subcommands, options, and refs
from paths. However, the programmable completion for several of these
commands does not respect the '--', and offer subcommands, options, or
refs after a '--', although only paths are permitted. e.g. 'git bisect
-- <TAB>' offers subcommands, 'git log -- --<TAB>' offers options and
'git log -- git<TAB>' offers all gitgui tags.
The completion for the following commands share this wrong behaviour:
am add bisect commit diff log reset shortlog submodule gitk.
To avoid this, we check the presence of a '--' on the command line first
and let the shell do filename completion, if one is found.
Signed-off-by: SZEDER Gábor <szeder@ira.uka.de>
Acked-by: Shawn O. Pearce <spearce@spearce.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-07-08 18:56:14 +02:00
|
|
|
__git_has_doubledash && return
|
|
|
|
|
2006-11-28 18:12:08 +01:00
|
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
|
|
case "$cur" in
|
2009-12-05 01:51:41 +01:00
|
|
|
--cleanup=*)
|
|
|
|
__gitcomp "default strip verbatim whitespace
|
|
|
|
" "" "${cur##--cleanup=}"
|
|
|
|
return
|
|
|
|
;;
|
|
|
|
--reuse-message=*)
|
|
|
|
__gitcomp "$(__git_refs)" "" "${cur##--reuse-message=}"
|
|
|
|
return
|
|
|
|
;;
|
|
|
|
--reedit-message=*)
|
|
|
|
__gitcomp "$(__git_refs)" "" "${cur##--reedit-message=}"
|
|
|
|
return
|
|
|
|
;;
|
|
|
|
--untracked-files=*)
|
|
|
|
__gitcomp "all no normal" "" "${cur##--untracked-files=}"
|
|
|
|
return
|
|
|
|
;;
|
2006-11-28 18:12:08 +01:00
|
|
|
--*)
|
2007-02-04 08:38:43 +01:00
|
|
|
__gitcomp "
|
2006-11-28 18:12:08 +01:00
|
|
|
--all --author= --signoff --verify --no-verify
|
2008-09-11 02:40:20 +02:00
|
|
|
--edit --amend --include --only --interactive
|
2009-12-05 01:51:41 +01:00
|
|
|
--dry-run --reuse-message= --reedit-message=
|
|
|
|
--reset-author --file= --message= --template=
|
|
|
|
--cleanup= --untracked-files --untracked-files=
|
|
|
|
--verbose --quiet
|
2007-02-04 08:38:43 +01:00
|
|
|
"
|
2006-11-28 18:12:08 +01:00
|
|
|
return
|
|
|
|
esac
|
|
|
|
COMPREPLY=()
|
|
|
|
}
|
|
|
|
|
2007-08-23 07:42:11 +02:00
|
|
|
_git_describe ()
|
|
|
|
{
|
2008-07-26 12:26:56 +02:00
|
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
|
|
case "$cur" in
|
|
|
|
--*)
|
|
|
|
__gitcomp "
|
|
|
|
--all --tags --contains --abbrev= --candidates=
|
|
|
|
--exact-match --debug --long --match --always
|
|
|
|
"
|
|
|
|
return
|
|
|
|
esac
|
2007-08-23 07:42:11 +02:00
|
|
|
__gitcomp "$(__git_refs)"
|
|
|
|
}
|
|
|
|
|
2009-01-19 22:18:00 +01:00
|
|
|
__git_diff_common_options="--stat --numstat --shortstat --summary
|
2007-11-23 02:11:35 +01:00
|
|
|
--patch-with-stat --name-only --name-status --color
|
|
|
|
--no-color --color-words --no-renames --check
|
2008-08-22 19:25:06 +02:00
|
|
|
--full-index --binary --abbrev --diff-filter=
|
2009-01-19 22:17:59 +01:00
|
|
|
--find-copies-harder
|
2007-11-23 02:11:35 +01:00
|
|
|
--text --ignore-space-at-eol --ignore-space-change
|
|
|
|
--ignore-all-space --exit-code --quiet --ext-diff
|
2008-04-06 18:56:08 +02:00
|
|
|
--no-ext-diff
|
|
|
|
--no-prefix --src-prefix= --dst-prefix=
|
2008-12-28 19:45:32 +01:00
|
|
|
--inter-hunk-context=
|
2009-01-01 17:39:37 +01:00
|
|
|
--patience
|
2009-01-19 22:18:00 +01:00
|
|
|
--raw
|
2009-10-07 10:48:51 +02:00
|
|
|
--dirstat --dirstat= --dirstat-by-file
|
|
|
|
--dirstat-by-file= --cumulative
|
2009-01-19 22:18:00 +01:00
|
|
|
"
|
|
|
|
|
|
|
|
_git_diff ()
|
|
|
|
{
|
|
|
|
__git_has_doubledash && return
|
|
|
|
|
|
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
|
|
case "$cur" in
|
|
|
|
--*)
|
2009-03-22 00:29:27 +01:00
|
|
|
__gitcomp "--cached --staged --pickaxe-all --pickaxe-regex
|
2009-01-19 22:18:00 +01:00
|
|
|
--base --ours --theirs
|
|
|
|
$__git_diff_common_options
|
2008-04-06 18:56:08 +02:00
|
|
|
"
|
2007-11-23 02:11:35 +01:00
|
|
|
return
|
|
|
|
;;
|
|
|
|
esac
|
2006-09-28 11:31:25 +02:00
|
|
|
__git_complete_file
|
|
|
|
}
|
|
|
|
|
2009-04-06 10:31:27 +02:00
|
|
|
__git_mergetools_common="diffuse ecmerge emerge kdiff3 meld opendiff
|
2009-10-28 22:39:32 +01:00
|
|
|
tkdiff vimdiff gvimdiff xxdiff araxis p4merge
|
2009-04-06 10:31:27 +02:00
|
|
|
"
|
|
|
|
|
|
|
|
_git_difftool ()
|
|
|
|
{
|
2009-10-28 10:45:38 +01:00
|
|
|
__git_has_doubledash && return
|
|
|
|
|
2009-04-06 10:31:27 +02:00
|
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
|
|
case "$cur" in
|
|
|
|
--tool=*)
|
|
|
|
__gitcomp "$__git_mergetools_common kompare" "" "${cur##--tool=}"
|
|
|
|
return
|
|
|
|
;;
|
|
|
|
--*)
|
2009-10-28 10:45:38 +01:00
|
|
|
__gitcomp "--cached --staged --pickaxe-all --pickaxe-regex
|
|
|
|
--base --ours --theirs
|
|
|
|
--no-renames --diff-filter= --find-copies-harder
|
|
|
|
--relative --ignore-submodules
|
|
|
|
--tool="
|
2009-04-06 10:31:27 +02:00
|
|
|
return
|
|
|
|
;;
|
|
|
|
esac
|
2009-10-28 10:45:38 +01:00
|
|
|
__git_complete_file
|
2009-04-06 10:31:27 +02:00
|
|
|
}
|
|
|
|
|
2009-03-06 05:39:33 +01:00
|
|
|
__git_fetch_options="
|
|
|
|
--quiet --verbose --append --upload-pack --force --keep --depth=
|
2009-12-12 11:21:46 +01:00
|
|
|
--tags --no-tags --all --prune --dry-run
|
2009-03-06 05:39:33 +01:00
|
|
|
"
|
|
|
|
|
2006-09-28 11:31:25 +02:00
|
|
|
_git_fetch ()
|
|
|
|
{
|
2009-03-06 05:39:33 +01:00
|
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
|
|
case "$cur" in
|
|
|
|
--*)
|
|
|
|
__gitcomp "$__git_fetch_options"
|
|
|
|
return
|
|
|
|
;;
|
|
|
|
esac
|
2009-03-06 05:39:31 +01:00
|
|
|
__git_complete_remote_or_refspec
|
2006-09-28 11:31:25 +02:00
|
|
|
}
|
|
|
|
|
2006-11-27 09:41:43 +01:00
|
|
|
_git_format_patch ()
|
|
|
|
{
|
|
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
|
|
case "$cur" in
|
2009-03-23 11:26:51 +01:00
|
|
|
--thread=*)
|
|
|
|
__gitcomp "
|
|
|
|
deep shallow
|
|
|
|
" "" "${cur##--thread=}"
|
|
|
|
return
|
|
|
|
;;
|
2006-11-27 09:41:43 +01:00
|
|
|
--*)
|
2007-02-04 08:38:43 +01:00
|
|
|
__gitcomp "
|
2009-03-23 11:26:51 +01:00
|
|
|
--stdout --attach --no-attach --thread --thread=
|
2006-11-27 09:41:43 +01:00
|
|
|
--output-directory
|
|
|
|
--numbered --start-number
|
2007-08-23 07:39:22 +02:00
|
|
|
--numbered-files
|
2006-11-27 09:41:43 +01:00
|
|
|
--keep-subject
|
|
|
|
--signoff
|
2009-03-23 11:26:50 +01:00
|
|
|
--in-reply-to= --cc=
|
2006-11-27 09:41:43 +01:00
|
|
|
--full-index --binary
|
2007-02-04 08:38:47 +01:00
|
|
|
--not --all
|
2008-02-21 17:21:49 +01:00
|
|
|
--cover-letter
|
2008-04-06 18:56:08 +02:00
|
|
|
--no-prefix --src-prefix= --dst-prefix=
|
2009-01-16 17:02:04 +01:00
|
|
|
--inline --suffix= --ignore-if-in-upstream
|
|
|
|
--subject-prefix=
|
2007-02-04 08:38:43 +01:00
|
|
|
"
|
2006-11-27 09:41:43 +01:00
|
|
|
return
|
|
|
|
;;
|
|
|
|
esac
|
|
|
|
__git_complete_revlist
|
|
|
|
}
|
|
|
|
|
2009-03-22 19:49:07 +01:00
|
|
|
_git_fsck ()
|
|
|
|
{
|
|
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
|
|
case "$cur" in
|
|
|
|
--*)
|
|
|
|
__gitcomp "
|
|
|
|
--tags --root --unreachable --cache --no-reflogs --full
|
|
|
|
--strict --verbose --lost-found
|
|
|
|
"
|
|
|
|
return
|
|
|
|
;;
|
|
|
|
esac
|
|
|
|
COMPREPLY=()
|
|
|
|
}
|
|
|
|
|
2007-02-05 21:44:28 +01:00
|
|
|
_git_gc ()
|
|
|
|
{
|
|
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
|
|
case "$cur" in
|
|
|
|
--*)
|
2007-08-23 07:39:22 +02:00
|
|
|
__gitcomp "--prune --aggressive"
|
2007-02-05 21:44:28 +01:00
|
|
|
return
|
|
|
|
;;
|
|
|
|
esac
|
|
|
|
COMPREPLY=()
|
|
|
|
}
|
|
|
|
|
2010-02-23 22:03:00 +01:00
|
|
|
_git_gitk ()
|
|
|
|
{
|
|
|
|
_gitk
|
|
|
|
}
|
|
|
|
|
2008-08-02 02:56:33 +02:00
|
|
|
_git_grep ()
|
|
|
|
{
|
|
|
|
__git_has_doubledash && return
|
|
|
|
|
|
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
|
|
case "$cur" in
|
|
|
|
--*)
|
|
|
|
__gitcomp "
|
|
|
|
--cached
|
|
|
|
--text --ignore-case --word-regexp --invert-match
|
|
|
|
--full-name
|
|
|
|
--extended-regexp --basic-regexp --fixed-strings
|
|
|
|
--files-with-matches --name-only
|
|
|
|
--files-without-match
|
grep: Add --max-depth option.
It is useful to grep directories non-recursively, e.g. when one wants to
look for all files in the toplevel directory, but not in any subdirectory,
or in Documentation/, but not in Documentation/technical/.
This patch adds support for --max-depth <depth> option to git-grep. If it is
given, git-grep descends at most <depth> levels of directories below paths
specified on the command line.
Note that if path specified on command line contains wildcards, this option
makes no sense, e.g.
$ git grep -l --max-depth 0 GNU -- 'contrib/*'
(note the quotes) will search all files in contrib/, even in
subdirectories, because '*' matches all files.
Documentation updates, bash-completion and simple test cases are also
provided.
Signed-off-by: Michał Kiedrowicz <michal.kiedrowicz@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-07-22 19:52:15 +02:00
|
|
|
--max-depth
|
2008-08-02 02:56:33 +02:00
|
|
|
--count
|
|
|
|
--and --or --not --all-match
|
|
|
|
"
|
|
|
|
return
|
|
|
|
;;
|
|
|
|
esac
|
2009-10-12 11:00:09 +02:00
|
|
|
|
|
|
|
__gitcomp "$(__git_refs)"
|
2008-08-02 02:56:33 +02:00
|
|
|
}
|
|
|
|
|
2008-07-24 02:07:23 +02:00
|
|
|
_git_help ()
|
|
|
|
{
|
|
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
|
|
case "$cur" in
|
|
|
|
--*)
|
|
|
|
__gitcomp "--all --info --man --web"
|
|
|
|
return
|
|
|
|
;;
|
|
|
|
esac
|
2009-11-18 01:49:10 +01:00
|
|
|
__git_compute_all_commands
|
|
|
|
__gitcomp "$__git_all_commands
|
2008-08-15 19:59:28 +02:00
|
|
|
attributes cli core-tutorial cvs-migration
|
|
|
|
diffcore gitk glossary hooks ignore modules
|
|
|
|
repository-layout tutorial tutorial-2
|
2008-10-20 19:31:38 +02:00
|
|
|
workflows
|
2008-08-15 19:59:28 +02:00
|
|
|
"
|
2008-07-24 02:07:23 +02:00
|
|
|
}
|
|
|
|
|
2008-08-05 07:50:33 +02:00
|
|
|
_git_init ()
|
|
|
|
{
|
|
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
|
|
case "$cur" in
|
|
|
|
--shared=*)
|
|
|
|
__gitcomp "
|
|
|
|
false true umask group all world everybody
|
|
|
|
" "" "${cur##--shared=}"
|
|
|
|
return
|
|
|
|
;;
|
|
|
|
--*)
|
|
|
|
__gitcomp "--quiet --bare --template= --shared --shared="
|
|
|
|
return
|
|
|
|
;;
|
|
|
|
esac
|
|
|
|
COMPREPLY=()
|
|
|
|
}
|
|
|
|
|
2008-08-05 07:50:37 +02:00
|
|
|
_git_ls_files ()
|
|
|
|
{
|
|
|
|
__git_has_doubledash && return
|
|
|
|
|
|
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
|
|
case "$cur" in
|
|
|
|
--*)
|
|
|
|
__gitcomp "--cached --deleted --modified --others --ignored
|
|
|
|
--stage --directory --no-empty-directory --unmerged
|
|
|
|
--killed --exclude= --exclude-from=
|
|
|
|
--exclude-per-directory= --exclude-standard
|
|
|
|
--error-unmatch --with-tree= --full-name
|
|
|
|
--abbrev --ignored --exclude-per-directory
|
|
|
|
"
|
|
|
|
return
|
|
|
|
;;
|
|
|
|
esac
|
|
|
|
COMPREPLY=()
|
|
|
|
}
|
|
|
|
|
2006-09-28 11:31:25 +02:00
|
|
|
_git_ls_remote ()
|
|
|
|
{
|
2007-02-04 08:38:43 +01:00
|
|
|
__gitcomp "$(__git_remotes)"
|
2006-09-28 11:31:25 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
_git_ls_tree ()
|
|
|
|
{
|
|
|
|
__git_complete_file
|
|
|
|
}
|
|
|
|
|
2009-02-16 17:34:56 +01:00
|
|
|
# Options that go well for log, shortlog and gitk
|
|
|
|
__git_log_common_options="
|
|
|
|
--not --all
|
|
|
|
--branches --tags --remotes
|
2009-07-13 17:11:45 +02:00
|
|
|
--first-parent --merges --no-merges
|
2009-02-16 17:34:56 +01:00
|
|
|
--max-count=
|
|
|
|
--max-age= --since= --after=
|
|
|
|
--min-age= --until= --before=
|
|
|
|
"
|
|
|
|
# Options that go well for log and gitk (not shortlog)
|
|
|
|
__git_log_gitk_options="
|
|
|
|
--dense --sparse --full-history
|
|
|
|
--simplify-merges --simplify-by-decoration
|
|
|
|
--left-right
|
|
|
|
"
|
|
|
|
# Options that go well for log and shortlog (not gitk)
|
|
|
|
__git_log_shortlog_options="
|
|
|
|
--author= --committer= --grep=
|
|
|
|
--all-match
|
|
|
|
"
|
|
|
|
|
2009-01-16 17:02:15 +01:00
|
|
|
__git_log_pretty_formats="oneline short medium full fuller email raw format:"
|
2009-05-04 08:25:34 +02:00
|
|
|
__git_log_date_formats="relative iso8601 rfc2822 short local default raw"
|
2009-01-16 17:02:15 +01:00
|
|
|
|
2006-09-28 11:31:25 +02:00
|
|
|
_git_log ()
|
|
|
|
{
|
bash: offer only paths after '--'
Many git commands use '--' to separate subcommands, options, and refs
from paths. However, the programmable completion for several of these
commands does not respect the '--', and offer subcommands, options, or
refs after a '--', although only paths are permitted. e.g. 'git bisect
-- <TAB>' offers subcommands, 'git log -- --<TAB>' offers options and
'git log -- git<TAB>' offers all gitgui tags.
The completion for the following commands share this wrong behaviour:
am add bisect commit diff log reset shortlog submodule gitk.
To avoid this, we check the presence of a '--' on the command line first
and let the shell do filename completion, if one is found.
Signed-off-by: SZEDER Gábor <szeder@ira.uka.de>
Acked-by: Shawn O. Pearce <spearce@spearce.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-07-08 18:56:14 +02:00
|
|
|
__git_has_doubledash && return
|
|
|
|
|
2006-11-27 09:42:18 +01:00
|
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
2009-02-16 17:34:57 +01:00
|
|
|
local g="$(git rev-parse --git-dir 2>/dev/null)"
|
|
|
|
local merge=""
|
2009-03-30 13:27:37 +02:00
|
|
|
if [ -f "$g/MERGE_HEAD" ]; then
|
2009-02-16 17:34:57 +01:00
|
|
|
merge="--merge"
|
|
|
|
fi
|
2006-11-27 09:42:18 +01:00
|
|
|
case "$cur" in
|
|
|
|
--pretty=*)
|
2009-01-16 17:02:15 +01:00
|
|
|
__gitcomp "$__git_log_pretty_formats
|
2007-02-04 08:38:43 +01:00
|
|
|
" "" "${cur##--pretty=}"
|
2006-11-27 09:42:18 +01:00
|
|
|
return
|
|
|
|
;;
|
2009-02-24 14:33:29 +01:00
|
|
|
--format=*)
|
|
|
|
__gitcomp "$__git_log_pretty_formats
|
|
|
|
" "" "${cur##--format=}"
|
|
|
|
return
|
|
|
|
;;
|
2007-08-23 07:39:22 +02:00
|
|
|
--date=*)
|
2009-05-04 08:25:34 +02:00
|
|
|
__gitcomp "$__git_log_date_formats" "" "${cur##--date=}"
|
2007-08-23 07:39:22 +02:00
|
|
|
return
|
|
|
|
;;
|
2009-10-07 10:48:50 +02:00
|
|
|
--decorate=*)
|
|
|
|
__gitcomp "long short" "" "${cur##--decorate=}"
|
|
|
|
return
|
|
|
|
;;
|
2006-11-27 09:42:18 +01:00
|
|
|
--*)
|
2007-02-04 08:38:43 +01:00
|
|
|
__gitcomp "
|
2009-02-16 17:34:56 +01:00
|
|
|
$__git_log_common_options
|
|
|
|
$__git_log_shortlog_options
|
|
|
|
$__git_log_gitk_options
|
2007-05-24 07:51:30 +02:00
|
|
|
--root --topo-order --date-order --reverse
|
2009-06-03 22:20:58 +02:00
|
|
|
--follow --full-diff
|
2006-11-27 09:42:18 +01:00
|
|
|
--abbrev-commit --abbrev=
|
2007-08-23 07:39:22 +02:00
|
|
|
--relative-date --date=
|
2009-02-24 14:33:29 +01:00
|
|
|
--pretty= --format= --oneline
|
2009-02-16 17:34:56 +01:00
|
|
|
--cherry-pick
|
2008-06-19 23:15:53 +02:00
|
|
|
--graph
|
2009-10-07 10:48:50 +02:00
|
|
|
--decorate --decorate=
|
2009-01-19 22:18:00 +01:00
|
|
|
--walk-reflogs
|
2009-02-16 17:34:56 +01:00
|
|
|
--parents --children
|
2009-02-16 17:34:57 +01:00
|
|
|
$merge
|
2009-01-19 22:18:00 +01:00
|
|
|
$__git_diff_common_options
|
2009-01-19 22:17:59 +01:00
|
|
|
--pickaxe-all --pickaxe-regex
|
2007-02-04 08:38:43 +01:00
|
|
|
"
|
2006-11-27 09:42:18 +01:00
|
|
|
return
|
|
|
|
;;
|
|
|
|
esac
|
2006-11-27 09:41:43 +01:00
|
|
|
__git_complete_revlist
|
2006-09-28 11:31:25 +02:00
|
|
|
}
|
|
|
|
|
2009-03-06 05:39:33 +01:00
|
|
|
__git_merge_options="
|
|
|
|
--no-commit --no-stat --log --no-log --squash --strategy
|
2009-11-11 05:49:07 +01:00
|
|
|
--commit --stat --no-squash --ff --no-ff --ff-only
|
2009-03-06 05:39:33 +01:00
|
|
|
"
|
|
|
|
|
2006-11-27 09:40:47 +01:00
|
|
|
_git_merge ()
|
|
|
|
{
|
2009-03-06 17:30:44 +01:00
|
|
|
__git_complete_strategy && return
|
|
|
|
|
2006-11-27 09:40:47 +01:00
|
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
|
|
case "$cur" in
|
|
|
|
--*)
|
2009-03-06 05:39:33 +01:00
|
|
|
__gitcomp "$__git_merge_options"
|
2006-11-27 09:40:47 +01:00
|
|
|
return
|
|
|
|
esac
|
2007-02-04 08:38:43 +01:00
|
|
|
__gitcomp "$(__git_refs)"
|
2006-11-27 09:40:47 +01:00
|
|
|
}
|
|
|
|
|
2008-08-15 00:41:10 +02:00
|
|
|
_git_mergetool ()
|
|
|
|
{
|
|
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
|
|
case "$cur" in
|
|
|
|
--tool=*)
|
2009-04-06 10:31:27 +02:00
|
|
|
__gitcomp "$__git_mergetools_common tortoisemerge" "" "${cur##--tool=}"
|
2008-08-15 00:41:10 +02:00
|
|
|
return
|
|
|
|
;;
|
|
|
|
--*)
|
|
|
|
__gitcomp "--tool="
|
|
|
|
return
|
|
|
|
;;
|
|
|
|
esac
|
|
|
|
COMPREPLY=()
|
|
|
|
}
|
|
|
|
|
2006-09-28 11:31:25 +02:00
|
|
|
_git_merge_base ()
|
|
|
|
{
|
2007-02-04 08:38:43 +01:00
|
|
|
__gitcomp "$(__git_refs)"
|
2006-09-28 11:31:25 +02:00
|
|
|
}
|
|
|
|
|
2008-08-05 07:50:38 +02:00
|
|
|
_git_mv ()
|
|
|
|
{
|
|
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
|
|
case "$cur" in
|
|
|
|
--*)
|
|
|
|
__gitcomp "--dry-run"
|
|
|
|
return
|
|
|
|
;;
|
|
|
|
esac
|
|
|
|
COMPREPLY=()
|
|
|
|
}
|
|
|
|
|
2006-11-27 09:41:12 +01:00
|
|
|
_git_name_rev ()
|
|
|
|
{
|
2007-02-04 08:38:43 +01:00
|
|
|
__gitcomp "--tags --all --stdin"
|
2006-11-27 09:41:12 +01:00
|
|
|
}
|
|
|
|
|
2010-01-28 02:05:55 +01:00
|
|
|
_git_notes ()
|
|
|
|
{
|
|
|
|
local subcommands="edit show"
|
|
|
|
if [ -z "$(__git_find_on_cmdline "$subcommands")" ]; then
|
|
|
|
__gitcomp "$subcommands"
|
|
|
|
return
|
|
|
|
fi
|
|
|
|
|
|
|
|
case "${COMP_WORDS[COMP_CWORD-1]}" in
|
|
|
|
-m|-F)
|
|
|
|
COMPREPLY=()
|
|
|
|
;;
|
|
|
|
*)
|
|
|
|
__gitcomp "$(__git_refs)"
|
|
|
|
;;
|
|
|
|
esac
|
|
|
|
}
|
|
|
|
|
2006-09-28 11:31:25 +02:00
|
|
|
_git_pull ()
|
|
|
|
{
|
2009-03-06 05:39:33 +01:00
|
|
|
__git_complete_strategy && return
|
|
|
|
|
|
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
|
|
case "$cur" in
|
|
|
|
--*)
|
|
|
|
__gitcomp "
|
|
|
|
--rebase --no-rebase
|
|
|
|
$__git_merge_options
|
|
|
|
$__git_fetch_options
|
|
|
|
"
|
|
|
|
return
|
|
|
|
;;
|
|
|
|
esac
|
2009-03-06 05:39:31 +01:00
|
|
|
__git_complete_remote_or_refspec
|
2006-09-28 11:31:25 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
_git_push ()
|
|
|
|
{
|
2009-03-06 05:39:33 +01:00
|
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
|
|
case "${COMP_WORDS[COMP_CWORD-1]}" in
|
|
|
|
--repo)
|
|
|
|
__gitcomp "$(__git_remotes)"
|
|
|
|
return
|
|
|
|
esac
|
|
|
|
case "$cur" in
|
|
|
|
--repo=*)
|
|
|
|
__gitcomp "$(__git_remotes)" "" "${cur##--repo=}"
|
|
|
|
return
|
|
|
|
;;
|
|
|
|
--*)
|
|
|
|
__gitcomp "
|
|
|
|
--all --mirror --tags --dry-run --force --verbose
|
|
|
|
--receive-pack= --repo=
|
|
|
|
"
|
|
|
|
return
|
|
|
|
;;
|
|
|
|
esac
|
2009-03-06 05:39:31 +01:00
|
|
|
__git_complete_remote_or_refspec
|
2006-09-28 11:31:25 +02:00
|
|
|
}
|
|
|
|
|
2006-11-27 09:42:07 +01:00
|
|
|
_git_rebase ()
|
|
|
|
{
|
2008-03-06 22:37:36 +01:00
|
|
|
local cur="${COMP_WORDS[COMP_CWORD]}" dir="$(__gitdir)"
|
2008-07-21 12:51:02 +02:00
|
|
|
if [ -d "$dir"/rebase-apply ] || [ -d "$dir"/rebase-merge ]; then
|
2007-02-04 08:38:43 +01:00
|
|
|
__gitcomp "--continue --skip --abort"
|
2006-11-27 09:42:07 +01:00
|
|
|
return
|
|
|
|
fi
|
2009-03-06 17:30:44 +01:00
|
|
|
__git_complete_strategy && return
|
2006-11-27 09:42:07 +01:00
|
|
|
case "$cur" in
|
2009-10-17 11:33:38 +02:00
|
|
|
--whitespace=*)
|
|
|
|
__gitcomp "$__git_whitespacelist" "" "${cur##--whitespace=}"
|
|
|
|
return
|
|
|
|
;;
|
2006-11-27 09:42:07 +01:00
|
|
|
--*)
|
2009-10-17 11:33:38 +02:00
|
|
|
__gitcomp "
|
|
|
|
--onto --merge --strategy --interactive
|
|
|
|
--preserve-merges --stat --no-stat
|
|
|
|
--committer-date-is-author-date --ignore-date
|
|
|
|
--ignore-whitespace --whitespace=
|
2010-02-06 09:37:53 +01:00
|
|
|
--autosquash
|
2009-10-17 11:33:38 +02:00
|
|
|
"
|
|
|
|
|
2006-11-27 09:42:07 +01:00
|
|
|
return
|
|
|
|
esac
|
2007-02-04 08:38:43 +01:00
|
|
|
__gitcomp "$(__git_refs)"
|
2006-11-27 09:42:07 +01:00
|
|
|
}
|
|
|
|
|
2009-05-04 08:25:35 +02:00
|
|
|
__git_send_email_confirm_options="always never auto cc compose"
|
2009-06-18 14:31:32 +02:00
|
|
|
__git_send_email_suppresscc_options="author self cc bodycc sob cccmd body all"
|
2009-05-04 08:25:35 +02:00
|
|
|
|
2008-07-14 10:21:02 +02:00
|
|
|
_git_send_email ()
|
|
|
|
{
|
|
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
|
|
case "$cur" in
|
2009-05-04 08:25:35 +02:00
|
|
|
--confirm=*)
|
|
|
|
__gitcomp "
|
|
|
|
$__git_send_email_confirm_options
|
|
|
|
" "" "${cur##--confirm=}"
|
|
|
|
return
|
|
|
|
;;
|
|
|
|
--suppress-cc=*)
|
|
|
|
__gitcomp "
|
|
|
|
$__git_send_email_suppresscc_options
|
|
|
|
" "" "${cur##--suppress-cc=}"
|
|
|
|
|
|
|
|
return
|
|
|
|
;;
|
|
|
|
--smtp-encryption=*)
|
|
|
|
__gitcomp "ssl tls" "" "${cur##--smtp-encryption=}"
|
|
|
|
return
|
|
|
|
;;
|
2008-07-14 10:21:02 +02:00
|
|
|
--*)
|
2009-03-23 11:26:49 +01:00
|
|
|
__gitcomp "--annotate --bcc --cc --cc-cmd --chain-reply-to
|
2009-05-04 08:25:35 +02:00
|
|
|
--compose --confirm= --dry-run --envelope-sender
|
|
|
|
--from --identity
|
2008-07-14 10:21:02 +02:00
|
|
|
--in-reply-to --no-chain-reply-to --no-signed-off-by-cc
|
|
|
|
--no-suppress-from --no-thread --quiet
|
|
|
|
--signed-off-by-cc --smtp-pass --smtp-server
|
2009-05-04 08:25:35 +02:00
|
|
|
--smtp-server-port --smtp-encryption= --smtp-user
|
|
|
|
--subject --suppress-cc= --suppress-from --thread --to
|
2008-09-28 06:51:21 +02:00
|
|
|
--validate --no-validate"
|
2008-07-14 10:21:02 +02:00
|
|
|
return
|
|
|
|
;;
|
|
|
|
esac
|
|
|
|
COMPREPLY=()
|
|
|
|
}
|
|
|
|
|
bash: support user-supplied completion scripts for user's git commands
The bash completion script already provides support to complete
aliases, options and refs for aliases (if the alias can be traced back
to a supported git command by __git_aliased_command()), and the user's
custom git commands, but it does not support the options of the user's
custom git commands (of course; how could it know about the options of
a custom git command?). Users of such custom git commands could
extend git's bash completion script by writing functions to support
their commands, but they might have issues with it: they might not
have the rights to modify a system-wide git completion script, and
they will need to track and merge upstream changes in the future.
This patch addresses this by providing means for users to supply
custom completion scriplets for their custom git commands without
modifying the main git bash completion script.
Instead of having a huge hard-coded list of command-completion
function pairs (in _git()), the completion script will figure out
which completion function to call based on the command's name. That
is, when completing the options of 'git foo', the main completion
script will check whether the function '_git_foo' is declared, and if
declared, it will invoke that function to perform the completion. If
such a function is not declared, it will fall back to complete file
names. So, users will only need to provide this '_git_foo' completion
function in a separate file, source that file, and it will be used the
next time they press TAB after 'git foo '.
There are two git commands (stage and whatchanged), for which the
completion functions of other commands were used, therefore they
got their own completion function.
Signed-off-by: SZEDER Gábor <szeder@ira.uka.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-02-23 22:02:58 +01:00
|
|
|
_git_stage ()
|
|
|
|
{
|
|
|
|
_git_add
|
|
|
|
}
|
|
|
|
|
2009-05-09 03:23:32 +02:00
|
|
|
__git_config_get_set_variables ()
|
|
|
|
{
|
|
|
|
local prevword word config_file= c=$COMP_CWORD
|
|
|
|
while [ $c -gt 1 ]; do
|
|
|
|
word="${COMP_WORDS[c]}"
|
|
|
|
case "$word" in
|
|
|
|
--global|--system|--file=*)
|
|
|
|
config_file="$word"
|
|
|
|
break
|
|
|
|
;;
|
|
|
|
-f|--file)
|
|
|
|
config_file="$word $prevword"
|
|
|
|
break
|
|
|
|
;;
|
|
|
|
esac
|
|
|
|
prevword=$word
|
|
|
|
c=$((--c))
|
|
|
|
done
|
|
|
|
|
2009-06-30 07:08:38 +02:00
|
|
|
git --git-dir="$(__gitdir)" config $config_file --list 2>/dev/null |
|
|
|
|
while read line
|
|
|
|
do
|
|
|
|
case "$line" in
|
|
|
|
*.*=*)
|
|
|
|
echo "${line/=*/}"
|
2009-05-09 03:23:32 +02:00
|
|
|
;;
|
|
|
|
esac
|
|
|
|
done
|
|
|
|
}
|
|
|
|
|
2007-01-29 01:16:53 +01:00
|
|
|
_git_config ()
|
2006-11-27 10:44:47 +01:00
|
|
|
{
|
|
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
|
|
local prv="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
case "$prv" in
|
|
|
|
branch.*.remote)
|
2007-02-04 08:38:37 +01:00
|
|
|
__gitcomp "$(__git_remotes)"
|
2006-11-27 10:44:47 +01:00
|
|
|
return
|
|
|
|
;;
|
|
|
|
branch.*.merge)
|
2007-02-04 08:38:37 +01:00
|
|
|
__gitcomp "$(__git_refs)"
|
2006-11-27 10:44:47 +01:00
|
|
|
return
|
|
|
|
;;
|
|
|
|
remote.*.fetch)
|
|
|
|
local remote="${prv#remote.}"
|
|
|
|
remote="${remote%.fetch}"
|
2007-02-04 08:38:37 +01:00
|
|
|
__gitcomp "$(__git_refs_remotes "$remote")"
|
2006-11-27 10:44:47 +01:00
|
|
|
return
|
|
|
|
;;
|
|
|
|
remote.*.push)
|
|
|
|
local remote="${prv#remote.}"
|
|
|
|
remote="${remote%.push}"
|
2007-02-04 08:38:37 +01:00
|
|
|
__gitcomp "$(git --git-dir="$(__gitdir)" \
|
2006-11-27 10:44:47 +01:00
|
|
|
for-each-ref --format='%(refname):%(refname)' \
|
2007-02-04 08:38:37 +01:00
|
|
|
refs/heads)"
|
|
|
|
return
|
|
|
|
;;
|
|
|
|
pull.twohead|pull.octopus)
|
2009-11-18 01:49:10 +01:00
|
|
|
__git_compute_merge_strategies
|
|
|
|
__gitcomp "$__git_merge_strategies"
|
2007-02-04 08:38:37 +01:00
|
|
|
return
|
|
|
|
;;
|
2009-04-25 13:46:14 +02:00
|
|
|
color.branch|color.diff|color.interactive|\
|
|
|
|
color.showbranch|color.status|color.ui)
|
2007-02-04 08:38:37 +01:00
|
|
|
__gitcomp "always never auto"
|
|
|
|
return
|
|
|
|
;;
|
2009-02-12 16:55:54 +01:00
|
|
|
color.pager)
|
|
|
|
__gitcomp "false true"
|
|
|
|
return
|
|
|
|
;;
|
2007-02-04 08:38:37 +01:00
|
|
|
color.*.*)
|
|
|
|
__gitcomp "
|
2008-12-15 18:45:49 +01:00
|
|
|
normal black red green yellow blue magenta cyan white
|
2007-02-04 08:38:37 +01:00
|
|
|
bold dim ul blink reverse
|
|
|
|
"
|
2006-11-27 10:44:47 +01:00
|
|
|
return
|
|
|
|
;;
|
2009-05-04 08:25:33 +02:00
|
|
|
help.format)
|
|
|
|
__gitcomp "man info web html"
|
|
|
|
return
|
|
|
|
;;
|
2009-05-04 08:25:34 +02:00
|
|
|
log.date)
|
|
|
|
__gitcomp "$__git_log_date_formats"
|
|
|
|
return
|
|
|
|
;;
|
2009-05-04 08:25:35 +02:00
|
|
|
sendemail.aliasesfiletype)
|
|
|
|
__gitcomp "mutt mailrc pine elm gnus"
|
|
|
|
return
|
|
|
|
;;
|
|
|
|
sendemail.confirm)
|
|
|
|
__gitcomp "$__git_send_email_confirm_options"
|
|
|
|
return
|
|
|
|
;;
|
|
|
|
sendemail.suppresscc)
|
|
|
|
__gitcomp "$__git_send_email_suppresscc_options"
|
|
|
|
return
|
|
|
|
;;
|
2009-05-09 03:23:32 +02:00
|
|
|
--get|--get-all|--unset|--unset-all)
|
|
|
|
__gitcomp "$(__git_config_get_set_variables)"
|
|
|
|
return
|
|
|
|
;;
|
2006-11-27 10:44:47 +01:00
|
|
|
*.*)
|
|
|
|
COMPREPLY=()
|
|
|
|
return
|
|
|
|
;;
|
|
|
|
esac
|
|
|
|
case "$cur" in
|
|
|
|
--*)
|
2007-02-04 08:38:37 +01:00
|
|
|
__gitcomp "
|
2007-08-23 07:39:22 +02:00
|
|
|
--global --system --file=
|
2007-05-24 08:07:45 +02:00
|
|
|
--list --replace-all
|
2006-11-27 10:44:47 +01:00
|
|
|
--get --get-all --get-regexp
|
2007-02-05 21:44:32 +01:00
|
|
|
--add --unset --unset-all
|
2007-05-24 08:07:45 +02:00
|
|
|
--remove-section --rename-section
|
2007-02-04 08:38:37 +01:00
|
|
|
"
|
2006-11-27 10:44:47 +01:00
|
|
|
return
|
|
|
|
;;
|
|
|
|
branch.*.*)
|
|
|
|
local pfx="${cur%.*}."
|
|
|
|
cur="${cur##*.}"
|
2009-06-30 06:24:24 +02:00
|
|
|
__gitcomp "remote merge mergeoptions rebase" "$pfx" "$cur"
|
2006-11-27 10:44:47 +01:00
|
|
|
return
|
|
|
|
;;
|
|
|
|
branch.*)
|
|
|
|
local pfx="${cur%.*}."
|
|
|
|
cur="${cur#*.}"
|
2007-02-04 08:38:37 +01:00
|
|
|
__gitcomp "$(__git_heads)" "$pfx" "$cur" "."
|
2006-11-27 10:44:47 +01:00
|
|
|
return
|
|
|
|
;;
|
2009-05-04 08:25:32 +02:00
|
|
|
guitool.*.*)
|
|
|
|
local pfx="${cur%.*}."
|
|
|
|
cur="${cur##*.}"
|
|
|
|
__gitcomp "
|
|
|
|
argprompt cmd confirm needsfile noconsole norescan
|
|
|
|
prompt revprompt revunmerged title
|
|
|
|
" "$pfx" "$cur"
|
|
|
|
return
|
|
|
|
;;
|
|
|
|
difftool.*.*)
|
|
|
|
local pfx="${cur%.*}."
|
|
|
|
cur="${cur##*.}"
|
|
|
|
__gitcomp "cmd path" "$pfx" "$cur"
|
|
|
|
return
|
|
|
|
;;
|
|
|
|
man.*.*)
|
|
|
|
local pfx="${cur%.*}."
|
|
|
|
cur="${cur##*.}"
|
|
|
|
__gitcomp "cmd path" "$pfx" "$cur"
|
|
|
|
return
|
|
|
|
;;
|
|
|
|
mergetool.*.*)
|
|
|
|
local pfx="${cur%.*}."
|
|
|
|
cur="${cur##*.}"
|
|
|
|
__gitcomp "cmd path trustExitCode" "$pfx" "$cur"
|
|
|
|
return
|
|
|
|
;;
|
|
|
|
pager.*)
|
|
|
|
local pfx="${cur%.*}."
|
|
|
|
cur="${cur#*.}"
|
2009-11-18 01:49:10 +01:00
|
|
|
__git_compute_all_commands
|
|
|
|
__gitcomp "$__git_all_commands" "$pfx" "$cur"
|
2009-05-04 08:25:32 +02:00
|
|
|
return
|
|
|
|
;;
|
2006-11-27 10:44:47 +01:00
|
|
|
remote.*.*)
|
|
|
|
local pfx="${cur%.*}."
|
|
|
|
cur="${cur##*.}"
|
2007-05-24 08:07:45 +02:00
|
|
|
__gitcomp "
|
2008-12-15 18:45:49 +01:00
|
|
|
url proxy fetch push mirror skipDefaultUpdate
|
2009-06-30 06:24:24 +02:00
|
|
|
receivepack uploadpack tagopt pushurl
|
2007-05-24 08:07:45 +02:00
|
|
|
" "$pfx" "$cur"
|
2006-11-27 10:44:47 +01:00
|
|
|
return
|
|
|
|
;;
|
|
|
|
remote.*)
|
|
|
|
local pfx="${cur%.*}."
|
|
|
|
cur="${cur#*.}"
|
2007-02-04 08:38:37 +01:00
|
|
|
__gitcomp "$(__git_remotes)" "$pfx" "$cur" "."
|
2006-11-27 10:44:47 +01:00
|
|
|
return
|
|
|
|
;;
|
2009-05-04 08:25:32 +02:00
|
|
|
url.*.*)
|
|
|
|
local pfx="${cur%.*}."
|
|
|
|
cur="${cur##*.}"
|
2009-09-07 10:56:33 +02:00
|
|
|
__gitcomp "insteadOf pushInsteadOf" "$pfx" "$cur"
|
2009-05-04 08:25:32 +02:00
|
|
|
return
|
|
|
|
;;
|
2006-11-27 10:44:47 +01:00
|
|
|
esac
|
2007-02-04 08:38:37 +01:00
|
|
|
__gitcomp "
|
2009-06-30 06:24:24 +02:00
|
|
|
add.ignore-errors
|
2009-05-04 08:25:31 +02:00
|
|
|
alias.
|
2009-08-04 13:16:49 +02:00
|
|
|
apply.ignorewhitespace
|
2006-11-27 10:44:47 +01:00
|
|
|
apply.whitespace
|
2008-12-15 18:45:49 +01:00
|
|
|
branch.autosetupmerge
|
|
|
|
branch.autosetuprebase
|
2007-04-24 02:18:16 +02:00
|
|
|
clean.requireForce
|
2007-02-04 08:38:37 +01:00
|
|
|
color.branch
|
|
|
|
color.branch.current
|
|
|
|
color.branch.local
|
|
|
|
color.branch.plain
|
2008-12-15 18:45:48 +01:00
|
|
|
color.branch.remote
|
2006-12-13 10:13:28 +01:00
|
|
|
color.diff
|
2008-12-15 18:45:48 +01:00
|
|
|
color.diff.commit
|
2007-02-04 08:38:37 +01:00
|
|
|
color.diff.frag
|
2008-12-15 18:45:48 +01:00
|
|
|
color.diff.meta
|
2007-02-04 08:38:37 +01:00
|
|
|
color.diff.new
|
2008-12-15 18:45:48 +01:00
|
|
|
color.diff.old
|
|
|
|
color.diff.plain
|
2007-02-04 08:38:37 +01:00
|
|
|
color.diff.whitespace
|
2009-05-04 08:25:31 +02:00
|
|
|
color.grep
|
|
|
|
color.grep.external
|
|
|
|
color.grep.match
|
2008-12-15 18:45:49 +01:00
|
|
|
color.interactive
|
|
|
|
color.interactive.header
|
|
|
|
color.interactive.help
|
|
|
|
color.interactive.prompt
|
2006-12-13 10:13:28 +01:00
|
|
|
color.pager
|
2009-04-25 13:46:14 +02:00
|
|
|
color.showbranch
|
2006-12-13 10:13:28 +01:00
|
|
|
color.status
|
2007-02-04 08:38:37 +01:00
|
|
|
color.status.added
|
|
|
|
color.status.changed
|
2008-12-15 18:45:48 +01:00
|
|
|
color.status.header
|
2008-12-15 18:45:49 +01:00
|
|
|
color.status.nobranch
|
2007-02-04 08:38:37 +01:00
|
|
|
color.status.untracked
|
2008-12-15 18:45:49 +01:00
|
|
|
color.status.updated
|
|
|
|
color.ui
|
|
|
|
commit.template
|
|
|
|
core.autocrlf
|
|
|
|
core.bare
|
2008-12-15 18:45:48 +01:00
|
|
|
core.compression
|
2009-05-04 08:25:31 +02:00
|
|
|
core.createObject
|
2008-12-15 18:45:49 +01:00
|
|
|
core.deltaBaseCacheLimit
|
|
|
|
core.editor
|
|
|
|
core.excludesfile
|
2008-12-15 18:45:48 +01:00
|
|
|
core.fileMode
|
2008-12-15 18:45:49 +01:00
|
|
|
core.fsyncobjectfiles
|
2008-12-15 18:45:48 +01:00
|
|
|
core.gitProxy
|
2008-12-15 18:45:49 +01:00
|
|
|
core.ignoreCygwinFSTricks
|
2008-12-15 18:45:48 +01:00
|
|
|
core.ignoreStat
|
|
|
|
core.logAllRefUpdates
|
|
|
|
core.loosecompression
|
|
|
|
core.packedGitLimit
|
|
|
|
core.packedGitWindowSize
|
2008-12-15 18:45:49 +01:00
|
|
|
core.pager
|
2008-12-15 18:45:48 +01:00
|
|
|
core.preferSymlinkRefs
|
2008-12-15 18:45:49 +01:00
|
|
|
core.preloadindex
|
|
|
|
core.quotepath
|
2008-12-15 18:45:48 +01:00
|
|
|
core.repositoryFormatVersion
|
2008-12-15 18:45:49 +01:00
|
|
|
core.safecrlf
|
2008-12-15 18:45:48 +01:00
|
|
|
core.sharedRepository
|
2008-12-15 18:45:49 +01:00
|
|
|
core.symlinks
|
|
|
|
core.trustctime
|
2008-12-15 18:45:48 +01:00
|
|
|
core.warnAmbiguousRefs
|
2008-12-15 18:45:49 +01:00
|
|
|
core.whitespace
|
|
|
|
core.worktree
|
|
|
|
diff.autorefreshindex
|
|
|
|
diff.external
|
|
|
|
diff.mnemonicprefix
|
2007-02-04 08:38:37 +01:00
|
|
|
diff.renameLimit
|
2008-12-15 18:45:49 +01:00
|
|
|
diff.renameLimit.
|
2007-02-04 08:38:37 +01:00
|
|
|
diff.renames
|
2009-05-04 08:25:31 +02:00
|
|
|
diff.suppressBlankEmpty
|
|
|
|
diff.tool
|
|
|
|
diff.wordRegex
|
2009-05-04 08:25:32 +02:00
|
|
|
difftool.
|
2009-05-04 08:25:31 +02:00
|
|
|
difftool.prompt
|
2007-02-04 08:38:37 +01:00
|
|
|
fetch.unpackLimit
|
2009-05-04 08:25:31 +02:00
|
|
|
format.attach
|
|
|
|
format.cc
|
2007-02-04 08:38:37 +01:00
|
|
|
format.headers
|
2008-12-15 18:45:49 +01:00
|
|
|
format.numbered
|
|
|
|
format.pretty
|
2009-05-04 08:25:31 +02:00
|
|
|
format.signoff
|
|
|
|
format.subjectprefix
|
2008-12-15 18:45:49 +01:00
|
|
|
format.suffix
|
2009-05-04 08:25:31 +02:00
|
|
|
format.thread
|
2008-12-15 18:45:49 +01:00
|
|
|
gc.aggressiveWindow
|
|
|
|
gc.auto
|
|
|
|
gc.autopacklimit
|
2007-05-24 08:07:45 +02:00
|
|
|
gc.packrefs
|
2008-12-15 18:45:49 +01:00
|
|
|
gc.pruneexpire
|
2007-02-04 08:38:37 +01:00
|
|
|
gc.reflogexpire
|
|
|
|
gc.reflogexpireunreachable
|
|
|
|
gc.rerereresolved
|
|
|
|
gc.rerereunresolved
|
2008-12-15 18:45:48 +01:00
|
|
|
gitcvs.allbinary
|
2009-05-04 08:25:31 +02:00
|
|
|
gitcvs.commitmsgannotation
|
2008-12-15 18:45:49 +01:00
|
|
|
gitcvs.dbTableNamePrefix
|
2008-12-15 18:45:48 +01:00
|
|
|
gitcvs.dbdriver
|
|
|
|
gitcvs.dbname
|
|
|
|
gitcvs.dbpass
|
|
|
|
gitcvs.dbuser
|
|
|
|
gitcvs.enabled
|
|
|
|
gitcvs.logfile
|
2008-12-15 18:45:49 +01:00
|
|
|
gitcvs.usecrlfattr
|
2009-05-04 08:25:32 +02:00
|
|
|
guitool.
|
2008-12-15 18:45:49 +01:00
|
|
|
gui.blamehistoryctx
|
|
|
|
gui.commitmsgwidth
|
|
|
|
gui.copyblamethreshold
|
|
|
|
gui.diffcontext
|
|
|
|
gui.encoding
|
|
|
|
gui.fastcopyblame
|
|
|
|
gui.matchtrackingbranch
|
|
|
|
gui.newbranchtemplate
|
|
|
|
gui.pruneduringfetch
|
|
|
|
gui.spellingdictionary
|
|
|
|
gui.trustmtime
|
|
|
|
help.autocorrect
|
|
|
|
help.browser
|
|
|
|
help.format
|
2007-02-04 08:38:37 +01:00
|
|
|
http.lowSpeedLimit
|
|
|
|
http.lowSpeedTime
|
2008-12-15 18:45:48 +01:00
|
|
|
http.maxRequests
|
2006-11-27 10:44:47 +01:00
|
|
|
http.noEPSV
|
2008-12-15 18:45:49 +01:00
|
|
|
http.proxy
|
2008-12-15 18:45:48 +01:00
|
|
|
http.sslCAInfo
|
|
|
|
http.sslCAPath
|
|
|
|
http.sslCert
|
|
|
|
http.sslKey
|
|
|
|
http.sslVerify
|
2007-02-04 08:38:37 +01:00
|
|
|
i18n.commitEncoding
|
|
|
|
i18n.logOutputEncoding
|
2009-05-04 08:25:31 +02:00
|
|
|
imap.folder
|
|
|
|
imap.host
|
|
|
|
imap.pass
|
|
|
|
imap.port
|
|
|
|
imap.preformattedHTML
|
|
|
|
imap.sslverify
|
|
|
|
imap.tunnel
|
|
|
|
imap.user
|
2008-12-15 18:45:49 +01:00
|
|
|
instaweb.browser
|
|
|
|
instaweb.httpd
|
|
|
|
instaweb.local
|
|
|
|
instaweb.modulepath
|
|
|
|
instaweb.port
|
2009-05-04 08:25:31 +02:00
|
|
|
interactive.singlekey
|
2008-12-15 18:45:49 +01:00
|
|
|
log.date
|
2007-02-04 08:38:37 +01:00
|
|
|
log.showroot
|
2009-05-04 08:25:31 +02:00
|
|
|
mailmap.file
|
2009-05-04 08:25:32 +02:00
|
|
|
man.
|
2008-12-15 18:45:49 +01:00
|
|
|
man.viewer
|
|
|
|
merge.conflictstyle
|
|
|
|
merge.log
|
|
|
|
merge.renameLimit
|
|
|
|
merge.stat
|
2008-12-15 18:45:48 +01:00
|
|
|
merge.tool
|
2007-02-04 08:38:37 +01:00
|
|
|
merge.verbosity
|
2009-05-04 08:25:32 +02:00
|
|
|
mergetool.
|
2008-12-15 18:45:49 +01:00
|
|
|
mergetool.keepBackup
|
2009-05-04 08:25:31 +02:00
|
|
|
mergetool.prompt
|
2007-08-23 07:39:22 +02:00
|
|
|
pack.compression
|
|
|
|
pack.deltaCacheLimit
|
2008-12-15 18:45:48 +01:00
|
|
|
pack.deltaCacheSize
|
|
|
|
pack.depth
|
2008-12-15 18:45:49 +01:00
|
|
|
pack.indexVersion
|
|
|
|
pack.packSizeLimit
|
|
|
|
pack.threads
|
2008-12-15 18:45:48 +01:00
|
|
|
pack.window
|
|
|
|
pack.windowMemory
|
2009-05-04 08:25:32 +02:00
|
|
|
pager.
|
2007-02-04 08:38:37 +01:00
|
|
|
pull.octopus
|
|
|
|
pull.twohead
|
2009-05-04 08:25:31 +02:00
|
|
|
push.default
|
|
|
|
rebase.stat
|
2008-12-15 18:45:49 +01:00
|
|
|
receive.denyCurrentBranch
|
|
|
|
receive.denyDeletes
|
2008-12-15 18:45:48 +01:00
|
|
|
receive.denyNonFastForwards
|
2008-12-15 18:45:49 +01:00
|
|
|
receive.fsckObjects
|
2008-12-15 18:45:48 +01:00
|
|
|
receive.unpackLimit
|
2008-12-15 18:45:49 +01:00
|
|
|
repack.usedeltabaseoffset
|
|
|
|
rerere.autoupdate
|
|
|
|
rerere.enabled
|
2009-05-04 08:25:31 +02:00
|
|
|
sendemail.aliasesfile
|
|
|
|
sendemail.aliasesfiletype
|
|
|
|
sendemail.bcc
|
|
|
|
sendemail.cc
|
|
|
|
sendemail.cccmd
|
|
|
|
sendemail.chainreplyto
|
|
|
|
sendemail.confirm
|
|
|
|
sendemail.envelopesender
|
|
|
|
sendemail.multiedit
|
|
|
|
sendemail.signedoffbycc
|
|
|
|
sendemail.smtpencryption
|
|
|
|
sendemail.smtppass
|
|
|
|
sendemail.smtpserver
|
|
|
|
sendemail.smtpserverport
|
|
|
|
sendemail.smtpuser
|
|
|
|
sendemail.suppresscc
|
|
|
|
sendemail.suppressfrom
|
|
|
|
sendemail.thread
|
|
|
|
sendemail.to
|
|
|
|
sendemail.validate
|
2007-02-04 08:38:37 +01:00
|
|
|
showbranch.default
|
2008-12-15 18:45:49 +01:00
|
|
|
status.relativePaths
|
|
|
|
status.showUntrackedFiles
|
2007-02-04 08:38:37 +01:00
|
|
|
tar.umask
|
|
|
|
transfer.unpackLimit
|
2009-05-04 08:25:32 +02:00
|
|
|
url.
|
2007-02-04 08:38:37 +01:00
|
|
|
user.email
|
2008-12-15 18:45:48 +01:00
|
|
|
user.name
|
2007-02-04 08:38:37 +01:00
|
|
|
user.signingkey
|
2008-12-15 18:45:49 +01:00
|
|
|
web.browser
|
2006-11-27 10:44:47 +01:00
|
|
|
branch. remote.
|
2007-02-04 08:38:37 +01:00
|
|
|
"
|
2006-11-27 10:44:47 +01:00
|
|
|
}
|
|
|
|
|
2007-02-05 05:52:08 +01:00
|
|
|
_git_remote ()
|
|
|
|
{
|
2009-02-25 09:32:25 +01:00
|
|
|
local subcommands="add rename rm show prune update set-head"
|
2009-09-15 12:21:43 +02:00
|
|
|
local subcommand="$(__git_find_on_cmdline "$subcommands")"
|
2008-03-10 16:02:23 +01:00
|
|
|
if [ -z "$subcommand" ]; then
|
2008-04-20 21:34:07 +02:00
|
|
|
__gitcomp "$subcommands"
|
2007-02-05 05:52:08 +01:00
|
|
|
return
|
|
|
|
fi
|
|
|
|
|
2008-03-10 16:02:23 +01:00
|
|
|
case "$subcommand" in
|
2009-01-21 20:14:55 +01:00
|
|
|
rename|rm|show|prune)
|
2007-02-05 05:52:08 +01:00
|
|
|
__gitcomp "$(__git_remotes)"
|
|
|
|
;;
|
2007-05-24 07:46:49 +02:00
|
|
|
update)
|
|
|
|
local i c='' IFS=$'\n'
|
2009-09-12 01:23:45 +02:00
|
|
|
for i in $(git --git-dir="$(__gitdir)" config --get-regexp "remotes\..*" 2>/dev/null); do
|
|
|
|
i="${i#remotes.}"
|
|
|
|
c="$c ${i/ */}"
|
2007-05-24 07:46:49 +02:00
|
|
|
done
|
|
|
|
__gitcomp "$c"
|
|
|
|
;;
|
2007-02-05 05:52:08 +01:00
|
|
|
*)
|
|
|
|
COMPREPLY=()
|
|
|
|
;;
|
|
|
|
esac
|
|
|
|
}
|
|
|
|
|
2009-10-09 22:49:06 +02:00
|
|
|
_git_replace ()
|
|
|
|
{
|
|
|
|
__gitcomp "$(__git_refs)"
|
|
|
|
}
|
|
|
|
|
2006-11-04 19:57:44 +01:00
|
|
|
_git_reset ()
|
|
|
|
{
|
bash: offer only paths after '--'
Many git commands use '--' to separate subcommands, options, and refs
from paths. However, the programmable completion for several of these
commands does not respect the '--', and offer subcommands, options, or
refs after a '--', although only paths are permitted. e.g. 'git bisect
-- <TAB>' offers subcommands, 'git log -- --<TAB>' offers options and
'git log -- git<TAB>' offers all gitgui tags.
The completion for the following commands share this wrong behaviour:
am add bisect commit diff log reset shortlog submodule gitk.
To avoid this, we check the presence of a '--' on the command line first
and let the shell do filename completion, if one is found.
Signed-off-by: SZEDER Gábor <szeder@ira.uka.de>
Acked-by: Shawn O. Pearce <spearce@spearce.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-07-08 18:56:14 +02:00
|
|
|
__git_has_doubledash && return
|
|
|
|
|
2006-11-04 19:57:44 +01:00
|
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
2007-02-04 08:38:43 +01:00
|
|
|
case "$cur" in
|
|
|
|
--*)
|
2009-09-15 12:21:45 +02:00
|
|
|
__gitcomp "--merge --mixed --hard --soft --patch"
|
2007-02-04 08:38:43 +01:00
|
|
|
return
|
|
|
|
;;
|
|
|
|
esac
|
|
|
|
__gitcomp "$(__git_refs)"
|
2006-11-04 19:57:44 +01:00
|
|
|
}
|
|
|
|
|
2008-08-05 07:50:34 +02:00
|
|
|
_git_revert ()
|
|
|
|
{
|
|
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
|
|
case "$cur" in
|
|
|
|
--*)
|
|
|
|
__gitcomp "--edit --mainline --no-edit --no-commit --signoff"
|
|
|
|
return
|
|
|
|
;;
|
|
|
|
esac
|
2008-11-27 14:35:53 +01:00
|
|
|
__gitcomp "$(__git_refs)"
|
2008-08-05 07:50:34 +02:00
|
|
|
}
|
|
|
|
|
2008-07-23 23:21:08 +02:00
|
|
|
_git_rm ()
|
|
|
|
{
|
|
|
|
__git_has_doubledash && return
|
|
|
|
|
|
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
|
|
case "$cur" in
|
|
|
|
--*)
|
|
|
|
__gitcomp "--cached --dry-run --ignore-unmatch --quiet"
|
|
|
|
return
|
|
|
|
;;
|
|
|
|
esac
|
|
|
|
COMPREPLY=()
|
|
|
|
}
|
|
|
|
|
2007-05-24 07:25:34 +02:00
|
|
|
_git_shortlog ()
|
|
|
|
{
|
bash: offer only paths after '--'
Many git commands use '--' to separate subcommands, options, and refs
from paths. However, the programmable completion for several of these
commands does not respect the '--', and offer subcommands, options, or
refs after a '--', although only paths are permitted. e.g. 'git bisect
-- <TAB>' offers subcommands, 'git log -- --<TAB>' offers options and
'git log -- git<TAB>' offers all gitgui tags.
The completion for the following commands share this wrong behaviour:
am add bisect commit diff log reset shortlog submodule gitk.
To avoid this, we check the presence of a '--' on the command line first
and let the shell do filename completion, if one is found.
Signed-off-by: SZEDER Gábor <szeder@ira.uka.de>
Acked-by: Shawn O. Pearce <spearce@spearce.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-07-08 18:56:14 +02:00
|
|
|
__git_has_doubledash && return
|
|
|
|
|
2007-05-24 07:25:34 +02:00
|
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
|
|
case "$cur" in
|
|
|
|
--*)
|
|
|
|
__gitcomp "
|
2009-02-16 17:34:56 +01:00
|
|
|
$__git_log_common_options
|
|
|
|
$__git_log_shortlog_options
|
2007-05-24 07:25:34 +02:00
|
|
|
--numbered --summary
|
|
|
|
"
|
|
|
|
return
|
|
|
|
;;
|
|
|
|
esac
|
|
|
|
__git_complete_revlist
|
|
|
|
}
|
|
|
|
|
2006-12-15 08:20:03 +01:00
|
|
|
_git_show ()
|
|
|
|
{
|
2008-10-31 01:04:46 +01:00
|
|
|
__git_has_doubledash && return
|
|
|
|
|
2006-12-15 08:20:03 +01:00
|
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
|
|
case "$cur" in
|
|
|
|
--pretty=*)
|
2009-01-16 17:02:15 +01:00
|
|
|
__gitcomp "$__git_log_pretty_formats
|
2007-02-04 08:38:43 +01:00
|
|
|
" "" "${cur##--pretty=}"
|
2006-12-15 08:20:03 +01:00
|
|
|
return
|
|
|
|
;;
|
2009-02-24 14:33:29 +01:00
|
|
|
--format=*)
|
|
|
|
__gitcomp "$__git_log_pretty_formats
|
|
|
|
" "" "${cur##--format=}"
|
|
|
|
return
|
|
|
|
;;
|
2006-12-15 08:20:03 +01:00
|
|
|
--*)
|
2009-05-17 05:42:43 +02:00
|
|
|
__gitcomp "--pretty= --format= --abbrev-commit --oneline
|
2009-01-19 22:18:00 +01:00
|
|
|
$__git_diff_common_options
|
|
|
|
"
|
2006-12-15 08:20:03 +01:00
|
|
|
return
|
|
|
|
;;
|
|
|
|
esac
|
|
|
|
__git_complete_file
|
|
|
|
}
|
|
|
|
|
2008-07-23 23:36:15 +02:00
|
|
|
_git_show_branch ()
|
|
|
|
{
|
|
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
|
|
case "$cur" in
|
|
|
|
--*)
|
|
|
|
__gitcomp "
|
|
|
|
--all --remotes --topo-order --current --more=
|
|
|
|
--list --independent --merge-base --no-name
|
2009-04-25 13:46:14 +02:00
|
|
|
--color --no-color
|
2009-05-17 05:42:43 +02:00
|
|
|
--sha1-name --sparse --topics --reflog
|
2008-07-23 23:36:15 +02:00
|
|
|
"
|
|
|
|
return
|
|
|
|
;;
|
|
|
|
esac
|
|
|
|
__git_complete_revlist
|
|
|
|
}
|
|
|
|
|
2007-08-03 11:04:37 +02:00
|
|
|
_git_stash ()
|
|
|
|
{
|
2009-09-15 12:21:44 +02:00
|
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
|
|
local save_opts='--keep-index --no-keep-index --quiet --patch'
|
2008-08-05 07:50:35 +02:00
|
|
|
local subcommands='save list show apply clear drop pop create branch'
|
2009-09-15 12:21:43 +02:00
|
|
|
local subcommand="$(__git_find_on_cmdline "$subcommands")"
|
2008-06-27 16:37:15 +02:00
|
|
|
if [ -z "$subcommand" ]; then
|
2009-09-15 12:21:44 +02:00
|
|
|
case "$cur" in
|
|
|
|
--*)
|
|
|
|
__gitcomp "$save_opts"
|
|
|
|
;;
|
|
|
|
*)
|
|
|
|
if [ -z "$(__git_find_on_cmdline "$save_opts")" ]; then
|
|
|
|
__gitcomp "$subcommands"
|
|
|
|
else
|
|
|
|
COMPREPLY=()
|
|
|
|
fi
|
|
|
|
;;
|
|
|
|
esac
|
2008-06-27 16:37:15 +02:00
|
|
|
else
|
|
|
|
case "$subcommand,$cur" in
|
|
|
|
save,--*)
|
2009-09-15 12:21:44 +02:00
|
|
|
__gitcomp "$save_opts"
|
2008-06-27 16:37:15 +02:00
|
|
|
;;
|
2009-06-09 00:57:39 +02:00
|
|
|
apply,--*|pop,--*)
|
2009-09-15 12:21:44 +02:00
|
|
|
__gitcomp "--index --quiet"
|
2008-08-05 07:50:35 +02:00
|
|
|
;;
|
2009-06-09 00:57:39 +02:00
|
|
|
show,--*|drop,--*|branch,--*)
|
2008-08-05 07:50:35 +02:00
|
|
|
COMPREPLY=()
|
|
|
|
;;
|
|
|
|
show,*|apply,*|drop,*|pop,*|branch,*)
|
|
|
|
__gitcomp "$(git --git-dir="$(__gitdir)" stash list \
|
|
|
|
| sed -n -e 's/:.*//p')"
|
|
|
|
;;
|
2008-06-27 16:37:15 +02:00
|
|
|
*)
|
|
|
|
COMPREPLY=()
|
|
|
|
;;
|
|
|
|
esac
|
2008-03-10 16:02:23 +01:00
|
|
|
fi
|
2007-08-03 11:04:37 +02:00
|
|
|
}
|
|
|
|
|
2007-08-23 07:50:49 +02:00
|
|
|
_git_submodule ()
|
|
|
|
{
|
bash: offer only paths after '--'
Many git commands use '--' to separate subcommands, options, and refs
from paths. However, the programmable completion for several of these
commands does not respect the '--', and offer subcommands, options, or
refs after a '--', although only paths are permitted. e.g. 'git bisect
-- <TAB>' offers subcommands, 'git log -- --<TAB>' offers options and
'git log -- git<TAB>' offers all gitgui tags.
The completion for the following commands share this wrong behaviour:
am add bisect commit diff log reset shortlog submodule gitk.
To avoid this, we check the presence of a '--' on the command line first
and let the shell do filename completion, if one is found.
Signed-off-by: SZEDER Gábor <szeder@ira.uka.de>
Acked-by: Shawn O. Pearce <spearce@spearce.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-07-08 18:56:14 +02:00
|
|
|
__git_has_doubledash && return
|
|
|
|
|
2008-08-28 10:57:55 +02:00
|
|
|
local subcommands="add status init update summary foreach sync"
|
2009-09-15 12:21:43 +02:00
|
|
|
if [ -z "$(__git_find_on_cmdline "$subcommands")" ]; then
|
2007-08-23 07:50:49 +02:00
|
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
|
|
case "$cur" in
|
|
|
|
--*)
|
|
|
|
__gitcomp "--quiet --cached"
|
|
|
|
;;
|
|
|
|
*)
|
2008-03-10 16:02:23 +01:00
|
|
|
__gitcomp "$subcommands"
|
2007-08-23 07:50:49 +02:00
|
|
|
;;
|
|
|
|
esac
|
|
|
|
return
|
|
|
|
fi
|
|
|
|
}
|
|
|
|
|
2008-03-10 16:02:25 +01:00
|
|
|
_git_svn ()
|
|
|
|
{
|
|
|
|
local subcommands="
|
|
|
|
init fetch clone rebase dcommit log find-rev
|
|
|
|
set-tree commit-diff info create-ignore propget
|
2009-02-14 17:21:53 +01:00
|
|
|
proplist show-ignore show-externals branch tag blame
|
2009-12-30 01:58:48 +01:00
|
|
|
migrate mkdirs reset gc
|
2008-03-10 16:02:25 +01:00
|
|
|
"
|
2009-09-15 12:21:43 +02:00
|
|
|
local subcommand="$(__git_find_on_cmdline "$subcommands")"
|
2008-03-10 16:02:25 +01:00
|
|
|
if [ -z "$subcommand" ]; then
|
|
|
|
__gitcomp "$subcommands"
|
|
|
|
else
|
|
|
|
local remote_opts="--username= --config-dir= --no-auth-cache"
|
|
|
|
local fc_opts="
|
|
|
|
--follow-parent --authors-file= --repack=
|
|
|
|
--no-metadata --use-svm-props --use-svnsync-props
|
|
|
|
--log-window-size= --no-checkout --quiet
|
2009-02-14 17:21:53 +01:00
|
|
|
--repack-flags --use-log-author --localtime
|
|
|
|
--ignore-paths= $remote_opts
|
2008-03-10 16:02:25 +01:00
|
|
|
"
|
|
|
|
local init_opts="
|
|
|
|
--template= --shared= --trunk= --tags=
|
|
|
|
--branches= --stdlayout --minimize-url
|
|
|
|
--no-metadata --use-svm-props --use-svnsync-props
|
2009-02-14 17:21:53 +01:00
|
|
|
--rewrite-root= --prefix= --use-log-author
|
|
|
|
--add-author-from $remote_opts
|
2008-03-10 16:02:25 +01:00
|
|
|
"
|
|
|
|
local cmt_opts="
|
|
|
|
--edit --rmdir --find-copies-harder --copy-similarity=
|
|
|
|
"
|
|
|
|
|
|
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
|
|
case "$subcommand,$cur" in
|
|
|
|
fetch,--*)
|
|
|
|
__gitcomp "--revision= --fetch-all $fc_opts"
|
|
|
|
;;
|
|
|
|
clone,--*)
|
|
|
|
__gitcomp "--revision= $fc_opts $init_opts"
|
|
|
|
;;
|
|
|
|
init,--*)
|
|
|
|
__gitcomp "$init_opts"
|
|
|
|
;;
|
|
|
|
dcommit,--*)
|
|
|
|
__gitcomp "
|
|
|
|
--merge --strategy= --verbose --dry-run
|
2009-02-14 17:21:53 +01:00
|
|
|
--fetch-all --no-rebase --commit-url
|
|
|
|
--revision $cmt_opts $fc_opts
|
2008-03-10 16:02:25 +01:00
|
|
|
"
|
|
|
|
;;
|
|
|
|
set-tree,--*)
|
|
|
|
__gitcomp "--stdin $cmt_opts $fc_opts"
|
|
|
|
;;
|
|
|
|
create-ignore,--*|propget,--*|proplist,--*|show-ignore,--*|\
|
2009-12-30 01:58:48 +01:00
|
|
|
show-externals,--*|mkdirs,--*)
|
2008-03-10 16:02:25 +01:00
|
|
|
__gitcomp "--revision="
|
|
|
|
;;
|
|
|
|
log,--*)
|
|
|
|
__gitcomp "
|
|
|
|
--limit= --revision= --verbose --incremental
|
|
|
|
--oneline --show-commit --non-recursive
|
2009-02-14 17:21:53 +01:00
|
|
|
--authors-file= --color
|
2008-03-10 16:02:25 +01:00
|
|
|
"
|
|
|
|
;;
|
|
|
|
rebase,--*)
|
|
|
|
__gitcomp "
|
|
|
|
--merge --verbose --strategy= --local
|
2009-02-14 17:21:53 +01:00
|
|
|
--fetch-all --dry-run $fc_opts
|
2008-03-10 16:02:25 +01:00
|
|
|
"
|
|
|
|
;;
|
|
|
|
commit-diff,--*)
|
|
|
|
__gitcomp "--message= --file= --revision= $cmt_opts"
|
|
|
|
;;
|
|
|
|
info,--*)
|
|
|
|
__gitcomp "--url"
|
|
|
|
;;
|
2009-02-14 17:21:53 +01:00
|
|
|
branch,--*)
|
|
|
|
__gitcomp "--dry-run --message --tag"
|
|
|
|
;;
|
|
|
|
tag,--*)
|
|
|
|
__gitcomp "--dry-run --message"
|
|
|
|
;;
|
|
|
|
blame,--*)
|
|
|
|
__gitcomp "--git-format"
|
|
|
|
;;
|
|
|
|
migrate,--*)
|
|
|
|
__gitcomp "
|
|
|
|
--config-dir= --ignore-paths= --minimize
|
|
|
|
--no-auth-cache --username=
|
|
|
|
"
|
|
|
|
;;
|
2009-12-30 01:58:48 +01:00
|
|
|
reset,--*)
|
|
|
|
__gitcomp "--revision= --parent"
|
|
|
|
;;
|
2008-03-10 16:02:25 +01:00
|
|
|
*)
|
|
|
|
COMPREPLY=()
|
|
|
|
;;
|
|
|
|
esac
|
|
|
|
fi
|
|
|
|
}
|
|
|
|
|
2007-09-01 05:47:01 +02:00
|
|
|
_git_tag ()
|
|
|
|
{
|
|
|
|
local i c=1 f=0
|
|
|
|
while [ $c -lt $COMP_CWORD ]; do
|
|
|
|
i="${COMP_WORDS[c]}"
|
|
|
|
case "$i" in
|
|
|
|
-d|-v)
|
|
|
|
__gitcomp "$(__git_tags)"
|
|
|
|
return
|
|
|
|
;;
|
|
|
|
-f)
|
|
|
|
f=1
|
|
|
|
;;
|
|
|
|
esac
|
|
|
|
c=$((++c))
|
|
|
|
done
|
|
|
|
|
|
|
|
case "${COMP_WORDS[COMP_CWORD-1]}" in
|
|
|
|
-m|-F)
|
|
|
|
COMPREPLY=()
|
|
|
|
;;
|
2008-11-27 14:35:38 +01:00
|
|
|
-*|tag)
|
2007-09-01 05:47:01 +02:00
|
|
|
if [ $f = 1 ]; then
|
|
|
|
__gitcomp "$(__git_tags)"
|
|
|
|
else
|
|
|
|
COMPREPLY=()
|
|
|
|
fi
|
|
|
|
;;
|
|
|
|
*)
|
|
|
|
__gitcomp "$(__git_refs)"
|
|
|
|
;;
|
|
|
|
esac
|
|
|
|
}
|
|
|
|
|
bash: support user-supplied completion scripts for user's git commands
The bash completion script already provides support to complete
aliases, options and refs for aliases (if the alias can be traced back
to a supported git command by __git_aliased_command()), and the user's
custom git commands, but it does not support the options of the user's
custom git commands (of course; how could it know about the options of
a custom git command?). Users of such custom git commands could
extend git's bash completion script by writing functions to support
their commands, but they might have issues with it: they might not
have the rights to modify a system-wide git completion script, and
they will need to track and merge upstream changes in the future.
This patch addresses this by providing means for users to supply
custom completion scriplets for their custom git commands without
modifying the main git bash completion script.
Instead of having a huge hard-coded list of command-completion
function pairs (in _git()), the completion script will figure out
which completion function to call based on the command's name. That
is, when completing the options of 'git foo', the main completion
script will check whether the function '_git_foo' is declared, and if
declared, it will invoke that function to perform the completion. If
such a function is not declared, it will fall back to complete file
names. So, users will only need to provide this '_git_foo' completion
function in a separate file, source that file, and it will be used the
next time they press TAB after 'git foo '.
There are two git commands (stage and whatchanged), for which the
completion functions of other commands were used, therefore they
got their own completion function.
Signed-off-by: SZEDER Gábor <szeder@ira.uka.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-02-23 22:02:58 +01:00
|
|
|
_git_whatchanged ()
|
|
|
|
{
|
|
|
|
_git_log
|
|
|
|
}
|
|
|
|
|
2006-09-28 11:31:25 +02:00
|
|
|
_git ()
|
|
|
|
{
|
2006-11-05 12:21:57 +01:00
|
|
|
local i c=1 command __git_dir
|
|
|
|
|
|
|
|
while [ $c -lt $COMP_CWORD ]; do
|
|
|
|
i="${COMP_WORDS[c]}"
|
|
|
|
case "$i" in
|
|
|
|
--git-dir=*) __git_dir="${i#--git-dir=}" ;;
|
|
|
|
--bare) __git_dir="." ;;
|
2008-07-24 02:07:23 +02:00
|
|
|
--version|-p|--paginate) ;;
|
|
|
|
--help) command="help"; break ;;
|
2006-11-05 12:21:57 +01:00
|
|
|
*) command="$i"; break ;;
|
|
|
|
esac
|
|
|
|
c=$((++c))
|
|
|
|
done
|
|
|
|
|
2008-03-10 16:02:22 +01:00
|
|
|
if [ -z "$command" ]; then
|
2007-02-04 08:38:27 +01:00
|
|
|
case "${COMP_WORDS[COMP_CWORD]}" in
|
2007-08-23 07:39:22 +02:00
|
|
|
--*) __gitcomp "
|
2008-03-06 17:52:37 +01:00
|
|
|
--paginate
|
2007-08-23 07:39:22 +02:00
|
|
|
--no-pager
|
|
|
|
--git-dir=
|
|
|
|
--bare
|
|
|
|
--version
|
|
|
|
--exec-path
|
2009-04-05 04:15:16 +02:00
|
|
|
--html-path
|
2008-03-06 17:52:37 +01:00
|
|
|
--work-tree=
|
|
|
|
--help
|
2007-08-23 07:39:22 +02:00
|
|
|
"
|
|
|
|
;;
|
2009-11-18 01:49:10 +01:00
|
|
|
*) __git_compute_porcelain_commands
|
|
|
|
__gitcomp "$__git_porcelain_commands $(__git_aliases)" ;;
|
2007-02-04 08:38:27 +01:00
|
|
|
esac
|
|
|
|
return
|
2006-11-05 12:21:57 +01:00
|
|
|
fi
|
2006-10-28 14:12:20 +02:00
|
|
|
|
bash: support user-supplied completion scripts for user's git commands
The bash completion script already provides support to complete
aliases, options and refs for aliases (if the alias can be traced back
to a supported git command by __git_aliased_command()), and the user's
custom git commands, but it does not support the options of the user's
custom git commands (of course; how could it know about the options of
a custom git command?). Users of such custom git commands could
extend git's bash completion script by writing functions to support
their commands, but they might have issues with it: they might not
have the rights to modify a system-wide git completion script, and
they will need to track and merge upstream changes in the future.
This patch addresses this by providing means for users to supply
custom completion scriplets for their custom git commands without
modifying the main git bash completion script.
Instead of having a huge hard-coded list of command-completion
function pairs (in _git()), the completion script will figure out
which completion function to call based on the command's name. That
is, when completing the options of 'git foo', the main completion
script will check whether the function '_git_foo' is declared, and if
declared, it will invoke that function to perform the completion. If
such a function is not declared, it will fall back to complete file
names. So, users will only need to provide this '_git_foo' completion
function in a separate file, source that file, and it will be used the
next time they press TAB after 'git foo '.
There are two git commands (stage and whatchanged), for which the
completion functions of other commands were used, therefore they
got their own completion function.
Signed-off-by: SZEDER Gábor <szeder@ira.uka.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-02-23 22:02:58 +01:00
|
|
|
local completion_func="_git_${command//-/_}"
|
bash: support user-supplied completion scripts for aliases
Shell command aliases can get rather complex, and the completion
script can not always determine correctly the git command invoked by
such an alias. For such cases users might want to provide custom
completion scripts the same way like for their custom commands made
possible by the previous patch.
The current completion script does not allow this, because if it
encounters an alias, then it will unconditionally perform completion
for the aliased git command (in case it can determine the aliased git
command, of course). With this patch the completion script will first
search for a completion function for the command given on the command
line, be it a git command, a custom git command of the user, or an
alias, and invoke that function to perform the completion. This has
no effect on git commands, because they can not be aliased anyway. If
it is an alias and there is a completion function for that alias (e.g.
_git_foo() for the alias 'foo'), then it will be invoked to perform
completion, allowing users to provide custom completion functions for
aliases. If such a completion function can not be found, only then
will the completion script check whether the command given on the
command line is an alias or not, and proceed as usual (i.e. find out
the aliased git command and provide completion for it).
Signed-off-by: SZEDER Gábor <szeder@ira.uka.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-02-23 22:02:59 +01:00
|
|
|
declare -F $completion_func >/dev/null && $completion_func && return
|
|
|
|
|
2006-11-05 12:21:57 +01:00
|
|
|
local expansion=$(__git_aliased_command "$command")
|
bash: support user-supplied completion scripts for aliases
Shell command aliases can get rather complex, and the completion
script can not always determine correctly the git command invoked by
such an alias. For such cases users might want to provide custom
completion scripts the same way like for their custom commands made
possible by the previous patch.
The current completion script does not allow this, because if it
encounters an alias, then it will unconditionally perform completion
for the aliased git command (in case it can determine the aliased git
command, of course). With this patch the completion script will first
search for a completion function for the command given on the command
line, be it a git command, a custom git command of the user, or an
alias, and invoke that function to perform the completion. This has
no effect on git commands, because they can not be aliased anyway. If
it is an alias and there is a completion function for that alias (e.g.
_git_foo() for the alias 'foo'), then it will be invoked to perform
completion, allowing users to provide custom completion functions for
aliases. If such a completion function can not be found, only then
will the completion script check whether the command given on the
command line is an alias or not, and proceed as usual (i.e. find out
the aliased git command and provide completion for it).
Signed-off-by: SZEDER Gábor <szeder@ira.uka.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-02-23 22:02:59 +01:00
|
|
|
if [ -n "$expansion" ]; then
|
|
|
|
completion_func="_git_${expansion//-/_}"
|
|
|
|
declare -F $completion_func >/dev/null && $completion_func
|
|
|
|
fi
|
2006-09-28 11:31:25 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
_gitk ()
|
|
|
|
{
|
bash: offer only paths after '--'
Many git commands use '--' to separate subcommands, options, and refs
from paths. However, the programmable completion for several of these
commands does not respect the '--', and offer subcommands, options, or
refs after a '--', although only paths are permitted. e.g. 'git bisect
-- <TAB>' offers subcommands, 'git log -- --<TAB>' offers options and
'git log -- git<TAB>' offers all gitgui tags.
The completion for the following commands share this wrong behaviour:
am add bisect commit diff log reset shortlog submodule gitk.
To avoid this, we check the presence of a '--' on the command line first
and let the shell do filename completion, if one is found.
Signed-off-by: SZEDER Gábor <szeder@ira.uka.de>
Acked-by: Shawn O. Pearce <spearce@spearce.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-07-08 18:56:14 +02:00
|
|
|
__git_has_doubledash && return
|
|
|
|
|
2006-09-28 11:31:25 +02:00
|
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
2009-02-11 19:03:23 +01:00
|
|
|
local g="$(__gitdir)"
|
2008-04-27 17:35:10 +02:00
|
|
|
local merge=""
|
2009-03-30 13:27:37 +02:00
|
|
|
if [ -f "$g/MERGE_HEAD" ]; then
|
2008-04-27 17:35:10 +02:00
|
|
|
merge="--merge"
|
|
|
|
fi
|
2007-02-04 08:38:43 +01:00
|
|
|
case "$cur" in
|
|
|
|
--*)
|
2009-02-16 17:34:56 +01:00
|
|
|
__gitcomp "
|
|
|
|
$__git_log_common_options
|
|
|
|
$__git_log_gitk_options
|
|
|
|
$merge
|
|
|
|
"
|
2007-02-04 08:38:43 +01:00
|
|
|
return
|
|
|
|
;;
|
|
|
|
esac
|
2007-02-04 08:38:47 +01:00
|
|
|
__git_complete_revlist
|
2006-09-28 11:31:25 +02:00
|
|
|
}
|
|
|
|
|
2009-01-15 17:02:22 +01:00
|
|
|
complete -o bashdefault -o default -o nospace -F _git git 2>/dev/null \
|
|
|
|
|| complete -o default -o nospace -F _git git
|
|
|
|
complete -o bashdefault -o default -o nospace -F _gitk gitk 2>/dev/null \
|
|
|
|
|| complete -o default -o nospace -F _gitk gitk
|
2006-09-28 11:31:25 +02:00
|
|
|
|
|
|
|
# The following are necessary only for Cygwin, and only are needed
|
|
|
|
# when the user has tab-completed the executable name and consequently
|
|
|
|
# included the '.exe' suffix.
|
|
|
|
#
|
2006-11-05 12:20:25 +01:00
|
|
|
if [ Cygwin = "$(uname -o 2>/dev/null)" ]; then
|
2009-01-15 17:02:22 +01:00
|
|
|
complete -o bashdefault -o default -o nospace -F _git git.exe 2>/dev/null \
|
|
|
|
|| complete -o default -o nospace -F _git git.exe
|
2006-11-05 12:20:25 +01:00
|
|
|
fi
|