jaro_winkler 1.4.0-java

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 52f268c19787793ca7383fe1de1f0355e0a3e6b9
+  data.tar.gz: f8814b814294a7f9268a6df2ad1ad72c75146c3e
+SHA512:
+  metadata.gz: 2ea65143ad847ef5cd565584c2dd1ce19908136506697eafe0579609227628a6e2bbb4baacd0d6c3ee883bcea07fff3043ae305d84c307a0e5f359dff64ab0c1
+  data.tar.gz: 254d25523a0654343ca5b9a552789021a30d3dc7d0c613333db7d67f3ccc41ce003c01bf00b63089b9a340a83594d40f1d7c49b2e59601885b471e68048fc23f

data/ext/jaro_winkler/adj_matrix.c

@@ -0,0 +1,89 @@
+#include "adj_matrix.h"
+#include "code.h"
+
+#include <stdlib.h>
+
+const char *DEFAULT_ADJ_TABLE[] = {
+  "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"," "
+};
+
+extern unsigned int MurmurHash2(const void * key, int len, unsigned int seed);
+void node_free(Node *head);
+
+AdjMatrix* adj_matrix_new(unsigned int length){
+  AdjMatrix *matrix = malloc(sizeof(AdjMatrix));
+  matrix->length = length == 0 ? ADJ_MATRIX_DEFAULT_LENGTH : length;
+  matrix->table = malloc(matrix->length * sizeof(Node**));
+  for(int i = 0; i < matrix->length; i++){
+    matrix->table[i] = malloc(matrix->length * sizeof(Node*));
+    for (int j = 0; j < matrix->length; j++)
+      matrix->table[i][j] = NULL;
+  }
+  return matrix;
+}
+
+void adj_matrix_add(AdjMatrix *matrix, unsigned long long x, unsigned long long y){
+  unsigned int h1 = MurmurHash2(&x, sizeof(long long), ADJ_MATRIX_SEED) % ADJ_MATRIX_DEFAULT_LENGTH,
+               h2 = MurmurHash2(&y, sizeof(long long), ADJ_MATRIX_SEED) % ADJ_MATRIX_DEFAULT_LENGTH;
+  Node *new_node = malloc(sizeof(Node)); new_node->x = h1; new_node->y = h2; new_node->next = NULL;
+  if(matrix->table[h1][h2] == NULL){
+    matrix->table[h1][h2] = matrix->table[h2][h1] = new_node;
+  }
+  else{
+    Node *previous = NULL;
+    for(Node *i = matrix->table[h1][h2]; i != NULL; i = i->next) previous = i;
+    previous->next = new_node;
+  }
+}
+
+char adj_matrix_find(AdjMatrix *matrix, unsigned long long x, unsigned long long y){
+  unsigned int h1 = MurmurHash2(&x, sizeof(long long), ADJ_MATRIX_SEED) % ADJ_MATRIX_DEFAULT_LENGTH,
+               h2 = MurmurHash2(&y, sizeof(long long), ADJ_MATRIX_SEED) % ADJ_MATRIX_DEFAULT_LENGTH;
+  Node *node = matrix->table[h1][h2];
+  if(node == NULL) return 0;
+  else{
+    for(Node *i = node; i != NULL; i = i->next)
+      if((i->x == h1 && i->y == h2) || (i->x == h2 && i->y == h1)) return 1;
+    return 0;
+  }
+}
+
+void node_free(Node *head){
+  if(head == NULL) return;
+  node_free(head->next);
+  free(head);
+}
+
+void adj_matrix_free(AdjMatrix *matrix){
+  for(int i = 0; i < matrix->length; i++){
+    for(int j = 0; j < matrix->length; j++)
+      if(matrix->table[i][j] != NULL){
+        node_free(matrix->table[i][j]);
+        matrix->table[i][j] = matrix->table[j][i] = NULL;
+      }
+    free(matrix->table[i]);
+  }
+  free(matrix->table);
+  free(matrix);
+}
+
+AdjMatrix* adj_matrix_default(){
+  static char first_time = 1;
+  static AdjMatrix *ret_matrix;
+  if(first_time){
+    ret_matrix = adj_matrix_new(ADJ_MATRIX_DEFAULT_LENGTH);
+    int length = sizeof(DEFAULT_ADJ_TABLE) / sizeof(char*);
+    for(int i = 0; i < length; i += 2){
+      unsigned long long code_1, code_2;
+      int dummy_length;
+      utf_char_to_code((char*)DEFAULT_ADJ_TABLE[i], &code_1, &dummy_length);
+      utf_char_to_code((char*)DEFAULT_ADJ_TABLE[i+1], &code_2, &dummy_length);
+      adj_matrix_add(ret_matrix, code_1, code_2);
+    }
+    first_time = 0;
+  }
+  return ret_matrix;
+}

data/ext/jaro_winkler/adj_matrix.h

@@ -0,0 +1,22 @@
+#ifndef ADJ_MATRIX_H
+#define ADJ_MATRIX_H
+#define ADJ_MATRIX_DEFAULT_LENGTH 958
+#define ADJ_MATRIX_SEED 9527
+
+typedef struct _node{
+  struct _node *next;
+  unsigned long long x, y;
+} Node;
+
+typedef struct{
+  Node ***table;
+  unsigned int length;
+} AdjMatrix;
+
+AdjMatrix* adj_matrix_new    (unsigned int length);
+void       adj_matrix_add    (AdjMatrix *matrix, unsigned long long x, unsigned long long y);
+char       adj_matrix_find   (AdjMatrix *matrix, unsigned long long x, unsigned long long y);
+void       adj_matrix_free   (AdjMatrix *matrix);
+AdjMatrix* adj_matrix_default();
+
+#endif

data/ext/jaro_winkler/code.c

@@ -0,0 +1,29 @@
+#include <stdlib.h>
+#include <string.h>
+
+void utf_char_to_code(char *str, unsigned long long *ret_code, int *ret_byte_length){
+  unsigned char first_char = str[0];
+  if(first_char >= 252) *ret_byte_length = 6;      // 1111110x
+  else if(first_char >= 248) *ret_byte_length = 5; // 111110xx
+  else if(first_char >= 240) *ret_byte_length = 4; // 11110xxx
+  else if(first_char >= 224) *ret_byte_length = 3; // 1110xxxx
+  else if(first_char >= 192) *ret_byte_length = 2; // 110xxxxx
+  else *ret_byte_length = 1;
+  *ret_code = 0;
+  memcpy(ret_code, str, *ret_byte_length);
+}
+
+void string_to_codes(char *str, int length, unsigned long long **ret_codes, int *ret_length){
+  unsigned int code;
+  char byte_length;
+
+  *ret_codes = calloc(length, sizeof(long long));
+  *ret_length = 0;
+
+  for(int i = 0; i < length;){
+    int byte_length;
+    utf_char_to_code(&str[i], &(*ret_codes)[*ret_length], &byte_length);
+    *ret_length += 1;
+    i += byte_length;
+  }
+}

data/ext/jaro_winkler/code.h

@@ -0,0 +1,7 @@
+#ifndef CODE_H
+#define CODE_H
+
+void utf_char_to_code(char *str, unsigned long long *ret_code, int *ret_byte_length);
+void string_to_codes(char *str, int length, unsigned long long **ret_codes, int *ret_length);
+
+#endif

data/ext/jaro_winkler/jaro.c

@@ -0,0 +1,122 @@
+#include "jaro.h"
+#include "code.h"
+#include "adj_matrix.h"
+
+#include <string.h>
+#include <stdlib.h>
+#include <ctype.h>
+
+#define SWAP(x, y) do{ __typeof__(x) SWAP = x; x = y; y = SWAP; }while(0)
+
+double jaro_distance_from_codes(unsigned long long *codes1, int len1, unsigned long long *codes2, int len2, LibJaroOption *opt);
+double jaro_winkler_distance_from_codes(unsigned long long *codes1, int len1, unsigned long long *codes2, int len2, LibJaroOption *opt);
+
+double jaro_distance(char* short_str, int short_str_len, char* long_str, int long_str_len, LibJaroOption *opt){
+  if(!short_str_len || !long_str_len) return 0.0;
+
+  unsigned long long *short_codes, *long_codes;
+  int short_codes_len, long_codes_len;
+  string_to_codes(short_str, short_str_len, &short_codes, &short_codes_len);
+  string_to_codes(long_str, long_str_len, &long_codes, &long_codes_len);
+
+  double ret = jaro_distance_from_codes(short_codes, short_codes_len, long_codes, long_codes_len, opt);
+
+  free(short_codes); free(long_codes);
+  return ret;
+}
+
+double jaro_winkler_distance(char* short_str, int short_str_len, char* long_str, int long_str_len, LibJaroOption *opt){
+  if(!short_str_len || !long_str_len) return 0.0;
+
+  unsigned long long *short_codes, *long_codes;
+  int short_codes_len, long_codes_len;
+  string_to_codes(short_str, short_str_len, &short_codes, &short_codes_len);
+  string_to_codes(long_str, long_str_len, &long_codes, &long_codes_len);
+
+  double ret = jaro_winkler_distance_from_codes(short_codes, short_codes_len, long_codes, long_codes_len, opt);
+
+  free(short_codes); free(long_codes);
+  return ret;
+}
+
+double jaro_distance_from_codes(unsigned long long* short_codes, int short_codes_len, unsigned long long* long_codes, int long_codes_len, LibJaroOption *opt){
+  if(!short_codes_len || !long_codes_len) return 0.0;
+
+  if(short_codes_len > long_codes_len){
+    SWAP(short_codes, long_codes);
+    SWAP(short_codes_len, long_codes_len);
+  }
+
+  if(opt->ignore_case){
+    for(int i = 0; i < short_codes_len; i++) short_codes[i] = tolower(short_codes[i]);
+    for(int i = 0; i < long_codes_len; i++) long_codes[i] = tolower(long_codes[i]);
+  }
+
+  int window_size = long_codes_len/2 - 1;
+  if(window_size < 0) window_size = 0;
+
+  char short_codes_flag[short_codes_len];
+  char long_codes_flag[long_codes_len];
+  memset(short_codes_flag, 0, short_codes_len);
+  memset(long_codes_flag, 0, long_codes_len);
+
+  // count number of matching characters
+  int match_count = 0;
+  for(int i = 0; i < short_codes_len; i++){
+    int left = (i >= window_size) ? i - window_size : 0;
+    int right = (i + window_size <= long_codes_len - 1) ? (i + window_size) : (long_codes_len - 1);
+    if(right > long_codes_len - 1) right = long_codes_len - 1;
+    for(int j = left; j <= right; j++){
+      if(!long_codes_flag[j] && short_codes[i] == long_codes[j]){
+        short_codes_flag[i] = long_codes_flag[j] = 1;
+        match_count++;
+        break;
+      }
+    }
+  }
+
+  if(!match_count) return 0.0;
+
+  // count number of transpositions
+  int transposition_count = 0, j = 0, k = 0;
+  for(int i = 0; i < short_codes_len; i++){
+    if(short_codes_flag[i]){
+      for(j = k; j < long_codes_len; j++){
+        if(long_codes_flag[j]){
+          k = j + 1;
+          break;
+        }
+      }
+      if(short_codes[i] != long_codes[j]) transposition_count++;
+    }
+  }
+
+  // count similarities in nonmatched characters
+  int similar_count = 0;
+  if(opt->adj_table && short_codes_len > match_count)
+    for(int i = 0; i < short_codes_len; i++)
+      if(!short_codes_flag[i])
+        for(int j = 0; j < long_codes_len; j++)
+          if(!long_codes_flag[j])
+            if(adj_matrix_find(adj_matrix_default(), short_codes[i], long_codes[j])){
+              similar_count += 3;
+              break;
+            }
+
+  double m = (double)match_count;
+  double t = (double)(transposition_count/2);
+  if(opt->adj_table) m = similar_count/10.0 + m;
+  return (m/short_codes_len + m/long_codes_len + (m-t)/m) / 3;
+}
+
+double jaro_winkler_distance_from_codes(unsigned long long* short_codes, int short_codes_len, unsigned long long* long_codes, int long_codes_len, LibJaroOption *opt){
+  double jaro_distance = jaro_distance_from_codes(short_codes, short_codes_len, long_codes, long_codes_len, opt);
+
+  if(jaro_distance < opt->threshold) return jaro_distance;
+  else{
+    int prefix = 0;
+    int max_4 = short_codes_len > 4 ? 4 : short_codes_len;
+    for(prefix = 0; prefix < max_4 && short_codes[prefix] == long_codes[prefix]; prefix++);
+    return jaro_distance + prefix*opt->weight*(1-jaro_distance);
+  }
+}

data/ext/jaro_winkler/jaro.h

@@ -0,0 +1,17 @@
+#ifndef LIBJARO_JARO_H
+#define LIBJARO_JARO_H
+
+#define DEFAULT_WEIGHT 0.1
+#define DEFAULT_THRESHOLD 0.7
+
+typedef struct LibJaroOption{
+  double weight, threshold;
+  char ignore_case, adj_table;
+} LibJaroOption;
+
+
+static const LibJaroOption DEFAULT_OPT = {.weight = DEFAULT_WEIGHT, .threshold = DEFAULT_THRESHOLD, .ignore_case = 0, .adj_table = 0};
+double jaro_distance(char *str1, int len1, char *str2, int len2, LibJaroOption *opt);
+double jaro_winkler_distance(char *str1, int len1, char *str2, int len2, LibJaroOption *opt);
+
+#endif

data/ext/jaro_winkler/jaro_winkler.c

@@ -0,0 +1,45 @@
+#include "ruby.h"
+#include "jaro.h"
+
+VALUE rb_mJaroWinkler,
+      rb_eError,
+      rb_eInvalidWeightError;
+
+VALUE rb_jaro_winkler_distance(int argc, VALUE *argv, VALUE self);
+VALUE rb_jaro_distance(int argc, VALUE *argv, VALUE self);
+VALUE distance(int argc, VALUE *argv, VALUE self, double (*distance_fn)(char *str1, int len1, char *str2, int len2, LibJaroOption *opt));
+
+void Init_jaro_winkler_ext(void){
+  rb_mJaroWinkler = rb_define_module("JaroWinkler");
+  rb_eError = rb_define_class_under(rb_mJaroWinkler, "Error", rb_eRuntimeError);
+  rb_eInvalidWeightError = rb_define_class_under(rb_mJaroWinkler, "InvalidWeightError", rb_eError);
+  rb_define_module_function(rb_mJaroWinkler, "distance", rb_jaro_winkler_distance, -1);
+  rb_define_module_function(rb_mJaroWinkler, "jaro_distance", rb_jaro_distance, -1);
+}
+
+
+VALUE distance(int argc, VALUE *argv, VALUE self, double (*distance_fn)(char *str1, int len1, char *str2, int len2, LibJaroOption *opt)){
+  VALUE s1, s2, opt;
+  rb_scan_args(argc, argv, "2:", &s1, &s2, &opt);
+  LibJaroOption c_opt = DEFAULT_OPT;
+  if(TYPE(opt) == T_HASH){
+    VALUE weight = rb_hash_aref(opt, ID2SYM(rb_intern("weight"))),
+          threshold = rb_hash_aref(opt, ID2SYM(rb_intern("threshold"))),
+          ignore_case = rb_hash_aref(opt, ID2SYM(rb_intern("ignore_case"))),
+          adj_table = rb_hash_aref(opt, ID2SYM(rb_intern("adj_table")));
+    if(!NIL_P(weight)) c_opt.weight = NUM2DBL(weight);
+    if(c_opt.weight > 0.25) rb_raise(rb_eInvalidWeightError, "Scaling factor should not exceed 0.25, otherwise the distance can become larger than 1.");
+    if(!NIL_P(threshold)) c_opt.threshold = NUM2DBL(threshold);
+    if(!NIL_P(ignore_case)) c_opt.ignore_case = (TYPE(ignore_case) == T_FALSE || NIL_P(ignore_case)) ? 0 : 1;
+    if(!NIL_P(adj_table)) c_opt.adj_table = (TYPE(adj_table) == T_FALSE || NIL_P(adj_table)) ? 0 : 1;
+  }
+  return rb_float_new((*distance_fn)(StringValuePtr(s1), RSTRING_LEN(s1), StringValuePtr(s2), RSTRING_LEN(s2), &c_opt));
+}
+
+VALUE rb_jaro_distance(int argc, VALUE *argv, VALUE self){
+  return distance(argc, argv, self, jaro_distance);
+}
+
+VALUE rb_jaro_winkler_distance(int argc, VALUE *argv, VALUE self){
+  return distance(argc, argv, self, jaro_winkler_distance);
+}

data/ext/jaro_winkler/murmur_hash2.c

@@ -0,0 +1,64 @@
+//-----------------------------------------------------------------------------
+// MurmurHash2, by Austin Appleby
+
+// Note - This code makes a few assumptions about how your machine behaves -
+
+// 1. We can read a 4-byte value from any address without crashing
+// 2. sizeof(int) == 4
+
+// And it has a few limitations -
+
+// 1. It will not work incrementally.
+// 2. It will not produce the same results on little-endian and big-endian
+//    machines.
+
+unsigned int MurmurHash2 ( const void * key, int len, unsigned int seed )
+{
+  // 'm' and 'r' are mixing constants generated offline.
+  // They're not really 'magic', they just happen to work well.
+
+  const unsigned int m = 0x5bd1e995;
+  const int r = 24;
+
+  // Initialize the hash to a 'random' value
+
+  unsigned int h = seed ^ len;
+
+  // Mix 4 bytes at a time into the hash
+
+  const unsigned char * data = (const unsigned char *)key;
+
+  while(len >= 4)
+  {
+    unsigned int k = *(unsigned int *)data;
+
+    k *= m;
+    k ^= k >> r;
+    k *= m;
+
+    h *= m;
+    h ^= k;
+
+    data += 4;
+    len -= 4;
+  }
+  
+  // Handle the last few bytes of the input array
+
+  switch(len)
+  {
+  case 3: h ^= data[2] << 16;
+  case 2: h ^= data[1] << 8;
+  case 1: h ^= data[0];
+          h *= m;
+  };
+
+  // Do a few final mixes of the hash to ensure the last few
+  // bytes are well-incorporated.
+
+  h ^= h >> 13;
+  h *= m;
+  h ^= h >> 15;
+
+  return h;
+} 

data/lib/jaro_winkler.rb

@@ -0,0 +1,9 @@
+require 'jaro_winkler/version'
+
+case RUBY_PLATFORM
+when 'java'
+  require 'jaro_winkler/jaro_winkler_pure'
+else
+  require 'jaro_winkler/jaro_winkler_ext'
+end
+  

data/lib/jaro_winkler/adjusting_table.rb

@@ -0,0 +1,19 @@
+module JaroWinkler
+  DEFAULT_ADJ_TABLE = Hash.new
+  [
+    ['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', ' ']
+  ].each{ |s1, s2|
+    if not DEFAULT_ADJ_TABLE.has_key?(s1)
+      DEFAULT_ADJ_TABLE[s1] = Hash.new
+    end
+    if not DEFAULT_ADJ_TABLE.has_key?(s2)
+      DEFAULT_ADJ_TABLE[s2] = Hash.new
+    end
+    DEFAULT_ADJ_TABLE[s1][s2] = DEFAULT_ADJ_TABLE[s2][s1] = true
+  }
+  DEFAULT_ADJ_TABLE.default = Hash.new
+end

data/lib/jaro_winkler/jaro_winkler_pure.rb

@@ -0,0 +1,125 @@
+require 'jaro_winkler/adjusting_table'
+module JaroWinkler
+  class Error < RuntimeError; end
+  class InvalidWeightError < Error; end
+
+  DEFAULT_WEIGHT = 0.1
+  DEFAULT_THRESHOLD = 0.7
+  DEFAULT_OPTIONS = {
+    jaro: {adj_table: false, ignore_case: false},
+    jaro_winkler: {weight: DEFAULT_WEIGHT, threshold: DEFAULT_THRESHOLD}
+  }
+
+  module_function
+
+  def distance str1, str2, options={}
+    _distance str1.codepoints.to_a, str2.codepoints.to_a, options
+  end
+
+  def jaro_distance str1, str2, options={}
+    _jaro_distance str1.codepoints.to_a, str2.codepoints.to_a, options
+  end
+
+  def _distance codes1, codes2, options={}
+    options = DEFAULT_OPTIONS[:jaro_winkler].merge options
+    raise InvalidWeightError if options[:weight] > 0.25
+    jaro_distance = _jaro_distance(codes1, codes2, options);
+
+    if jaro_distance < options[:threshold]
+      jaro_distance
+    else
+      codes1, codes2 = codes2, codes1 if codes1.length > codes2.length
+      len1, len2 = codes1.length, codes2.length
+      max_4 = len1 > 4 ? 4 : len1
+      prefix = 0
+      while prefix < max_4 && codes1[prefix] == codes2[prefix]
+        prefix += 1
+      end
+      jaro_distance + prefix * options[:weight] * (1 - jaro_distance)
+    end
+  end
+
+  def _jaro_distance codes1, codes2, options={}
+    options = DEFAULT_OPTIONS[:jaro].merge options
+
+    codes1, codes2 = codes2, codes1 if codes1.length > codes2.length
+    len1, len2 = codes1.length, codes2.length
+    return 0.0 if len1 == 0 || len2 == 0
+
+    if options[:ignore_case]
+      codes1.map!{ |c| c >= 97 && c <= 122 ? c -= 32 : c }
+      codes2.map!{ |c| c >= 97 && c <= 122 ? c -= 32 : c }
+    end
+
+    window = len2/2 - 1
+    window = 0 if(window < 0)
+    flags1, flags2 = 0, 0
+
+    # // count number of matching characters
+    match_count = 0;
+    i = 0
+    while i < len1
+      left = (i >= window) ? i - window : 0
+      right = (i + window <= len2 - 1) ? (i + window) : (len2 - 1)
+      right = len2 - 1 if right > len2 - 1
+      j = left
+      while j <= right
+        if flags2[j] == 0 && codes1[i] == codes2[j]
+          flags1 |= (1 << i)
+          flags2 |= (1 << j)
+          match_count += 1
+          break
+        end
+        j +=1
+      end
+      i += 1
+    end
+
+    return 0.0 if match_count == 0
+
+    # // count number of transpositions
+    transposition_count = j = k = 0
+    i = 0
+    while i < len1
+      if flags1[i] == 1
+        j = k
+        while j < len2
+          if flags2[j] == 1
+            k = j + 1;
+            break;
+          end
+          j += 1
+        end
+        transposition_count += 1 if codes1[i] != codes2[j]
+      end
+      i += 1
+    end
+
+    # // count similarities in nonmatched characters
+    similar_count = 0
+    if options[:adj_table] && len1 > match_count
+      i = 0
+      while i < len1
+        if flags1[i] == 0
+          j = 0
+          while j < len2
+            if flags2[j] == 0
+              if DEFAULT_ADJ_TABLE[codes1[i].chr(Encoding::UTF_8)][codes2[j].chr(Encoding::UTF_8)]
+                similar_count += 3
+                break
+              end
+            end
+            j += 1
+          end
+        end
+        i += 1
+      end
+    end
+
+    m = match_count.to_f
+    t = transposition_count/2
+    m = similar_count/10.0 + m if options[:adj_table]
+    (m/len1 + m/len2 + (m-t)/m) / 3
+  end
+
+end

data/lib/jaro_winkler/version.rb

@@ -0,0 +1,3 @@
+module JaroWinkler
+  VERSION = '1.4.0'
+end

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification
+name: jaro_winkler
+version: !ruby/object:Gem::Version
+  version: 1.4.0
+platform: java
+authors:
+- Jian Weihang
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2015-12-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: rake
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: minitest
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  prerelease: false
+  type: :development
+description: It's a implementation of Jaro-Winkler distance algorithm, it uses C extension and will fallback to pure Ruby version in JRuby. Both implementation supports UTF-8 string.
+email: tonytonyjan@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ext/jaro_winkler/adj_matrix.c
+- ext/jaro_winkler/adj_matrix.h
+- ext/jaro_winkler/code.c
+- ext/jaro_winkler/code.h
+- ext/jaro_winkler/jaro.c
+- ext/jaro_winkler/jaro.h
+- ext/jaro_winkler/jaro_winkler.c
+- ext/jaro_winkler/murmur_hash2.c
+- lib/jaro_winkler.rb
+- lib/jaro_winkler/adjusting_table.rb
+- lib/jaro_winkler/jaro_winkler_pure.rb
+- lib/jaro_winkler/version.rb
+homepage: https://github.com/tonytonyjan/jaro_winkler
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+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: []
+rubyforge_project:
+rubygems_version: 2.4.5
+signing_key:
+specification_version: 4
+summary: Ruby & C implementation of Jaro-Winkler distance algorithm which both support UTF-8 string.
+test_files: []