aspell_edit_dist 0.1.0

data/.gitignore

@@ -0,0 +1,5 @@
+.idea/*
+Makefile
+*.o
+*.so
+mkmf.log

data/README

@@ -0,0 +1 @@
+This is a very simple gem, which purpose is to expose limit_edit_distance from aspell.

data/Rakefile

@@ -0,0 +1,12 @@
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "aspell_edit_dist"
+    gemspec.summary = "Gem that exposes limit_edit_distance function from Aspell."
+    gemspec.email = "adam@pohorecki.pl"
+    gemspec.homepage = "http://github.com/psyho/aspell_edit_dist"
+    gemspec.authors = ["Adam Pohorecki"]
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: gem install jeweler"
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/ext/aspell_edit_dist.cpp

@@ -0,0 +1,127 @@
+#include "aspell_edit_dist.h"
+#include "weights.hpp"
+#include "leditdist.hpp"
+
+// Forward declarations
+void Init_edit_distance_weights();
+void Init_limit_edit_distance();
+
+extern "C" void Init_aspell_edit_dist() {
+  Init_edit_distance_weights();
+  Init_limit_edit_distance();
+}
+
+static aspeller::EditDistanceWeights* get_weights(VALUE weights) {
+    aspeller::EditDistanceWeights* result;
+    Data_Get_Struct(weights, aspeller::EditDistanceWeights, result);
+    return result;
+}
+
+static void weights_free(aspeller::EditDistanceWeights* obj) {
+  if (obj) {
+    delete obj;
+  }
+}
+
+static VALUE weights_init(VALUE self) {
+  aspeller::EditDistanceWeights * new_obj = new aspeller::EditDistanceWeights();
+  return Data_Wrap_Struct(cEditDistanceWeights, 0, weights_free, new_obj);
+}
+
+static VALUE weights_del1(VALUE self) {
+  return INT2FIX(get_weights(self)->del1);
+}
+
+static VALUE weights_set_del1(VALUE self, VALUE val) {
+  get_weights(self)->del1 = NUM2INT(val);
+  return val;
+}
+
+static VALUE weights_del2(VALUE self) {
+  return INT2FIX(get_weights(self)->del2);
+}
+
+static VALUE weights_set_del2(VALUE self, VALUE val) {
+  get_weights(self)->del2 = NUM2INT(val);
+  return val;
+}
+
+static VALUE weights_swap(VALUE self) {
+  return INT2FIX(get_weights(self)->swap);
+}
+
+static VALUE weights_set_swap(VALUE self, VALUE val) {
+  get_weights(self)->swap = NUM2INT(val);
+  return val;
+}
+
+static VALUE weights_sub(VALUE self) {
+  return INT2FIX(get_weights(self)->sub);
+}
+
+static VALUE weights_set_sub(VALUE self, VALUE val) {
+  get_weights(self)->sub = NUM2INT(val);
+  return val;
+}
+
+static VALUE weights_similar(VALUE self) {
+  return INT2FIX(get_weights(self)->similar);
+}
+
+static VALUE weights_set_similar(VALUE self, VALUE val) {
+  get_weights(self)->similar = NUM2INT(val);
+  return val;
+}
+
+static VALUE weights_min(VALUE self) {
+  return INT2FIX(get_weights(self)->min);
+}
+
+static VALUE weights_set_min(VALUE self, VALUE val) {
+  get_weights(self)->min = NUM2INT(val);
+  return val;
+}
+
+static VALUE weights_max(VALUE self) {
+  return INT2FIX(get_weights(self)->max);
+}
+
+static VALUE weights_set_max(VALUE self, VALUE val) {
+  get_weights(self)->max = NUM2INT(val);
+  return val;
+}
+
+typedef VALUE (*rb_method)(...);
+
+void Init_edit_distance_weights() {
+  mAspell = rb_define_module("Aspeller");
+
+  cEditDistanceWeights = rb_define_class_under(mAspell, "EditDistanceWeights", rb_cObject);
+
+  rb_define_method(cEditDistanceWeights, "initialize", (rb_method)weights_init, 0);
+  rb_define_singleton_method(cEditDistanceWeights, "new", (rb_method)weights_init, 0);
+
+  rb_define_method(cEditDistanceWeights, "del1",    (rb_method)weights_del1,     0);
+  rb_define_method(cEditDistanceWeights, "del1=",   (rb_method)weights_set_del1, 1);
+  rb_define_method(cEditDistanceWeights, "del2",    (rb_method)weights_del2,     0);
+  rb_define_method(cEditDistanceWeights, "del2=",   (rb_method)weights_set_del2, 1);
+  rb_define_method(cEditDistanceWeights, "swap",    (rb_method)weights_swap,     0);
+  rb_define_method(cEditDistanceWeights, "swap=",   (rb_method)weights_set_swap, 1);
+  rb_define_method(cEditDistanceWeights, "sub",     (rb_method)weights_sub,      0);
+  rb_define_method(cEditDistanceWeights, "sub=",    (rb_method)weights_set_sub,  1);
+  rb_define_method(cEditDistanceWeights, "similar", (rb_method)weights_similar,  0);
+  rb_define_method(cEditDistanceWeights, "similar=",(rb_method)weights_set_similar, 1);
+  rb_define_method(cEditDistanceWeights, "min",     (rb_method)weights_min,      0);
+  rb_define_method(cEditDistanceWeights, "min=",    (rb_method)weights_set_min,  1);
+  rb_define_method(cEditDistanceWeights, "max",     (rb_method)weights_max,      0);
+  rb_define_method(cEditDistanceWeights, "max=",    (rb_method)weights_set_max,  1);
+}
+
+static VALUE aspell_limit_edit_distance(VALUE self, VALUE strA, VALUE strB, VALUE limit, VALUE weights) {
+  int result = aspeller::limit_edit_distance(STR2CSTR(strA), STR2CSTR(strB), NUM2INT(limit), *get_weights(weights));
+  return INT2FIX(result);
+}
+
+void Init_limit_edit_distance() {
+  rb_define_singleton_method(mAspell, "limit_edit_distance", (rb_method)aspell_limit_edit_distance, 4);
+}

data/ext/aspell_edit_dist.h

@@ -0,0 +1,9 @@
+#ifndef _ASPELL_EDIT_DIST_H
+#define _ASPELL_EDIT_DIST_H
+
+#include <ruby.h>
+
+VALUE mAspell;
+VALUE cEditDistanceWeights;
+
+#endif

data/ext/extconf.rb

@@ -0,0 +1,5 @@
+require "mkmf"
+
+have_header("ruby.h")
+have_library("stdc++")
+create_makefile("aspell_edit_dist")

data/ext/leditdist.cpp

@@ -0,0 +1,308 @@
+
+#include "leditdist.hpp"
+
+// The basic algorithm is as follows:
+//
+// Let A[n] represent the nth character of string n
+//     A[n..] represent the substring of A starting at n
+//            if n > length of A then it is considered an empty string
+//
+// edit_distance(A,B,limit) = ed(A,B,0)
+//   where ed(A,B,d) = d                              if A & B is empty.
+//                   = infinity                       if d > limit
+//                   = ed(A[2..],B[2..], d)           if A[1] == B[1] 
+//                   = min ( ed(A[2..],B[2..], d+1),  
+//                           ed(A,     B[2..], d+1),
+//                           ed(A[2..],B,      d+1) ) otherwise
+//
+// However, the code below:
+// 1) Also allows for swaps
+// 2) Allow weights to be attached to each edit
+// 3) Is not recursive, it uses a loop when it is tail recursion
+//    and a small stack otherwise.  The stack will NEVER be larger
+//    then 2 * limit.
+// 4) Is extremely optimized
+
+
+#define check_rest(a,b,s)   \
+  a0 = a; b0 = b;           \
+  while (*a0 == *b0) {      \
+    if (*a0 == '\0') {      \
+      if (s < min) min = s; \
+      break;                \
+    }                       \
+    ++a0; ++b0;             \
+  }
+
+namespace aspeller {
+
+  int limit_edit_distance(const char * a, const char * b, 
+			  int limit, const EditDistanceWeights & w)
+  {
+    limit = limit*w.max;
+    static const int size = 10;
+    struct Edit {
+      const char * a;
+      const char * b;
+      int score;
+    };
+    Edit begin[size];
+    Edit * i = begin;
+    const char * a0;
+    const char * b0;
+    int score = 0;
+    int min = LARGE_NUM;
+    
+    while (true) {
+      
+      while (*a == *b) {
+	if (*a == '\0') { 
+	  if (score < min) min = score;
+	  goto FINISH;
+	} 
+	++a; ++b;
+      }
+
+      if (*a == '\0') {
+
+	do {
+	  score += w.del2;
+	  if (score >= min) goto FINISH;
+	  ++b;
+	} while (*b != '\0');
+	min = score;
+	
+      } else if (*b == '\0') {
+	
+	do {
+	  score += w.del1;
+	  if (score >= min) goto FINISH;
+	  ++a;
+	} while (*a != '\0');
+	min = score;
+	
+      } else {
+
+	if (score + w.max <= limit) {
+	  if (limit*w.min <= w.max*(w.min+score)) {
+	    // if floor(score/max)=limit/max-1 then this edit is only good
+	    // if it makes the rest of the string match.  So check if
+	    // the rest of the string matches to avoid the overhead of
+	    // pushing it on then off the stack
+	    
+	    // delete a character from a
+	    check_rest(a+1,b,score + w.del1);
+	    
+	    // delete a character from b
+	    check_rest(a,b+1,score + w.del2);
+	    
+	    if (*a == *(b+1) && *b == *(a+1)) {
+
+	      // swap two characters
+	      check_rest(a+2,b+2, score + w.swap);
+
+	    } else {
+
+	      // substitute one character for another which is the same
+	      // thing as deleting a character from both a & b
+	      check_rest(a+1,b+1, score + w.sub);
+	    
+	    }
+	  
+	  } else {
+	  
+	    // delete a character from a
+	    i->a = a + 1;
+	    i->b = b;
+	    i->score = score + w.del1;
+	    ++i;
+	  
+	    // delete a character from b
+	    i->a = a;
+	    i->b = b + 1;
+	    i->score = score + w.del2;
+	    ++i;
+	    
+	    // If two characters can be swapped and make a match 
+	    // then the substitution is pointless.
+	    // Also, there is no need to push this on the stack as
+	    // it is going to be imminently removed.
+	    if (*a == *(b+1) && *b == *(a+1)) {
+	      
+	      // swap two characters
+	      a = a + 2;
+	      b = b + 2;
+	      score += w.swap;
+	      continue;
+	      
+	    } else {
+	      
+	      // substitute one character for another which is the same
+	      // thing as deleting a character from both a & b
+	      a = a + 1;
+	      b = b + 1;
+	      score += w.sub;
+	      continue;
+	    
+	    }
+	  }
+	}
+      }
+    FINISH:
+      if (i == begin) return min;
+      --i;
+      a = i->a;
+      b = i->b;
+      score = i->score;
+    }
+  }
+
+#undef check_rest
+#define check_rest(a,b,w)               \
+          a0 = a; b0 = b;               \
+          while(*a0 == *b0) {           \
+	    if (*a0 == '\0') {          \
+	      if (w < min) min = w;     \
+	      break;                    \
+	    }                           \
+	    ++a0;                       \
+	    ++b0;                       \
+          }                             \
+          if (amax < a0) amax = a0;
+
+#define check2(a,b,w)                                             \
+  aa = a; bb = b;                                                 \
+  while(*aa == *bb) {                                             \
+    if (*aa == '\0')  {                                           \
+      if (amax < aa) amax = aa;                                   \
+      if (w < min) min = w;                                       \
+      break;                                                      \
+    }                                                             \
+    ++aa; ++bb;                                                   \
+  }                                                               \
+  if (*aa == '\0') {                                              \
+    if (amax < aa) amax = aa;                                     \
+    if (*bb == '\0') {}                                           \
+    else if (*(bb+1) == '\0' && w+ws.del2 < min) min = w+ws.del2; \
+  } else if (*bb == '\0') {                                       \
+    ++aa;                                                         \
+    if (amax < aa) amax = aa;                                     \
+    if (*aa == '\0' && w+ws.del1 < min) min = w+ws.del1;          \
+  } else {                                                        \
+    check_rest(aa+1,bb,w+ws.del1);                                \
+    check_rest(aa,bb+1,w+ws.del2);                                \
+    if (*aa == *(bb+1) && *bb == *(aa+1)) {                       \
+      check_rest(aa+2,bb+2,w+ws.swap);                            \
+    } else {                                                      \
+      check_rest(aa+1,bb+1,w+ws.sub);                             \
+    }                                                             \
+  }
+
+  EditDist limit1_edit_distance(const char * a, const char * b,
+				const EditDistanceWeights & ws)
+  {
+    int min = LARGE_NUM;
+    const char * a0;
+    const char * b0;
+    const char * amax = a;
+    
+    while(*a == *b) { 
+      if (*a == '\0') 
+	return EditDist(0, a);
+      ++a; ++b;
+    }
+
+    if (*a == '\0') {
+      
+      ++b;
+      if (*b == '\0') return EditDist(ws.del2, a);
+      return EditDist(LARGE_NUM, a);
+      
+    } else if (*b == '\0') {
+
+      ++a;
+      if (*a == '\0') return EditDist(ws.del1, a);
+      return EditDist(LARGE_NUM, a);
+      
+    } else {
+      
+      // delete a character from a
+      check_rest(a+1,b,ws.del1);
+      
+      // delete a character from b
+      check_rest(a,b+1,ws.del2);
+
+      if (*a == *(b+1) && *b == *(a+1)) {
+	
+	// swap two characters
+	check_rest(a+2,b+2,ws.swap);
+
+      } else {
+	
+	// substitute one character for another which is the same
+	// thing as deleting a character from both a & b
+	check_rest(a+1,b+1,ws.sub);
+	
+      }
+    }
+    return EditDist(min, amax);
+  }
+
+  EditDist limit2_edit_distance(const char * a, const char * b,
+				const EditDistanceWeights & ws)
+  {
+    int min = LARGE_NUM;
+    const char * a0;
+    const char * b0;
+    const char * aa;
+    const char * bb;
+    const char * amax = a;
+    
+    while(*a == *b) { 
+      if (*a == '\0') 
+	return EditDist(0, a);
+      ++a; ++b;
+    }
+
+    if (*a == '\0') {
+      
+      ++b;
+      if (*b == '\0') return EditDist(ws.del2, a);
+      ++b;
+      if (*b == '\0') return EditDist(2*ws.del2, a);
+      return EditDist(LARGE_NUM, a);
+      
+    } else if (*b == '\0') {
+
+      ++a;
+      if (*a == '\0') return EditDist(ws.del1, a);
+      ++a;
+      if (*a == '\0') return EditDist(2*ws.del1, a);
+      return EditDist(LARGE_NUM, a);
+      
+    } else {
+      
+      // delete a character from a
+      check2(a+1,b,ws.del1);
+      
+      // delete a character from b
+      check2(a,b+1,ws.del2);
+
+      if (*a == *(b+1) && *b == *(a+1)) {
+	
+	// swap two characters
+	check2(a+2,b+2,ws.swap);
+
+      } else {
+	
+	// substitute one character for another which is the same
+	// thing as deleting a character from both a & b
+	check2(a+1,b+1,ws.sub);
+	
+      }
+    }
+    return EditDist(min, amax);
+  }
+}
+
+

data/ext/leditdist.hpp

@@ -0,0 +1,68 @@
+
+#ifndef __aspeller_leditdist_hh__
+#define __aspeller_leditdist_hh__
+
+#include "weights.hpp"
+
+namespace aspeller {
+
+  // limit_edit_distance finds the shortest edit distance but will
+  // stop and return a number at least as large as LARGE_NUM if it has
+  // to do more edits than a set limit.
+  // Note that this does NOT mean that the score returned is <= limit*w.max
+  // as "sub" vs "submarine" will return 6*(cost of insertion) no matter what
+  // the limit is.
+  // The edit distance is 
+  // (cost of swap)(# of swaps) + (cost of deletion)(# of deletions) 
+  //   + (cost of insertion)(# of insertions) 
+  //   + (cost of substitutions)(# of substitutions)
+
+  // Preconditions:
+  //   max(strlen(a), strlen(b))*max(of the edit weights) <= 2^15
+  //     if violated than an incorrect result may be returned (which may be negative)
+  //     due to overflow of a short integer
+  //   (limit+1)*w.min < limit*w.max
+  //   limit <= 5 (use edit_distance if limit > 5)
+  // where w.min and w.max is the minimum and maximum cost of an edit
+  // respectfully.
+
+  // The running time is asymptotically bounded above by 
+  // (3^l)*n where l is the limit and n is the maxium of strlen(a),strlen(b)
+  // Based on my informal tests, however, the n does not really matter
+  // and the running time is more like (3^l).
+
+  // limit_edit_distance, based on my informal tests, turns out to be
+  // faster than edit_dist for l < 5.  For l == 5 it is about the 
+  // smaller for short strings (<= 5) and less than for longer strings
+
+  // limit2_edit_distance(a,b,w) = limit_edit_distance(a,b,2,w)
+  // but is roughly 2/3's faster
+
+  struct EditDist {
+    int          score;
+    const char * stopped_at;
+    EditDist() {}
+    EditDist(int s, const char * p) 
+      : score(s), stopped_at(p) {}
+    operator int () const {return score;}
+  };
+
+  static const int LARGE_NUM = 0xFFFFF; 
+  // this needs to be SMALLER than INT_MAX since it may be incremented 
+  // a few times
+
+  int limit_edit_distance(const char * a, const char * b, int limit, 
+			  const EditDistanceWeights & w 
+			  = EditDistanceWeights());
+  
+  EditDist limit1_edit_distance(const char * a, const char * b,
+				const EditDistanceWeights & w 
+				= EditDistanceWeights());
+
+  EditDist limit2_edit_distance(const char * a, const char * b,
+				const EditDistanceWeights & w 
+				= EditDistanceWeights());
+  
+}
+
+#endif

data/ext/weights.hpp

@@ -0,0 +1,23 @@
+
+#ifndef __aspeller_weights_hh__
+#define __aspeller_weights_hh__
+
+namespace aspeller {
+
+  struct EditDistanceWeights {
+    int del1;    // the cost of deleting a char in the first string
+    int del2;    // the cost of inserting a character or deleting a char
+                    // in the next string
+    int swap;    // the cost of swapping two adjacent letters
+    int sub;     // the cost of replacing one letter with another
+    int similar; // the cost of a "similar" but not exact match for
+                    // two characters
+    int min;     // the min of del1, del2, swap and sub.
+    int max;     // the max of del1, del2, swap and sub.
+    EditDistanceWeights()
+      : del1(1), del2(1), swap(1), sub(1), similar(0), min(1), max(1) {}
+  };
+  
+}
+
+#endif

data/lib/aspell_edit_dist_stub.rb

@@ -0,0 +1,61 @@
+raise "This file should never be required. It's here only for documentation purposes."
+
+# module, through which the functionality of edit distance calculation is possible
+module Aspeller
+
+  # weights that are used by Aspell to determine edit distance between two strings
+  class EditDistanceWeights
+
+    # the cost of deleting a char in the first string, defaults to 1
+    attr_accessor :del1
+
+    # the cost of inserting a character or deleting a char in the next string, defaults to 1
+    attr_accessor :del2
+
+    # the cost of swapping two adjacent letters, defaults to 1
+    attr_accessor :swap
+
+    # the cost of replacing one letter with another, defaults to 1
+    attr_accessor :sub
+
+    # the cost of a "similar" but not exact match for two characters, defaults to 0
+    attr_accessor :similar
+
+    # the min of del1, del2, swap and sub, defaults to 1
+    attr_accessor :min
+
+    # the max of del1, del2, swap and sub, defaults to 1
+    attr_accessor :max
+    
+  end
+
+  # limit_edit_distance finds the shortest edit distance but will
+  # stop and return a number at least as large as LARGE_NUM if it has
+  # to do more edits than a set limit.
+  # Note that this does NOT mean that the score returned is <= limit*w.max
+  # as "sub" vs "submarine" will return 6*(cost of insertion) no matter what
+  # the limit is.
+  # The edit distance is
+  # (cost of swap)(# of swaps) + (cost of deletion)(# of deletions)
+  #   + (cost of insertion)(# of insertions)
+  #   + (cost of substitutions)(# of substitutions)
+  #
+  # Preconditions:
+  #   max(strlen(a), strlen(b))*max(of the edit weights) <= 2^15
+  #     if violated than an incorrect result may be returned (which may be negative)
+  #     due to overflow of a short integer
+  #   (limit+1)*w.min < limit*w.max
+  #   limit <= 5 (use edit_distance if limit > 5)
+  # where w.min and w.max is the minimum and maximum cost of an edit
+  # respectfully.
+  #
+  # The running time is asymptotically bounded above by
+  # (3^l)*n where l is the limit and n is the maxium of strlen(a),strlen(b)
+  # Based on my informal tests, however, the n does not really matter
+  # and the running time is more like (3^l).
+  #
+  # limit_edit_distance, based on my informal tests, turns out to be
+  # faster than edit_dist for l < 5.  For l == 5 it is about the
+  # smaller for short strings (<= 5) and less than for longer strings
+  def self.limit_edit_distance(strA, strB, limit, weights); end
+end

data/test/edit_distance_test.rb

@@ -0,0 +1,26 @@
+require File.expand_path( File.dirname(__FILE__) + '/test_helper.rb' )
+
+class EditDistanceTest < Test::Unit::TestCase
+
+  def test_limit_distance_defined
+    assert defined?(Aspeller), "module Aspell must be defined"
+    assert defined?(Aspeller.limit_edit_distance), "method Aspell.limit_edit_distance must be defined"
+  end
+
+  def test_limit_distance_returns_fixnum
+    result = Aspeller.limit_edit_distance("a", "b", 1, Aspeller::EditDistanceWeights.new)
+    assert result.is_a?(Fixnum), "limit_edit_distance is supposed to return a fixnum"
+  end
+
+  def test_limit_distance_returns_right_value
+    result = Aspeller.limit_edit_distance("test", "tast", 1, Aspeller::EditDistanceWeights.new)
+    assert_equal 1, result
+  end
+
+  def test_limit_distance_uses_passed_weights
+    weights = Aspeller::EditDistanceWeights.new
+    weights.sub = 2
+    result = Aspeller.limit_edit_distance("test", "tast", 1, weights)
+    assert_equal 2, result
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,11 @@
+$LOAD_PATH << File.expand_path( File.dirname(__FILE__) + '/../ext' )
+$LOAD_PATH << File.expand_path( File.dirname(__FILE__) + '/..' )
+
+require 'test/unit'
+
+system("cd #{File.expand_path(File.join(File.dirname(__FILE__), '..'))}; make distclean")
+
+system("cd #{File.expand_path(File.join(File.dirname(__FILE__), '..'))}; ruby ext/extconf.rb")
+system("cd #{File.expand_path(File.join(File.dirname(__FILE__), '..'))}; make")
+
+require "aspell_edit_dist"

data/test/weights_test.rb

@@ -0,0 +1,51 @@
+require File.expand_path( File.dirname(__FILE__) + '/test_helper.rb' )
+
+class WeightsTest < Test::Unit::TestCase
+
+  def test_weights_defined
+    assert defined?(Aspeller), "Aspeller module should be defined"
+    assert defined?(Aspeller::EditDistanceWeights), "class Aspeller::EditDistanceWeights is supposed to be defined"
+  end
+
+  def test_weights_has_constructor
+    assert_respond_to Aspeller::EditDistanceWeights, :new
+  end
+
+  WEIGHT_METHODS = [:del1, :del2, :swap, :sub, :similar, :min, :max]
+
+  def test_weights_getters
+    weights = Aspeller::EditDistanceWeights.new
+    WEIGHT_METHODS.each do |method_name|
+      assert_respond_to weights, method_name
+      assert weights.send(method_name), "weights.#{method_name} should return something"
+    end
+  end
+
+  def test_weights_default_values
+    weights = Aspeller::EditDistanceWeights.new
+    assert_equal 1, weights.del1
+    assert_equal 1, weights.del2
+    assert_equal 1, weights.swap
+    assert_equal 1, weights.sub
+    assert_equal 0, weights.similar
+    assert_equal 1, weights.min
+    assert_equal 1, weights.max
+  end
+
+  def test_weights_setters
+    weights = Aspeller::EditDistanceWeights.new
+
+    n = 123
+    WEIGHT_METHODS.each do |method_name|
+      setter_name = :"#{method_name}="
+
+      assert_respond_to weights, setter_name
+
+      weights.send(setter_name, n)
+      assert_equal n, weights.send(method_name)
+
+      n += 1
+    end
+  end
+
+end

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification 
+name: aspell_edit_dist
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Adam Pohorecki
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-12-29 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: 
+email: adam@pohorecki.pl
+executables: []
+
+extensions: 
+- ext/extconf.rb
+extra_rdoc_files: 
+- README
+files: 
+- .gitignore
+- README
+- Rakefile
+- VERSION
+- ext/aspell_edit_dist.cpp
+- ext/aspell_edit_dist.h
+- ext/extconf.rb
+- ext/leditdist.cpp
+- ext/leditdist.hpp
+- ext/weights.hpp
+- lib/aspell_edit_dist_stub.rb
+- test/edit_distance_test.rb
+- test/test_helper.rb
+- test/weights_test.rb
+has_rdoc: true
+homepage: http://github.com/psyho/aspell_edit_dist
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+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: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Gem that exposes limit_edit_distance function from Aspell.
+test_files: 
+- test/edit_distance_test.rb
+- test/weights_test.rb
+- test/test_helper.rb