git-filter-branch.shon commit Merge branch 'sg/clean-nested-repo-with-ignored' (026428c)
   1#!/bin/sh
   2#
   3# Rewrite revision history
   4# Copyright (c) Petr Baudis, 2006
   5# Minimal changes to "port" it to core-git (c) Johannes Schindelin, 2007
   6#
   7# Lets you rewrite the revision history of the current branch, creating
   8# a new branch. You can specify a number of filters to modify the commits,
   9# files and trees.
  10
  11# The following functions will also be available in the commit filter:
  12
  13functions=$(cat << \EOF
  14EMPTY_TREE=$(git hash-object -t tree /dev/null)
  15
  16warn () {
  17        echo "$*" >&2
  18}
  19
  20map()
  21{
  22        # if it was not rewritten, take the original
  23        if test -r "$workdir/../map/$1"
  24        then
  25                cat "$workdir/../map/$1"
  26        else
  27                echo "$1"
  28        fi
  29}
  30
  31# if you run 'skip_commit "$@"' in a commit filter, it will print
  32# the (mapped) parents, effectively skipping the commit.
  33
  34skip_commit()
  35{
  36        shift;
  37        while [ -n "$1" ];
  38        do
  39                shift;
  40                map "$1";
  41                shift;
  42        done;
  43}
  44
  45# if you run 'git_commit_non_empty_tree "$@"' in a commit filter,
  46# it will skip commits that leave the tree untouched, commit the other.
  47git_commit_non_empty_tree()
  48{
  49        if test $# = 3 && test "$1" = $(git rev-parse "$3^{tree}"); then
  50                map "$3"
  51        elif test $# = 1 && test "$1" = $EMPTY_TREE; then
  52                :
  53        else
  54                git commit-tree "$@"
  55        fi
  56}
  57# override die(): this version puts in an extra line break, so that
  58# the progress is still visible
  59
  60die()
  61{
  62        echo >&2
  63        echo "$*" >&2
  64        exit 1
  65}
  66EOF
  67)
  68
  69eval "$functions"
  70
  71finish_ident() {
  72        # Ensure non-empty id name.
  73        echo "case \"\$GIT_$1_NAME\" in \"\") GIT_$1_NAME=\"\${GIT_$1_EMAIL%%@*}\" && export GIT_$1_NAME;; esac"
  74        # And make sure everything is exported.
  75        echo "export GIT_$1_NAME"
  76        echo "export GIT_$1_EMAIL"
  77        echo "export GIT_$1_DATE"
  78}
  79
  80set_ident () {
  81        parse_ident_from_commit author AUTHOR committer COMMITTER
  82        finish_ident AUTHOR
  83        finish_ident COMMITTER
  84}
  85
  86if test -z "$FILTER_BRANCH_SQUELCH_WARNING$GIT_TEST_DISALLOW_ABBREVIATED_OPTIONS"
  87then
  88        cat <<EOF
  89WARNING: git-filter-branch has a glut of gotchas generating mangled history
  90         rewrites.  Hit Ctrl-C before proceeding to abort, then use an
  91         alternative filtering tool such as 'git filter-repo'
  92         (https://github.com/newren/git-filter-repo/) instead.  See the
  93         filter-branch manual page for more details; to squelch this warning,
  94         set FILTER_BRANCH_SQUELCH_WARNING=1.
  95EOF
  96        sleep 10
  97        printf "Proceeding with filter-branch...\n\n"
  98fi
  99
 100USAGE="[--setup <command>] [--subdirectory-filter <directory>] [--env-filter <command>]
 101        [--tree-filter <command>] [--index-filter <command>]
 102        [--parent-filter <command>] [--msg-filter <command>]
 103        [--commit-filter <command>] [--tag-name-filter <command>]
 104        [--original <namespace>]
 105        [-d <directory>] [-f | --force] [--state-branch <branch>]
 106        [--] [<rev-list options>...]"
 107
 108OPTIONS_SPEC=
 109. git-sh-setup
 110
 111if [ "$(is_bare_repository)" = false ]; then
 112        require_clean_work_tree 'rewrite branches'
 113fi
 114
 115tempdir=.git-rewrite
 116filter_setup=
 117filter_env=
 118filter_tree=
 119filter_index=
 120filter_parent=
 121filter_msg=cat
 122filter_commit=
 123filter_tag_name=
 124filter_subdir=
 125state_branch=
 126orig_namespace=refs/original/
 127force=
 128prune_empty=
 129remap_to_ancestor=
 130while :
 131do
 132        case "$1" in
 133        --)
 134                shift
 135                break
 136                ;;
 137        --force|-f)
 138                shift
 139                force=t
 140                continue
 141                ;;
 142        --remap-to-ancestor)
 143                # deprecated ($remap_to_ancestor is set now automatically)
 144                shift
 145                remap_to_ancestor=t
 146                continue
 147                ;;
 148        --prune-empty)
 149                shift
 150                prune_empty=t
 151                continue
 152                ;;
 153        -*)
 154                ;;
 155        *)
 156                break;
 157        esac
 158
 159        # all switches take one argument
 160        ARG="$1"
 161        case "$#" in 1) usage ;; esac
 162        shift
 163        OPTARG="$1"
 164        shift
 165
 166        case "$ARG" in
 167        -d)
 168                tempdir="$OPTARG"
 169                ;;
 170        --setup)
 171                filter_setup="$OPTARG"
 172                ;;
 173        --subdirectory-filter)
 174                filter_subdir="$OPTARG"
 175                remap_to_ancestor=t
 176                ;;
 177        --env-filter)
 178                filter_env="$OPTARG"
 179                ;;
 180        --tree-filter)
 181                filter_tree="$OPTARG"
 182                ;;
 183        --index-filter)
 184                filter_index="$OPTARG"
 185                ;;
 186        --parent-filter)
 187                filter_parent="$OPTARG"
 188                ;;
 189        --msg-filter)
 190                filter_msg="$OPTARG"
 191                ;;
 192        --commit-filter)
 193                filter_commit="$functions; $OPTARG"
 194                ;;
 195        --tag-name-filter)
 196                filter_tag_name="$OPTARG"
 197                ;;
 198        --original)
 199                orig_namespace=$(expr "$OPTARG/" : '\(.*[^/]\)/*$')/
 200                ;;
 201        --state-branch)
 202                state_branch="$OPTARG"
 203                ;;
 204        *)
 205                usage
 206                ;;
 207        esac
 208done
 209
 210case "$prune_empty,$filter_commit" in
 211,)
 212        filter_commit='git commit-tree "$@"';;
 213t,)
 214        filter_commit="$functions;"' git_commit_non_empty_tree "$@"';;
 215,*)
 216        ;;
 217*)
 218        die "Cannot set --prune-empty and --commit-filter at the same time"
 219esac
 220
 221case "$force" in
 222t)
 223        rm -rf "$tempdir"
 224;;
 225'')
 226        test -d "$tempdir" &&
 227                die "$tempdir already exists, please remove it"
 228esac
 229orig_dir=$(pwd)
 230mkdir -p "$tempdir/t" &&
 231tempdir="$(cd "$tempdir"; pwd)" &&
 232cd "$tempdir/t" &&
 233workdir="$(pwd)" ||
 234die ""
 235
 236# Remove tempdir on exit
 237trap 'cd "$orig_dir"; rm -rf "$tempdir"' 0
 238
 239ORIG_GIT_DIR="$GIT_DIR"
 240ORIG_GIT_WORK_TREE="$GIT_WORK_TREE"
 241ORIG_GIT_INDEX_FILE="$GIT_INDEX_FILE"
 242ORIG_GIT_AUTHOR_NAME="$GIT_AUTHOR_NAME"
 243ORIG_GIT_AUTHOR_EMAIL="$GIT_AUTHOR_EMAIL"
 244ORIG_GIT_AUTHOR_DATE="$GIT_AUTHOR_DATE"
 245ORIG_GIT_COMMITTER_NAME="$GIT_COMMITTER_NAME"
 246ORIG_GIT_COMMITTER_EMAIL="$GIT_COMMITTER_EMAIL"
 247ORIG_GIT_COMMITTER_DATE="$GIT_COMMITTER_DATE"
 248
 249GIT_WORK_TREE=.
 250export GIT_DIR GIT_WORK_TREE
 251
 252# Make sure refs/original is empty
 253git for-each-ref > "$tempdir"/backup-refs || exit
 254while read sha1 type name
 255do
 256        case "$force,$name" in
 257        ,$orig_namespace*)
 258                die "Cannot create a new backup.
 259A previous backup already exists in $orig_namespace
 260Force overwriting the backup with -f"
 261        ;;
 262        t,$orig_namespace*)
 263                git update-ref -d "$name" $sha1
 264        ;;
 265        esac
 266done < "$tempdir"/backup-refs
 267
 268# The refs should be updated if their heads were rewritten
 269git rev-parse --no-flags --revs-only --symbolic-full-name \
 270        --default HEAD "$@" > "$tempdir"/raw-refs || exit
 271while read ref
 272do
 273        case "$ref" in ^?*) continue ;; esac
 274
 275        if git rev-parse --verify "$ref"^0 >/dev/null 2>&1
 276        then
 277                echo "$ref"
 278        else
 279                warn "WARNING: not rewriting '$ref' (not a committish)"
 280        fi
 281done >"$tempdir"/heads <"$tempdir"/raw-refs
 282
 283test -s "$tempdir"/heads ||
 284        die "You must specify a ref to rewrite."
 285
 286GIT_INDEX_FILE="$(pwd)/../index"
 287export GIT_INDEX_FILE
 288
 289# map old->new commit ids for rewriting parents
 290mkdir ../map || die "Could not create map/ directory"
 291
 292if test -n "$state_branch"
 293then
 294        state_commit=$(git rev-parse --no-flags --revs-only "$state_branch")
 295        if test -n "$state_commit"
 296        then
 297                echo "Populating map from $state_branch ($state_commit)" 1>&2
 298                perl -e'open(MAP, "-|", "git show $ARGV[0]:filter.map") or die;
 299                        while (<MAP>) {
 300                                m/(.*):(.*)/ or die;
 301                                open F, ">../map/$1" or die;
 302                                print F "$2" or die;
 303                                close(F) or die;
 304                        }
 305                        close(MAP) or die;' "$state_commit" \
 306                                || die "Unable to load state from $state_branch:filter.map"
 307        else
 308                echo "Branch $state_branch does not exist. Will create" 1>&2
 309        fi
 310fi
 311
 312# we need "--" only if there are no path arguments in $@
 313nonrevs=$(git rev-parse --no-revs "$@") || exit
 314if test -z "$nonrevs"
 315then
 316        dashdash=--
 317else
 318        dashdash=
 319        remap_to_ancestor=t
 320fi
 321
 322git rev-parse --revs-only "$@" >../parse
 323
 324case "$filter_subdir" in
 325"")
 326        eval set -- "$(git rev-parse --sq --no-revs "$@")"
 327        ;;
 328*)
 329        eval set -- "$(git rev-parse --sq --no-revs "$@" $dashdash \
 330                "$filter_subdir")"
 331        ;;
 332esac
 333
 334git rev-list --reverse --topo-order --default HEAD \
 335        --parents --simplify-merges --stdin "$@" <../parse >../revs ||
 336        die "Could not get the commits"
 337commits=$(wc -l <../revs | tr -d " ")
 338
 339test $commits -eq 0 && die_with_status 2 "Found nothing to rewrite"
 340
 341# Rewrite the commits
 342report_progress ()
 343{
 344        if test -n "$progress" &&
 345                test $git_filter_branch__commit_count -gt $next_sample_at
 346        then
 347                count=$git_filter_branch__commit_count
 348
 349                now=$(date +%s)
 350                elapsed=$(($now - $start_timestamp))
 351                remaining=$(( ($commits - $count) * $elapsed / $count ))
 352                if test $elapsed -gt 0
 353                then
 354                        next_sample_at=$(( ($elapsed + 1) * $count / $elapsed ))
 355                else
 356                        next_sample_at=$(($next_sample_at + 1))
 357                fi
 358                progress=" ($elapsed seconds passed, remaining $remaining predicted)"
 359        fi
 360        printf "\rRewrite $commit ($count/$commits)$progress    "
 361}
 362
 363git_filter_branch__commit_count=0
 364
 365progress= start_timestamp=
 366if date '+%s' 2>/dev/null | grep -q '^[0-9][0-9]*$'
 367then
 368        next_sample_at=0
 369        progress="dummy to ensure this is not empty"
 370        start_timestamp=$(date '+%s')
 371fi
 372
 373if test -n "$filter_index" ||
 374   test -n "$filter_tree" ||
 375   test -n "$filter_subdir"
 376then
 377        need_index=t
 378else
 379        need_index=
 380fi
 381
 382eval "$filter_setup" < /dev/null ||
 383        die "filter setup failed: $filter_setup"
 384
 385while read commit parents; do
 386        git_filter_branch__commit_count=$(($git_filter_branch__commit_count+1))
 387
 388        report_progress
 389        test -f "$workdir"/../map/$commit && continue
 390
 391        case "$filter_subdir" in
 392        "")
 393                if test -n "$need_index"
 394                then
 395                        GIT_ALLOW_NULL_SHA1=1 git read-tree -i -m $commit
 396                fi
 397                ;;
 398        *)
 399                # The commit may not have the subdirectory at all
 400                err=$(GIT_ALLOW_NULL_SHA1=1 \
 401                      git read-tree -i -m $commit:"$filter_subdir" 2>&1) || {
 402                        if ! git rev-parse -q --verify $commit:"$filter_subdir"
 403                        then
 404                                rm -f "$GIT_INDEX_FILE"
 405                        else
 406                                echo >&2 "$err"
 407                                false
 408                        fi
 409                }
 410        esac || die "Could not initialize the index"
 411
 412        GIT_COMMIT=$commit
 413        export GIT_COMMIT
 414        git cat-file commit "$commit" >../commit ||
 415                die "Cannot read commit $commit"
 416
 417        eval "$(set_ident <../commit)" ||
 418                die "setting author/committer failed for commit $commit"
 419        eval "$filter_env" < /dev/null ||
 420                die "env filter failed: $filter_env"
 421
 422        if [ "$filter_tree" ]; then
 423                git checkout-index -f -u -a ||
 424                        die "Could not checkout the index"
 425                # files that $commit removed are now still in the working tree;
 426                # remove them, else they would be added again
 427                git clean -d -q -f -x
 428                eval "$filter_tree" < /dev/null ||
 429                        die "tree filter failed: $filter_tree"
 430
 431                (
 432                        git diff-index -r --name-only --ignore-submodules $commit -- &&
 433                        git ls-files --others
 434                ) > "$tempdir"/tree-state || exit
 435                git update-index --add --replace --remove --stdin \
 436                        < "$tempdir"/tree-state || exit
 437        fi
 438
 439        eval "$filter_index" < /dev/null ||
 440                die "index filter failed: $filter_index"
 441
 442        parentstr=
 443        for parent in $parents; do
 444                for reparent in $(map "$parent"); do
 445                        case "$parentstr " in
 446                        *" -p $reparent "*)
 447                                ;;
 448                        *)
 449                                parentstr="$parentstr -p $reparent"
 450                                ;;
 451                        esac
 452                done
 453        done
 454        if [ "$filter_parent" ]; then
 455                parentstr="$(echo "$parentstr" | eval "$filter_parent")" ||
 456                                die "parent filter failed: $filter_parent"
 457        fi
 458
 459        {
 460                while IFS='' read -r header_line && test -n "$header_line"
 461                do
 462                        # skip header lines...
 463                        :;
 464                done
 465                # and output the actual commit message
 466                cat
 467        } <../commit |
 468                eval "$filter_msg" > ../message ||
 469                        die "msg filter failed: $filter_msg"
 470
 471        if test -n "$need_index"
 472        then
 473                tree=$(git write-tree)
 474        else
 475                tree=$(git rev-parse "$commit^{tree}")
 476        fi
 477        workdir=$workdir @SHELL_PATH@ -c "$filter_commit" "git commit-tree" \
 478                "$tree" $parentstr < ../message > ../map/$commit ||
 479                        die "could not write rewritten commit"
 480done <../revs
 481
 482# If we are filtering for paths, as in the case of a subdirectory
 483# filter, it is possible that a specified head is not in the set of
 484# rewritten commits, because it was pruned by the revision walker.
 485# Ancestor remapping fixes this by mapping these heads to the unique
 486# nearest ancestor that survived the pruning.
 487
 488if test "$remap_to_ancestor" = t
 489then
 490        while read ref
 491        do
 492                sha1=$(git rev-parse "$ref"^0)
 493                test -f "$workdir"/../map/$sha1 && continue
 494                ancestor=$(git rev-list --simplify-merges -1 "$ref" "$@")
 495                test "$ancestor" && echo $(map $ancestor) >> "$workdir"/../map/$sha1
 496        done < "$tempdir"/heads
 497fi
 498
 499# Finally update the refs
 500
 501_x40='[0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f]'
 502_x40="$_x40$_x40$_x40$_x40$_x40$_x40$_x40$_x40"
 503echo
 504while read ref
 505do
 506        # avoid rewriting a ref twice
 507        test -f "$orig_namespace$ref" && continue
 508
 509        sha1=$(git rev-parse "$ref"^0)
 510        rewritten=$(map $sha1)
 511
 512        test $sha1 = "$rewritten" &&
 513                warn "WARNING: Ref '$ref' is unchanged" &&
 514                continue
 515
 516        case "$rewritten" in
 517        '')
 518                echo "Ref '$ref' was deleted"
 519                git update-ref -m "filter-branch: delete" -d "$ref" $sha1 ||
 520                        die "Could not delete $ref"
 521        ;;
 522        $_x40)
 523                echo "Ref '$ref' was rewritten"
 524                if ! git update-ref -m "filter-branch: rewrite" \
 525                                        "$ref" $rewritten $sha1 2>/dev/null; then
 526                        if test $(git cat-file -t "$ref") = tag; then
 527                                if test -z "$filter_tag_name"; then
 528                                        warn "WARNING: You said to rewrite tagged commits, but not the corresponding tag."
 529                                        warn "WARNING: Perhaps use '--tag-name-filter cat' to rewrite the tag."
 530                                fi
 531                        else
 532                                die "Could not rewrite $ref"
 533                        fi
 534                fi
 535        ;;
 536        *)
 537                # NEEDSWORK: possibly add -Werror, making this an error
 538                warn "WARNING: '$ref' was rewritten into multiple commits:"
 539                warn "$rewritten"
 540                warn "WARNING: Ref '$ref' points to the first one now."
 541                rewritten=$(echo "$rewritten" | head -n 1)
 542                git update-ref -m "filter-branch: rewrite to first" \
 543                                "$ref" $rewritten $sha1 ||
 544                        die "Could not rewrite $ref"
 545        ;;
 546        esac
 547        git update-ref -m "filter-branch: backup" "$orig_namespace$ref" $sha1 ||
 548                 exit
 549done < "$tempdir"/heads
 550
 551# TODO: This should possibly go, with the semantics that all positive given
 552#       refs are updated, and their original heads stored in refs/original/
 553# Filter tags
 554
 555if [ "$filter_tag_name" ]; then
 556        git for-each-ref --format='%(objectname) %(objecttype) %(refname)' refs/tags |
 557        while read sha1 type ref; do
 558                ref="${ref#refs/tags/}"
 559                # XXX: Rewrite tagged trees as well?
 560                if [ "$type" != "commit" -a "$type" != "tag" ]; then
 561                        continue;
 562                fi
 563
 564                if [ "$type" = "tag" ]; then
 565                        # Dereference to a commit
 566                        sha1t="$sha1"
 567                        sha1="$(git rev-parse -q "$sha1"^{commit})" || continue
 568                fi
 569
 570                [ -f "../map/$sha1" ] || continue
 571                new_sha1="$(cat "../map/$sha1")"
 572                GIT_COMMIT="$sha1"
 573                export GIT_COMMIT
 574                new_ref="$(echo "$ref" | eval "$filter_tag_name")" ||
 575                        die "tag name filter failed: $filter_tag_name"
 576
 577                echo "$ref -> $new_ref ($sha1 -> $new_sha1)"
 578
 579                if [ "$type" = "tag" ]; then
 580                        new_sha1=$( ( printf 'object %s\ntype commit\ntag %s\n' \
 581                                                "$new_sha1" "$new_ref"
 582                                git cat-file tag "$ref" |
 583                                sed -n \
 584                                    -e '1,/^$/{
 585                                          /^object /d
 586                                          /^type /d
 587                                          /^tag /d
 588                                        }' \
 589                                    -e '/^-----BEGIN PGP SIGNATURE-----/q' \
 590                                    -e 'p' ) |
 591                                git hash-object -t tag -w --stdin) ||
 592                                die "Could not create new tag object for $ref"
 593                        if git cat-file tag "$ref" | \
 594                           sane_grep '^-----BEGIN PGP SIGNATURE-----' >/dev/null 2>&1
 595                        then
 596                                warn "gpg signature stripped from tag object $sha1t"
 597                        fi
 598                fi
 599
 600                git update-ref "refs/tags/$new_ref" "$new_sha1" ||
 601                        die "Could not write tag $new_ref"
 602        done
 603fi
 604
 605unset GIT_DIR GIT_WORK_TREE GIT_INDEX_FILE
 606unset GIT_AUTHOR_NAME GIT_AUTHOR_EMAIL GIT_AUTHOR_DATE
 607unset GIT_COMMITTER_NAME GIT_COMMITTER_EMAIL GIT_COMMITTER_DATE
 608test -z "$ORIG_GIT_DIR" || {
 609        GIT_DIR="$ORIG_GIT_DIR" && export GIT_DIR
 610}
 611test -z "$ORIG_GIT_WORK_TREE" || {
 612        GIT_WORK_TREE="$ORIG_GIT_WORK_TREE" &&
 613        export GIT_WORK_TREE
 614}
 615test -z "$ORIG_GIT_INDEX_FILE" || {
 616        GIT_INDEX_FILE="$ORIG_GIT_INDEX_FILE" &&
 617        export GIT_INDEX_FILE
 618}
 619test -z "$ORIG_GIT_AUTHOR_NAME" || {
 620        GIT_AUTHOR_NAME="$ORIG_GIT_AUTHOR_NAME" &&
 621        export GIT_AUTHOR_NAME
 622}
 623test -z "$ORIG_GIT_AUTHOR_EMAIL" || {
 624        GIT_AUTHOR_EMAIL="$ORIG_GIT_AUTHOR_EMAIL" &&
 625        export GIT_AUTHOR_EMAIL
 626}
 627test -z "$ORIG_GIT_AUTHOR_DATE" || {
 628        GIT_AUTHOR_DATE="$ORIG_GIT_AUTHOR_DATE" &&
 629        export GIT_AUTHOR_DATE
 630}
 631test -z "$ORIG_GIT_COMMITTER_NAME" || {
 632        GIT_COMMITTER_NAME="$ORIG_GIT_COMMITTER_NAME" &&
 633        export GIT_COMMITTER_NAME
 634}
 635test -z "$ORIG_GIT_COMMITTER_EMAIL" || {
 636        GIT_COMMITTER_EMAIL="$ORIG_GIT_COMMITTER_EMAIL" &&
 637        export GIT_COMMITTER_EMAIL
 638}
 639test -z "$ORIG_GIT_COMMITTER_DATE" || {
 640        GIT_COMMITTER_DATE="$ORIG_GIT_COMMITTER_DATE" &&
 641        export GIT_COMMITTER_DATE
 642}
 643
 644if test -n "$state_branch"
 645then
 646        echo "Saving rewrite state to $state_branch" 1>&2
 647        state_blob=$(
 648                perl -e'opendir D, "../map" or die;
 649                        open H, "|-", "git hash-object -w --stdin" or die;
 650                        foreach (sort readdir(D)) {
 651                                next if m/^\.\.?$/;
 652                                open F, "<../map/$_" or die;
 653                                chomp($f = <F>);
 654                                print H "$_:$f\n" or die;
 655                        }
 656                        close(H) or die;' || die "Unable to save state")
 657        state_tree=$(printf '100644 blob %s\tfilter.map\n' "$state_blob" | git mktree)
 658        if test -n "$state_commit"
 659        then
 660                state_commit=$(echo "Sync" | git commit-tree "$state_tree" -p "$state_commit")
 661        else
 662                state_commit=$(echo "Sync" | git commit-tree "$state_tree" )
 663        fi
 664        git update-ref "$state_branch" "$state_commit"
 665fi
 666
 667cd "$orig_dir"
 668rm -rf "$tempdir"
 669
 670trap - 0
 671
 672if [ "$(is_bare_repository)" = false ]; then
 673        git read-tree -u -m HEAD || exit
 674fi
 675
 676exit 0