levenshtein 0.1.0 → 0.2.2

data/CHANGELOG

@@ -0,0 +1,34 @@
+0.2.2 (16-03-2012)
+
+* Simplified code.
+
+0.2.1 (11-03-2012)
+
+* Better memory handling.
+
+* Little speed improvements.
+
+* Ruby 1.9 compatible?
+
+0.2.0 (11-07-2009)
+
+* Return 0 instead of 0.0 in case of empty strings.
+
+* Added specific support for arrays.
+
+* Added specific support for arrays of strings.
+
+* Added generic support for all (?) kind of sequences.
+
+* Moved a lot of code to the C world.
+
+0.1.1 (06-10-2008)
+
+* If one of the strings was both the begin and the end of the
+  other string, it would be stripped from both ends. Example:
+  Levenshtein.distance("abracadabra", "abra") resulted in 3
+  instead of 7. It's fixed now.
+
+0.1.0 (24-05-2008)
+
+* First release.

data/README

@@ -1,8 +1,15 @@
-# The Levenshtein distance is a metric for measuring the amount of difference
-# between two sequences (i.e., the so called edit distance). The Levenshtein
-# distance between two strings is given by the minimum number of operations
-# needed to transform one string into the other, where an operation is an
-# insertion, deletion, or substitution of a single character.
-#
-# More information about the Levenshtein distance algorithm:
-# http://en.wikipedia.org/wiki/Levenshtein_distance .
+The Levenshtein distance is a metric for measuring the amount
+of difference between two sequences (i.e., the so called edit
+distance). The Levenshtein distance between two sequences is
+given by the minimum number of operations needed to transform
+one sequence into the other, where an operation is an
+insertion, deletion, or substitution of a single element.
+
+The two sequences can be two strings, two arrays, or two other
+objects responding to :each. All sequences are by generic
+(fast) C code.
+
+All objects in the sequences should respond to :hash and :eql?.
+
+More information about the Levenshtein distance algorithm:
+http://en.wikipedia.org/wiki/Levenshtein_distance .

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.2.2

data/ext/levenshtein/extconf.rb

@@ -2,4 +2,9 @@ require "mkmf"
 
 dir_config("levenshtein")
 
-create_makefile("levenshtein/levenshtein_c")
+have_library("levenshtein_array")
+have_library("levenshtein_array_of_strings")
+have_library("levenshtein_generic")
+have_library("levenshtein_string")
+
+create_makefile("levenshtein/levenshtein_fast")

data/ext/levenshtein/levenshtein.h

@@ -0,0 +1,13 @@
+#ifdef RARRAY_PTR
+#else
+#define RARRAY_PTR(o) (RARRAY(o)->ptr)
+#define RARRAY_LEN(o) (RARRAY(o)->len)
+#endif
+
+#ifdef RSTRING_PTR
+#else
+#define RSTRING_PTR(o) (RSTRING(o)->ptr)
+#define RSTRING_LEN(o) (RSTRING(o)->len)
+#endif
+
+VALUE mLevenshtein;

data/ext/levenshtein/{levenshtein_c.c → levenshtein_fast.c}

@@ -1,25 +1,27 @@
 #include "ruby.h"
+#include "levenshtein.h"
 
-static VALUE levenshtein_distance_part2(VALUE self, VALUE rb_s1, VALUE rb_s2, VALUE rb_threshold) {
-  VALUE	rb_s3;
+VALUE levenshtein_distance_fast(VALUE self, VALUE rb_o1, VALUE rb_o2, VALUE rb_threshold) {
+  VALUE	*p1, *p2;
+  long	l1, l2;
+  long	col, row;
   int	threshold;
-  int	l1, l2, l3;
-  char	*s1, *s2, *s3;
-  int	*prev_row, *curr_row;
-  int	col, row;
+  int	*prev_row, *curr_row, *temp_row;
   int	curr_row_min, result;
+  int	value1, value2;
 
-  /* Convert Ruby's s1 to C's s1. */
+  /* Be sure that all equivalent objects in rb_o1 and rb_o2 (a.eql?(b) == true) are taken from a pool (a.equal?(b) == true). */
+  /* This is done in levenshtein.rb by means of Util.pool. */
 
-  rb_s1	= StringValue(rb_s1);
-  s1	= RSTRING(rb_s1)->ptr;
-  l1	= RSTRING(rb_s1)->len;
+  /* Get the sizes of both arrays. */
 
-  /* Convert Ruby's s2 to C's s2. */
+  l1	= RARRAY_LEN(rb_o1);
+  l2	= RARRAY_LEN(rb_o2);
 
-  rb_s2	= StringValue(rb_s2);
-  s2	= RSTRING(rb_s2)->ptr;
-  l2	= RSTRING(rb_s2)->len;
+  /* Get the pointers of both arrays. */
+
+  p1	= RARRAY_PTR(rb_o1);
+  p2	= RARRAY_PTR(rb_o2);
 
   /* Convert Ruby's threshold to C's threshold. */
 
@@ -29,7 +31,7 @@ static VALUE levenshtein_distance_part2(VALUE self, VALUE rb_s1, VALUE rb_s2, VA
     threshold	= -1;
   }
 
-  /* The Levenshtein Algorithm itself. */
+  /* The Levenshtein algorithm itself. */
 
   /*       s1=              */
   /*       ERIK             */
@@ -43,15 +45,11 @@ static VALUE levenshtein_distance_part2(VALUE self, VALUE rb_s1, VALUE rb_s2, VA
   /*    T 65555             */
   /*    R 76566             */
   /*    A 87667             */
- 
+
   /* Allocate memory for both rows */
 
-  prev_row	= ALLOC_N(int, l1+1);
-  curr_row	= ALLOC_N(int, l1+1);
-
-  if ((prev_row == NULL) || (curr_row == NULL)) {
-    rb_raise(rb_eNoMemError, "out of memory");
-  }
+  prev_row	= (int*) ALLOC_N(int, (l1+1));
+  curr_row	= (int*) ALLOC_N(int, (l1+1));
 
   /* Initialize the current row. */
 
@@ -62,7 +60,9 @@ static VALUE levenshtein_distance_part2(VALUE self, VALUE rb_s1, VALUE rb_s2, VA
   for (row=1; row<=l2; row++) {
     /* Copy the current row to the previous row. */
 
-    memcpy(prev_row, curr_row, sizeof(int)*(l1+1));
+    temp_row	= prev_row;
+    prev_row	= curr_row;
+    curr_row	= temp_row;
 
     /* Calculate the values of the current row. */
 
@@ -70,27 +70,31 @@ static VALUE levenshtein_distance_part2(VALUE self, VALUE rb_s1, VALUE rb_s2, VA
     curr_row_min	= row;
 
     for (col=1; col<=l1; col++) {
-      /* Equal (cost=0) or Substitution (cost=1). */
+      /* Equal (cost=0) or substitution (cost=1). */
 
-      curr_row[col]	= prev_row[col-1] + ((s1[col-1] == s2[row-1]) ? 0 : 1);
+      value1	= prev_row[col-1] + ((p1[col-1] == p2[row-1]) ? 0 : 1);
 
       /* Insertion if it's cheaper than substitution. */
 
-      if (prev_row[col]+1 < curr_row[col]) {
-        curr_row[col] = prev_row[col]+1;
+      value2	= prev_row[col]+1;
+      if (value2 < value1) {
+        value1	= value2;
       }
 
       /* Deletion if it's cheaper than substitution. */
 
-      if (curr_row[col-1]+1 < curr_row[col]) {
-        curr_row[col] = curr_row[col-1]+1;
+      value2	= curr_row[col-1]+1;
+      if (value2 < value1) {
+        value1	= value2;
       }
 
       /* Keep track of the minimum value on this row. */
 
-      if (curr_row[col] < curr_row_min) {
-        curr_row_min	= curr_row[col];
+      if (value1 < curr_row_min) {
+        curr_row_min	= value1;
       }
+
+      curr_row[col]	= value1;
     }
 
     /* Return nil as soon as we exceed the threshold. */
@@ -115,8 +119,8 @@ static VALUE levenshtein_distance_part2(VALUE self, VALUE rb_s1, VALUE rb_s2, VA
   return INT2FIX(result);
 }
 
-void Init_levenshtein_c() {
-  VALUE mLevenshtein	= rb_define_module("Levenshtein");
+void Init_levenshtein_fast() {
+  mLevenshtein	= rb_const_get(rb_mKernel, rb_intern("Levenshtein"));
 
-  rb_define_singleton_method(mLevenshtein, "distance_part2_fast" , levenshtein_distance_part2, 3);
+  rb_define_singleton_method(mLevenshtein, "distance_fast" , levenshtein_distance_fast, 3);
 }

data/lib/levenshtein/version.rb

@@ -0,0 +1,5 @@
+# encoding: UTF-8
+
+module Levenshtein
+  VERSION	= "0.2.2"
+end

data/lib/levenshtein.rb

@@ -1,100 +1,148 @@
-begin
-  require "levenshtein/levenshtein_c"
-rescue LoadError
-  begin
-    require "levenshtein_c"
-  rescue LoadError
-    $stderr.puts "WARNING: Couldn't find the fast C implementation of Levenshtein.distance_part2. Using the slow Ruby version instead."
-  end
-end
+# encoding: UTF-8
 
-# The Levenshtein distance is a metric for measuring the amount of difference
-# between two sequences (i.e., the so called edit distance). The Levenshtein
-# distance between two strings is given by the minimum number of operations
-# needed to transform one string into the other, where an operation is an
-# insertion, deletion, or substitution of a single character.
-#
-# More information about the Levenshtein distance algorithm:
-# http://en.wikipedia.org/wiki/Levenshtein_distance .
+require "levenshtein/version"
 
 module Levenshtein
-  # Returns the Levenshtein distance as a number bestween 0.0 and 1.0.
-  # It's basically the Levenshtein distance divided by the length of the longest string.
-
-  def self.normalized_distance(s1, s2, threshold=nil)
-    s1, s2	= s2, s1	if s1.length > s2.length	# s1 is the short one; s2 is the long one.
-
-    if s2.empty?
-      0.0	# Since s1.length < s2.length, s1 must be empty as well.
+  # Returns the Levenshtein distance as a number between 0.0 and
+  # 1.0. It's basically the Levenshtein distance divided by the
+  # size of the longest sequence.
+
+  def self.normalized_distance(a1, a2, threshold=nil, options={})
+    size	= [a1.size, a2.size].max
+
+    if a1.size == 0 and a2.size == 0
+      0.0
+    elsif a1.size == 0
+      a2.size.to_f/size
+    elsif a2.size == 0
+      a1.size.to_f/size
     else
       if threshold
-        if d = self.distance(s1, s2, (threshold*s2.length+1).to_i)
-          d.to_f/s2.length
+        if d = self.distance(a1, a2, (threshold*size).to_i+1)
+          d.to_f/size
         else
           nil
         end
       else
-        self.distance(s1, s2).to_f/s2.length
+        self.distance(a1, a2).to_f/size
       end
     end
   end
 
-  # Returns the Levenshtein distance between two byte strings.
+  # Returns the Levenshtein distance between two sequences.
+  #
+  # The two sequences can be two strings, two arrays, or two other
+  # objects responding to :each. All sequences are by generic
+  # (fast) C code.
+  #
+  # All objects in the sequences should respond to :hash and :eql?.
 
-  def self.distance(s1, s2, threshold=nil)
-    s1, s2	= s2, s1	if s1.length > s2.length	# s1 is the short one; s2 is the long one.
+  def self.distance(a1, a2, threshold=nil, options={})
+    a1, a2	= a1.scan(/./), a2.scan(/./)	if String === a1 and String === a2
+    a1, a2	= Util.pool(a1, a2)
 
     # Handle some basic circumstances.
 
-    return 0.0		if s1 == s2
-    return s2.length	if s1.empty?
-    return nil		if threshold and (s2.length-s1.length) >= threshold
-    return nil		if threshold and (s1.scan(/./) - s2.scan(/./)).length >= threshold
-    return nil		if threshold and (s2.scan(/./) - s1.scan(/./)).length >= threshold
+    return 0		if a1 == a2
+    return a2.size	if a1.empty?
+    return a1.size	if a2.empty?
 
-    # Do the expensive calculation on a subset of the strings only, if possible.
+    if threshold
+      return nil	if (a1.size-a2.size) >= threshold
+      return nil	if (a2.size-a1.size) >= threshold
+      return nil	if (a1-a2).size >= threshold
+      return nil	if (a2-a1).size >= threshold
+    end
+
+    # Remove the common prefix and the common postfix.
 
-    b	= 0
-    e1	= s1.length-1
-    e2	= s2.length-1
+    l1	= a1.size
+    l2	= a2.size
 
-    while s1[b, 1] == s2[b, 1]
-      b += 1
+    offset			= 0
+    no_more_optimizations	= true
+ 
+    while offset < l1 and offset < l2 and a1[offset].equal?(a2[offset])
+      offset += 1
+
+      no_more_optimizations	= false
     end
+ 
+    while offset < l1 and offset < l2 and a1[l1-1].equal?(a2[l2-1])
+      l1 -= 1
+      l2 -= 1
 
-    while s1[e1, 1] == s2[e2, 1]
-      e1 -= 1
-      e2 -= 1
+      no_more_optimizations	= false
     end
+ 
+    if no_more_optimizations
+      distance_fast_or_slow(a1, a2, threshold, options)
+    else
+      l1 -= offset
+      l2 -= offset
 
-    distance_part2(s1[b..e1], s2[b..e2], threshold)
+      a1	= a1[offset, l1]
+      a2	= a2[offset, l2]
+
+      distance(a1, a2, threshold, options)
+    end
   end
 
-  def self.distance_part2(s1, s2, threshold)	# :nodoc:
-    if respond_to?(:distance_part2_fast)
-      distance_part2_fast(s1, s2, threshold)	# Implemented in C.
+  def self.distance_fast_or_slow(a1, a2, threshold, options)	# :nodoc:
+    if respond_to?(:distance_fast) and options[:force_slow]
+      distance_fast(a1, a2, threshold)	# Implemented in C.
     else
-      distance_part2_slow(s1, s2, threshold)	# Implemented in Ruby.
+      distance_slow(a1, a2, threshold)	# Implemented in Ruby.
     end
   end
 
-  def self.distance_part2_slow(s1, s2, threshold)	# :nodoc:
-    row	= (0..s1.length).to_a
+  def self.distance_slow(a1, a2, threshold)	# :nodoc:
+    crow	= (0..a1.size).to_a
 
-    1.upto(s2.length) do |y|
-      prow	= row
-      row	= [y]
+    1.upto(a2.size) do |y|
+      prow	= crow
+      crow	= [y]
 
-      1.upto(s1.length) do |x|
-        row[x]	= [prow[x]+1, row[x-1]+1, prow[x-1]+(s1[x-1]==s2[y-1] ? 0 : 1)].min
+      1.upto(a1.size) do |x|
+        crow[x]	= [prow[x]+1, crow[x-1]+1, prow[x-1]+(a1[x-1].equal?(a2[y-1]) ? 0 : 1)].min
       end
 
-      # Stop analysing this string as soon as the best possible result for this string is bigger than the best result so far.
-      # (The minimum value in the next row will be equal to or greater than the minimum value in this row.)
+      # Stop analysing this sequence as soon as the best possible
+      # result for this sequence is bigger than the best result so far.
+      # (The minimum value in the next row will be equal to or greater
+      # than the minimum value in this row.)
+
+      return nil	if threshold and crow.min >= threshold
+    end
+
+    crow[-1]
+  end
+
+  module Util	# :nodoc:
+    def self.pool(*args)
+      # So we can compare pointers instead of objects (equal?() instead of ==()).
+
+      pool	= {}
+
+      args.collect do |arg|
+        a	= []
+
+        arg.each do |o|
+          a << pool[o] ||= o
+        end
 
-      return nil	if threshold and row.min >= threshold
+        a
+      end
     end
+  end
+end
 
-    row[-1]
+begin
+  require "levenshtein/levenshtein_fast"	# Compiled by RubyGems.
+rescue LoadError
+  begin
+    require "levenshtein_fast"			# Compiled by the build script.
+  rescue LoadError
+    $stderr.puts "WARNING: Couldn't find the fast C implementation of Levenshtein. Using the much slower Ruby version instead."
   end
 end

data/test/test.rb

@@ -1,6 +1,39 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
 require "test/unit"
 require "levenshtein"
 
+module Levenshtein
+  class TestSequence
+    def initialize(o)
+      @sequence	= o
+    end
+  
+    def each
+      @sequence.length.times do |pos|
+        yield(@sequence[pos])
+      end
+    end
+  end
+  
+  class TestElement
+    attr_reader :object
+
+    def initialize(o)
+      @object	= o
+    end
+
+    def hash
+      @object.hash
+    end
+ 
+    def eql?(other)
+      @object.eql?(other.object)
+    end
+  end
+end
+
 class TestLevenshtein < Test::Unit::TestCase
   def test_erik_veenstra
     assert_equal(7, Levenshtein.distance("erik", "veenstra"))
@@ -30,9 +63,11 @@ class TestLevenshtein < Test::Unit::TestCase
 
   def test_threshold
     assert_equal(3, Levenshtein.distance("foo", "foobar"))
+    assert_equal(3, Levenshtein.distance("foo", "foobar", 4))
     assert_equal(nil, Levenshtein.distance("foo", "foobar", 2))
 
     assert_in_delta(0.5, Levenshtein.normalized_distance("foo", "foobar"), 0.01)
+    assert_in_delta(0.5, Levenshtein.normalized_distance("foo", "foobar", 0.66), 0.01)
     assert_equal(nil, Levenshtein.normalized_distance("foo", "foobar", 0.30))
   end
 
@@ -40,51 +75,80 @@ class TestLevenshtein < Test::Unit::TestCase
     assert_equal(3, Levenshtein.distance("ab123cd", "abxyzcd"))
     assert_equal(3, Levenshtein.distance("ab123", "abxyz"))
     assert_equal(3, Levenshtein.distance("123cd", "xyzcd"))
+    assert_equal(5, Levenshtein.distance("123cd123", "123"))
 
     assert_in_delta(0.42, Levenshtein.normalized_distance("ab123cd", "abxyzcd"), 0.01)
     assert_in_delta(0.6, Levenshtein.normalized_distance("ab123", "abxyz"), 0.01)
     assert_in_delta(0.6, Levenshtein.normalized_distance("123cd", "xyzcd"), 0.01)
+    assert_in_delta(0.625, Levenshtein.normalized_distance("123cd123", "123"), 0.01)
+  end
+
+  def test_interface
+    seq1	= Levenshtein::TestSequence.new("erik".scan(/./).collect{|e| Levenshtein::TestElement.new(e)})
+    seq2	= Levenshtein::TestSequence.new("veenstra".scan(/./).collect{|e| Levenshtein::TestElement.new(e)})
+
+    assert_equal(7, Levenshtein.distance(seq1, seq2))
   end
 end
 
-class TestLevenshteinPart2Slow < Test::Unit::TestCase
+class TestLevenshteinFast < Test::Unit::TestCase
   def test_erik_veenstra
-    assert_equal(7, Levenshtein.distance_part2_slow("erik", "veenstra", nil))
+    assert_equal(7, Levenshtein.distance("erik", "veenstra", nil, :force_slow=>false))
+    assert_equal(7, Levenshtein.distance("veenstra", "erik", nil, :force_slow=>false))
   end
 
   def test_empty_string
-    assert_equal(0, Levenshtein.distance_part2_slow("", "", nil))
-    assert_equal(3, Levenshtein.distance_part2_slow("", "foo", nil))
+    assert_equal(0, Levenshtein.distance("", "", nil, :force_slow=>false))
+    assert_equal(3, Levenshtein.distance("", "foo", nil, :force_slow=>false))
+    assert_equal(3, Levenshtein.distance("foo", "", nil, :force_slow=>false))
   end
 
   def test_same_string
-    assert_equal(0, Levenshtein.distance_part2_slow("", "", nil))
-    assert_equal(0, Levenshtein.distance_part2_slow("foo", "foo", nil))
+    assert_equal(0, Levenshtein.distance("", "", nil, :force_slow=>false))
+    assert_equal(0, Levenshtein.distance("foo", "foo", nil, :force_slow=>false))
   end
 
   def test_threshold
-    assert_equal(3, Levenshtein.distance_part2_slow("foo", "foobar", nil))
-    assert_equal(nil, Levenshtein.distance_part2_slow("foo", "foobar", 2))
+    assert_equal(3, Levenshtein.distance("foo", "foobar", nil, :force_slow=>false))
+    assert_equal(3, Levenshtein.distance("foo", "foobar", 4, :force_slow=>false))
+    assert_equal(nil, Levenshtein.distance("foo", "foobar", 2, :force_slow=>false))
+  end
+
+  def test_same_head_and_or_tail
+    assert_equal(3, Levenshtein.distance("ab123cd", "abxyzcd", nil, :force_slow=>false))
+    assert_equal(3, Levenshtein.distance("ab123", "abxyz", nil, :force_slow=>false))
+    assert_equal(3, Levenshtein.distance("123cd", "xyzcd", nil, :force_slow=>false))
+    assert_equal(5, Levenshtein.distance("123cd123", "123", nil, :force_slow=>false))
   end
 end
 
-class TestLevenshteinPart2Fast < Test::Unit::TestCase
+class TestLevenshteinSlow < Test::Unit::TestCase
   def test_erik_veenstra
-    assert_equal(7, Levenshtein.distance_part2_fast("erik", "veenstra", nil))
+    assert_equal(7, Levenshtein.distance("erik", "veenstra", nil, :force_slow=>true))
+    assert_equal(7, Levenshtein.distance("veenstra", "erik", nil, :force_slow=>true))
   end
 
   def test_empty_string
-    assert_equal(0, Levenshtein.distance_part2_fast("", "", nil))
-    assert_equal(3, Levenshtein.distance_part2_fast("", "foo", nil))
+    assert_equal(0, Levenshtein.distance("", "", nil, :force_slow=>true))
+    assert_equal(3, Levenshtein.distance("", "foo", nil, :force_slow=>true))
+    assert_equal(3, Levenshtein.distance("foo", "", nil, :force_slow=>true))
   end
 
   def test_same_string
-    assert_equal(0, Levenshtein.distance_part2_fast("", "", nil))
-    assert_equal(0, Levenshtein.distance_part2_fast("foo", "foo", nil))
+    assert_equal(0, Levenshtein.distance("", "", nil, :force_slow=>true))
+    assert_equal(0, Levenshtein.distance("foo", "foo", nil, :force_slow=>true))
   end
 
   def test_threshold
-    assert_equal(3, Levenshtein.distance_part2_fast("foo", "foobar", nil))
-    assert_equal(nil, Levenshtein.distance_part2_fast("foo", "foobar", 2))
+    assert_equal(3, Levenshtein.distance("foo", "foobar", nil, :force_slow=>true))
+    assert_equal(3, Levenshtein.distance("foo", "foobar", 4, :force_slow=>true))
+    assert_equal(nil, Levenshtein.distance("foo", "foobar", 2, :force_slow=>true))
+  end
+
+  def test_same_head_and_or_tail
+    assert_equal(3, Levenshtein.distance("ab123cd", "abxyzcd", nil, :force_slow=>true))
+    assert_equal(3, Levenshtein.distance("ab123", "abxyz", nil, :force_slow=>true))
+    assert_equal(3, Levenshtein.distance("123cd", "xyzcd", nil, :force_slow=>true))
+    assert_equal(5, Levenshtein.distance("123cd123", "123", nil, :force_slow=>true))
   end
 end

metadata

@@ -1,65 +1,64 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: levenshtein
-version: !ruby/object:Gem::Version 
-  version: 0.1.0
+version: !ruby/object:Gem::Version
+  version: 0.2.2
+  prerelease: 
 platform: ruby
-authors: 
+authors:
 - Erik Veenstra
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2008-05-24 00:00:00 +02:00
-default_executable: 
+date: 2012-03-16 00:00:00.000000000 Z
 dependencies: []
-
 description: Calculates the Levenshtein distance between two byte strings.
 email: levenshtein@erikveen.dds.nl
 executables: []
-
-extensions: 
+extensions:
 - ext/levenshtein/extconf.rb
 extra_rdoc_files: []
-
-files: 
+files:
+- lib/levenshtein/version.rb
 - lib/levenshtein.rb
-- ext/levenshtein
+- ext/levenshtein/levenshtein.h
+- ext/levenshtein/levenshtein_fast.c
 - ext/levenshtein/extconf.rb
-- ext/levenshtein/levenshtein_c.c
 - README
 - LICENSE
 - VERSION
-has_rdoc: true
+- CHANGELOG
+- test/test.rb
 homepage: http://www.erikveen.dds.nl/levenshtein/index.html
+licenses: []
 post_install_message: 
-rdoc_options: 
+rdoc_options:
 - README
 - LICENSE
 - VERSION
+- CHANGELOG
 - --title
-- levenshtein (0.1.0)
+- levenshtein (0.2.2)
 - --main
 - README
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-  version: 
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-  version: 
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: levenshtein
-rubygems_version: 1.0.1
+rubygems_version: 1.8.18
 signing_key: 
-specification_version: 2
+specification_version: 3
 summary: Calculates the Levenshtein distance between two byte strings.
-test_files: 
+test_files:
 - test/test.rb