diff-lcs 1.6.2 → 2.0.0.beta.2

data/Rakefile

@@ -1,52 +1,24 @@
 require "rubygems"
-require "rspec"
-require "rspec/core/rake_task"
 require "hoe"
 require "rake/clean"
-
-MAINTENANCE = ENV["MAINTENANCE"] == "true"
-BUILD_DOCS = MAINTENANCE || ENV["DOCS"] == "true"
-TRUSTED_RELEASE = ENV["rubygems_release_gem"] == "true"
+require "rdoc/task"
+require "minitest/test_task"
 
 Hoe.plugin :halostatue
-Hoe.plugin :rubygems
 
 Hoe.plugins.delete :debug
 Hoe.plugins.delete :newb
+Hoe.plugins.delete :publish
 Hoe.plugins.delete :signing
-Hoe.plugins.delete :publish unless BUILD_DOCS
-
-if RUBY_VERSION < "1.9"
-  class Array # :nodoc:
-    def to_h
-      Hash[*flatten(1)]
-    end
-  end
+Hoe.plugins.delete :test
 
-  class Gem::Specification # :nodoc:
-    def metadata=(*)
-    end
-
-    def default_value(*)
-    end
-  end
-
-  class Object # :nodoc:
-    def caller_locations(*)
-      []
-    end
-  end
-end
-
-_spec = Hoe.spec "diff-lcs" do
+hoe = Hoe.spec "diff-lcs" do
   developer("Austin Ziegler", "halostatue@gmail.com")
 
-  self.trusted_release = TRUSTED_RELEASE
+  self.trusted_release = ENV["rubygems_release_gem"] == "true"
 
-  require_ruby_version ">= 1.8"
+  require_ruby_version ">= 3.2.0", "< 5"
 
-  self.history_file = "CHANGELOG.md"
-  self.readme_file = "README.md"
   self.licenses = ["MIT", "Artistic-1.0-Perl", "GPL-2.0-or-later"]
 
   spec_extras[:metadata] = ->(val) {
@@ -54,62 +26,116 @@ _spec = Hoe.spec "diff-lcs" do
   }
 
   extra_dev_deps << ["hoe", "~> 4.0"]
-  extra_dev_deps << ["hoe-halostatue", "~> 2.0"]
-  extra_dev_deps << ["hoe-rubygems", "~> 1.0"]
-  extra_dev_deps << ["rspec", ">= 2.0", "< 4"]
+  extra_dev_deps << ["hoe-halostatue", "~> 3.0"]
+  extra_dev_deps << ["minitest", "~> 6.0"]
+  extra_dev_deps << ["minitest-autotest", "~> 1.0"]
+  extra_dev_deps << ["minitest-focus", "~> 1.1"]
   extra_dev_deps << ["rake", ">= 10.0", "< 14"]
-  extra_dev_deps << ["rdoc", ">= 6.3.1", "< 7"]
+  extra_dev_deps << ["rdoc", ">= 6.0", "< 8"]
+  extra_dev_deps << ["simplecov", "~> 0.9"]
+  extra_dev_deps << ["simplecov-lcov", "~> 0.9"]
+  extra_dev_deps << ["standard", "~> 1.50"]
+  extra_dev_deps << ["standard-thread_safety", "~> 1.0"]
+  extra_dev_deps << ["fasterer", "~> 0.11"]
 end
 
-if BUILD_DOCS
-  rake_tasks = Rake.application.instance_variable_get(:@tasks)
-  tasks = ["publish_docs", "publish_on_announce", "debug_email", "post_blog", "announce"]
-  tasks.each do |task|
-    rake_tasks.delete(task)
+Minitest::TestTask.create :test
+Minitest::TestTask.create :coverage do |t|
+  formatters = <<-RUBY.split($/).join(" ")
+    SimpleCov::Formatter::MultiFormatter.new([
+      SimpleCov::Formatter::HTMLFormatter,
+      SimpleCov::Formatter::LcovFormatter,
+      SimpleCov::Formatter::SimpleFormatter
+    ])
+  RUBY
+  t.test_prelude = <<-RUBY.split($/).join("; ")
+  require "simplecov"
+  require "simplecov-lcov"
+
+  SimpleCov::Formatter::LcovFormatter.config do |config|
+    config.report_with_single_file = true
+    config.lcov_file_name = "lcov.info"
   end
-end
 
-desc "Run all specifications"
-RSpec::Core::RakeTask.new(:spec) do |t|
-  rspec_dirs = %w[spec lib].join(":")
-  t.rspec_opts = ["-I#{rspec_dirs}"]
+  SimpleCov.start "test_frameworks" do
+    enable_coverage :branch
+    primary_coverage :branch
+    formatter #{formatters}
+  end
+  RUBY
 end
 
+task default: :test
+
 task :version do
   require "diff/lcs/version"
   puts Diff::LCS::VERSION
 end
 
-Rake::Task["spec"].actions.uniq! { |a| a.source_location }
+RDoc::Task.new do |config|
+  config.title = "diff-lcs"
+  config.main = "README.md"
+  config.rdoc_dir = "doc"
+  config.rdoc_files = hoe.spec.require_paths + hoe.spec.extra_rdoc_files -
+    FileList["integration/golden/*.txt", "Manifest.txt"].to_a
+  config.markup = "markdown"
+end
+task docs: :rerdoc
 
-# standard:disable Style/HashSyntax
-task :default => :spec unless Rake::Task["default"].prereqs.include?("spec")
-task :test => :spec unless Rake::Task["test"].prereqs.include?("spec")
-# standard:enable Style/HashSyntax
+def rspec_to_golden(file)
+  File.join("integration/golden", File.basename(file, "_spec.rb")) + ".txt"
+end
 
-if RUBY_VERSION >= "3.0" && RUBY_ENGINE == "ruby"
-  namespace :spec do
-    desc "Runs test coverage. Only works Ruby 2.0+ and assumes 'simplecov' is installed."
-    task :coverage do
-      ENV["COVERAGE"] = "true"
-      Rake::Task["spec"].execute
-    end
+def normalize_rspec_output(data)
+  data
+    .gsub(/Randomized with seed \d+/, "Randomized with seed XXXXX")
+    .gsub(/Finished in [\d.]+ seconds/, "Finished in X.XXXXX seconds")
+    .gsub(/files took [\d.]+ seconds to load/, "files took X.XXXXX seconds to load")
+end
+
+def unbundled(&block)
+  if defined?(Bundler)
+    Bundler.with_unbundled_env(&block)
+  else
+    block.call
   end
 end
 
-if MAINTENANCE
-  task ruby18: :package do
-    require "diff/lcs/version"
-    # standard:disable Layout/HeredocIndentation
-    puts <<-MESSAGE
-You are starting a barebones Ruby 1.8 docker environment for testing.
-A snapshot package has been built, so install it with:
+rspecs = FileList["integration/compare/*_spec.rb"]
+
+namespace :integration do
+  desc "Compare RSpec output with and without diff-lcs 2"
+  task :compare do
+    require "tempfile"
+    base = Tempfile.create("baseline") { _1.path }
+    work = Tempfile.create("working") { _1.path }
+
+    unbundled { sh "gem install rspec" }
 
-    cd diff-lcs
-    gem install pkg/diff-lcs-#{Diff::LCS::VERSION}
+    rspecs.to_a.each do |rspec_file|
+      basename = File.basename(rspec_file, "_spec.rb")
 
-    MESSAGE
-    # standard:enable Layout/HeredocIndentation
-    sh "docker run -it --rm -v #{Dir.pwd}:/root/diff-lcs bellbind/docker-ruby18-rails2 bash -l"
+      base_contents = unbundled { `integration/runner rspec #{rspec_file} 2>&1` }
+      base_contents = normalize_rspec_output(base_contents)
+
+      work_contents = unbundled { `integration/runner rspec -Ilib -rdiff/lcs #{rspec_file} 2>&1` }
+      work_contents = normalize_rspec_output(work_contents)
+
+      if base_contents == work_contents
+        puts "#{basename}: OK"
+      else
+        puts "#{basename}: FAIL"
+
+        File.write(base, base_contents)
+        File.write(work, work_contents)
+
+        unbundled { sh "integration/runner -Ilib bin/ldiff -U #{base} #{work}" }
+      end
+    end
   end
 end
+
+desc "Run RSpec integration tests with diff-lcs 2.0"
+task integration: ["integration:compare"] do
+  sh "rspec -Ilib -r diff/lcs integration/*_spec.rb"
+end

data/SECURITY.md

@@ -1,41 +1,36 @@
 # diff-lcs Security
 
+## LLM-Generated Security Report Policy
+
+Absolutely no security reports will be accepted that have been generated by LLM
+agents.
+
 ## Supported Versions
 
-Security reports are accepted for the most recent major release and the previous
-version for a limited time after the initial major release version. After a
-major release, the previous version will receive full support for six months and
-security support for an additional six months (for a total of twelve months).
+Security reports are accepted for the most recent major release, with a limited
+window of support after the initial major release.
 
-Because diff-lcs 1.x supports a wide range of Ruby versions, security reports
-will only be accepted when they can be demonstrated on Ruby 3.1 or higher.
+- Bug reports will be accepted up to three months after release.
+- Security reports will be accepted up to six months after release.
 
-> [!information]
->
-> There will be a diff-lcs 2.0 released in 2025 which narrows support to modern
-> versions of Ruby only.
+All issues raised must be demonstrated on the minimum supported Ruby version.
+
+> [!important]
 >
-> | Release Date | Support Ends | Security Support Ends |
-> | ------------ | ------------ | --------------------- |
-> | 2025         | +6 months    | +12 months            |
+> Because diff-lcs 1 has been the only version for over twenty years, security
+> reports will be accepted for one year after the release of diff-lcs 2.
 >
-> If the 2.0.0 release happens on 2025-07-01, regular support for diff-lcs 1.x
-> will end on 2026-12-31 and security support for diff-lcs 1.x will end on
-> 2026-06-30.
+> | Version | Release Date | Support Ends | Security Support Ends |
+> | ------- | ------------ | ------------ | --------------------- |
+> | 1.x     | 2010         | 2026-04-30   | 2027-01-31            |
+> | 2.x     | 2026-01-31   | -            | -                     |
 
 ## Reporting a Vulnerability
 
-By preference, use the [Tidelift security contact][tidelift]. Tidelift will
-coordinate the fix and disclosure.
-
-Alternatively, Send an email to [diff-lcs@halostatue.ca][email] with the text
-`Diff::LCS` in the subject. Emails sent to this address should be encrypted
-using [age][age] with the following public key:
+Report vulnerabilities via the [Tidelift security contact][tidelift]. Tidelift
+will coordinate the fix and disclosure.
 
-```
-age1fc6ngxmn02m62fej5cl30lrvwmxn4k3q2atqu53aatekmnqfwumqj4g93w
-```
+Alternatively, create a [private vulnerability report][advisory] with GitHub.
 
+[advisory]: https://github.com/halostatue/diff-lcs/security/advisories/new
 [tidelift]: https://tidelift.com/security
-[email]: mailto:diff-lcs@halostatue.ca
-[age]: https://github.com/FiloSottile/age

data/integration/compare/array_diff_spec.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+RSpec.describe "Array diff failure" do
+  it "shows diff for array with different elements" do
+    expected = ["apple", "banana", "cherry", "date", "elderberry"]
+    actual = ["apple", "blueberry", "cherry", "date", "elderberry"]
+
+    expect(actual).to eq(expected)
+  end
+end

data/integration/compare/hash_diff_spec.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+RSpec.describe "Hash diff failure" do
+  it "shows diff for nested hash mismatch" do
+    expected = {
+      name: "John",
+      age: 30,
+      address: {
+        city: "New York",
+        zip: "10001"
+      }
+    }
+
+    actual = {
+      name: "John",
+      age: 35,
+      address: {
+        city: "Boston",
+        zip: "10001"
+      }
+    }
+
+    expect(actual).to eq(expected)
+  end
+end

data/integration/compare/string_diff_spec.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+RSpec.describe "String diff failure" do
+  it "shows diff for multiline string mismatch" do
+    expected = "line1\nline2\nline3\nline4\nline5\n"
+    actual = "line1\nchanged\nline3\nline4\nline5\n"
+
+    expect(actual).to eq(expected)
+  end
+end

data/integration/rspec_differ_spec.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+# Integration test to verify diff-lcs 2.0 works with RSpec's differ
+# This runs RSpec with diff-lcs 1.x installed but loads the repo version
+
+RSpec.describe "Diff::LCS 2.0 with RSpec::Support::Differ" do
+  let(:differ) { RSpec::Support::Differ.new }
+
+  it "produces diff output for multiline strings" do
+    expected = "foo\nzap\nbar\n"
+    actual = "foo\nbar\nzap\n"
+
+    diff = differ.diff(actual, expected)
+
+    expect(diff).to be_a(String)
+    expect(diff).not_to be_empty
+  end
+
+  it "handles identical strings" do
+    str = "same\n"
+    diff = differ.diff(str, str)
+
+    # May return empty or just newline depending on implementation
+    expect(diff.strip).to be_empty
+  end
+end

data/integration/rspec_expectations_spec.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+# Integration test for RSpec expectation failures that use diff-lcs
+# Verifies that diff output is generated correctly with diff-lcs 2.0
+
+RSpec.describe "Diff::LCS 2.0 with RSpec expectations" do
+  it "produces diff for failed multiline string equality" do
+    expect {
+      expect("foo\nbar\nbaz").to eq("foo\nqux\nbaz")
+    }.to raise_error(RSpec::Expectations::ExpectationNotMetError) do |error|
+      expect(error.message).to include("Diff:")
+      expect(error.message).to match(/[-+](qux|bar)/)
+    end
+  end
+
+  it "produces diff for failed hash equality" do
+    expect {
+      expect({a: 1, b: 2}).to eq({a: 1, b: 3})
+    }.to raise_error(RSpec::Expectations::ExpectationNotMetError) do |error|
+      expect(error.message).to include("Diff:")
+    end
+  end
+
+  it "does not crash when comparing complex objects" do
+    obj1 = {a: [1, 2, 3], b: "test"}
+    obj2 = {a: [1, 4, 3], b: "test"}
+
+    expect {
+      expect(obj1).to eq(obj2)
+    }.to raise_error(RSpec::Expectations::ExpectationNotMetError)
+  end
+end

data/integration/runner

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+
+require "rbconfig"
+require "rubygems"
+
+if ENV["CI"]
+  vendor_dir = Dir.glob(File.join(Dir.pwd, "vendor", "bundle", "{ruby,jruby,truffleruby}", "*")).max
+  unless vendor_dir && Dir.exist?(vendor_dir)
+    fail "vendor bundle not found; expected vendor/bundle/ruby/*"
+  end
+
+  # Prefer vendored gems, fall back to system gem dir
+  ENV["GEM_HOME"] = vendor_dir
+  ENV["GEM_PATH"] = "#{vendor_dir}:#{Gem.default_dir}"
+
+  # Ensure Gem.path is updated for the running process (affects Gem.lookup)
+  Gem.use_paths(ENV["GEM_HOME"], ENV["GEM_PATH"].split(":"))
+end
+
+exec RbConfig.ruby, "-S", *ARGV

data/lib/diff/lcs/block.rb

@@ -1,37 +1,42 @@
 # frozen_string_literal: true
 
-# A block is an operation removing, adding, or changing a group of items.
-# Basically, this is just a list of changes, where each change adds or
-# deletes a single item. Used by bin/ldiff.
-class Diff::LCS::Block
-  attr_reader :changes, :insert, :remove
+Diff::LCS::Block = Data.define(:changes, :insert, :remove) # :nodoc:
 
-  def initialize(chunk)
-    @changes = []
-    @insert = []
-    @remove = []
+# A block is an operation removing, adding, or changing a group of items, a list of
+# changes, where each change adds or deletes a single item.
+#
+# Used by bin/ldiff.
+class Diff::LCS::Block
+  def self.from_chunk(chunk)
+    changes, insert, remove = [], [], []
 
-    chunk.each do |item|
-      @changes << item
-      @remove << item if item.deleting?
-      @insert << item if item.adding?
+    chunk.each do
+      changes << _1
+      remove << _1 if _1.deleting?
+      insert << _1 if _1.adding?
     end
+
+    new(changes: changes.freeze, remove: remove.freeze, insert: insert.freeze)
   end
 
-  def diff_size
-    @insert.size - @remove.size
+  class << self
+    private :new, :[]
   end
 
+  private :with
+
+  def diff_size = insert.size - remove.size
+
   def op
-    case [@remove.empty?, @insert.empty?]
-    when [false, false]
-      "!"
-    when [false, true]
-      "-"
-    when [true, false]
-      "+"
-    else # [true, true]
-      "^"
+    case [remove, insert]
+    # Unchanged
+    in [[], []] then "^"
+    # Delete
+    in [_, []] then "-"
+    # Insert
+    in [[], _] then "+"
+    # Conflict
+    in [_, _] then "!"
     end
   end
 end