mirror of
git://git.code.sf.net/p/zsh/code
synced 2024-05-04 06:36:18 +02:00
510df60dd1
Joint work with Peter Grayson.
421 lines
17 KiB
Bash
421 lines
17 KiB
Bash
## vim:ft=zsh
|
|
## git support by: Frank Terbeck <ft@bewatermyfriend.org>
|
|
## Distributed under the same BSD-ish license as zsh itself.
|
|
|
|
setopt localoptions extendedglob NO_shwordsplit
|
|
local gitdir gitbase gitbranch gitaction gitunstaged gitstaged gitsha1 gitmisc
|
|
local -i querystaged queryunstaged
|
|
local -a git_patches_applied git_patches_unapplied
|
|
local -A hook_com
|
|
|
|
(( ${+functions[VCS_INFO_git_getaction]} )) ||
|
|
VCS_INFO_git_getaction () {
|
|
local gitdir=$1
|
|
local tmp
|
|
|
|
for tmp in "${gitdir}/rebase-apply" \
|
|
"${gitdir}/rebase" \
|
|
"${gitdir}/../.dotest" ; do
|
|
if [[ -d ${tmp} ]] ; then
|
|
if [[ -f "${tmp}/rebasing" ]] ; then
|
|
gitaction="rebase"
|
|
elif [[ -f "${tmp}/applying" ]] ; then
|
|
gitaction="am"
|
|
else
|
|
gitaction="am/rebase"
|
|
fi
|
|
return 0
|
|
fi
|
|
done
|
|
|
|
for tmp in "${gitdir}/rebase-merge/interactive" \
|
|
"${gitdir}/.dotest-merge/interactive" ; do
|
|
if [[ -f "${tmp}" ]] ; then
|
|
gitaction="rebase-i"
|
|
return 0
|
|
fi
|
|
done
|
|
|
|
for tmp in "${gitdir}/rebase-merge" \
|
|
"${gitdir}/.dotest-merge" ; do
|
|
if [[ -d "${tmp}" ]] ; then
|
|
gitaction="rebase-m"
|
|
return 0
|
|
fi
|
|
done
|
|
|
|
if [[ -f "${gitdir}/MERGE_HEAD" ]] ; then
|
|
gitaction="merge"
|
|
return 0
|
|
fi
|
|
|
|
if [[ -f "${gitdir}/BISECT_LOG" ]] ; then
|
|
gitaction="bisect"
|
|
return 0
|
|
fi
|
|
|
|
if [[ -f "${gitdir}/CHERRY_PICK_HEAD" ]] ; then
|
|
if [[ -d "${gitdir}/sequencer" ]] ; then
|
|
gitaction=cherry-seq
|
|
else
|
|
gitaction=cherry
|
|
fi
|
|
return 0
|
|
fi
|
|
|
|
if [[ -d "${gitdir}/sequencer" ]] ; then
|
|
gitaction="cherry-or-revert"
|
|
return 0
|
|
fi
|
|
|
|
return 1
|
|
}
|
|
|
|
(( ${+functions[VCS_INFO_git_getbranch]} )) ||
|
|
VCS_INFO_git_getbranch () {
|
|
local gitdir=$1 tmp actiondir
|
|
local gitsymref="${vcs_comm[cmd]} symbolic-ref HEAD"
|
|
|
|
actiondir=''
|
|
for tmp in "${gitdir}/rebase-apply" \
|
|
"${gitdir}/rebase" \
|
|
"${gitdir}/../.dotest"; do
|
|
if [[ -d ${tmp} ]]; then
|
|
actiondir=${tmp}
|
|
break
|
|
fi
|
|
done
|
|
if [[ -n ${actiondir} ]]; then
|
|
gitbranch="$(${(z)gitsymref} 2> /dev/null)"
|
|
[[ -z ${gitbranch} ]] && [[ -r ${actiondir}/head-name ]] \
|
|
&& gitbranch="$(< ${actiondir}/head-name)"
|
|
[[ -z ${gitbranch} || ${gitbranch} == 'detached HEAD' ]] && [[ -r ${actiondir}/onto ]] \
|
|
&& gitbranch="$(< ${actiondir}/onto)"
|
|
|
|
elif [[ -f "${gitdir}/MERGE_HEAD" ]] ; then
|
|
gitbranch="$(${(z)gitsymref} 2> /dev/null)"
|
|
[[ -z ${gitbranch} ]] && gitbranch="$(< ${gitdir}/ORIG_HEAD)"
|
|
|
|
elif [[ -d "${gitdir}/rebase-merge" ]] ; then
|
|
gitbranch="$(< ${gitdir}/rebase-merge/head-name)"
|
|
if [[ $gitbranch == 'detached HEAD' ]]; then
|
|
# get a sha1
|
|
gitbranch="$(< ${gitdir}/rebase-merge/orig-head)"
|
|
fi
|
|
|
|
elif [[ -d "${gitdir}/.dotest-merge" ]] ; then
|
|
gitbranch="$(< ${gitdir}/.dotest-merge/head-name)"
|
|
|
|
elif gitbranch="$(${(z)gitsymref} 2> /dev/null)" ; then
|
|
elif gitbranch="refs/tags/$(${vcs_comm[cmd]} describe --all --exact-match HEAD 2>/dev/null)" ; then
|
|
elif gitbranch="$(${vcs_comm[cmd]} describe --contains HEAD 2>/dev/null)" ; then
|
|
## Commented out because we don't know of a case in which 'describe --contains' fails and 'name-rev --tags' succeeds.
|
|
#elif gitbranch="$(${vcs_comm[cmd]} name-rev --name-only --no-undefined --tags HEAD 2>/dev/null)" ; then
|
|
elif gitbranch="$(${vcs_comm[cmd]} name-rev --name-only --no-undefined --always HEAD 2>/dev/null)" ; then
|
|
fi
|
|
|
|
if [[ -z ${gitbranch} ]]
|
|
then
|
|
gitbranch="${${"$(< $gitdir/HEAD)"}[1,7]}..."
|
|
fi
|
|
|
|
return 0
|
|
}
|
|
|
|
(( ${+functions[VCS_INFO_git_handle_patches]} )) ||
|
|
VCS_INFO_git_handle_patches () {
|
|
local git_applied_s git_unapplied_s gitmsg
|
|
# All callers populate $git_patches_applied and $git_patches_unapplied in
|
|
# order, but the hook requires us to reverse $git_patches_applied.
|
|
git_patches_applied=(${(Oa)git_patches_applied})
|
|
|
|
VCS_INFO_set-patch-format 'git_patches_applied' 'git_applied_s' \
|
|
'git_patches_unapplied' 'git_unapplied_s' \
|
|
":vcs_info:${vcs}:${usercontext}:${rrn}" gitmsg \
|
|
'' '' ''
|
|
gitmisc=$REPLY
|
|
}
|
|
|
|
gitdir=${vcs_comm[gitdir]}
|
|
VCS_INFO_git_getbranch ${gitdir}
|
|
gitbase=${vcs_comm[basedir]}
|
|
if [[ -z ${gitbase} ]]; then
|
|
# Bare repository
|
|
gitbase=${gitdir:P}
|
|
fi
|
|
rrn=${gitbase:t}
|
|
if zstyle -t ":vcs_info:${vcs}:${usercontext}:${rrn}" get-revision ; then
|
|
gitsha1=$(${vcs_comm[cmd]} rev-parse --quiet --verify HEAD)
|
|
else
|
|
gitsha1=''
|
|
fi
|
|
gitbranch="${gitbranch##refs/[^/]##/}"
|
|
|
|
if [[ -z ${gitdir} ]] || [[ -z ${gitbranch} ]] ; then
|
|
return 1
|
|
fi
|
|
|
|
if zstyle -t ":vcs_info:${vcs}:${usercontext}:${rrn}" "check-for-changes" ; then
|
|
querystaged=1
|
|
queryunstaged=1
|
|
elif zstyle -t ":vcs_info:${vcs}:${usercontext}:${rrn}" "check-for-staged-changes" ; then
|
|
querystaged=1
|
|
fi
|
|
if (( querystaged || queryunstaged )) && \
|
|
[[ "$(${vcs_comm[cmd]} rev-parse --is-inside-work-tree 2> /dev/null)" == 'true' ]] ; then
|
|
# Default: off - these are potentially expensive on big repositories
|
|
if (( queryunstaged )) ; then
|
|
${vcs_comm[cmd]} diff --no-ext-diff --ignore-submodules=dirty --quiet --exit-code 2> /dev/null ||
|
|
gitunstaged=1
|
|
fi
|
|
if (( querystaged )) ; then
|
|
if ${vcs_comm[cmd]} rev-parse --quiet --verify HEAD &> /dev/null ; then
|
|
${vcs_comm[cmd]} diff-index --cached --quiet --ignore-submodules=dirty HEAD 2> /dev/null
|
|
(( $? && $? != 128 )) && gitstaged=1
|
|
else
|
|
# empty repository (no commits yet)
|
|
# 4b825dc642cb6eb9a060e54bf8d69288fbee4904 is the git empty tree.
|
|
${vcs_comm[cmd]} diff-index --cached --quiet --ignore-submodules=dirty 4b825dc642cb6eb9a060e54bf8d69288fbee4904 2>/dev/null
|
|
(( $? && $? != 128 )) && gitstaged=1
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
VCS_INFO_adjust
|
|
VCS_INFO_git_getaction ${gitdir}
|
|
|
|
local patchdir
|
|
if [[ -d "${gitdir}/rebase-merge" ]]; then
|
|
# 'git rebase -i'
|
|
patchdir="${gitdir}/rebase-merge"
|
|
local p
|
|
(( ${+functions[VCS_INFO_git_map_rebase_line_to_hash_and_subject]} )) ||
|
|
VCS_INFO_git_map_rebase_line_to_hash_and_subject() {
|
|
local p=$1
|
|
unset REPLY
|
|
# pick/edit/fixup/squash/reword: Add "$hash $subject" to $git_patches_applied.
|
|
# exec: Add "exec ${command}" to $git_patches_applied.
|
|
# (anything else): As 'exec'.
|
|
case $p in
|
|
([#]*)
|
|
# Comment line. Skip.
|
|
return 0
|
|
;;
|
|
(''(p|pick|e|edit|r|reword|f|fixup|s|squash)' '*)
|
|
# The line is of the form "pick $hash $subject".
|
|
# Just strip the verb and we're good to go.
|
|
p=${p#* }
|
|
# Special case: in an interactive rebase, if the user wrote "p $shorthash\n"
|
|
# in the editor (without a description after the hash), then the .../done
|
|
# file will contain "p $longhash $shorthash\n" (git 2.11.0) or "pick $longhash\n"
|
|
# (git 2.19.0).
|
|
if [[ $p != *\ * ]]; then
|
|
# The line is of the form "pick $longhash\n"
|
|
#
|
|
# Mark the log message subject as unknown.
|
|
# TODO: Can we performantly obtain the subject?
|
|
p+=" ?"
|
|
elif (( ${#${p//[^ ]}} == 1 )) && [[ ${p%% *} == ${p#* }* ]]; then
|
|
# The line is of the form "p $longhash $shorthash\n"
|
|
#
|
|
# The shorthash is superfluous, so discard it, and mark
|
|
# the log message subject as unknown.
|
|
# TODO: Can we performantly obtain the subject?
|
|
p="${p%% *} ?"
|
|
fi
|
|
;;
|
|
(''(x|exec) *)
|
|
# The line is of the form 'exec foo bar baz' where 'foo bar
|
|
# baz' is a shell command. There's no way to map _that_ to
|
|
# "$hash $subject", but I hope this counts as making an effort.
|
|
p=${p/#x /exec }
|
|
;;
|
|
(*)
|
|
# Forward compatibility with not-yet-existing 'git rebase -i' verbs.
|
|
if [[ $p != *\ * ]]; then
|
|
p+=" ?"
|
|
fi
|
|
esac
|
|
REPLY=$p
|
|
}
|
|
if [[ -f "${patchdir}/done" ]] ; then
|
|
for p in ${(f)"$(< "${patchdir}/done")"}; do
|
|
VCS_INFO_git_map_rebase_line_to_hash_and_subject "$p"
|
|
(( $+REPLY )) && git_patches_applied+=( "$REPLY" )
|
|
done
|
|
fi
|
|
if zstyle -t ":vcs_info:${vcs}:${usercontext}:${rrn}" get-unapplied &&
|
|
[[ -f "${patchdir}/git-rebase-todo" ]]
|
|
then
|
|
for p in ${(f)"$(< "${patchdir}/git-rebase-todo")"}; do
|
|
VCS_INFO_git_map_rebase_line_to_hash_and_subject "$p"
|
|
(( $+REPLY )) && git_patches_unapplied+=( "$REPLY" )
|
|
done
|
|
fi
|
|
VCS_INFO_git_handle_patches
|
|
elif [[ -d "${gitdir}/rebase-apply" ]]; then
|
|
# 'git rebase' without -i, or 'git am'
|
|
patchdir="${gitdir}/rebase-apply"
|
|
local next="${patchdir}/next"
|
|
local this_patch_file
|
|
if [[ -f $next ]]; then
|
|
local cur=$(< $next)
|
|
local p subject
|
|
# Compute patch names for patches "before" the current patch
|
|
if [[ -r ${patchdir}/rewritten ]]; then
|
|
if zstyle -t ":vcs_info:${vcs}:${usercontext}:${rrn}" use-simple; then
|
|
git_patches_applied=( ${${(f)"$(<${patchdir}/rewritten)"}// */' ?'} )
|
|
else
|
|
git_patches_applied=(
|
|
${(f)"$(${vcs_comm[cmd]} log --no-walk=unsorted --pretty='%h %s' ${${(f)"$(<${patchdir}/rewritten)"}%% *} --)"}
|
|
)
|
|
fi
|
|
else
|
|
# Compatibility with old git. In 2.11 and 2.24, at least,
|
|
# (( cur == 1 )), so the loop body would never run. However, both
|
|
# of these versions have original-commit and orig-head and would
|
|
# take the 'if' branch, rather than this 'else' branch.
|
|
for ((p = 1; p < cur; p++)); do
|
|
printf -v this_patch_file "%s/%04d" "${patchdir}" "${p}"
|
|
if [[ -f $this_patch_file ]]; then
|
|
VCS_INFO_patch2subject "${this_patch_file}"
|
|
git_patches_applied+=( "$p $REPLY" )
|
|
else
|
|
git_patches_applied+=( "$p ?" )
|
|
fi
|
|
done
|
|
fi
|
|
# Set $subject to the info for the current patch
|
|
if [[ -f "${patchdir}/msg-clean" ]]; then
|
|
subject="${$(< "${patchdir}/msg-clean")[(f)1]}"
|
|
elif [[ -f "${patchdir}/final-commit" ]]; then
|
|
# This value is not rfc2047-encoded. It's also available via
|
|
# "${patchdir}/info".
|
|
subject="${$(< "${patchdir}/final-commit")[(f)1]}"
|
|
elif printf -v this_patch_file "%s/%04d" "${patchdir}" "${cur}"
|
|
[[ -f $this_patch_file ]]
|
|
then
|
|
# This branch is last for several reasons:
|
|
#
|
|
# - The "Subject" header will be MIME-encoded (rfc2047).
|
|
#
|
|
# - If the mail has full rfc822 headers (including "Received" and
|
|
# so on), we won't find the "Subject:" header, since
|
|
# VCS_INFO_patch2subject only checks the first few lines.
|
|
#
|
|
# - In --scissors mode, we may find the outer "Subject:" header,
|
|
# whereas the inner one (after the scissors line) will be used,
|
|
# if present.
|
|
() {
|
|
local REPLY
|
|
VCS_INFO_patch2subject "${this_patch_file}"
|
|
subject=$REPLY
|
|
}
|
|
fi
|
|
subject=${subject:-'?'}
|
|
if [[ -f "${patchdir}/original-commit" ]]; then
|
|
git_patches_applied+=("$(< ${patchdir}/original-commit) $subject")
|
|
elif [[ -f "${patchdir}/next" ]]; then
|
|
git_patches_applied+=("$(< ${patchdir}/next) $subject")
|
|
else
|
|
git_patches_applied+=("? $subject")
|
|
fi
|
|
# Handle patches scheduled for after the current patch, if instructed to.
|
|
if zstyle -t ":vcs_info:${vcs}:${usercontext}:${rrn}" get-unapplied; then
|
|
local last="$(< "${patchdir}/last")"
|
|
if [[ -r ${patchdir}/original-commit && -r ${patchdir}/orig-head ]] &&
|
|
! zstyle -t ":vcs_info:${vcs}:${usercontext}:${rrn}" use-simple
|
|
then
|
|
git_patches_unapplied+=( ${(f)"$(${vcs_comm[cmd]} log --reverse --pretty="%h %s" "$(<${patchdir}/original-commit)..$(<${patchdir}/orig-head)")"} )
|
|
else
|
|
for ((p = cur+1; p <= last; p++)); do
|
|
printf -v this_patch_file "%s/%04d" "${patchdir}" "${p}"
|
|
if [[ -f $this_patch_file ]]; then
|
|
VCS_INFO_patch2subject "${this_patch_file}"
|
|
git_patches_unapplied+=( "$p $REPLY" )
|
|
else
|
|
git_patches_unapplied+=( "$p ?" )
|
|
fi
|
|
done
|
|
fi
|
|
fi
|
|
fi
|
|
unset this_patch_file
|
|
|
|
VCS_INFO_git_handle_patches
|
|
elif [[ -f "${gitdir}/MERGE_HEAD" ]]; then
|
|
# This is 'git merge --no-commit'
|
|
local -a heads=( ${(@f)"$(<"${gitdir}/MERGE_HEAD")"} )
|
|
local subject;
|
|
# TODO: maybe read up to the first blank line
|
|
IFS='' read -r subject < "${gitdir}/MERGE_MSG"
|
|
# $subject is the subject line of the would-be commit
|
|
# Maybe we can get the subject lines of MERGE_HEAD's commits cheaply?
|
|
|
|
local p
|
|
for p in $heads[@]; do
|
|
git_patches_applied+=("$p $subject")
|
|
done
|
|
unset p
|
|
|
|
# Not touching git_patches_unapplied
|
|
|
|
VCS_INFO_git_handle_patches
|
|
elif [[ -f "${gitdir}/CHERRY_PICK_HEAD" ]]; then
|
|
# 'git cherry-pick' without -n, that conflicted. (With -n, git doesn't
|
|
# record the CHERRY_PICK_HEAD information anywhere, as of git 2.6.2.)
|
|
#
|
|
# ### 'git cherry-pick foo bar baz' only records the "remaining" part of
|
|
# ### the queue in the .git dir: if 'bar' has a conflict, the .git dir
|
|
# ### has a record of 'baz' being queued, but no record of 'foo' having been
|
|
# ### part of the queue as well. Therefore, the %n/%c applied/unapplied
|
|
# ### expandos will be memoryless: the "applied" counter will always
|
|
# ### be "1". The %u/%c tuple will assume the values [(1,2), (1,1), (1,0)],
|
|
# ### whereas the correct sequence would be [(1,2), (2,1), (3,0)].
|
|
local subject
|
|
# TODO: maybe read up to the first blank line
|
|
IFS='' read -r subject < "${gitdir}/MERGE_MSG"
|
|
git_patches_applied=( "$(<${gitdir}/CHERRY_PICK_HEAD) ${subject}" )
|
|
if zstyle -t ":vcs_info:${vcs}:${usercontext}:${rrn}" get-unapplied &&
|
|
[[ -f "${gitdir}/sequencer/todo" ]]
|
|
then
|
|
# Get the next patches, and remove the one that's in CHERRY_PICK_HEAD.
|
|
git_patches_unapplied=( ${${(M)${(f)"$(<"${gitdir}/sequencer/todo")"}:#pick *}#pick } )
|
|
git_patches_unapplied[1]=()
|
|
else
|
|
git_patches_unapplied=()
|
|
fi
|
|
VCS_INFO_git_handle_patches
|
|
elif command -v stg >/dev/null &&
|
|
${vcs_comm[cmd]} show-ref --quiet refs/stacks/${gitbranch} refs/heads/${gitbranch}.stgit 2>/dev/null &&
|
|
git_patches_applied=(${${(f)"$(stg series --noprefix --applied --description 2>/dev/null)"}/ #[#]})
|
|
then
|
|
# Testing for StGit patches is done after testing for all git-proper
|
|
# patches/states. If a StGit user's repo is in one of those states, they
|
|
# will want to see that instead of the StGit patch info.
|
|
|
|
# Performance note: testing for the stg executable is done first because it
|
|
# is extremely cheap and there is nothing else to do if it isn't present.
|
|
# Using git to test whether a StGit stack is initialized is cheaper than
|
|
# running stg itself; especially for versions of StGit <= 2.0. Thus getting
|
|
# StGit patch info should only have a material runtime cost if StGit is
|
|
# installed and in-use for the current branch.
|
|
|
|
# In StGit >=1.2, the existence of refs/stacks/<branch> indicates StGit is
|
|
# initialized. In StGit >=0.15, it is refs/heads/<branch>.stgit.
|
|
|
|
# N.B. the "--noprefix" option is available in StGit 2.x as an alias for
|
|
# --no-prefix. The former is compatible with StGit versions going back to
|
|
# 2008.
|
|
if zstyle -t ":vcs_info:${vcs}:${usercontext}:${rrn}" get-unapplied; then
|
|
git_patches_unapplied=(${${(f)"$(stg series --noprefix --unapplied --description 2>/dev/null)"}/ #[#]})
|
|
fi
|
|
VCS_INFO_git_handle_patches
|
|
else
|
|
gitmisc=''
|
|
fi
|
|
|
|
backend_misc[patches]="${gitmisc}"
|
|
VCS_INFO_formats "${gitaction}" "${gitbranch}" "${gitbase}" "${gitstaged}" "${gitunstaged}" "${gitsha1}" "${gitmisc}"
|
|
return 0
|