diff-lcs 1.4.4 → 1.5.1

data/lib/diff/lcs/hunk.rb

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
-require 'diff/lcs/block'
+require "diff/lcs/block"
 
 # A Hunk is a group of Blocks which overlap because of the context surrounding
 # each block. (So if we're not using context, every hunk will contain one
 # block.) Used in the diff program (bin/ldiff).
 class Diff::LCS::Hunk
-  OLD_DIFF_OP_ACTION = { '+' => 'a', '-' => 'd', '!' => 'c' }.freeze #:nodoc:
-  ED_DIFF_OP_ACTION = { '+' => 'a', '-' => 'd', '!' => 'c' }.freeze #:nodoc:
+  OLD_DIFF_OP_ACTION = {"+" => "a", "-" => "d", "!" => "c"}.freeze # :nodoc:
+  ED_DIFF_OP_ACTION = {"+" => "a", "-" => "d", "!" => "c"}.freeze # :nodoc:
 
   private_constant :OLD_DIFF_OP_ACTION, :ED_DIFF_OP_ACTION if respond_to?(:private_constant)
 
@@ -22,7 +22,7 @@ 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
@@ -33,7 +33,6 @@ class Diff::LCS::Hunk
     @file_length_difference = after # The caller must get this manually
     @max_diff_size = @blocks.map { |e| e.diff_size.abs }.max
 
-
     # Save the start & end of each array. If the array doesn't exist (e.g.,
     # we're only adding items in this block), then figure out the line number
     # based on the line number of the other file and the current difference in
@@ -54,8 +53,8 @@ class Diff::LCS::Hunk
 
     @start_old = a1 || (b1 - before)
     @start_new = b1 || (a1 + before)
-    @end_old   = a2 || (b2 - after)
-    @end_new   = b2 || (a2 + after)
+    @end_old = a2 || (b2 - after)
+    @end_new = b2 || (a2 + after)
 
     self.flag_context = flag_context
   end
@@ -67,12 +66,12 @@ class Diff::LCS::Hunk
 
   # Change the "start" and "end" fields to note that context should be added
   # to this hunk.
-  attr_accessor :flag_context # rubocop:disable Layout/EmptyLinesAroundAttributeAccessor
+  attr_accessor :flag_context
   undef :flag_context=
-  def flag_context=(context) #:nodoc: # rubocop:disable Lint/DuplicateMethods
-    return if context.nil? or context.zero?
+  def flag_context=(context) # :nodoc: # standard:disable Lint/DuplicateMethods
+    return if context.nil? || context.zero?
 
-    add_start = context > @start_old ? @start_old : context
+    add_start = (context > @start_old) ? @start_old : context
 
     @start_old -= add_start
     @start_new -= add_start
@@ -102,7 +101,7 @@ class Diff::LCS::Hunk
     @start_new = hunk.start_new
     blocks.unshift(*hunk.blocks)
   end
-  alias unshift merge
+  alias_method :unshift, :merge
 
   # Determines whether there is an overlap between this hunk and the
   # provided hunk. This will be true if the difference between the two hunks
@@ -133,24 +132,24 @@ 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)
-    warn 'Expecting only one block in an old diff hunk!' if @blocks.size > 1
+    warn "Expecting only one block in an old diff hunk!" if @blocks.size > 1
 
     block = @blocks[0]
 
     # 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.
-    s = encode("#{context_range(:old, ',')}#{OLD_DIFF_OP_ACTION[block.op]}#{context_range(:new, ',')}\n")
+    s = encode("#{context_range(:old, ",")}#{OLD_DIFF_OP_ACTION[block.op]}#{context_range(:new, ",")}\n")
     # If removing anything, just print out all the remove lines in the hunk
     # which is just all the remove lines in the block.
     unless block.remove.empty?
-      @data_old[@start_old..@end_old].each { |e| s << encode('< ') + e.chomp + encode("\n") }
+      @data_old[@start_old..@end_old].each { |e| s << encode("< ") + e.chomp + encode("\n") }
     end
 
-    s << encode("---\n") if block.op == '!'
+    s << encode("---\n") if block.op == "!"
 
     unless block.insert.empty?
-      @data_new[@start_new..@end_new].each { |e| s << encode('> ') + e.chomp + encode("\n") }
+      @data_new[@start_new..@end_new].each { |e| s << encode("> ") + e.chomp + encode("\n") }
     end
 
     s
@@ -172,7 +171,9 @@ class Diff::LCS::Hunk
     # file -- don't take removed items into account.
     lo, hi, num_added, num_removed = @start_old, @end_old, 0, 0
 
-    outlist = @data_old[lo..hi].map { |e| String.new("#{encode(' ')}#{e.chomp}") }
+    # standard:disable Performance/UnfreezeString
+    outlist = @data_old[lo..hi].map { |e| String.new("#{encode(" ")}#{e.chomp}") }
+    # standard:enable Performance/UnfreezeString
 
     last_block = blocks[-1]
 
@@ -183,7 +184,7 @@ class Diff::LCS::Hunk
 
     @blocks.each do |block|
       block.remove.each do |item|
-        op     = item.action.to_s # -
+        op = item.action.to_s # -
         offset = item.position - lo + num_added
         outlist[offset][0, 1] = encode(op)
         num_removed += 1
@@ -195,7 +196,7 @@ class Diff::LCS::Hunk
       end
 
       block.insert.each do |item|
-        op     = item.action.to_s # +
+        op = item.action.to_s # +
         offset = item.position - @start_new + num_removed
         outlist[offset, 0] = encode(op) + @data_new[item.position].chomp
         num_added += 1
@@ -212,8 +213,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, ",", last)} ****\n")
+    r = context_range(:new, ",", last)
 
     if last
       old_missing_newline = missing_last_newline?(@data_old)
@@ -226,7 +227,9 @@ class Diff::LCS::Hunk
     removes = @blocks.reject { |e| e.remove.empty? }
 
     unless removes.empty?
-      outlist = @data_old[lo..hi].map { |e| String.new("#{encode('  ')}#{e.chomp}") }
+      # standard:disable Performance/UnfreezeString
+      outlist = @data_old[lo..hi].map { |e| String.new("#{encode("  ")}#{e.chomp}") }
+      # standard:enable Performance/UnfreezeString
 
       last_block = removes[-1]
 
@@ -248,7 +251,9 @@ class Diff::LCS::Hunk
     inserts = @blocks.reject { |e| e.insert.empty? }
 
     unless inserts.empty?
-      outlist = @data_new[lo..hi].map { |e| String.new("#{encode('  ')}#{e.chomp}") }
+      # standard:disable Performance/UnfreezeString
+      outlist = @data_new[lo..hi].map { |e| String.new("#{encode("  ")}#{e.chomp}") }
+      # standard:enable Performance/UnfreezeString
 
       last_block = inserts[-1]
 
@@ -269,13 +274,13 @@ class Diff::LCS::Hunk
   private :context_diff
 
   def ed_diff(format, _last = false)
-    warn 'Expecting only one block in an old diff hunk!' if @blocks.size > 1
+    warn "Expecting only one block in an old diff hunk!" if @blocks.size > 1
 
     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?
@@ -301,7 +306,7 @@ class Diff::LCS::Hunk
     e -= 1 if last
     e = 1 if e.zero?
 
-    s < e ? "#{s}#{op}#{e}" : e.to_s
+    (s < e) ? "#{s}#{op}#{e}" : e.to_s
   end
   private :context_range
 
@@ -318,8 +323,8 @@ class Diff::LCS::Hunk
 
     length = e - s + (last ? 0 : 1)
 
-    first = length < 2 ? e : s # "strange, but correct"
-    length <= 1 ? first.to_s : "#{first},#{length}"
+    first = (length < 2) ? e : s # "strange, but correct"
+    (length <= 1) ? first.to_s : "#{first},#{length}"
   end
   private :unified_range
 

data/lib/diff/lcs/internals.rb

@@ -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,34 +44,38 @@ 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|
       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)
@@ -96,7 +100,7 @@ class << Diff::LCS::Internals
   # the object form of same) and detection of whether the patchset represents
   # changes to be made.
   def analyze_patchset(patchset, depth = 0)
-    fail 'Patchset too complex' if depth > 1
+    fail "Patchset too complex" if depth > 1
 
     has_changes = false
     new_patchset = []
@@ -141,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|
@@ -153,22 +157,22 @@ 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
@@ -185,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
@@ -247,13 +251,13 @@ enumerable as either source or destination value."
   # 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
       i = (first_index + last_index) >> 1
@@ -292,7 +296,7 @@ enumerable as either source or destination value."
   # 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,10 +1,11 @@
 # frozen_string_literal: true
 
-require 'optparse'
-require 'ostruct'
-require 'diff/lcs/hunk'
+require "optparse"
+require "ostruct"
+require "diff/lcs/hunk"
 
-module Diff::LCS::Ldiff #:nodoc:
+module Diff::LCS::Ldiff # :nodoc:
+  # standard:disable Layout/HeredocIndentation
   BANNER = <<-COPYRIGHT
 ldiff #{Diff::LCS::VERSION}
   Copyright 2004-2019 Austin Ziegler
@@ -16,60 +17,61 @@ ldiff #{Diff::LCS::VERSION}
   the terms of the GPL version 2 (or later), the Perl Artistic licence, or the
   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:
+  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 run(args, _input = $stdin, output = $stdout, error = $stderr) # :nodoc:
     @binary = nil
 
     args.options do |o|
       o.banner = "Usage: #{File.basename($0)} [options] oldfile newfile"
-      o.separator ''
+      o.separator ""
       o.on(
-        '-c', '-C', '--context [LINES]', Integer,
-        'Displays a context diff with LINES lines', 'of context. Default 3 lines.'
+        "-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]', Integer,
-        'Displays a unified diff with LINES lines', 'of context. Default 3 lines.'
+        "-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.'
+        "-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
-      o.on_tail ''
+      o.on_tail ""
       o.on_tail 'By default, runs produces an "old-style" diff, with output like UNIX diff.'
       o.parse!
     end
@@ -81,25 +83,25 @@ class << Diff::LCS::Ldiff
 
     # Defaults are for old-style diff
     @format ||= :old
-    @lines  ||= 0
+    @lines ||= 0
 
     file_old, file_new = *ARGV
 
     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
 
-    data_old = IO.read(file_old)
-    data_new = IO.read(file_new)
+    data_old = File.read(file_old)
+    data_new = File.read(file_new)
 
     # Test binary status
     if @binary.nil?
@@ -128,10 +130,10 @@ class << Diff::LCS::Ldiff
       return 1
     end
 
-    if (@format == :unified) or (@format == :context)
-      ft = File.stat(file_old).mtime.localtime.strftime('%Y-%m-%d %H:%M:%S.000000000 %z')
+    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')
+      ft = File.stat(file_new).mtime.localtime.strftime("%Y-%m-%d %H:%M:%S.000000000 %z")
       output << "#{char_new} #{file_new}\t#{ft}\n"
     end
 
@@ -150,7 +152,7 @@ class << Diff::LCS::Ldiff
         file_length_difference = hunk.file_length_difference
 
         next unless oldhunk
-        next if @lines.positive? and hunk.merge(oldhunk)
+        next if @lines.positive? && hunk.merge(oldhunk)
 
         output << oldhunk.diff(@format)
         output << "\n" if @format == :unified