patch_util 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e6922fb856381f64462a95b3d1cac90be5d9cce4eca63783cb0966da67252047
-  data.tar.gz: c4b080b73b5e6eacc8bf030c375ae3bd5caf12bc490bb55d6e78b6d2aca00f87
+  metadata.gz: bf6570d59e8e6963dff93ccdefb9700ef5e092983ead2247d6d1d1b3089480f8
+  data.tar.gz: f93ac6bac66beeb70b20ba5bcaae298c0d6009f83a31a34b2bd55e443ed245e3
 SHA512:
-  metadata.gz: 815db1d23e934a049c97f733b7948d8fa88cb040262c52fe00f0f3241f96e6d35ffad69553b4245b35de98007314017716356f8e324987d5358bda7e8a5f9b93
-  data.tar.gz: d1b3348828a4732ca3250b3a4ab392fa3738c45d273463124e18bdc30f06f1dc1f971f3fdb458a5fa0513a8f63c040e48d97eabc68bb9c25c73549e0ce3cce16
+  metadata.gz: e4112a08d973206903cdd2412607f40f2f8832a48878f09bcc34ea25f0ca1107341017776ac0a072703bd0ed7e6387bac8eb85aaec919b11fef91301abe52df2
+  data.tar.gz: b1efec788658c8bc301e513200ef257e5d668c585eb9d68c8471c8ac41bafcc02bea3b1459bae6ce9b9b233800fad34c484b07bb53d3f0f8f41c86385324ae28

data/CHANGELOG.md

@@ -1,3 +1,8 @@
-Initial release.
-
+## v0.1.1
 - Add GitHub Actions CI for Ruby matrix testing.
+- Fix rewrite replay when git identity is not configured in the environment.
+- Fix sequential replay for split text additions and deletions.
+- Add rewrite preflight verification so non-replayable chunk series fail before history rewrite starts.
+
+## v0.1.0
+- Initial release.

data/lib/patch_util/git/cli.rb

@@ -111,6 +111,14 @@ module PatchUtil
         stdout
       end
 
+      def check_patch_text(path, patch_text)
+        stdout, stderr, status = Open3.capture3('git', '-C', File.expand_path(path), 'apply', '--check',
+                                                '--whitespace=nowarn', '-', stdin_data: patch_text)
+        raise PatchUtil::Error, "git apply --check failed: #{stderr.strip}" unless status.success?
+
+        stdout
+      end
+
       def commit_all(path, message, env: {})
         add_stdout, add_stderr, add_status = Open3.capture3(env, 'git', '-C', File.expand_path(path), 'add', '-A')
         raise PatchUtil::Error, "git add failed: #{add_stderr.strip}" unless add_status.success?

data/lib/patch_util/git/rewrite_preflight_verifier.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+module PatchUtil
+  module Git
+    class RewritePreflightVerifier
+      def initialize(git_cli: Cli.new, applier: PatchUtil::Split::Applier.new, clock: -> { Time.now.utc })
+        @git_cli = git_cli
+        @applier = applier
+        @clock = clock
+      end
+
+      def verify(source:, parent:, diff:, plan_entry:, branch:)
+        repo_path = source.repo_path
+        worktree = build_worktree_path(repo_path, branch, source.commit_sha)
+        output_dir = File.join(worktree, '.patch_util_emitted')
+        nil
+        worktree_added = false
+
+        begin
+          @git_cli.worktree_add(repo_path, worktree, parent)
+          worktree_added = true
+          emitted = @applier.apply(diff: diff, plan_entry: plan_entry, output_dir: output_dir)
+          emitted.each do |item|
+            @git_cli.check_patch_text(worktree, item[:patch_text])
+            @git_cli.apply_patch_text(worktree, item[:patch_text])
+          rescue PatchUtil::Error => e
+            raise PatchUtil::ValidationError, "rewrite preflight failed for chunk #{item[:name]}: #{e.message}"
+          end
+
+          emitted.map do |item|
+            { name: item[:name], patch_text: item[:patch_text] }
+          end
+        ensure
+          @git_cli.worktree_remove(repo_path, worktree) if worktree_added
+        end
+      end
+
+      private
+
+      def timestamp_token
+        @clock.call.strftime('%Y%m%d%H%M%S')
+      end
+
+      def build_worktree_path(repo_path, branch, target)
+        git_dir = @git_cli.git_dir(repo_path)
+        root = File.join(git_dir, 'patch_util', 'rewrite-preflight-worktrees')
+        FileUtils.mkdir_p(root)
+        File.join(root, "#{timestamp_token}-#{sanitize(branch)}-#{target[0, 12]}")
+      end
+
+      def sanitize(text)
+        text.gsub(/[^a-zA-Z0-9._-]+/, '-')
+      end
+    end
+  end
+end

data/lib/patch_util/git/rewrite_session_manager.rb

@@ -57,7 +57,7 @@ module PatchUtil
           if @git_cli.cherry_pick_in_progress?(worktree)
             current_revision = @git_cli.cherry_pick_head(worktree)
             pending_revisions = normalize_pending_revisions(repo_path, state, current_revision, pending_revisions)
-            @git_cli.cherry_pick_continue(worktree)
+            @git_cli.cherry_pick_continue(worktree, env: replay_commit_env(repo_path, current_revision))
             pending_revisions.shift if pending_revisions.first == current_revision
           elsif !@git_cli.worktree_clean?(worktree)
             raise PatchUtil::ValidationError,
@@ -66,7 +66,7 @@ module PatchUtil
 
           until pending_revisions.empty?
             revision = pending_revisions.first
-            @git_cli.cherry_pick(worktree, revision)
+            @git_cli.cherry_pick(worktree, revision, env: replay_commit_env(repo_path, revision))
             pending_revisions.shift
           end
 
@@ -466,6 +466,15 @@ module PatchUtil
         [current_revision, *@git_cli.rev_list(repo_path, "#{current_revision}..#{state.head_sha}")]
       end
 
+      def replay_commit_env(repo_path, revision)
+        original_commit = @git_cli.show_commit_metadata(repo_path, revision)
+        {
+          'GIT_COMMITTER_NAME' => original_commit.committer_name,
+          'GIT_COMMITTER_EMAIL' => original_commit.committer_email,
+          'GIT_COMMITTER_DATE' => original_commit.committer_date
+        }
+      end
+
       def finalize_rewrite(repo_path, branch, old_head, backup_ref, worktree, state_store)
         new_head = @git_cli.head_sha(worktree)
         @git_cli.update_ref(repo_path, "refs/heads/#{branch}", new_head, old_head)

data/lib/patch_util/git/rewriter.rb

@@ -20,11 +20,16 @@ module PatchUtil
       Status = RewriteSessionManager::Status
 
       def initialize(git_cli: Cli.new, applier: PatchUtil::Split::Applier.new, clock: -> { Time.now.utc },
-                     session_manager: nil)
+                     session_manager: nil, preflight_verifier: nil)
         @git_cli = git_cli
         @applier = applier
         @clock = clock
         @session_manager = session_manager || RewriteSessionManager.new(git_cli: git_cli, clock: clock)
+        @preflight_verifier = preflight_verifier || RewritePreflightVerifier.new(
+          git_cli: git_cli,
+          applier: applier,
+          clock: clock
+        )
       end
 
       def rewrite(source:, diff:, plan_entry:)
@@ -52,29 +57,33 @@ module PatchUtil
           raise PatchUtil::ValidationError,
                 "git rewrite apply does not support descendant merge commits yet: #{merge_descendant} is a merge commit in #{target}..#{head}"
         end
+
+        emitted = @preflight_verifier.verify(
+          source: source,
+          parent: parent,
+          diff: diff,
+          plan_entry: plan_entry,
+          branch: branch
+        )
+
         original_commit = @git_cli.show_commit_metadata(repo_path, target)
         backup_ref = "refs/patch_util-backups/#{branch}/#{timestamp_token}"
         @git_cli.update_ref(repo_path, backup_ref, head)
         worktree = build_worktree_path(repo_path, branch, target)
-        emitted_output_dir = File.join(worktree, '.patch_util_emitted')
         state_store = RewriteStateStore.new(git_dir: @git_cli.git_dir(repo_path))
         pending_revisions = descendants.dup
 
         begin
           @git_cli.worktree_add(repo_path, worktree, parent)
-
-          emitted = @applier.apply(diff: diff, plan_entry: plan_entry,
-                                   output_dir: emitted_output_dir)
           emitted.each do |item|
             @git_cli.apply_patch_text(worktree, item[:patch_text])
-            FileUtils.rm_rf(emitted_output_dir)
             @git_cli.commit_all(worktree, build_commit_message(item[:name], target, original_commit),
                                 env: split_commit_env(original_commit))
           end
 
           until pending_revisions.empty?
             revision = pending_revisions.first
-            @git_cli.cherry_pick(worktree, revision)
+            @git_cli.cherry_pick(worktree, revision, env: replay_commit_env(repo_path, revision))
             pending_revisions.shift
           end
 
@@ -214,6 +223,15 @@ module PatchUtil
         }
       end
 
+      def replay_commit_env(repo_path, revision)
+        original_commit = @git_cli.show_commit_metadata(repo_path, revision)
+        {
+          'GIT_COMMITTER_NAME' => original_commit.committer_name,
+          'GIT_COMMITTER_EMAIL' => original_commit.committer_email,
+          'GIT_COMMITTER_DATE' => original_commit.committer_date
+        }
+      end
+
       def timestamp_token
         @clock.call.strftime('%Y%m%d%H%M%S')
       end

data/lib/patch_util/git.rb

@@ -3,6 +3,7 @@
 module PatchUtil
   module Git
     autoload :Cli, 'patch_util/git/cli'
+    autoload :RewritePreflightVerifier, 'patch_util/git/rewrite_preflight_verifier'
     autoload :RewriteStateStore, 'patch_util/git/rewrite_state_store'
     autoload :RewriteSessionManager, 'patch_util/git/rewrite_session_manager'
     autoload :Rewriter, 'patch_util/git/rewriter'

data/lib/patch_util/split/projector.rb

@@ -10,6 +10,7 @@ module PatchUtil
         @diff = diff
         @plan_entry = plan_entry
         @chunk_index_by_row_id = {}
+        @chunk_indexes_by_file_diff = {}
 
         @plan_entry.chunks.each_with_index do |chunk, chunk_index|
           chunk.row_ids.each do |row_id|
@@ -27,6 +28,8 @@ module PatchUtil
           projected_hunks = []
           path_operation_applied_before = path_operation_applied_before?(file_diff, chunk_index)
           path_operation_applied_after = path_operation_applied_after?(file_diff, chunk_index)
+          file_present_before = file_present_before?(file_diff, chunk_index)
+          file_present_after = file_present_after?(file_diff, chunk_index)
 
           file_diff.hunks.each do |hunk|
             case hunk.kind
@@ -37,7 +40,14 @@ module PatchUtil
               projected_hunk = project_binary_hunk(hunk, chunk_index)
               projected_hunks << projected_hunk if projected_hunk
             else
-              changed, projected_hunk = project_text_hunk(hunk, chunk_index, before_offset, after_offset)
+              changed, projected_hunk = project_text_hunk(
+                hunk,
+                chunk_index,
+                before_offset,
+                after_offset,
+                file_present_before,
+                file_present_after
+              )
               projected_hunks << projected_hunk if changed
 
               before_offset += applied_delta(hunk, max_chunk_index: chunk_index - 1)
@@ -48,15 +58,30 @@ module PatchUtil
           next if projected_hunks.empty?
 
           metadata_lines = projected_hunks.select { |hunk| hunk.kind == :file_operation }.flat_map(&:patch_lines)
-          metadata_lines = implicit_metadata_lines(file_diff, metadata_lines) if metadata_lines.empty?
-          before_paths = current_paths(file_diff, path_operation_applied: path_operation_applied_before)
-          after_paths = current_paths(file_diff, path_operation_applied: path_operation_applied_after)
+          if metadata_lines.empty?
+            metadata_lines = implicit_metadata_lines(
+              file_diff,
+              metadata_lines,
+              file_present_before: file_present_before,
+              file_present_after: file_present_after
+            )
+          end
+          before_path = path_for_state(
+            file_diff,
+            path_operation_applied: path_operation_applied_before,
+            file_present: file_present_before
+          )
+          after_path = path_for_state(
+            file_diff,
+            path_operation_applied: path_operation_applied_after,
+            file_present: file_present_after
+          )
           binary_only = projected_hunks.all? { |hunk| hunk.kind == :binary }
 
           projected_files << ProjectedFile.new(
-            old_path: before_paths[:old_path],
-            new_path: after_paths[:new_path],
-            diff_git_line: build_diff_git_line(before_paths[:old_path], after_paths[:new_path]),
+            old_path: before_path,
+            new_path: after_path,
+            diff_git_line: projected_diff_git_line(file_diff, before_path, after_path),
             metadata_lines: metadata_lines,
             hunks: projected_hunks.reject { |hunk| hunk.kind == :file_operation },
             emit_text_headers: !binary_only || emits_text_headers_for_binary?(file_diff)
@@ -96,7 +121,7 @@ module PatchUtil
         )
       end
 
-      def project_text_hunk(hunk, chunk_index, before_offset, after_offset)
+      def project_text_hunk(hunk, chunk_index, before_offset, after_offset, file_present_before, file_present_after)
         lines = []
         changed = false
         old_count = 0
@@ -124,9 +149,9 @@ module PatchUtil
         [
           changed,
           ProjectedHunk.new(
-            old_start: hunk.old_start + before_offset,
+            old_start: normalize_start(hunk.old_start + before_offset, old_count, file_present_before),
             old_count: old_count,
-            new_start: hunk.new_start + after_offset,
+            new_start: normalize_start(hunk.new_start + after_offset, new_count, file_present_after),
             new_count: new_count,
             lines: lines,
             kind: :text,
@@ -179,17 +204,6 @@ module PatchUtil
         end
       end
 
-      def current_paths(file_diff, path_operation_applied:)
-        operation_hunk = file_diff.path_operation_hunk
-        return { old_path: file_diff.old_path, new_path: file_diff.new_path } unless operation_hunk
-
-        if path_operation_applied
-          { old_path: file_diff.new_path, new_path: file_diff.new_path }
-        else
-          { old_path: file_diff.old_path, new_path: file_diff.old_path }
-        end
-      end
-
       def build_diff_git_line(old_path, new_path)
         old_git_path = if old_path == '/dev/null'
                          to_git_old_path(new_path)
@@ -209,6 +223,12 @@ module PatchUtil
         "diff --git #{old_git_path} #{new_git_path}"
       end
 
+      def projected_diff_git_line(file_diff, old_path, new_path)
+        return nil unless file_diff.diff_git_line
+
+        build_diff_git_line(old_path, new_path)
+      end
+
       def path_operation_applied_before?(file_diff, chunk_index)
         return false if chunk_index.zero?
 
@@ -224,18 +244,67 @@ module PatchUtil
         end
       end
 
+      def file_present_before?(file_diff, chunk_index)
+        file_present_at_boundary?(file_diff, chunk_index, after_chunk: false)
+      end
+
+      def file_present_after?(file_diff, chunk_index)
+        file_present_at_boundary?(file_diff, chunk_index, after_chunk: true)
+      end
+
+      def file_present_at_boundary?(file_diff, chunk_index, after_chunk:)
+        return true unless file_diff.addition? || file_diff.deletion?
+
+        chunk_indexes = chunk_indexes_for(file_diff)
+        return file_diff.deletion? if chunk_indexes.empty?
+
+        if file_diff.addition?
+          created_chunk_index = chunk_indexes.min
+          after_chunk ? chunk_index >= created_chunk_index : chunk_index > created_chunk_index
+        else
+          removed_chunk_index = chunk_indexes.max
+          after_chunk ? chunk_index < removed_chunk_index : chunk_index <= removed_chunk_index
+        end
+      end
+
+      def chunk_indexes_for(file_diff)
+        @chunk_indexes_by_file_diff[file_diff] ||= file_diff.hunks.flat_map(&:change_rows).map do |row|
+          @chunk_index_by_row_id.fetch(row.id)
+        end.uniq
+      end
+
+      def path_for_state(file_diff, path_operation_applied:, file_present:)
+        return '/dev/null' unless file_present
+        return file_diff.new_path if path_operation_applied || file_diff.addition?
+
+        file_diff.old_path
+      end
+
       def emits_text_headers_for_binary?(file_diff)
         file_diff.modification? || file_diff.path_operation_hunk
       end
 
-      def implicit_metadata_lines(file_diff, metadata_lines)
+      def implicit_metadata_lines(file_diff, metadata_lines, file_present_before:, file_present_after:)
         return metadata_lines unless file_diff.addition? || file_diff.deletion?
 
+        if file_diff.addition?
+          return [] unless !file_present_before && file_present_after
+        else
+          return [] unless file_present_before && !file_present_after
+        end
+
         file_diff.metadata_lines.select do |line|
           line.start_with?('new file mode ') || line.start_with?('deleted file mode ')
         end
       end
 
+      def normalize_start(start, count, file_present)
+        return 0 if count.zero? || !file_present
+        return 1 if start.zero?
+
+        start
+      end
+
       def to_git_old_path(path)
         return '/dev/null' if path == '/dev/null'
 

data/lib/patch_util/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module PatchUtil
-  VERSION = '0.1.0'
+  VERSION = '0.1.1'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: patch_util
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - hmdne
@@ -45,6 +45,7 @@ files:
 - lib/patch_util/git.rb
 - lib/patch_util/git/cli.rb
 - lib/patch_util/git/rewrite_cli.rb
+- lib/patch_util/git/rewrite_preflight_verifier.rb
 - lib/patch_util/git/rewrite_session_manager.rb
 - lib/patch_util/git/rewrite_state_store.rb
 - lib/patch_util/git/rewriter.rb