diff options
Diffstat (limited to 'third_party/git/git-filter-branch.sh')
| -rwxr-xr-x | third_party/git/git-filter-branch.sh | 662 |
1 files changed, 662 insertions, 0 deletions
diff --git a/third_party/git/git-filter-branch.sh b/third_party/git/git-filter-branch.sh new file mode 100755 index 0000000000..5c5afa2b98 --- /dev/null +++ b/third_party/git/git-filter-branch.sh @@ -0,0 +1,662 @@ +#!/bin/sh +# +# Rewrite revision history +# Copyright (c) Petr Baudis, 2006 +# Minimal changes to "port" it to core-git (c) Johannes Schindelin, 2007 +# +# 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. + +# The following functions will also be available in the commit filter: + +functions=$(cat << \EOF +EMPTY_TREE=$(git hash-object -t tree /dev/null) + +warn () { + echo "$*" >&2 +} + +map() +{ + # 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; +} + +# 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" + elif test $# = 1 && test "$1" = $EMPTY_TREE; then + : + else + git commit-tree "$@" + fi +} +# 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" + +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" +} + +set_ident () { + parse_ident_from_commit author AUTHOR committer COMMITTER + finish_ident AUTHOR + finish_ident COMMITTER +} + +USAGE="[--setup <command>] [--subdirectory-filter <directory>] [--env-filter <command>] + [--tree-filter <command>] [--index-filter <command>] + [--parent-filter <command>] [--msg-filter <command>] + [--commit-filter <command>] [--tag-name-filter <command>] + [--original <namespace>] + [-d <directory>] [-f | --force] [--state-branch <branch>] + [--] [<rev-list options>...]" + +OPTIONS_SPEC= +. git-sh-setup + +if [ "$(is_bare_repository)" = false ]; then + require_clean_work_tree 'rewrite branches' +fi + +tempdir=.git-rewrite +filter_setup= +filter_env= +filter_tree= +filter_index= +filter_parent= +filter_msg=cat +filter_commit= +filter_tag_name= +filter_subdir= +state_branch= +orig_namespace=refs/original/ +force= +prune_empty= +remap_to_ancestor= +while : +do + case "$1" in + --) + shift + break + ;; + --force|-f) + shift + force=t + continue + ;; + --remap-to-ancestor) + # deprecated ($remap_to_ancestor is set now automatically) + shift + remap_to_ancestor=t + continue + ;; + --prune-empty) + shift + prune_empty=t + continue + ;; + -*) + ;; + *) + break; + esac + + # all switches take one argument + ARG="$1" + case "$#" in 1) usage ;; esac + shift + OPTARG="$1" + shift + + case "$ARG" in + -d) + tempdir="$OPTARG" + ;; + --setup) + filter_setup="$OPTARG" + ;; + --subdirectory-filter) + filter_subdir="$OPTARG" + remap_to_ancestor=t + ;; + --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) + filter_commit="$functions; $OPTARG" + ;; + --tag-name-filter) + filter_tag_name="$OPTARG" + ;; + --original) + orig_namespace=$(expr "$OPTARG/" : '\(.*[^/]\)/*$')/ + ;; + --state-branch) + state_branch="$OPTARG" + ;; + *) + usage + ;; + esac +done + +case "$prune_empty,$filter_commit" in +,) + filter_commit='git commit-tree "$@"';; +t,) + filter_commit="$functions;"' git_commit_non_empty_tree "$@"';; +,*) + ;; +*) + die "Cannot set --prune-empty and --commit-filter at the same time" +esac + +case "$force" in +t) + rm -rf "$tempdir" +;; +'') + test -d "$tempdir" && + die "$tempdir already exists, please remove it" +esac +orig_dir=$(pwd) +mkdir -p "$tempdir/t" && +tempdir="$(cd "$tempdir"; pwd)" && +cd "$tempdir/t" && +workdir="$(pwd)" || +die "" + +# Remove tempdir on exit +trap 'cd "$orig_dir"; rm -rf "$tempdir"' 0 + +ORIG_GIT_DIR="$GIT_DIR" +ORIG_GIT_WORK_TREE="$GIT_WORK_TREE" +ORIG_GIT_INDEX_FILE="$GIT_INDEX_FILE" +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" + +GIT_WORK_TREE=. +export GIT_DIR GIT_WORK_TREE + +# Make sure refs/original is empty +git for-each-ref > "$tempdir"/backup-refs || exit +while read sha1 type name +do + case "$force,$name" in + ,$orig_namespace*) + die "Cannot create a new backup. +A previous backup already exists in $orig_namespace +Force overwriting the backup with -f" + ;; + t,$orig_namespace*) + git update-ref -d "$name" $sha1 + ;; + esac +done < "$tempdir"/backup-refs + +# The refs should be updated if their heads were rewritten +git rev-parse --no-flags --revs-only --symbolic-full-name \ + --default HEAD "$@" > "$tempdir"/raw-refs || exit +while read ref +do + case "$ref" in ^?*) continue ;; esac + + if git rev-parse --verify "$ref"^0 >/dev/null 2>&1 + then + echo "$ref" + else + warn "WARNING: not rewriting '$ref' (not a committish)" + fi +done >"$tempdir"/heads <"$tempdir"/raw-refs + +test -s "$tempdir"/heads || + die "You must specify a ref to rewrite." + +GIT_INDEX_FILE="$(pwd)/../index" +export GIT_INDEX_FILE + +# map old->new commit ids for rewriting parents +mkdir ../map || die "Could not create map/ directory" + +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 + +# we need "--" only if there are no path arguments in $@ +nonrevs=$(git rev-parse --no-revs "$@") || exit +if test -z "$nonrevs" +then + dashdash=-- +else + dashdash= + remap_to_ancestor=t +fi + +git rev-parse --revs-only "$@" >../parse + +case "$filter_subdir" in +"") + eval set -- "$(git rev-parse --sq --no-revs "$@")" + ;; +*) + eval set -- "$(git rev-parse --sq --no-revs "$@" $dashdash \ + "$filter_subdir")" + ;; +esac + +git rev-list --reverse --topo-order --default HEAD \ + --parents --simplify-merges --stdin "$@" <../parse >../revs || + die "Could not get the commits" +commits=$(wc -l <../revs | tr -d " ") + +test $commits -eq 0 && die_with_status 2 "Found nothing to rewrite" + +# Rewrite the commits +report_progress () +{ + if test -n "$progress" && + test $git_filter_branch__commit_count -gt $next_sample_at + then + count=$git_filter_branch__commit_count + + now=$(date +%s) + elapsed=$(($now - $start_timestamp)) + remaining=$(( ($commits - $count) * $elapsed / $count )) + if test $elapsed -gt 0 + then + next_sample_at=$(( ($elapsed + 1) * $count / $elapsed )) + else + next_sample_at=$(($next_sample_at + 1)) + fi + progress=" ($elapsed seconds passed, remaining $remaining predicted)" + fi + printf "\rRewrite $commit ($count/$commits)$progress " +} + +git_filter_branch__commit_count=0 + +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 + +if test -n "$filter_index" || + test -n "$filter_tree" || + test -n "$filter_subdir" +then + need_index=t +else + need_index= +fi + +eval "$filter_setup" < /dev/null || + die "filter setup failed: $filter_setup" + +while read commit parents; do + git_filter_branch__commit_count=$(($git_filter_branch__commit_count+1)) + + report_progress + test -f "$workdir"/../map/$commit && continue + + case "$filter_subdir" in + "") + if test -n "$need_index" + then + GIT_ALLOW_NULL_SHA1=1 git read-tree -i -m $commit + fi + ;; + *) + # The commit may not have the subdirectory at all + err=$(GIT_ALLOW_NULL_SHA1=1 \ + git read-tree -i -m $commit:"$filter_subdir" 2>&1) || { + if ! git rev-parse -q --verify $commit:"$filter_subdir" + then + rm -f "$GIT_INDEX_FILE" + else + echo >&2 "$err" + false + fi + } + esac || die "Could not initialize the index" + + GIT_COMMIT=$commit + export GIT_COMMIT + git cat-file commit "$commit" >../commit || + die "Cannot read commit $commit" + + eval "$(set_ident <../commit)" || + die "setting author/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 || + 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 clean -d -q -f -x + eval "$filter_tree" < /dev/null || + die "tree filter failed: $filter_tree" + + ( + git diff-index -r --name-only --ignore-submodules $commit -- && + git ls-files --others + ) > "$tempdir"/tree-state || exit + git update-index --add --replace --remove --stdin \ + < "$tempdir"/tree-state || exit + fi + + eval "$filter_index" < /dev/null || + die "index filter failed: $filter_index" + + parentstr= + for parent in $parents; do + for reparent in $(map "$parent"); do + case "$parentstr " in + *" -p $reparent "*) + ;; + *) + parentstr="$parentstr -p $reparent" + ;; + esac + done + done + if [ "$filter_parent" ]; then + parentstr="$(echo "$parentstr" | eval "$filter_parent")" || + die "parent filter failed: $filter_parent" + fi + + { + while IFS='' read -r header_line && test -n "$header_line" + do + # skip header lines... + :; + done + # and output the actual commit message + cat + } <../commit | + eval "$filter_msg" > ../message || + die "msg filter failed: $filter_msg" + + if test -n "$need_index" + then + tree=$(git write-tree) + else + tree=$(git rev-parse "$commit^{tree}") + fi + workdir=$workdir @SHELL_PATH@ -c "$filter_commit" "git commit-tree" \ + "$tree" $parentstr < ../message > ../map/$commit || + die "could not write rewritten commit" +done <../revs + +# 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. + +if test "$remap_to_ancestor" = t +then + while read ref + do + sha1=$(git rev-parse "$ref"^0) + test -f "$workdir"/../map/$sha1 && continue + ancestor=$(git rev-list --simplify-merges -1 "$ref" "$@") + test "$ancestor" && echo $(map $ancestor) >> "$workdir"/../map/$sha1 + done < "$tempdir"/heads +fi + +# 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" + 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 + ;; + *) + # 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 || + exit +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 | + 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" + sha1="$(git rev-parse -q "$sha1"^{commit})" || continue + fi + + [ -f "../map/$sha1" ] || continue + new_sha1="$(cat "../map/$sha1")" + 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)" + + if [ "$type" = "tag" ]; then + new_sha1=$( ( printf 'object %s\ntype commit\ntag %s\n' \ + "$new_sha1" "$new_ref" + git cat-file tag "$ref" | + sed -n \ + -e '1,/^$/{ + /^object /d + /^type /d + /^tag /d + }' \ + -e '/^-----BEGIN PGP SIGNATURE-----/q' \ + -e 'p' ) | + git hash-object -t tag -w --stdin) || + die "Could not create new tag object for $ref" + if git cat-file tag "$ref" | \ + sane_grep '^-----BEGIN PGP SIGNATURE-----' >/dev/null 2>&1 + then + warn "gpg signature stripped from tag object $sha1t" + fi + fi + + git update-ref "refs/tags/$new_ref" "$new_sha1" || + die "Could not write tag $new_ref" + done +fi + +unset GIT_DIR GIT_WORK_TREE GIT_INDEX_FILE +unset GIT_AUTHOR_NAME GIT_AUTHOR_EMAIL GIT_AUTHOR_DATE +unset GIT_COMMITTER_NAME GIT_COMMITTER_EMAIL GIT_COMMITTER_DATE +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 +} +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 +} + +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=$(printf '100644 blob %s\tfilter.map\n' "$state_blob" | git mktree) + if test -n "$state_commit" + then + state_commit=$(echo "Sync" | git commit-tree "$state_tree" -p "$state_commit") + else + state_commit=$(echo "Sync" | git commit-tree "$state_tree" ) + fi + git update-ref "$state_branch" "$state_commit" +fi + +cd "$orig_dir" +rm -rf "$tempdir" + +trap - 0 + +if [ "$(is_bare_repository)" = false ]; then + git read-tree -u -m HEAD || exit +fi + +exit 0 |