levenshtein-extended 0.0.1

data/.gitignore

@@ -0,0 +1,7 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+*/.DS_Store
+tmp/*
+*/.DS_Store

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in levenshtein.gemspec
+gemspec

data/README

@@ -0,0 +1,14 @@
+The levenshtein module implements fast Damerau-Levenshtein edit distance computation in O(n) memory and O(n^2) time, using a C wrapper.
+
+USAGE:
+
+@install
+git clone git://github.com/esdras/levenshtein.git
+cd levenshtein
+rake compile
+rake install
+
+@usage
+require 'levenshtein'
+Levenshtein.normalized_distance("string 1", "string 2")
+Levenshtein.normalized_distance([2, 3, 4, 5], [1, 2, 3, 4])

data/Rakefile

@@ -0,0 +1,3 @@
+require 'bundler/gem_tasks'
+require 'rake/extensiontask'
+Rake::ExtensionTask.new('levenshtein_in_c')

data/ext/levenshtein_in_c/extconf.rb

@@ -0,0 +1,10 @@
+require "mkmf"
+
+dir_config("levenshtein_in_c")
+
+have_library("levenshtein_array")
+have_library("levenshtein_array_of_strings")
+have_library("levenshtein_generic")
+have_library("levenshtein_string")
+
+create_makefile("levenshtein_in_c/levenshtein_in_c")

data/ext/levenshtein_in_c/levenshtein_array.c

@@ -0,0 +1,127 @@
+#include "ruby.h"
+
+VALUE levenshtein_distance_array(VALUE self, VALUE rb_o1, VALUE rb_o2, VALUE rb_threshold) {
+  int	threshold;
+  long	l1, l2;
+  int	*prev_row, *curr_row;
+  int	col, row;
+  int	curr_row_min, result;
+  int	offset;
+
+  ID id_eql	= rb_intern("==");
+
+  /* Get the sizes of both arrays. */
+
+  l1	= RARRAY_LEN(RARRAY(rb_o1));
+  l2	= RARRAY_LEN(RARRAY(rb_o2));
+
+  /* Convert Ruby's threshold to C's threshold. */
+
+  if (!NIL_P(rb_threshold)) {
+    threshold	= FIX2INT(rb_threshold);
+  } else {
+    threshold	= -1;
+  }
+
+  /* Do the expensive calculation on a subset of the sequences, if possible, by removing the common prefix. */
+
+  offset	= 0;
+  while RTEST(rb_funcall(rb_ary_entry(rb_o1, offset), id_eql, 1, rb_ary_entry(rb_o2, offset))) {
+    offset++;
+  }
+
+  /* Do the expensive calculation on a subset of the sequences, if possible, by removing the common postfix. */
+
+  while ((l1-1 > offset) && (l2-1 > offset) && RTEST(rb_funcall(rb_ary_entry(rb_o1, l1-1), id_eql, 1, rb_ary_entry(rb_o2, l2-1)))) {
+    l1--;
+    l2--;
+  }
+
+  l1 -= offset;
+  l2 -= offset;
+
+  /* The Levenshtein algorithm itself. */
+
+  /*       s1=              */
+  /*       ERIK             */
+  /*                        */
+  /*      01234             */
+  /* s2=V 11234             */
+  /*    E 21234             */
+  /*    E 32234             */
+  /*    N 43334 <- prev_row */
+  /*    S 54444 <- curr_row */
+  /*    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");
+  }
+
+  /* Initialize the current row. */
+
+  for (col=0; col<=l1; col++) {
+    curr_row[col]	= col;
+  }
+
+  for (row=1; row<=l2; row++) {
+    /* Copy the current row to the previous row. */
+
+    memcpy(prev_row, curr_row, sizeof(int)*(l1+1));
+
+    /* Calculate the values of the current row. */
+
+    curr_row[0]		= row;
+    curr_row_min	= row;
+
+    for (col=1; col<=l1; col++) {
+      /* Equal (cost=0) or substitution (cost=1). */
+
+      curr_row[col]	= prev_row[col-1] + (RTEST(rb_funcall(rb_ary_entry(rb_o1, offset+col-1), id_eql, 1, rb_ary_entry(rb_o2, offset+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;
+      }
+
+      /* Deletion if it's cheaper than substitution. */
+
+      if (curr_row[col-1]+1 < curr_row[col]) {
+        curr_row[col] = curr_row[col-1]+1;
+      }
+
+      /* Keep track of the minimum value on this row. */
+
+      if (curr_row[col] < curr_row_min) {
+        curr_row_min	= curr_row[col];
+      }
+    }
+
+    /* Return nil as soon as we exceed the threshold. */
+
+    if (threshold > -1 && curr_row_min >= threshold) {
+      free(prev_row);
+      free(curr_row);
+
+      return Qnil;
+    }
+  }
+
+  /* The result is the last value on the last row. */
+
+  result	= curr_row[l1];
+
+  free(prev_row);
+  free(curr_row);
+
+  /* Return the Ruby version of the result. */
+
+  return INT2FIX(result);
+}

data/ext/levenshtein_in_c/levenshtein_array_of_strings.c

@@ -0,0 +1,125 @@
+#include "ruby.h"
+
+VALUE levenshtein_distance_array_of_strings(VALUE self, VALUE rb_o1, VALUE rb_o2, VALUE rb_threshold) {
+  int	threshold;
+  long	l1, l2;
+  int	*prev_row, *curr_row;
+  int	col, row;
+  int	curr_row_min, result;
+  int	offset;
+
+  /* Get the sizes of both arrays. */
+
+  l1	= RARRAY_LEN(RARRAY(rb_o1));
+  l2	= RARRAY_LEN(RARRAY(rb_o2));
+
+  /* Convert Ruby's threshold to C's threshold. */
+
+  if (!NIL_P(rb_threshold)) {
+    threshold	= FIX2INT(rb_threshold);
+  } else {
+    threshold	= -1;
+  }
+
+  /* Do the expensive calculation on a subset of the sequences, if possible, by removing the common prefix. */
+
+  offset	= 0;
+  while (rb_str_cmp(rb_ary_entry(rb_o1, offset), rb_ary_entry(rb_o2, offset)) == 0) {
+    offset++;
+  }
+
+  /* Do the expensive calculation on a subset of the sequences, if possible, by removing the common postfix. */
+
+  while ((l1-1 > offset) && (l2-1 > offset) && (rb_str_cmp(rb_ary_entry(rb_o1, l1-1), rb_ary_entry(rb_o2, l2-1)) == 0 )) {
+    l1--;
+    l2--;
+  }
+
+  l1 -= offset;
+  l2 -= offset;
+
+  /* The Levenshtein algorithm itself. */
+
+  /*       s1=              */
+  /*       ERIK             */
+  /*                        */
+  /*      01234             */
+  /* s2=V 11234             */
+  /*    E 21234             */
+  /*    E 32234             */
+  /*    N 43334 <- prev_row */
+  /*    S 54444 <- curr_row */
+  /*    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");
+  }
+
+  /* Initialize the current row. */
+
+  for (col=0; col<=l1; col++) {
+    curr_row[col]	= col;
+  }
+
+  for (row=1; row<=l2; row++) {
+    /* Copy the current row to the previous row. */
+
+    memcpy(prev_row, curr_row, sizeof(int)*(l1+1));
+
+    /* Calculate the values of the current row. */
+
+    curr_row[0]		= row;
+    curr_row_min	= row;
+
+    for (col=1; col<=l1; col++) {
+      /* Equal (cost=0) or substitution (cost=1). */
+
+      curr_row[col]	= prev_row[col-1] + ((rb_str_cmp(rb_ary_entry(rb_o1, offset+col-1), rb_ary_entry(rb_o2, offset+row-1)) == 0) ? 0 : 1);
+
+      /* Insertion if it's cheaper than substitution. */
+
+      if (prev_row[col]+1 < curr_row[col]) {
+        curr_row[col] = prev_row[col]+1;
+      }
+
+      /* Deletion if it's cheaper than substitution. */
+
+      if (curr_row[col-1]+1 < curr_row[col]) {
+        curr_row[col] = curr_row[col-1]+1;
+      }
+
+      /* Keep track of the minimum value on this row. */
+
+      if (curr_row[col] < curr_row_min) {
+        curr_row_min	= curr_row[col];
+      }
+    }
+
+    /* Return nil as soon as we exceed the threshold. */
+
+    if (threshold > -1 && curr_row_min >= threshold) {
+      free(prev_row);
+      free(curr_row);
+
+      return Qnil;
+    }
+  }
+
+  /* The result is the last value on the last row. */
+
+  result	= curr_row[l1];
+
+  free(prev_row);
+  free(curr_row);
+
+  /* Return the Ruby version of the result. */
+
+  return INT2FIX(result);
+}

data/ext/levenshtein_in_c/levenshtein_fast.c

@@ -0,0 +1,21 @@
+#include "ruby.h"
+
+VALUE levenshtein_distance_fast(VALUE self, VALUE rb_o1, VALUE rb_o2, VALUE rb_threshold) {
+  if ((TYPE(rb_o1) == T_STRING) && (TYPE(rb_o2)) == T_STRING) {
+    return levenshtein_distance_string(self, rb_o1, rb_o2, rb_threshold);
+  } else if ((TYPE(rb_o1) == T_ARRAY) && (TYPE(rb_o2)) == T_ARRAY) {
+    if ((TYPE(rb_ary_entry(rb_o1, 0)) == T_STRING) && (TYPE(rb_ary_entry(rb_o2, 0))) == T_STRING) {
+      return levenshtein_distance_array_of_strings(self, rb_o1, rb_o2, rb_threshold);
+    } else {
+      return levenshtein_distance_array(self, rb_o1, rb_o2, rb_threshold);
+    }
+  } else {
+    return levenshtein_distance_generic(self, rb_o1, rb_o2, rb_threshold);
+  }
+}
+
+void Init_levenshtein_in_c() {
+  VALUE mLevenshtein	= rb_define_module("Levenshtein");
+
+  rb_define_singleton_method(mLevenshtein, "levenshtein_distance_fast" , levenshtein_distance_fast, 3);
+}

data/ext/levenshtein_in_c/levenshtein_generic.c

@@ -0,0 +1,129 @@
+#include "ruby.h"
+
+VALUE levenshtein_distance_generic(VALUE self, VALUE rb_o1, VALUE rb_o2, VALUE rb_threshold) {
+  int	threshold;
+  int	l1, l2;
+  int	*prev_row, *curr_row;
+  int	col, row;
+  int	curr_row_min, result;
+  int	offset;
+
+  ID id_length	= rb_intern("length");
+  ID id_get	= rb_intern("[]");
+  ID id_equal	= rb_intern("==");
+
+  /* Get the sizes of both sequences. */
+
+  l1	= FIX2INT(rb_funcall(rb_o1, id_length, 0));
+  l2	= FIX2INT(rb_funcall(rb_o2, id_length, 0));
+
+  /* Convert Ruby's threshold to C's threshold. */
+
+  if (!NIL_P(rb_threshold)) {
+    threshold	= FIX2INT(rb_threshold);
+  } else {
+    threshold	= -1;
+  }
+
+  /* Do the expensive calculation on a subset of the sequences, if possible, by removing the common prefix. */
+
+  offset	= 0;
+  while RTEST(rb_funcall(rb_funcall(rb_o1, id_get, 1, INT2FIX(offset)), id_equal, 1, rb_funcall(rb_o2, id_get, 1, INT2FIX(offset)))) {
+    offset++;
+  }
+
+  /* Do the expensive calculation on a subset of the sequences, if possible, by removing the common postfix. */
+
+  while ((l1-1 > offset) && (l2-1 > offset) && RTEST(rb_funcall(rb_funcall(rb_o1, id_get, 1, INT2FIX(l1-1)), id_equal, 1, rb_funcall(rb_o2, id_get, 1, INT2FIX(l2-1))))) {
+    l1--;
+    l2--;
+  }
+
+  l1 -= offset;
+  l2 -= offset;
+
+  /* The Levenshtein algorithm itself. */
+
+  /*       s1=              */
+  /*       ERIK             */
+  /*                        */
+  /*      01234             */
+  /* s2=V 11234             */
+  /*    E 21234             */
+  /*    E 32234             */
+  /*    N 43334 <- prev_row */
+  /*    S 54444 <- curr_row */
+  /*    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");
+  }
+
+  /* Initialize the current row. */
+
+  for (col=0; col<=l1; col++) {
+    curr_row[col]	= col;
+  }
+
+  for (row=1; row<=l2; row++) {
+    /* Copy the current row to the previous row. */
+
+    memcpy(prev_row, curr_row, sizeof(int)*(l1+1));
+
+    /* Calculate the values of the current row. */
+
+    curr_row[0]		= row;
+    curr_row_min	= row;
+
+    for (col=1; col<=l1; col++) {
+      /* Equal (cost=0) or substitution (cost=1). */
+
+      curr_row[col]	= prev_row[col-1] + (RTEST(rb_funcall(rb_funcall(rb_o1, id_get, 1, INT2FIX(offset+col-1)), id_equal, 1, rb_funcall(rb_o2, id_get, 1, INT2FIX(offset+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;
+      }
+
+      /* Deletion if it's cheaper than substitution. */
+
+      if (curr_row[col-1]+1 < curr_row[col]) {
+        curr_row[col] = curr_row[col-1]+1;
+      }
+
+      /* Keep track of the minimum value on this row. */
+
+      if (curr_row[col] < curr_row_min) {
+        curr_row_min	= curr_row[col];
+      }
+    }
+
+    /* Return nil as soon as we exceed the threshold. */
+
+    if (threshold > -1 && curr_row_min >= threshold) {
+      free(prev_row);
+      free(curr_row);
+
+      return Qnil;
+    }
+  }
+
+  /* The result is the last value on the last row. */
+
+  result	= curr_row[l1];
+
+  free(prev_row);
+  free(curr_row);
+
+  /* Return the Ruby version of the result. */
+
+  return INT2FIX(result);
+}

data/ext/levenshtein_in_c/levenshtein_string.c

@@ -0,0 +1,133 @@
+#include "ruby.h"
+
+VALUE levenshtein_distance_string(VALUE self, VALUE rb_o1, VALUE rb_o2, VALUE rb_threshold) {
+  int	threshold;
+  long	l1, l2;
+  int	*prev_row, *curr_row;
+  int	col, row;
+  int	curr_row_min, result;
+  int	offset;
+  char	*s1, *s2;
+
+  /* Convert Ruby's s1 to C's s1. */
+
+  rb_o1	= StringValue(rb_o1);
+  s1	= RSTRING_PTR(RSTRING(rb_o1));
+  l1	= RSTRING_LEN(RSTRING(rb_o1));
+
+  /* Convert Ruby's s2 to C's s2. */
+
+  rb_o2	= StringValue(rb_o2);
+  s2	= RSTRING_PTR(RSTRING(rb_o2));
+  l2	= RSTRING_LEN(RSTRING(rb_o2));
+
+  /* Convert Ruby's threshold to C's threshold. */
+
+  if (!NIL_P(rb_threshold)) {
+    threshold	= FIX2INT(rb_threshold);
+  } else {
+    threshold	= -1;
+  }
+
+  /* Do the expensive calculation on a subset of the sequences, if possible, by removing the common prefix. */
+
+  offset	= 0;
+  while (s1[offset] == s2[offset]) {
+    offset++;
+  }
+
+  /* Do the expensive calculation on a subset of the sequences, if possible, by removing the common postfix. */
+
+  while ((l1-1 > offset) && (l2-1 > offset) && (s1[l1-1] == s2[l2-1])) {
+    l1--;
+    l2--;
+  }
+
+  l1 -= offset;
+  l2 -= offset;
+
+  /* The Levenshtein algorithm itself. */
+
+  /*       s1=              */
+  /*       ERIK             */
+  /*                        */
+  /*      01234             */
+  /* s2=V 11234             */
+  /*    E 21234             */
+  /*    E 32234             */
+  /*    N 43334 <- prev_row */
+  /*    S 54444 <- curr_row */
+  /*    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");
+  }
+
+  /* Initialize the current row. */
+
+  for (col=0; col<=l1; col++) {
+    curr_row[col]	= col;
+  }
+
+  for (row=1; row<=l2; row++) {
+    /* Copy the current row to the previous row. */
+
+    memcpy(prev_row, curr_row, sizeof(int)*(l1+1));
+
+    /* Calculate the values of the current row. */
+
+    curr_row[0]		= row;
+    curr_row_min	= row;
+
+    for (col=1; col<=l1; col++) {
+      /* Equal (cost=0) or substitution (cost=1). */
+
+      curr_row[col]	= prev_row[col-1] + ((s1[offset+col-1] == s2[offset+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;
+      }
+
+      /* Deletion if it's cheaper than substitution. */
+
+      if (curr_row[col-1]+1 < curr_row[col]) {
+        curr_row[col] = curr_row[col-1]+1;
+      }
+
+      /* Keep track of the minimum value on this row. */
+
+      if (curr_row[col] < curr_row_min) {
+        curr_row_min	= curr_row[col];
+      }
+    }
+
+    /* Return nil as soon as we exceed the threshold. */
+
+    if (threshold > -1 && curr_row_min >= threshold) {
+      free(prev_row);
+      free(curr_row);
+
+      return Qnil;
+    }
+  }
+
+  /* The result is the last value on the last row. */
+
+  result	= curr_row[l1];
+
+  free(prev_row);
+  free(curr_row);
+
+  /* Return the Ruby version of the result. */
+
+  return INT2FIX(result);
+}

data/levenshtein.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "levenshtein/version"
+
+Gem::Specification.new do |s|
+  s.name        = "levenshtein-extended"
+  s.version     = Levenshtein::VERSION
+  s.authors     = ["Esdras Mayrink"]
+  s.email       = ["falecom@oesdras.com.br"]
+  s.homepage    = ""
+  s.summary     = "fast string edit distance computation, using the Damerau-Levenshtein algorithm"
+  s.description = "The levenshtein module implements fast Damerau-Levenshtein edit distance computation in O(n) memory and O(n^2) time, using a C wrapper."
+
+  s.rubyforge_project = "levenshtein"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/lib/levenshtein.rb

@@ -0,0 +1,108 @@
+begin
+  require "levenshtein/levenshtein_in_c"	# If compiled by RubyGems.
+rescue LoadError
+  begin
+    require "levenshtein_in_c"			# If compiled by the build script.
+  rescue LoadError
+    $stderr.puts "WARNING: Couldn't find the fast C implementation of Levenshtein.distance. Using the much slower Ruby version instead."
+  end
+end
+
+# 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.
+#
+# More information about the Levenshtein distance algorithm:
+# http://en.wikipedia.org/wiki/Levenshtein_distance .
+
+module Levenshtein
+
+  # Returns the Levenshtein distance as a number between 0.0 and
+  # 1.0. It's basically the Levenshtein distance divided by the
+  # length of the longest sequence.
+
+  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.length == 0
+      0.0	# Since s1.length < s2.length, s1 must be empty as well.
+    else
+      if threshold
+        if d = self.distance(s1, s2, (threshold*s2.length+1).to_i)
+          d.to_f/s2.length
+        else
+          nil
+        end
+      else
+        self.distance(s1, s2).to_f/s2.length
+      end
+    end
+  end
+
+  # Returns the Levenshtein distance between two sequences.
+  #
+  # The two sequences can be two strings, two arrays, or two other
+  # objects. Strings, arrays and arrays of strings are handled with
+  # optimized (very fast) C code. All other sequences are handled
+  # with generic (fast) C code.
+  #
+  # The sequences should respond to :length and :[] and all objects
+  # in the sequences (as returned by []) should response to :==.
+
+  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.
+
+    # Handle some basic circumstances.
+
+    return 0		if s1 == s2
+    return s2.length	if s1.length == 0
+
+    if threshold
+      return nil	if (s2.length-s1.length) >= threshold
+
+      a1, a2	= nil, nil
+      a1, a2	= s1, s2			if s1.respond_to?(:-) and s2.respond_to?(:-)
+      a1, a2	= s1.scan(/./), s2.scan(/./)	if s1.respond_to?(:scan) and s2.respond_to?(:scan)
+
+      if a1 and a2
+        return nil	if (a1-a2).length >= threshold
+        return nil	if (a2-a1).length >= threshold
+      end
+    end
+
+    distance_fast_or_slow(s1, s2, threshold)
+  end
+
+  def self.distance_fast_or_slow(s1, s2, threshold)	# :nodoc:
+    if respond_to?(:levenshtein_distance_fast)
+      levenshtein_distance_fast(s1, s2, threshold)	# Implemented in C.
+    else
+      levenshtein_distance_slow(s1, s2, threshold)	# Implemented in Ruby.
+    end
+  end
+
+  def self.levenshtein_distance_slow(s1, s2, threshold)	# :nodoc:
+    row	= (0..s1.length).to_a
+
+    1.upto(s2.length) do |y|
+      prow	= row
+      row	= [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
+      end
+
+      # 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 row.min >= threshold
+    end
+
+    row[-1]
+  end
+end

data/lib/levenshtein/version.rb

@@ -0,0 +1,3 @@
+module Levenshtein
+  VERSION = "0.0.1"
+end

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification 
+name: levenshtein-extended
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Esdras Mayrink
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-07-04 00:00:00 -03:00
+default_executable: 
+dependencies: []
+
+description: The levenshtein module implements fast Damerau-Levenshtein edit distance computation in O(n) memory and O(n^2) time, using a C wrapper.
+email: 
+- falecom@oesdras.com.br
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- README
+- Rakefile
+- ext/levenshtein_in_c/extconf.rb
+- ext/levenshtein_in_c/levenshtein_array.c
+- ext/levenshtein_in_c/levenshtein_array_of_strings.c
+- ext/levenshtein_in_c/levenshtein_fast.c
+- ext/levenshtein_in_c/levenshtein_generic.c
+- ext/levenshtein_in_c/levenshtein_string.c
+- levenshtein.gemspec
+- lib/levenshtein.rb
+- lib/levenshtein/version.rb
+- lib/levenshtein_in_c.bundle
+has_rdoc: true
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+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.5.2
+signing_key: 
+specification_version: 3
+summary: fast string edit distance computation, using the Damerau-Levenshtein algorithm
+test_files: []
+