porrima 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a343ef7bf35f119ee70c360d6fb3f4d69e20e052911cbd8f449ea87964b40284
+  data.tar.gz: fabc56760d330596512fa8481359dcc364a7793af4e8984e98a920b230c6b052
+SHA512:
+  metadata.gz: 48f5568c01680dab34f4633161d19d3e34486e2b8e7299ddf31eb40765fabe57f7ea796c73b11a39686bc3237a4c52d70c83422f842c98f94aefe90b681c66d6
+  data.tar.gz: 46430b633bdc526768d2f186d2f73d6030a7d764a97c65692033246204441ead795faacb391bdd24652de5231cd659d63a617aa03b65b5a8e38fb4a142733637

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Changelog
+
+## 0.1.0 — 2026-09-12
+
+- Initial release.

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Yudai Takada
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,101 @@
+# Porrima
+
+[![Gem version](https://img.shields.io/gem/v/porrima.svg)](https://rubygems.org/gems/porrima)
+[![CI](https://github.com/noxdea/porrima/actions/workflows/main.yml/badge.svg)](https://github.com/noxdea/porrima/actions/workflows/main.yml)
+[![CRuby 3.1+](https://img.shields.io/badge/CRuby-%3E%3D%203.1-cc342d.svg)](porrima.gemspec)
+[![MIT license](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE.txt)
+
+Line, word, and three-way diff, patch, and merge in pure Ruby.
+
+## Scope
+
+Porrima computes from two or three texts. Its core never reads files, knows
+nothing about Git, and has no runtime dependencies. Color, width, truncation,
+caching, and other display policy belong to the caller. The CLI only connects
+files to the library's interoperable formats.
+
+## Installation
+
+```sh
+gem install porrima
+```
+
+## Quick start
+
+```ruby
+require "porrima"
+
+result = Porrima.diff("one\ntwo\n", "one\nchanged\n", context: 1)
+result.hunks
+result.stat.to_h # => {insertions: 1, deletions: 1, hunks: 1}
+result.marks
+result.rows
+result.to_unified(old_name: "a/example", new_name: "b/example")
+
+old_spans, new_spans = Porrima::Inline.refine("hello old", "hello new")
+patch = Porrima::Patch.parse(result.to_unified).first
+patch.apply("one\ntwo\n")
+
+merge = Porrima::Merge.three_way(base: "old\n", ours: "ours\n", theirs: "theirs\n")
+Porrima::Merge.to_text(merge, style: :diff3)
+```
+
+`Porrima.edits`, `.hunks`, `.unified`, `.apply`, and `.revert` are available
+as lower-level entry points. `Porrima::Budget` can replace an oversized input
+as one block or raise `Porrima::BudgetExceeded`.
+
+## Data model
+
+- `Edit` is an equal, deleted, or inserted line with old and new positions.
+- `Hunk` groups edits and exposes its exact old and new text.
+- `Mark` locates an added, modified, or removed block on the new side.
+- `Row` pairs old and new lines without presentation policy.
+- `Span` describes equal, deleted, or inserted inline text.
+- `Merge::Result` contains plain sections and structured conflicts; markers are
+  only produced by `Merge.to_text`.
+
+`Diff` snapshots its inputs and lazily memoizes these collections. Finish the
+fields needed by another thread on the producing thread before handing the
+instance across.
+
+## CLI
+
+```text
+porrima [diff] [options] OLD NEW
+porrima merge [options] BASE OURS THEIRS
+porrima apply [options] PATCH [FILE]
+```
+
+Diff supports unified output, `--json`, `--quiet`, and `--max-bytes`. Merge
+supports structured JSON or `diff3`/`merge` markers. Apply supports
+`--reverse` and validation-only `--check`. Exit status is 0 for no
+diff/conflict, 1 for a diff/conflict, and 2 for an error.
+
+## Compatibility
+
+Porrima requires CRuby 3.1 or newer. The line edit, hunk, unified output, and
+revert behavior are byte-compatible with the original Canopus diff engine.
+Public struct field names and order are part of the 0.1 contract.
+
+## Development
+
+```sh
+bundle install
+bundle exec rake
+ruby tools/check_isolation.rb
+bundle exec rbs -I sig validate
+bundle exec rake bench:assert
+gem build --strict porrima.gemspec
+```
+
+## Limits
+
+- Comparison uses `String#==`; callers own encoding normalization.
+- Patch application is exact and intentionally has no fuzz matching.
+- Inline refinement treats over 2,000 combined tokens as a whole-text replacement.
+- `Diff` memoization is not synchronized; complete it before cross-thread use.
+- During 0.x releases, minor versions may contain breaking changes.
+
+## License
+
+Porrima is released under the [MIT License](LICENSE.txt).

data/exe/porrima

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "rbconfig"
+require "rubygems"
+unless RUBY_ENGINE == "ruby" && (RUBY_VERSION.split(".").first(2).map(&:to_i) <=> [3, 1]) >= 0
+  abort "Porrima requires CRuby 3.1 or newer."
+end
+$LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
+require "porrima"
+require "porrima/cli"
+exit Porrima::CLI.main(ARGV)

data/lib/porrima/budget.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Porrima
+  class Budget
+    attr_reader :max_bytes, :max_lines, :on_exceeded
+
+    def initialize(max_bytes: nil, max_lines: nil, on_exceeded: :replace)
+      raise ArgumentError, "max_bytes must be nonnegative" unless max_bytes.nil? || max_bytes.is_a?(Integer) && max_bytes >= 0
+      raise ArgumentError, "max_lines must be nonnegative" unless max_lines.nil? || max_lines.is_a?(Integer) && max_lines >= 0
+      raise ArgumentError, "on_exceeded must be :replace or :raise" unless %i[replace raise].include?(on_exceeded)
+      @max_bytes, @max_lines, @on_exceeded = max_bytes, max_lines, on_exceeded
+      freeze
+    end
+
+    def exceeded?(before, after)
+      exceeded = max_lines && before.length + after.length > max_lines
+      exceeded ||= max_bytes && before.sum(&:bytesize) + after.sum(&:bytesize) > max_bytes
+      return false unless exceeded
+      raise BudgetExceeded, "diff budget exceeded" if on_exceeded == :raise
+      true
+    end
+
+    NONE = new
+  end
+end

data/lib/porrima/cli.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require "json"
+require "optparse"
+require "tempfile"
+require "fileutils"
+
+module Porrima
+  module CLI
+    MAX_BYTES = 10 * 1024 * 1024
+    module_function
+
+    def main(argv, output: $stdout, error: $stderr)
+      arguments = argv.dup
+      command = %w[diff merge apply].include?(arguments.first) ? arguments.shift : "diff"
+      send("run_#{command}", arguments, output)
+    rescue OptionParser::ParseError, StandardError => exception
+      error.puts "porrima: #{exception.message}"
+      2
+    end
+
+    def run_diff(arguments, output)
+      options = {context: 3, json: false, quiet: false, max_bytes: MAX_BYTES}
+      parser = OptionParser.new do |command|
+        command.banner = "Usage: porrima [diff] [options] OLD NEW"
+        command.on("-u", "--unified N", Integer) { |value| options[:context] = value }
+        command.on("--json") { options[:json] = true }
+        command.on("-q", "--quiet") { options[:quiet] = true }
+        command.on("--max-bytes N", Integer) { |value| options[:max_bytes] = value }
+        command.on("--version") { output.puts VERSION; return 0 }
+        command.on("--help") { output.puts command; return 0 }
+      end
+      parser.parse!(arguments)
+      raise OptionParser::MissingArgument, "OLD NEW" unless arguments.length == 2
+      budget = Budget.new(max_bytes: options[:max_bytes], on_exceeded: :raise)
+      result = Porrima.diff(File.binread(arguments[0]), File.binread(arguments[1]), context: options[:context], budget: budget)
+      unless options[:quiet]
+        output.puts JSON.generate(result.to_h) if options[:json]
+        output << result.to_unified(old_name: arguments[0], new_name: arguments[1]) unless options[:json] || result.empty?
+      end
+      result.empty? ? 0 : 1
+    end
+    private_class_method :run_diff
+
+    def run_merge(arguments, output)
+      options = {style: :diff3, json: false, quiet: false, max_bytes: MAX_BYTES}
+      parser = OptionParser.new do |command|
+        command.banner = "Usage: porrima merge [options] BASE OURS THEIRS"
+        command.on("--style STYLE", %w[diff3 merge]) { |value| options[:style] = value.to_sym }
+        command.on("--json") { options[:json] = true }
+        command.on("-q", "--quiet") { options[:quiet] = true }
+        command.on("--max-bytes N", Integer) { |value| options[:max_bytes] = value }
+        command.on("--version") { output.puts VERSION; return 0 }
+        command.on("--help") { output.puts command; return 0 }
+      end
+      parser.parse!(arguments)
+      raise OptionParser::MissingArgument, "BASE OURS THEIRS" unless arguments.length == 3
+      texts = arguments.map { |path| File.binread(path) }
+      raise BudgetExceeded, "diff budget exceeded" if texts.sum(&:bytesize) > options[:max_bytes]
+      result = Merge.three_way(base: texts[0], ours: texts[1], theirs: texts[2])
+      unless options[:quiet]
+        output.puts JSON.generate(merge_to_h(result)) if options[:json]
+        output << Merge.to_text(result, style: options[:style], labels: [arguments[1], arguments[0], arguments[2]]) unless options[:json]
+      end
+      result.clean? ? 0 : 1
+    end
+    private_class_method :run_merge
+
+    def run_apply(arguments, output)
+      options = {reverse: false, check: false, quiet: false, max_bytes: MAX_BYTES}
+      parser = OptionParser.new do |command|
+        command.banner = "Usage: porrima apply [options] PATCH [FILE]"
+        command.on("--reverse") { options[:reverse] = true }
+        command.on("--check") { options[:check] = true }
+        command.on("-q", "--quiet") { options[:quiet] = true }
+        command.on("--max-bytes N", Integer) { |value| options[:max_bytes] = value }
+        command.on("--version") { output.puts VERSION; return 0 }
+        command.on("--help") { output.puts command; return 0 }
+      end
+      parser.parse!(arguments)
+      raise OptionParser::MissingArgument, "PATCH [FILE]" unless (1..2).cover?(arguments.length)
+      patch_text = File.binread(arguments[0])
+      raise BudgetExceeded, "diff budget exceeded" if patch_text.bytesize > options[:max_bytes]
+      files = Patch.parse(patch_text)
+      raise PatchError, "FILE is required for a multi-file patch" if arguments[1] && files.length != 1
+      updates = files.map do |file|
+        path = arguments[1] || patch_path(file, options[:reverse])
+        content = File.file?(path) ? File.binread(path) : ""
+        raise BudgetExceeded, "diff budget exceeded" if patch_text.bytesize + content.bytesize > options[:max_bytes]
+        updated = options[:reverse] ? file.revert(content) : file.apply(content)
+        [path, updated, options[:reverse] ? file.old_name == "/dev/null" : file.new_name == "/dev/null"]
+      end
+      unless options[:check]
+        updates.each { |path, content, delete| delete ? File.unlink(path) : atomic_write(path, content) }
+      end
+      updates.each { |path,| output.puts path } unless options[:quiet]
+      0
+    end
+    private_class_method :run_apply
+
+    def patch_path(file, reverse)
+      name = if reverse
+        file.new_name == "/dev/null" ? file.old_name : file.new_name
+      else
+        file.old_name == "/dev/null" ? file.new_name : file.old_name
+      end
+      name = name.delete_prefix("a/").delete_prefix("b/")
+      raise PatchError, "unsafe patch path" if name.empty? || name.start_with?("/") || name.split("/").any? { |part| ["", ".", "..", ".git"].include?(part) }
+      name
+    end
+    private_class_method :patch_path
+
+    def atomic_write(path, content)
+      directory = File.dirname(File.expand_path(path))
+      FileUtils.mkdir_p(directory)
+      mode = File.file?(path) ? File.stat(path).mode & 0o777 : 0o644
+      Tempfile.create([".porrima-", ".tmp"], directory) do |file|
+        file.binmode
+        file.chmod(mode)
+        file.write(content)
+        file.flush
+        file.fsync
+        file.close
+        File.rename(file.path, path)
+      end
+    end
+    private_class_method :atomic_write
+
+    def merge_to_h(result)
+      {version: 1, clean: result.clean?, sections: result.sections.map do |section|
+        section.is_a?(Merge::Conflict) ? section.to_h.merge(kind: :conflict) : {kind: :text, text: section}
+      end}
+    end
+    private_class_method :merge_to_h
+  end
+end

data/lib/porrima/diff.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Porrima
+  class Diff
+    def initialize(before, after, context: 3, budget: nil)
+      @before = snapshot(before)
+      @after = snapshot(after)
+      @context = context
+      @budget = budget
+      @memo = {}
+      freeze
+    end
+
+    def edits = @memo[:edits] ||= Porrima.edits(@before, @after, budget: @budget).each(&:freeze).freeze
+
+    def hunks
+      @memo[:hunks] ||= Porrima.hunks(@before, @after, context: @context, budget: @budget).each do |hunk|
+        hunk.edits.each(&:freeze).freeze
+        hunk.freeze
+      end.freeze
+    end
+
+    def marks = @memo[:marks] ||= build_marks.freeze
+    def rows = @memo[:rows] ||= build_rows.freeze
+
+    def stat
+      @memo[:stat] ||= Stat.new(insertions: edits.count { |edit| edit.kind == :insert },
+        deletions: edits.count { |edit| edit.kind == :delete }, hunks: hunks.length).freeze
+    end
+
+    def hunk_at(new_line:)
+      left = 0
+      right = hunks.length - 1
+      while left <= right
+        middle = (left + right) / 2
+        hunk = hunks[middle]
+        first = [hunk.new_start, 1].max
+        last = [hunk.new_start + hunk.new_count - 1, hunk.new_start, 1].max
+        return hunk if new_line.between?(first, last)
+        new_line < first ? right = middle - 1 : left = middle + 1
+      end
+      nil
+    end
+
+    def mark_at(new_line:)
+      marks.find do |mark|
+        mark.kind == :removed ? new_line == mark.new_line : new_line.between?(mark.new_line, mark.new_line + mark.count - 1)
+      end
+    end
+
+    def empty? = Porrima.identical?(@before, @after)
+
+    def to_unified(old_name: "a/file", new_name: "b/file")
+      Porrima.unified(@before, @after, old_name: old_name, new_name: new_name, context: @context, budget: @budget)
+    end
+
+    def to_h
+      {version: 1, edits: edits.map(&:to_h), hunks: hunks.map { |hunk| hunk.to_h.merge(edits: hunk.edits.map(&:to_h)) },
+       stat: stat.to_h, marks: marks.map(&:to_h), rows: rows.map(&:to_h)}
+    end
+
+    private
+
+    def snapshot(value)
+      return value.dup.freeze if value.is_a?(String)
+      value.map { |item| item.dup.freeze }.freeze
+    end
+
+    def build_marks
+      Porrima.hunks(@before, @after, context: 0, budget: @budget).map do |hunk|
+        insertions = hunk.edits.count { |edit| edit.kind == :insert }
+        deletions = hunk.edits.count { |edit| edit.kind == :delete }
+        kind = insertions.positive? ? (deletions.positive? ? :modified : :added) : :removed
+        Mark.new(new_line: hunk.new_start, kind: kind, count: insertions.positive? ? insertions : deletions).freeze
+      end
+    end
+
+    def build_rows
+      result = []
+      index = 0
+      while index < edits.length
+        edit = edits[index]
+        if edit.kind == :equal
+          result << Row.new(kind: :equal, old_line: edit.old_line, new_line: edit.new_line, old_text: edit.text, new_text: edit.text).freeze
+          index += 1
+          next
+        end
+        changed = []
+        while index < edits.length && edits[index].kind != :equal
+          changed << edits[index]
+          index += 1
+        end
+        deleted = changed.select { |item| item.kind == :delete }
+        inserted = changed.select { |item| item.kind == :insert }
+        [deleted.length, inserted.length].max.times do |offset|
+          old, new = deleted[offset], inserted[offset]
+          kind = old && new ? :modified : old ? :removed : :added
+          result << Row.new(kind: kind, old_line: old&.old_line, new_line: new&.new_line,
+            old_text: old&.text, new_text: new&.text).freeze
+        end
+      end
+      result
+    end
+  end
+end

data/lib/porrima/edit.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Porrima
+  Edit = Struct.new(:kind, :old_line, :new_line, :text, keyword_init: true)
+  Hunk = Struct.new(:old_start, :old_count, :new_start, :new_count, :edits, keyword_init: true) do
+    def old_text = edits.reject { |edit| edit.kind == :insert }.map(&:text).join
+    def new_text = edits.reject { |edit| edit.kind == :delete }.map(&:text).join
+  end
+  Mark = Struct.new(:new_line, :kind, :count, keyword_init: true)
+  Row = Struct.new(:kind, :old_line, :new_line, :old_text, :new_text, keyword_init: true)
+  Stat = Struct.new(:insertions, :deletions, :hunks, keyword_init: true)
+  Span = Struct.new(:kind, :text, keyword_init: true)
+end

data/lib/porrima/errors.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Porrima
+  class Error < StandardError; end
+  class PatchError < Error; end
+  class BudgetExceeded < Error; end
+end

data/lib/porrima/hunks.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Porrima
+  def hunks(before, after, context: 3, budget: nil)
+    raise ArgumentError, "context must be nonnegative" unless context.is_a?(Integer) && context >= 0
+    changes = edits(before, after, budget: budget)
+    ranges = []
+    changes.each_with_index do |edit, index|
+      next if edit.kind == :equal
+      first = [0, index - context].max
+      last = [changes.length - 1, index + context].min
+      if ranges.last && first <= ranges.last[1] + 1
+        ranges.last[1] = last
+      else
+        ranges << [first, last]
+      end
+    end
+    ranges.map do |first, last|
+      items = changes[first..last]
+      old_count = items.count { |edit| edit.kind != :insert }
+      new_count = items.count { |edit| edit.kind != :delete }
+      Hunk.new(old_start: items.first.old_line - (old_count.zero? ? 1 : 0), old_count: old_count,
+        new_start: items.first.new_line - (new_count.zero? ? 1 : 0), new_count: new_count, edits: items)
+    end
+  end
+  module_function :hunks
+end

data/lib/porrima/inline.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Porrima
+  module Inline
+    TOKEN_LIMIT = 2_000
+    module_function
+
+    def refine(old_text, new_text, granularity: :word)
+      old_tokens = tokenize(old_text, granularity)
+      new_tokens = tokenize(new_text, granularity)
+      return replacement(old_text, new_text) if old_tokens.length + new_tokens.length > TOKEN_LIMIT
+      changes = Porrima.edits(old_tokens, new_tokens)
+      [spans(changes.reject { |edit| edit.kind == :insert }), spans(changes.reject { |edit| edit.kind == :delete })]
+    end
+
+    def refine_row(row, granularity: :word)
+      refine(row.old_text.to_s, row.new_text.to_s, granularity: granularity)
+    end
+
+    def tokenize(text, granularity)
+      case granularity
+      when :word then text.scan(/\w+|\s+|./)
+      when :char then text.grapheme_clusters
+      else raise ArgumentError, "granularity must be :word or :char"
+      end
+    end
+    private_class_method :tokenize
+
+    def spans(edits)
+      edits.each_with_object([]) do |edit, result|
+        if result.last&.kind == edit.kind
+          result.last.text << edit.text
+        else
+          result << Span.new(kind: edit.kind, text: edit.text.dup)
+        end
+      end
+    end
+    private_class_method :spans
+
+    def replacement(old_text, new_text)
+      [old_text.empty? ? [] : [Span.new(kind: :delete, text: old_text)],
+       new_text.empty? ? [] : [Span.new(kind: :insert, text: new_text)]]
+    end
+    private_class_method :replacement
+  end
+end

data/lib/porrima/merge.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module Porrima
+  module Merge
+    Change = Struct.new(:start, :finish, :replacement, :side, keyword_init: true)
+    Conflict = Struct.new(:base_start, :base_count, :base, :ours, :theirs, keyword_init: true)
+
+    class Result
+      attr_reader :sections, :conflicts
+
+      def initialize(sections)
+        @sections = sections.freeze
+        @conflicts = sections.grep(Conflict).freeze
+        freeze
+      end
+
+      def clean? = conflicts.empty?
+    end
+
+    module_function
+
+    def three_way(base:, ours:, theirs:)
+      return Result.new([ours]) if ours == theirs || theirs == base
+      return Result.new([theirs]) if ours == base
+
+      base_lines = lines(base)
+      changes = side_changes(base, ours, :ours) + side_changes(base, theirs, :theirs)
+      changes.sort_by! { |change| [change.start, change.finish] }
+      sections = []
+      cursor = index = 0
+      while index < changes.length
+        cluster = [changes[index]]
+        index += 1
+        while index < changes.length && cluster.any? { |change| overlap?(change, changes[index]) }
+          cluster << changes[index]
+          index += 1
+        end
+        first = cluster.map(&:start).min
+        last = cluster.map(&:finish).max
+        append_text(sections, base_lines[cursor...first].join)
+        ours_changes = cluster.select { |change| change.side == :ours }
+        theirs_changes = cluster.select { |change| change.side == :theirs }
+        base_text = base_lines[first...last].join
+        ours_text = project(base_lines, first, last, ours_changes)
+        theirs_text = project(base_lines, first, last, theirs_changes)
+        if ours_changes.empty? || theirs_changes.empty? || ours_text == theirs_text
+          append_text(sections, ours_changes.empty? ? theirs_text : ours_text)
+        elsif ours_text == base_text || theirs_text == base_text
+          append_text(sections, ours_text == base_text ? theirs_text : ours_text)
+        else
+          append_conflict(sections, Conflict.new(base_start: first == last ? first : first + 1,
+            base_count: last - first, base: base_text, ours: ours_text, theirs: theirs_text).freeze)
+        end
+        cursor = last
+      end
+      append_text(sections, base_lines[cursor..].join)
+      Result.new(sections)
+    end
+
+    def to_text(result, style: :diff3, labels: ["ours", "base", "theirs"])
+      raise ArgumentError, "style must be :diff3 or :merge" unless %i[diff3 merge].include?(style)
+      raise ArgumentError, "labels must contain ours, base, and theirs" unless labels.is_a?(Array) && labels.length == 3 && labels.all?(String)
+      result.sections.each_with_object(+"") do |section, output|
+        unless section.is_a?(Conflict)
+          output << section
+          next
+        end
+        output << "<<<<<<< #{labels[0]}\n"
+        append_marked_text(output, section.ours)
+        if style == :diff3
+          output << "||||||| #{labels[1]}\n"
+          append_marked_text(output, section.base)
+        end
+        output << "=======\n"
+        append_marked_text(output, section.theirs)
+        output << ">>>>>>> #{labels[2]}\n"
+      end
+    end
+
+    def lines(text) = text.is_a?(String) ? text.lines : text
+    private_class_method :lines
+
+    def side_changes(base, side, name)
+      Porrima.hunks(base, side, context: 0).map do |hunk|
+        start = hunk.old_count.zero? ? hunk.old_start : hunk.old_start - 1
+        Change.new(start: start, finish: start + hunk.old_count, replacement: hunk.new_text.lines, side: name)
+      end
+    end
+    private_class_method :side_changes
+
+    def overlap?(left, right)
+      left_insert = left.start == left.finish
+      right_insert = right.start == right.finish
+      return left.start == right.start if left_insert && right_insert
+      return right.start < left.finish && right.start > left.start if right_insert
+      return left.start < right.finish && left.start > right.start if left_insert
+      left.start < right.finish && right.start < left.finish
+    end
+    private_class_method :overlap?
+
+    def project(base, first, last, changes)
+      cursor = first
+      changes.sort_by(&:start).each_with_object([]) do |change, output|
+        output.concat(base[cursor...change.start])
+        output.concat(change.replacement)
+        cursor = change.finish
+      end.concat(base[cursor...last]).join
+    end
+    private_class_method :project
+
+    def append_text(sections, text)
+      return if text.empty?
+      sections.last.is_a?(String) ? sections.last << text : sections << +text
+    end
+    private_class_method :append_text
+
+    def append_conflict(sections, conflict)
+      previous = sections.last
+      unless previous.is_a?(Conflict)
+        sections << conflict
+        return
+      end
+      sections[-1] = Conflict.new(base_start: previous.base_start, base_count: previous.base_count + conflict.base_count,
+        base: previous.base + conflict.base, ours: previous.ours + conflict.ours, theirs: previous.theirs + conflict.theirs).freeze
+    end
+    private_class_method :append_conflict
+
+    def append_marked_text(output, text)
+      output << text
+      output << "\n" unless text.empty? || text.end_with?("\n")
+    end
+    private_class_method :append_marked_text
+  end
+end

data/lib/porrima/myers.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Porrima
+  module_function
+
+  def script(left, right)
+    return right.map { |line| [:insert, line] } if left.empty?
+    return left.map { |line| [:delete, line] } if right.empty?
+    return left.map { |line| [:delete, line] } + right.map { |line| [:insert, line] } unless left.intersect?(right)
+    x, y = bisect(left, right)
+    if !x || (x.zero? && y.zero?) || (x == left.length && y == right.length)
+      return left.map { |line| [:delete, line] } + right.map { |line| [:insert, line] }
+    end
+    [edits(left[0...x], right[0...y]), edits(left[x..], right[y..])].flatten.map { |edit| [edit.kind, edit.text] }
+  end
+  private_class_method :script
+
+  def bisect(left, right)
+    n, m = left.length, right.length
+    limit = (n + m + 1) / 2
+    forward = {1 => 0}
+    reverse = {1 => 0}
+    delta = n - m
+    odd = delta.odd?
+    (0..limit).each do |depth|
+      (-depth..depth).step(2) do |k|
+        x = k == -depth || (k != depth && forward.fetch(k - 1, -1) < forward.fetch(k + 1, -1)) ? forward.fetch(k + 1, 0) : forward.fetch(k - 1, 0) + 1
+        y = x - k
+        while x < n && y < m && x >= 0 && y >= 0 && left[x] == right[y]
+          x += 1
+          y += 1
+        end
+        forward[k] = x
+        return [x, y] if odd && reverse.key?(delta - k) && x + reverse[delta - k] >= n
+      end
+      (-depth..depth).step(2) do |k|
+        x = k == -depth || (k != depth && reverse.fetch(k - 1, -1) < reverse.fetch(k + 1, -1)) ? reverse.fetch(k + 1, 0) : reverse.fetch(k - 1, 0) + 1
+        y = x - k
+        while x < n && y < m && x >= 0 && y >= 0 && left[n - x - 1] == right[m - y - 1]
+          x += 1
+          y += 1
+        end
+        reverse[k] = x
+        if !odd && forward.key?(delta - k) && forward[delta - k] + x >= n
+          middle_x = forward[delta - k]
+          return [middle_x, middle_x - (delta - k)]
+        end
+      end
+    end
+    nil
+  end
+  private_class_method :bisect
+end

data/lib/porrima/patch.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Porrima
+  module Patch
+    FileDiff = Struct.new(:old_name, :new_name, :hunks, keyword_init: true) do
+      def applies?(text)
+        apply(text)
+        true
+      rescue PatchError
+        false
+      end
+
+      def apply(text)
+        hunks.reverse_each { |hunk| text = Porrima.apply(text, hunk) }
+        text
+      rescue ArgumentError => error
+        raise PatchError, error.message
+      end
+
+      def revert(text)
+        hunks.reverse_each { |hunk| text = Porrima.revert(text, hunk) }
+        text
+      rescue ArgumentError => error
+        raise PatchError, error.message
+      end
+    end
+
+    module_function
+
+    def parse(text)
+      lines = text.lines
+      files = []
+      index = 0
+      while index < lines.length
+        index += 1 while index < lines.length && !lines[index].start_with?("--- ")
+        break if index == lines.length
+        old_name = header_name(lines[index], "--- ")
+        index += 1
+        raise PatchError, "missing new file header" unless lines[index]&.start_with?("+++ ")
+        new_name = header_name(lines[index], "+++ ")
+        index += 1
+        hunks = []
+        while index < lines.length && lines[index].start_with?("@@ ")
+          hunk, index = parse_hunk(lines, index)
+          hunks << hunk
+        end
+        files << FileDiff.new(old_name: old_name, new_name: new_name, hunks: hunks)
+      end
+      raise PatchError, "malformed patch" if files.empty? && !text.empty?
+      files
+    rescue PatchError
+      raise
+    rescue StandardError => error
+      raise PatchError, error.message
+    end
+
+    def header_name(line, prefix)
+      line.delete_prefix(prefix).chomp.split("\t", 2).first
+    end
+    private_class_method :header_name
+
+    def parse_hunk(lines, index)
+      match = /\A@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/.match(lines[index])
+      raise PatchError, "malformed hunk header" unless match
+      old_start, old_count, new_start, new_count = match.captures.map.with_index { |value, offset| value ? value.to_i : [1, 3].include?(offset) ? 1 : nil }
+      old_line = [old_start, 1].max
+      new_line = [new_start, 1].max
+      old_seen = new_seen = 0
+      edits = []
+      index += 1
+      until old_seen == old_count && new_seen == new_count
+        line = lines[index]
+        raise PatchError, "truncated hunk" unless line && [" ", "-", "+"].include?(line[0])
+        kind = {" " => :equal, "-" => :delete, "+" => :insert}.fetch(line[0])
+        body = line[1..]
+        index += 1
+        if lines[index]&.start_with?("\")
+          body = body.delete_suffix("\n")
+          index += 1
+        end
+        edits << Edit.new(kind: kind, old_line: old_line, new_line: new_line, text: body)
+        unless kind == :insert
+          old_line += 1
+          old_seen += 1
+        end
+        unless kind == :delete
+          new_line += 1
+          new_seen += 1
+        end
+        raise PatchError, "hunk line count mismatch" if old_seen > old_count || new_seen > new_count
+      end
+      [Hunk.new(old_start: old_start, old_count: old_count, new_start: new_start, new_count: new_count, edits: edits), index]
+    end
+    private_class_method :parse_hunk
+  end
+end

data/lib/porrima/unified.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Porrima
+  def unified(before, after, old_name: "a/file", new_name: "b/file", context: 3, budget: nil)
+    output = +"--- #{old_name}\n+++ #{new_name}\n"
+    hunks(before, after, context: context, budget: budget).each do |hunk|
+      output << "@@ -#{hunk.old_start},#{hunk.old_count} +#{hunk.new_start},#{hunk.new_count} @@\n"
+      hunk.edits.each do |edit|
+        output << {equal: " ", delete: "-", insert: "+"}.fetch(edit.kind) << edit.text
+        output << "\n\\n" unless edit.text.end_with?("\n")
+      end
+    end
+    output
+  end
+  module_function :unified
+end

data/lib/porrima/version.rb

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

data/lib/porrima.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require_relative "porrima/version"
+require_relative "porrima/errors"
+require_relative "porrima/edit"
+require_relative "porrima/budget"
+require_relative "porrima/myers"
+require_relative "porrima/hunks"
+require_relative "porrima/unified"
+require_relative "porrima/diff"
+require_relative "porrima/patch"
+require_relative "porrima/inline"
+require_relative "porrima/merge"
+
+module Porrima
+  module_function
+
+  def diff(before, after, context: 3, budget: nil) = Diff.new(before, after, context: context, budget: budget)
+
+  def edits(before, after, budget: nil)
+    left = before.is_a?(String) ? before.lines : before
+    right = after.is_a?(String) ? after.lines : after
+    if (budget || Budget::NONE).exceeded?(left, right)
+      return numbered(left.map { |line| [:delete, line] } + right.map { |line| [:insert, line] })
+    end
+
+    prefix = 0
+    prefix += 1 while prefix < left.length && prefix < right.length && left[prefix] == right[prefix]
+    suffix = 0
+    suffix += 1 while suffix < left.length - prefix && suffix < right.length - prefix && left[-suffix - 1] == right[-suffix - 1]
+    a = left.slice(prefix, left.length - prefix - suffix)
+    b = right.slice(prefix, right.length - prefix - suffix)
+    middle = script(a, b)
+    pairs = left.first(prefix).map { |line| [:equal, line] } + middle + (suffix.zero? ? [] : left.last(suffix).map { |line| [:equal, line] })
+    numbered(pairs)
+  end
+
+  def revert(text, hunk)
+    replace_hunk(text, hunk.new_start, hunk.new_count, hunk.new_text, hunk.old_text)
+  end
+
+  def apply(text, hunk)
+    replace_hunk(text, hunk.old_start, hunk.old_count, hunk.old_text, hunk.new_text)
+  end
+
+  def identical?(before, after) = before == after
+
+  def numbered(pairs)
+    old_line = new_line = 1
+    pairs.map do |kind, text|
+      edit = Edit.new(kind: kind, old_line: old_line, new_line: new_line, text: text)
+      old_line += 1 unless kind == :insert
+      new_line += 1 unless kind == :delete
+      edit
+    end
+  end
+  private_class_method :numbered
+
+  def replace_hunk(text, start_line, count, expected, replacement)
+    lines = text.lines
+    start = count.zero? ? start_line : start_line - 1
+    raise ArgumentError, "hunk no longer applies" unless lines.slice(start, count)&.join == expected
+    lines[start, count] = replacement.lines
+    lines.join
+  end
+  private_class_method :replace_hunk
+end

data/sig/porrima.rbs

@@ -0,0 +1,130 @@
+module Porrima
+  VERSION: String
+  type lines = String | Array[String]
+  type kind = :equal | :delete | :insert
+
+  class Error < StandardError
+  end
+  class PatchError < Error
+  end
+  class BudgetExceeded < Error
+  end
+
+  class Edit < Struct[untyped]
+    attr_accessor kind: kind
+    attr_accessor old_line: Integer
+    attr_accessor new_line: Integer
+    attr_accessor text: String
+    def self.new: (kind: kind, old_line: Integer, new_line: Integer, text: String) -> instance
+  end
+
+  class Hunk < Struct[untyped]
+    attr_accessor old_start: Integer
+    attr_accessor old_count: Integer
+    attr_accessor new_start: Integer
+    attr_accessor new_count: Integer
+    attr_accessor edits: Array[Edit]
+    def self.new: (old_start: Integer, old_count: Integer, new_start: Integer, new_count: Integer, edits: Array[Edit]) -> instance
+    def old_text: () -> String
+    def new_text: () -> String
+  end
+
+  class Mark < Struct[untyped]
+    attr_accessor new_line: Integer
+    attr_accessor kind: :added | :modified | :removed
+    attr_accessor count: Integer
+    def self.new: (new_line: Integer, kind: (:added | :modified | :removed), count: Integer) -> instance
+  end
+
+  class Row < Struct[untyped]
+    attr_accessor kind: :equal | :modified | :added | :removed
+    attr_accessor old_line: Integer?
+    attr_accessor new_line: Integer?
+    attr_accessor old_text: String?
+    attr_accessor new_text: String?
+    def self.new: (kind: (:equal | :modified | :added | :removed), old_line: Integer?, new_line: Integer?, old_text: String?, new_text: String?) -> instance
+  end
+
+  class Span < Struct[untyped]
+    attr_accessor kind: kind
+    attr_accessor text: String
+    def self.new: (kind: kind, text: String) -> instance
+  end
+
+  class Stat < Struct[untyped]
+    attr_accessor insertions: Integer
+    attr_accessor deletions: Integer
+    attr_accessor hunks: Integer
+    def self.new: (insertions: Integer, deletions: Integer, hunks: Integer) -> instance
+  end
+
+  class Budget
+    NONE: Budget
+    attr_reader max_bytes: Integer?
+    attr_reader max_lines: Integer?
+    attr_reader on_exceeded: :replace | :raise
+    def initialize: (?max_bytes: Integer?, ?max_lines: Integer?, ?on_exceeded: (:replace | :raise)) -> void
+    def exceeded?: (Array[String], Array[String]) -> bool
+  end
+
+  # Finish lazy fields on the producing thread before sharing an instance.
+  class Diff
+    def initialize: (lines, lines, ?context: Integer, ?budget: Budget?) -> void
+    def edits: () -> Array[Edit]
+    def hunks: () -> Array[Hunk]
+    def marks: () -> Array[Mark]
+    def rows: () -> Array[Row]
+    def stat: () -> Stat
+    def hunk_at: (new_line: Integer) -> Hunk?
+    def mark_at: (new_line: Integer) -> Mark?
+    def empty?: () -> bool
+    def to_unified: (?old_name: String, ?new_name: String) -> String
+    def to_h: () -> Hash[Symbol, untyped]
+  end
+
+  module Patch
+    class FileDiff < Struct[untyped]
+      attr_accessor old_name: String
+      attr_accessor new_name: String
+      attr_accessor hunks: Array[Hunk]
+      def self.new: (old_name: String, new_name: String, hunks: Array[Hunk]) -> instance
+      def applies?: (String) -> bool
+      def apply: (String) -> String
+      def revert: (String) -> String
+    end
+    def self.parse: (String) -> Array[FileDiff]
+  end
+
+  module Inline
+    TOKEN_LIMIT: Integer
+    def self.refine: (String, String, ?granularity: (:word | :char)) -> [Array[Span], Array[Span]]
+    def self.refine_row: (Row, ?granularity: (:word | :char)) -> [Array[Span], Array[Span]]
+  end
+
+  module Merge
+    class Conflict < Struct[untyped]
+      attr_accessor base_start: Integer
+      attr_accessor base_count: Integer
+      attr_accessor base: String
+      attr_accessor ours: String
+      attr_accessor theirs: String
+      def self.new: (base_start: Integer, base_count: Integer, base: String, ours: String, theirs: String) -> instance
+    end
+    class Result
+      attr_reader sections: Array[String | Conflict]
+      attr_reader conflicts: Array[Conflict]
+      def initialize: (Array[String | Conflict]) -> void
+      def clean?: () -> bool
+    end
+    def self.three_way: (base: String, ours: String, theirs: String) -> Result
+    def self.to_text: (Result, ?style: (:diff3 | :merge), ?labels: Array[String]) -> String
+  end
+
+  def self.diff: (lines, lines, ?context: Integer, ?budget: Budget?) -> Diff
+  def self.edits: (lines, lines, ?budget: Budget?) -> Array[Edit]
+  def self.hunks: (lines, lines, ?context: Integer, ?budget: Budget?) -> Array[Hunk]
+  def self.unified: (lines, lines, ?old_name: String, ?new_name: String, ?context: Integer, ?budget: Budget?) -> String
+  def self.revert: (String, Hunk) -> String
+  def self.apply: (String, Hunk) -> String
+  def self.identical?: (lines, lines) -> bool
+end

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification
+name: porrima
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Yudai Takada
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: Linear-space Myers diff with context hunks, gutter marks, paired rows,
+  unified output, strict patch application, and three-way merge. No I/O, no dependencies.
+email:
+- t.yudai92@gmail.com
+executables:
+- porrima
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- exe/porrima
+- lib/porrima.rb
+- lib/porrima/budget.rb
+- lib/porrima/cli.rb
+- lib/porrima/diff.rb
+- lib/porrima/edit.rb
+- lib/porrima/errors.rb
+- lib/porrima/hunks.rb
+- lib/porrima/inline.rb
+- lib/porrima/merge.rb
+- lib/porrima/myers.rb
+- lib/porrima/patch.rb
+- lib/porrima/unified.rb
+- lib/porrima/version.rb
+- sig/porrima.rbs
+homepage: https://github.com/noxdea/porrima
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  source_code_uri: https://github.com/noxdea/porrima
+  changelog_uri: https://github.com/noxdea/porrima/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.19
+specification_version: 4
+summary: Line, word, and three-way diff, patch, and merge in pure Ruby
+test_files: []