# Copyright (c) Petr Baudis, 2006
# Minimal changes to "port" it to core-git (c) Johannes Schindelin, 2007
#
-# Lets you rewrite GIT revision history by creating a new branch from
-# your current branch by applying custom filters on each revision.
-# Those filters can modify each tree (e.g. removing a file or running
-# a perl rewrite on all files) or information about each commit.
-# Otherwise, all information (including original commit times or merge
-# information) will be preserved.
-#
-# The command takes the new branch name as a mandatory argument and
-# the filters as optional arguments. If you specify no filters, the
-# commits will be recommitted without any changes, which would normally
-# have no effect and result with the new branch pointing to the same
-# branch as your current branch. (Nevertheless, this may be useful in
-# the future for compensating for some Git bugs or such, therefore
-# such a usage is permitted.)
-#
-# WARNING! The rewritten history will have different ids for all the
-# objects and will not converge with the original branch. You will not
-# be able to easily push and distribute the rewritten branch. Please do
-# not use this command if you do not know the full implications, and
-# avoid using it anyway - do not do what a simple single commit on top
-# of the current version would fix.
-#
-# Always verify that the rewritten version is correct before disposing
-# the original branch.
-#
-# Note that since this operation is extensively I/O expensive, it might
-# be a good idea to do it off-disk, e.g. on tmpfs. Reportedly the speedup
-# is very noticeable.
-#
-# OPTIONS
-# -------
-# -d TEMPDIR:: The path to the temporary tree used for rewriting
-# When applying a tree filter, the command needs to temporary
-# checkout the tree to some directory, which may consume
-# considerable space in case of large projects. By default it
-# does this in the '.git-rewrite/' directory but you can override
-# that choice by this parameter.
-#
-# -r STARTREV:: The commit id to start the rewrite at
-# Normally, the command will rewrite the entire history. If you
-# pass this argument, though, this will be the first commit it
-# will rewrite and keep the previous commits intact.
-#
-# -k KEEPREV:: A commit id until which _not_ to rewrite history
-# If you pass this argument, this commit and all of its
-# predecessors are kept intact.
-#
-# Filters
-# ~~~~~~~
-# The filters are applied in the order as listed below. The COMMAND
-# argument is always evaluated in shell using the 'eval' command.
-# The $GIT_COMMIT environment variable is permanently set to contain
-# the id of the commit being rewritten. The author/committer environment
-# variables are set before the first filter is run.
-#
-# A 'map' function is available that takes an "original sha1 id" argument
-# and outputs a "rewritten sha1 id" if the commit has been already
-# rewritten, fails otherwise; the 'map' function can return several
-# ids on separate lines if your commit filter emitted multiple commits
-# (see below).
-#
-# --env-filter COMMAND:: The filter for modifying environment
-# This is the filter for modifying the environment in which
-# the commit will be performed. Specifically, you might want
-# to rewrite the author/committer name/email/time environment
-# variables (see `git-commit` for details). Do not forget to
-# re-export the variables.
-#
-# --tree-filter COMMAND:: The filter for rewriting tree (and its contents)
-# This is the filter for rewriting the tree and its contents.
-# The COMMAND argument is evaluated in shell with the working
-# directory set to the root of the checked out tree. The new tree
-# is then used as-is (new files are auto-added, disappeared files
-# are auto-removed - .gitignore files nor any other ignore rules
-# HAVE NO EFFECT!).
-#
-# --index-filter COMMAND:: The filter for rewriting index
-# This is the filter for rewriting the Git's directory index.
-# It is similar to the tree filter but does not check out the
-# tree, which makes it much faster. However, you must use the
-# lowlevel Git index manipulation commands to do your work.
-#
-# --parent-filter COMMAND:: The filter for rewriting parents
-# This is the filter for rewriting the commit's parent list.
-# It will receive the parent string on stdin and shall output
-# the new parent string on stdout. The parent string is in
-# format accepted by `git-commit-tree`: empty for initial
-# commit, "-p parent" for a normal commit and "-p parent1
-# -p parent2 -p parent3 ..." for a merge commit.
-#
-# --msg-filter COMMAND:: The filter for rewriting commit message
-# This is the filter for rewriting the commit messages.
-# The COMMAND argument is evaluated in shell with the original
-# commit message on standard input; its standard output is
-# is used as the new commit message.
-#
-# --commit-filter COMMAND:: The filter for performing the commit
-# If this filter is passed, it will be called instead of the
-# `git-commit-tree` command, with those arguments:
-#
-# TREE_ID [-p PARENT_COMMIT_ID]...
-#
-# and the log message on stdin. The commit id is expected on
-# stdout. As a special extension, the commit filter may emit
-# multiple commit ids; in that case, all of them will be used
-# as parents instead of the original commit in further commits.
-#
-# --tag-name-filter COMMAND:: The filter for rewriting tag names.
-# If this filter is passed, it will be called for every tag ref
-# that points to a rewritten object (or to a tag object which
-# points to a rewritten object). The original tag name is passed
-# via standard input, and the new tag name is expected on standard
-# output.
-#
-# The original tags are not deleted, but can be overwritten;
-# use "--tag-name-filter=cat" to simply update the tags. In this
-# case, be very careful and make sure you have the old tags
-# backed up in case the conversion has run afoul.
-#
-# Note that there is currently no support for proper rewriting of
-# tag objects; in layman terms, if the tag has a message or signature
-# attached, the rewritten tag won't have it. Sorry. (It is by
-# definition impossible to preserve signatures at any rate, though.)
-#
-# EXAMPLE USAGE
-# -------------
-# Suppose you want to remove a file (containing confidential information
-# or copyright violation) from all commits:
-#
-# git-filter-branch --tree-filter 'rm filename' newbranch
-#
-# A significantly faster version:
-#
-# git-filter-branch --index-filter 'git-update-index --remove filename' newbranch
-#
-# Now, you will get the rewritten history saved in the branch 'newbranch'
-# (your current branch is left untouched).
-#
-# To "etch-graft" a commit to the revision history (set a commit to be
-# the parent of the current initial commit and propagate that):
-#
-# git-filter-branch --parent-filter sed\ 's/^$/-p graftcommitid/' newbranch
-#
-# (if the parent string is empty - therefore we are dealing with the
-# initial commit - add graftcommit as a parent). Note that this assumes
-# history with a single root (that is, no git-merge without common ancestors
-# happened). If this is not the case, use:
-#
-# git-filter-branch --parent-filter 'cat; [ "$GIT_COMMIT" = "COMMIT" ] && echo "-p GRAFTCOMMIT"' newbranch
-#
-# To remove commits authored by "Darl McBribe" from the history:
-#
-# git-filter-branch --commit-filter 'if [ "$GIT_AUTHOR_NAME" = "Darl McBribe" ]; then shift; while [ -n "$1" ]; do shift; echo "$1"; shift; done; else git-commit-tree "$@"; fi' newbranch
-#
-# (the shift magic first throws away the tree id and then the -p
-# parameters). Note that this handles merges properly! In case Darl
-# committed a merge between P1 and P2, it will be propagated properly
-# and all children of the merge will become merge commits with P1,P2
-# as their parents instead of the merge commit.
-#
-# To restrict rewriting to only part of the history, use -r or -k or both.
-# Consider this history:
-#
-# D--E--F--G--H
-# / /
-# A--B-----C
-#
-# To rewrite only commits F,G,H, use:
-#
-# git-filter-branch -r F ...
-#
-# To rewrite commits E,F,G,H, use one of these:
-#
-# git-filter-branch -r E -k C ...
-# git-filter-branch -k D -k C ...
-
-# Testsuite: TODO
+# 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.
-set -e
+# The following functions will also be available in the commit filter:
-USAGE="git-filter-branch [-d TEMPDIR] [-r STARTREV]... [-k KEEPREV]... [-s SRCBRANCH] [FILTERS] DESTBRANCH"
-. git-sh-setup
+functions=$(cat << \EOF
+warn () {
+ echo "$*" >&2
+}
map()
{
- [ -r "$workdir/../map/$1" ] || return 1
- cat "$workdir/../map/$1"
+ # if it was not rewritten, take the original
+ if test -r "$workdir/../map/$1"
+ then
+ cat "$workdir/../map/$1"
+ else
+ echo "$1"
+ fi
+}
+
+# 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;
}
+# override die(): this version puts in an extra line break, so that
+# the progress is still visible
+
+die()
+{
+ echo >&2
+ echo "$*" >&2
+ exit 1
+}
+EOF
+)
+
+eval "$functions"
+
# When piped a commit, output a script to set the ident of either
# "author" or "committer
h
s/^'$lid' \([^<]*\) <[^>]*> .*$/\1/
s/'\''/'\''\'\'\''/g
- s/.*/export GIT_'$uid'_NAME='\''&'\''/p
+ s/.*/GIT_'$uid'_NAME='\''&'\''; export GIT_'$uid'_NAME/p
g
s/^'$lid' [^<]* <\([^>]*\)> .*$/\1/
s/'\''/'\''\'\'\''/g
- s/.*/export GIT_'$uid'_EMAIL='\''&'\''/p
+ s/.*/GIT_'$uid'_EMAIL='\''&'\''; export GIT_'$uid'_EMAIL/p
g
s/^'$lid' [^<]* <[^>]*> \(.*\)$/\1/
s/'\''/'\''\'\'\''/g
- s/.*/export GIT_'$uid'_DATE='\''&'\''/p
+ s/.*/GIT_'$uid'_DATE='\''&'\''; export GIT_'$uid'_DATE/p
q
}
LANG=C LC_ALL=C sed -ne "$pick_id_script"
# Ensure non-empty id name.
- echo "[ -n \"\$GIT_${uid}_NAME\" ] || export GIT_${uid}_NAME=\"\${GIT_${uid}_EMAIL%%@*}\""
+ echo "case \"\$GIT_${uid}_NAME\" in \"\") GIT_${uid}_NAME=\"\${GIT_${uid}_EMAIL%%@*}\" && export GIT_${uid}_NAME;; esac"
}
-# list all parent's object names for a given commit
-get_parents () {
- git-rev-list -1 --parents "$1" | sed "s/^[0-9a-f]*//"
-}
+USAGE="[--env-filter <command>] [--tree-filter <command>] \
+[--index-filter <command>] [--parent-filter <command>] \
+[--msg-filter <command>] [--commit-filter <command>] \
+[--tag-name-filter <command>] [--subdirectory-filter <directory>] \
+[--original <namespace>] [-d <directory>] [-f | --force] \
+[<rev-list options>...]"
+
+OPTIONS_SPEC=
+. git-sh-setup
+
+git diff-files --quiet &&
+ git diff-index --cached --quiet HEAD -- ||
+ die "Cannot rewrite branch(es) with a dirty working directory."
tempdir=.git-rewrite
-unchanged=" "
filter_env=
filter_tree=
filter_index=
filter_parent=
filter_msg=cat
-filter_commit='git-commit-tree "$@"'
+filter_commit='git commit-tree "$@"'
filter_tag_name=
-srcbranch=HEAD
-while case "$#" in 0) usage;; esac
+filter_subdir=
+orig_namespace=refs/original/
+force=
+while :
do
case "$1" in
--)
shift
break
;;
+ --force|-f)
+ shift
+ force=t
+ continue
+ ;;
-*)
;;
*)
-d)
tempdir="$OPTARG"
;;
- -r)
- unchanged="$(get_parents "$OPTARG") $unchanged"
- ;;
- -k)
- unchanged="$(git-rev-parse "$OPTARG"^{commit}) $unchanged"
- ;;
--env-filter)
filter_env="$OPTARG"
;;
filter_msg="$OPTARG"
;;
--commit-filter)
- filter_commit="$OPTARG"
+ filter_commit="$functions; $OPTARG"
;;
--tag-name-filter)
filter_tag_name="$OPTARG"
;;
- -s)
- srcbranch="$OPTARG"
+ --subdirectory-filter)
+ filter_subdir="$OPTARG"
+ ;;
+ --original)
+ orig_namespace=$(expr "$OPTARG/" : '\(.*[^/]\)/*$')/
;;
*)
usage
esac
done
-dstbranch="$1"
-test -n "$dstbranch" || die "missing branch name"
-git-show-ref "refs/heads/$dstbranch" 2> /dev/null &&
- die "branch $dstbranch already exists"
-
-test ! -e "$tempdir" || die "$tempdir already exists, please remove it"
-mkdir -p "$tempdir/t"
-cd "$tempdir/t"
-workdir="$(pwd)"
-
-case "$GIT_DIR" in
-/*)
+case "$force" in
+t)
+ rm -rf "$tempdir"
+;;
+'')
+ test -d "$tempdir" &&
+ die "$tempdir already exists, please remove it"
+esac
+mkdir -p "$tempdir/t" &&
+tempdir="$(cd "$tempdir"; pwd)" &&
+cd "$tempdir/t" &&
+workdir="$(pwd)" ||
+die ""
+
+# Remove tempdir on exit
+trap 'cd ../..; rm -rf "$tempdir"' 0
+
+# Make sure refs/original is empty
+git for-each-ref > "$tempdir"/backup-refs
+while read sha1 type name
+do
+ case "$force,$name" in
+ ,$orig_namespace*)
+ die "Namespace $orig_namespace not empty"
;;
-*)
- export GIT_DIR="$(pwd)/../../$GIT_DIR"
+ t,$orig_namespace*)
+ git update-ref -d "$name" $sha1
;;
-esac
+ esac
+done < "$tempdir"/backup-refs
-export GIT_INDEX_FILE="$(pwd)/../index"
-git-read-tree # seed the index file
+ORIG_GIT_DIR="$GIT_DIR"
+ORIG_GIT_WORK_TREE="$GIT_WORK_TREE"
+ORIG_GIT_INDEX_FILE="$GIT_INDEX_FILE"
+GIT_WORK_TREE=.
+export GIT_DIR GIT_WORK_TREE
-ret=0
+# The refs should be updated if their heads were rewritten
+git rev-parse --no-flags --revs-only --symbolic-full-name --default HEAD "$@" |
+sed -e '/^^/d' >"$tempdir"/heads
+test -s "$tempdir"/heads ||
+ die "Which ref do you want to rewrite?"
-mkdir ../map # map old->new commit ids for rewriting parents
+GIT_INDEX_FILE="$(pwd)/../index"
+export GIT_INDEX_FILE
+git read-tree || die "Could not seed the index"
-# seed with identity mappings for the parents where we start off
-for commit in $unchanged; do
- echo $commit > ../map/$commit
-done
+ret=0
-git-rev-list --reverse --topo-order $srcbranch --not $unchanged >../revs
-commits=$(cat ../revs | wc -l | tr -d " ")
+# map old->new commit ids for rewriting parents
+mkdir ../map || die "Could not create map/ directory"
+
+case "$filter_subdir" in
+"")
+ git rev-list --reverse --topo-order --default HEAD \
+ --parents "$@"
+ ;;
+*)
+ git rev-list --reverse --topo-order --default HEAD \
+ --parents --full-history "$@" -- "$filter_subdir"
+esac > ../revs || die "Could not get the commits"
+commits=$(wc -l <../revs | tr -d " ")
test $commits -eq 0 && die "Found nothing to rewrite"
+# Rewrite the commits
+
i=0
-while read commit; do
+while read commit parents; do
i=$(($i+1))
- printf "$commit ($i/$commits) "
+ printf "\rRewrite $commit ($i/$commits)"
- git-read-tree -i -m $commit
+ case "$filter_subdir" in
+ "")
+ git read-tree -i -m $commit
+ ;;
+ *)
+ git read-tree -i -m $commit:"$filter_subdir"
+ esac || die "Could not initialize the index"
- export GIT_COMMIT=$commit
- git-cat-file commit "$commit" >../commit
+ GIT_COMMIT=$commit
+ export GIT_COMMIT
+ git cat-file commit "$commit" >../commit ||
+ die "Cannot read commit $commit"
- eval "$(set_ident AUTHOR <../commit)"
- eval "$(set_ident COMMITTER <../commit)"
- eval "$filter_env" < /dev/null
+ eval "$(set_ident AUTHOR <../commit)" ||
+ die "setting author failed for commit $commit"
+ eval "$(set_ident COMMITTER <../commit)" ||
+ die "setting committer failed for commit $commit"
+ eval "$filter_env" < /dev/null ||
+ die "env filter failed: $filter_env"
if [ "$filter_tree" ]; then
- git-checkout-index -f -u -a
+ git checkout-index -f -u -a ||
+ die "Could not checkout the index"
# files that $commit removed are now still in the working tree;
# remove them, else they would be added again
- git-ls-files -z --others | xargs -0 rm -f
- eval "$filter_tree" < /dev/null
- git-diff-index -r $commit | cut -f 2- | tr '\n' '\0' | \
- xargs -0 git-update-index --add --replace --remove
- git-ls-files -z --others | \
- xargs -0 git-update-index --add --replace --remove
+ git ls-files -z --others | xargs -0 rm -f
+ eval "$filter_tree" < /dev/null ||
+ die "tree filter failed: $filter_tree"
+
+ git diff-index -r $commit | cut -f 2- | tr '\012' '\000' | \
+ xargs -0 git update-index --add --replace --remove
+ git ls-files -z --others | \
+ xargs -0 git update-index --add --replace --remove
fi
- eval "$filter_index" < /dev/null
+ eval "$filter_index" < /dev/null ||
+ die "index filter failed: $filter_index"
parentstr=
- for parent in $(get_parents $commit); do
- if [ -r "../map/$parent" ]; then
- for reparent in $(cat "../map/$parent"); do
- parentstr="$parentstr -p $reparent"
- done
- else
- die "assertion failed: parent $parent for commit $commit not found in rewritten ones"
- fi
+ for parent in $parents; do
+ for reparent in $(map "$parent"); do
+ parentstr="$parentstr -p $reparent"
+ done
done
if [ "$filter_parent" ]; then
- parentstr="$(echo "$parentstr" | eval "$filter_parent")"
+ parentstr="$(echo "$parentstr" | eval "$filter_parent")" ||
+ die "parent filter failed: $filter_parent"
fi
sed -e '1,/^$/d' <../commit | \
- eval "$filter_msg" | \
- sh -c "$filter_commit" git-commit-tree $(git-write-tree) $parentstr | \
- tee ../map/$commit
+ eval "$filter_msg" > ../message ||
+ die "msg filter failed: $filter_msg"
+ sh -c "$filter_commit" "git commit-tree" \
+ $(git write-tree) $parentstr < ../message > ../map/$commit
done <../revs
-git-update-ref refs/heads/"$dstbranch" $(head -n 1 ../map/$(tail -n 1 ../revs))
-if [ "$(cat ../map/$(tail -n 1 ../revs) | wc -l)" -gt 1 ]; then
- echo "WARNING: Your commit filter caused the head commit to expand to several rewritten commits. Only the first such commit was recorded as the current $dstbranch head but you will need to resolve the situation now (probably by manually merging the other commits). These are all the commits:" >&2
- sed 's/^/ /' ../map/$(tail -n 1 ../revs) >&2
- ret=1
-fi
+# In 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. Fix it by mapping these heads to the next rewritten
+# ancestor(s), i.e. the boundaries in the set of rewritten commits.
+
+# NEEDSWORK: we should sort the unmapped refs topologically first
+while read ref
+do
+ sha1=$(git rev-parse "$ref"^0)
+ test -f "$workdir"/../map/$sha1 && continue
+ # Assign the boundarie(s) in the set of rewritten commits
+ # as the replacement commit(s).
+ # (This would look a bit nicer if --not --stdin worked.)
+ for p in $( (cd "$workdir"/../map; ls | sed "s/^/^/") |
+ git rev-list $ref --boundary --stdin |
+ sed -n "s/^-//p")
+ do
+ map $p >> "$workdir"/../map/$sha1
+ done
+done < "$tempdir"/heads
+
+# 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"
+ ;;
+ $_x40)
+ echo "Ref '$ref' was rewritten"
+ git update-ref -m "filter-branch: rewrite" \
+ "$ref" $rewritten $sha1 ||
+ die "Could not rewrite $ref"
+ ;;
+ *)
+ # 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
+ git update-ref -m "filter-branch: backup" "$orig_namespace$ref" $sha1
+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
if [ "$filter_tag_name" ]; then
- git-for-each-ref --format='%(objectname) %(objecttype) %(refname)' refs/tags |
+ git for-each-ref --format='%(objectname) %(objecttype) %(refname)' refs/tags |
while read sha1 type ref; do
ref="${ref#refs/tags/}"
# XXX: Rewrite tagged trees as well?
if [ "$type" = "tag" ]; then
# Dereference to a commit
sha1t="$sha1"
- sha1="$(git-rev-parse "$sha1"^{commit} 2>/dev/null)" || continue
+ sha1="$(git rev-parse "$sha1"^{commit} 2>/dev/null)" || continue
fi
[ -f "../map/$sha1" ] || continue
new_sha1="$(cat "../map/$sha1")"
- export GIT_COMMIT="$sha1"
- new_ref="$(echo "$ref" | eval "$filter_tag_name")"
+ GIT_COMMIT="$sha1"
+ export GIT_COMMIT
+ new_ref="$(echo "$ref" | eval "$filter_tag_name")" ||
+ die "tag name filter failed: $filter_tag_name"
echo "$ref -> $new_ref ($sha1 -> $new_sha1)"
warn "unreferencing tag object $sha1t"
fi
- git-update-ref "refs/tags/$new_ref" "$new_sha1"
+ git update-ref "refs/tags/$new_ref" "$new_sha1" ||
+ die "Could not write tag $new_ref"
done
fi
cd ../..
rm -rf "$tempdir"
-echo "Rewritten history saved to the $dstbranch branch"
+
+trap - 0
+
+unset GIT_DIR GIT_WORK_TREE GIT_INDEX_FILE
+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
+git read-tree -u -m HEAD
exit $ret