jaro_winkler 1.0.1 → 1.1.0

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    M2Y4MDU5ZmVjNmIwMWQ3NzNmMDdkYzgzZDYwMDVmZDdkMTc0NGUyMg==
-  data.tar.gz: !binary |-
-    MDFmODkwMGZkZTQ5OTk4YjZlODRjOWVmNjQxMDVhMjQ1NDlhYzhiMg==
+SHA1:
+  metadata.gz: f84ae47f4c9a9afe40e7b01c7d49359dd6986009
+  data.tar.gz: 6994fd05b085d89e203f1c5663915bdc9ce88735
 SHA512:
-  metadata.gz: !binary |-
-    YTI5YjYxMjkwYTAyMDhkZjI3Yjc1ZjNhZjdjZGNjMDAxYzg4MmUxNGUzNDBm
-    NzM1ZGRjM2EwZTUxMzM4MWQzM2JhZDE3NjdkMmE2NTVlODdiMjM2YmJlMWY3
-    N2I4MjdhZjkwNzcxNTEyODE4ZTdkNjg1NmZjMjQ0ZWNkN2MzODM=
-  data.tar.gz: !binary |-
-    ZDc4YWQ3NDJlYmYwMDg2MWQyODVkYzI1MjgyMzRhY2EyZDdmNzBiMWQ2MWIw
-    M2I3OWYyZTZkOTc4YzFjODM3MWM3OThmOTRhYjM4YjIwYTc0YTZhMjBmZWJk
-    ZTg4M2Y2MWEzMWU0YzM2ZWQ3MTBmYTZjZjUxMTI4NDMxODQzYTM=
+  metadata.gz: b2bf1f5c392750f82e203aafed8264eaa79750b9a3a11209cc221d8506cbf8b1840cd8822b631f0d5de5c6b8bd2c2c471b0992c55986918b81b9e4ef5236e072
+  data.tar.gz: c02296f3c27531a518f752177cca86c7e00670a1c3e7566bb6c3b499f7f676148a44fd3ec6848eedd50072bcd94a2c4781d9667440b44cd4032e24570f10a862

data/README.md

@@ -2,22 +2,26 @@
 
 It's a pure Ruby implementation of [Jaro-Winkler distance](http://en.wikipedia.org/wiki/Jaro%E2%80%93Winkler_distance) algorithm.
 
-## Installation
+# Installation
 
 ```
 gem install jaro_winkler
 ```
 
-## Usage
+# Usage
 
 ```ruby
 require 'jaro_winkler'
-JaroWinkler.jaro_winkler_distance "MARTHA", "MARHTA"
+JaroWinkler.distance "MARTHA", "MARHTA"
 # => 0.9611
-JaroWinkler.jaro_winkler_distance "MARTHA", "marhta", case_match: true
+JaroWinkler.distance "MARTHA", "marhta", case_match: true
 # => 0.9611
-JaroWinkler.jaro_winkler_distance "MARTHA", "MARHTA", weight: 0.2
+JaroWinkler.distance "MARTHA", "MARHTA", weight: 0.2
 # => 0.9778
+
+# Native
+JaroWinkler.c_distance "MARTHA", "MARHTA"
+JaroWinkler.distance "MARTHA", "MARHTA", native: true
 ```
 
 ## Options
@@ -26,4 +30,70 @@ Name        | Type    | Default | Note
 ----------- | ------  | ------- | ------------------------------------------------------------------------------------------------------------
 case_match  | boolean | false   | All upper case characters are converted to lower case prior to the comparison.
 weight      | number  | 0.1     | A constant scaling factor for how much the score is adjusted upwards for having common prefixes.
-threshold   | number  | 0.7     | The prefix bonus is only added when the compared strings have a Jaro distance above a this.
+threshold   | number  | 0.7     | The prefix bonus is only added when the compared strings have a Jaro distance above a this.
+native      | boolean | false   | Use native version, note that it omits all the other options.
+
+## Pure Ruby v.s. Native
+
+               | Pure | Native
+-------------- | ---- | ------
+UTF-8 Support  | Yes  | No
+Option Setting | Yes  | No
+
+# Why This?
+
+There is also another gem named [fuzzy-string-match](https://github.com/kiyoka/fuzzy-string-match), it uses the same algorithm and both provides C and Ruby implementation.
+
+I reinvent this wheel because of the naming in `fuzzy-string-match` such as `getDistance` breaks convention, and some weird code like `a1 = s1.split( // )` (`s1.chars` could be better), furthermore, it's bugged:
+
+string 1   | string 2   | origin   | fuzzy-string-match | jaro_winkler
+---------- | ---------- | -------- | ------------------ | ------------------
+"henka"    | "henkan"   | 0.966667 | 0.9722 (wrong)     | 0.9666666666666667
+"al"       | "al"       | 1.000000 | 1.0                | 1.0
+"martha"   | "marhta"   | 0.961111 | 0.9611             | 0.9611111111111111
+"jones"    | "johnson"  | 0.832381 | 0.8323             | 0.8323809523809523
+"abcvwxyz" | "cabvwxyz" | 0.958333 | 0.9583             | 0.9583333333333333
+"dwayne"   | "duane"    | 0.840000 | 0.8400             | 0.84
+"dixon"    | "dicksonx" | 0.813333 | 0.8133             | 0.8133333333333332
+"fvie"     | "ten"      | 0.000000 | 0.0                | 0
+
+- The origin result is from the [original C implementation by the author of the algorithm](http://web.archive.org/web/20100227020019/http://www.census.gov/geo/msb/stand/strcmp.c).
+- Test data are borrowed from [fuzzy-string-match's rspec file](https://github.com/kiyoka/fuzzy-string-match/blob/master/test/basic_pure_spec.rb).
+
+## Benchmark
+
+- jaro_winkler (1.0.1)
+- fuzzy-string-match (0.9.6)
+
+```ruby
+require 'benchmark'
+require 'jaro_winkler'
+require 'fuzzystringmatch'
+ary = [['al', 'al'], ['martha', 'marhta'], ['jones', 'johnson'], ['abcvwxyz', 'cabvwxyz'], ['dwayne', 'duane'], ['dixon', 'dicksonx'], ['fvie', 'ten']]
+
+n = 100000
+Benchmark.bmbm do |x|
+  x.report 'jaro_winkler    ' do
+    n.times{ ary.each{ |str1, str2| JaroWinkler.distance(str1, str2) } }
+  end
+
+  x.report 'fuzzystringmatch' do
+    jarow = FuzzyStringMatch::JaroWinkler.create(:pure)
+    n.times{ ary.each{ |str1, str2| jarow.getDistance(str1, str2) } }
+  end
+end
+
+#                        user     system      total        real
+# jaro_winkler      12.480000   0.010000  12.490000 ( 12.497828)
+# fuzzystringmatch  14.990000   0.010000  15.000000 ( 15.014898)
+```
+
+# Todo
+
+- Speed up `#distance(s1, s2, native: true)`
+- Support UTF-8 in native version.
+- Add more optoins to natvie version.
+  - case_match
+  - weight
+  - threshold
+  - adjusting word table (It's from the original C implementation.)

data/Rakefile

@@ -1,2 +1,7 @@
 require "bundler/gem_tasks"
 
+require "rake/extensiontask"
+
+Rake::ExtensionTask.new("jaro_winkler") do |ext|
+  ext.lib_dir = "lib/jaro_winkler"
+end

data/benchmark/native.rb

@@ -0,0 +1,25 @@
+require 'benchmark'
+require 'jaro_winkler'
+require 'fuzzystringmatch'
+ary = [['al', 'al'], ['martha', 'marhta'], ['jones', 'johnson'], ['abcvwxyz', 'cabvwxyz'], ['dwayne', 'duane'], ['dixon', 'dicksonx'], ['fvie', 'ten']]
+
+n = 100000
+Benchmark.bmbm do |x|
+  x.report '#c_distance(s1, s2)' do
+    n.times{ ary.each{ |str1, str2| JaroWinkler.c_distance(str1, str2) } }
+  end
+
+  x.report '#distance(s1, s2, native: true)' do
+    n.times{ ary.each{ |str1, str2| JaroWinkler.distance(str1, str2, native: true) } }
+  end
+
+  x.report 'fuzzystringmatch' do
+    jarow = FuzzyStringMatch::JaroWinkler.create(:native)
+    n.times{ ary.each{ |str1, str2| jarow.getDistance(str1, str2) } }
+  end
+end
+
+#                                       user     system      total        real
+# #c_distance(s1, s2)               0.270000   0.000000   0.270000 (  0.270250)
+# #distance(s1, s2, native: true)   2.030000   0.050000   2.080000 (  2.075878)
+# fuzzystringmatch                  0.140000   0.000000   0.140000 (  0.141239)

data/benchmark/pure.rb

@@ -0,0 +1,20 @@
+require 'benchmark'
+require 'jaro_winkler'
+require 'fuzzystringmatch'
+ary = [['al', 'al'], ['martha', 'marhta'], ['jones', 'johnson'], ['abcvwxyz', 'cabvwxyz'], ['dwayne', 'duane'], ['dixon', 'dicksonx'], ['fvie', 'ten']]
+
+n = 100000
+Benchmark.bmbm do |x|
+  x.report 'jaro_winkler    ' do
+    n.times{ ary.each{ |str1, str2| JaroWinkler.distance(str1, str2) } }
+  end
+
+  x.report 'fuzzystringmatch' do
+    jarow = FuzzyStringMatch::JaroWinkler.create(:pure)
+    n.times{ ary.each{ |str1, str2| jarow.getDistance(str1, str2) } }
+  end
+end
+
+#                        user     system      total        real
+# jaro_winkler      12.480000   0.010000  12.490000 ( 12.497828)
+# fuzzystringmatch  14.990000   0.010000  15.000000 ( 15.014898)

data/ext/jaro_winkler/extconf.rb

@@ -0,0 +1,3 @@
+require "mkmf"
+
+create_makefile("jaro_winkler")

data/ext/jaro_winkler/jaro_winkler.c

@@ -0,0 +1,32 @@
+#include "jaro_winkler.h"
+#define MAX(X,Y) ((X) < (Y) ? (Y) : (X))
+VALUE rb_mJaroWinkler;
+
+static VALUE distance(VALUE self, VALUE s1, VALUE s2){
+  Check_Type(s1, T_STRING); Check_Type(s2, T_STRING);
+  // Check encoding
+  VALUE s1_ascii_only = TYPE(rb_funcall(s1, rb_intern("ascii_only?"), 0));
+  VALUE s2_ascii_only = TYPE(rb_funcall(s2, rb_intern("ascii_only?"), 0));
+  if(s1_ascii_only == T_FALSE || s2_ascii_only == T_FALSE) printf("WARNING: Non-ASCII string detected.\n");
+
+  VALUE *s1_ptr = &s1, *s2_ptr = &s2;
+  // guarantee the length of s1_ptr is less than or equal to that of s2_ptr
+  if(RSTRING_LEN(s1) > RSTRING_LEN(s2)){ VALUE *tmp = s1_ptr; s1_ptr = s2_ptr; s2_ptr = tmp; }
+  int min_length = RSTRING_LEN(*s1_ptr), max_length   = RSTRING_LEN(*s2_ptr);
+  char *c_s1_ptr = StringValuePtr(*s1_ptr), *c_s2_ptr = StringValuePtr(*s2_ptr);
+  int opt[] = {1, 0};
+  if(min_length != max_length){
+    // padding spaces
+    char buf[max_length];
+    for(int i = min_length; i < max_length; ++i) buf[i] = ' ';
+    memcpy(buf, c_s1_ptr, min_length);
+    c_s1_ptr = buf;
+    return rb_float_new(strcmp95(c_s1_ptr, c_s2_ptr, max_length, opt));
+  }
+  return rb_float_new(strcmp95(c_s1_ptr, c_s2_ptr, max_length, opt));
+}
+
+void Init_jaro_winkler(void){
+  rb_mJaroWinkler = rb_define_module("JaroWinkler");
+  rb_define_module_function(rb_mJaroWinkler, "c_distance", distance, 2);
+}

data/ext/jaro_winkler/jaro_winkler.h

@@ -0,0 +1,8 @@
+#ifndef JARO_WINKLER_H
+#define JARO_WINKLER_H 1
+
+#include "ruby.h"
+
+double strcmp95(char *ying, char *yang, long y_length, int *ind_c);
+
+#endif /* JARO_WINKLER_H */

data/ext/jaro_winkler/strcmp95.c

@@ -0,0 +1,199 @@
+
+/* strcmp95.c   Version 2                 */
+
+/* The strcmp95 function returns a double precision value from 0.0 (total
+   disagreement) to 1.0 (character-by-character agreement).  The returned 
+   value is a measure of the similarity of the two strings.                   */
+
+/* Date of Release:  Jan. 26, 1994                */
+/* Modified: April 24, 1994  Corrected the processing of the single length
+             character strings.
+   Authors:  This function was written using the logic from code written by
+             Bill Winkler, George McLaughlin and Matt Jaro with modifications
+             by Maureen Lynch. 
+   Comment:  This is the official string comparator to be used for matching 
+             during the 1995 Test Census.                                     */
+
+#include <ctype.h>
+#include <string.h>
+
+#define NOTNUM(c) ((c>57) || (c<48))
+#define INRANGE(c)      ((c>0)  && (c<91))
+#define MAX_VAR_SIZE 61
+#define NULL60 "                                                            "
+
+double  strcmp95(char *ying, char *yang, long y_length, int *ind_c)
+
+{
+/* Arguments:
+
+   ying and yang are pointers to the 2 strings to be compared.  The strings
+   need not be NUL-terminated strings because the length is passed.
+
+   y_length is the length of the strings. 
+
+   ind_c is an array that is used to define whether certain options should be 
+   activated.  A nonzero value indicates the option is deactivated.  
+   The options are:
+     ind_c[0] Increase the probability of a match when the number of matched
+              characters is large.  This option allows for a little more
+              tolerance when the strings are large.  It is not an appropriate
+              test when comparing fixed length fields such as phone and
+              social security numbers.
+     ind_c[1] All lower case characters are converted to upper case prior
+              to the comparison.  Disabling this feature means that the lower 
+              case string "code" will not be recognized as the same as the 
+              upper case string "CODE".  Also, the adjustment for similar 
+              characters section only applies to uppercase characters.
+
+   The suggested values are all zeros for character strings such as names.    */
+
+static  int pass=1/* TODO: make it an option parameter */, adjwt[91][91];
+static  char  sp[39][2] =
+ {'A','E',  'A','I',  'A','O',  'A','U',  'B','V',  'E','I',  'E','O',  'E','U',
+  'I','O',  'I','U',  'O','U',  'I','Y',  'E','Y',  'C','G',  'E','F',
+  'W','U',  'W','V',  'X','K',  'S','Z',  'X','S',  'Q','C',  'U','V',
+  'M','N',  'L','I',  'Q','O',  'P','R',  'I','J',  '2','Z',  '5','S',
+  '8','B',  '1','I',  '1','L',  '0','O',  '0','Q',  'C','K',  'G','J',
+  'E',' ',  'Y',' ',  'S',' '};
+
+char    ying_hold[MAX_VAR_SIZE],
+        yang_hold[MAX_VAR_SIZE],
+        ying_flag[MAX_VAR_SIZE],
+        yang_flag[MAX_VAR_SIZE];
+
+double  weight, Num_sim;
+
+long    minv,   search_range,   lowlim,    ying_length,
+        hilim,  N_trans,        Num_com,   yang_length;
+
+int yl1,  yi_st,  N_simi;
+
+register        int     i,      j,      k;
+
+/* Initialize the adjwt array on the first call to the function only.
+   The adjwt array is used to give partial credit for characters that 
+   may be errors due to known phonetic or character recognition errors.
+   A typical example is to match the letter "O" with the number "0"           */
+if (!pass) {
+  pass++;
+  for (i=0; i<91; i++) for (j=0; j<91; j++) adjwt[i][j] = 0;
+  for (i=0; i<36; i++) {
+    adjwt[sp[i][0]][sp[i][1]] = 3;
+    adjwt[sp[i][1]][sp[i][0]] = 3;
+} }
+
+/* If either string is blank - return - added in Version 2                    */
+if (!strncmp(ying,NULL60,y_length)) return(0.0);                 
+if (!strncmp(yang,NULL60,y_length)) return(0.0);                 
+
+/* Identify the strings to be compared by stripping off all leading and 
+   trailing spaces.                   */
+k = y_length - 1;
+for(j = 0;((ying[j]==' ') && (j < k));j++);
+for(i = k;((ying[i]==' ') && (i > 0));i--);
+ying_length = i + 1 - j;
+yi_st = j;
+
+for(j = 0;((yang[j]==' ') && (j < k));j++);
+for(i = k;((yang[i]==' ') && (i > 0));i--);
+yang_length = i + 1 - j;
+
+ying_hold[0]=yang_hold[0]=0;
+strncat(ying_hold,&ying[yi_st],ying_length);
+strncat(yang_hold,&yang[j],yang_length);
+
+if (ying_length > yang_length) {
+  search_range = ying_length;
+  minv = yang_length;
+  }
+ else {
+  search_range = yang_length;
+  minv = ying_length;
+  }
+
+/* If either string is blank - return                                         */
+/* if (!minv) return(0.0);                   removed in version 2             */
+
+/* Blank out the flags                    */
+ying_flag[0] = yang_flag[0] = 0;
+strncat(ying_flag,NULL60,search_range);
+strncat(yang_flag,NULL60,search_range);
+search_range = (search_range/2) - 1;
+if (search_range < 0) search_range = 0;   /* added in version 2               */
+
+/* Convert all lower case characters to upper case.                           */
+if (!ind_c[1]) {
+  for (i = 0;i < ying_length;i++) if (islower(ying_hold[i])) ying_hold[i] -= 32;
+  for (j = 0;j < yang_length;j++) if (islower(yang_hold[j])) yang_hold[j] -= 32;
+}
+
+/* Looking only within the search range, count and flag the matched pairs.    */
+Num_com = 0; 
+yl1 = yang_length - 1;
+for (i = 0;i < ying_length;i++) {
+  lowlim = (i >= search_range) ? i - search_range : 0;
+  hilim = ((i + search_range) <= yl1) ? (i + search_range) : yl1;
+  for (j = lowlim;j <= hilim;j++)  {
+    if ((yang_flag[j] != '1') && (yang_hold[j] == ying_hold[i])) {
+        yang_flag[j] = '1';
+        ying_flag[i] = '1';
+        Num_com++;
+        break;
+} } }
+
+/* If no characters in common - return                                        */
+if (!Num_com) return(0.0);                          
+
+/* Count the number of transpositions                                         */
+k = N_trans = 0;
+for (i = 0;i < ying_length;i++) {
+  if (ying_flag[i] == '1') {
+    for (j = k;j < yang_length;j++) {
+        if (yang_flag[j] == '1') { 
+         k = j + 1;
+         break;
+    } }
+    if (ying_hold[i] != yang_hold[j]) N_trans++;
+} }
+N_trans = N_trans / 2;
+
+/* adjust for similarities in nonmatched characters                           */
+N_simi = 0;
+if (minv > Num_com) {   
+  for (i = 0;i < ying_length;i++) {
+    if (ying_flag[i] == ' ' && INRANGE(ying_hold[i])) { 
+      for (j = 0;j < yang_length;j++) {
+        if (yang_flag[j] == ' ' && INRANGE(yang_hold[j])) {
+          if (adjwt[ying_hold[i]][yang_hold[j]] > 0) {
+            N_simi += adjwt[ying_hold[i]][yang_hold[j]];
+            yang_flag[j] = '2';
+            break;
+} } } } } }
+Num_sim = ((double) N_simi)/10.0 + Num_com;
+
+/* Main weight computation.                 */
+weight= Num_sim / ((double) ying_length) + Num_sim / ((double) yang_length)
+   + ((double) (Num_com - N_trans)) / ((double) Num_com);
+weight = weight / 3.0;
+
+/* Continue to boost the weight if the strings are similar                    */
+if (weight > 0.7) {
+
+  /* Adjust for having up to the first 4 characters in common                 */
+  j = (minv >= 4) ? 4 : minv;
+  for (i=0;((i<j)&&(ying_hold[i]==yang_hold[i])&&(NOTNUM(ying_hold[i])));i++); 
+  if (i) weight += i * 0.1 * (1.0 - weight);
+
+  /* Optionally adjust for long strings.                                      */
+  /* After agreeing beginning chars, at least two more must agree and 
+       the agreeing characters must be > .5 of remaining characters.          */
+  if ((!ind_c[0]) && (minv>4) && (Num_com>i+1) && (2*Num_com>=minv+i)) 
+  if (NOTNUM(ying_hold[0])) 
+    weight += (double) (1.0-weight) *
+   ((double) (Num_com-i-1) / ((double) (ying_length+yang_length-i*2+2)));
+ }
+
+return(weight);
+
+} /* strcmp95 */

data/jaro_winkler.gemspec

@@ -8,6 +8,7 @@ Gem::Specification.new do |spec|
   spec.version       = JaroWinkler::VERSION
   spec.authors       = ["Jian Weihang"]
   spec.email         = ["tonytonyjan@gmail.com"]
+  spec.extensions    = ["ext/jaro_winkler/extconf.rb"]
   spec.summary       = %q{Pure Ruby implementation of Jaro-Winkler distance algorithm.}
   spec.description   = %q{Pure Ruby implementation of Jaro-Winkler distance algorithm.}
   spec.homepage      = "https://github.com/tonytonyjan/jaro_winkler"
@@ -20,4 +21,5 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler", "~> 1.7"
   spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rake-compiler"
 end

data/lib/jaro_winkler.rb

@@ -1,3 +1,4 @@
+require 'jaro_winkler/jaro_winkler.so'
 module JaroWinkler
   module_function
   def jaro_distance s1, s2
@@ -33,11 +34,12 @@ module JaroWinkler
       end
     end
     # Don't divide transpositions by 2 since it's been counted directly by above code.
-    matches == 0 ? 0 : 1.0 / 3.0 * (matches / length1 + matches / length2 + (matches - transpositions) / matches)
+    matches == 0 ? 0 : (matches / length1 + matches / length2 + (matches - transpositions) / matches) / 3.0
   end
 
-  def jaro_winkler_distance s1, s2, options = {}
-    options = {weight: 0.1, threshold: 0.7, case_match: false}.merge options
+  def distance s1, s2, options = {}
+    options = {weight: 0.1, threshold: 0.7, case_match: false, native: false}.merge options
+    return c_distance(s1, s2) if options[:native]
     weight, threshold, case_match = options[:weight], options[:threshold], options[:case_match]
     raise 'Scaling factor should not exceed 0.25, otherwise the distance can become larger than 1' if weight > 0.25
     s1, s2 = s1.downcase, s2.downcase if case_match

data/lib/jaro_winkler/version.rb

@@ -1,3 +1,3 @@
 module JaroWinkler
-  VERSION = "1.0.1"
+  VERSION = "1.1.0"
 end

data/spec/jaro_winkler_spec.rb

@@ -1,24 +1,42 @@
 require 'jaro_winkler'
-
+include JaroWinkler
 describe JaroWinkler do
+  before(:all) do
+    @ary = [
+      ['henka', 'henkan', 0.9667],
+      ['al', 'al', 1.0],
+      ['martha', 'marhta', 0.9611],
+      ['jones', 'johnson', 0.8323],
+      ['abcvwxyz', 'cabvwxyz', 0.9583],
+      ['dwayne', 'duane', 0.8400],
+      ['dixon', 'dicksonx', 0.8133],
+      ['fvie', 'ten', 0.0],
+      ['tony', 'tony', 1.0],
+      ['tonytonyjan', 'tonytonyjan', 1.0],
+      ['', '', 0.0],
+      ['tony', '', 0.0],
+      ['', 'tony', 0.0]
+    ]
+  end
+
   it 'works' do
-    expect(JaroWinkler.jaro_winkler_distance("MARTHA", "MARHTA")).to  be_within(0.0001).of(0.9611)
-    expect(JaroWinkler.jaro_winkler_distance("DIXON", "DICKSONX")).to be_within(0.0001).of(0.8133)
-    expect(JaroWinkler.jaro_winkler_distance("abcvwxyz", "cabvwxyz")).to be_within(0.0001).of(0.9583)
-    expect(JaroWinkler.jaro_winkler_distance("DWAYNE", "DUANE")).to   eq 0.84
-    expect(JaroWinkler.jaro_winkler_distance("tony", "tony")).to eq 1.0
-    expect(JaroWinkler.jaro_winkler_distance("tonytonyjan", "tonytonyjan")).to eq 1.0
-    expect(JaroWinkler.jaro_winkler_distance("", "")).to eq 0.0
-    expect(JaroWinkler.jaro_winkler_distance("tony", "")).to eq 0.0
-    expect(JaroWinkler.jaro_winkler_distance("", "tony")).to eq 0.0
+    @ary.each do |s1, s2, ans|
+      expect(distance(s1, s2)).to be_within(0.0001).of(ans)
+    end
+  end
+
+  it 'supports C extension' do
+    @ary.each do |s1, s2, ans|
+      expect(distance(s1, s2, native: true)).to be_within(0.0001).of(ans)
+    end
   end
 
   it 'can ignore case' do
-    expect(JaroWinkler.jaro_winkler_distance("MARTHA", "marhta", case_match: true)).to  be_within(0.0001).of(0.9611)
+    expect(distance('MARTHA', 'marhta', case_match: true)).to be_within(0.0001).of(0.9611)
   end
 
   it 'can set weight' do
-    expect(JaroWinkler.jaro_winkler_distance("MARTHA", "MARHTA", weight: 0.2)).to  be_within(0.0001).of(0.9778)
-    expect{ JaroWinkler.jaro_winkler_distance("MARTHA", "MARHTA", weight: 0.26) }.to  raise_error
+    expect(distance('MARTHA', 'MARHTA', weight: 0.2)).to be_within(0.0001).of(0.9778)
+    expect{ distance('MARTHA', 'MARHTA', weight: 0.26) }.to raise_error
   end
 end

metadata

@@ -1,56 +1,77 @@
 --- !ruby/object:Gem::Specification
 name: jaro_winkler
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.1.0
 platform: ruby
 authors:
 - Jian Weihang
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-06 00:00:00.000000000 Z
+date: 2014-09-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.7'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.7'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Pure Ruby implementation of Jaro-Winkler distance algorithm.
 email:
 - tonytonyjan@gmail.com
 executables: []
-extensions: []
+extensions:
+- ext/jaro_winkler/extconf.rb
 extra_rdoc_files: []
 files:
-- .gitignore
-- .rspec
+- ".gitignore"
+- ".rspec"
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
+- benchmark/native.rb
+- benchmark/pure.rb
+- ext/jaro_winkler/extconf.rb
+- ext/jaro_winkler/jaro_winkler.c
+- ext/jaro_winkler/jaro_winkler.h
+- ext/jaro_winkler/strcmp95.c
 - jaro_winkler.gemspec
 - lib/jaro_winkler.rb
 - lib/jaro_winkler/version.rb
@@ -66,12 +87,12 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []