diff-lcs 1.3 → 1.6.2

data/lib/diff/lcs/internals.rb

@@ -1,4 +1,4 @@
-# -*- ruby encoding: utf-8 -*-
+# frozen_string_literal: true
 
 class << Diff::LCS
   def diff_traversal(method, seq1, seq2, callbacks, &block)
@@ -13,7 +13,7 @@ class << Diff::LCS
 
     if block
       callbacks.diffs.map do |hunk|
-        if hunk.kind_of? Array
+        if hunk.is_a? Array
           hunk.map { |hunk_block| block[hunk_block] }
         else
           block[hunk]
@@ -44,47 +44,49 @@ class << Diff::LCS::Internals
     b_finish = b.size - 1
     vector = []
 
-    # Prune off any common elements at the beginning...
-    while ((a_start <= a_finish) and (b_start <= b_finish) and
-           (a[a_start] == b[b_start]))
+    # Collect any common elements at the beginning...
+    while (a_start <= a_finish) && (b_start <= b_finish) && (a[a_start] == b[b_start])
       vector[a_start] = b_start
       a_start += 1
       b_start += 1
     end
-    b_start = a_start
 
     # Now the end...
-    while ((a_start <= a_finish) and (b_start <= b_finish) and
-           (a[a_finish] == b[b_finish]))
+    while (a_start <= a_finish) && (b_start <= b_finish) && (a[a_finish] == b[b_finish])
       vector[a_finish] = b_finish
       a_finish -= 1
       b_finish -= 1
     end
 
     # 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.kind_of?(String)
+    links = []
+    string = a.is_a?(String)
 
-    (a_start .. a_finish).each do |i|
+    (a_start..a_finish).each do |i|
       ai = string ? a[i, 1] : a[i]
       bm = b_matches[ai]
       k = nil
       bm.reverse_each do |j|
-        if k and (thresh[k] > j) and (thresh[k - 1] < j)
+        # 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)
           thresh[k] = j
         else
           k = replace_next_larger(thresh, j, k)
         end
-        links[k] = [ (k > 0) ? links[k - 1] : nil, i, j ] unless k.nil?
+        links[k] = [k.positive? ? links[k - 1] : nil, i, j] unless k.nil?
       end
     end
 
     unless thresh.empty?
       link = links[thresh.size - 1]
-      while not link.nil?
+      until link.nil?
         vector[link[1]] = link[2]
         link = link[0]
       end
@@ -93,14 +95,15 @@ 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.
+  # 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)
-    raise "Patchset too complex" if depth > 1
+    fail "Patchset too complex" if depth > 1
 
     has_changes = false
+    new_patchset = []
 
     # Format:
     # [ # patchset
@@ -110,29 +113,28 @@ class << Diff::LCS::Internals
     #   ]
     # ]
 
-    patchset = patchset.map do |hunk|
+    patchset.each do |hunk|
       case hunk
       when Diff::LCS::Change
         has_changes ||= !hunk.unchanged?
-        hunk
+        new_patchset << hunk
       when Array
-        # Detect if the 'hunk' is actually an array-format
-        # Change object.
+        # Detect if the 'hunk' is actually an array-format change object.
         if Diff::LCS::Change.valid_action? hunk[0]
           hunk = Diff::LCS::Change.from_a(hunk)
           has_changes ||= !hunk.unchanged?
-          hunk
+          new_patchset << hunk
         else
           with_changes, hunk = analyze_patchset(hunk, depth + 1)
           has_changes ||= with_changes
-          hunk.flatten
+          new_patchset.concat(hunk)
         end
       else
-        raise ArgumentError, "Cannot normalise a hunk of class #{hunk.class}."
+        fail ArgumentError, "Cannot normalise a hunk of class #{hunk.class}."
       end
     end
 
-    [ has_changes, patchset.flatten(1) ]
+    [has_changes, new_patchset]
   end
 
   # Examine the patchset and the source to see in which direction the
@@ -143,7 +145,7 @@ class << Diff::LCS::Internals
   # 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.kind_of?(String)
+    string = src.is_a?(String)
     count = left_match = left_miss = right_match = right_miss = 0
 
     patchset.each do |change|
@@ -155,31 +157,29 @@ class << Diff::LCS::Internals
         re = string ? src[change.new_position, 1] : src[change.new_position]
 
         case change.action
-        when '-' # Remove details from the old string
+        when "-" # Remove details from the old string
           if le == change.old_element
             left_match += 1
           else
             left_miss += 1
           end
-        when '+'
+        when "+"
           if re == change.new_element
             right_match += 1
           else
             right_miss += 1
           end
-        when '='
+        when "="
           left_miss += 1 if le != change.old_element
           right_miss += 1 if re != change.new_element
-        when '!'
+        when "!"
           if le == change.old_element
             left_match += 1
+          elsif re == change.new_element
+            right_match += 1
           else
-            if re == change.new_element
-              right_match += 1
-            else
-              left_miss += 1
-              right_miss += 1
-            end
+            left_miss += 1
+            right_miss += 1
           end
         end
       when Diff::LCS::Change
@@ -189,19 +189,19 @@ class << Diff::LCS::Internals
         element = string ? src[change.position, 1] : src[change.position]
 
         case change.action
-        when '-'
+        when "-"
           if element == change.element
             left_match += 1
           else
             left_miss += 1
           end
-        when '+'
+        when "+"
           if element == change.element
             right_match += 1
           else
             right_miss += 1
           end
-        when '='
+        when "="
           if element != change.element
             left_miss += 1
             right_miss += 1
@@ -209,16 +209,16 @@ class << Diff::LCS::Internals
         end
       end
 
-      break if (not limit.nil?) && (count > limit)
+      break if !limit.nil? && (count > limit)
     end
 
-    no_left = (left_match == 0) && (left_miss > 0)
-    no_right = (right_match == 0) && (right_miss > 0)
+    no_left = left_match.zero? && left_miss.positive?
+    no_right = right_match.zero? && right_miss.positive?
 
-    case [ no_left, no_right ]
-    when [ false, true ]
+    case [no_left, no_right]
+    when [false, true]
       :patch
-    when [ true, false ]
+    when [true, false]
       :unpatch
     else
       case left_match <=> right_match
@@ -235,7 +235,8 @@ class << Diff::LCS::Internals
           :patch
         end
       else
-        raise "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
@@ -250,22 +251,22 @@ class << Diff::LCS::Internals
   # This operation preserves the sort order.
   def replace_next_larger(enum, value, last_index = nil)
     # Off the end?
-    if enum.empty? or (value > enum[-1])
+    if enum.empty? || (value > enum[-1])
       enum << value
       return enum.size - 1
     end
 
     # Binary search for the insertion point
-    last_index ||= enum.size
+    last_index ||= enum.size - 1
     first_index = 0
-    while (first_index <= last_index)
+    while first_index <= last_index
       i = (first_index + last_index) >> 1
 
       found = enum[i]
 
-      if value == found
-        return nil
-      elsif value > found
+      return nil if value == found
+
+      if value > found
         first_index = i + 1
       else
         last_index = i - 1
@@ -275,7 +276,7 @@ class << Diff::LCS::Internals
     # The insertion point is in first_index; overwrite the next larger
     # value.
     enum[first_index] = value
-    return first_index
+    first_index
   end
   private :replace_next_larger
 
@@ -295,7 +296,7 @@ class << Diff::LCS::Internals
   # 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.kind_of?(String)
+    string = enum.is_a?(String)
     hash = Hash.new { |h, k| h[k] = [] }
     interval.each do |i|
       k = string ? enum[i, 1] : enum[i]

data/lib/diff/lcs/ldiff.rb

@@ -1,13 +1,13 @@
-# -*- ruby encoding: utf-8 -*-
+# frozen_string_literal: true
 
-require 'optparse'
-require 'ostruct'
-require 'diff/lcs/hunk'
+require "optparse"
+require "diff/lcs/hunk"
 
-module Diff::LCS::Ldiff #:nodoc:
+class Diff::LCS::Ldiff # :nodoc:
+  # standard:disable Layout/HeredocIndentation
   BANNER = <<-COPYRIGHT
 ldiff #{Diff::LCS::VERSION}
-  Copyright 2004-2014 Austin Ziegler
+  Copyright 2004-2025 Austin Ziegler
 
   Part of Diff::LCS.
   https://github.com/halostatue/diff-lcs
@@ -15,48 +15,70 @@ ldiff #{Diff::LCS::VERSION}
   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
-end
+  COPYRIGHT
+  # standard:enable Layout/HeredocIndentation
+
+  InputInfo = Struct.new(:filename, :data, :stat) do
+    def initialize(filename)
+      super(filename, ::File.read(filename), ::File.stat(filename))
+    end
+  end
 
-class << Diff::LCS::Ldiff
-  attr_reader :format, :lines #:nodoc:
-  attr_reader :file_old, :file_new #:nodoc:
-  attr_reader :data_old, :data_new #:nodoc:
+  attr_reader :format, :lines # :nodoc:
+  attr_reader :file_old, :file_new # :nodoc:
+  attr_reader :data_old, :data_new # :nodoc:
 
-  def run(args, input = $stdin, output = $stdout, error = $stderr) #:nodoc:
+  def self.run(args, input = $stdin, output = $stdout, error = $stderr) # :nodoc:
+    new.run(args, input, output, error)
+  end
+
+  def initialize
     @binary = nil
+    @format = :old
+    @lines = 0
+  end
 
+  def run(args, _input = $stdin, output = $stdout, error = $stderr) # :nodoc:
     args.options do |o|
       o.banner = "Usage: #{File.basename($0)} [options] oldfile newfile"
       o.separator ""
-      o.on('-c', '-C', '--context [LINES]', Numeric, 'Displays a context diff with LINES lines', 'of context. Default 3 lines.') do |ctx|
+      o.on(
+        "-c", "-C", "--context [LINES]", Integer,
+        "Displays a context diff with LINES lines", "of context. Default 3 lines."
+      ) do |ctx|
         @format = :context
-        @lines  = ctx || 3
+        @lines = ctx || 3
       end
-      o.on('-u', '-U', '--unified [LINES]', Numeric, 'Displays a unified diff with LINES lines', 'of context. Default 3 lines.') do |ctx|
+      o.on(
+        "-u", "-U", "--unified [LINES]", Integer,
+        "Displays a unified diff with LINES lines", "of context. Default 3 lines."
+      ) do |ctx|
         @format = :unified
-        @lines  = ctx || 3
+        @lines = ctx || 3
       end
-      o.on('-e', 'Creates an \'ed\' script to change', 'oldfile to newfile.') do |ctx|
+      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|
+      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.') do |txt|
+      o.on(
+        "-a", "--text",
+        "Treat the files as text and compare them", "line-by-line, even if they do not seem", "to be text."
+      ) do |_txt|
         @binary = false
       end
-      o.on('--binary', 'Treats the files as binary.') do |bin|
+      o.on("--binary", "Treats the files as binary.") do |_bin|
         @binary = true
       end
-      o.on('-q', '--brief', 'Report only whether or not the files', 'differ, not the details.') do |ctx|
+      o.on("-q", "--brief", "Report only whether or not the files", "differ, not the details.") do |_ctx|
         @format = :report
       end
-      o.on_tail('--help', 'Shows this text.') do
+      o.on_tail("--help", "Shows this text.") do
         error << o
         return 0
       end
-      o.on_tail('--version', 'Shows the version of Diff::LCS.') do
+      o.on_tail("--version", "Shows the version of Diff::LCS.") do
         error << Diff::LCS::Ldiff::BANNER
         return 0
       end
@@ -72,96 +94,96 @@ class << Diff::LCS::Ldiff
 
     # Defaults are for old-style diff
     @format ||= :old
-    @lines  ||= 0
+    @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 diff?(info_old, info_new, format, output, binary: nil, lines: 0)
+    case format
     when :context
-      char_old = '*' * 3
-      char_new = '-' * 3
+      char_old = "*" * 3
+      char_new = "-" * 3
     when :unified
-      char_old = '-' * 3
-      char_new = '+' * 3
+      char_old = "-" * 3
+      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).
     file_length_difference = 0
 
-    if @binary.nil? or @binary
-      data_old = IO.read(file_old)
-      data_new = IO.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 = (not old_txt) or (not new_txt)
-        old_txt = new_txt = nil
-      end
-
-      unless @binary
-        data_old = data_old.split($/).map { |e| e.chomp }
-        data_new = data_new.split($/).map { |e| e.chomp }
-      end
-    else
-      data_old = IO.readlines(file_old).map { |e| e.chomp }
-      data_new = IO.readlines(file_new).map { |e| e.chomp }
+    # Test binary status
+    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?
-    end
-
-    return 0 unless diffs
-
-    if @format == :report
-      output << "Files #{file_old} and #{file_new} differ\n"
-      return 1
+      return false if diffs.empty?
     end
 
-    if (@format == :unified) or (@format == :context)
-      ft = File.stat(file_old).mtime.localtime.strftime('%Y-%m-%d %H:%M:%S.%N %z')
-      output << "#{char_old} #{file_old}\t#{ft}\n"
-      ft = File.stat(file_new).mtime.localtime.strftime('%Y-%m-%d %H:%M:%S.%N %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
-        hunk = Diff::LCS::Hunk.new(data_old, data_new, piece, @lines,
-                                   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 > 0) and hunk.merge(oldhunk)
+        next if lines.positive? && hunk.merge(oldhunk)
 
-        output << oldhunk.diff(@format) << "\n"
+        output << oldhunk.diff(format)
+        output << "\n" if format == :unified
       ensure
         oldhunk = hunk
       end
     end
 
-    output << oldhunk.diff(@format) << "\n"
+    last = oldhunk.diff(format, true)
+    last << "\n" unless last.is_a?(Diff::LCS::Hunk) || last.empty? || last.end_with?("\n")
 
-    if @format == :ed
-      output.reverse_each { |e| real_output << e.diff(:ed_finish) }
-    end
+    output << last
+
+    output.reverse_each { |e| real_output << e.diff(:ed_finish, e == output[0]) } if format == :ed
 
-    return 1
+    true
   end
 end

data/lib/diff/lcs/string.rb

@@ -1,4 +1,4 @@
-# -*- ruby encoding: utf-8 -*-
+# frozen_string_literal: true
 
 class String
   include Diff::LCS

data/lib/diff/lcs/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Diff
+  module LCS
+    VERSION = "1.6.2"
+  end
+end