RubyGems - diff-lcs - Versions diffs - 1.3 → 1.5.1 - Mend

diff-lcs 1.3 → 1.5.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (56) hide show

checksums.yaml +5 -5
data/Contributing.md +86 -48
data/History.md +370 -159
data/License.md +6 -4
data/Manifest.txt +23 -1
data/README.rdoc +10 -10
data/Rakefile +109 -36
data/bin/htmldiff +9 -6
data/bin/ldiff +4 -1
data/lib/diff/lcs/array.rb +2 -2
data/lib/diff/lcs/backports.rb +9 -0
data/lib/diff/lcs/block.rb +5 -5
data/lib/diff/lcs/callbacks.rb +22 -17
data/lib/diff/lcs/change.rb +42 -49
data/lib/diff/lcs/htmldiff.rb +21 -12
data/lib/diff/lcs/hunk.rb +160 -73
data/lib/diff/lcs/internals.rb +57 -56
data/lib/diff/lcs/ldiff.rb +63 -57
data/lib/diff/lcs/string.rb +1 -1
data/lib/diff/lcs.rb +226 -210
data/lib/diff-lcs.rb +2 -2
data/spec/change_spec.rb +58 -34
data/spec/diff_spec.rb +13 -9
data/spec/fixtures/aX +1 -0
data/spec/fixtures/bXaX +1 -0
data/spec/fixtures/ldiff/output.diff +4 -0
data/spec/fixtures/ldiff/output.diff-c +7 -0
data/spec/fixtures/ldiff/output.diff-e +3 -0
data/spec/fixtures/ldiff/output.diff-f +3 -0
data/spec/fixtures/ldiff/output.diff-u +5 -0
data/spec/fixtures/ldiff/output.diff.chef +4 -0
data/spec/fixtures/ldiff/output.diff.chef-c +15 -0
data/spec/fixtures/ldiff/output.diff.chef-e +3 -0
data/spec/fixtures/ldiff/output.diff.chef-f +3 -0
data/spec/fixtures/ldiff/output.diff.chef-u +9 -0
data/spec/fixtures/ldiff/output.diff.chef2 +7 -0
data/spec/fixtures/ldiff/output.diff.chef2-c +20 -0
data/spec/fixtures/ldiff/output.diff.chef2-d +7 -0
data/spec/fixtures/ldiff/output.diff.chef2-e +7 -0
data/spec/fixtures/ldiff/output.diff.chef2-f +7 -0
data/spec/fixtures/ldiff/output.diff.chef2-u +16 -0
data/spec/fixtures/new-chef +4 -0
data/spec/fixtures/new-chef2 +17 -0
data/spec/fixtures/old-chef +4 -0
data/spec/fixtures/old-chef2 +14 -0
data/spec/hunk_spec.rb +48 -37
data/spec/issues_spec.rb +132 -21
data/spec/lcs_spec.rb +3 -3
data/spec/ldiff_spec.rb +74 -32
data/spec/patch_spec.rb +14 -20
data/spec/sdiff_spec.rb +83 -81
data/spec/spec_helper.rb +146 -91
data/spec/traverse_balanced_spec.rb +138 -136
data/spec/traverse_sequences_spec.rb +7 -9
metadata +76 -48
data/autotest/discover.rb +0 -1

data/lib/diff/lcs/htmldiff.rb CHANGED Viewed

@@ -1,14 +1,15 @@
-# -*- ruby encoding: utf-8 -*-
+# frozen_string_literal: true
-require 'cgi'
+require "cgi"
+# Produce a simple HTML diff view.
 class Diff::LCS::HTMLDiff
   class << self
-    attr_accessor :can_expand_tabs #:nodoc:
+    attr_accessor :can_expand_tabs # :nodoc:
   end
   self.can_expand_tabs = true
-  class Callbacks
+  class Callbacks # :nodoc:
     attr_accessor :output
     attr_accessor :match_class
     attr_accessor :only_a_class
@@ -25,7 +26,7 @@ class Diff::LCS::HTMLDiff
     def htmlize(element, css_class)
       element = "&nbsp;" if element.empty?
-      %Q|<pre class="#{__send__(css_class)}">#{element}</pre>\n|
+      %(<pre class="#{__send__(css_class)}">#{element}</pre>\n)
     end
     private :htmlize
@@ -45,13 +46,16 @@ class Diff::LCS::HTMLDiff
     end
   end
+  # standard:disable Style/HashSyntax
   DEFAULT_OPTIONS = {
     :expand_tabs => nil,
     :output => nil,
     :css => nil,
-    :title => nil,
-  }
+    :title => nil
+  }.freeze
+  # standard:enable Style/HashSyntax
+  # standard:disable Layout/HeredocIndentation
   DEFAULT_CSS = <<-CSS
 body { margin: 0; }
 .diff
@@ -85,18 +89,19 @@ pre
 }
 h1 { margin-left: 2em; }
   CSS
+  # standard:enable Layout/HeredocIndentation
   def initialize(left, right, options = nil)
-    @left     = left
-    @right    = right
-    @options  = options
+    @left = left
+    @right = right
+    @options = options
     @options = DEFAULT_OPTIONS.dup if @options.nil?
   end
   def verify_options
     @options[:expand_tabs] ||= 4
-    @options[:expand_tabs] = 4 if @options[:expand_tabs] < 0
+    @options[:expand_tabs] = 4 if @options[:expand_tabs].negative?
     @options[:output] ||= $stdout
@@ -111,7 +116,7 @@ h1 { margin-left: 2em; }
   def run
     verify_options
-    if @options[:expand_tabs] > 0 && self.class.can_expand_tabs
+    if @options[:expand_tabs].positive? && self.class.can_expand_tabs
       formatter = Text::Format.new
       formatter.tabstop = @options[:expand_tabs]
@@ -122,6 +127,7 @@ h1 { margin-left: 2em; }
     @left.map! { |line| CGI.escapeHTML(line.chomp) }
     @right.map! { |line| CGI.escapeHTML(line.chomp) }
+    # standard:disable Layout/HeredocIndentation
     @options[:output] << <<-OUTPUT
 <html>
   <head>
@@ -136,14 +142,17 @@ h1 { margin-left: 2em; }
     <span class="only_b">Only in New</span></p>
     <div class="diff">
     OUTPUT
+    # standard:enable Layout/HeredocIndentation
     callbacks = Callbacks.new(@options[:output])
     Diff::LCS.traverse_sequences(@left, @right, callbacks)
+    # standard:disable Layout/HeredocIndentation
     @options[:output] << <<-OUTPUT
     </div>
   </body>
 </html>
     OUTPUT
+    # standard:enable Layout/HeredocIndentation
   end
 end

data/lib/diff/lcs/hunk.rb CHANGED Viewed

@@ -1,30 +1,42 @@
-# -*- ruby encoding: utf-8 -*-
+# 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/diff).
+# 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
-  # Create a hunk using references to both the old and new data, as well as
-  # the piece of data.
+  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)
+  # 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.new(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
+      @preferred_data_encoding = data_old.fetch(0) { data_new.fetch(0, "") }.encoding
     end
     @data_old = data_old
     @data_new = data_new
     before = after = file_length_difference
     after += @blocks[0].diff_size
     @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.
+    # 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
@@ -41,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
@@ -55,19 +67,26 @@ class Diff::LCS::Hunk
   # 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:
-    return if context.nil? or context.zero?
+  undef :flag_context=
+  def flag_context=(context) # :nodoc: # standard:disable Lint/DuplicateMethods
+    return if context.nil? || context.zero?
     add_start = (context > @start_old) ? @start_old : context
     @start_old -= add_start
     @start_new -= add_start
-    if (@end_old + context) > @data_old.size
-      add_end = @data_old.size - @end_old
-    else
-      add_end = context
-    end
+    old_size = @data_old.size
+    add_end =
+      if (@end_old + context) > old_size
+        old_size - @end_old
+      else
+        context
+      end
+    add_end = @max_diff_size if add_end >= old_size
     @end_old += add_end
     @end_new += add_end
   end
@@ -76,13 +95,11 @@ class Diff::LCS::Hunk
   # a truthy value so that if there is no overlap, you can know the merge
   # was skipped.
   def merge(hunk)
-    if overlaps?(hunk)
-      @start_old = hunk.start_old
-      @start_new = hunk.start_new
-      blocks.unshift(*hunk.blocks)
-    else
-      nil
-    end
+    return unless overlaps?(hunk)
+    @start_old = hunk.start_old
+    @start_new = hunk.start_new
+    blocks.unshift(*hunk.blocks)
   end
   alias_method :unshift, :merge
@@ -95,47 +112,53 @@ class Diff::LCS::Hunk
   end
   # Returns a diff string based on a format.
-  def diff(format)
+  def diff(format, last = false)
     case format
     when :old
-      old_diff
+      old_diff(last)
     when :unified
-      unified_diff
+      unified_diff(last)
     when :context
-      context_diff
+      context_diff(last)
     when :ed
       self
     when :reverse_ed, :ed_finish
-      ed_diff(format)
+      ed_diff(format, last)
     else
-      raise "Unknown diff format #{format}."
+      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.
-  def old_diff
+  def old_diff(_last = false)
     warn "Expecting only one block in an old diff hunk!" if @blocks.size > 1
-    op_act = { "+" => 'a', "-" => 'd', "!" => "c" }
     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)}#{op_act[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.
-    @data_old[@start_old .. @end_old].each { |e| s << encode("< ") + e + encode("\n") } unless block.remove.empty?
+    unless block.remove.empty?
+      @data_old[@start_old..@end_old].each { |e| s << encode("< ") + e.chomp + encode("\n") }
+    end
     s << encode("---\n") if block.op == "!"
-    @data_new[@start_new .. @end_new].each { |e| s << encode("> ") + e + encode("\n") } unless block.insert.empty?
+    unless block.insert.empty?
+      @data_new[@start_new..@end_new].each { |e| s << encode("> ") + e.chomp + encode("\n") }
+    end
     s
   end
   private :old_diff
-  def unified_diff
+  def unified_diff(last = false)
     # Calculate item number range.
-    s = encode("@@ -#{unified_range(:old)} +#{unified_range(:new)} @@\n")
+    s = encode("@@ -#{unified_range(:old, last)} +#{unified_range(:new, last)} @@\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
@@ -148,75 +171,122 @@ 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| e.insert(0, encode(' ')) }
+    # standard:disable Performance/UnfreezeString
+    outlist = @data_old[lo..hi].map { |e| String.new("#{encode(" ")}#{e.chomp}") }
+    # standard:enable Performance/UnfreezeString
+    last_block = blocks[-1]
+    if last
+      old_missing_newline = missing_last_newline?(@data_old)
+      new_missing_newline = missing_last_newline?(@data_new)
+    end
     @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
       end
+      if last && block == last_block && old_missing_newline && !new_missing_newline
+        outlist << encode('\')
+        num_removed += 1
+      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]
+        outlist[offset, 0] = encode(op) + @data_new[item.position].chomp
         num_added += 1
       end
     end
+    outlist << encode('\') if last && new_missing_newline
     s << outlist.join(encode("\n"))
+    s
   end
   private :unified_diff
-  def context_diff
+  def context_diff(last = false)
     s = encode("***************\n")
-    s << encode("*** #{context_range(:old)} ****\n")
-    r = context_range(:new)
+    s << encode("*** #{context_range(:old, ",", last)} ****\n")
+    r = context_range(:new, ",", last)
+    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
     lo, hi = @start_old, @end_old
-    removes = @blocks.select { |e| not e.remove.empty? }
-    if removes
-      outlist = @data_old[lo .. hi].map { |e| e.insert(0, encode(' ')) }
+    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
+      last_block = removes[-1]
       removes.each do |block|
         block.remove.each do |item|
           outlist[item.position - lo][0, 1] = encode(block.op) # - or !
         end
+        if last && block == last_block && old_missing_newline
+          outlist << encode('\')
+        end
       end
-      s << outlist.join("\n")
+      s << outlist.join(encode("\n")) << encode("\n")
     end
-    s << encode("\n--- #{r} ----\n")
+    s << encode("--- #{r} ----\n")
     lo, hi = @start_new, @end_new
-    inserts = @blocks.select { |e| not e.insert.empty? }
-    if inserts
-      outlist = @data_new[lo .. hi].collect { |e| e.insert(0, encode(' ')) }
+    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
+      last_block = inserts[-1]
       inserts.each do |block|
         block.insert.each do |item|
           outlist[item.position - lo][0, 1] = encode(block.op) # + or !
         end
+        if last && block == last_block && new_missing_newline
+          outlist << encode('\')
+        end
       end
-      s << outlist.join("\n")
+      s << outlist.join(encode("\n"))
     end
     s
   end
   private :context_diff
-  def ed_diff(format)
-    op_act = { "+" => 'a', "-" => 'd', "!" => "c" }
+  def ed_diff(format, _last = false)
     warn "Expecting only one block in an old diff hunk!" if @blocks.size > 1
-    if format == :reverse_ed
-      s = encode("#{op_act[@blocks[0].op]}#{context_range(:old)}\n")
-    else
-      s = encode("#{context_range(:old, ' ')}#{op_act[@blocks[0].op]}\n")
-    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 { |e| s << e + encode("\n") }
+      @data_new[@start_new..@end_new].each do |e|
+        s << e.chomp + encode("\n")
+      end
       s << encode(".\n")
     end
     s
@@ -225,7 +295,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 = ',')
+  def context_range(mode, op, last = false)
     case mode
     when :old
       s, e = (@start_old + 1), (@end_old + 1)
@@ -233,14 +303,17 @@ class Diff::LCS::Hunk
       s, e = (@start_new + 1), (@end_new + 1)
     end
-    (s < e) ? "#{s}#{op}#{e}" : "#{e}"
+    e -= 1 if last
+    e = 1 if e.zero?
+    (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)
-  def unified_range(mode)
+  def unified_range(mode, last)
     case mode
     when :old
       s, e = (@start_old + 1), (@end_old + 1)
@@ -248,12 +321,25 @@ class Diff::LCS::Hunk
       s, e = (@start_new + 1), (@end_new + 1)
     end
-    length = e - s + 1
+    length = e - s + (last ? 0 : 1)
     first = (length < 2) ? e : s # "strange, but correct"
-    (length == 1) ? "#{first}" : "#{first},#{length}"
+    (length <= 1) ? first.to_s : "#{first},#{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)
+    elsif data[-1]
+      !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
@@ -263,10 +349,11 @@ class Diff::LCS::Hunk
       args.map { |arg| arg.encode(string.encoding) }
     end
   else
-    def encode(literal, target_encoding = nil)
+    def encode(literal, _target_encoding = nil)
       literal
     end
-    def encode_as(string, *args)
+    def encode_as(_string, *args)
       args
     end
   end