diff-lcs 1.2.3 → 1.4.1

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)
@@ -45,16 +45,15 @@ class << Diff::LCS::Internals
     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]))
+    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
     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) and (b_start <= b_finish) and (a[a_finish] == b[b_finish])
       vector[a_finish] = b_finish
       a_finish -= 1
       b_finish -= 1
@@ -67,7 +66,7 @@ class << Diff::LCS::Internals
     links  = []
     string = a.kind_of?(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
@@ -77,13 +76,13 @@ class << Diff::LCS::Internals
         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
@@ -92,14 +91,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
@@ -109,29 +109,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
@@ -141,8 +140,6 @@ class << Diff::LCS::Internals
   # 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.
-  #
-  # Note: This will be deprecated as a public function in a future release.
   def intuit_diff_direction(src, patchset, limit = nil)
     string = src.kind_of?(String)
     count = left_match = left_miss = right_match = right_miss = 0
@@ -174,13 +171,11 @@ class << Diff::LCS::Internals
         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
@@ -210,11 +205,11 @@ 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]
@@ -224,11 +219,20 @@ class << Diff::LCS::Internals
     else
       case left_match <=> right_match
       when 1
-        :patch
+        if left_miss.zero?
+          :patch
+        else
+          :unpatch
+        end
       when -1
-        :unpatch
+        if right_miss.zero?
+          :unpatch
+        else
+          :patch
+        end
       else
-        raise "The provided patchset does not appear to apply to the provided value 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
@@ -251,14 +255,14 @@ class << Diff::LCS::Internals
     # Binary search for the insertion point
     last_index ||= enum.size
     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
@@ -268,7 +272,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
 

data/lib/diff/lcs/ldiff.rb

@@ -1,49 +1,21 @@
-# -*- ruby encoding: utf-8 -*-
+# 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-2013 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
+  COPYRIGHT
 end
 
 class << Diff::LCS::Ldiff
@@ -51,33 +23,42 @@ class << Diff::LCS::Ldiff
   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.on('-c', '-C', '--context [LINES]', Numeric, 'Displays a context diff with LINES lines', 'of context. Default 3 lines.') do |ctx|
+      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
-      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
       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
@@ -85,10 +66,10 @@ class << Diff::LCS::Ldiff
         return 0
       end
       o.on_tail('--version', 'Shows the version of Diff::LCS.') do
-        error << BANNER
+        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
@@ -118,15 +99,14 @@ class << Diff::LCS::Ldiff
     file_length_difference = 0
 
     if @binary.nil? or @binary
-      data_old = IO::read(file_old)
-      data_new = IO::read(file_new)
+      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
+        old_txt = data_old[0, 4096].scan(/\0/).empty?
+        new_txt = data_new[0, 4096].scan(/\0/).empty?
+        @binary = !old_txt or !new_txt
       end
 
       unless @binary
@@ -134,8 +114,8 @@ class << Diff::LCS::Ldiff
         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 }
+      data_old = IO.readlines(file_old).map { |e| e.chomp }
+      data_new = IO.readlines(file_new).map { |e| e.chomp }
     end
 
     # diff yields lots of pieces, each of which is basically a Block object
@@ -148,16 +128,16 @@ class << Diff::LCS::Ldiff
 
     return 0 unless diffs
 
-    if (@format == :report) and diffs
+    if @format == :report
       output << "Files #{file_old} and #{file_new} differ\n"
       return 1
     end
 
     if (@format == :unified) or (@format == :context)
-      ft = File.stat(file_old).mtime.localtime.strftime('%Y-%m-%d %H:%M:%S.%N %z')
-      puts "#{char_old} #{file_old}\t#{ft}"
-      ft = File.stat(file_new).mtime.localtime.strftime('%Y-%m-%d %H:%M:%S.%N %z')
-      puts "#{char_new} #{file_new}\t#{ft}"
+      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
 
     # Loop over hunks. If a hunk overlaps with the last hunk, join them.
@@ -171,12 +151,11 @@ class << Diff::LCS::Ldiff
 
     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? and hunk.merge(oldhunk)
 
         output << oldhunk.diff(@format) << "\n"
       ensure
@@ -184,12 +163,13 @@ class << Diff::LCS::Ldiff
       end
     end
 
-    output << oldhunk.diff(@format) << "\n"
+    last = oldhunk.diff(@format)
+    last << "\n" if last.respond_to?(:end_with?) && !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) } if @format == :ed
 
-    return 1
+    1
   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/spec/change_spec.rb

@@ -1,9 +1,9 @@
-# -*- ruby encoding: utf-8 -*-
+# frozen_string_literal: true
 
 require 'spec_helper'
 
 describe Diff::LCS::Change do
-  describe "an add" do
+  describe 'an add' do
     subject { described_class.new('+', 0, 'element') }
     it { should_not be_deleting   }
     it { should     be_adding     }
@@ -13,7 +13,7 @@ describe Diff::LCS::Change do
     it { should_not be_finished_b }
   end
 
-  describe "a delete" do
+  describe 'a delete' do
     subject { described_class.new('-', 0, 'element') }
     it { should     be_deleting   }
     it { should_not be_adding     }
@@ -23,7 +23,7 @@ describe Diff::LCS::Change do
     it { should_not be_finished_b }
   end
 
-  describe "an unchanged" do
+  describe 'an unchanged' do
     subject { described_class.new('=', 0, 'element') }
     it { should_not be_deleting   }
     it { should_not be_adding     }
@@ -33,7 +33,7 @@ describe Diff::LCS::Change do
     it { should_not be_finished_b }
   end
 
-  describe "a changed" do
+  describe 'a changed' do
     subject { described_class.new('!', 0, 'element') }
     it { should_not be_deleting   }
     it { should_not be_adding     }
@@ -43,7 +43,7 @@ describe Diff::LCS::Change do
     it { should_not be_finished_b }
   end
 
-  describe "a finished_a" do
+  describe 'a finished_a' do
     subject { described_class.new('>', 0, 'element') }
     it { should_not be_deleting   }
     it { should_not be_adding     }
@@ -53,7 +53,7 @@ describe Diff::LCS::Change do
     it { should_not be_finished_b }
   end
 
-  describe "a finished_b" do
+  describe 'a finished_b' do
     subject { described_class.new('<', 0, 'element') }
     it { should_not be_deleting   }
     it { should_not be_adding     }
@@ -62,4 +62,28 @@ describe Diff::LCS::Change do
     it { should_not be_finished_a }
     it { should     be_finished_b }
   end
+
+  describe 'as array' do
+    it 'should be converted' do
+      action, position, element = described_class.new('!', 0, 'element')
+      expect(action).to eq '!'
+      expect(position).to eq 0
+      expect(element).to eq 'element'
+    end
+  end
+end
+
+describe Diff::LCS::ContextChange do
+  describe 'as array' do
+    it 'should be converted' do
+      action, (old_position, old_element), (new_position, new_element) =
+        described_class.new('!', 1, 'old_element', 2, 'new_element')
+
+      expect(action).to eq '!'
+      expect(old_position).to eq 1
+      expect(old_element).to eq 'old_element'
+      expect(new_position).to eq 2
+      expect(new_element).to eq 'new_element'
+    end
+  end
 end