diff-lcs 1.2.5 → 1.3

data/Rakefile

@@ -6,36 +6,52 @@ require 'hoe'
 
 Hoe.plugin :bundler
 Hoe.plugin :doofus
-Hoe.plugin :email
+Hoe.plugin :email unless ENV['CI'] or ENV['TRAVIS']
 Hoe.plugin :gemspec2
 Hoe.plugin :git
-Hoe.plugin :rubyforge
 Hoe.plugin :travis
 
-Hoe.spec 'diff-lcs' do
-  developer('Austin Ziegler', 'austin@rubyforge.org')
+spec = Hoe.spec 'diff-lcs' do
+  developer('Austin Ziegler', 'halostatue@gmail.com')
 
-  self.remote_rdoc_dir = '.'
-  self.rsync_args << ' --exclude=statsvn/'
+  require_ruby_version '>= 1.8'
 
-  self.history_file = 'History.rdoc'
+  self.history_file = 'History.md'
   self.readme_file = 'README.rdoc'
-  self.extra_rdoc_files = FileList["*.rdoc"].to_a
-
-  %w(MIT Perl\ Artistic\ v2 GNU\ GPL\ v2).each { |l| self.license l }
-
-  self.extra_dev_deps << ['hoe-bundler', '~> 1.2']
-  self.extra_dev_deps << ['hoe-doofus', '~> 1.0']
-  self.extra_dev_deps << ['hoe-gemspec2', '~> 1.1']
-  self.extra_dev_deps << ['hoe-git', '~> 1.5']
-  self.extra_dev_deps << ['hoe-rubygems', '~> 1.0']
-  self.extra_dev_deps << ['hoe-travis', '~> 1.2']
-  self.extra_dev_deps << ['rake', '~> 10.0']
-  self.extra_dev_deps << ['rspec', '~> 2.0']
+  self.licenses = [ 'MIT', 'Artistic-2.0', 'GPL-2.0+' ]
+
+  extra_dev_deps << ['hoe-doofus', '~> 1.0']
+  extra_dev_deps << ['hoe-gemspec2', '~> 1.1']
+  extra_dev_deps << ['hoe-git', '~> 1.6']
+  extra_dev_deps << ['hoe-rubygems', '~> 1.0']
+  extra_dev_deps << ['hoe-travis', '~> 1.2']
+  extra_dev_deps << ['rspec', '>= 2.0', '< 4']
+  extra_dev_deps << ['rake', '>= 10.0', '< 12']
+  extra_dev_deps << ['rdoc', '>= 0']
 end
 
 unless Rake::Task.task_defined? :test
   task :test => :spec
+  Rake::Task['travis'].prerequisites.replace(%w(spec))
 end
 
-# vim: syntax=ruby
+if RUBY_VERSION >= '2.0' && RUBY_ENGINE == 'ruby'
+  namespace :spec do
+    task :coveralls do
+      if ENV['CI'] or ENV['TRAVIS']
+        ENV['COVERALLS'] = 'yes'
+        Rake::Task['spec'].execute
+      else
+        Rake::Task['spec:coverage'].execute
+      end
+    end
+
+    desc "Runs test coverage. Only works Ruby 2.0+ and assumes 'simplecov' is installed."
+    task :coverage do
+      ENV['COVERAGE'] = 'yes'
+      Rake::Task['spec'].execute
+    end
+  end
+
+  # Rake::Task['travis'].prerequisites.replace(%w(spec:coveralls))
+end

data/lib/diff/lcs.rb

@@ -1,59 +1,7 @@
 # -*- ruby encoding: utf-8 -*-
 
 module Diff; end unless defined? Diff
-# = Diff::LCS 1.2.5
-#
-# Computes "intelligent" differences between two sequenced Enumerables. This
-# is an implementation of the McIlroy-Hunt "diff" algorithm for Enumerable
-# objects that include Diffable.
-#
-# Based on Mario I. Wolczko's Smalltalk version (1.2, 1993) and Ned Konz's
-# Perl version (Algorithm::Diff 1.15).
-#
-# == Synopsis
-#   require 'diff/lcs'
-#
-#   seq1 = %w(a b c e h j l m n p)
-#   seq2 = %w(b c d e f j k l m r s t)
-#
-#   lcs = Diff::LCS.lcs(seq1, seq2)
-#   diffs = Diff::LCS.diff(seq1, seq2)
-#   sdiff = Diff::LCS.sdiff(seq1, seq2)
-#   seq = Diff::LCS.traverse_sequences(seq1, seq2, callback_obj)
-#   bal = Diff::LCS.traverse_balanced(seq1, seq2, callback_obj)
-#   seq2 == Diff::LCS.patch(seq1, diffs)
-#   seq2 == Diff::LCS.patch!(seq1, diffs)
-#   seq1 == Diff::LCS.unpatch(seq2, diffs)
-#   seq1 == Diff::LCS.unpatch!(seq2, diffs)
-#   seq2 == Diff::LCS.patch(seq1, sdiff)
-#   seq2 == Diff::LCS.patch!(seq1, sdiff)
-#   seq1 == Diff::LCS.unpatch(seq2, sdiff)
-#   seq1 == Diff::LCS.unpatch!(seq2, sdiff)
-#
-# Alternatively, objects can be extended with Diff::LCS:
-#
-#   seq1.extend(Diff::LCS)
-#   lcs = seq1.lcs(seq2)
-#   diffs = seq1.diff(seq2)
-#   sdiff = seq1.sdiff(seq2)
-#   seq = seq1.traverse_sequences(seq2, callback_obj)
-#   bal = seq1.traverse_balanced(seq2, callback_obj)
-#   seq2 == seq1.patch(diffs)
-#   seq2 == seq1.patch!(diffs)
-#   seq1 == seq2.unpatch(diffs)
-#   seq1 == seq2.unpatch!(diffs)
-#   seq2 == seq1.patch(sdiff)
-#   seq2 == seq1.patch!(sdiff)
-#   seq1 == seq2.unpatch(sdiff)
-#   seq1 == seq2.unpatch!(sdiff)
-#
-# Default extensions are provided for Array and String objects through the
-# use of 'diff/lcs/array' and 'diff/lcs/string'.
-#
-# == Introduction (by Mark-Jason Dominus)
-#
-# <em>The following text is from the Perl documentation. The only changes
-# have been to make the text appear better in Rdoc</em>.
+# == How Diff Works (by Mark-Jason Dominus)
 #
 # I once read an article written by the authors of +diff+; they said that
 # they hard worked very hard on the algorithm until they found the right
@@ -100,36 +48,8 @@ module Diff; end unless defined? Diff
 #
 #          a x b y c z p d q
 #    a b c a x b y c z
-#
-# == Author
-# This version is by Austin Ziegler <austin@rubyforge.org>.
-#
-# It is based on the Perl Algorithm::Diff (1.15) by Ned Konz , copyright
-# &copy; 2000&ndash;2002 and the Smalltalk diff version by Mario I.
-# Wolczko, copyright &copy; 1993. Documentation includes work by
-# Mark-Jason Dominus.
-#
-# == Licence
-# Copyright &copy; 2004&ndash;2013 Austin Ziegler
-# This program is free software; you can redistribute it and/or modify it
-# under the same terms as Ruby, or alternatively under the Perl Artistic
-# licence.
-#
-# == Credits
-# Much of the documentation is taken directly from the Perl Algorithm::Diff
-# implementation and was written originally by Mark-Jason Dominus and later
-# by Ned Konz. The basic Ruby implementation was re-ported from the
-# Smalltalk implementation, available at
-# ftp://st.cs.uiuc.edu/pub/Smalltalk/MANCHESTER/manchester/4.0/diff.st
-#
-# #sdiff and #traverse_balanced were written for the Perl version by Mike
-# Schilli <m@perlmeister.com>.
-#
-# "The algorithm is described in <em>A Fast Algorithm for Computing Longest
-# Common Subsequences</em>, CACM, vol.20, no.5, pp.350-353, May
-# 1977, with a few minor improvements to improve the speed."
 module Diff::LCS
-  VERSION = '1.2.5'
+  VERSION = '1.3'
 end
 
 require 'diff/lcs/callbacks'
@@ -767,7 +687,7 @@ class << Diff::LCS
             ai += 1
             bj += 1
           end
-        ai += 1
+          ai += 1
         when '+'
           while bj < change.position
             res << (string ? src[ai, 1] : src[ai])
@@ -775,9 +695,9 @@ class << Diff::LCS
             bj += 1
           end
 
-        bj += 1
+          bj += 1
 
-        res << change.element
+          res << change.element
         end
       end
     end

data/lib/diff/lcs/change.rb

@@ -4,6 +4,8 @@
 # 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
+
   # 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
@@ -28,7 +30,7 @@ class Diff::LCS::Change
     unless Diff::LCS::Change.valid_action?(@action)
       raise "Invalid Change Action '#{@action}'"
     end
-    raise "Invalid Position Type" unless @position.kind_of? Fixnum
+    raise "Invalid Position Type" unless @position.kind_of? IntClass
   end
 
   def inspect
@@ -54,6 +56,7 @@ class Diff::LCS::Change
   include Comparable
 
   def ==(other)
+    (self.class == other.class) and
     (self.action == other.action) and
     (self.position == other.position) and
     (self.element == other.element)
@@ -114,10 +117,10 @@ class Diff::LCS::ContextChange < Diff::LCS::Change
     unless Diff::LCS::Change.valid_action?(@action)
       raise "Invalid Change Action '#{@action}'"
     end
-    unless @old_position.nil? or @old_position.kind_of? Fixnum
+    unless @old_position.nil? or @old_position.kind_of? IntClass
       raise "Invalid (Old) Position Type"
     end
-    unless @new_position.nil? or @new_position.kind_of? Fixnum
+    unless @new_position.nil? or @new_position.kind_of? IntClass
       raise "Invalid (New) Position Type"
     end
   end
@@ -159,6 +162,7 @@ class Diff::LCS::ContextChange < Diff::LCS::Change
   end
 
   def ==(other)
+    (self.class == other.class) and
     (@action == other.action) and
     (@old_position == other.old_position) and
     (@new_position == other.new_position) and

data/lib/diff/lcs/htmldiff.rb

@@ -115,8 +115,8 @@ h1 { margin-left: 2em; }
       formatter = Text::Format.new
       formatter.tabstop = @options[:expand_tabs]
 
-      @left = left.map { |line| formatter.expand(line.chomp) }
-      @right = right.map { |line| formatter.expand(line.chomp) }
+      @left.map! { |line| formatter.expand(line.chomp) }
+      @right.map! { |line| formatter.expand(line.chomp) }
     end
 
     @left.map! { |line| CGI.escapeHTML(line.chomp) }

data/lib/diff/lcs/internals.rb

@@ -142,8 +142,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
@@ -217,19 +215,27 @@ class << Diff::LCS::Internals
     no_left = (left_match == 0) && (left_miss > 0)
     no_right = (right_match == 0) && (right_miss > 0)
 
-    case [no_left, no_right]
-    when [false, true]
+    case [ no_left, no_right ]
+    when [ false, true ]
       :patch
-    when [true, false]
+    when [ true, false ]
       :unpatch
     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."
+        raise "The provided patchset does not appear to apply to the provided enumerable as either source or destination value."
       end
     end
   end

data/lib/diff/lcs/ldiff.rb

@@ -4,46 +4,18 @@ 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-2014 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
@@ -85,7 +57,7 @@ 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 ""
@@ -118,13 +90,13 @@ 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?
+        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
       end
@@ -134,8 +106,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
@@ -155,9 +127,9 @@ class << Diff::LCS::Ldiff
 
     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}"
+      output << "#{char_old} #{file_old}\t#{ft}\n"
       ft = File.stat(file_new).mtime.localtime.strftime('%Y-%m-%d %H:%M:%S.%N %z')
-      puts "#{char_new} #{file_new}\t#{ft}"
+      output << "#{char_new} #{file_new}\t#{ft}\n"
     end
 
     # Loop over hunks. If a hunk overlaps with the last hunk, join them.

data/spec/diff_spec.rb

@@ -2,20 +2,20 @@
 
 require 'spec_helper'
 
-describe "Diff::LCS.diff" do
+describe Diff::LCS, ".diff" do
   include Diff::LCS::SpecHelper::Matchers
 
-  it "should correctly diff seq1 to seq2" do
+  it "correctly diffs seq1 to seq2" do
     diff_s1_s2 = Diff::LCS.diff(seq1, seq2)
-    change_diff(correct_forward_diff).should == diff_s1_s2
+    expect(change_diff(correct_forward_diff)).to eq(diff_s1_s2)
   end
 
-  it "should correctly diff seq2 to seq1" do
+  it "correctly diffs seq2 to seq1" do
     diff_s2_s1 = Diff::LCS.diff(seq2, seq1)
-    change_diff(correct_backward_diff).should == diff_s2_s1
+    expect(change_diff(correct_backward_diff)).to eq(diff_s2_s1)
   end
 
-  it "should correctly diff against an empty sequence" do
+  it "correctly diffs against an empty sequence" do
     diff = Diff::LCS.diff(word_sequence, [])
     correct_diff = [
       [ [ '-', 0, 'abcd'           ],
@@ -24,24 +24,24 @@ describe "Diff::LCS.diff" do
         [ '-', 3, 'mnopqrstuvwxyz' ] ]
     ]
 
-    change_diff(correct_diff).should == diff
+    expect(change_diff(correct_diff)).to eq(diff)
 
     diff = Diff::LCS.diff([], word_sequence)
     correct_diff.each { |hunk| hunk.each { |change| change[0] = '+' } }
-    change_diff(correct_diff).should == diff
+    expect(change_diff(correct_diff)).to eq(diff)
   end
 
-  it "should correctly diff 'xx' and 'xaxb'" do
+  it "correctly diffs 'xx' and 'xaxb'" do
     left = 'xx'
     right = 'xaxb'
-    Diff::LCS.patch(left, Diff::LCS.diff(left, right)).should == right
+    expect(Diff::LCS.patch(left, Diff::LCS.diff(left, right))).to eq(right)
   end
 
-  it "should return an empty diff with (hello, hello)" do
-    Diff::LCS.diff(hello, hello).should == []
+  it "returns an empty diff with (hello, hello)" do
+    expect(Diff::LCS.diff(hello, hello)).to be_empty
   end
 
-  it "should return an empty diff with (hello_ary, hello_ary)" do
-    Diff::LCS.diff(hello_ary, hello_ary).should == []
+  it "returns an empty diff with (hello_ary, hello_ary)" do
+    expect(Diff::LCS.diff(hello_ary, hello_ary)).to be_empty
   end
 end