2007-06-03 00:31:28 +00:00
|
|
|
#!/bin/sh
|
|
|
|
#
|
|
|
|
# Rewrite revision history
|
|
|
|
# Copyright (c) Petr Baudis, 2006
|
|
|
|
# Minimal changes to "port" it to core-git (c) Johannes Schindelin, 2007
|
|
|
|
#
|
2007-07-03 23:41:55 +00:00
|
|
|
# Lets you rewrite the revision history of the current branch, creating
|
|
|
|
# a new branch. You can specify a number of filters to modify the commits,
|
|
|
|
# files and trees.
|
2007-06-03 00:31:28 +00:00
|
|
|
|
2007-11-28 15:50:38 +00:00
|
|
|
# The following functions will also be available in the commit filter:
|
|
|
|
|
|
|
|
functions=$(cat << \EOF
|
2007-07-04 08:36:24 +00:00
|
|
|
warn () {
|
2011-08-05 13:31:29 +00:00
|
|
|
echo "$*" >&2
|
2007-07-04 08:36:24 +00:00
|
|
|
}
|
|
|
|
|
2007-06-03 00:31:28 +00:00
|
|
|
map()
|
|
|
|
{
|
2007-06-06 18:38:35 +00:00
|
|
|
# if it was not rewritten, take the original
|
2007-07-04 12:08:17 +00:00
|
|
|
if test -r "$workdir/../map/$1"
|
|
|
|
then
|
|
|
|
cat "$workdir/../map/$1"
|
|
|
|
else
|
|
|
|
echo "$1"
|
|
|
|
fi
|
2007-06-03 00:31:28 +00:00
|
|
|
}
|
|
|
|
|
2007-08-31 19:06:27 +00:00
|
|
|
# if you run 'skip_commit "$@"' in a commit filter, it will print
|
|
|
|
# the (mapped) parents, effectively skipping the commit.
|
|
|
|
|
|
|
|
skip_commit()
|
|
|
|
{
|
|
|
|
shift;
|
|
|
|
while [ -n "$1" ];
|
|
|
|
do
|
|
|
|
shift;
|
|
|
|
map "$1";
|
|
|
|
shift;
|
|
|
|
done;
|
|
|
|
}
|
|
|
|
|
2008-10-31 09:12:21 +00:00
|
|
|
# if you run 'git_commit_non_empty_tree "$@"' in a commit filter,
|
|
|
|
# it will skip commits that leave the tree untouched, commit the other.
|
|
|
|
git_commit_non_empty_tree()
|
|
|
|
{
|
|
|
|
if test $# = 3 && test "$1" = $(git rev-parse "$3^{tree}"); then
|
|
|
|
map "$3"
|
2017-02-23 08:27:35 +00:00
|
|
|
elif test $# = 1 && test "$1" = 4b825dc642cb6eb9a060e54bf8d69288fbee4904; then
|
|
|
|
:
|
2008-10-31 09:12:21 +00:00
|
|
|
else
|
|
|
|
git commit-tree "$@"
|
|
|
|
fi
|
|
|
|
}
|
filter-branch: fail gracefully when a filter fails
A common mistake is to provide a filter which fails unwantedly. For
example, this will stop in the middle:
git filter-branch --env-filter '
test $GIT_COMMITTER_EMAIL = xyz &&
export GIT_COMMITTER_EMAIL = abc' rewritten
When $GIT_COMMITTER_EMAIL is not "xyz", the test fails, and consequently
the whole filter has a non-zero exit status. However, as demonstrated
in this example, filter-branch would just stop, and the user would be
none the wiser.
Also, a failing msg-filter would not have been caught, as was the
case with one of the tests.
This patch fixes both issues, by paying attention to the exit status
of msg-filter, and by saying what failed before exiting.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-07-04 14:36:01 +00:00
|
|
|
# override die(): this version puts in an extra line break, so that
|
|
|
|
# the progress is still visible
|
|
|
|
|
|
|
|
die()
|
|
|
|
{
|
|
|
|
echo >&2
|
|
|
|
echo "$*" >&2
|
|
|
|
exit 1
|
|
|
|
}
|
2007-11-28 15:50:38 +00:00
|
|
|
EOF
|
|
|
|
)
|
|
|
|
|
|
|
|
eval "$functions"
|
filter-branch: fail gracefully when a filter fails
A common mistake is to provide a filter which fails unwantedly. For
example, this will stop in the middle:
git filter-branch --env-filter '
test $GIT_COMMITTER_EMAIL = xyz &&
export GIT_COMMITTER_EMAIL = abc' rewritten
When $GIT_COMMITTER_EMAIL is not "xyz", the test fails, and consequently
the whole filter has a non-zero exit status. However, as demonstrated
in this example, filter-branch would just stop, and the user would be
none the wiser.
Also, a failing msg-filter would not have been caught, as was the
case with one of the tests.
This patch fixes both issues, by paying attention to the exit status
of msg-filter, and by saying what failed before exiting.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-07-04 14:36:01 +00:00
|
|
|
|
2012-10-18 10:33:02 +00:00
|
|
|
finish_ident() {
|
|
|
|
# Ensure non-empty id name.
|
|
|
|
echo "case \"\$GIT_$1_NAME\" in \"\") GIT_$1_NAME=\"\${GIT_$1_EMAIL%%@*}\" && export GIT_$1_NAME;; esac"
|
|
|
|
# And make sure everything is exported.
|
|
|
|
echo "export GIT_$1_NAME"
|
|
|
|
echo "export GIT_$1_EMAIL"
|
|
|
|
echo "export GIT_$1_DATE"
|
|
|
|
}
|
2007-06-03 00:31:28 +00:00
|
|
|
|
|
|
|
set_ident () {
|
2012-10-18 10:33:02 +00:00
|
|
|
parse_ident_from_commit author AUTHOR committer COMMITTER
|
|
|
|
finish_ident AUTHOR
|
|
|
|
finish_ident COMMITTER
|
2007-06-03 00:31:28 +00:00
|
|
|
}
|
|
|
|
|
2017-10-19 05:45:45 +00:00
|
|
|
USAGE="[--setup <command>] [--subdirectory-filter <directory>] [--env-filter <command>]
|
2017-06-10 08:54:44 +00:00
|
|
|
[--tree-filter <command>] [--index-filter <command>]
|
|
|
|
[--parent-filter <command>] [--msg-filter <command>]
|
|
|
|
[--commit-filter <command>] [--tag-name-filter <command>]
|
2017-10-19 05:45:45 +00:00
|
|
|
[--original <namespace>]
|
2017-09-21 07:49:31 +00:00
|
|
|
[-d <directory>] [-f | --force] [--state-branch <branch>]
|
2017-06-10 08:54:45 +00:00
|
|
|
[--] [<rev-list options>...]"
|
2007-08-31 19:05:36 +00:00
|
|
|
|
2007-11-06 09:50:02 +00:00
|
|
|
OPTIONS_SPEC=
|
2007-08-31 19:05:36 +00:00
|
|
|
. git-sh-setup
|
|
|
|
|
2008-07-23 22:15:36 +00:00
|
|
|
if [ "$(is_bare_repository)" = false ]; then
|
2011-09-01 21:53:07 +00:00
|
|
|
require_clean_work_tree 'rewrite branches'
|
2008-07-23 22:15:36 +00:00
|
|
|
fi
|
2007-10-17 02:23:10 +00:00
|
|
|
|
2007-06-03 00:31:28 +00:00
|
|
|
tempdir=.git-rewrite
|
2017-06-10 08:54:44 +00:00
|
|
|
filter_setup=
|
2007-06-03 00:31:28 +00:00
|
|
|
filter_env=
|
|
|
|
filter_tree=
|
|
|
|
filter_index=
|
|
|
|
filter_parent=
|
|
|
|
filter_msg=cat
|
2008-10-31 09:12:21 +00:00
|
|
|
filter_commit=
|
2007-06-03 00:31:28 +00:00
|
|
|
filter_tag_name=
|
2007-06-08 00:30:35 +00:00
|
|
|
filter_subdir=
|
2017-09-21 07:49:31 +00:00
|
|
|
state_branch=
|
2007-07-23 17:34:13 +00:00
|
|
|
orig_namespace=refs/original/
|
|
|
|
force=
|
2008-10-31 09:12:21 +00:00
|
|
|
prune_empty=
|
2009-11-10 21:04:51 +00:00
|
|
|
remap_to_ancestor=
|
2007-09-23 20:42:08 +00:00
|
|
|
while :
|
2007-06-03 00:31:28 +00:00
|
|
|
do
|
|
|
|
case "$1" in
|
|
|
|
--)
|
|
|
|
shift
|
|
|
|
break
|
|
|
|
;;
|
2007-07-23 17:34:13 +00:00
|
|
|
--force|-f)
|
|
|
|
shift
|
|
|
|
force=t
|
|
|
|
continue
|
|
|
|
;;
|
2009-11-10 21:04:51 +00:00
|
|
|
--remap-to-ancestor)
|
2010-08-27 20:44:56 +00:00
|
|
|
# deprecated ($remap_to_ancestor is set now automatically)
|
2009-11-10 21:04:51 +00:00
|
|
|
shift
|
|
|
|
remap_to_ancestor=t
|
|
|
|
continue
|
|
|
|
;;
|
2008-10-31 09:12:21 +00:00
|
|
|
--prune-empty)
|
|
|
|
shift
|
|
|
|
prune_empty=t
|
|
|
|
continue
|
|
|
|
;;
|
2007-06-03 00:31:28 +00:00
|
|
|
-*)
|
|
|
|
;;
|
|
|
|
*)
|
|
|
|
break;
|
|
|
|
esac
|
|
|
|
|
|
|
|
# all switches take one argument
|
|
|
|
ARG="$1"
|
|
|
|
case "$#" in 1) usage ;; esac
|
|
|
|
shift
|
|
|
|
OPTARG="$1"
|
|
|
|
shift
|
|
|
|
|
|
|
|
case "$ARG" in
|
|
|
|
-d)
|
|
|
|
tempdir="$OPTARG"
|
|
|
|
;;
|
2017-06-10 08:54:44 +00:00
|
|
|
--setup)
|
|
|
|
filter_setup="$OPTARG"
|
|
|
|
;;
|
2017-10-17 09:45:15 +00:00
|
|
|
--subdirectory-filter)
|
|
|
|
filter_subdir="$OPTARG"
|
|
|
|
remap_to_ancestor=t
|
|
|
|
;;
|
2007-06-03 00:31:28 +00:00
|
|
|
--env-filter)
|
|
|
|
filter_env="$OPTARG"
|
|
|
|
;;
|
|
|
|
--tree-filter)
|
|
|
|
filter_tree="$OPTARG"
|
|
|
|
;;
|
|
|
|
--index-filter)
|
|
|
|
filter_index="$OPTARG"
|
|
|
|
;;
|
|
|
|
--parent-filter)
|
|
|
|
filter_parent="$OPTARG"
|
|
|
|
;;
|
|
|
|
--msg-filter)
|
|
|
|
filter_msg="$OPTARG"
|
|
|
|
;;
|
|
|
|
--commit-filter)
|
2007-11-28 15:50:38 +00:00
|
|
|
filter_commit="$functions; $OPTARG"
|
2007-06-03 00:31:28 +00:00
|
|
|
;;
|
|
|
|
--tag-name-filter)
|
|
|
|
filter_tag_name="$OPTARG"
|
|
|
|
;;
|
2007-07-23 17:34:13 +00:00
|
|
|
--original)
|
2007-08-31 02:17:42 +00:00
|
|
|
orig_namespace=$(expr "$OPTARG/" : '\(.*[^/]\)/*$')/
|
2007-07-23 17:34:13 +00:00
|
|
|
;;
|
2017-09-21 07:49:31 +00:00
|
|
|
--state-branch)
|
|
|
|
state_branch="$OPTARG"
|
|
|
|
;;
|
2007-06-03 00:31:28 +00:00
|
|
|
*)
|
|
|
|
usage
|
|
|
|
;;
|
|
|
|
esac
|
|
|
|
done
|
|
|
|
|
2008-10-31 09:12:21 +00:00
|
|
|
case "$prune_empty,$filter_commit" in
|
|
|
|
,)
|
|
|
|
filter_commit='git commit-tree "$@"';;
|
|
|
|
t,)
|
|
|
|
filter_commit="$functions;"' git_commit_non_empty_tree "$@"';;
|
|
|
|
,*)
|
|
|
|
;;
|
|
|
|
*)
|
2010-02-12 02:46:22 +00:00
|
|
|
die "Cannot set --prune-empty and --commit-filter at the same time"
|
2008-10-31 09:12:21 +00:00
|
|
|
esac
|
|
|
|
|
2007-07-23 17:34:13 +00:00
|
|
|
case "$force" in
|
|
|
|
t)
|
|
|
|
rm -rf "$tempdir"
|
|
|
|
;;
|
|
|
|
'')
|
|
|
|
test -d "$tempdir" &&
|
|
|
|
die "$tempdir already exists, please remove it"
|
|
|
|
esac
|
2013-04-02 14:22:19 +00:00
|
|
|
orig_dir=$(pwd)
|
2007-07-18 13:17:43 +00:00
|
|
|
mkdir -p "$tempdir/t" &&
|
2007-07-23 17:34:13 +00:00
|
|
|
tempdir="$(cd "$tempdir"; pwd)" &&
|
2007-07-18 13:17:43 +00:00
|
|
|
cd "$tempdir/t" &&
|
|
|
|
workdir="$(pwd)" ||
|
|
|
|
die ""
|
2007-06-03 00:31:28 +00:00
|
|
|
|
2008-01-28 21:16:02 +00:00
|
|
|
# Remove tempdir on exit
|
2013-04-02 14:22:19 +00:00
|
|
|
trap 'cd "$orig_dir"; rm -rf "$tempdir"' 0
|
2008-01-28 21:16:02 +00:00
|
|
|
|
2009-02-18 08:35:36 +00:00
|
|
|
ORIG_GIT_DIR="$GIT_DIR"
|
|
|
|
ORIG_GIT_WORK_TREE="$GIT_WORK_TREE"
|
|
|
|
ORIG_GIT_INDEX_FILE="$GIT_INDEX_FILE"
|
2017-09-21 07:49:30 +00:00
|
|
|
ORIG_GIT_AUTHOR_NAME="$GIT_AUTHOR_NAME"
|
|
|
|
ORIG_GIT_AUTHOR_EMAIL="$GIT_AUTHOR_EMAIL"
|
|
|
|
ORIG_GIT_AUTHOR_DATE="$GIT_AUTHOR_DATE"
|
|
|
|
ORIG_GIT_COMMITTER_NAME="$GIT_COMMITTER_NAME"
|
|
|
|
ORIG_GIT_COMMITTER_EMAIL="$GIT_COMMITTER_EMAIL"
|
|
|
|
ORIG_GIT_COMMITTER_DATE="$GIT_COMMITTER_DATE"
|
|
|
|
|
2009-02-18 08:35:36 +00:00
|
|
|
GIT_WORK_TREE=.
|
|
|
|
export GIT_DIR GIT_WORK_TREE
|
|
|
|
|
2007-07-23 17:34:13 +00:00
|
|
|
# Make sure refs/original is empty
|
2009-02-11 21:10:41 +00:00
|
|
|
git for-each-ref > "$tempdir"/backup-refs || exit
|
2007-07-23 17:34:13 +00:00
|
|
|
while read sha1 type name
|
|
|
|
do
|
|
|
|
case "$force,$name" in
|
|
|
|
,$orig_namespace*)
|
2009-02-19 07:36:35 +00:00
|
|
|
die "Cannot create a new backup.
|
|
|
|
A previous backup already exists in $orig_namespace
|
|
|
|
Force overwriting the backup with -f"
|
2007-07-23 17:34:13 +00:00
|
|
|
;;
|
|
|
|
t,$orig_namespace*)
|
|
|
|
git update-ref -d "$name" $sha1
|
|
|
|
;;
|
|
|
|
esac
|
|
|
|
done < "$tempdir"/backup-refs
|
|
|
|
|
2008-01-05 20:18:43 +00:00
|
|
|
# The refs should be updated if their heads were rewritten
|
2009-02-11 21:10:41 +00:00
|
|
|
git rev-parse --no-flags --revs-only --symbolic-full-name \
|
|
|
|
--default HEAD "$@" > "$tempdir"/raw-heads || exit
|
|
|
|
sed -e '/^^/d' "$tempdir"/raw-heads >"$tempdir"/heads
|
2007-07-23 17:34:13 +00:00
|
|
|
|
|
|
|
test -s "$tempdir"/heads ||
|
2017-05-11 12:06:34 +00:00
|
|
|
die "You must specify a ref to rewrite."
|
2007-07-23 17:34:13 +00:00
|
|
|
|
2007-11-28 15:56:11 +00:00
|
|
|
GIT_INDEX_FILE="$(pwd)/../index"
|
|
|
|
export GIT_INDEX_FILE
|
2007-06-03 00:31:28 +00:00
|
|
|
|
2007-07-18 13:17:43 +00:00
|
|
|
# map old->new commit ids for rewriting parents
|
|
|
|
mkdir ../map || die "Could not create map/ directory"
|
2007-06-03 00:31:28 +00:00
|
|
|
|
2017-09-21 07:49:31 +00:00
|
|
|
if test -n "$state_branch"
|
|
|
|
then
|
|
|
|
state_commit=$(git rev-parse --no-flags --revs-only "$state_branch")
|
|
|
|
if test -n "$state_commit"
|
|
|
|
then
|
|
|
|
echo "Populating map from $state_branch ($state_commit)" 1>&2
|
|
|
|
perl -e'open(MAP, "-|", "git show $ARGV[0]:filter.map") or die;
|
|
|
|
while (<MAP>) {
|
|
|
|
m/(.*):(.*)/ or die;
|
|
|
|
open F, ">../map/$1" or die;
|
|
|
|
print F "$2" or die;
|
|
|
|
close(F) or die;
|
|
|
|
}
|
|
|
|
close(MAP) or die;' "$state_commit" \
|
|
|
|
|| die "Unable to load state from $state_branch:filter.map"
|
|
|
|
else
|
|
|
|
echo "Branch $state_branch does not exist. Will create" 1>&2
|
|
|
|
fi
|
|
|
|
fi
|
|
|
|
|
2009-11-11 08:53:46 +00:00
|
|
|
# we need "--" only if there are no path arguments in $@
|
|
|
|
nonrevs=$(git rev-parse --no-revs "$@") || exit
|
2010-08-27 20:44:56 +00:00
|
|
|
if test -z "$nonrevs"
|
|
|
|
then
|
|
|
|
dashdash=--
|
|
|
|
else
|
|
|
|
dashdash=
|
|
|
|
remap_to_ancestor=t
|
|
|
|
fi
|
|
|
|
|
2013-09-10 22:55:35 +00:00
|
|
|
git rev-parse --revs-only "$@" >../parse
|
2009-11-11 08:53:46 +00:00
|
|
|
|
2007-06-08 00:30:35 +00:00
|
|
|
case "$filter_subdir" in
|
|
|
|
"")
|
2009-11-11 08:53:46 +00:00
|
|
|
eval set -- "$(git rev-parse --sq --no-revs "$@")"
|
2007-06-08 00:30:35 +00:00
|
|
|
;;
|
|
|
|
*)
|
2009-11-11 08:53:46 +00:00
|
|
|
eval set -- "$(git rev-parse --sq --no-revs "$@" $dashdash \
|
|
|
|
"$filter_subdir")"
|
|
|
|
;;
|
|
|
|
esac
|
|
|
|
|
|
|
|
git rev-list --reverse --topo-order --default HEAD \
|
2013-09-10 22:55:35 +00:00
|
|
|
--parents --simplify-merges --stdin "$@" <../parse >../revs ||
|
2009-11-11 08:53:46 +00:00
|
|
|
die "Could not get the commits"
|
2007-07-14 08:05:43 +00:00
|
|
|
commits=$(wc -l <../revs | tr -d " ")
|
2007-06-03 00:31:28 +00:00
|
|
|
|
|
|
|
test $commits -eq 0 && die "Found nothing to rewrite"
|
|
|
|
|
2007-07-23 17:34:13 +00:00
|
|
|
# Rewrite the commits
|
2015-09-07 13:52:08 +00:00
|
|
|
report_progress ()
|
|
|
|
{
|
|
|
|
if test -n "$progress" &&
|
|
|
|
test $git_filter_branch__commit_count -gt $next_sample_at
|
|
|
|
then
|
2015-09-21 22:16:20 +00:00
|
|
|
count=$git_filter_branch__commit_count
|
|
|
|
|
|
|
|
now=$(date +%s)
|
|
|
|
elapsed=$(($now - $start_timestamp))
|
|
|
|
remaining=$(( ($commits - $count) * $elapsed / $count ))
|
|
|
|
if test $elapsed -gt 0
|
2015-09-07 13:52:08 +00:00
|
|
|
then
|
2015-09-21 22:16:20 +00:00
|
|
|
next_sample_at=$(( ($elapsed + 1) * $count / $elapsed ))
|
2015-09-07 13:52:08 +00:00
|
|
|
else
|
|
|
|
next_sample_at=$(($next_sample_at + 1))
|
|
|
|
fi
|
2015-09-21 22:16:20 +00:00
|
|
|
progress=" ($elapsed seconds passed, remaining $remaining predicted)"
|
2015-09-07 13:52:08 +00:00
|
|
|
fi
|
2015-09-21 22:16:20 +00:00
|
|
|
printf "\rRewrite $commit ($count/$commits)$progress "
|
2015-09-07 13:52:08 +00:00
|
|
|
}
|
2007-07-23 17:34:13 +00:00
|
|
|
|
2009-03-25 21:51:01 +00:00
|
|
|
git_filter_branch__commit_count=0
|
2015-09-07 13:52:08 +00:00
|
|
|
|
|
|
|
progress= start_timestamp=
|
|
|
|
if date '+%s' 2>/dev/null | grep -q '^[0-9][0-9]*$'
|
|
|
|
then
|
|
|
|
next_sample_at=0
|
|
|
|
progress="dummy to ensure this is not empty"
|
|
|
|
start_timestamp=$(date '+%s')
|
|
|
|
fi
|
|
|
|
|
2015-11-06 06:24:29 +00:00
|
|
|
if test -n "$filter_index" ||
|
|
|
|
test -n "$filter_tree" ||
|
|
|
|
test -n "$filter_subdir"
|
|
|
|
then
|
|
|
|
need_index=t
|
|
|
|
else
|
|
|
|
need_index=
|
|
|
|
fi
|
|
|
|
|
2017-06-10 08:54:44 +00:00
|
|
|
eval "$filter_setup" < /dev/null ||
|
|
|
|
die "filter setup failed: $filter_setup"
|
|
|
|
|
2007-06-08 21:28:39 +00:00
|
|
|
while read commit parents; do
|
2009-03-25 21:51:01 +00:00
|
|
|
git_filter_branch__commit_count=$(($git_filter_branch__commit_count+1))
|
2015-09-07 13:52:08 +00:00
|
|
|
|
|
|
|
report_progress
|
2007-06-03 00:31:28 +00:00
|
|
|
|
2007-06-08 00:30:35 +00:00
|
|
|
case "$filter_subdir" in
|
|
|
|
"")
|
2015-11-06 06:24:29 +00:00
|
|
|
if test -n "$need_index"
|
|
|
|
then
|
|
|
|
GIT_ALLOW_NULL_SHA1=1 git read-tree -i -m $commit
|
|
|
|
fi
|
2007-06-08 00:30:35 +00:00
|
|
|
;;
|
|
|
|
*)
|
2008-03-08 20:25:58 +00:00
|
|
|
# The commit may not have the subdirectory at all
|
write_index: optionally allow broken null sha1s
Commit 4337b58 (do not write null sha1s to on-disk index,
2012-07-28) added a safety check preventing git from writing
null sha1s into the index. The intent was to catch errors in
other parts of the code that might let such an entry slip
into the index (or worse, a tree).
Some existing repositories may have invalid trees that
contain null sha1s already, though. Until 4337b58, a common
way to clean this up would be to use git-filter-branch's
index-filter to repair such broken entries. That now fails
when filter-branch tries to write out the index.
Introduce a GIT_ALLOW_NULL_SHA1 environment variable to
relax this check and make it easier to recover from such a
history.
It is tempting to not involve filter-branch in this commit
at all, and instead require the user to manually invoke
GIT_ALLOW_NULL_SHA1=1 git filter-branch ...
to perform an index-filter on a history with trees with null
sha1s. That would be slightly safer, but requires some
specialized knowledge from the user. So let's set the
GIT_ALLOW_NULL_SHA1 variable automatically when checking out
the to-be-filtered trees. Advice on using filter-branch to
remove such entries already exists on places like
stackoverflow, and this patch makes it Just Work again on
recent versions of git.
Further commands that touch the index will still notice and
fail, unless they actually remove the broken entries. A
filter-branch whose filters do not touch the index at all
will not error out (since we complain of the null sha1 only
on writing, not when making a tree out of the index), but
this is acceptable, as we still print a loud warning, so the
problem is unlikely to go unnoticed.
Signed-off-by: Jeff King <peff@peff.net>
Reviewed-by: Jonathan Nieder <jrnieder@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-08-27 20:41:12 +00:00
|
|
|
err=$(GIT_ALLOW_NULL_SHA1=1 \
|
|
|
|
git read-tree -i -m $commit:"$filter_subdir" 2>&1) || {
|
2008-12-03 13:26:48 +00:00
|
|
|
if ! git rev-parse -q --verify $commit:"$filter_subdir"
|
2008-03-08 20:25:58 +00:00
|
|
|
then
|
|
|
|
rm -f "$GIT_INDEX_FILE"
|
|
|
|
else
|
|
|
|
echo >&2 "$err"
|
|
|
|
false
|
|
|
|
fi
|
|
|
|
}
|
2007-07-18 13:17:43 +00:00
|
|
|
esac || die "Could not initialize the index"
|
2007-06-03 00:31:28 +00:00
|
|
|
|
2007-11-28 15:56:11 +00:00
|
|
|
GIT_COMMIT=$commit
|
|
|
|
export GIT_COMMIT
|
2007-07-18 13:17:43 +00:00
|
|
|
git cat-file commit "$commit" >../commit ||
|
|
|
|
die "Cannot read commit $commit"
|
2007-06-03 00:31:28 +00:00
|
|
|
|
2012-10-18 10:33:02 +00:00
|
|
|
eval "$(set_ident <../commit)" ||
|
|
|
|
die "setting author/committer failed for commit $commit"
|
filter-branch: fail gracefully when a filter fails
A common mistake is to provide a filter which fails unwantedly. For
example, this will stop in the middle:
git filter-branch --env-filter '
test $GIT_COMMITTER_EMAIL = xyz &&
export GIT_COMMITTER_EMAIL = abc' rewritten
When $GIT_COMMITTER_EMAIL is not "xyz", the test fails, and consequently
the whole filter has a non-zero exit status. However, as demonstrated
in this example, filter-branch would just stop, and the user would be
none the wiser.
Also, a failing msg-filter would not have been caught, as was the
case with one of the tests.
This patch fixes both issues, by paying attention to the exit status
of msg-filter, and by saying what failed before exiting.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-07-04 14:36:01 +00:00
|
|
|
eval "$filter_env" < /dev/null ||
|
|
|
|
die "env filter failed: $filter_env"
|
2007-06-03 00:31:28 +00:00
|
|
|
|
|
|
|
if [ "$filter_tree" ]; then
|
2007-07-18 13:17:43 +00:00
|
|
|
git checkout-index -f -u -a ||
|
|
|
|
die "Could not checkout the index"
|
2007-06-03 00:31:28 +00:00
|
|
|
# files that $commit removed are now still in the working tree;
|
|
|
|
# remove them, else they would be added again
|
2008-03-31 07:14:15 +00:00
|
|
|
git clean -d -q -f -x
|
filter-branch: fail gracefully when a filter fails
A common mistake is to provide a filter which fails unwantedly. For
example, this will stop in the middle:
git filter-branch --env-filter '
test $GIT_COMMITTER_EMAIL = xyz &&
export GIT_COMMITTER_EMAIL = abc' rewritten
When $GIT_COMMITTER_EMAIL is not "xyz", the test fails, and consequently
the whole filter has a non-zero exit status. However, as demonstrated
in this example, filter-branch would just stop, and the user would be
none the wiser.
Also, a failing msg-filter would not have been caught, as was the
case with one of the tests.
This patch fixes both issues, by paying attention to the exit status
of msg-filter, and by saying what failed before exiting.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-07-04 14:36:01 +00:00
|
|
|
eval "$filter_tree" < /dev/null ||
|
|
|
|
die "tree filter failed: $filter_tree"
|
|
|
|
|
2008-02-16 07:57:26 +00:00
|
|
|
(
|
2015-11-23 12:23:16 +00:00
|
|
|
git diff-index -r --name-only --ignore-submodules $commit -- &&
|
2008-02-16 07:57:26 +00:00
|
|
|
git ls-files --others
|
2009-02-11 21:10:41 +00:00
|
|
|
) > "$tempdir"/tree-state || exit
|
|
|
|
git update-index --add --replace --remove --stdin \
|
|
|
|
< "$tempdir"/tree-state || exit
|
2007-06-03 00:31:28 +00:00
|
|
|
fi
|
|
|
|
|
filter-branch: fail gracefully when a filter fails
A common mistake is to provide a filter which fails unwantedly. For
example, this will stop in the middle:
git filter-branch --env-filter '
test $GIT_COMMITTER_EMAIL = xyz &&
export GIT_COMMITTER_EMAIL = abc' rewritten
When $GIT_COMMITTER_EMAIL is not "xyz", the test fails, and consequently
the whole filter has a non-zero exit status. However, as demonstrated
in this example, filter-branch would just stop, and the user would be
none the wiser.
Also, a failing msg-filter would not have been caught, as was the
case with one of the tests.
This patch fixes both issues, by paying attention to the exit status
of msg-filter, and by saying what failed before exiting.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-07-04 14:36:01 +00:00
|
|
|
eval "$filter_index" < /dev/null ||
|
|
|
|
die "index filter failed: $filter_index"
|
2007-06-03 00:31:28 +00:00
|
|
|
|
|
|
|
parentstr=
|
2007-06-08 21:28:39 +00:00
|
|
|
for parent in $parents; do
|
2007-06-06 18:38:35 +00:00
|
|
|
for reparent in $(map "$parent"); do
|
2014-06-30 21:20:27 +00:00
|
|
|
case "$parentstr " in
|
|
|
|
*" -p $reparent "*)
|
|
|
|
;;
|
|
|
|
*)
|
|
|
|
parentstr="$parentstr -p $reparent"
|
|
|
|
;;
|
|
|
|
esac
|
2007-06-06 18:38:35 +00:00
|
|
|
done
|
2007-06-03 00:31:28 +00:00
|
|
|
done
|
|
|
|
if [ "$filter_parent" ]; then
|
filter-branch: fail gracefully when a filter fails
A common mistake is to provide a filter which fails unwantedly. For
example, this will stop in the middle:
git filter-branch --env-filter '
test $GIT_COMMITTER_EMAIL = xyz &&
export GIT_COMMITTER_EMAIL = abc' rewritten
When $GIT_COMMITTER_EMAIL is not "xyz", the test fails, and consequently
the whole filter has a non-zero exit status. However, as demonstrated
in this example, filter-branch would just stop, and the user would be
none the wiser.
Also, a failing msg-filter would not have been caught, as was the
case with one of the tests.
This patch fixes both issues, by paying attention to the exit status
of msg-filter, and by saying what failed before exiting.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-07-04 14:36:01 +00:00
|
|
|
parentstr="$(echo "$parentstr" | eval "$filter_parent")" ||
|
|
|
|
die "parent filter failed: $filter_parent"
|
2007-06-03 00:31:28 +00:00
|
|
|
fi
|
|
|
|
|
2015-04-29 15:48:58 +00:00
|
|
|
{
|
filter-branch: remove multi-line headers in msg filter
df062010 (filter-branch: avoid passing commit message through sed)
introduced a regression when filtering commits with multi-line headers,
if the header contains a blank line. An example of this is a gpg-signed
commit:
$ git cat-file commit signed-commit
tree 3d4038e029712da9fc59a72afbfcc90418451630
parent 110eac945dc1713b27bdf49e74e5805db66971f0
author A U Thor <author@example.com> 1112912413 -0700
committer C O Mitter <committer@example.com> 1112912413 -0700
gpgsig -----BEGIN PGP SIGNATURE-----
Version: GnuPG v1
iEYEABECAAYFAlYXADwACgkQE7b1Hs3eQw23CACgldB/InRyDgQwyiFyMMm3zFpj
pUsAnA+f3aMUsd9mNroloSmlOgL6jIMO
=0Hgm
-----END PGP SIGNATURE-----
Adding gpg
As a consequence, "filter-branch --msg-filter cat" (which should leave the
commit message unchanged) spills the signature (after the internal blank
line) into the original commit message.
The reason is that although the signature is indented, making the line a
whitespace only line, the "read" call is splitting the line based on
the shell's IFS, which defaults to <space><tab><newline>. The leading
space is consumed and $header_line is empty, causing the "skip header
lines" loop to exit.
The rest of the commit object is then re-used as the rewritten commit
message, causing the new message to include the signature of the
original commit.
Set IFS to an empty string for the "read" call, thus disabling the word
splitting, which causes $header_line to be set to the non-empty value ' '.
This allows the loop to fully consume the header lines before
emitting the original, intact commit message.
[jc: this is literally based on MJG's suggestion]
Signed-off-by: Michael J Gruber <git@drmicha.warpmail.net>
Signed-off-by: James McCoy <vega.james@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-10-09 00:21:13 +00:00
|
|
|
while IFS='' read -r header_line && test -n "$header_line"
|
2015-04-29 15:48:58 +00:00
|
|
|
do
|
|
|
|
# skip header lines...
|
|
|
|
:;
|
|
|
|
done
|
|
|
|
# and output the actual commit message
|
|
|
|
cat
|
|
|
|
} <../commit |
|
filter-branch: fail gracefully when a filter fails
A common mistake is to provide a filter which fails unwantedly. For
example, this will stop in the middle:
git filter-branch --env-filter '
test $GIT_COMMITTER_EMAIL = xyz &&
export GIT_COMMITTER_EMAIL = abc' rewritten
When $GIT_COMMITTER_EMAIL is not "xyz", the test fails, and consequently
the whole filter has a non-zero exit status. However, as demonstrated
in this example, filter-branch would just stop, and the user would be
none the wiser.
Also, a failing msg-filter would not have been caught, as was the
case with one of the tests.
This patch fixes both issues, by paying attention to the exit status
of msg-filter, and by saying what failed before exiting.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-07-04 14:36:01 +00:00
|
|
|
eval "$filter_msg" > ../message ||
|
|
|
|
die "msg filter failed: $filter_msg"
|
2015-11-06 06:24:29 +00:00
|
|
|
|
|
|
|
if test -n "$need_index"
|
|
|
|
then
|
|
|
|
tree=$(git write-tree)
|
|
|
|
else
|
filter-branch: resolve $commit^{tree} in no-index case
Commit 348d4f2 (filter-branch: skip index read/write when
possible, 2015-11-06) taught filter-branch to optimize out
the final "git write-tree" when we know we haven't touched
the tree with any of our filters. It does by simply putting
the literal text "$commit^{tree}" into the "$tree" variable,
avoiding a useless rev-parse call.
However, when we pass this to git_commit_non_empty_tree(),
it gets confused; it resolves "$commit^{tree}" itself, and
compares our string to the 40-hex sha1, which obviously
doesn't match. As a result, "--prune-empty" (or any custom
filter using git_commit_non_empty_tree) will fail to drop
an empty commit (when filter-branch is used without a tree
or index filter).
Let's resolve $tree to the 40-hex ourselves, so that
git_commit_non_empty_tree can work. Unfortunately, this is a
bit slower due to the extra process overhead:
$ cd t/perf && ./run 348d4f2 HEAD p7000-filter-branch.sh
[...]
Test 348d4f2 HEAD
--------------------------------------------------------------
7000.2: noop filter 3.76(0.24+0.26) 4.54(0.28+0.24) +20.7%
We could try to make git_commit_non_empty_tree more clever.
However, the value of $tree here is technically
user-visible. The user can provide arbitrary shell code at
this stage, which could itself have a similar assumption to
what is in git_commit_non_empty_tree. So the conservative
choice to fix this regression is to take the 20% hit and
give the pre-348d4f2 behavior. We still end up much faster
than before the optimization:
$ cd t/perf && ./run 348d4f2^ HEAD p7000-filter-branch.sh
[...]
Test 348d4f2^ HEAD
--------------------------------------------------------------
7000.2: noop filter 9.51(4.32+0.40) 4.51(0.28+0.23) -52.6%
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-01-19 22:07:22 +00:00
|
|
|
tree=$(git rev-parse "$commit^{tree}")
|
2015-11-06 06:24:29 +00:00
|
|
|
fi
|
2011-08-07 02:44:43 +00:00
|
|
|
workdir=$workdir @SHELL_PATH@ -c "$filter_commit" "git commit-tree" \
|
2015-11-06 06:24:29 +00:00
|
|
|
"$tree" $parentstr < ../message > ../map/$commit ||
|
2009-02-11 21:10:41 +00:00
|
|
|
die "could not write rewritten commit"
|
2007-06-03 00:31:28 +00:00
|
|
|
done <../revs
|
|
|
|
|
2009-11-10 21:04:51 +00:00
|
|
|
# If we are filtering for paths, as in the case of a subdirectory
|
|
|
|
# filter, it is possible that a specified head is not in the set of
|
|
|
|
# rewritten commits, because it was pruned by the revision walker.
|
|
|
|
# Ancestor remapping fixes this by mapping these heads to the unique
|
|
|
|
# nearest ancestor that survived the pruning.
|
2007-07-23 17:34:13 +00:00
|
|
|
|
2009-11-10 21:04:51 +00:00
|
|
|
if test "$remap_to_ancestor" = t
|
filter-branch: fix ref rewriting with --subdirectory-filter
The previous ancestor discovery code failed on any refs that are
(pre-rewrite) ancestors of commits marked for rewriting. This means
that in a situation
A -- B(topic) -- C(master)
where B is dropped by --subdirectory-filter pruning, the 'topic' was
not moved up to A as intended, but left unrewritten because we asked
about 'git rev-list ^master topic', which does not return anything.
Instead, we use the straightforward
git rev-list -1 $ref -- $filter_subdir
to find the right ancestor. To justify this, note that the nearest
ancestor is unique: We use the output of
git rev-list --parents -- $filter_subdir
to rewrite commits in the first pass, before any ref rewriting. If B
is a non-merge commit, the only candidate is its parent. If it is a
merge, there are two cases:
- All sides of the merge bring the same subdirectory contents. Then
rev-list already pruned away the merge in favour for just one of its
parents, so there is only one candidate.
- Some merge sides, or the merge outcome, differ. Then the merge is
not pruned and can be rewritten directly.
So it is always safe to use rev-list -1.
Signed-off-by: Thomas Rast <trast@student.ethz.ch>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-08-12 08:45:58 +00:00
|
|
|
then
|
|
|
|
while read ref
|
2007-07-23 17:34:13 +00:00
|
|
|
do
|
filter-branch: fix ref rewriting with --subdirectory-filter
The previous ancestor discovery code failed on any refs that are
(pre-rewrite) ancestors of commits marked for rewriting. This means
that in a situation
A -- B(topic) -- C(master)
where B is dropped by --subdirectory-filter pruning, the 'topic' was
not moved up to A as intended, but left unrewritten because we asked
about 'git rev-list ^master topic', which does not return anything.
Instead, we use the straightforward
git rev-list -1 $ref -- $filter_subdir
to find the right ancestor. To justify this, note that the nearest
ancestor is unique: We use the output of
git rev-list --parents -- $filter_subdir
to rewrite commits in the first pass, before any ref rewriting. If B
is a non-merge commit, the only candidate is its parent. If it is a
merge, there are two cases:
- All sides of the merge bring the same subdirectory contents. Then
rev-list already pruned away the merge in favour for just one of its
parents, so there is only one candidate.
- Some merge sides, or the merge outcome, differ. Then the merge is
not pruned and can be rewritten directly.
So it is always safe to use rev-list -1.
Signed-off-by: Thomas Rast <trast@student.ethz.ch>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-08-12 08:45:58 +00:00
|
|
|
sha1=$(git rev-parse "$ref"^0)
|
|
|
|
test -f "$workdir"/../map/$sha1 && continue
|
2009-11-11 08:53:46 +00:00
|
|
|
ancestor=$(git rev-list --simplify-merges -1 "$ref" "$@")
|
filter-branch: fix ref rewriting with --subdirectory-filter
The previous ancestor discovery code failed on any refs that are
(pre-rewrite) ancestors of commits marked for rewriting. This means
that in a situation
A -- B(topic) -- C(master)
where B is dropped by --subdirectory-filter pruning, the 'topic' was
not moved up to A as intended, but left unrewritten because we asked
about 'git rev-list ^master topic', which does not return anything.
Instead, we use the straightforward
git rev-list -1 $ref -- $filter_subdir
to find the right ancestor. To justify this, note that the nearest
ancestor is unique: We use the output of
git rev-list --parents -- $filter_subdir
to rewrite commits in the first pass, before any ref rewriting. If B
is a non-merge commit, the only candidate is its parent. If it is a
merge, there are two cases:
- All sides of the merge bring the same subdirectory contents. Then
rev-list already pruned away the merge in favour for just one of its
parents, so there is only one candidate.
- Some merge sides, or the merge outcome, differ. Then the merge is
not pruned and can be rewritten directly.
So it is always safe to use rev-list -1.
Signed-off-by: Thomas Rast <trast@student.ethz.ch>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-08-12 08:45:58 +00:00
|
|
|
test "$ancestor" && echo $(map $ancestor) >> "$workdir"/../map/$sha1
|
|
|
|
done < "$tempdir"/heads
|
|
|
|
fi
|
2007-07-23 17:34:13 +00:00
|
|
|
|
|
|
|
# Finally update the refs
|
|
|
|
|
|
|
|
_x40='[0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f]'
|
|
|
|
_x40="$_x40$_x40$_x40$_x40$_x40$_x40$_x40$_x40"
|
|
|
|
echo
|
|
|
|
while read ref
|
|
|
|
do
|
|
|
|
# avoid rewriting a ref twice
|
|
|
|
test -f "$orig_namespace$ref" && continue
|
|
|
|
|
|
|
|
sha1=$(git rev-parse "$ref"^0)
|
|
|
|
rewritten=$(map $sha1)
|
|
|
|
|
|
|
|
test $sha1 = "$rewritten" &&
|
|
|
|
warn "WARNING: Ref '$ref' is unchanged" &&
|
|
|
|
continue
|
|
|
|
|
|
|
|
case "$rewritten" in
|
|
|
|
'')
|
|
|
|
echo "Ref '$ref' was deleted"
|
|
|
|
git update-ref -m "filter-branch: delete" -d "$ref" $sha1 ||
|
|
|
|
die "Could not delete $ref"
|
2007-06-05 15:58:13 +00:00
|
|
|
;;
|
2007-07-23 17:34:13 +00:00
|
|
|
$_x40)
|
|
|
|
echo "Ref '$ref' was rewritten"
|
2008-08-07 23:50:31 +00:00
|
|
|
if ! git update-ref -m "filter-branch: rewrite" \
|
|
|
|
"$ref" $rewritten $sha1 2>/dev/null; then
|
|
|
|
if test $(git cat-file -t "$ref") = tag; then
|
|
|
|
if test -z "$filter_tag_name"; then
|
|
|
|
warn "WARNING: You said to rewrite tagged commits, but not the corresponding tag."
|
|
|
|
warn "WARNING: Perhaps use '--tag-name-filter cat' to rewrite the tag."
|
|
|
|
fi
|
|
|
|
else
|
|
|
|
die "Could not rewrite $ref"
|
|
|
|
fi
|
|
|
|
fi
|
2007-06-05 15:58:13 +00:00
|
|
|
;;
|
2007-07-23 17:34:13 +00:00
|
|
|
*)
|
|
|
|
# NEEDSWORK: possibly add -Werror, making this an error
|
|
|
|
warn "WARNING: '$ref' was rewritten into multiple commits:"
|
|
|
|
warn "$rewritten"
|
|
|
|
warn "WARNING: Ref '$ref' points to the first one now."
|
|
|
|
rewritten=$(echo "$rewritten" | head -n 1)
|
|
|
|
git update-ref -m "filter-branch: rewrite to first" \
|
|
|
|
"$ref" $rewritten $sha1 ||
|
|
|
|
die "Could not rewrite $ref"
|
|
|
|
;;
|
|
|
|
esac
|
2009-02-11 21:10:41 +00:00
|
|
|
git update-ref -m "filter-branch: backup" "$orig_namespace$ref" $sha1 ||
|
|
|
|
exit
|
2007-07-23 17:34:13 +00:00
|
|
|
done < "$tempdir"/heads
|
|
|
|
|
|
|
|
# TODO: This should possibly go, with the semantics that all positive given
|
|
|
|
# refs are updated, and their original heads stored in refs/original/
|
|
|
|
# Filter tags
|
2007-06-03 00:31:28 +00:00
|
|
|
|
|
|
|
if [ "$filter_tag_name" ]; then
|
2007-07-03 05:52:14 +00:00
|
|
|
git for-each-ref --format='%(objectname) %(objecttype) %(refname)' refs/tags |
|
2007-06-03 00:31:28 +00:00
|
|
|
while read sha1 type ref; do
|
|
|
|
ref="${ref#refs/tags/}"
|
|
|
|
# XXX: Rewrite tagged trees as well?
|
|
|
|
if [ "$type" != "commit" -a "$type" != "tag" ]; then
|
|
|
|
continue;
|
|
|
|
fi
|
|
|
|
|
|
|
|
if [ "$type" = "tag" ]; then
|
|
|
|
# Dereference to a commit
|
|
|
|
sha1t="$sha1"
|
2009-04-23 01:46:02 +00:00
|
|
|
sha1="$(git rev-parse -q "$sha1"^{commit})" || continue
|
2007-06-03 00:31:28 +00:00
|
|
|
fi
|
|
|
|
|
|
|
|
[ -f "../map/$sha1" ] || continue
|
|
|
|
new_sha1="$(cat "../map/$sha1")"
|
2007-11-28 15:56:11 +00:00
|
|
|
GIT_COMMIT="$sha1"
|
|
|
|
export GIT_COMMIT
|
filter-branch: fail gracefully when a filter fails
A common mistake is to provide a filter which fails unwantedly. For
example, this will stop in the middle:
git filter-branch --env-filter '
test $GIT_COMMITTER_EMAIL = xyz &&
export GIT_COMMITTER_EMAIL = abc' rewritten
When $GIT_COMMITTER_EMAIL is not "xyz", the test fails, and consequently
the whole filter has a non-zero exit status. However, as demonstrated
in this example, filter-branch would just stop, and the user would be
none the wiser.
Also, a failing msg-filter would not have been caught, as was the
case with one of the tests.
This patch fixes both issues, by paying attention to the exit status
of msg-filter, and by saying what failed before exiting.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-07-04 14:36:01 +00:00
|
|
|
new_ref="$(echo "$ref" | eval "$filter_tag_name")" ||
|
|
|
|
die "tag name filter failed: $filter_tag_name"
|
2007-06-03 00:31:28 +00:00
|
|
|
|
|
|
|
echo "$ref -> $new_ref ($sha1 -> $new_sha1)"
|
|
|
|
|
|
|
|
if [ "$type" = "tag" ]; then
|
2008-08-21 14:45:11 +00:00
|
|
|
new_sha1=$( ( printf 'object %s\ntype commit\ntag %s\n' \
|
|
|
|
"$new_sha1" "$new_ref"
|
|
|
|
git cat-file tag "$ref" |
|
2008-03-26 15:47:09 +00:00
|
|
|
sed -n \
|
2010-01-26 23:08:31 +00:00
|
|
|
-e '1,/^$/{
|
2008-08-21 14:45:11 +00:00
|
|
|
/^object /d
|
|
|
|
/^type /d
|
|
|
|
/^tag /d
|
2010-01-26 23:08:31 +00:00
|
|
|
}' \
|
2008-03-26 15:47:09 +00:00
|
|
|
-e '/^-----BEGIN PGP SIGNATURE-----/q' \
|
2008-08-21 14:45:11 +00:00
|
|
|
-e 'p' ) |
|
2017-09-21 07:49:32 +00:00
|
|
|
git hash-object -t tag -w --stdin) ||
|
2008-03-26 15:47:09 +00:00
|
|
|
die "Could not create new tag object for $ref"
|
|
|
|
if git cat-file tag "$ref" | \
|
2009-11-23 23:56:32 +00:00
|
|
|
sane_grep '^-----BEGIN PGP SIGNATURE-----' >/dev/null 2>&1
|
2008-03-26 15:47:09 +00:00
|
|
|
then
|
|
|
|
warn "gpg signature stripped from tag object $sha1t"
|
|
|
|
fi
|
2007-06-03 00:31:28 +00:00
|
|
|
fi
|
|
|
|
|
2007-07-18 13:17:43 +00:00
|
|
|
git update-ref "refs/tags/$new_ref" "$new_sha1" ||
|
|
|
|
die "Could not write tag $new_ref"
|
2007-06-03 00:31:28 +00:00
|
|
|
done
|
|
|
|
fi
|
|
|
|
|
2009-02-03 18:27:03 +00:00
|
|
|
unset GIT_DIR GIT_WORK_TREE GIT_INDEX_FILE
|
2017-09-21 07:49:30 +00:00
|
|
|
unset GIT_AUTHOR_NAME GIT_AUTHOR_EMAIL GIT_AUTHOR_DATE
|
|
|
|
unset GIT_COMMITTER_NAME GIT_COMMITTER_EMAIL GIT_COMMITTER_DATE
|
2009-02-03 18:27:03 +00:00
|
|
|
test -z "$ORIG_GIT_DIR" || {
|
|
|
|
GIT_DIR="$ORIG_GIT_DIR" && export GIT_DIR
|
|
|
|
}
|
|
|
|
test -z "$ORIG_GIT_WORK_TREE" || {
|
|
|
|
GIT_WORK_TREE="$ORIG_GIT_WORK_TREE" &&
|
|
|
|
export GIT_WORK_TREE
|
|
|
|
}
|
|
|
|
test -z "$ORIG_GIT_INDEX_FILE" || {
|
|
|
|
GIT_INDEX_FILE="$ORIG_GIT_INDEX_FILE" &&
|
|
|
|
export GIT_INDEX_FILE
|
|
|
|
}
|
2017-09-21 07:49:30 +00:00
|
|
|
test -z "$ORIG_GIT_AUTHOR_NAME" || {
|
|
|
|
GIT_AUTHOR_NAME="$ORIG_GIT_AUTHOR_NAME" &&
|
|
|
|
export GIT_AUTHOR_NAME
|
|
|
|
}
|
|
|
|
test -z "$ORIG_GIT_AUTHOR_EMAIL" || {
|
|
|
|
GIT_AUTHOR_EMAIL="$ORIG_GIT_AUTHOR_EMAIL" &&
|
|
|
|
export GIT_AUTHOR_EMAIL
|
|
|
|
}
|
|
|
|
test -z "$ORIG_GIT_AUTHOR_DATE" || {
|
|
|
|
GIT_AUTHOR_DATE="$ORIG_GIT_AUTHOR_DATE" &&
|
|
|
|
export GIT_AUTHOR_DATE
|
|
|
|
}
|
|
|
|
test -z "$ORIG_GIT_COMMITTER_NAME" || {
|
|
|
|
GIT_COMMITTER_NAME="$ORIG_GIT_COMMITTER_NAME" &&
|
|
|
|
export GIT_COMMITTER_NAME
|
|
|
|
}
|
|
|
|
test -z "$ORIG_GIT_COMMITTER_EMAIL" || {
|
|
|
|
GIT_COMMITTER_EMAIL="$ORIG_GIT_COMMITTER_EMAIL" &&
|
|
|
|
export GIT_COMMITTER_EMAIL
|
|
|
|
}
|
|
|
|
test -z "$ORIG_GIT_COMMITTER_DATE" || {
|
|
|
|
GIT_COMMITTER_DATE="$ORIG_GIT_COMMITTER_DATE" &&
|
|
|
|
export GIT_COMMITTER_DATE
|
|
|
|
}
|
2009-02-03 18:27:03 +00:00
|
|
|
|
2017-09-21 07:49:31 +00:00
|
|
|
if test -n "$state_branch"
|
|
|
|
then
|
|
|
|
echo "Saving rewrite state to $state_branch" 1>&2
|
|
|
|
state_blob=$(
|
|
|
|
perl -e'opendir D, "../map" or die;
|
|
|
|
open H, "|-", "git hash-object -w --stdin" or die;
|
|
|
|
foreach (sort readdir(D)) {
|
|
|
|
next if m/^\.\.?$/;
|
|
|
|
open F, "<../map/$_" or die;
|
|
|
|
chomp($f = <F>);
|
|
|
|
print H "$_:$f\n" or die;
|
|
|
|
}
|
|
|
|
close(H) or die;' || die "Unable to save state")
|
|
|
|
state_tree=$(/bin/echo -e "100644 blob $state_blob\tfilter.map" | git mktree)
|
|
|
|
if test -n "$state_commit"
|
|
|
|
then
|
|
|
|
state_commit=$(/bin/echo "Sync" | git commit-tree "$state_tree" -p "$state_commit")
|
|
|
|
else
|
|
|
|
state_commit=$(/bin/echo "Sync" | git commit-tree "$state_tree" )
|
|
|
|
fi
|
|
|
|
git update-ref "$state_branch" "$state_commit"
|
|
|
|
fi
|
|
|
|
|
2017-09-21 07:49:29 +00:00
|
|
|
cd "$orig_dir"
|
|
|
|
rm -rf "$tempdir"
|
|
|
|
|
|
|
|
trap - 0
|
|
|
|
|
2008-07-23 22:15:36 +00:00
|
|
|
if [ "$(is_bare_repository)" = false ]; then
|
2009-02-11 21:10:41 +00:00
|
|
|
git read-tree -u -m HEAD || exit
|
2008-07-23 22:15:36 +00:00
|
|
|
fi
|
2007-10-17 02:23:10 +00:00
|
|
|
|
2009-02-11 21:10:41 +00:00
|
|
|
exit 0
|