patch_util 0.1.0

data/lib/patch_util/git/rewriter.rb

@@ -0,0 +1,233 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'time'
+
+module PatchUtil
+  module Git
+    class Rewriter
+      Result = RewriteSessionManager::Result
+      AbortResult = RewriteSessionManager::AbortResult
+      RestoreResult = RewriteSessionManager::RestoreResult
+      ResolveResult = RewriteSessionManager::ResolveResult
+      ResolveBlockResult = RewriteSessionManager::ResolveBlockResult
+      ConflictBlocksResult = RewriteSessionManager::ConflictBlocksResult
+      ExportBlockResult = RewriteSessionManager::ExportBlockResult
+      ApplyBlockEditResult = RewriteSessionManager::ApplyBlockEditResult
+      ExportBlockSessionResult = RewriteSessionManager::ExportBlockSessionResult
+      ApplyBlockSessionEditResult = RewriteSessionManager::ApplyBlockSessionEditResult
+      SessionSummaryResult = RewriteSessionManager::SessionSummaryResult
+      Status = RewriteSessionManager::Status
+
+      def initialize(git_cli: Cli.new, applier: PatchUtil::Split::Applier.new, clock: -> { Time.now.utc },
+                     session_manager: nil)
+        @git_cli = git_cli
+        @applier = applier
+        @clock = clock
+        @session_manager = session_manager || RewriteSessionManager.new(git_cli: git_cli, clock: clock)
+      end
+
+      def rewrite(source:, diff:, plan_entry:)
+        repo_path = source.repo_path
+        raise PatchUtil::ValidationError, 'git rewrite apply requires a git commit source' unless source.git?
+
+        unless @git_cli.worktree_clean?(repo_path)
+          raise PatchUtil::ValidationError,
+                'git rewrite apply requires a clean worktree'
+        end
+
+        branch = @git_cli.current_branch(repo_path)
+        raise PatchUtil::ValidationError, 'git rewrite apply requires a checked out branch' if branch.empty?
+
+        head = @git_cli.head_sha(repo_path)
+        target = source.commit_sha
+        unless @git_cli.ancestor?(repo_path, target, head)
+          raise PatchUtil::ValidationError, "target commit #{target} is not an ancestor of HEAD"
+        end
+
+        parent = @git_cli.rev_parse(repo_path, "#{target}^")
+        descendants = @git_cli.rev_list(repo_path, "#{target}..#{head}")
+        merge_descendant = descendants.find { |revision| @git_cli.merge_commit?(repo_path, revision) }
+        if merge_descendant
+          raise PatchUtil::ValidationError,
+                "git rewrite apply does not support descendant merge commits yet: #{merge_descendant} is a merge commit in #{target}..#{head}"
+        end
+        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)
+            pending_revisions.shift
+          end
+
+          new_head = @git_cli.head_sha(worktree)
+          @git_cli.update_ref(repo_path, "refs/heads/#{branch}", new_head, head)
+          @git_cli.reset_hard(repo_path, new_head)
+          @git_cli.worktree_remove(repo_path, worktree)
+          state_store.clear_branch(branch)
+
+          Result.new(
+            branch: branch,
+            old_head: head,
+            new_head: new_head,
+            backup_ref: backup_ref,
+            commits: emitted.map { |item| item[:name] }
+          )
+        rescue PatchUtil::Error => e
+          state_store.record_failure(
+            RewriteStateStore::State.new(
+              branch: branch,
+              target_sha: target,
+              head_sha: head,
+              backup_ref: backup_ref,
+              worktree_path: worktree,
+              status: 'failed',
+              message: e.message,
+              created_at: @clock.call.iso8601,
+              pending_revisions: pending_revisions
+            )
+          )
+          raise PatchUtil::Error,
+                "#{e.message}\nbackup ref: #{backup_ref}\nretained worktree: #{worktree}"
+        end
+      end
+
+      def abort_rewrite(repo_path:)
+        @session_manager.abort_rewrite(repo_path: repo_path)
+      end
+
+      def continue_rewrite(repo_path:)
+        @session_manager.continue_rewrite(repo_path: repo_path)
+      end
+
+      def status(repo_path:)
+        @session_manager.status(repo_path: repo_path)
+      end
+
+      def restore_rewrite(repo_path:)
+        @session_manager.restore_rewrite(repo_path: repo_path)
+      end
+
+      def resolve_conflicts(repo_path:, side:, paths: nil, all_unresolved: false)
+        @session_manager.resolve_conflicts(
+          repo_path: repo_path,
+          side: side,
+          paths: paths,
+          all_unresolved: all_unresolved
+        )
+      end
+
+      def resolve_conflict_block(repo_path:, path:, block_id:, side:)
+        @session_manager.resolve_conflict_block(
+          repo_path: repo_path,
+          path: path,
+          block_id: block_id,
+          side: side
+        )
+      end
+
+      def conflict_blocks(repo_path:, paths: nil)
+        @session_manager.conflict_blocks(repo_path: repo_path, paths: paths)
+      end
+
+      def export_conflict_block(repo_path:, path:, block_id:, output_path:)
+        @session_manager.export_conflict_block(
+          repo_path: repo_path,
+          path: path,
+          block_id: block_id,
+          output_path: output_path
+        )
+      end
+
+      def apply_conflict_block_edit(repo_path:, path:, block_id:, input_path:)
+        @session_manager.apply_conflict_block_edit(
+          repo_path: repo_path,
+          path: path,
+          block_id: block_id,
+          input_path: input_path
+        )
+      end
+
+      def export_conflict_block_session(repo_path:, output_path:, paths: nil)
+        @session_manager.export_conflict_block_session(
+          repo_path: repo_path,
+          output_path: output_path,
+          paths: paths
+        )
+      end
+
+      def apply_conflict_block_session_edit(repo_path:, input_path:)
+        @session_manager.apply_conflict_block_session_edit(repo_path: repo_path, input_path: input_path)
+      end
+
+      def conflict_block_session_summary(repo_path:, paths: nil)
+        @session_manager.conflict_block_session_summary(repo_path: repo_path, paths: paths)
+      end
+
+      def next_action(status)
+        @session_manager.next_action(status)
+      end
+
+      private
+
+      def build_commit_message(chunk_name, target_sha, original_commit)
+        sections = []
+        sections << chunk_name
+        sections << original_commit.body unless original_commit.body.empty?
+        sections << build_split_metadata_block(target_sha, original_commit.subject)
+        sections.join("\n\n")
+      end
+
+      def build_split_metadata_block(target_sha, original_subject)
+        [
+          "Split-from: #{target_sha}",
+          "Original-subject: #{original_subject}"
+        ].join("\n")
+      end
+
+      def split_commit_env(original_commit)
+        {
+          'GIT_AUTHOR_NAME' => original_commit.author_name,
+          'GIT_AUTHOR_EMAIL' => original_commit.author_email,
+          'GIT_AUTHOR_DATE' => original_commit.author_date,
+          '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
+
+      def build_worktree_path(repo_path, branch, target)
+        git_dir = @git_cli.git_dir(repo_path)
+        root = File.join(git_dir, 'patch_util', 'rewrite-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.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module PatchUtil
+  module Git
+    autoload :Cli, 'patch_util/git/cli'
+    autoload :RewriteStateStore, 'patch_util/git/rewrite_state_store'
+    autoload :RewriteSessionManager, 'patch_util/git/rewrite_session_manager'
+    autoload :Rewriter, 'patch_util/git/rewriter'
+    autoload :RewriteCLI, 'patch_util/git/rewrite_cli'
+  end
+end

data/lib/patch_util/parser.rb

@@ -0,0 +1,412 @@
+# frozen_string_literal: true
+
+module PatchUtil
+  class Parser
+    HUNK_HEADER = /\A@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(?: ?(.*))?\z/
+
+    def parse(source)
+      lines = source.diff_text.lines(chomp: true)
+      file_diffs = []
+      index = 0
+      hunk_index = 0
+
+      while index < lines.length
+        index += 1 while index < lines.length && lines[index].empty?
+        break if index >= lines.length
+
+        diff_git_line = nil
+        metadata_lines = []
+
+        if lines[index].start_with?('diff --git ')
+          diff_git_line = lines[index]
+          index += 1
+
+          while index < lines.length && metadata_line?(lines[index])
+            metadata_lines << lines[index]
+            index += 1
+          end
+        elsif !lines[index].start_with?('--- ')
+          raise ParseError, "unsupported diff prelude line: #{lines[index]}"
+        end
+
+        if index < lines.length && lines[index].start_with?('Binary files ')
+          raise UnsupportedFeatureError,
+                'binary diff requires a GIT binary patch payload; plain Binary files differ output is not enough'
+        end
+
+        old_path, new_path, index = parse_paths(lines, index, metadata_lines, diff_git_line)
+        hunks = []
+
+        if index < lines.length && lines[index] == 'GIT binary patch'
+          path_lines = path_metadata_lines(metadata_lines)
+          if path_lines.any?
+            operation_hunk, hunk_index = build_operation_hunk(
+              old_path: old_path,
+              new_path: new_path,
+              patch_lines: path_lines,
+              hunk_index: hunk_index
+            )
+            hunks << operation_hunk
+          end
+
+          binary_hunk, index, hunk_index = build_binary_hunk(
+            lines: lines,
+            index: index,
+            old_path: old_path,
+            new_path: new_path,
+            metadata_lines: binary_metadata_lines(metadata_lines),
+            hunk_index: hunk_index
+          )
+          hunks << binary_hunk
+        else
+          operation_lines = nonbinary_operation_lines(metadata_lines)
+          if operation_lines.any?
+            operation_hunk, hunk_index = build_operation_hunk(
+              old_path: old_path,
+              new_path: new_path,
+              patch_lines: operation_lines,
+              hunk_index: hunk_index
+            )
+            hunks << operation_hunk
+          end
+
+          while index < lines.length && lines[index].start_with?('@@ ')
+            hunk, index = parse_text_hunk(lines, index, hunk_index)
+            hunks << hunk
+            hunk_index += 1
+          end
+        end
+
+        raise UnsupportedFeatureError, "file diff for #{new_path} has no supported hunks" if hunks.empty?
+
+        file_diffs << FileDiff.new(
+          old_path: old_path,
+          new_path: new_path,
+          hunks: hunks,
+          diff_git_line: diff_git_line,
+          metadata_lines: metadata_lines
+        )
+      end
+
+      Diff.new(source: source, file_diffs: file_diffs)
+    end
+
+    private
+
+    def parse_paths(lines, index, metadata_lines, diff_git_line)
+      if index < lines.length && lines[index].start_with?('--- ')
+        old_path = lines[index].delete_prefix('--- ')
+        index += 1
+        new_line = lines[index]
+        raise ParseError, "missing +++ header after #{old_path}" unless new_line&.start_with?('+++ ')
+
+        new_path = new_line.delete_prefix('+++ ')
+        index += 1
+        return [old_path, new_path, index]
+      end
+
+      rename_from = metadata_value(metadata_lines, 'rename from ')
+      rename_to = metadata_value(metadata_lines, 'rename to ')
+      copy_from = metadata_value(metadata_lines, 'copy from ')
+      copy_to = metadata_value(metadata_lines, 'copy to ')
+      old_path_from_diff, new_path_from_diff = diff_git_line ? paths_from_diff_git_line(diff_git_line) : [nil, nil]
+
+      return ["a/#{rename_from}", "b/#{rename_to}", index] if rename_from && rename_to
+      return ["a/#{copy_from}", "b/#{copy_to}", index] if copy_from && copy_to
+
+      return ['/dev/null', new_path_from_diff, index] if metadata_value(metadata_lines, 'new file mode ')
+
+      return [old_path_from_diff, '/dev/null', index] if metadata_value(metadata_lines, 'deleted file mode ')
+
+      return [*paths_from_diff_git_line(diff_git_line), index] if diff_git_line
+
+      raise ParseError, 'missing path headers and no diff --git or rename/copy metadata to infer paths'
+    end
+
+    def metadata_line?(line)
+      line.start_with?('index ') ||
+        line.start_with?('old mode ') ||
+        line.start_with?('new mode ') ||
+        line.start_with?('deleted file mode ') ||
+        line.start_with?('new file mode ') ||
+        line.start_with?('similarity index ') ||
+        line.start_with?('rename from ') ||
+        line.start_with?('rename to ') ||
+        line.start_with?('copy from ') ||
+        line.start_with?('copy to ')
+    end
+
+    def path_metadata_lines(metadata_lines)
+      metadata_lines.select do |line|
+        line.start_with?('similarity index ') ||
+          line.start_with?('rename from ') ||
+          line.start_with?('rename to ') ||
+          line.start_with?('copy from ') ||
+          line.start_with?('copy to ')
+      end
+    end
+
+    def mode_metadata_lines(metadata_lines)
+      metadata_lines.select do |line|
+        line.start_with?('old mode ') ||
+          line.start_with?('new mode ')
+      end
+    end
+
+    def nonbinary_operation_lines(metadata_lines)
+      metadata_lines.select do |line|
+        line.start_with?('old mode ') ||
+          line.start_with?('new mode ') ||
+          line.start_with?('similarity index ') ||
+          line.start_with?('rename from ') ||
+          line.start_with?('rename to ') ||
+          line.start_with?('copy from ') ||
+          line.start_with?('copy to ')
+      end
+    end
+
+    def binary_metadata_lines(metadata_lines)
+      metadata_lines.reject do |line|
+        line.start_with?('similarity index ') ||
+          line.start_with?('rename from ') ||
+          line.start_with?('rename to ') ||
+          line.start_with?('copy from ') ||
+          line.start_with?('copy to ')
+      end
+    end
+
+    def build_operation_hunk(old_path:, new_path:, patch_lines:, hunk_index:)
+      label = hunk_label_for(hunk_index)
+      row = Row.new(
+        id: "#{label}:0",
+        kind: :file_operation,
+        text: operation_summary(old_path: old_path, new_path: new_path, patch_lines: patch_lines),
+        old_lineno: nil,
+        new_lineno: nil,
+        change_label: "#{label}1",
+        change_ordinal: 1
+      )
+
+      [
+        Hunk.new(
+          label: label,
+          old_start: 0,
+          old_count: 0,
+          new_start: 0,
+          new_count: 0,
+          section: "file operation #{old_path} -> #{new_path}",
+          rows: [row],
+          kind: :file_operation,
+          patch_lines: patch_lines
+        ),
+        hunk_index + 1
+      ]
+    end
+
+    def build_binary_hunk(lines:, index:, old_path:, new_path:, metadata_lines:, hunk_index:)
+      label = hunk_label_for(hunk_index)
+      payload_lines = []
+
+      while index < lines.length
+        break if lines[index].start_with?('diff --git ')
+
+        payload_lines << lines[index]
+        index += 1
+      end
+
+      patch_lines = metadata_lines + payload_lines
+      row = Row.new(
+        id: "#{label}:0",
+        kind: :binary,
+        text: binary_summary(old_path: old_path, new_path: new_path, patch_lines: patch_lines),
+        old_lineno: nil,
+        new_lineno: nil,
+        change_label: "#{label}1",
+        change_ordinal: 1
+      )
+
+      [
+        Hunk.new(
+          label: label,
+          old_start: 0,
+          old_count: 0,
+          new_start: 0,
+          new_count: 0,
+          section: "binary change #{old_path} -> #{new_path}",
+          rows: [row],
+          kind: :binary,
+          patch_lines: patch_lines
+        ),
+        index,
+        hunk_index + 1
+      ]
+    end
+
+    def parse_text_hunk(lines, start_index, hunk_index)
+      header = lines[start_index]
+      match = HUNK_HEADER.match(header)
+      raise ParseError, "invalid hunk header: #{header}" unless match
+
+      old_start = Integer(match[1], 10)
+      old_count = match[2] ? Integer(match[2], 10) : 1
+      new_start = Integer(match[3], 10)
+      new_count = match[4] ? Integer(match[4], 10) : 1
+      section = match[5]
+
+      rows = []
+      index = start_index + 1
+      old_lineno = old_start
+      new_lineno = new_start
+      change_ordinal = 0
+      row_index = 0
+      hunk_label = hunk_label_for(hunk_index)
+
+      while index < lines.length
+        line = lines[index]
+        break if line.start_with?('@@ ') || line.start_with?('diff --git ') || line.start_with?('--- ')
+        break if metadata_line?(line) || line == 'GIT binary patch' || line.start_with?('Binary files ')
+
+        if line == ''
+          index += 1
+          next
+        end
+
+        prefix = line[0]
+        text = line[1..] || ''
+        row_id = "#{hunk_label}:#{row_index}"
+
+        case prefix
+        when ' '
+          rows << Row.new(
+            id: row_id,
+            kind: :context,
+            text: text,
+            old_lineno: old_lineno,
+            new_lineno: new_lineno,
+            change_label: nil,
+            change_ordinal: nil
+          )
+          old_lineno += 1
+          new_lineno += 1
+        when '-'
+          change_ordinal += 1
+          rows << Row.new(
+            id: row_id,
+            kind: :deletion,
+            text: text,
+            old_lineno: old_lineno,
+            new_lineno: nil,
+            change_label: "#{hunk_label}#{change_ordinal}",
+            change_ordinal: change_ordinal
+          )
+          old_lineno += 1
+        when '+'
+          change_ordinal += 1
+          rows << Row.new(
+            id: row_id,
+            kind: :addition,
+            text: text,
+            old_lineno: nil,
+            new_lineno: new_lineno,
+            change_label: "#{hunk_label}#{change_ordinal}",
+            change_ordinal: change_ordinal
+          )
+          new_lineno += 1
+        else
+          raise ParseError, "unsupported hunk row: #{line}"
+        end
+
+        row_index += 1
+        index += 1
+      end
+
+      [
+        Hunk.new(
+          label: hunk_label,
+          old_start: old_start,
+          old_count: old_count,
+          new_start: new_start,
+          new_count: new_count,
+          section: section,
+          rows: rows,
+          kind: :text,
+          patch_lines: []
+        ),
+        index
+      ]
+    end
+
+    def metadata_value(metadata_lines, prefix)
+      line = metadata_lines.find { |item| item.start_with?(prefix) }
+      return nil unless line
+
+      line.delete_prefix(prefix)
+    end
+
+    def operation_summary(old_path:, new_path:, patch_lines:)
+      old_mode = metadata_value(patch_lines, 'old mode ')
+      new_mode = metadata_value(patch_lines, 'new mode ')
+      rename_from = metadata_value(patch_lines, 'rename from ')
+      copy_from = metadata_value(patch_lines, 'copy from ')
+      similarity = metadata_value(patch_lines, 'similarity index ')
+
+      operation_parts = []
+      if rename_from
+        text = "rename #{display_path(old_path)} -> #{display_path(new_path)}"
+        text += " (#{similarity})" if similarity
+        operation_parts << text
+      elsif copy_from
+        text = "copy #{display_path(old_path)} -> #{display_path(new_path)}"
+        text += " (#{similarity})" if similarity
+        operation_parts << text
+      end
+
+      operation_parts << "mode #{display_path(new_path)} #{old_mode} -> #{new_mode}" if old_mode && new_mode
+
+      return operation_parts.join(', ') if operation_parts.any?
+
+      "file operation #{display_path(old_path)} -> #{display_path(new_path)}"
+    end
+
+    def binary_summary(old_path:, new_path:, patch_lines:)
+      old_mode = metadata_value(patch_lines, 'old mode ')
+      new_mode = metadata_value(patch_lines, 'new mode ')
+
+      summary = if old_path == '/dev/null'
+                  "binary add #{display_path(new_path)}"
+                elsif new_path == '/dev/null'
+                  "binary delete #{display_path(old_path)}"
+                else
+                  "binary #{display_path(new_path)}"
+                end
+      summary += " (mode #{old_mode} -> #{new_mode})" if old_mode && new_mode
+      summary
+    end
+
+    def display_path(path)
+      return path if path == '/dev/null'
+
+      path.sub(%r{\A[ab]/}, '')
+    end
+
+    def paths_from_diff_git_line(diff_git_line)
+      match = /\Adiff --git (\S+) (\S+)\z/.match(diff_git_line.to_s)
+      raise ParseError, 'missing diff --git header needed to infer diff paths' unless match
+
+      [match[1], match[2]]
+    end
+
+    def hunk_label_for(index)
+      current = index
+      label = +''
+
+      loop do
+        label.prepend((97 + (current % 26)).chr)
+        current = (current / 26) - 1
+        break if current.negative?
+      end
+
+      label
+    end
+  end
+end