diff-lcs 1.6.1 → 2.0.0.beta.1

data/lib/diff/lcs/change.rb

@@ -1,53 +1,49 @@
 # frozen_string_literal: true
 
-# Represents a simplistic (non-contextual) change. Represents the removal or
-# addition of an element from either the old or the new sequenced
-# enumerable.
-class Diff::LCS::Change
-  IntClass = 1.class # Fixnum is deprecated in Ruby 2.4 # standard:disable Naming/ConstantName
+Diff::LCS::Change = Data.define(:action, :position, :element) # :nodoc:
+Diff::LCS::ContextChange = Data.define(:action, :old_position, :old_element, :new_position, :new_element) # :nodoc:
 
-  # The only actions valid for changes are '+' (add), '-' (delete), '='
-  # (no change), '!' (changed), '<' (tail changes from first sequence), or
-  # '>' (tail changes from second sequence). The last two ('<>') are only
-  # found with Diff::LCS::diff and Diff::LCS::sdiff.
+# Represents a simplistic (non-contextual) change. Represents the removal or addition of
+# an element from either the old or the new sequenced enumerable.
+class Diff::LCS::Change
+  # The only actions valid for changes are '+' (add), '-' (delete), '=' (no change), '!'
+  # (changed), '<' (tail changes from first sequence), or '>' (tail changes from second
+  # sequence). The last two ('<>') are only found with Diff::LCS::diff and
+  # Diff::LCS::sdiff.
   VALID_ACTIONS = %w[+ - = ! > <].freeze
 
-  def self.valid_action?(action)
-    VALID_ACTIONS.include? action
-  end
+  def self.valid_action?(action) = VALID_ACTIONS.include?(action)
 
+  ##
   # Returns the action this Change represents.
-  attr_reader :action
+  # :attr_reader: action
 
+  ##
   # Returns the position of the Change.
-  attr_reader :position
-  # Returns the sequence element of the Change.
-  attr_reader :element
+  # :attr_reader: position
 
-  def initialize(*args)
-    @action, @position, @element = *args
+  ##
+  # Returns the sequence element of the Change.
+  # :attr_reader: element
 
-    fail "Invalid Change Action '#{@action}'" unless Diff::LCS::Change.valid_action?(@action)
-    fail "Invalid Position Type" unless @position.is_a? IntClass
-  end
+  def initialize(action:, position:, element:)
+    fail "Invalid Change Action '#{action}'" unless Diff::LCS::Change.valid_action?(action)
+    fail "Invalid Position Type" unless position.is_a?(Integer)
 
-  def inspect(*_args)
-    "#<#{self.class}: #{to_a.inspect}>"
+    super
   end
 
-  def to_a
-    [@action, @position, @element]
-  end
+  def inspect(*_args) = "#<#{self.class}: #{to_a.inspect}>"
 
+  def to_a = [action, position, element]
   alias_method :to_ary, :to_a
 
   def self.from_a(arr)
-    arr = arr.flatten(1)
-    case arr.size
-    when 5
-      Diff::LCS::ContextChange.new(*(arr[0...5]))
-    when 3
-      Diff::LCS::Change.new(*(arr[0...3]))
+    case arr
+    in [action, [old_position, old_element], [new_position, new_element]]
+      Diff::LCS::ContextChange[action, old_position, old_element, new_position, new_element]
+    in [action, position, element]
+      new(action, position, element)
     else
       fail "Invalid change array format provided."
     end
@@ -69,72 +65,57 @@ class Diff::LCS::Change
     r
   end
 
-  def adding?
-    @action == "+"
-  end
+  def adding? = action == "+"
 
-  def deleting?
-    @action == "-"
-  end
+  def deleting? = action == "-"
 
-  def unchanged?
-    @action == "="
-  end
+  def unchanged? = action == "="
 
-  def changed?
-    @action == "!"
-  end
+  def changed? = action == "!"
 
-  def finished_a?
-    @action == ">"
-  end
+  def finished_a? = action == ">"
 
-  def finished_b?
-    @action == "<"
-  end
+  def finished_b? = action == "<"
 end
 
-# Represents a contextual change. Contains the position and values of the
-# elements in the old and the new sequenced enumerables as well as the action
-# taken.
-class Diff::LCS::ContextChange < Diff::LCS::Change
-  # We don't need these two values.
-  undef :position
-  undef :element
+# Represents a contextual change. Contains the position and values of the elements in the
+# old and the new sequenced enumerable values as well as the action taken.
+class Diff::LCS::ContextChange
+  ##
+  # Returns the action this Change represents.
+  # :attr_reader: action
 
+  ##
   # Returns the old position being changed.
-  attr_reader :old_position
+  # :attr_reader: old_position
+
+  ##
   # Returns the new position being changed.
-  attr_reader :new_position
+  # :attr_reader: new_position
+
+  ##
   # Returns the old element being changed.
-  attr_reader :old_element
-  # Returns the new element being changed.
-  attr_reader :new_element
+  # :attr_reader: old_element
 
-  def initialize(*args)
-    @action, @old_position, @old_element, @new_position, @new_element = *args
+  ##
+  # Returns the new element being changed.
+  # :attr_reader: new_element
 
-    fail "Invalid Change Action '#{@action}'" unless Diff::LCS::Change.valid_action?(@action)
-    fail "Invalid (Old) Position Type" unless @old_position.nil? || @old_position.is_a?(IntClass)
-    fail "Invalid (New) Position Type" unless @new_position.nil? || @new_position.is_a?(IntClass)
-  end
+  def initialize(action:, old_position:, old_element:, new_position:, new_element:)
+    fail "Invalid Change Action '#{action}'" unless Diff::LCS::Change.valid_action?(action)
+    fail "Invalid (Old) Position Type" unless old_position.nil? || old_position.is_a?(Integer)
+    fail "Invalid (New) Position Type" unless new_position.nil? || new_position.is_a?(Integer)
 
-  def to_a
-    [
-      @action,
-      [@old_position, @old_element],
-      [@new_position, @new_element]
-    ]
+    super
   end
 
+  def to_a = [action, [old_position, old_element], [new_position, new_element]]
   alias_method :to_ary, :to_a
 
-  def self.from_a(arr)
-    Diff::LCS::Change.from_a(arr)
-  end
+  def self.from_a(arr) = Diff::LCS::Change.from_a(arr)
 
-  # Simplifies a context change for use in some diff callbacks. '<' actions
-  # are converted to '-' and '>' actions are converted to '+'.
+  # Simplifies a context change for use in some diff callbacks. '<' actions are converted
+  # to '-' and '>' actions are converted to '+'.
   def self.simplify(event)
     ea = event.to_a
 
@@ -151,24 +132,36 @@ class Diff::LCS::ContextChange < Diff::LCS::Change
       ea[1][1] = nil
     end
 
-    Diff::LCS::ContextChange.from_a(ea)
+    from_a(ea)
   end
 
   def ==(other)
-    (self.class == other.class) and
-      (@action == other.action) and
-      (@old_position == other.old_position) and
-      (@new_position == other.new_position) and
-      (@old_element == other.old_element) and
-      (@new_element == other.new_element)
+    (self.class == other.class) &&
+      (action == other.action) &&
+      (old_position == other.old_position) &&
+      (new_position == other.new_position) &&
+      (old_element == other.old_element) &&
+      (new_element == other.new_element)
   end
 
   def <=>(other)
-    r = @action <=> other.action
-    r = @old_position <=> other.old_position if r.zero?
-    r = @new_position <=> other.new_position if r.zero?
-    r = @old_element <=> other.old_element if r.zero?
-    r = @new_element <=> other.new_element if r.zero?
+    r = action <=> other.action
+    r = old_position <=> other.old_position if r.zero?
+    r = new_position <=> other.new_position if r.zero?
+    r = old_element <=> other.old_element if r.zero?
+    r = new_element <=> other.new_element if r.zero?
     r
   end
+
+  def adding? = action == "+"
+
+  def deleting? = action == "-"
+
+  def unchanged? = action == "="
+
+  def changed? = action == "!"
+
+  def finished_a? = action == ">"
+
+  def finished_b? = action == "<"
 end

data/lib/diff/lcs/hunk.rb

@@ -2,28 +2,26 @@
 
 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).
+# 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:
+  private_constant :OLD_DIFF_OP_ACTION
 
-  private_constant :OLD_DIFF_OP_ACTION, :ED_DIFF_OP_ACTION if respond_to?(:private_constant)
-
-  # Create a hunk using references to both the old and new data, as well as the
-  # piece of data.
+  # Create a hunk using references to both the old and new data, as well as the piece of
+  # data.
   def initialize(data_old, data_new, piece, flag_context, file_length_difference)
     # At first, a hunk will have just one Block in it
-    @blocks = [Diff::LCS::Block.new(piece)]
+    @blocks = [Diff::LCS::Block.from_chunk(piece)]
 
     if @blocks[0].remove.empty? && @blocks[0].insert.empty?
       fail "Cannot build a hunk from #{piece.inspect}; has no add or remove actions"
     end
 
-    if String.method_defined?(:encoding)
-      @preferred_data_encoding = data_old.fetch(0) { data_new.fetch(0) { "" } }.encoding
-    end
+    @preferred_data_encoding = data_old.fetch(0) { data_new.fetch(0) { "" } }.encoding
+    @newline = "\n".encode(@preferred_data_encoding)
+    @missing_newline = "\".encode(@preferred_data_encoding)
 
     @data_old = data_old
     @data_new = data_new
@@ -35,10 +33,9 @@ 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
-    # file lengths.
+    # Save the start and 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 file lengths.
     if @blocks[0].remove.empty?
       a1 = a2 = nil
     else
@@ -66,11 +63,13 @@ class Diff::LCS::Hunk
   attr_reader :end_old, :end_new
   attr_reader :file_length_difference
 
-  # Change the "start" and "end" fields to note that context should be added
-  # to this hunk.
-  attr_accessor :flag_context
-  undef :flag_context=
-  def flag_context=(context) # :nodoc: # standard:disable Lint/DuplicateMethods
+  ##
+  # Change the "start" and "end" fields to note that context should be added to this hunk.
+  # :attr_accessor: :flag_context
+  attr_reader :flag_context
+
+  ##
+  def flag_context=(context) # :nodoc:
     return if context.nil? || context.zero?
 
     add_start = (context > @start_old) ? @start_old : context
@@ -91,9 +90,8 @@ class Diff::LCS::Hunk
     @end_new += add_end
   end
 
-  # Merges this hunk and the provided hunk together if they overlap. Returns
-  # a truthy value so that if there is no overlap, you can know the merge
-  # was skipped.
+  # Merges this hunk and the provided hunk together if they overlap. Returns a truthy
+  # value so that if there is no overlap, you can know the merge was skipped.
   def merge(hunk)
     return unless overlaps?(hunk)
 
@@ -103,12 +101,11 @@ class Diff::LCS::Hunk
   end
   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
-  # start or end positions is within one position of each other.
+  # Determines whether there is an overlap between this hunk and the provided hunk. This
+  # will be true if the difference between the two hunks start or end positions is within
+  # one position of each other.
   def overlaps?(hunk)
-    hunk and (((@start_old - hunk.end_old) <= 1) or
-              ((@start_new - hunk.end_new) <= 1))
+    hunk && (((@start_old - hunk.end_old) <= 1) || ((@start_new - hunk.end_new) <= 1))
   end
 
   # Returns a diff string based on a format.
@@ -120,20 +117,21 @@ class Diff::LCS::Hunk
       unified_diff(last)
     when :context
       context_diff(last)
-    when :ed
-      self
-    when :reverse_ed, :ed_finish
-      ed_diff(format, last)
     else
       fail "Unknown diff format #{format}."
     end
   end
 
-  # Note that an old diff can't have any context. Therefore, we know that
-  # there's only one block in the hunk.
+  private
+
+  # 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
 
+    del, ins, sep, _ = ["< ", "> ", "---\n", "\\n"]
+      .map { _1.encode(@preferred_data_encoding) }
+
     block = @blocks[0]
 
     if last
@@ -141,47 +139,45 @@ class Diff::LCS::Hunk
       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.
-    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.
+    # 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 = "#{context_range(:old, ",")}#{OLD_DIFF_OP_ACTION[block.op]}#{context_range(:new, ",")}\n"
+      .encode(@preferred_data_encoding)
+    # 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 << del + e.chomp + @newline }
     end
 
-    s << encode("\\n") if old_missing_newline && !new_missing_newline
-    s << encode("---\n") if block.op == "!"
+    s << @missing_newline << @newline if old_missing_newline && !new_missing_newline
+    s << sep 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 << ins + e.chomp + @newline }
     end
 
-    s << encode("\\n") if new_missing_newline && !old_missing_newline
+    s << @missing_newline << @newline 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)} +#{unified_range(:new)} @@\n")
+    s = "@@ -#{unified_range(:old)} +#{unified_range(:new)} @@\n"
+      .encode(@preferred_data_encoding)
 
-    # Outlist starts containing the hunk of the old file. Removing an item
-    # just means putting a '-' in front of it. Inserting an item requires
-    # getting it from the new file and splicing it in. We splice in
-    # +num_added+ items. Remove blocks use +num_added+ because splicing
-    # changed the length of outlist.
+    # `outlist` starts containing the hunk of the old file. Removing an item just means
+    # putting a '-' in front of it. Inserting an item requires getting it from the new
+    # file and splicing it in. We splice in `num_added` items. Remove blocks use
+    # `num_added` because splicing changed the length of outlist.
     #
-    # We remove +num_removed+ items. Insert blocks use +num_removed+
-    # because their item numbers -- corresponding to positions in the NEW
-    # file -- don't take removed items into account.
+    # We remove `num_removed` items. Insert blocks use `num_removed` because their item
+    # numbers -- corresponding to positions in the NEW file -- don't take removed items
+    # into account.
     lo, hi, num_added, num_removed = @start_old, @end_old, 0, 0
 
-    # standard:disable Performance/UnfreezeString
-    outlist = @data_old[lo..hi].map { |e| String.new("#{encode(" ")}#{e.chomp}") }
-    # standard:enable Performance/UnfreezeString
+    space = " ".encode(@preferred_data_encoding)
+    outlist = @data_old[lo..hi].map { |e| "#{space}#{e.chomp}" }
 
     last_block = blocks[-1]
 
@@ -192,127 +188,92 @@ class Diff::LCS::Hunk
 
     @blocks.each do |block|
       block.remove.each do |item|
-        op = item.action.to_s # -
         offset = item.position - lo + num_added
-        outlist[offset][0, 1] = encode(op)
+        outlist[offset][0, 1] = item.action.to_s.encode(@preferred_data_encoding) # -
         num_removed += 1
       end
 
       if last && block == last_block && old_missing_newline && !new_missing_newline
-        outlist << encode('\')
+        outlist << @missing_newline
         num_removed += 1
       end
 
       block.insert.each do |item|
-        op = item.action.to_s # +
+        op = item.action.to_s.encode(@preferred_data_encoding) # +
         offset = item.position - @start_new + num_removed
-        outlist[offset, 0] = encode(op) + @data_new[item.position].chomp
+        outlist[offset, 0] = op + @data_new[item.position].chomp
         num_added += 1
       end
     end
 
-    outlist << encode('\') if last && new_missing_newline
+    outlist << @missing_newline if last && new_missing_newline
 
-    s << outlist.join(encode("\n"))
+    s << outlist.join("\n".encode(@preferred_data_encoding))
 
     s
   end
-  private :unified_diff
 
   def context_diff(last = false)
-    s = encode("***************\n")
-    s << encode("*** #{context_range(:old, ",")} ****\n")
+    s = "***************\n".encode(@preferred_data_encoding)
+    s << "*** #{context_range(:old, ",")} ****\n".encode(@preferred_data_encoding)
     r = context_range(:new, ",")
 
+    spaces = "  ".encode(@preferred_data_encoding)
+
     if last
       old_missing_newline = missing_last_newline?(@data_old)
       new_missing_newline = missing_last_newline?(@data_new)
     end
 
-    # Print out file 1 part for each block in context diff format if there
-    # are any blocks that remove items
+    # Print out file 1 part for each block in context diff format if there are any blocks
+    # that remove items
     lo, hi = @start_old, @end_old
     removes = @blocks.reject { |e| e.remove.empty? }
 
     unless removes.empty?
-      # standard:disable Performance/UnfreezeString
-      outlist = @data_old[lo..hi].map { |e| String.new("#{encode("  ")}#{e.chomp}") }
-      # standard:enable Performance/UnfreezeString
+      outlist = @data_old[lo..hi].map { |e| "#{spaces}#{e.chomp}" }
 
       last_block = removes[-1]
 
       removes.each do |block|
         block.remove.each do |item|
-          outlist[item.position - lo][0, 1] = encode(block.op) # - or !
+          outlist[item.position - lo][0, 1] = block.op.encode(@preferred_data_encoding) # - or !
         end
 
         if last && block == last_block && old_missing_newline
-          outlist << encode('\')
+          outlist << @missing_newline
         end
       end
 
-      s << outlist.join(encode("\n")) << encode("\n")
+      s << outlist.join(@newline) << @newline
     end
 
-    s << encode("--- #{r} ----\n")
+    s << "--- #{r} ----\n".encode(@preferred_data_encoding)
     lo, hi = @start_new, @end_new
     inserts = @blocks.reject { |e| e.insert.empty? }
 
     unless inserts.empty?
-      # standard:disable Performance/UnfreezeString
-      outlist = @data_new[lo..hi].map { |e| String.new("#{encode("  ")}#{e.chomp}") }
-      # standard:enable Performance/UnfreezeString
+      outlist = @data_new[lo..hi].map { |e| "#{spaces}#{e.chomp}" }
 
       last_block = inserts[-1]
 
       inserts.each do |block|
         block.insert.each do |item|
-          outlist[item.position - lo][0, 1] = encode(block.op) # + or !
+          outlist[item.position - lo][0, 1] = block.op.encode(@preferred_data_encoding) # + or !
         end
 
         if last && block == last_block && new_missing_newline
-          outlist << encode('\')
+          outlist << @missing_newline
         end
       end
-      s << outlist.join(encode("\n"))
+      s << outlist.join(@newline)
     end
 
     s
   end
-  private :context_diff
 
-  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")
-      else
-        encode("#{context_range(:old, ",")}#{ED_DIFF_OP_ACTION[@blocks[0].op]}\n")
-      end
-
-    unless @blocks[0].insert.empty?
-      @data_new[@start_new..@end_new].each do |e|
-        s << e.chomp + encode("\n")
-      end
-      s << encode(".\n")
-    end
-    s
-  end
-  private :ed_diff
-
-  # 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'
+  # 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)
     case mode
     when :old
@@ -323,57 +284,33 @@ class Diff::LCS::Hunk
 
     (s < e) ? "#{s}#{op}#{e}" : e.to_s
   end
-  private :context_range
 
-  # 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)
+  # 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)
-    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
+    s, e =
+      case mode
+      when :old
+        return "0,0" if @old_empty
+        [(@start_old + 1), (@end_old + 1)]
+      when :new
+        return "0,0" if @new_empty
+        [(@start_new + 1), (@end_new + 1)]
+      end
 
     length = e - s + 1
 
     (length <= 1) ? e.to_s : "#{s},#{length}"
   end
-  private :unified_range
 
   def missing_last_newline?(data)
-    newline = encode("\n")
-
     if data[-2]
-      data[-2].end_with?(newline) && !data[-1].end_with?(newline)
+      data[-2].end_with?(@newline) && !data[-1].end_with?(@newline)
     elsif data[-1]
-      !data[-1].end_with?(newline)
+      !data[-1].end_with?(@newline)
     else
       true
     end
   end
-
-  if String.method_defined?(:encoding)
-    def encode(literal, target_encoding = @preferred_data_encoding)
-      literal.encode target_encoding
-    end
-
-    def encode_as(string, *args)
-      args.map { |arg| arg.encode(string.encoding) }
-    end
-  else
-    def encode(literal, _target_encoding = nil)
-      literal
-    end
-
-    def encode_as(_string, *args)
-      args
-    end
-  end
-
-  private :encode
-  private :encode_as
 end