patch_util 0.1.0

data/lib/patch_util/split/plan_store.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'json'
+
+module PatchUtil
+  module Split
+    class PlanStore
+      FORMAT_VERSION = 1
+
+      attr_reader :path
+
+      def initialize(path:)
+        @path = File.expand_path(path)
+      end
+
+      def load
+        return PlanSet.new(version: FORMAT_VERSION, entries: []) unless File.exist?(path)
+
+        payload = JSON.parse(File.read(path))
+        entries = []
+        payload.fetch('entries', []).each do |entry|
+          entries << deserialize_entry(entry)
+        end
+        PlanSet.new(version: payload.fetch('version', FORMAT_VERSION), entries: entries)
+      end
+
+      def save(plan_set)
+        FileUtils.mkdir_p(File.dirname(path))
+        File.write(path, JSON.pretty_generate(serialize_plan_set(plan_set)) + "\n")
+      end
+
+      def upsert(plan_set, entry)
+        entries = []
+        replaced = false
+
+        plan_set.entries.each do |existing|
+          if existing.source_kind == entry.source_kind && existing.source_fingerprint == entry.source_fingerprint
+            entries << entry
+            replaced = true
+          else
+            entries << existing
+          end
+        end
+
+        entries << entry unless replaced
+        PlanSet.new(version: FORMAT_VERSION, entries: entries)
+      end
+
+      private
+
+      def serialize_plan_set(plan_set)
+        entries = []
+        plan_set.entries.each do |entry|
+          entries << {
+            'source_kind' => entry.source_kind,
+            'source_label' => entry.source_label,
+            'source_fingerprint' => entry.source_fingerprint,
+            'created_at' => entry.created_at,
+            'chunks' => serialize_chunks(entry.chunks)
+          }
+        end
+
+        {
+          'version' => plan_set.version,
+          'entries' => entries
+        }
+      end
+
+      def serialize_chunks(chunks)
+        items = []
+        chunks.each do |chunk|
+          items << {
+            'name' => chunk.name,
+            'selector_text' => chunk.selector_text,
+            'row_ids' => chunk.row_ids,
+            'change_labels' => chunk.change_labels,
+            'leftovers' => chunk.leftovers?
+          }
+        end
+        items
+      end
+
+      def deserialize_entry(entry)
+        chunks = []
+        entry.fetch('chunks', []).each do |chunk|
+          chunks << Chunk.new(
+            name: chunk.fetch('name'),
+            selector_text: chunk['selector_text'],
+            row_ids: chunk.fetch('row_ids'),
+            change_labels: chunk.fetch('change_labels'),
+            leftovers: chunk.fetch('leftovers', false)
+          )
+        end
+
+        PlanEntry.new(
+          source_kind: entry.fetch('source_kind'),
+          source_label: entry.fetch('source_label'),
+          source_fingerprint: entry.fetch('source_fingerprint'),
+          chunks: chunks,
+          created_at: entry.fetch('created_at')
+        )
+      end
+    end
+  end
+end

data/lib/patch_util/split/planner.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'time'
+
+module PatchUtil
+  module Split
+    class Planner
+      def initialize(verifier: Verifier.new)
+        @verifier = verifier
+      end
+
+      def build(source:, diff:, chunk_requests:)
+        chunks = @verifier.build_chunks(diff: diff, chunk_requests: chunk_requests)
+        PlanEntry.new(
+          source_kind: source.kind,
+          source_label: source.label,
+          source_fingerprint: source.fingerprint,
+          chunks: chunks,
+          created_at: Time.now.utc.iso8601
+        )
+      end
+    end
+  end
+end

data/lib/patch_util/split/projector.rb

@@ -0,0 +1,252 @@
+# frozen_string_literal: true
+
+module PatchUtil
+  module Split
+    ProjectedFile = Data.define(:old_path, :new_path, :diff_git_line, :metadata_lines, :hunks, :emit_text_headers)
+    ProjectedHunk = Data.define(:old_start, :old_count, :new_start, :new_count, :lines, :kind, :patch_lines)
+
+    class Projector
+      def initialize(diff:, plan_entry:)
+        @diff = diff
+        @plan_entry = plan_entry
+        @chunk_index_by_row_id = {}
+
+        @plan_entry.chunks.each_with_index do |chunk, chunk_index|
+          chunk.row_ids.each do |row_id|
+            @chunk_index_by_row_id[row_id] = chunk_index
+          end
+        end
+      end
+
+      def project_chunk(chunk_index)
+        projected_files = []
+
+        @diff.file_diffs.each do |file_diff|
+          before_offset = 0
+          after_offset = 0
+          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_diff.hunks.each do |hunk|
+            case hunk.kind
+            when :file_operation
+              projected_hunk = project_operation_hunk(hunk, chunk_index)
+              projected_hunks << projected_hunk if projected_hunk
+            when :binary
+              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)
+              projected_hunks << projected_hunk if changed
+
+              before_offset += applied_delta(hunk, max_chunk_index: chunk_index - 1)
+              after_offset += applied_delta(hunk, max_chunk_index: chunk_index)
+            end
+          end
+
+          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)
+          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]),
+            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)
+          )
+        end
+
+        projected_files
+      end
+
+      private
+
+      def project_operation_hunk(hunk, chunk_index)
+        return nil unless rows_assigned_to_chunk?(hunk, chunk_index)
+
+        ProjectedHunk.new(
+          old_start: 0,
+          old_count: 0,
+          new_start: 0,
+          new_count: 0,
+          lines: [],
+          kind: :file_operation,
+          patch_lines: hunk.patch_lines
+        )
+      end
+
+      def project_binary_hunk(hunk, chunk_index)
+        return nil unless rows_assigned_to_chunk?(hunk, chunk_index)
+
+        ProjectedHunk.new(
+          old_start: 0,
+          old_count: 0,
+          new_start: 0,
+          new_count: 0,
+          lines: [],
+          kind: :binary,
+          patch_lines: hunk.patch_lines
+        )
+      end
+
+      def project_text_hunk(hunk, chunk_index, before_offset, after_offset)
+        lines = []
+        changed = false
+        old_count = 0
+        new_count = 0
+
+        hunk.rows.each do |row|
+          visible_before = visible_in_before?(row, chunk_index)
+          visible_after = visible_in_after?(row, chunk_index)
+          changed ||= visible_before != visible_after
+
+          old_count += 1 if visible_before
+          new_count += 1 if visible_after
+          next unless visible_before || visible_after
+
+          prefix = if visible_before && visible_after
+                     ' '
+                   elsif visible_before
+                     '-'
+                   else
+                     '+'
+                   end
+          lines << "#{prefix}#{row.text}"
+        end
+
+        [
+          changed,
+          ProjectedHunk.new(
+            old_start: hunk.old_start + before_offset,
+            old_count: old_count,
+            new_start: hunk.new_start + after_offset,
+            new_count: new_count,
+            lines: lines,
+            kind: :text,
+            patch_lines: []
+          )
+        ]
+      end
+
+      def rows_assigned_to_chunk?(hunk, chunk_index)
+        hunk.change_rows.all? { |row| @chunk_index_by_row_id.fetch(row.id) == chunk_index }
+      end
+
+      def applied_delta(hunk, max_chunk_index:)
+        return 0 if max_chunk_index.negative?
+
+        delta = 0
+        hunk.change_rows.each do |row|
+          chunk_index = @chunk_index_by_row_id.fetch(row.id)
+          next if chunk_index > max_chunk_index
+
+          delta += 1 if row.kind == :addition
+          delta -= 1 if row.kind == :deletion
+        end
+        delta
+      end
+
+      def visible_in_before?(row, chunk_index)
+        case row.kind
+        when :context
+          true
+        when :deletion
+          @chunk_index_by_row_id.fetch(row.id) >= chunk_index
+        when :addition
+          @chunk_index_by_row_id.fetch(row.id) < chunk_index
+        else
+          false
+        end
+      end
+
+      def visible_in_after?(row, chunk_index)
+        case row.kind
+        when :context
+          true
+        when :deletion
+          @chunk_index_by_row_id.fetch(row.id) > chunk_index
+        when :addition
+          @chunk_index_by_row_id.fetch(row.id) <= chunk_index
+        else
+          false
+        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)
+                       elsif new_path == '/dev/null'
+                         to_git_old_path(old_path)
+                       else
+                         to_git_old_path(old_path)
+                       end
+        new_git_path = if new_path == '/dev/null'
+                         to_git_new_path(old_path)
+                       elsif old_path == '/dev/null'
+                         to_git_new_path(new_path)
+                       else
+                         to_git_new_path(new_path)
+                       end
+
+        "diff --git #{old_git_path} #{new_git_path}"
+      end
+
+      def path_operation_applied_before?(file_diff, chunk_index)
+        return false if chunk_index.zero?
+
+        path_operation_applied_after?(file_diff, chunk_index - 1)
+      end
+
+      def path_operation_applied_after?(file_diff, chunk_index)
+        operation_hunk = file_diff.path_operation_hunk
+        return false unless operation_hunk
+
+        operation_hunk.change_rows.all? do |row|
+          @chunk_index_by_row_id.fetch(row.id) <= chunk_index
+        end
+      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)
+        return metadata_lines unless file_diff.addition? || file_diff.deletion?
+
+        file_diff.metadata_lines.select do |line|
+          line.start_with?('new file mode ') || line.start_with?('deleted file mode ')
+        end
+      end
+
+      def to_git_old_path(path)
+        return '/dev/null' if path == '/dev/null'
+
+        "a/#{path.sub(%r{\A[ab]/}, '')}"
+      end
+
+      def to_git_new_path(path)
+        return '/dev/null' if path == '/dev/null'
+
+        "b/#{path.sub(%r{\A[ab]/}, '')}"
+      end
+    end
+  end
+end

data/lib/patch_util/split/verifier.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module PatchUtil
+  module Split
+    class Verifier
+      def initialize(selector_parser: PatchUtil::Selection::Parser.new)
+        @selector_parser = selector_parser
+      end
+
+      def build_chunks(diff:, chunk_requests:)
+        chunks = []
+        assigned_row_ids = {}
+        leftovers_request = nil
+
+        chunk_requests.each do |request|
+          if request.leftovers?
+            raise ValidationError, 'leftovers chunk can only be declared once' if leftovers_request
+
+            leftovers_request = request
+            next
+          end
+
+          selectors = @selector_parser.parse(request.selector_text)
+          row_ids, change_labels = resolve_selectors(diff, selectors)
+
+          row_ids.each do |row_id|
+            existing = assigned_row_ids[row_id]
+            next unless existing
+
+            label = diff.row_by_id(row_id)&.change_label || row_id
+            raise ValidationError, "#{label} is assigned to both #{existing} and #{request.name}"
+          end
+
+          row_ids.each { |row_id| assigned_row_ids[row_id] = request.name }
+
+          chunks << Chunk.new(
+            name: request.name,
+            selector_text: request.selector_text,
+            row_ids: row_ids,
+            change_labels: change_labels,
+            leftovers: false
+          )
+        end
+
+        leftovers = []
+        diff.change_rows.each do |row|
+          leftovers << row unless assigned_row_ids.key?(row.id)
+        end
+
+        if leftovers.any?
+          unless leftovers_request
+            raise ValidationError,
+                  "#{leftovers.length} lines will be removed; re-plan with a leftovers commit if you do not intend removal"
+          end
+
+          row_ids = leftovers.map(&:id)
+          change_labels = leftovers.map(&:change_label)
+          chunks << Chunk.new(
+            name: leftovers_request.name,
+            selector_text: nil,
+            row_ids: row_ids,
+            change_labels: change_labels,
+            leftovers: true
+          )
+        elsif leftovers_request
+          chunks << Chunk.new(
+            name: leftovers_request.name,
+            selector_text: nil,
+            row_ids: [],
+            change_labels: [],
+            leftovers: true
+          )
+        end
+
+        chunks
+      end
+
+      private
+
+      def resolve_selectors(diff, selectors)
+        whole_hunks = {}
+        partial_hunks = {}
+
+        selectors.each do |selector|
+          if selector.whole_hunk?
+            whole_hunks[selector.hunk_label] = true
+          else
+            partial_hunks[selector.hunk_label] = true
+          end
+        end
+
+        whole_hunks.each_key do |hunk_label|
+          next unless partial_hunks[hunk_label]
+
+          raise ValidationError, "cannot select both whole hunk #{hunk_label} and partial changed lines from it"
+        end
+
+        selected_row_ids = []
+        selected_change_labels = []
+        seen_row_ids = {}
+
+        selectors.each do |selector|
+          rows = rows_for_selector(diff, selector)
+          rows.each do |row|
+            raise ValidationError, "#{row.change_label} is selected more than once" if seen_row_ids[row.id]
+
+            seen_row_ids[row.id] = true
+            selected_row_ids << row.id
+            selected_change_labels << row.change_label
+          end
+        end
+
+        [selected_row_ids, selected_change_labels]
+      end
+
+      def rows_for_selector(diff, selector)
+        hunk = diff.hunk_by_label(selector.hunk_label)
+        raise ValidationError, "unknown hunk label: #{selector.hunk_label}" unless hunk
+
+        return hunk.change_rows if selector.whole_hunk?
+
+        rows = []
+        selector.ordinals.each do |ordinal|
+          row = hunk.change_rows.find { |candidate| candidate.change_ordinal == ordinal }
+          raise ValidationError, "unknown changed line #{selector.hunk_label}#{ordinal}" unless row
+
+          rows << row
+        end
+        rows
+      end
+    end
+  end
+end

data/lib/patch_util/split.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module PatchUtil
+  module Split
+    autoload :Plan, 'patch_util/split/plan'
+    autoload :ChunkRequest, 'patch_util/split/plan'
+    autoload :Chunk, 'patch_util/split/plan'
+    autoload :PlanEntry, 'patch_util/split/plan'
+    autoload :PlanSet, 'patch_util/split/plan'
+    autoload :PlanStore, 'patch_util/split/plan_store'
+    autoload :Verifier, 'patch_util/split/verifier'
+    autoload :Planner, 'patch_util/split/planner'
+    autoload :ProjectedFile, 'patch_util/split/projector'
+    autoload :ProjectedHunk, 'patch_util/split/projector'
+    autoload :Projector, 'patch_util/split/projector'
+    autoload :Emitter, 'patch_util/split/emitter'
+    autoload :Applier, 'patch_util/split/applier'
+    autoload :Inspector, 'patch_util/split/inspector'
+    autoload :CLI, 'patch_util/split/cli'
+  end
+end

data/lib/patch_util/version.rb

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

data/lib/patch_util.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module PatchUtil
+  autoload :VERSION, 'patch_util/version'
+  class Error < StandardError; end
+  class ParseError < Error; end
+  class ValidationError < Error; end
+  class UnsupportedFeatureError < Error; end
+
+  autoload :Git, 'patch_util/git'
+  autoload :Source, 'patch_util/source'
+  autoload :Diff, 'patch_util/diff'
+  autoload :FileDiff, 'patch_util/diff'
+  autoload :Hunk, 'patch_util/diff'
+  autoload :Row, 'patch_util/diff'
+  autoload :ChangeLine, 'patch_util/diff'
+  autoload :Parser, 'patch_util/parser'
+  autoload :Selection, 'patch_util/selection'
+  autoload :Split, 'patch_util/split'
+  autoload :CLI, 'patch_util/cli'
+end

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification
+name: patch_util
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- hmdne
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+description: Patch planning and materialization helpers for splitting one unified
+  diff into multiple reviewable patches.
+email:
+- 54514036+hmdne@users.noreply.github.com
+executables:
+- patch_util
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- SKILL.md
+- exe/patch_util
+- lib/patch_util.rb
+- lib/patch_util/cli.rb
+- lib/patch_util/diff.rb
+- lib/patch_util/git.rb
+- lib/patch_util/git/cli.rb
+- lib/patch_util/git/rewrite_cli.rb
+- lib/patch_util/git/rewrite_session_manager.rb
+- lib/patch_util/git/rewrite_state_store.rb
+- lib/patch_util/git/rewriter.rb
+- lib/patch_util/parser.rb
+- lib/patch_util/selection.rb
+- lib/patch_util/source.rb
+- lib/patch_util/split.rb
+- lib/patch_util/split/applier.rb
+- lib/patch_util/split/cli.rb
+- lib/patch_util/split/emitter.rb
+- lib/patch_util/split/inspector.rb
+- lib/patch_util/split/plan.rb
+- lib/patch_util/split/plan_store.rb
+- lib/patch_util/split/planner.rb
+- lib/patch_util/split/projector.rb
+- lib/patch_util/split/verifier.rb
+- lib/patch_util/version.rb
+homepage: https://github.com/rbutils/patch_util
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  source_code_uri: https://github.com/rbutils/patch_util
+  changelog_uri: https://github.com/rbutils/patch_util/blob/master/CHANGELOG.md
+  documentation_uri: https://github.com/rbutils/patch_util#readme
+  bug_tracker_uri: https://github.com/rbutils/patch_util/issues
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.6
+specification_version: 4
+summary: Split unified diffs into smaller ordered patches
+test_files: []