diff-lcs 1.1.3 → 1.5.0

data/lib/diff/lcs/internals.rb

@@ -0,0 +1,308 @@
+# frozen_string_literal: true
+
+class << Diff::LCS
+  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.kind_of? Array
+          hunk.map { |hunk_block| block[hunk_block] }
+        else
+          block[hunk]
+        end
+      end
+    else
+      callbacks.diffs
+    end
+  end
+  private :diff_traversal
+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
+  #
+  #     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)
+    a_start = b_start = 0
+    a_finish = a.size - 1
+    b_finish = b.size - 1
+    vector = []
+
+    # Collect any common elements at the beginning...
+    while (a_start <= a_finish) and (b_start <= b_finish) and (a[a_start] == b[b_start])
+      vector[a_start] = b_start
+      a_start += 1
+      b_start += 1
+    end
+
+    # Now the end...
+    while (a_start <= a_finish) and (b_start <= b_finish) and (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)
+
+    (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|
+        # 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 and (thresh[k] > j) and (thresh[k - 1] < j)
+          thresh[k] = j
+        else
+          k = replace_next_larger(thresh, j, k)
+        end
+        links[k] = [k.positive? ? links[k - 1] : nil, i, j] unless k.nil?
+      end
+    end
+
+    unless thresh.empty?
+      link = links[thresh.size - 1]
+      until link.nil?
+        vector[link[1]] = link[2]
+        link = link[0]
+      end
+    end
+
+    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)
+    fail 'Patchset too complex' if depth > 1
+
+    has_changes = false
+    new_patchset = []
+
+    # Format:
+    # [ # patchset
+    #   # hunk (change)
+    #   [ # hunk
+    #     # change
+    #   ]
+    # ]
+
+    patchset.each do |hunk|
+      case hunk
+      when Diff::LCS::Change
+        has_changes ||= !hunk.unchanged?
+        new_patchset << hunk
+      when Array
+        # 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?
+          new_patchset << hunk
+        else
+          with_changes, hunk = analyze_patchset(hunk, depth + 1)
+          has_changes ||= with_changes
+          new_patchset.concat(hunk)
+        end
+      else
+        fail ArgumentError, "Cannot normalise a hunk of class #{hunk.class}."
+      end
+    end
+
+    [has_changes, new_patchset]
+  end
+
+  # 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.kind_of?(String)
+    count = left_match = left_miss = right_match = right_miss = 0
+
+    patchset.each do |change|
+      count += 1
+
+      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]
+
+        case change.action
+        when '-' # Remove details from the old string
+          if le == change.old_element
+            left_match += 1
+          else
+            left_miss += 1
+          end
+        when '+'
+          if re == change.new_element
+            right_match += 1
+          else
+            right_miss += 1
+          end
+        when '='
+          left_miss += 1 if le != change.old_element
+          right_miss += 1 if re != change.new_element
+        when '!'
+          if le == change.old_element
+            left_match += 1
+          elsif re == change.new_element
+            right_match += 1
+          else
+            left_miss += 1
+            right_miss += 1
+          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]
+
+        case change.action
+        when '-'
+          if element == change.element
+            left_match += 1
+          else
+            left_miss += 1
+          end
+        when '+'
+          if element == change.element
+            right_match += 1
+          else
+            right_miss += 1
+          end
+        when '='
+          if element != change.element
+            left_miss += 1
+            right_miss += 1
+          end
+        end
+      end
+
+      break if !limit.nil? && (count > limit)
+    end
+
+    no_left = left_match.zero? && left_miss.positive?
+    no_right = right_match.zero? && right_miss.positive?
+
+    case [no_left, no_right]
+    when [false, true]
+      :patch
+    when [true, false]
+      :unpatch
+    else
+      case left_match <=> right_match
+      when 1
+        if left_miss.zero?
+          :patch
+        else
+          :unpatch
+        end
+      when -1
+        if right_miss.zero?
+          :unpatch
+        else
+          :patch
+        end
+      else
+        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? or (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
+
+      found = enum[i]
+
+      return nil if value == found
+
+      if value > found
+        first_index = i + 1
+      else
+        last_index = i - 1
+      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?
+    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.kind_of?(String)
+    hash = Hash.new { |h, k| h[k] = [] }
+    interval.each do |i|
+      k = string ? enum[i, 1] : enum[i]
+      hash[k] << i
+    end
+    hash
+  end
+  private :position_hash
+end

data/lib/diff/lcs/ldiff.rb

@@ -1,210 +1,171 @@
-#!/usr/bin/env ruby
+# frozen_string_literal: true
 
 require 'optparse'
 require 'ostruct'
 require 'diff/lcs/hunk'
 
-  # == ldiff Usage
-  #   ldiff [options] oldfile newfile
-  #
-  # -c::                            Displays a context diff with 3 lines of context.
-  # -C [LINES], --context [LINES]:: Displays a context diff with LINES lines of context. Default 3 lines.
-  # -u::                            Displays a unified diff with 3 lines of context.
-  # -U [LINES], --unified [LINES]:: Displays a unified diff with LINES lines of context. Default 3 lines.
-  # -e::                            Creates an 'ed' script to change oldfile to newfile.
-  # -f::                            Creates an 'ed' script to change oldfile to newfile in reverse order.
-  # -a, --text::                    Treats the files as text and compares them line-by-line, even if they do not seem to be text.
-  # --binary::                      Treats the files as binary.
-  # -q, --brief::                   Reports only whether or not the files differ, not the details.
-  # --help::                        Shows the command-line help.
-  # --version::                     Shows the version of Diff::LCS.
-  #
-  # By default, runs produces an "old-style" diff, with output like UNIX diff.
-  #
-  # == Copyright
-  # Copyright © 2004 Austin Ziegler
-  #
-  #   Part of Diff::LCS <http://rubyforge.org/projects/ruwiki/>
-  #   Austin Ziegler <diff-lcs@halostatue.ca>
-  #
-  # 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
-  # Ruby licence.
-module Diff::LCS::Ldiff
+module Diff::LCS::Ldiff #:nodoc:
   BANNER = <<-COPYRIGHT
 ldiff #{Diff::LCS::VERSION}
-  Copyright 2004-2011 Austin Ziegler
+  Copyright 2004-2019 Austin Ziegler
 
   Part of Diff::LCS.
-  http://rubyforge.org/projects/ruwiki/
-
-  Austin Ziegler <diff-lcs@halostatue.ca>
+  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.
+  COPYRIGHT
+end
 
-$Id$
-              COPYRIGHT
-
-  class << self
-    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:
-      @binary = nil
-
-      args.options do |o|
-        o.banner = "Usage: #{File.basename($0)} [options] oldfile newfile"
-        o.separator ""
-        o.on('-c', 'Displays a context diff with 3 lines of', 'context.') do |ctx|
-          @format = :context
-          @lines  = 3
-        end
-        o.on('-C', '--context [LINES]', Numeric, 'Displays a context diff with LINES lines', 'of context. Default 3 lines.') do |ctx|
-          @format = :context
-          @lines  = ctx || 3
-        end
-        o.on('-u', 'Displays a unified diff with 3 lines of', 'context.') do |ctx|
-          @format = :unified
-          @lines  = 3
-        end
-        o.on('-U', '--unified [LINES]', Numeric, 'Displays a unified diff with LINES lines', 'of context. Default 3 lines.') do |ctx|
-          @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.') do |txt|
-          @binary = false
-        end
-        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|
-          @format = :report
-        end
-        o.on_tail('--help', 'Shows this text.') do
-          error << o
-          return 0
-        end
-        o.on_tail('--version', 'Shows the version of Diff::LCS.') do
-          error << BANNER
-          return 0
-        end
-        o.on_tail ""
-        o.on_tail 'By default, runs produces an "old-style" diff, with output like UNIX diff.'
-        o.parse!
+class << Diff::LCS::Ldiff
+  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:
+    @binary = nil
+
+    args.options do |o|
+      o.banner = "Usage: #{File.basename($0)} [options] oldfile newfile"
+      o.separator ''
+      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
       end
-
-      unless args.size == 2
-        error << args.options
-        return 127
+      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
+      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.'
+      ) do |_txt|
+        @binary = false
+      end
+      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|
+        @format = :report
+      end
+      o.on_tail('--help', 'Shows this text.') do
+        error << o
+        return 0
+      end
+      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 'By default, runs produces an "old-style" diff, with output like UNIX diff.'
+      o.parse!
+    end
 
-      # Defaults are for old-style diff
-      @format ||= :old
-      @lines  ||= 0
+    unless args.size == 2
+      error << args.options
+      return 127
+    end
 
-      file_old, file_new = *ARGV
+    # Defaults are for old-style diff
+    @format ||= :old
+    @lines  ||= 0
 
-      case @format
-      when :context
-        char_old = '*' * 3
-        char_new = '-' * 3
-      when :unified
-        char_old = '-' * 3
-        char_new = '+' * 3
-      end
+    file_old, file_new = *ARGV
 
-      # 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].grep(/\0/).empty?
-          new_txt = data_new[0...4096].grep(/\0/).empty?
-          @binary = (not old_txt) or (not new_txt)
-          old_txt = new_txt = nil
-        end
-
-        unless @binary
-          data_old = data_old.split(/\n/).map! { |e| e.chomp }
-          data_new = data_new.split(/\n/).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 }
-      end
+    case @format
+    when :context
+      char_old = '*' * 3
+      char_new = '-' * 3
+    when :unified
+      char_old = '-' * 3
+      char_new = '+' * 3
+    end
 
-      # diff yields lots of pieces, each of which is basically a Block object
-      if @binary
-        diffs = (data_old == data_new)
-      else
-        diffs = Diff::LCS.diff(data_old, data_new)
-        diffs = nil if diffs.empty?
-      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
 
-      return 0 unless diffs
+    data_old = IO.read(file_old)
+    data_new = IO.read(file_new)
 
-      if (@format == :report) and diffs
-        output << "Files #{file_old} and #{file_new} differ\n"
-        return 1
-      end
+    # 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 = !old_txt || !new_txt
+    end
 
-      if (@format == :unified) or (@format == :context)
-        ft = File.stat(file_old).mtime.localtime.strftime('%Y-%m-%d %H:%M:%S %z')
-        puts "#{char_old} #{file_old}\t#{ft}"
-        ft = File.stat(file_new).mtime.localtime.strftime('%Y-%m-%d %H:%M:%S %z')
-        puts "#{char_new} #{file_new}\t#{ft}"
-      end
+    unless @binary
+      data_old = data_old.lines.to_a
+      data_new = data_new.lines.to_a
+    end
 
-      # Loop over hunks. If a hunk overlaps with the last hunk, join them.
-      # Otherwise, print out the old one.
-      oldhunk = hunk = nil
+    # diff yields lots of pieces, each of which is basically a Block object
+    if @binary
+      diffs = (data_old == data_new)
+    else
+      diffs = Diff::LCS.diff(data_old, data_new)
+      diffs = nil if diffs.empty?
+    end
 
-      if @format == :ed
-        real_output = output
-        output = []
-      end
+    return 0 unless diffs
 
-      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
-
-          next unless oldhunk
-
-          if (@lines > 0) and hunk.overlaps?(oldhunk)
-            hunk.unshift(oldhunk)
-          else
-            output << oldhunk.diff(@format)
-          end
-        ensure
-          oldhunk = hunk
-          output << "\n"
-        end
-      end
+    if @format == :report
+      output << "Files #{file_old} and #{file_new} differ\n"
+      return 1
+    end
 
-      output << oldhunk.diff(@format)
-      output << "\n"
+    if (@format == :unified) or (@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')
+      output << "#{char_new} #{file_new}\t#{ft}\n"
+    end
 
-      if @format == :ed
-        output.reverse_each { |e| real_output << e.diff(:ed_finish) }
-      end
+    # Loop over hunks. If a hunk overlaps with the last hunk, join them.
+    # Otherwise, print out the old one.
+    oldhunk = hunk = nil
 
-      return 1
+    if @format == :ed
+      real_output = output
+      output = []
     end
+
+    diffs.each do |piece|
+      begin # rubocop:disable Style/RedundantBegin
+        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? and hunk.merge(oldhunk)
+
+        output << oldhunk.diff(@format)
+        output << "\n" if @format == :unified
+      ensure
+        oldhunk = hunk
+      end
+    end
+
+    last = oldhunk.diff(@format, true)
+    last << "\n" if last.respond_to?(:end_with?) && !last.end_with?("\n")
+
+    output << last
+
+    output.reverse_each { |e| real_output << e.diff(:ed_finish) } if @format == :ed
+
+    1
   end
 end

data/lib/diff/lcs/string.rb

@@ -1,18 +1,4 @@
-#! /usr/env/bin ruby
-#--
-# Copyright 2004 Austin Ziegler <diff-lcs@halostatue.ca>
-#   adapted from:
-#     Algorithm::Diff (Perl) by Ned Konz <perl@bike-nomad.com>
-#     Smalltalk by Mario I. Wolczko <mario@wolczko.com>
-#   implements McIlroy-Hunt diff algorithm
-#
-# 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
-# Ruby licence.
-# 
-# $Id$
-#++
-# Includes Diff::LCS into String.
+# frozen_string_literal: true
 
 class String
   include Diff::LCS