git-filter-branch.sh

   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
  13 functions=$(cat << \EOF
  14 EMPTY_TREE=$(git hash-object -t tree /dev/null)
  15
  16 warn () {
  17         echo "$*" >&2
  18 }
  19
  20 map()
  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
  34 skip_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.
  47 git_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
  60 die()
  61 {
  62         echo >&2
  63         echo "$*" >&2
  64         exit 1
  65 }
  66 EOF
  67 )
  68
  69 eval "$functions"
  70
  71 finish_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
  80 set_ident () {
  81         parse_ident_from_commit author AUTHOR committer COMMITTER
  82         finish_ident AUTHOR
  83         finish_ident COMMITTER
  84 }
  85
  86 if test -z "$FILTER_BRANCH_SQUELCH_WARNING$GIT_TEST_DISALLOW_ABBREVIATED_OPTIONS"
  87 then
  88         cat <<EOF
  89 WARNING: 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.
  95 EOF
  96         sleep 10
  97         printf "Proceeding with filter-branch...\n\n"
  98 fi
  99
 100 USAGE="[--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
 108 OPTIONS_SPEC=
 109 . git-sh-setup
 110
 111 if [ "$(is_bare_repository)" = false ]; then
 112         require_clean_work_tree 'rewrite branches'
 113 fi
 114
 115 tempdir=.git-rewrite
 116 filter_setup=
 117 filter_env=
 118 filter_tree=
 119 filter_index=
 120 filter_parent=
 121 filter_msg=cat
 122 filter_commit=
 123 filter_tag_name=
 124 filter_subdir=
 125 state_branch=
 126 orig_namespace=refs/original/
 127 force=
 128 prune_empty=
 129 remap_to_ancestor=
 130 while :
 131 do
 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
 208 done
 209
 210 case "$prune_empty,$filter_commit" in
 211 ,)
 212         filter_commit='git commit-tree "$@"';;
 213 t,)
 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"
 219 esac
 220
 221 case "$force" in
 222 t)
 223         rm -rf "$tempdir"
 224 ;;
 225 '')
 226         test -d "$tempdir" &&
 227                 die "$tempdir already exists, please remove it"
 228 esac
 229 orig_dir=$(pwd)
 230 mkdir -p "$tempdir/t" &&
 231 tempdir="$(cd "$tempdir"; pwd)" &&
 232 cd "$tempdir/t" &&
 233 workdir="$(pwd)" ||
 234 die ""
 235
 236 # Remove tempdir on exit
 237 trap 'cd "$orig_dir"; rm -rf "$tempdir"' 0
 238
 239 ORIG_GIT_DIR="$GIT_DIR"
 240 ORIG_GIT_WORK_TREE="$GIT_WORK_TREE"
 241 ORIG_GIT_INDEX_FILE="$GIT_INDEX_FILE"
 242 ORIG_GIT_AUTHOR_NAME="$GIT_AUTHOR_NAME"
 243 ORIG_GIT_AUTHOR_EMAIL="$GIT_AUTHOR_EMAIL"
 244 ORIG_GIT_AUTHOR_DATE="$GIT_AUTHOR_DATE"
 245 ORIG_GIT_COMMITTER_NAME="$GIT_COMMITTER_NAME"
 246 ORIG_GIT_COMMITTER_EMAIL="$GIT_COMMITTER_EMAIL"
 247 ORIG_GIT_COMMITTER_DATE="$GIT_COMMITTER_DATE"
 248
 249 GIT_WORK_TREE=.
 250 export GIT_DIR GIT_WORK_TREE
 251
 252 # Make sure refs/original is empty
 253 git for-each-ref > "$tempdir"/backup-refs || exit
 254 while read sha1 type name
 255 do
 256         case "$force,$name" in
 257         ,$orig_namespace*)
 258                 die "Cannot create a new backup.
 259 A previous backup already exists in $orig_namespace
 260 Force overwriting the backup with -f"
 261         ;;
 262         t,$orig_namespace*)
 263                 git update-ref -d "$name" $sha1
 264         ;;
 265         esac
 266 done < "$tempdir"/backup-refs
 267
 268 # The refs should be updated if their heads were rewritten
 269 git rev-parse --no-flags --revs-only --symbolic-full-name \
 270         --default HEAD "$@" > "$tempdir"/raw-refs || exit
 271 while read ref
 272 do
 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
 281 done >"$tempdir"/heads <"$tempdir"/raw-refs
 282
 283 test -s "$tempdir"/heads ||
 284         die "You must specify a ref to rewrite."
 285
 286 GIT_INDEX_FILE="$(pwd)/../index"
 287 export GIT_INDEX_FILE
 288
 289 # map old->new commit ids for rewriting parents
 290 mkdir ../map || die "Could not create map/ directory"
 291
 292 if test -n "$state_branch"
 293 then
 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
 310 fi
 311
 312 # we need "--" only if there are no path arguments in $@
 313 nonrevs=$(git rev-parse --no-revs "$@") || exit
 314 if test -z "$nonrevs"
 315 then
 316         dashdash=--
 317 else
 318         dashdash=
 319         remap_to_ancestor=t
 320 fi
 321
 322 git rev-parse --revs-only "$@" >../parse
 323
 324 case "$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         ;;
 332 esac
 333
 334 git rev-list --reverse --topo-order --default HEAD \
 335         --parents --simplify-merges --stdin "$@" <../parse >../revs ||
 336         die "Could not get the commits"
 337 commits=$(wc -l <../revs | tr -d " ")
 338
 339 test $commits -eq 0 && die_with_status 2 "Found nothing to rewrite"
 340
 341 # Rewrite the commits
 342 report_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
 363 git_filter_branch__commit_count=0
 364
 365 progress= start_timestamp=
 366 if date '+%s' 2>/dev/null | grep -q '^[0-9][0-9]*$'
 367 then
 368         next_sample_at=0
 369         progress="dummy to ensure this is not empty"
 370         start_timestamp=$(date '+%s')
 371 fi
 372
 373 if test -n "$filter_index" ||
 374    test -n "$filter_tree" ||
 375    test -n "$filter_subdir"
 376 then
 377         need_index=t
 378 else
 379         need_index=
 380 fi
 381
 382 eval "$filter_setup" < /dev/null ||
 383         die "filter setup failed: $filter_setup"
 384
 385 while 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"
 480 done <../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
 488 if test "$remap_to_ancestor" = t
 489 then
 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
 497 fi
 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"
 503 echo
 504 while read ref
 505 do
 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
 549 done < "$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
 555 if [ "$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
 603 fi
 604
 605 unset GIT_DIR GIT_WORK_TREE GIT_INDEX_FILE
 606 unset GIT_AUTHOR_NAME GIT_AUTHOR_EMAIL GIT_AUTHOR_DATE
 607 unset GIT_COMMITTER_NAME GIT_COMMITTER_EMAIL GIT_COMMITTER_DATE
 608 test -z "$ORIG_GIT_DIR" || {
 609         GIT_DIR="$ORIG_GIT_DIR" && export GIT_DIR
 610 }
 611 test -z "$ORIG_GIT_WORK_TREE" || {
 612         GIT_WORK_TREE="$ORIG_GIT_WORK_TREE" &&
 613         export GIT_WORK_TREE
 614 }
 615 test -z "$ORIG_GIT_INDEX_FILE" || {
 616         GIT_INDEX_FILE="$ORIG_GIT_INDEX_FILE" &&
 617         export GIT_INDEX_FILE
 618 }
 619 test -z "$ORIG_GIT_AUTHOR_NAME" || {
 620         GIT_AUTHOR_NAME="$ORIG_GIT_AUTHOR_NAME" &&
 621         export GIT_AUTHOR_NAME
 622 }
 623 test -z "$ORIG_GIT_AUTHOR_EMAIL" || {
 624         GIT_AUTHOR_EMAIL="$ORIG_GIT_AUTHOR_EMAIL" &&
 625         export GIT_AUTHOR_EMAIL
 626 }
 627 test -z "$ORIG_GIT_AUTHOR_DATE" || {
 628         GIT_AUTHOR_DATE="$ORIG_GIT_AUTHOR_DATE" &&
 629         export GIT_AUTHOR_DATE
 630 }
 631 test -z "$ORIG_GIT_COMMITTER_NAME" || {
 632         GIT_COMMITTER_NAME="$ORIG_GIT_COMMITTER_NAME" &&
 633         export GIT_COMMITTER_NAME
 634 }
 635 test -z "$ORIG_GIT_COMMITTER_EMAIL" || {
 636         GIT_COMMITTER_EMAIL="$ORIG_GIT_COMMITTER_EMAIL" &&
 637         export GIT_COMMITTER_EMAIL
 638 }
 639 test -z "$ORIG_GIT_COMMITTER_DATE" || {
 640         GIT_COMMITTER_DATE="$ORIG_GIT_COMMITTER_DATE" &&
 641         export GIT_COMMITTER_DATE
 642 }
 643
 644 if test -n "$state_branch"
 645 then
 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"
 665 fi
 666
 667 cd "$orig_dir"
 668 rm -rf "$tempdir"
 669
 670 trap - 0
 671
 672 if [ "$(is_bare_repository)" = false ]; then
 673         git read-tree -u -m HEAD || exit
 674 fi
 675
 676 exit 0