diff-lcs 1.6.1 → 2.0.0.beta.1

data/lib/diff/lcs/internals.rb

@@ -1,22 +1,31 @@
 # frozen_string_literal: true
 
 class << Diff::LCS
+  def callbacks_for(callbacks) # :nodoc:
+    callbacks.new
+  rescue
+    callbacks
+  end
+  private :callbacks_for
+
   def diff_traversal(method, seq1, seq2, callbacks, &block)
     callbacks = callbacks_for(callbacks)
+
     case method
     when :diff
       traverse_sequences(seq1, seq2, callbacks)
     when :sdiff
       traverse_balanced(seq1, seq2, callbacks)
     end
+
     callbacks.finish if callbacks.respond_to? :finish
 
     if block
       callbacks.diffs.map do |hunk|
         if hunk.is_a? Array
-          hunk.map { |hunk_block| block[hunk_block] }
+          hunk.map { block.call(_1) }
         else
-          block[hunk]
+          block.call(hunk)
         end
       end
     else
@@ -27,18 +36,16 @@ class << Diff::LCS
 end
 
 module Diff::LCS::Internals # :nodoc:
-end
-
-class << Diff::LCS::Internals
-  # Compute the longest common subsequence between the sequenced
-  # Enumerables +a+ and +b+. The result is an array whose contents is such
-  # that
+  # Compute the longest common subsequence between the sequenced enumerable values `a` and
+  # `b`. The result is an array whose contents is such that
   #
-  #     result = Diff::LCS::Internals.lcs(a, b)
-  #     result.each_with_index do |e, i|
-  #       assert_equal(a[i], b[e]) unless e.nil?
-  #     end
-  def lcs(a, b)
+  # ```ruby
+  # result = Diff::LCS::Internals.lcs(a, b)
+  # result.each_with_index do |e, i|
+  #   assert_equal(a[i], b[e]) unless e.nil?
+  # end
+  # ```
+  def self.lcs(a, b)
     a_start = b_start = 0
     a_finish = a.size - 1
     b_finish = b.size - 1
@@ -58,21 +65,20 @@ class << Diff::LCS::Internals
       b_finish -= 1
     end
 
-    # Now, compute the equivalence classes of positions of elements.
-    # An explanation for how this works: https://codeforces.com/topic/92191
+    # Now, compute the equivalence classes of positions of elements. An explanation for
+    # how this works: https://codeforces.com/topic/92191
     b_matches = position_hash(b, b_start..b_finish)
 
     thresh = []
     links = []
-    string = a.is_a?(String)
 
     (a_start..a_finish).each do |i|
-      ai = string ? a[i, 1] : a[i]
+      ai = a[i]
       bm = b_matches[ai]
       k = nil
       bm.reverse_each do |j|
-        # Although the threshold check is not mandatory for this to work,
-        # it may have an optimization purpose
+        # Although the threshold check is not mandatory for this to work, it may have an
+        # optimization purpose.
         # An attempt to remove it: https://github.com/halostatue/diff-lcs/pull/72
         # Why it is reintroduced: https://github.com/halostatue/diff-lcs/issues/78
         if k && (thresh[k] > j) && (thresh[k - 1] < j)
@@ -95,11 +101,10 @@ class << Diff::LCS::Internals
     vector
   end
 
-  # This method will analyze the provided patchset to provide a single-pass
-  # normalization (conversion of the array form of Diff::LCS::Change objects to
-  # the object form of same) and detection of whether the patchset represents
-  # changes to be made.
-  def analyze_patchset(patchset, depth = 0)
+  # This method will analyze the provided patchset to provide a single-pass normalization
+  # (conversion of the array form of Diff::LCS::Change objects to the object form of same)
+  # and detection of whether the patchset represents changes to be made.
+  def self.analyze_patchset(patchset, depth = 0)
     fail "Patchset too complex" if depth > 1
 
     has_changes = false
@@ -115,7 +120,7 @@ class << Diff::LCS::Internals
 
     patchset.each do |hunk|
       case hunk
-      when Diff::LCS::Change
+      when Diff::LCS::Change, Diff::LCS::ContextChange
         has_changes ||= !hunk.unchanged?
         new_patchset << hunk
       when Array
@@ -137,15 +142,13 @@ class << Diff::LCS::Internals
     [has_changes, new_patchset]
   end
 
-  # Examine the patchset and the source to see in which direction the
-  # patch should be applied.
+  # Examine the patchset and the source to see in which direction the patch should be
+  # applied.
   #
-  # WARNING: By default, this examines the whole patch, so this could take
-  # some time. This also works better with Diff::LCS::ContextChange or
-  # Diff::LCS::Change as its source, as an array will cause the creation
-  # of one of the above.
-  def intuit_diff_direction(src, patchset, limit = nil)
-    string = src.is_a?(String)
+  # WARNING: By default, this examines the whole patch, so this could take some time. This
+  # also works better with Diff::LCS::ContextChange or Diff::LCS::Change as its source, as
+  # an array will cause the creation of one of the above.
+  def self.intuit_diff_direction(src, patchset, limit = nil)
     count = left_match = left_miss = right_match = right_miss = 0
 
     patchset.each do |change|
@@ -153,8 +156,8 @@ class << Diff::LCS::Internals
 
       case change
       when Diff::LCS::ContextChange
-        le = string ? src[change.old_position, 1] : src[change.old_position]
-        re = string ? src[change.new_position, 1] : src[change.new_position]
+        le = src[change.old_position]
+        re = src[change.new_position]
 
         case change.action
         when "-" # Remove details from the old string
@@ -183,10 +186,10 @@ class << Diff::LCS::Internals
           end
         end
       when Diff::LCS::Change
-        # With a simplistic change, we can't tell the difference between
-        # the left and right on '!' actions, so we ignore those. On '='
-        # actions, if there's a miss, we miss both left and right.
-        element = string ? src[change.position, 1] : src[change.position]
+        # With a simplistic change, we can't tell the difference between the left and
+        # right on '!' actions, so we ignore those. On '=' actions, if there's a miss, we
+        # miss both left and right.
+        element = src[change.position]
 
         case change.action
         when "-"
@@ -235,74 +238,67 @@ class << Diff::LCS::Internals
           :patch
         end
       else
-        fail "The provided patchset does not appear to apply to the provided \
-enumerable as either source or destination value."
+        fail "The provided patchset does not appear to apply to the provided enumerable as either source or destination value."
       end
     end
   end
 
-  # Find the place at which +value+ would normally be inserted into the
-  # Enumerable. If that place is already occupied by +value+, do nothing
-  # and return +nil+. If the place does not exist (i.e., it is off the end
-  # of the Enumerable), add it to the end. Otherwise, replace the element
-  # at that point with +value+. It is assumed that the Enumerable's values
-  # are numeric.
-  #
-  # This operation preserves the sort order.
-  def replace_next_larger(enum, value, last_index = nil)
-    # Off the end?
-    if enum.empty? || (value > enum[-1])
-      enum << value
-      return enum.size - 1
-    end
+  class << self
+    # Find the place at which `value` would normally be inserted into the Enumerable. If
+    # that place is already occupied by `value`, do nothing and return `nil`. If the place
+    # does not exist (i.e., it is off the end of the Enumerable), add it to the end.
+    # Otherwise, replace the element at that point with `value`. It is assumed that the
+    # Enumerable's values are numeric.
+    #
+    # This operation preserves the sort order.
+    def replace_next_larger(enum, value, last_index = nil)
+      # Off the end?
+      if enum.empty? || (value > enum[-1])
+        enum << value
+        return enum.size - 1
+      end
 
-    # Binary search for the insertion point
-    last_index ||= enum.size - 1
-    first_index = 0
-    while first_index <= last_index
-      i = (first_index + last_index) >> 1
+      # Binary search for the insertion point
+      last_index ||= enum.size - 1
+      first_index = 0
+      while first_index <= last_index
+        i = (first_index + last_index) >> 1
 
-      found = enum[i]
+        found = enum[i]
 
-      return nil if value == found
+        return nil if value == found
 
-      if value > found
-        first_index = i + 1
-      else
-        last_index = i - 1
+        if value > found
+          first_index = i + 1
+        else
+          last_index = i - 1
+        end
       end
-    end
 
-    # The insertion point is in first_index; overwrite the next larger
-    # value.
-    enum[first_index] = value
-    first_index
-  end
-  private :replace_next_larger
-
-  # If +vector+ maps the matching elements of another collection onto this
-  # Enumerable, compute the inverse of +vector+ that maps this Enumerable
-  # onto the collection. (Currently unused.)
-  def inverse_vector(a, vector)
-    inverse = a.dup
-    (0...vector.size).each do |i|
-      inverse[vector[i]] = i unless vector[i].nil?
+      # The insertion point is in first_index; overwrite the next larger value.
+      enum[first_index] = value
+      first_index
     end
-    inverse
-  end
-  private :inverse_vector
-
-  # Returns a hash mapping each element of an Enumerable to the set of
-  # positions it occupies in the Enumerable, optionally restricted to the
-  # elements specified in the range of indexes specified by +interval+.
-  def position_hash(enum, interval)
-    string = enum.is_a?(String)
-    hash = Hash.new { |h, k| h[k] = [] }
-    interval.each do |i|
-      k = string ? enum[i, 1] : enum[i]
-      hash[k] << i
+    private :replace_next_larger
+
+    # If `vector` maps the matching elements of another collection onto this Enumerable,
+    # compute the inverse of `vector` that maps this Enumerable onto the collection.
+    # (Currently unused.)
+    def inverse_vector(a, vector)
+      inverse = a.dup
+      (0...vector.size).each do
+        inverse[vector[_1]] = i unless vector[_1].nil?
+      end
+      inverse
+    end
+    private :inverse_vector
+
+    # Returns a hash mapping each element of an Enumerable to the set of positions it
+    # occupies in the Enumerable, optionally restricted to the elements specified in the
+    # range of indexes specified by `interval`.
+    def position_hash(enum, interval)
+      Hash.new { |h, k| h[k] = [] }.tap { |hash| interval.each { hash[enum[_1]] << _1 } }
     end
-    hash
+    private :position_hash
   end
-  private :position_hash
 end

data/lib/diff/lcs/ldiff.rb

@@ -4,19 +4,17 @@ require "optparse"
 require "diff/lcs/hunk"
 
 class Diff::LCS::Ldiff # :nodoc:
-  # standard:disable Layout/HeredocIndentation
-  BANNER = <<-COPYRIGHT
-ldiff #{Diff::LCS::VERSION}
-  Copyright 2004-2025 Austin Ziegler
+  BANNER = <<~COPYRIGHT
+    ldiff #{Diff::LCS::VERSION}
+      Copyright 2004-2025 Austin Ziegler
 
-  Part of Diff::LCS.
-  https://github.com/halostatue/diff-lcs
+    Part of Diff::LCS.
+    https://github.com/halostatue/diff-lcs
 
-  This program is free software. It may be redistributed and/or modified under
-  the terms of the GPL version 2 (or later), the Perl Artistic licence, or the
-  MIT licence.
+    This program is free software. It may be redistributed and/or modified under
+    the terms of the GPL version 2 (or later), the Perl Artistic licence, or the
+    MIT licence.
   COPYRIGHT
-  # standard:enable Layout/HeredocIndentation
 
   InputInfo = Struct.new(:filename, :data, :stat) do
     def initialize(filename)
@@ -56,12 +54,6 @@ ldiff #{Diff::LCS::VERSION}
         @format = :unified
         @lines = ctx || 3
       end
-      o.on("-e", "Creates an 'ed' script to change", "oldfile to newfile.") do |_ctx|
-        @format = :ed
-      end
-      o.on("-f", "Creates an 'ed' script to change", "oldfile to newfile in reverse order.") do |_ctx|
-        @format = :reverse_ed
-      end
       o.on(
         "-a", "--text",
         "Treat the files as text and compare them", "line-by-line, even if they do not seem", "to be text."
@@ -117,8 +109,8 @@ ldiff #{Diff::LCS::VERSION}
       char_new = "+" * 3
     end
 
-    # After we've read up to a certain point in each file, the number of
-    # items we've read from each file will differ by FLD (could be 0).
+    # After we've read up to a certain point in each file, the number of items we've read
+    # from each file will differ by FLD (could be 0).
     file_length_difference = 0
 
     # Test binary status
@@ -155,26 +147,23 @@ ldiff #{Diff::LCS::VERSION}
       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.
+    # Loop over hunks. If a hunk overlaps with the last hunk, join them. Otherwise, print
+    # out the old one.
     oldhunk = hunk = nil
     diffs.each do |piece|
-      begin
-        hunk = Diff::LCS::Hunk.new(data_old, data_new, piece, lines, file_length_difference)
-        file_length_difference = hunk.file_length_difference
+      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 unless oldhunk
+      next if lines.positive? && hunk.merge(oldhunk)
 
-        output << oldhunk.diff(format)
-        output << "\n" if format == :unified
-      ensure
-        oldhunk = hunk
-      end
+      output << oldhunk.diff(format)
+      output << "\n" if format == :unified
+    ensure
+      oldhunk = hunk
     end
 
     last = oldhunk.diff(format, true)
@@ -182,8 +171,6 @@ ldiff #{Diff::LCS::VERSION}
 
     output << last
 
-    output.reverse_each { |e| real_output << e.diff(:ed_finish, e == output[0]) } if format == :ed
-
-    true
+    1
   end
 end

data/lib/diff/lcs/version.rb

@@ -2,6 +2,6 @@
 
 module Diff
   module LCS
-    VERSION = "1.6.1"
+    VERSION = "2.0.0.beta.1"
   end
 end