jacobat-htmldiff 0.0.2

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Nathan Herald
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1,9 @@
+HTMLDiff.diff('a word is here', 'a nother word is there')
+# => 'a<ins class=\"diffins\"> nother</ins> word is <del class=\"diffmod\">here</del><ins class=\"diffmod\">there</ins>'
+
+
+HTMLDiff.textdiff('a word is here', 'a nother word is there')
+# => a[++ nother++] word is [--here--][++there++]
+
+
+Checkout the crappy specs for good examples. 

data/Rakefile

@@ -0,0 +1,57 @@
+require 'rubygems'
+require 'rake/gempackagetask'
+require 'rubygems/specification'
+require 'date'
+require 'spec/rake/spectask'
+
+GEM = "jacobat-htmldiff"
+GEM_VERSION = "0.0.2"
+AUTHOR = "Nathan Herald"
+EMAIL = "nathan@myobie.com"
+HOMEPAGE = "http://github.com/myobie/htmldiff"
+SUMMARY = "HTML diffs of text (borrowed from a wiki software I no longer remember)"
+
+spec = Gem::Specification.new do |s|
+  s.name = GEM
+  s.version = GEM_VERSION
+  s.platform = Gem::Platform::RUBY
+  s.has_rdoc = true
+  s.extra_rdoc_files = ["README", "LICENSE", 'TODO']
+  s.summary = SUMMARY
+  s.description = s.summary
+  s.author = AUTHOR
+  s.email = EMAIL
+  s.homepage = HOMEPAGE
+  
+  # Uncomment this to add a dependency
+  # s.add_dependency "foo"
+  
+  s.require_path = 'lib'
+  s.autorequire = GEM
+  s.files = %w(LICENSE README Rakefile TODO) + Dir.glob("{lib,spec}/**/*")
+end
+
+task :default => :spec
+
+desc "Run specs"
+Spec::Rake::SpecTask.new do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+  t.spec_opts = %w(-fs --color)
+end
+
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+
+desc "install the gem locally"
+task :install => [:package] do
+  sh %{sudo gem install pkg/#{GEM}-#{GEM_VERSION}}
+end
+
+desc "create a gemspec file"
+task :make_spec do
+  File.open("#{GEM}.gemspec", "w") do |file|
+    file.puts spec.to_ruby
+  end
+end

data/lib/htmldiff.rb

@@ -0,0 +1,341 @@
+class HTMLDiff
+
+  Match = Struct.new(:start_in_old, :start_in_new, :size)
+  class Match
+    def end_in_old
+      self.start_in_old + self.size
+    end
+    
+    def end_in_new
+      self.start_in_new + self.size
+    end
+  end
+  
+  Operation = Struct.new(:action, :start_in_old, :end_in_old, :start_in_new, :end_in_new)
+
+  class DiffBuilder
+
+    def initialize(old_version, new_version, mode = :html)
+      @old_version, @new_version = old_version, new_version
+      @content = []
+      @mode = mode
+    end
+
+    def build
+      split_inputs_to_words
+      index_new_words
+      operations.each { |op| perform_operation(op) }
+      return @content.join
+    end
+
+    def split_inputs_to_words
+      @old_words = convert_html_to_list_of_words(explode(@old_version))
+      @new_words = convert_html_to_list_of_words(explode(@new_version))
+    end
+
+    def index_new_words
+      @word_indices = Hash.new { |h, word| h[word] = [] }
+      @new_words.each_with_index { |word, i| @word_indices[word] << i }
+    end
+
+    def operations
+      position_in_old = position_in_new = 0
+      operations = []
+      
+      matches = matching_blocks
+      # an empty match at the end forces the loop below to handle the unmatched tails
+      # I'm sure it can be done more gracefully, but not at 23:52
+      matches << Match.new(@old_words.length, @new_words.length, 0)
+      
+      matches.each_with_index do |match, i|
+        match_starts_at_current_position_in_old = (position_in_old == match.start_in_old)
+        match_starts_at_current_position_in_new = (position_in_new == match.start_in_new)
+        
+        action_upto_match_positions = 
+          case [match_starts_at_current_position_in_old, match_starts_at_current_position_in_new]
+          when [false, false]
+            :replace
+          when [true, false]
+            :insert
+          when [false, true]
+            :delete
+          else
+            # this happens if the first few words are same in both versions
+            :none
+          end
+
+        if action_upto_match_positions != :none
+          operation_upto_match_positions = 
+              Operation.new(action_upto_match_positions, 
+                  position_in_old, match.start_in_old, 
+                  position_in_new, match.start_in_new)
+          operations << operation_upto_match_positions
+        end
+        if match.size != 0
+          match_operation = Operation.new(:equal, 
+              match.start_in_old, match.end_in_old, 
+              match.start_in_new, match.end_in_new)
+          operations << match_operation
+        end
+
+        position_in_old = match.end_in_old
+        position_in_new = match.end_in_new
+      end
+      
+      operations
+    end
+
+    def matching_blocks
+      matching_blocks = []
+      recursively_find_matching_blocks(0, @old_words.size, 0, @new_words.size, matching_blocks)
+      matching_blocks
+    end
+
+    def recursively_find_matching_blocks(start_in_old, end_in_old, start_in_new, end_in_new, matching_blocks)
+      match = find_match(start_in_old, end_in_old, start_in_new, end_in_new)
+      if match
+        if start_in_old < match.start_in_old and start_in_new < match.start_in_new
+          recursively_find_matching_blocks(
+              start_in_old, match.start_in_old, start_in_new, match.start_in_new, matching_blocks) 
+        end
+        matching_blocks << match
+        if match.end_in_old < end_in_old and match.end_in_new < end_in_new
+          recursively_find_matching_blocks(
+              match.end_in_old, end_in_old, match.end_in_new, end_in_new, matching_blocks)
+        end
+      end
+    end
+
+    def find_match(start_in_old, end_in_old, start_in_new, end_in_new)
+
+      best_match_in_old = start_in_old
+      best_match_in_new = start_in_new
+      best_match_size = 0
+      
+      match_length_at = Hash.new { |h, index| h[index] = 0 }
+      
+      start_in_old.upto(end_in_old - 1) do |index_in_old|
+
+        new_match_length_at = Hash.new { |h, index| h[index] = 0 }
+
+        @word_indices[@old_words[index_in_old]].each do |index_in_new|
+          next  if index_in_new < start_in_new
+          break if index_in_new >= end_in_new
+
+          new_match_length = match_length_at[index_in_new - 1] + 1
+          new_match_length_at[index_in_new] = new_match_length
+
+          if new_match_length > best_match_size
+            best_match_in_old = index_in_old - new_match_length + 1
+            best_match_in_new = index_in_new - new_match_length + 1
+            best_match_size = new_match_length
+          end
+        end
+        match_length_at = new_match_length_at
+      end
+
+#      best_match_in_old, best_match_in_new, best_match_size = add_matching_words_left(
+#          best_match_in_old, best_match_in_new, best_match_size, start_in_old, start_in_new)
+#      best_match_in_old, best_match_in_new, match_size = add_matching_words_right(
+#          best_match_in_old, best_match_in_new, best_match_size, end_in_old, end_in_new)
+
+      return (best_match_size != 0 ? Match.new(best_match_in_old, best_match_in_new, best_match_size) : nil)
+    end
+
+    def add_matching_words_left(match_in_old, match_in_new, match_size, start_in_old, start_in_new)
+      while match_in_old > start_in_old and 
+            match_in_new > start_in_new and 
+            @old_words[match_in_old - 1] == @new_words[match_in_new - 1]
+        match_in_old -= 1
+        match_in_new -= 1
+        match_size += 1
+      end
+      [match_in_old, match_in_new, match_size]
+    end
+
+    def add_matching_words_right(match_in_old, match_in_new, match_size, end_in_old, end_in_new)
+      while match_in_old + match_size < end_in_old and 
+            match_in_new + match_size < end_in_new and
+            @old_words[match_in_old + match_size] == @new_words[match_in_new + match_size]
+        match_size += 1
+      end
+      [match_in_old, match_in_new, match_size]
+    end
+    
+    VALID_METHODS = [:replace, :insert, :delete, :equal]
+
+    def perform_operation(operation)
+      @operation = operation
+      self.send operation.action, operation
+    end
+
+    def replace(operation)
+      delete(operation, 'diffmod')
+      insert(operation, 'diffmod')
+    end
+    
+    def insert(operation, tagclass = 'diffins')
+      if @mode == :html
+        insert_tag('ins', tagclass, @new_words[operation.start_in_new...operation.end_in_new])
+      else
+        @content << '[++'
+        @content << @new_words[operation.start_in_new...operation.end_in_new]
+        @content << '++]'
+      end
+    end
+    
+    def delete(operation, tagclass = 'diffdel')
+      if @mode == :html
+        insert_tag('del', tagclass, @old_words[operation.start_in_old...operation.end_in_old])
+      else
+        @content << '[--'
+        @content << @old_words[operation.start_in_old...operation.end_in_old]
+        @content << '--]'
+      end
+    end
+    
+    def equal(operation)
+      # no tags to insert, simply copy the matching words from one of the versions
+      @content += @new_words[operation.start_in_new...operation.end_in_new]
+    end
+  
+    def opening_tag?(item)
+      item =~ %r!^\s*<[^>]+>\s*$!
+    end
+
+    def closing_tag?(item)
+      item =~ %r!^\s*</[^>]+>\s*$!
+    end
+
+    def tag?(item)
+      opening_tag?(item) or closing_tag?(item)
+    end
+
+    def extract_consecutive_words(words, &condition)
+      index_of_first_tag = nil
+      words.each_with_index do |word, i| 
+        if !condition.call(word)
+          index_of_first_tag = i
+          break
+        end
+      end
+      if index_of_first_tag
+        return words.slice!(0...index_of_first_tag)
+      else
+        return words.slice!(0..words.length)
+      end
+    end
+
+    # This method encloses words within a specified tag (ins or del), and adds this into @content, 
+    # with a twist: if there are words contain tags, it actually creates multiple ins or del, 
+    # so that they don't include any ins or del. This handles cases like
+    # old: '<p>a</p>'
+    # new: '<p>ab</p><p>c</b>'
+    # diff result: '<p>a<ins>b</ins></p><p><ins>c</ins></p>'
+    # this still doesn't guarantee valid HTML (hint: think about diffing a text containing ins or
+    # del tags), but handles correctly more cases than the earlier version.
+    # 
+    # P.S.: Spare a thought for people who write HTML browsers. They live in this ... every day.
+
+    def insert_tag(tagname, cssclass, words)
+      loop do
+        break if words.empty?
+        non_tags = extract_consecutive_words(words) { |word| not tag?(word) }
+        @content << wrap_text(non_tags.join, tagname, cssclass) unless non_tags.empty?
+
+        break if words.empty?
+        @content += extract_consecutive_words(words) { |word| tag?(word) }
+      end
+    end
+
+    def wrap_text(text, tagname, cssclass)
+      %(<#{tagname} class="#{cssclass}">#{text}</#{tagname}>)
+    end
+
+    def explode(sequence)
+      sequence.is_a?(String) ? sequence.split(//) : sequence
+    end
+  
+    def end_of_tag?(char)
+      char == '>'
+    end
+  
+    def start_of_tag?(char)
+      char == '<'
+    end
+    
+    def whitespace?(char)
+      char =~ /\s/
+    end
+  
+    def convert_html_to_list_of_words(x, use_brackets = false)
+      mode = :char
+      current_word  = ''
+      words = []
+      
+      explode(x).each do |char|
+        case mode
+        when :tag
+          if end_of_tag? char
+            current_word << (use_brackets ? ']' : '>')
+            words << current_word
+            current_word = ''
+            if whitespace?(char) 
+              mode = :whitespace 
+            else
+              mode = :char
+            end
+          else
+            current_word << char
+          end
+        when :char
+          if start_of_tag? char
+            words << current_word unless current_word.empty?
+            current_word = (use_brackets ? '[' : '<')
+            mode = :tag
+          elsif /\s/.match char
+            words << current_word unless current_word.empty?
+            current_word = char
+            mode = :whitespace
+          else
+            current_word << char
+          end
+        when :whitespace
+          if start_of_tag? char
+            words << current_word unless current_word.empty?
+            current_word = (use_brackets ? '[' : '<')
+            mode = :tag
+          elsif /\s/.match char
+            current_word << char
+          else
+            words << current_word unless current_word.empty?
+            current_word = char
+            mode = :char
+          end
+        else 
+          raise "Unknown mode #{mode.inspect}"
+        end
+      end
+      words << current_word unless current_word.empty?
+      words
+    end
+
+  end # of class Diff Builder
+
+  def HTMLDiff.diff(a, b)
+    HTMLDiff.new.diff(a, b)
+  end
+
+  def HTMLDiff.textdiff(a, b)
+    HTMLDiff.new.textdiff(a, b)
+  end
+  
+  def diff(a, b)
+    DiffBuilder.new(a, b).build
+  end
+
+  def textdiff(a, b)
+    DiffBuilder.new(a, b, :text).build
+  end
+
+end

data/spec/htmldiff_spec.rb

@@ -0,0 +1,33 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require 'htmldiff'
+
+describe "htmldiff" do
+  
+  it "should diff text" do
+    
+    diff = HTMLDiff.diff('a word is here', 'a nother word is there')
+    diff.should == "a<ins class=\"diffins\"> nother</ins> word is <del class=\"diffmod\">here</del><ins class=\"diffmod\">there</ins>"
+    
+  end
+  
+  it "should insert a letter and a space" do
+    diff = HTMLDiff.diff('a c', 'a b c')
+    diff.should == "a <ins class=\"diffins\">b </ins>c"
+  end
+  
+  it "should remove a letter and a space" do
+    diff = HTMLDiff.diff('a b c', 'a c')
+    diff.should == "a <del class=\"diffdel\">b </del>c"
+  end
+  
+  it "should change a letter" do
+    diff = HTMLDiff.diff('a b c', 'a d c')
+    diff.should == "a <del class=\"diffmod\">b</del><ins class=\"diffmod\">d</ins> c"
+  end
+
+  it "should provide a text output format" do
+    diff = HTMLDiff.textdiff('a b c', 'a d c')
+    diff.should == "a [--b--][++d++] c"
+  end
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+$TESTING=true
+$:.push File.join(File.dirname(__FILE__), '..', 'lib')

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification 
+name: jacobat-htmldiff
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 2
+  version: 0.0.2
+platform: ruby
+authors: 
+- Nathan Herald
+autorequire: jacobat-htmldiff
+bindir: bin
+cert_chain: []
+
+date: 2011-02-03 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: HTML diffs of text (borrowed from a wiki software I no longer remember)
+email: nathan@myobie.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- LICENSE
+- TODO
+files: 
+- LICENSE
+- README
+- Rakefile
+- TODO
+- lib/htmldiff.rb
+- spec/htmldiff_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/myobie/htmldiff
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: HTML diffs of text (borrowed from a wiki software I no longer remember)
+test_files: []
+