diff 0.3.1

data/Manifest

@@ -0,0 +1,13 @@
+Manifest
+README
+Rakefile
+TODO
+diff.gemspec
+lib/diff.rb
+lib/emaildiff.rb
+lib/unixdiff.rb
+test/test_cases.rb
+test/test_diff.rb
+test/test_emailcases.rb
+test/test_emaildiff.rb
+test/test_unixdiff.rb

data/README

@@ -0,0 +1,69 @@
+
+diff.rb README
+
+    Diff Algorithm Implementation, Copyright (C) 2001 Lars
+    Christensen, larsch@cs.auc.dk.
+
+LEGAL NOTICE
+
+    This program is free software; you can redistribute it and/or
+    modify it under the terms of the GNU General Public License as
+    published by the Free Software Foundation; either version 2 of the
+    License, or (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+    02111-1307, USA.
+
+ABOUT
+
+    This implementation is basically a Ruby conversion of the Perl
+    Algorithm::Diff module in CPAN.
+
+    Diff is an algorithm which computes the differences between two
+    lists a and b. The resulting set of differences can be applied to
+    a (also called "patching") to get b. This is also what the Unix
+    command line tools "diff" and "patch" are able to do.
+
+    diff.rb generates a "minimal diff". This means that the set of
+    changes that should be applied to a to get b can not be fewer than
+    those generated by diff.rb. diff.rb does not generate contextual
+    diffs. Therefor, the diff can only be succesfully applied to a
+    list exactly equal to to original a.
+
+    Documentation is in RD format in diff.rb. Ruby rd2 on it to
+    extract into other formats.
+
+INSTALLATION
+
+    You should not installed this library system wide, because it is a
+    work in progress and the API may still change. You should place
+    the file "diff.rb" together with the source that needs to use it
+    and simply put "require 'diff'" at the top of your program file.
+
+REVISION HISTORY 
+
+    Version 0.1
+
+        Initial release. Diff algorithm works.
+
+    Version 0.2
+
+        Speed improvements and code clean up
+
+    Version 0.3
+
+        Added unixdiff.rb, an implementation of Unix Diff (simple
+	format only)
+
+CREDITS
+
+    Thanks to authors of Perl's Algorithm::Diff (originally written by
+    Mark-Jason Dominus, currently maintained by Ned Konz).
+

data/Rakefile

@@ -0,0 +1,12 @@
+require 'rubygems'
+require 'rake'
+require 'echoe'
+
+Echoe.new('diff','0.3.1') do |s|
+  s.description = "Diff Algorithm Implementation"
+  s.url = "http://users.cybercity.dk/~dsl8950/ruby/diff.html"
+  s.author = "Wayne Walter"
+  s.email = "diffgem@tickzoom.com"
+  s.ignore_pattern = []
+  s.development_dependencies = []
+end

data/TODO

@@ -0,0 +1,17 @@
+= For 1.0:
+
+  * Settle on a diff format, e.g. what should the first field look like:
+	[ '+', 23, "foo" ]
+	[ :add, 23, "foo" ]
+	[ DiffAdd, 23, "foo" ]
+    or should we have classed
+	class DiffAdd
+		attr_reader :position, :element
+	end
+
+= Other Ideas:
+
+  * Contextual diffs?
+  * Unix diff/patch compatible wrapper
+
+

data/diff.gemspec

@@ -0,0 +1,33 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{diff}
+  s.version = "0.3.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Wayne Walter"]
+  s.cert_chain = ["/root/.ssh/gem-public_cert.pem"]
+  s.date = %q{2010-06-27}
+  s.description = %q{Diff Algorithm Implementation}
+  s.email = %q{diffgem@tickzoom.com}
+  s.extra_rdoc_files = ["README", "TODO", "lib/diff.rb", "lib/emaildiff.rb", "lib/unixdiff.rb"]
+  s.files = ["Manifest", "README", "Rakefile", "TODO", "diff.gemspec", "lib/diff.rb", "lib/emaildiff.rb", "lib/unixdiff.rb", "test/test_cases.rb", "test/test_diff.rb", "test/test_emailcases.rb", "test/test_emaildiff.rb", "test/test_unixdiff.rb"]
+  s.homepage = %q{http://users.cybercity.dk/~dsl8950/ruby/diff.html}
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Diff", "--main", "README"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{diff}
+  s.rubygems_version = %q{1.3.7}
+  s.signing_key = %q{/root/.ssh/gem-private_key.pem}
+  s.summary = %q{Diff Algorithm Implementation}
+  s.test_files = ["test/test_emailcases.rb", "test/test_emaildiff.rb", "test/test_unixdiff.rb", "test/test_diff.rb", "test/test_cases.rb"]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/lib/diff.rb

@@ -0,0 +1,278 @@
+class Diff
+
+  def Diff.lcs(a, b)
+    astart = 0
+    bstart = 0
+    afinish = a.length-1
+    bfinish = b.length-1
+    mvector = []
+    
+    # First we prune off any common elements at the beginning
+    while (astart <= afinish && bstart <= afinish && a[astart] == b[bstart])
+      mvector[astart] = bstart
+      astart += 1
+      bstart += 1
+    end
+    
+    # now the end
+    while (astart <= afinish && bstart <= bfinish && a[afinish] == b[bfinish])
+      mvector[afinish] = bfinish
+      afinish -= 1
+      bfinish -= 1
+    end
+
+    bmatches = b.reverse_hash(bstart..bfinish)
+    thresh = []
+    links = []
+    
+    (astart..afinish).each { |aindex|
+      aelem = a[aindex]
+      next unless bmatches.has_key? aelem
+      k = nil
+      bmatches[aelem].reverse.each { |bindex|
+	if k && (thresh[k] > bindex) && (thresh[k-1] < bindex)
+	  thresh[k] = bindex
+	else
+	  k = thresh.replacenextlarger(bindex, k)
+	end
+	links[k] = [ (k==0) ? nil : links[k-1], aindex, bindex ] if k
+      }
+    }
+
+    if !thresh.empty?
+      link = links[thresh.length-1]
+      while link
+	mvector[link[1]] = link[2]
+	link = link[0]
+      end
+    end
+
+    return mvector
+  end
+
+  def makediff(a, b)
+    mvector = Diff.lcs(a, b)
+    ai = bi = 0
+    while ai < mvector.length
+      bline = mvector[ai]
+      if bline
+	while bi < bline
+	  discardb(bi, b[bi])
+	  bi += 1
+	end
+	match(ai, bi)
+	bi += 1
+      else
+	discarda(ai, a[ai])
+      end
+      ai += 1
+    end
+    while ai < a.length
+      discarda(ai, a[ai])
+      ai += 1
+    end
+    while bi < b.length
+      discardb(bi, b[bi])
+      bi += 1
+    end
+    match(ai, bi)
+    1
+  end
+
+  def compactdiffs
+    diffs = []
+    @diffs.each { |df|
+      i = 0
+      curdiff = []
+      while i < df.length
+	whot = df[i][0]
+	s = @isstring ? df[i][2].chr : [df[i][2]]
+	p = df[i][1]
+	last = df[i][1]
+	i += 1
+	while df[i] && df[i][0] == whot && df[i][1] == last+1
+	  s << df[i][2]
+	  last  = df[i][1]
+	  i += 1
+	end
+	curdiff.push [whot, p, s]
+      end
+      diffs.push curdiff
+    }
+    return diffs
+  end
+
+  attr_reader :diffs, :difftype
+
+  def initialize(diffs_or_a, b = nil, isstring = nil)
+    if b.nil?
+      @diffs = diffs_or_a
+      @isstring = isstring
+    else
+      @diffs = []
+      @curdiffs = []
+      makediff(diffs_or_a, b)
+      @difftype = diffs_or_a.class
+    end
+  end
+  
+  def match(ai, bi)
+    @diffs.push @curdiffs unless @curdiffs.empty?
+    @curdiffs = []
+  end
+
+  def discarda(i, elem)
+    @curdiffs.push ['-', i, elem]
+  end
+
+  def discardb(i, elem)
+    @curdiffs.push ['+', i, elem]
+  end
+
+  def compact
+    return Diff.new(compactdiffs)
+  end
+
+  def compact!
+    @diffs = compactdiffs
+  end
+
+  def inspect
+    @diffs.inspect
+  end
+
+end
+
+module Diffable
+  def diff(b)
+    Diff.new(self, b)
+  end
+
+  # Create a hash that maps elements of the array to arrays of indices
+  # where the elements are found.
+
+  def reverse_hash(range = (0...self.length))
+    revmap = {}
+    range.each { |i|
+      elem = self[i]
+      if revmap.has_key? elem
+	revmap[elem].push i
+      else
+	revmap[elem] = [i]
+      end
+    }
+    return revmap
+  end
+
+  def replacenextlarger(value, high = nil)
+    high ||= self.length
+    if self.empty? || value > self[-1]
+      push value
+      return high
+    end
+    # binary search for replacement point
+    low = 0
+    while low < high
+      index = (high+low)/2
+      found = self[index]
+      return nil if value == found
+      if value > found
+	low = index + 1
+      else
+	high = index
+      end
+    end
+
+    self[low] = value
+    # $stderr << "replace #{value} : 0/#{low}/#{init_high} (#{steps} steps) (#{init_high-low} off )\n"
+    # $stderr.puts self.inspect
+    #gets
+    #p length - low
+    return low
+  end
+
+  def patch(diff)
+    newary = nil
+    if diff.difftype == String
+      newary = diff.difftype.new('')
+    else
+      newary = diff.difftype.new
+    end
+    ai = 0
+    bi = 0
+    diff.diffs.each { |d|
+      d.each { |mod|
+	case mod[0]
+	when '-'
+	  while ai < mod[1]
+	    newary << self[ai]
+	    ai += 1
+	    bi += 1
+	  end
+	  ai += 1
+	when '+'
+	  while bi < mod[1]
+	    newary << self[ai]
+	    ai += 1
+	    bi += 1
+	  end
+	  newary << mod[2]
+	  bi += 1
+	else
+	  raise "Unknown diff action"
+	end
+      }
+    }
+    while ai < self.length
+      newary << self[ai]
+      ai += 1
+      bi += 1
+    end
+    return newary
+  end
+end
+
+class Array
+  include Diffable
+end
+
+class String
+  include Diffable
+end
+
+=begin
+= Diff
+(({diff.rb})) - computes the differences between two arrays or
+strings. Copyright (C) 2001 Lars Christensen
+
+== Synopsis
+
+    diff = Diff.new(a, b)
+    b = a.patch(diff)
+
+== Class Diff
+=== Class Methods
+--- Diff.new(a, b)
+--- a.diff(b)
+      Creates a Diff object which represent the differences between
+      ((|a|)) and ((|b|)). ((|a|)) and ((|b|)) can be either be arrays
+      of any objects, strings, or object of any class that include
+      module ((|Diffable|))
+
+== Module Diffable
+The module ((|Diffable|)) is intended to be included in any class for
+which differences are to be computed. Diffable is included into String
+and Array when (({diff.rb})) is (({require}))'d.
+
+Classes including Diffable should implement (({[]})) to get element at
+integer indices, (({<<})) to append elements to the object and
+(({ClassName#new})) should accept 0 arguments to create a new empty
+object.
+
+=== Instance Methods
+--- Diffable#patch(diff)
+      Applies the differences from ((|diff|)) to the object ((|obj|))
+      and return the result. ((|obj|)) is not changed. ((|obj|)) and
+      can be either an array or a string, but must match the object
+      from which the ((|diff|)) was created.
+=end

data/lib/emaildiff.rb

@@ -0,0 +1,73 @@
+require 'diff'
+
+module HTMLCollapsable
+  def diff(b)
+    Diff.new(self, b)
+  end
+
+  def collapse(diff,starttoken,endtoken)
+    newary = nil
+    if diff.difftype == String
+      newary = diff.difftype.new('')
+    else
+      newary = diff.difftype.new
+    end
+    ai = 0
+    bi = 0
+    diff.diffs.each { |d|
+      d.each { |mod|
+        quoted = 0
+	case mod[0]
+	when '-'
+	  if ai < mod[1] 
+            quoted = 1
+          end
+          newary << starttoken if quoted == 1
+	  while ai < mod[1]
+	    newary << self[ai]
+	    ai += 1
+	    bi += 1
+	  end
+	  newary << endtoken if quoted == 1
+	  ai += 1
+	when '+'
+	  if bi < mod[1] 
+            quoted = 1
+          end
+          newary << starttoken if quoted == 1
+	  while bi < mod[1]
+	    newary << self[ai]
+	    ai += 1
+	    bi += 1
+	  end
+	  newary << endtoken if quoted == 1
+	  newary << mod[2]
+	  bi += 1
+	else
+	  raise "Unknown diff action"
+	end
+      }
+    }
+    quoted = 0
+    if ai < self.length
+      quoted = 1
+    end
+    newary << starttoken if quoted == 1
+    while ai < self.length
+      newary << self[ai]
+      ai += 1
+      bi += 1
+    end
+    newary << endtoken if quoted == 1
+    return newary
+  end
+end
+
+class Array
+  include HTMLCollapsable
+end
+
+class String
+  include HTMLCollapsable
+end
+

data/lib/unixdiff.rb

@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby
+
+require 'diff'
+
+def loadfile(filename)
+  lines = nil
+  File.open(filename, "r") { |f|
+    lines = f.readlines
+  }
+  return lines
+end
+
+def diffrange(a, b)
+  if (a == b)
+    "#{a}"
+  else
+    "#{a},#{b}"
+  end
+end
+
+class Diff
+  def to_diff(io = $defout)
+    offset = 0
+    @diffs.each { |b|
+      first = b[0][1]
+      length = b.length
+      action = b[0][0]
+      addcount = 0
+      remcount = 0
+      b.each { |l| 
+        if l[0] == "+"
+          addcount += 1
+        elsif l[0] == "-"
+          remcount += 1
+        end
+      }
+      if addcount == 0
+        puts "#{diffrange(first+1, first+remcount)}d#{first+offset}"
+      elsif remcount == 0
+        puts "#{first-offset}a#{diffrange(first+1, first+addcount)}"
+      else
+        puts "#{diffrange(first+1, first+remcount)}c#{diffrange(first+offset+1, first+offset+addcount)}"
+      end
+      lastdel = (b[0][0] == "-")
+      b.each { |l|
+        if l[0] == "-"
+          offset -= 1
+          print "< "
+        elsif l[0] == "+"
+          offset += 1
+	  if lastdel
+	    lastdel = false
+            puts "---"
+          end
+          print "> "
+        end
+	print l[2]
+      }
+    }
+  end
+end
+
+if $0 == __FILE__
+
+  file1 = ARGV.shift
+  file2 = ARGV.shift
+
+  ary1 = loadfile file1
+  ary2 = loadfile file2
+
+  diff = Diff.new(ary1, ary2)
+  diff.to_diff
+
+end

data/test/test_cases.rb

@@ -0,0 +1,137 @@
+module DiffArrayTests
+
+  def test_array_append
+    difftest [1,2,3], [1,2,3,4]
+    difftest [1,2,3], [1,2,3,4,5]
+  end
+
+  def test_array_prepend
+    difftest [1,2,3], [0,1,2,3]
+    difftest [1,2,3], [-1,0,1,2,3]
+  end
+
+  def test_array_insert
+    difftest [1,2,3], [1,2,4,3]
+    difftest [1,2,3], [1,2,4,5,3]
+  end
+
+  def test_array_remove
+    difftest [1,2,3], [1,3]
+  end
+
+  def test_array_cutfront
+    difftest [1,2,3], [2,3]
+    difftest [1,2,3], [3]
+  end
+
+  def test_array_cutback
+    difftest [1,2,3], [1,2]
+    difftest [1,2,3], [1]
+  end
+
+  def test_array_empty
+    difftest [1,2,3], []
+  end
+
+  def test_array_fill
+    difftest [], [1,2,3]
+  end
+
+  def test_array_change
+    difftest [1,2,3], [1,4,3]
+    difftest [1,2,3], [1,4,5]
+    difftest [1,2,3,4], [1,5,4]
+  end
+
+  def test_array_noop
+    difftest [1,2,3], [1,2,3]
+  end
+
+  def test_array_grow
+    difftest [1,2,3], [4,1,5,2,6,3,7]
+  end
+
+  def test_array_shrink
+    difftest [1,2,3,4,5,6,7], [2,4,6]
+  end
+
+end
+
+module DiffStringTests
+
+  def test_string_append
+    difftest "abc", "abcd"
+    difftest "abc", "abcde"
+  end
+
+  def test_string_preprend
+    difftest "abc", "qabc"
+    difftest "abc", "qrabc"
+  end
+  
+  def test_string_insert
+    difftest "abc", "abqc"
+    difftest "abc", "abqrc"
+  end
+  
+  def test_string_cutfront
+    difftest "abc", "bc"
+    difftest "abc", "c"
+  end
+
+  def test_string_cutback
+    difftest "abc", "ab"
+    difftest "abc", "a"
+  end
+
+  def test_string_empty
+    difftest "abc", ""
+  end
+  
+  def test_string_fill
+    difftest "", "abc"
+  end
+
+  def test_string_change
+    difftest "abc", "aqc"
+    difftest "abc", "aqrc"
+    difftest "abcd", "aqd"
+  end
+
+  def test_string_noop
+    difftest "abc", "abc"
+  end
+
+  def test_string_grow
+    difftest "abc", "qarbsct"
+  end
+  
+  def test_string_shrink
+    difftest "abcdefg", "bdf"
+  end
+
+  def test_string_remove
+    difftest "abc", "ac"
+  end
+
+end
+
+module DiffStressTest
+  Elems = [1,2,3]
+  def generate_array
+    length = (16 + 16 * rand).to_i
+    ary = []
+    length.times {
+      ary << Elems[(rand * Elems.length).to_i]
+    }
+    return ary
+  end
+
+  def test_stress
+    256.times {
+      a = generate_array
+      b = generate_array
+      difftest(a, b)
+    }
+  end
+end

data/test/test_diff.rb

@@ -0,0 +1,24 @@
+require 'runit/testcase'
+require 'runit/cui/testrunner'
+require 'runit/testsuite'
+require 'diff'
+require 'test_cases'
+
+class DiffTest < RUNIT::TestCase
+
+  include DiffStringTests
+  include DiffArrayTests
+  include DiffStressTest
+
+  def difftest(a, b)
+    diff = Diff.new(a, b)
+    c = a.patch(diff)
+    assert_equal(b, c)
+    diff = Diff.new(b, a)
+    c = b.patch(diff)
+    assert_equal(a, c)
+  end
+
+end
+
+RUNIT::CUI::TestRunner.run(DiffTest.suite)

data/test/test_emailcases.rb

@@ -0,0 +1,60 @@
+module DiffArrayTests
+
+  def test_array_append
+    difftest [1,2,3], [1,2,3,4], [888,1,2,3,999,4]
+    difftest [1,2,3], [1,2,3,4,5], [888,1,2,3,999,4,5]
+  end
+
+  def test_array_prepend
+    difftest [1,2,3], [0,1,2,3], [0,888,1,2,3,999]
+    difftest [1,2,3], [-1,0,1,2,3], [-1,0,888,1,2,3,999]
+  end
+
+  def test_array_insert
+    difftest [1,2,3], [1,2,4,3], [888,1,2,999,4,888,3,999]
+    difftest [1,2,3], [1,2,4,5,3], [888,1,2,999,4,5,888,3,999]
+  end
+
+  def test_array_remove
+    difftest [1,2,3], [1,3], [888,1,999,888,3,999]
+
+  end
+
+  def test_array_cutfront
+    difftest [1,2,3], [2,3], [888,2,3,999]
+    difftest [1,2,3], [3], [888,3,999]
+  end
+
+  def test_array_cutback
+    difftest [1,2,3], [1,2], [888,1,2,999]
+    difftest [1,2,3], [1], [888,1,999]
+  end
+
+  def test_array_empty
+    difftest [1,2,3], [], []
+  end
+
+  def test_array_fill
+    difftest [], [1,2,3], [1,2,3]
+  end
+
+  def test_array_change
+    difftest [1,2,3], [1,4,3], [888,1,999,4,888,3,999]
+    difftest [1,2,3], [1,4,5], [888,1,999,4,5]
+    difftest [1,2,3,4], [1,5,4], [888,1,999,5,888,4,999]
+  end
+
+  def test_array_noop
+    difftest [1,2,3], [1,2,3], [888,1,2,3,999]
+  end
+
+  def test_array_grow
+    difftest [1,2,3], [4,1,5,2,6,3,7], [4,888,1,999,5,888,2,999,6,888,3,999,7]
+  end
+
+  def test_array_shrink
+    difftest [1,2,3,4,5,6,7], [2,4,6], [888,2,999,888,4,999,888,6,999]
+  end
+
+end
+

data/test/test_emaildiff.rb

@@ -0,0 +1,26 @@
+require 'runit/testcase'
+require 'runit/cui/testrunner'
+require 'runit/testsuite'
+require 'diff'
+require 'emaildiff'
+require 'test_emailcases'
+
+class EmailDiffTest < RUNIT::TestCase
+
+  include DiffArrayTests
+
+  def difftest(a, b, c)
+    #puts "old string:"
+    #puts a
+    #puts "new string:"
+    #puts b
+    diff = Diff.new(a, b)
+    d = a.collapse(diff,888,999)
+    #puts "result:"
+    #puts c
+    assert_equal(c,d)
+  end
+end
+
+
+RUNIT::CUI::TestRunner.run(EmailDiffTest.suite)

data/test/test_unixdiff.rb

@@ -0,0 +1,39 @@
+require 'runit/testcase'
+require 'runit/cui/testrunner'
+require 'runit/testsuite'
+require 'diff'
+require 'test_cases'
+
+class UnixDiffTest < RUNIT::TestCase
+
+  include DiffArrayTests
+  #include DiffStressTest
+
+  def makefile(filename, ary)
+    File.open(filename, "w") { |f|
+      ary.each { |elem|
+        f.puts elem.to_s
+      }
+    }
+  end
+
+  def rundiff(prog)
+    res = []
+    IO.popen("#{prog} file1 file2") { |f|
+      while ln = f.gets 
+        res << ln
+      end
+    }
+    res
+  end
+
+  def difftest(a, b)
+    makefile("file1", a)
+    makefile("file2", b)
+    result1 = rundiff("diff")
+    result2 = rundiff("lib/unixdiff.rb");
+    assert_equal(result1, result2)
+  end
+end
+
+RUNIT::CUI::TestRunner.run(UnixDiffTest.suite)

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification 
+name: diff
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 3
+  - 1
+  version: 0.3.1
+platform: ruby
+authors: 
+- Wayne Walter
+autorequire: 
+bindir: bin
+cert_chain: 
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIDNjCCAh6gAwIBAgIBADANBgkqhkiG9w0BAQUFADBBMRAwDgYDVQQDDAdkaWZm
+  Z2VtMRgwFgYKCZImiZPyLGQBGRYIdGlja3pvb20xEzARBgoJkiaJk/IsZAEZFgNj
+  b20wHhcNMTAwNjI3MDUwNjEyWhcNMTEwNjI3MDUwNjEyWjBBMRAwDgYDVQQDDAdk
+  aWZmZ2VtMRgwFgYKCZImiZPyLGQBGRYIdGlja3pvb20xEzARBgoJkiaJk/IsZAEZ
+  FgNjb20wggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDbPiHhbX0yQuqX
+  NONpzyqFHMSIM6aUXrOMWv1VWJejRli2ssdixBEL3laSCbAIpBwPQXlUbkl5Keq6
+  kZK9LmztDK3S8y37YSJ/ojFjdX8AM/MVByC2BJGQGEzIrHikiKwlJ8GxM3pLow4+
+  +av0dyWCUgVn9bGvDIcay780i4wmaSC2Sf9Obkgu1TiR0hc48AtUOToN4RwdScL0
+  oAmKG/lSYGUhkhUROdghMEaGMotCFHm5szM5miOxK5PqCq14cQP5W+ubKo2oE6iF
+  3YH7iG+qspCGOGjKcz8g+AYmMsN8sO2oh1orM7EG6Bm1RI6gKeruC6ez1woF8jn2
+  6WGa9a4rAgMBAAGjOTA3MAkGA1UdEwQCMAAwCwYDVR0PBAQDAgSwMB0GA1UdDgQW
+  BBRYb3kBzatxDzFkBANlHfc1S5u7yjANBgkqhkiG9w0BAQUFAAOCAQEAhISiSEuF
+  RbvSpMfZe4g/9O2e+A6pE7BCmmR6EzGanQFf39DMSdwd8GbtW1p7ZQYGuxiFVGQw
+  OZiRnP5QNqqtR5LjArw9obt9BgeJjhAs0WI97G9LJdKu4kz1Yee+6kN5Dt5hjrVX
+  tHxTUv4oyN8PxyKnQt+pevLsp7TkaYHtl2+VLg9iU5syNPhASx7erHwiMu6yNOjZ
+  uwsQ4lOsT6OM45inY82GupysnaP5BrZh/WBQ3m8mdA47pGBmHH3Vm57hooA+RSW7
+  NYrQY6HQkU2llwX9w8Ts8rO45tig6pSbgkim0V0ewjxWUI4D7zzc1t55ZsJJZu9o
+  nbAv9FEyqLVW8Q==
+  -----END CERTIFICATE-----
+
+date: 2010-06-27 00:00:00 +00:00
+default_executable: 
+dependencies: []
+
+description: Diff Algorithm Implementation
+email: diffgem@tickzoom.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- TODO
+- lib/diff.rb
+- lib/emaildiff.rb
+- lib/unixdiff.rb
+files: 
+- Manifest
+- README
+- Rakefile
+- TODO
+- diff.gemspec
+- lib/diff.rb
+- lib/emaildiff.rb
+- lib/unixdiff.rb
+- test/test_cases.rb
+- test/test_diff.rb
+- test/test_emailcases.rb
+- test/test_emaildiff.rb
+- test/test_unixdiff.rb
+has_rdoc: true
+homepage: http://users.cybercity.dk/~dsl8950/ruby/diff.html
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --title
+- Diff
+- --main
+- README
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 2
+      version: "1.2"
+requirements: []
+
+rubyforge_project: diff
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Diff Algorithm Implementation
+test_files: 
+- test/test_emailcases.rb
+- test/test_emaildiff.rb
+- test/test_unixdiff.rb
+- test/test_diff.rb
+- test/test_cases.rb