difflcs 0.6.0

data/README.txt

@@ -0,0 +1,43 @@
+= Diff Longest Common Sub String -- The diff sniffing out every move
+
+PositionRange is a library by the LogiLogi Foundation, extracted from
+http://www.logilogi.org (http://foundation.logilogi.org).
+
+== Usage
+
+== Download
+
+The latest version of Diff LCS can be found at:
+
+* http://rubyforge.org/frs/?group_id=7565
+
+Documentation can be found at:
+
+* http://difflcs.rubyonrails.org
+
+== Installation
+
+You can install Diff LCS with the following command:
+
+  % [sudo] gem install difflcs
+
+Or from its distribution directory with:
+
+  % [sudo] ruby install.rb
+
+== License
+
+Diff LCS is released under the GNU Affero GPL licence.
+
+* http://www.fsf.org/licensing/licenses/agpl-3.0.html
+
+== Support
+
+The Diff LCS homepage is http://difflcs.rubyforge.org.
+
+For the latest news on Diff LCS:
+
+* http://foundation.logilogi.org/tags/DiffLCS
+
+Feel free to submit commits or feature requests. If you send a patch,
+remember to update the corresponding unit tests.

data/Rakefile

@@ -0,0 +1,93 @@
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/packagetask'
+require 'rake/gempackagetask'
+require 'rake/contrib/sshpublisher'
+require File.join(File.dirname(__FILE__), 'lib', 'diff_l_c_s', 'version')
+
+PKG_BUILD     = ENV['PKG_BUILD'] ? '.' + ENV['PKG_BUILD'] : ''
+PKG_NAME      = 'difflcs'
+PKG_VERSION   = DiffLCS::VERSION::STRING + PKG_BUILD
+PKG_FILE_NAME = "#{PKG_NAME}-#{PKG_VERSION}"
+
+RELEASE_NAME  = "REL #{PKG_VERSION}"
+
+RUBY_FORGE_PROJECT = "difflcs"
+RUBY_FORGE_USER    = "wybo"
+
+desc "Default Task"
+task :default => [ :test ]
+
+# Run the unit tests
+Rake::TestTask.new { |t|
+  t.libs << "test"
+  t.pattern = 'test/*_test.rb'
+  t.verbose = true
+  t.warning = false
+}
+
+# Generate the RDoc documentation
+Rake::RDocTask.new { |rdoc|
+  rdoc.rdoc_dir = 'doc'
+  rdoc.title    = "Diff Longest Common Substring -- The diff sniffing out every move"
+  rdoc.options << '--line-numbers' << '--inline-source' << '-A cattr_accessor=object'
+  rdoc.options << '--charset' << 'utf-8'
+  rdoc.rdoc_files.include('README.txt', 'CHANGELOG.txt')
+  rdoc.rdoc_files.include('lib/diff_l_c_s.rb')
+  rdoc.rdoc_files.include('lib/diff_l_c_s/*.rb')
+}
+
+# Create compressed packages
+spec = Gem::Specification.new do |s|
+  s.platform = Gem::Platform::RUBY
+  s.name = PKG_NAME
+  s.summary = "Diffing that sniffs out moved text."
+  s.description = %q{A diff algoritm using longest common substrings that can also find text that has moved.}
+  s.version = PKG_VERSION
+
+  s.author = "Wybo Wiersma"
+  s.email = "wybo@logilogi.org"
+  s.rubyforge_project = "difflcs"
+  s.homepage = "http://difflcs.rubyforge.org"
+
+  s.add_dependency('positionrange', '>= 0.6.0' + PKG_BUILD)
+
+  s.has_rdoc = true
+  s.requirements << 'none'
+  s.require_path = 'lib'
+
+  s.files = [ "Rakefile", "install.rb", "README.txt", "CHANGELOG.txt", "LICENSE.txt" ]
+  s.files = s.files + Dir.glob( "lib/**/*" ).delete_if { |item| item.include?( "\.svn" ) }
+  s.files = s.files + Dir.glob( "test/**/*" ).delete_if { |item| item.include?( "\.svn" ) }
+end
+  
+Rake::GemPackageTask.new(spec) do |p|
+  p.gem_spec = spec
+  p.need_tar = true
+  p.need_zip = true
+end
+
+desc "Publish the docs, gem, and release files"
+task :deploy => [:release, :pdoc] do       
+  puts 'Published gem'
+end
+
+desc "Publish the API documentation"
+task :pdoc => [:rdoc] do
+  sh "rsync -azv --no-perms --no-times doc/*" +
+      " rubyforge.org:/var/www/gforge-projects/difflcs"
+end
+
+desc "Publish the release files to RubyForge."
+task :release => [ :package ] do
+  require 'rubyforge'
+  require 'rake/contrib/rubyforgepublisher'
+
+  packages = %w( gem tgz zip ).collect{ |ext| "pkg/#{PKG_NAME}-#{PKG_VERSION}.#{ext}" }
+
+  rubyforge = RubyForge.new.configure
+  rubyforge.login
+  rubyforge.add_release(PKG_NAME, PKG_NAME, "REL #{PKG_VERSION}", *packages)
+end

data/install.rb

@@ -0,0 +1,30 @@
+require 'rbconfig'
+require 'find'
+require 'ftools'
+
+include Config
+
+# this was adapted from rdoc's install.rb by way of Log4r
+
+$sitedir = CONFIG["sitelibdir"]
+unless $sitedir
+  version = CONFIG["MAJOR"] + "." + CONFIG["MINOR"]
+  $libdir = File.join(CONFIG["libdir"], "ruby", version)
+  $sitedir = $:.find {|x| x =~ /site_ruby/ }
+  if !$sitedir
+    $sitedir = File.join($libdir, "site_ruby")
+  elsif $sitedir !~ Regexp.quote(version)
+    $sitedir = File.join($sitedir, version)
+  end
+end
+
+# the actual gruntwork
+Dir.chdir("lib")
+
+Find.find("diff_l_c_s", "diff_l_c_s.rb") { |f|
+  if f[-3..-1] == ".rb"
+    File::install(f, File.join($sitedir, *f.split(/\//)), 0644, true)
+  else
+    File::makedirs(File.join($sitedir, *f.split(/\//)))
+  end
+}

data/lib/diff_l_c_s.rb

@@ -0,0 +1,148 @@
+#--#
+# Copyright: (c) 2006-2008 The LogiLogi Foundation <foundation@logilogi.org>
+#
+# License:
+#   This file is part of the DiffLCS library. DiffLCS is Free Software.
+#   You can run/distribute/modify DiffLCS under the terms of the GNU Affero 
+#   General Public License version 3. The Affero GPL states that running a 
+#   modified version or a derivative work also requires you to make the 
+#   sourcecode of that work available to everyone that can interact with it. 
+#   We chose the Affero GPL to ensure that DiffLCS remains open and libre 
+#   (LICENSE.txt contains the full text of the legally binding license).
+#++#
+
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+unless defined?(PositionRange)
+  begin
+    $:.unshift(File.dirname(__FILE__) + "/../../positionrange/lib")  
+    require 'position_range'
+  rescue LoadError
+    require 'rubygems'
+    gem 'positionrange'
+    require 'position_range'
+  end
+end
+
+module DiffLCS
+  # Diffs self with other, see DiffLCS#diff
+  #
+  def diff(other, options = {})
+    DiffLCS.diff(self.split(''), other.split(''), options)
+  end
+
+  # Diffs words in self with other, see DiffLCS#diff
+  #
+  # Words are non-spaces or groups of spaces delimited by either
+  # spaces or the beginning or the end of the string.
+  #
+  def word_diff(other, options = {})
+    DiffLCS.word_diff(self, other, options)
+  end
+end
+
+require 'diff_l_c_s/counter'
+require 'diff_l_c_s/word_split_array'
+
+module DiffLCS
+  class << self
+    # Diffs the current logi_version and the logi's body_text with the
+    # logi_versions body_text given and returns a hash containing:
+    #
+    # <tt>:matched_old</tt> = the position_ranges in the old text for
+    #     the places where the new matches the old.
+    # <tt>:remaining_new</tt> = the position-ranges for the part of
+    #     the new text that remains unmatched in the old
+    #
+    # Valid options are:
+    # * <tt>:minimum_lcs_size</tt> = the minimum size of LCS-es to allow
+    #
+    def diff(old_arr, new_arr, options = {})
+      minimum_lcs_size = options[:minimum_lcs_size] || 0
+      diff_hash = DiffLCS.longest_common_sub_strings(old_arr, new_arr,
+          :minimum_lcs_size => minimum_lcs_size)
+      original_matched_old = diff_hash[:matched_old]
+      matched_old = PositionRange::List.new
+      original_matched_new = diff_hash[:matched_new]
+      matched_new = original_matched_new.sort
+      i = 0
+      while i < original_matched_old.size
+        matched_old[matched_new.index(original_matched_new[i])] =
+            original_matched_old[i]
+        i += 1
+      end
+
+      return {:matched_old => matched_old,
+              :matched_new => matched_new}
+    end
+
+    # Words are non-spaces or groups of spaces delimited by either
+    # spaces or the beginning or the end of the string.
+    #
+    def word_diff(old_string, new_string, options = {})
+      old_w_s_arr = DiffLCS::WordSplitArray.new(old_string)
+      new_w_s_arr = DiffLCS::WordSplitArray.new(new_string)
+      diff = DiffLCS.diff(old_w_s_arr, new_w_s_arr, options)
+      return {:matched_old => old_w_s_arr.translate_to_pos(diff[:matched_old]),
+              :matched_new => new_w_s_arr.translate_to_pos(diff[:matched_new])}
+    end
+
+    # Returns a PositionRange::List containing pointers to the Longest
+    # Common Substrings (not Subsequences) of the Arrays or an empty
+    # PositionRange::List if none was found.
+    #
+    # Valid options are:
+    # * <tt>:minimum_lcs_size</tt> = the minimum size of LCS-es to allow
+    #
+    # The returned List is sorted by LCS-size.
+    #
+    def longest_common_sub_strings(old_arr, new_arr, options = {})
+      minimum_lcs_size = options[:minimum_lcs_size] || 0
+
+      counter_hash = Hash.new
+      counter_array = Array.new
+      old_arr.each_with_index do |old_el, old_i|
+        counter_hash[old_i] = Hash.new
+        new_arr.each_with_index do |new_el, new_i|
+          if old_el == new_el
+            if new_i > 0 and old_i > 0 and counter_hash[old_i - 1][new_i - 1]
+              counter_hash[old_i][new_i] = counter_hash[old_i - 1][new_i - 1]
+              counter_hash[old_i][new_i].step_up
+            else
+              counter = Counter.new(old_i, new_i)
+              counter_hash[old_i][new_i] = counter
+              counter_array.push(counter)
+            end
+          end
+        end
+      end
+
+      in_old_p_r_list = PositionRange::List.new
+      in_new_p_r_list = PositionRange::List.new
+
+      counter_array = counter_array.select {|co| co.step_size > minimum_lcs_size}
+
+      while counter = counter_array.sort!.pop
+        i = 0
+        while i < counter_array.size
+          if counter_array[i].in_old === counter.in_old
+            counter_array[i].in_old = counter_array[i].in_old - counter.in_old
+          end
+          if counter_array[i].in_new === counter.in_new
+            counter_array[i].in_new = counter_array[i].in_new - counter.in_new
+          end
+          if counter_array[i].size <= minimum_lcs_size
+            counter_array.delete_at(i)
+          else
+            i += 1
+          end
+        end
+        in_old_p_r_list.push(counter.in_old)
+        in_new_p_r_list.push(counter.in_new)
+      end
+      return {:matched_old => in_old_p_r_list,
+          :matched_new => in_new_p_r_list}
+    end
+  end
+end

data/lib/diff_l_c_s/counter.rb

@@ -0,0 +1,120 @@
+#--#
+# Copyright: (c) 2006-2008 The LogiLogi Foundation <foundation@logilogi.org>
+#
+# License:
+#   This file is part of the DiffLCS library. DiffLCS is Free Software.
+#   You can run/distribute/modify DiffLCS under the terms of the GNU Affero 
+#   General Public License version 3. The Affero GPL states that running a 
+#   modified version or a derivative work also requires you to make the 
+#   sourcecode of that work available to everyone that can interact with it. 
+#   We chose the Affero GPL to ensure that DiffLCS remains open and libre 
+#   (LICENSE.txt contains the full text of the legally binding license).
+#++#
+
+class DiffLCS::Counter
+  include Comparable
+
+  # Creates a new counter and sets the initial positions and size
+  #
+  def initialize(old_i, new_i)
+    @in_old_begin = old_i
+    @in_new_begin = new_i
+    @size = 1
+  end
+
+  # Increases the size
+  #
+  def step_up
+    @size += 1
+    return self
+  end
+
+  # Returns the PositionRange for the range in the old string.
+  #
+  # NOTE: No step_up's possible anymore after this function has been
+  # called.
+  #
+  def in_old
+    if !@in_old
+      @in_old = PositionRange.new(@in_old_begin, @in_old_begin + @size)
+    end
+    return @in_old
+  end
+
+  # Returns the PositionRange for the range in the new string
+  #
+  # NOTE: No step_up's possible anymore after this function has been
+  # called.
+  #
+  def in_new
+    if !@in_new
+      @in_new = PositionRange.new(@in_new_begin, @in_new_begin + @size)
+    end
+    return @in_new
+  end
+
+  # Sets the in_old PositionRange, and updates the in_new too
+  #
+  # If new_in_old is nil, the counter is set empty
+  #
+  # NOTE: Assumed to be smaller than before, and not moved.
+  #
+  def in_old=(new_in_old)
+    if new_in_old
+      @in_new = self.adjust(self.in_new, self.in_old, new_in_old)
+      @in_old = new_in_old
+    else
+      @empty = true
+    end
+  end
+
+  # Sets the in_new PositionRange, and updates the in_old too
+  #
+  # If new_in_old is nil, the counter is set empty
+  #
+  # NOTE: Assumed to be smaller than before, and not moved.
+  #
+  def in_new=(new_in_new)
+    if new_in_new
+      @in_old = self.adjust(self.in_old, self.in_new, new_in_new)
+      @in_new = new_in_new
+    else
+      @empty = true
+    end
+  end
+
+  # Faster than size, but only tells the size to which was
+  # stepped.
+  #
+  def step_size
+    return @size
+  end
+
+  # Returns the size of this Counter
+  #
+  def size
+    if @empty
+      return 0
+    else
+      return self.in_old.size
+    end
+  end
+
+  # Compares it's own size with the size of the other
+  #
+  def <=> (other)
+    return self.size <=> other.size
+  end
+
+  protected
+
+  # Helper for in_new = and in_old =
+  #
+  def adjust(to_set, other_old, other_new)
+    if other_new.end < other_old.end
+      return to_set.new_dup(to_set.begin, to_set.end - (other_old.end - other_new.end))
+    else
+      return to_set.new_dup(to_set.begin + (other_new.begin - other_old.begin), to_set.end)
+    end
+  end
+end

data/lib/diff_l_c_s/string.rb

@@ -0,0 +1,18 @@
+#--#
+# Copyright: (c) 2006-2008 The LogiLogi Foundation <foundation@logilogi.org>
+#
+# License:
+#   This file is part of the DiffLCS library. DiffLCS is Free Software.
+#   You can run/distribute/modify DiffLCS under the terms of the GNU Affero 
+#   General Public License version 3. The Affero GPL states that running a 
+#   modified version or a derivative work also requires you to make the 
+#   sourcecode of that work available to everyone that can interact with it. 
+#   We chose the Affero GPL to ensure that DiffLCS remains open and libre 
+#   (LICENSE.txt contains the full text of the legally binding license).
+#++#
+
+require 'diff_l_c_s'
+
+class String
+  include DiffLCS
+end