patch_util 0.1.0

data/lib/patch_util/selection.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module PatchUtil
+  module Selection
+    WholeHunk = Data.define(:hunk_label) do
+      def whole_hunk?
+        true
+      end
+    end
+
+    ChangedLineRange = Data.define(:hunk_label, :start_ordinal, :end_ordinal) do
+      def whole_hunk?
+        false
+      end
+
+      def ordinals
+        (start_ordinal..end_ordinal).to_a
+      end
+    end
+
+    class Parser
+      def parse(selector_text)
+        tokens = selector_text.to_s.split(',').map(&:strip).reject(&:empty?)
+        selectors = []
+
+        tokens.each do |token|
+          selectors.concat(parse_token(token))
+        end
+
+        selectors
+      end
+
+      private
+
+      def parse_token(token)
+        if (match = /\A([a-z]+)(\d+)-([a-z]+)(\d+)\z/.match(token))
+          start_hunk = match[1]
+          finish_hunk = match[3]
+          raise ValidationError, "cross-hunk ranges are not supported: #{token}" unless start_hunk == finish_hunk
+
+          start_ordinal = Integer(match[2], 10)
+          end_ordinal = Integer(match[4], 10)
+          raise ValidationError, "descending selector range: #{token}" if start_ordinal > end_ordinal
+
+          return [ChangedLineRange.new(
+            hunk_label: start_hunk,
+            start_ordinal: start_ordinal,
+            end_ordinal: end_ordinal
+          )]
+        end
+
+        if (match = /\A([a-z]+)(\d+)\z/.match(token))
+          ordinal = Integer(match[2], 10)
+          return [ChangedLineRange.new(hunk_label: match[1], start_ordinal: ordinal, end_ordinal: ordinal)]
+        end
+
+        if (match = /\A([a-z]+)-([a-z]+)\z/.match(token))
+          start_label = match[1]
+          end_label = match[2]
+          start_index = hunk_label_index(start_label)
+          end_index = hunk_label_index(end_label)
+          raise ValidationError, "descending hunk range: #{token}" if start_index > end_index
+
+          return (start_index..end_index).map do |index|
+            WholeHunk.new(hunk_label: hunk_label_for(index))
+          end
+        end
+
+        return [WholeHunk.new(hunk_label: token)] if /\A[a-z]+\z/.match?(token)
+
+        raise ValidationError, "invalid selector token: #{token}"
+      end
+
+      def hunk_label_index(label)
+        value = 0
+
+        label.each_byte do |byte|
+          value = (value * 26) + (byte - 96)
+        end
+
+        value - 1
+      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
+end

data/lib/patch_util/source.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'digest'
+
+module PatchUtil
+  class Source
+    attr_reader :diff_text, :fingerprint, :kind, :label, :path, :repo_path, :commit_sha, :parent_shas
+
+    def self.from_diff_text(diff_text, label: 'stdin')
+      bytes = diff_text.dup.force_encoding(Encoding::BINARY)
+      new(
+        kind: 'raw_diff',
+        label: label,
+        path: nil,
+        diff_text: bytes.dup.force_encoding(Encoding::UTF_8),
+        fingerprint: Digest::SHA256.hexdigest(bytes)
+      )
+    end
+
+    def self.from_patch_file(path)
+      expanded = File.expand_path(path)
+      bytes = File.binread(expanded)
+      new(
+        kind: 'patch_file',
+        label: path,
+        path: expanded,
+        diff_text: bytes.dup.force_encoding(Encoding::UTF_8),
+        fingerprint: Digest::SHA256.hexdigest(bytes)
+      )
+    end
+
+    def self.from_git_commit(repo_path:, revision: 'HEAD', git_cli: PatchUtil::Git::Cli.new)
+      root = git_cli.repo_root(repo_path)
+      sha = git_cli.rev_parse(root, revision)
+      parent_shas = git_cli.parent_shas(root, sha)
+      if parent_shas.length > 1
+        raise ValidationError,
+              "merge commits are not supported yet for inspect/plan/apply: #{sha} has #{parent_shas.length} parents"
+      end
+
+      diff_text = git_cli.show_commit_patch(root, sha)
+      new(
+        kind: 'git_commit',
+        label: "#{root}@#{sha}",
+        path: nil,
+        diff_text: diff_text,
+        fingerprint: sha,
+        repo_path: root,
+        commit_sha: sha,
+        parent_shas: parent_shas
+      )
+    end
+
+    def initialize(kind:, label:, path:, diff_text:, fingerprint:, repo_path: nil, commit_sha: nil, parent_shas: [])
+      @kind = kind
+      @label = label
+      @path = path
+      @diff_text = diff_text
+      @fingerprint = fingerprint
+      @repo_path = repo_path
+      @commit_sha = commit_sha
+      @parent_shas = parent_shas
+    end
+
+    def git?
+      kind.start_with?('git_')
+    end
+  end
+end

data/lib/patch_util/split/applier.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+module PatchUtil
+  module Split
+    class Applier
+      def initialize(emitter: Emitter.new)
+        @emitter = emitter
+      end
+
+      def apply(diff:, plan_entry:, output_dir:)
+        projector = Projector.new(diff: diff, plan_entry: plan_entry)
+        target_dir = File.expand_path(output_dir)
+        FileUtils.mkdir_p(target_dir)
+
+        emitted = []
+        plan_entry.chunks.each_with_index do |chunk, chunk_index|
+          patch_text = @emitter.emit(projector.project_chunk(chunk_index))
+          raise ValidationError, "chunk #{chunk.name} did not produce a patch" if patch_text.empty?
+
+          path = File.join(target_dir, format('%04d-%s.patch', chunk_index + 1, slug(chunk.name)))
+          File.write(path, patch_text)
+          emitted << { name: chunk.name, path: path, patch_text: patch_text }
+        end
+
+        emitted
+      end
+
+      private
+
+      def slug(name)
+        normalized = name.downcase.gsub(/[^a-z0-9]+/, '-').gsub(/\A-|-\z/, '')
+        normalized.empty? ? 'chunk' : normalized
+      end
+    end
+  end
+end

data/lib/patch_util/split/cli.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'thor'
+
+module PatchUtil
+  module Split
+    class CLI < Thor
+      desc 'inspect', 'Display annotated diff lines and any saved plan overlay'
+      option :patch, type: :string, aliases: '-p', banner: 'PATH'
+      option :commit, type: :string, aliases: '-c', banner: 'REV'
+      option :repo, type: :string, aliases: '-r', banner: 'PATH'
+      option :plan, type: :string, aliases: '-P', banner: 'PATH'
+      option :compact, type: :boolean, default: false, banner: 'BOOL'
+      option :expand, type: :string, banner: 'HUNKS'
+      def inspect
+        source = load_source
+        diff = PatchUtil::Parser.new.parse(source)
+        plan_entry = load_plan_entry(source)
+        expand_hunks = parse_expanded_hunks(diff)
+        puts Inspector.new.render(diff: diff,
+                                  plan_entry: plan_entry,
+                                  compact: options[:compact],
+                                  expand_hunks: expand_hunks)
+      end
+
+      desc 'plan [NAME SELECTORS]... [LEFTOVERS_NAME]', 'Persist a split plan'
+      option :patch, type: :string, aliases: '-p', banner: 'PATH'
+      option :commit, type: :string, aliases: '-c', banner: 'REV'
+      option :repo, type: :string, aliases: '-r', banner: 'PATH'
+      option :plan, type: :string, aliases: '-P', banner: 'PATH'
+      def plan(*args)
+        source = load_source
+        diff = PatchUtil::Parser.new.parse(source)
+        chunk_requests = build_chunk_requests(args)
+        plan_entry = Planner.new.build(source: source, diff: diff, chunk_requests: chunk_requests)
+
+        store = PlanStore.new(path: resolve_plan_path(source))
+        plan_set = store.upsert(store.load, plan_entry)
+        store.save(plan_set)
+
+        puts "saved #{plan_entry.chunks.length} chunks to #{store.path}"
+      end
+
+      desc 'apply', 'Emit one patch file per saved chunk'
+      option :patch, type: :string, aliases: '-p', banner: 'PATH'
+      option :commit, type: :string, aliases: '-c', banner: 'REV'
+      option :repo, type: :string, aliases: '-r', banner: 'PATH'
+      option :plan, type: :string, aliases: '-P', banner: 'PATH'
+      option :output_dir, type: :string, aliases: '-o', banner: 'DIR'
+      option :rewrite, type: :boolean, default: false, banner: 'BOOL'
+      def apply
+        source = load_source
+        diff = PatchUtil::Parser.new.parse(source)
+        plan_entry = load_plan_entry(source)
+        raise ValidationError, "no saved plan matches #{source.label}" unless plan_entry
+
+        if options[:rewrite]
+          raise ValidationError, '--rewrite is only supported for git commit sources' unless source.git?
+
+          result = PatchUtil::Git::Rewriter.new.rewrite(source: source, diff: diff, plan_entry: plan_entry)
+          puts "rewrote #{result.branch}: #{result.old_head} -> #{result.new_head}"
+          puts "backup ref: #{result.backup_ref}"
+          result.commits.each { |name| puts "created #{name}" }
+        else
+          raise ValidationError, '--output-dir is required unless --rewrite is used' unless options[:output_dir]
+
+          emitted = Applier.new.apply(diff: diff, plan_entry: plan_entry, output_dir: options[:output_dir])
+          emitted.each do |item|
+            puts "#{item[:name]} -> #{item[:path]}"
+          end
+        end
+      end
+
+      no_commands do
+        def load_source
+          validate_source_options!
+
+          if options[:patch]
+            PatchUtil::Source.from_patch_file(options[:patch])
+          else
+            PatchUtil::Source.from_git_commit(repo_path: options[:repo] || Dir.pwd,
+                                              revision: options[:commit] || 'HEAD')
+          end
+        end
+
+        def build_chunk_requests(args)
+          raise ValidationError, 'plan requires at least one chunk name and selector' if args.empty?
+
+          requests = []
+          pairable_count = args.length.even? ? args.length : args.length - 1
+          index = 0
+
+          while index < pairable_count
+            name = args[index]
+            selector_text = args[index + 1]
+            raise ValidationError, "missing selector for chunk #{name}" if selector_text.nil?
+
+            requests << ChunkRequest.new(name: name, selector_text: selector_text, leftovers: false)
+            index += 2
+          end
+
+          requests << ChunkRequest.new(name: args[-1], selector_text: nil, leftovers: true) if args.length.odd?
+
+          requests
+        end
+
+        def parse_expanded_hunks(diff)
+          selector_text = options[:expand]
+          return [] unless selector_text
+
+          raise ValidationError, '--expand requires --compact' unless options[:compact]
+
+          selectors = PatchUtil::Selection::Parser.new.parse(selector_text)
+          raise ValidationError, '--expand requires at least one hunk label' if selectors.empty?
+
+          labels = []
+          selectors.each do |selector|
+            unless selector.whole_hunk?
+              raise ValidationError,
+                    '--expand only accepts whole-hunk labels or hunk ranges (for example: a,b,c or a-c)'
+            end
+
+            unless diff.hunk_by_label(selector.hunk_label)
+              raise ValidationError,
+                    "unknown hunk label for --expand: #{selector.hunk_label}"
+            end
+
+            labels << selector.hunk_label
+          end
+
+          labels.uniq
+        end
+
+        def load_plan_entry(source)
+          store = PlanStore.new(path: resolve_plan_path(source))
+          store.load.find_entry(source)
+        end
+
+        def resolve_plan_path(source)
+          return File.expand_path(options[:plan]) if options[:plan]
+
+          if source.git?
+            git_dir = PatchUtil::Git::Cli.new.git_dir(source.repo_path)
+            return File.join(git_dir, 'patch_util', 'plans.json')
+          end
+
+          raise ValidationError, "--plan is required for #{source.kind} sources outside a git repository"
+        end
+
+        def validate_source_options!
+          if options[:patch] && (options[:commit] || options[:repo])
+            raise ValidationError, 'use either --patch or --commit/--repo source options, not both'
+          end
+
+          raise ValidationError, '--repo requires --commit when used explicitly' if options[:repo] && !options[:commit]
+
+          return if options[:patch]
+          return if options[:commit]
+          return if PatchUtil::Git::Cli.new.inside_repo?(options[:repo] || Dir.pwd)
+
+          raise ValidationError, 'provide --patch, or run inside a git repository, or pass --commit with --repo'
+        end
+      end
+    end
+  end
+end

data/lib/patch_util/split/emitter.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module PatchUtil
+  module Split
+    class Emitter
+      def emit(projected_files)
+        lines = []
+
+        projected_files.each do |file_patch|
+          lines << file_patch.diff_git_line if file_patch.diff_git_line
+          lines.concat(file_patch.metadata_lines)
+          if file_patch.emit_text_headers
+            lines << "--- #{format_old_path(file_patch.old_path)}"
+            lines << "+++ #{format_new_path(file_patch.new_path)}"
+          end
+
+          file_patch.hunks.each do |hunk|
+            if hunk.kind == :text
+              lines << "@@ -#{format_range(hunk.old_start,
+                                           hunk.old_count)} +#{format_range(hunk.new_start, hunk.new_count)} @@"
+              lines.concat(hunk.lines)
+            else
+              lines.concat(hunk.patch_lines)
+            end
+          end
+        end
+
+        return '' if lines.empty?
+
+        lines.join("\n") + "\n"
+      end
+
+      private
+
+      def format_range(start, count)
+        "#{start},#{count}"
+      end
+
+      def format_old_path(path)
+        return '/dev/null' if path == '/dev/null'
+
+        "a/#{path.sub(%r{\A[ab]/}, '')}"
+      end
+
+      def format_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/inspector.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+module PatchUtil
+  module Split
+    class Inspector
+      COLUMN_WIDTH = 28
+
+      def render(diff:, plan_entry: nil, compact: false, expand_hunks: [])
+        assignments = assignment_map(plan_entry)
+        return render_compact(diff, assignments, expand_hunks) if compact
+
+        render_full(diff, assignments)
+      end
+
+      private
+
+      def render_full(diff, assignments)
+        lines = []
+
+        diff.file_diffs.each do |file_diff|
+          lines << "--- #{file_diff.old_path}"
+          lines << "+++ #{file_diff.new_path}"
+
+          file_diff.hunks.each do |hunk|
+            lines << "@@ -#{hunk.old_start},#{hunk.old_count} +#{hunk.new_start},#{hunk.new_count} @@"
+            hunk.rows.each do |row|
+              if row.change?
+                label = row.change_label
+                chunk_name = assignments[row.id]
+                marker = chunk_name ? "#{label} [#{chunk_name}]" : label
+                lines << format("%-#{COLUMN_WIDTH}s %s%s", marker, row.display_prefix, row.text)
+              else
+                lines << format("%-#{COLUMN_WIDTH}s %s%s", '', row.display_prefix, row.text)
+              end
+            end
+          end
+        end
+
+        lines.join("\n") + "\n"
+      end
+
+      def render_compact(diff, assignments, expand_hunks)
+        lines = []
+        expanded_labels = expand_hunks.to_set
+
+        lines << '== Compact Inspect =='
+        lines << 'legend: text=unified hunk, operation=rename/copy/mode metadata, binary=git binary payload'
+        lines << 'label spans show selectable changed-line ranges with optional [chunk name] overlay'
+        lines << "expanded hunks: #{expanded_labels.to_a.join(', ')}" unless expanded_labels.empty?
+        lines << ''
+        lines << '== File Index =='
+
+        diff.file_diffs.each do |file_diff|
+          lines << compact_file_index_line(file_diff, assignments)
+        end
+
+        lines << ''
+        lines << '== Details =='
+
+        diff.file_diffs.each do |file_diff|
+          lines << "--- #{file_diff.old_path}"
+          lines << "+++ #{file_diff.new_path}"
+
+          file_diff.hunks.each do |hunk|
+            if expanded_labels.include?(hunk.label)
+              lines.concat(full_hunk_lines(hunk, assignments))
+            else
+              lines << compact_hunk_line(hunk, assignments)
+            end
+          end
+        end
+
+        lines.join("\n") + "\n"
+      end
+
+      def compact_file_index_line(file_diff, assignments)
+        path = compact_file_path(file_diff)
+        hunks = compact_index_hunks(file_diff).map { |hunk| compact_file_index_hunk(hunk, assignments) }
+        change_count = 0
+        file_diff.hunks.each do |hunk|
+          change_count += hunk.change_rows.length
+        end
+
+        "#{path} (#{count_label(file_diff.hunks.length,
+                                'hunk')}, #{count_label(change_count, 'change')}): #{hunks.join('; ')}"
+      end
+
+      def compact_file_path(file_diff)
+        return file_diff.new_path if file_diff.addition?
+        return file_diff.old_path if file_diff.deletion?
+
+        file_diff.new_path
+      end
+
+      def compact_index_hunks(file_diff)
+        indexed = []
+        file_diff.hunks.each_with_index do |hunk, index|
+          indexed << [hunk, index]
+        end
+
+        indexed.sort_by { |hunk, index| [-hunk.change_rows.length, index] }.map(&:first)
+      end
+
+      def compact_file_index_hunk(hunk, assignments)
+        summary = compact_change_segments(hunk.change_rows, assignments)
+        "#{hunk.label}(#{compact_kind(hunk)}, #{count_label(hunk.change_rows.length, 'change')}: #{summary})"
+      end
+
+      def compact_hunk_line(hunk, assignments)
+        if hunk.text?
+          "#{hunk.label} text @@ -#{hunk.old_start},#{hunk.old_count} +#{hunk.new_start},#{hunk.new_count} @@: " \
+            "#{compact_change_segments(hunk.change_rows, assignments)}"
+        else
+          row = hunk.change_rows.first
+          "#{hunk.label} #{compact_kind(hunk)}: #{compact_change_segments([row],
+                                                                          assignments)} #{row.display_prefix}#{row.text}"
+        end
+      end
+
+      def full_hunk_lines(hunk, assignments)
+        lines = []
+        lines << "#{compact_hunk_line(hunk, assignments)} [expanded]"
+
+        lines << "@@ -#{hunk.old_start},#{hunk.old_count} +#{hunk.new_start},#{hunk.new_count} @@" if hunk.text?
+
+        hunk.rows.each do |row|
+          if row.change?
+            label = row.change_label
+            chunk_name = assignments[row.id]
+            marker = chunk_name ? "#{label} [#{chunk_name}]" : label
+            lines << format("%-#{COLUMN_WIDTH}s %s%s", marker, row.display_prefix, row.text)
+          else
+            lines << format("%-#{COLUMN_WIDTH}s %s%s", '', row.display_prefix, row.text)
+          end
+        end
+
+        lines
+      end
+
+      def compact_change_segments(rows, assignments)
+        segments = []
+        range_start = nil
+        range_end = nil
+        current_chunk_name = nil
+
+        rows.each do |row|
+          chunk_name = assignments[row.id]
+
+          if range_start && contiguous_segment?(range_end, row) && current_chunk_name == chunk_name
+            range_end = row
+            next
+          end
+
+          segments << compact_segment_label(range_start, range_end, current_chunk_name) if range_start
+          range_start = row
+          range_end = row
+          current_chunk_name = chunk_name
+        end
+
+        segments << compact_segment_label(range_start, range_end, current_chunk_name) if range_start
+        segments.join(', ')
+      end
+
+      def compact_segment_label(range_start, range_end, chunk_name)
+        marker = if range_start.change_label == range_end.change_label
+                   range_start.change_label
+                 else
+                   "#{range_start.change_label}-#{range_end.change_label}"
+                 end
+        chunk_name ? "#{marker} [#{chunk_name}]" : marker
+      end
+
+      def contiguous_segment?(left, right)
+        left.change_ordinal + 1 == right.change_ordinal
+      end
+
+      def compact_kind(hunk)
+        return 'text' if hunk.text?
+        return 'operation' if hunk.operation?
+        return 'binary' if hunk.binary?
+
+        raise PatchUtil::UnsupportedFeatureError, "unknown hunk kind: #{hunk.kind.inspect}"
+      end
+
+      def count_label(count, singular)
+        noun = count == 1 ? singular : "#{singular}s"
+        "#{count} #{noun}"
+      end
+
+      def assignment_map(plan_entry)
+        return {} unless plan_entry
+
+        map = {}
+        plan_entry.chunks.each do |chunk|
+          chunk.row_ids.each do |row_id|
+            map[row_id] = chunk.name
+          end
+        end
+        map
+      end
+    end
+  end
+end

data/lib/patch_util/split/plan.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module PatchUtil
+  module Split
+    ChunkRequest = Data.define(:name, :selector_text, :leftovers) do
+      def leftovers?
+        leftovers
+      end
+    end
+
+    Chunk = Data.define(:name, :selector_text, :row_ids, :change_labels, :leftovers) do
+      def leftovers?
+        leftovers
+      end
+    end
+
+    PlanEntry = Data.define(:source_kind, :source_label, :source_fingerprint, :chunks, :created_at) do
+      def matches_source?(source)
+        source_kind == source.kind && source_fingerprint == source.fingerprint
+      end
+
+      def chunk_for_row_id(row_id)
+        chunks.find { |chunk| chunk.row_ids.include?(row_id) }
+      end
+    end
+
+    PlanSet = Data.define(:version, :entries) do
+      def find_entry(source)
+        entries.find { |entry| entry.matches_source?(source) }
+      end
+    end
+  end
+end