diff-lcs 1.5.1 → 1.6.0

data/lib/diff/lcs/hunk.rb

@@ -22,11 +22,13 @@ class Diff::LCS::Hunk
     end
 
     if String.method_defined?(:encoding)
-      @preferred_data_encoding = data_old.fetch(0) { data_new.fetch(0, "") }.encoding
+      @preferred_data_encoding = data_old.fetch(0) { data_new.fetch(0) { "" } }.encoding
     end
 
     @data_old = data_old
     @data_new = data_new
+    @old_empty = data_old.empty? || (data_old.size == 1 && data_old[0].empty?)
+    @new_empty = data_new.empty? || (data_new.size == 1 && data_new[0].empty?)
 
     before = after = file_length_difference
     after += @blocks[0].diff_size
@@ -79,14 +81,12 @@ class Diff::LCS::Hunk
     old_size = @data_old.size
 
     add_end =
-      if (@end_old + context) > old_size
-        old_size - @end_old
+      if (@end_old + context) >= old_size
+        old_size - @end_old - 1
       else
         context
       end
 
-    add_end = @max_diff_size if add_end >= old_size
-
     @end_old += add_end
     @end_new += add_end
   end
@@ -131,11 +131,16 @@ class Diff::LCS::Hunk
 
   # Note that an old diff can't have any context. Therefore, we know that
   # there's only one block in the hunk.
-  def old_diff(_last = false)
+  def old_diff(last = false)
     warn "Expecting only one block in an old diff hunk!" if @blocks.size > 1
 
     block = @blocks[0]
 
+    if last
+      old_missing_newline = !@old_empty && missing_last_newline?(@data_old)
+      new_missing_newline = !@new_empty && missing_last_newline?(@data_new)
+    end
+
     # Calculate item number range. Old diff range is just like a context
     # diff range, except the ranges are on one line with the action between
     # them.
@@ -146,19 +151,22 @@ class Diff::LCS::Hunk
       @data_old[@start_old..@end_old].each { |e| s << encode("< ") + e.chomp + encode("\n") }
     end
 
+    s << encode("\\n") if old_missing_newline && !new_missing_newline
     s << encode("---\n") if block.op == "!"
 
     unless block.insert.empty?
       @data_new[@start_new..@end_new].each { |e| s << encode("> ") + e.chomp + encode("\n") }
     end
 
+    s << encode("\\n") if new_missing_newline && !old_missing_newline
+
     s
   end
   private :old_diff
 
   def unified_diff(last = false)
     # Calculate item number range.
-    s = encode("@@ -#{unified_range(:old, last)} +#{unified_range(:new, last)} @@\n")
+    s = encode("@@ -#{unified_range(:old)} +#{unified_range(:new)} @@\n")
 
     # Outlist starts containing the hunk of the old file. Removing an item
     # just means putting a '-' in front of it. Inserting an item requires
@@ -178,8 +186,8 @@ class Diff::LCS::Hunk
     last_block = blocks[-1]
 
     if last
-      old_missing_newline = missing_last_newline?(@data_old)
-      new_missing_newline = missing_last_newline?(@data_new)
+      old_missing_newline = !@old_empty && missing_last_newline?(@data_old)
+      new_missing_newline = !@new_empty && missing_last_newline?(@data_new)
     end
 
     @blocks.each do |block|
@@ -213,8 +221,8 @@ class Diff::LCS::Hunk
 
   def context_diff(last = false)
     s = encode("***************\n")
-    s << encode("*** #{context_range(:old, ",", last)} ****\n")
-    r = context_range(:new, ",", last)
+    s << encode("*** #{context_range(:old, ",")} ****\n")
+    r = context_range(:new, ",")
 
     if last
       old_missing_newline = missing_last_newline?(@data_old)
@@ -273,14 +281,24 @@ class Diff::LCS::Hunk
   end
   private :context_diff
 
-  def ed_diff(format, _last = false)
+  def ed_diff(format, last)
     warn "Expecting only one block in an old diff hunk!" if @blocks.size > 1
+    if last
+      # ed script doesn't support well incomplete lines
+      warn "<old_file>: No newline at end of file\n" if !@old_empty && missing_last_newline?(@data_old)
+      warn "<new_file>: No newline at end of file\n" if !@new_empty && missing_last_newline?(@data_new)
+
+      if @blocks[0].op == "!"
+        return +"" if @blocks[0].changes[0].element == @blocks[0].changes[1].element + "\n"
+        return +"" if @blocks[0].changes[0].element + "\n" == @blocks[0].changes[1].element
+      end
+    end
 
     s =
       if format == :reverse_ed
-        encode("#{ED_DIFF_OP_ACTION[@blocks[0].op]}#{context_range(:old, ",")}\n")
+        encode("#{ED_DIFF_OP_ACTION[@blocks[0].op]}#{context_range(:old, " ")}\n")
       else
-        encode("#{context_range(:old, " ")}#{ED_DIFF_OP_ACTION[@blocks[0].op]}\n")
+        encode("#{context_range(:old, ",")}#{ED_DIFF_OP_ACTION[@blocks[0].op]}\n")
       end
 
     unless @blocks[0].insert.empty?
@@ -295,7 +313,7 @@ class Diff::LCS::Hunk
 
   # Generate a range of item numbers to print. Only print 1 number if the
   # range has only one item in it. Otherwise, it's 'start,end'
-  def context_range(mode, op, last = false)
+  def context_range(mode, op)
     case mode
     when :old
       s, e = (@start_old + 1), (@end_old + 1)
@@ -303,9 +321,6 @@ class Diff::LCS::Hunk
       s, e = (@start_new + 1), (@end_new + 1)
     end
 
-    e -= 1 if last
-    e = 1 if e.zero?
-
     (s < e) ? "#{s}#{op}#{e}" : e.to_s
   end
   private :context_range
@@ -313,18 +328,19 @@ class Diff::LCS::Hunk
   # Generate a range of item numbers to print for unified diff. Print number
   # where block starts, followed by number of lines in the block
   # (don't print number of lines if it's 1)
-  def unified_range(mode, last)
+  def unified_range(mode)
     case mode
     when :old
+      return "0,0" if @old_empty
       s, e = (@start_old + 1), (@end_old + 1)
     when :new
+      return "0,0" if @new_empty
       s, e = (@start_new + 1), (@end_new + 1)
     end
 
-    length = e - s + (last ? 0 : 1)
+    length = e - s + 1
 
-    first = (length < 2) ? e : s # "strange, but correct"
-    (length <= 1) ? first.to_s : "#{first},#{length}"
+    (length <= 1) ? e.to_s : "#{s},#{length}"
   end
   private :unified_range
 

data/lib/diff/lcs/ldiff.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "optparse"
-require "ostruct"
 require "diff/lcs/hunk"
 
 module Diff::LCS::Ldiff # :nodoc:
@@ -18,14 +17,20 @@ ldiff #{Diff::LCS::VERSION}
   MIT licence.
   COPYRIGHT
   # standard:enable Layout/HeredocIndentation
-end
 
-class << Diff::LCS::Ldiff
-  attr_reader :format, :lines # :nodoc:
-  attr_reader :file_old, :file_new # :nodoc:
-  attr_reader :data_old, :data_new # :nodoc:
+  InputInfo = Struct.new(:filename, :data, :stat) do
+    def initialize(filename)
+      super(filename, ::File.read(filename), ::File.stat(filename))
+    end
+  end
+
+  class << self
+    attr_reader :format, :lines # :nodoc:
+    attr_reader :file_old, :file_new # :nodoc:
+    attr_reader :data_old, :data_new # :nodoc:
+  end
 
-  def run(args, _input = $stdin, output = $stdout, error = $stderr) # :nodoc:
+  def self.run(args, _input = $stdin, output = $stdout, error = $stderr) # :nodoc:
     @binary = nil
 
     args.options do |o|
@@ -86,8 +91,18 @@ class << Diff::LCS::Ldiff
     @lines ||= 0
 
     file_old, file_new = *ARGV
+    diff?(
+      InputInfo.new(file_old),
+      InputInfo.new(file_new),
+      @format,
+      output,
+      binary: @binary,
+      lines: @lines
+    ) ? 1 : 0
+  end
 
-    case @format
+  def self.diff?(info_old, info_new, format, output, binary: nil, lines: 0)
+    case format
     when :context
       char_old = "*" * 3
       char_new = "-" * 3
@@ -100,74 +115,69 @@ class << Diff::LCS::Ldiff
     # items we've read from each file will differ by FLD (could be 0).
     file_length_difference = 0
 
-    data_old = File.read(file_old)
-    data_new = File.read(file_new)
-
     # Test binary status
-    if @binary.nil?
-      old_txt = data_old[0, 4096].scan(/\0/).empty?
-      new_txt = data_new[0, 4096].scan(/\0/).empty?
-      @binary = !old_txt || !new_txt
-    end
-
-    unless @binary
-      data_old = data_old.lines.to_a
-      data_new = data_new.lines.to_a
+    if binary.nil?
+      old_bin = info_old.data[0, 4096].include?("\0")
+      new_bin = info_new.data[0, 4096].include?("\0")
+      binary = old_bin || new_bin
     end
 
     # diff yields lots of pieces, each of which is basically a Block object
-    if @binary
-      diffs = (data_old == data_new)
+    if binary
+      has_diffs = (info_old.data != info_new.data)
+      if format != :report
+        if has_diffs
+          output << "Binary files #{info_old.filename} and #{info_new.filename} differ\n"
+          return true
+        end
+        return false
+      end
     else
+      data_old = info_old.data.lines.to_a
+      data_new = info_new.data.lines.to_a
       diffs = Diff::LCS.diff(data_old, data_new)
-      diffs = nil if diffs.empty?
+      return false if diffs.empty?
     end
 
-    return 0 unless diffs
-
-    if @format == :report
-      output << "Files #{file_old} and #{file_new} differ\n"
-      return 1
-    end
-
-    if (@format == :unified) || (@format == :context)
-      ft = File.stat(file_old).mtime.localtime.strftime("%Y-%m-%d %H:%M:%S.000000000 %z")
-      output << "#{char_old} #{file_old}\t#{ft}\n"
-      ft = File.stat(file_new).mtime.localtime.strftime("%Y-%m-%d %H:%M:%S.000000000 %z")
-      output << "#{char_new} #{file_new}\t#{ft}\n"
+    case format
+    when :report
+      output << "Files #{info_old.filename} and #{info_new.filename} differ\n"
+      return true
+    when :unified, :context
+      ft = info_old.stat.mtime.localtime.strftime("%Y-%m-%d %H:%M:%S.000000000 %z")
+      output << "#{char_old} #{info_old.filename}\t#{ft}\n"
+      ft = info_new.stat.mtime.localtime.strftime("%Y-%m-%d %H:%M:%S.000000000 %z")
+      output << "#{char_new} #{info_new.filename}\t#{ft}\n"
+    when :ed
+      real_output = output
+      output = []
     end
 
     # Loop over hunks. If a hunk overlaps with the last hunk, join them.
     # Otherwise, print out the old one.
     oldhunk = hunk = nil
-
-    if @format == :ed
-      real_output = output
-      output = []
-    end
-
     diffs.each do |piece|
-      begin # rubocop:disable Style/RedundantBegin
-        hunk = Diff::LCS::Hunk.new(data_old, data_new, piece, @lines, file_length_difference)
+      begin
+        hunk = Diff::LCS::Hunk.new(data_old, data_new, piece, lines, file_length_difference)
         file_length_difference = hunk.file_length_difference
 
         next unless oldhunk
-        next if @lines.positive? && hunk.merge(oldhunk)
+        next if lines.positive? && hunk.merge(oldhunk)
 
-        output << oldhunk.diff(@format)
-        output << "\n" if @format == :unified
+        output << oldhunk.diff(format)
+        output << "\n" if format == :unified
       ensure
         oldhunk = hunk
       end
     end
 
-    last = oldhunk.diff(@format, true)
-    last << "\n" if last.respond_to?(:end_with?) && !last.end_with?("\n")
+    last = oldhunk.diff(format, true)
+    last << "\n" unless last.is_a?(Diff::LCS::Hunk) || last.empty? || last.end_with?("\n")
 
     output << last
 
-    output.reverse_each { |e| real_output << e.diff(:ed_finish) } if @format == :ed
+    output.reverse_each { |e| real_output << e.diff(:ed_finish, e == output[0]) } if format == :ed
 
-    1
+    true
   end
 end

data/lib/diff/lcs.rb

@@ -49,7 +49,7 @@ module Diff; end unless defined? Diff
 #          a x b y c z p d q
 #    a b c a x b y c z
 module Diff::LCS
-  VERSION = "1.5.1"
+  VERSION = "1.6.0"
 end
 
 require "diff/lcs/callbacks"
@@ -62,11 +62,12 @@ module Diff::LCS
   #   lcs = seq1.lcs(seq2)
   #
   # A note when using objects: Diff::LCS only works properly when each object
-  # can be used as a key in a Hash, which typically means that the objects must
-  # implement Object#eql? in a way that two identical values compare
-  # identically for key purposes. That is:
+  # can be used as a key in a Hash. This means that those objects must implement
+  # the methods +#hash+ and +#eql?+ such that two objects containing identical values
+  # compare identically for key purposes. That is:
   #
-  #   O.new('a').eql?(O.new('a')) == true
+  #   O.new('a').eql?(O.new('a')) == true &&
+  #   O.new('a').hash == O.new('a').hash
   def lcs(other, &block) # :yields: self[i] if there are matched subsequences
     Diff::LCS.lcs(self, other, &block)
   end
@@ -256,7 +257,7 @@ class << Diff::LCS
   #
   # The methods for <tt>callbacks#match</tt>, <tt>callbacks#discard_a</tt>, and
   # <tt>callbacks#discard_b</tt> are invoked with an event comprising the
-  # action ("=", "+", or "-", respectively), the indicies +i+ and +j+, and the
+  # action ("=", "+", or "-", respectively), the indexes +i+ and +j+, and the
   # elements <tt>A[i]</tt> and <tt>B[j]</tt>. Return values are discarded by
   # #traverse_sequences.
   #
@@ -421,7 +422,7 @@ class << Diff::LCS
   #                                 occurred.
   #
   # #traverse_balanced might be a bit slower than #traverse_sequences,
-  # noticable only while processing huge amounts of data.
+  # noticeable only while processing huge amounts of data.
   #
   # == Algorithm
   #
@@ -465,7 +466,7 @@ class << Diff::LCS
   # The methods for <tt>callbacks#match</tt>, <tt>callbacks#discard_a</tt>,
   # <tt>callbacks#discard_b</tt>, and <tt>callbacks#change</tt> are invoked
   # with an event comprising the action ("=", "+", "-", or "!", respectively),
-  # the indicies +i+ and +j+, and the elements <tt>A[i]</tt> and <tt>B[j]</tt>.
+  # the indexes +i+ and +j+, and the elements <tt>A[i]</tt> and <tt>B[j]</tt>.
   # Return values are discarded by #traverse_balanced.
   #
   # === Context
@@ -482,7 +483,7 @@ class << Diff::LCS
 
     # Process all the lines in the match vector.
     loop do
-      # Find next match indices +ma+ and +mb+
+      # Find next match indexes +ma+ and +mb+
       loop do
         ma += 1
         break unless ma < matches.size && matches[ma].nil?

data/spec/hunk_spec.rb

@@ -72,7 +72,7 @@ if String.method_defined?(:encoding)
 
       it "produces a unified diff" do
         expected = <<-EXPECTED.gsub(/^\s+/, "").encode("UTF-16LE").chomp
-          @@ -1 +1,2 @@
+          @@ -0,0 +1 @@
           +Tu a un carte avec {count} items
         EXPECTED
 

data/spec/issues_spec.rb

@@ -68,38 +68,6 @@ describe "Diff::LCS Issues" do
     end
   end
 
-  describe "issue #60" do
-    it "should produce unified output with correct context" do
-      # standard:disable Layout/HeredocIndentation
-      old_data = <<-DATA_OLD.strip.split("\n").map(&:chomp)
-{
-  "name": "x",
-  "description": "hi"
-}
-      DATA_OLD
-
-      new_data = <<-DATA_NEW.strip.split("\n").map(&:chomp)
-{
-  "name": "x",
-  "description": "lo"
-}
-      DATA_NEW
-
-      diff = ::Diff::LCS.diff(old_data, new_data)
-      hunk = ::Diff::LCS::Hunk.new(old_data, new_data, diff.first, 3, 0)
-
-      expect(hunk.diff(:unified)).to eq(<<-EXPECTED.chomp)
-@@ -1,5 +1,5 @@
- {
-   "name": "x",
--  "description": "hi"
-+  "description": "lo"
- }
-      EXPECTED
-      # standard:enable Layout/HeredocIndentation
-    end
-  end
-
   describe "issue #65" do
     def diff_lines(old_lines, new_lines)
       file_length_difference = 0
@@ -157,4 +125,36 @@ describe "Diff::LCS Issues" do
       # standard:enable Layout/HeredocIndentation
     end
   end
+
+  describe "issue #107 (replaces issue #60)" do
+    it "should produce unified output with correct context" do
+      # standard:disable Layout/HeredocIndentation
+      old_data = <<-DATA_OLD.strip.split("\n").map(&:chomp)
+{
+  "name": "x",
+  "description": "hi"
+}
+      DATA_OLD
+
+      new_data = <<-DATA_NEW.strip.split("\n").map(&:chomp)
+{
+  "name": "x",
+  "description": "lo"
+}
+      DATA_NEW
+
+      diff = ::Diff::LCS.diff(old_data, new_data)
+      hunk = ::Diff::LCS::Hunk.new(old_data, new_data, diff.first, 3, 0)
+
+      expect(hunk.diff(:unified)).to eq(<<-EXPECTED.chomp)
+@@ -1,4 +1,4 @@
+ {
+   "name": "x",
+-  "description": "hi"
++  "description": "lo"
+ }
+      EXPECTED
+      # standard:enable Layout/HeredocIndentation
+    end
+  end
 end

data/spec/ldiff_spec.rb

@@ -7,9 +7,16 @@ RSpec.describe "bin/ldiff" do
 
   # standard:disable Style/HashSyntax
   fixtures = [
-    {:name => "output.diff", :left => "aX", :right => "bXaX"},
-    {:name => "output.diff.chef", :left => "old-chef", :right => "new-chef"},
-    {:name => "output.diff.chef2", :left => "old-chef2", :right => "new-chef2"}
+    {:name => "diff", :left => "aX", :right => "bXaX", :diff => 1},
+    {:name => "diff.missing_new_line1", :left => "four_lines", :right => "four_lines_with_missing_new_line", :diff => 1},
+    {:name => "diff.missing_new_line2", :left => "four_lines_with_missing_new_line", :right => "four_lines", :diff => 1},
+    {:name => "diff.issue95_trailing_context", :left => "123_x", :right => "456_x", :diff => 1},
+    {:name => "diff.four_lines.vs.empty", :left => "four_lines", :right => "empty", :diff => 1},
+    {:name => "diff.empty.vs.four_lines", :left => "empty", :right => "four_lines", :diff => 1},
+    {:name => "diff.bin1", :left => "file1.bin", :right => "file1.bin", :diff => 0},
+    {:name => "diff.bin2", :left => "file1.bin", :right => "file2.bin", :diff => 1},
+    {:name => "diff.chef", :left => "old-chef", :right => "new-chef", :diff => 1},
+    {:name => "diff.chef2", :left => "old-chef2", :right => "new-chef2", :diff => 1}
   ].product([nil, "-e", "-f", "-c", "-u"]).map { |(fixture, flag)|
     fixture = fixture.dup
     fixture[:flag] = flag
@@ -24,11 +31,14 @@ RSpec.describe "bin/ldiff" do
       "spec/fixtures/#{fixture[:right]}",
       "#",
       "=>",
-      "spec/fixtures/ldiff/#{fixture[:name]}#{fixture[:flag]}"
+      "spec/fixtures/ldiff/output.#{fixture[:name]}#{fixture[:flag]}"
     ].join(" ")
 
     it desc do
-      expect(run_ldiff(fixture)).to eq(read_fixture(fixture))
+      stdout, stderr, status = run_ldiff(fixture)
+      expect(status).to eq(fixture[:diff])
+      expect(stderr).to eq(read_fixture(fixture, mode: "error", allow_missing: true))
+      expect(stdout).to eq(read_fixture(fixture, mode: "output", allow_missing: false))
     end
   end
 
@@ -36,10 +46,13 @@ RSpec.describe "bin/ldiff" do
     test_ldiff(fixture)
   end
 
-  def read_fixture(options)
+  def read_fixture(options, mode: "output", allow_missing: false)
     fixture = options.fetch(:name)
     flag = options.fetch(:flag)
-    name = "spec/fixtures/ldiff/#{fixture}#{flag}"
+    name = "spec/fixtures/ldiff/#{mode}.#{fixture}#{flag}"
+
+    return "" if !::File.exist?(name) && allow_missing
+
     data = IO.__send__(IO.respond_to?(:binread) ? :binread : :read, name)
     clean_data(data, flag)
   end
@@ -82,8 +95,6 @@ RSpec.describe "bin/ldiff" do
       system("ruby -Ilib bin/ldiff #{flag} spec/fixtures/#{left} spec/fixtures/#{right}")
     end
 
-    expect(stderr).to be_empty if RUBY_VERSION >= "1.9"
-    expect(stdout).not_to be_empty
-    clean_data(stdout, flag)
+    [clean_data(stdout, flag), stderr, $?.exitstatus]
   end
 end

data/spec/patch_spec.rb

@@ -181,7 +181,7 @@ describe "Diff::LCS.patch" do
   # above.
   describe "fix bug 891: patchsets do not contain the last equal part" do
     before :each do
-      @s1 = %w[a b c d   e f g h i j k] # rubocop:disable Layout/SpaceInsideArrayPercentLiteral
+      @s1 = %w[a b c d   e f g h i j k] # standard:disable Layout/SpaceInsideArrayPercentLiteral
       @s2 = %w[a b c d D e f g h i j k]
     end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: diff-lcs
 version: !ruby/object:Gem::Version
-  version: 1.5.1
+  version: 1.6.0
 platform: ruby
 authors:
 - Austin Ziegler
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-01-31 00:00:00.000000000 Z
+date: 2025-02-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: hoe
@@ -146,20 +146,34 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '7'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.21'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.21'
 description: |-
   Diff::LCS computes the difference between two Enumerable sequences using the
   McIlroy-Hunt longest common subsequence (LCS) algorithm. It includes utilities
   to create a simple HTML diff output format and a standard diff-like tool.
 
   This is release 1.4.3, providing a simple extension that allows for
-  Diff::LCS::Change objects to be treated implicitly as arrays and fixes a
-  number of formatting issues.
+  Diff::LCS::Change objects to be treated implicitly as arrays and fixes a number
+  of formatting issues.
 
-  Ruby versions below 2.5 are soft-deprecated, which means that older versions
-  are no longer part of the CI test suite. If any changes have been introduced
-  that break those versions, bug reports and patches will be accepted, but it
-  will be up to the reporter to verify any fixes prior to release. The next
-  major release will completely break compatibility.
+  Ruby versions below 2.5 are soft-deprecated, which means that older versions are
+  no longer part of the CI test suite. If any changes have been introduced that
+  break those versions, bug reports and patches will be accepted, but it will be
+  up to the reporter to verify any fixes prior to release. The next major release
+  will completely break compatibility.
 email:
 - halostatue@gmail.com
 executables:
@@ -167,23 +181,29 @@ executables:
 - ldiff
 extensions: []
 extra_rdoc_files:
-- Code-of-Conduct.md
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- CONTRIBUTING.md
+- CONTRIBUTORS.md
 - Contributing.md
-- History.md
-- License.md
+- LICENCE.md
 - Manifest.txt
-- README.rdoc
+- README.md
+- SECURITY.md
 - docs/COPYING.txt
 - docs/artistic.txt
 files:
 - ".rspec"
-- Code-of-Conduct.md
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- CONTRIBUTING.md
+- CONTRIBUTORS.md
 - Contributing.md
-- History.md
-- License.md
+- LICENCE.md
 - Manifest.txt
-- README.rdoc
+- README.md
 - Rakefile
+- SECURITY.md
 - bin/htmldiff
 - bin/ldiff
 - docs/COPYING.txt
@@ -238,17 +258,15 @@ files:
 homepage: https://github.com/halostatue/diff-lcs
 licenses:
 - MIT
-- Artistic-2.0
+- Artistic-1.0-Perl
 - GPL-2.0-or-later
 metadata:
-  homepage_uri: https://github.com/halostatue/diff-lcs
-  source_code_uri: https://github.com/halostatue/diff-lcs
-  bug_tracker_uri: https://github.com/halostatue/diff-lcs/issues
   rubygems_mfa_required: 'true'
+  changelog_uri: https://github.com/halostatue/diff-lcs/blob/main/CHANGELOG.md
 post_install_message:
 rdoc_options:
 - "--main"
-- README.rdoc
+- README.md
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
@@ -262,7 +280,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.3
+rubygems_version: 3.5.22
 signing_key:
 specification_version: 4
 summary: Diff::LCS computes the difference between two Enumerable sequences using