jaro_winkler 1.5.1-universal-java-10

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2f783ac8d8355443adfe51a5d3f32cf7b8ddef5f
+  data.tar.gz: 96f863de9c8e879104fdb78ded7834691ad6ca66
+SHA512:
+  metadata.gz: 354d4337b57d40de31960a6fd050d56ca7dd852031f5ad0525e7f2147ef8345ab6c4b4d53ff93a0e6011b55dc342b2ab05147db277c392f31988109757219685
+  data.tar.gz: 8db99ee1730ac2d84d95ec509fd9d2395ae812d6169bf1ce9f60c44495bafa541b4fbe39a3688c521b5f38707d635164c7ef5b8b7b062390ff2be6a017e6ce8c

data/ext/jaro_winkler/adj_matrix.c

@@ -0,0 +1,97 @@
+#include "adj_matrix.h"
+#include "codepoints.h"
+#include "ruby.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", " "};
+
+void node_free(Node *head);
+
+AdjMatrix *adj_matrix_new(uint32_t length) {
+  AdjMatrix *matrix = malloc(sizeof(AdjMatrix));
+  matrix->length = length == 0 ? ADJ_MATRIX_DEFAULT_LENGTH : length;
+  matrix->table = malloc(matrix->length * sizeof(Node **));
+  for (size_t i = 0; i < matrix->length; i++) {
+    matrix->table[i] = malloc(matrix->length * sizeof(Node *));
+    for (size_t j = 0; j < matrix->length; j++)
+      matrix->table[i][j] = NULL;
+  }
+  return matrix;
+}
+
+void adj_matrix_add(AdjMatrix *matrix, uint64_t x, uint64_t y) {
+  uint32_t h1 = st_hash(&x, sizeof(x), ADJ_MATRIX_SEED) %
+                ADJ_MATRIX_DEFAULT_LENGTH,
+           h2 = st_hash(&y, sizeof(y), 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, uint64_t x, uint64_t y) {
+  uint32_t h1 = st_hash(&x, sizeof(x), ADJ_MATRIX_SEED) %
+                ADJ_MATRIX_DEFAULT_LENGTH,
+           h2 = st_hash(&y, sizeof(y), 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 (size_t i = 0; i < matrix->length; i++) {
+    for (size_t 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);
+    size_t length = sizeof(DEFAULT_ADJ_TABLE) / sizeof(char *);
+    for (size_t i = 0; i < length; i += 2) {
+      uint64_t code_1, code_2;
+      code_1 = *DEFAULT_ADJ_TABLE[i] & 0xff;
+      code_2 = *DEFAULT_ADJ_TABLE[i + 1] & 0xff;
+      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 @@
+#pragma once
+
+#include "stdint.h"
+
+#define ADJ_MATRIX_DEFAULT_LENGTH 958
+#define ADJ_MATRIX_SEED 9527
+
+typedef struct _node {
+  struct _node *next;
+  uint64_t x, y;
+} Node;
+
+typedef struct {
+  Node ***table;
+  uint32_t length;
+} AdjMatrix;
+
+AdjMatrix *adj_matrix_new(uint32_t length);
+void adj_matrix_add(AdjMatrix *matrix, uint64_t x, uint64_t y);
+char adj_matrix_find(AdjMatrix *matrix, uint64_t x, uint64_t y);
+void adj_matrix_free(AdjMatrix *matrix);
+AdjMatrix *adj_matrix_default();

data/ext/jaro_winkler/codepoints.c

@@ -0,0 +1,61 @@
+#include "codepoints.h"
+#include "ruby.h"
+#include "ruby/encoding.h"
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+// this function is copied from string.c
+static inline int single_byte_optimizable(VALUE str) {
+  rb_encoding *enc;
+
+  /* Conservative.  It may be ENC_CODERANGE_UNKNOWN. */
+  if (ENC_CODERANGE(str) == ENC_CODERANGE_7BIT)
+    return 1;
+
+  enc = rb_enc_get(str);
+  if (rb_enc_mbmaxlen(enc) == 1)
+    return 1;
+
+  /* Conservative.  Possibly single byte.
+   * "\xa1" in Shift_JIS for example. */
+  return 0;
+}
+
+void codepoints_init(CodePoints *codepoints, VALUE str) {
+  size_t i, length;
+  int32_t n;
+  uint32_t c;
+  const char *ptr, *end;
+  rb_encoding *enc;
+
+  if (single_byte_optimizable(str)) {
+    length = RSTRING_LEN(str);
+    ptr = RSTRING_PTR(str);
+    codepoints->data = malloc(length * sizeof(*codepoints->data));
+    for (i = 0, codepoints->length = 0; i < length; i++, codepoints->length++)
+      codepoints->data[i] = ptr[i] & 0xff;
+  } else {
+    codepoints->length = 0;
+    codepoints->size = 32;
+    codepoints->data = malloc(codepoints->size * sizeof(*codepoints->data));
+    str = rb_str_new_frozen(str);
+    ptr = RSTRING_PTR(str);
+    end = RSTRING_END(str);
+    enc = rb_enc_get(str);
+
+    while (ptr < end) {
+      c = rb_enc_codepoint_len(ptr, end, &n, enc);
+      if (codepoints->length == codepoints->size) {
+        codepoints->size *= 2;
+        codepoints->data = realloc(codepoints->data, sizeof(*codepoints->data) *
+                                                         codepoints->size);
+      }
+      codepoints->data[codepoints->length++] = c;
+      ptr += n;
+    }
+    RB_GC_GUARD(str);
+  }
+}
+
+void codepoints_free(CodePoints *codepoints) { free(codepoints->data); }

data/ext/jaro_winkler/codepoints.h

@@ -0,0 +1,13 @@
+#pragma once
+#include "ruby.h"
+#include <stddef.h>
+#include <stdint.h>
+
+typedef struct {
+  uint32_t *data;
+  size_t length;
+  size_t size;
+} CodePoints;
+
+void codepoints_init(CodePoints *, VALUE str);
+void codepoints_free(CodePoints *);

data/ext/jaro_winkler/jaro.c

@@ -0,0 +1,121 @@
+#include "jaro.h"
+#include "adj_matrix.h"
+#include "codepoints.h"
+
+#include <ctype.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define DEFAULT_WEIGHT 0.1
+#define DEFAULT_THRESHOLD 0.7
+#define SWAP(x, y)                                                             \
+  do {                                                                         \
+    __typeof__(x) SWAP = x;                                                    \
+    x = y;                                                                     \
+    y = SWAP;                                                                  \
+  } while (0)
+
+const Options DEFAULT_OPTIONS = {.weight = DEFAULT_WEIGHT,
+                                 .threshold = DEFAULT_THRESHOLD,
+                                 .ignore_case = 0,
+                                 .adj_table = 0};
+
+double jaro_distance_from_codes(uint32_t *codepoints1, size_t len1,
+                                uint32_t *codepoints2, size_t len2,
+                                Options *opt) {
+  if (!len1 || !len2)
+    return 0.0;
+
+  if (len1 > len2) {
+    SWAP(codepoints1, codepoints2);
+    SWAP(len1, len2);
+  }
+
+  if (opt->ignore_case) {
+    for (size_t i = 0; i < len1; i++)
+      codepoints1[i] = tolower(codepoints1[i]);
+    for (size_t i = 0; i < len2; i++)
+      codepoints2[i] = tolower(codepoints2[i]);
+  }
+
+  int32_t window_size = (int32_t)len2 / 2 - 1;
+  if (window_size < 0)
+    window_size = 0;
+
+  char short_codes_flag[len1];
+  char long_codes_flag[len2];
+  memset(short_codes_flag, 0, len1);
+  memset(long_codes_flag, 0, len2);
+
+  // count number of matching characters
+  size_t match_count = 0;
+  for (size_t i = 0; i < len1; i++) {
+    size_t left = (i >= (size_t)window_size) ? i - window_size : 0;
+    size_t right =
+        (i + window_size <= len2 - 1) ? (i + window_size) : (len2 - 1);
+    if (right > len2 - 1)
+      right = len2 - 1;
+    for (size_t j = left; j <= right; j++) {
+      if (!long_codes_flag[j] && codepoints1[i] == codepoints2[j]) {
+        short_codes_flag[i] = long_codes_flag[j] = 1;
+        match_count++;
+        break;
+      }
+    }
+  }
+
+  if (!match_count)
+    return 0.0;
+
+  // count number of transpositions
+  size_t transposition_count = 0, j = 0, k = 0;
+  for (size_t i = 0; i < len1; i++) {
+    if (short_codes_flag[i]) {
+      for (j = k; j < len2; j++) {
+        if (long_codes_flag[j]) {
+          k = j + 1;
+          break;
+        }
+      }
+      if (codepoints1[i] != codepoints2[j])
+        transposition_count++;
+    }
+  }
+
+  // count similarities in nonmatched characters
+  size_t similar_count = 0;
+  if (opt->adj_table && len1 > match_count)
+    for (size_t i = 0; i < len1; i++)
+      if (!short_codes_flag[i])
+        for (size_t j = 0; j < len2; j++)
+          if (!long_codes_flag[j])
+            if (adj_matrix_find(adj_matrix_default(), codepoints1[i],
+                                codepoints2[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 / len1 + m / len2 + (m - t) / m) / 3;
+}
+
+double jaro_winkler_distance_from_codes(uint32_t *codepoints1, size_t len1,
+                                        uint32_t *codepoints2, size_t len2,
+                                        Options *opt) {
+  double jaro_distance =
+      jaro_distance_from_codes(codepoints1, len1, codepoints2, len2, opt);
+
+  if (jaro_distance < opt->threshold)
+    return jaro_distance;
+  else {
+    size_t prefix = 0;
+    size_t max_4 = len1 > 4 ? 4 : len1;
+    for (prefix = 0;
+         prefix < max_4 && codepoints1[prefix] == codepoints2[prefix]; prefix++)
+      ;
+    return jaro_distance + prefix * opt->weight * (1 - jaro_distance);
+  }
+}

data/ext/jaro_winkler/jaro.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#include <stddef.h>
+#include <stdint.h>
+
+typedef struct {
+  double weight, threshold;
+  char ignore_case, adj_table;
+} Options;
+
+extern const Options DEFAULT_OPTIONS;
+
+double jaro_distance_from_codes(uint32_t *codepoints1, size_t len1,
+                                uint32_t *codepoints2, size_t len2, Options *);
+double jaro_winkler_distance_from_codes(uint32_t *codepoints1, size_t len1,
+                                        uint32_t *codepoints2, size_t len2,
+                                        Options *);

data/ext/jaro_winkler/jaro_winkler.c

@@ -0,0 +1,70 @@
+#include "codepoints.h"
+#include "jaro.h"
+#include "ruby.h"
+
+VALUE rb_mJaroWinkler, rb_eError, rb_eInvalidWeightError;
+
+VALUE rb_jaro_winkler_distance(size_t argc, VALUE *argv, VALUE self);
+VALUE rb_jaro_distance(size_t argc, VALUE *argv, VALUE self);
+VALUE distance(size_t argc, VALUE *argv, VALUE self,
+               double (*distance_fn)(uint32_t *codepoints1, size_t len1,
+                                     uint32_t *codepoints2, size_t len2,
+                                     Options *));
+
+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_singleton_method(rb_mJaroWinkler, "distance",
+                             rb_jaro_winkler_distance, -1);
+  rb_define_singleton_method(rb_mJaroWinkler, "jaro_distance", rb_jaro_distance,
+                             -1);
+}
+
+VALUE distance(size_t argc, VALUE *argv, VALUE self,
+               double (*distance_fn)(uint32_t *codepoints1, size_t len1,
+                                     uint32_t *codepoints2, size_t len2,
+                                     Options *)) {
+  VALUE s1, s2, opt;
+  CodePoints cp1, cp2;
+
+  rb_scan_args((int32_t)argc, argv, "2:", &s1, &s2, &opt);
+  codepoints_init(&cp1, s1);
+  codepoints_init(&cp2, s2);
+
+  Options c_opt = DEFAULT_OPTIONS;
+  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;
+  }
+  VALUE ret = rb_float_new(
+      (*distance_fn)(cp1.data, cp1.length, cp2.data, cp2.length, &c_opt));
+  codepoints_free(&cp1);
+  codepoints_free(&cp2);
+  return ret;
+}
+
+VALUE rb_jaro_distance(size_t argc, VALUE *argv, VALUE self) {
+  return distance(argc, argv, self, jaro_distance_from_codes);
+}
+
+VALUE rb_jaro_winkler_distance(size_t argc, VALUE *argv, VALUE self) {
+  return distance(argc, argv, self, jaro_winkler_distance_from_codes);
+}

data/lib/jaro_winkler.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'jaro_winkler/version'
+
+if RUBY_ENGINE == 'ruby'
+  require 'jaro_winkler/jaro_winkler_ext'
+else
+  require 'jaro_winkler/jaro_winkler_pure'
+end

data/lib/jaro_winkler/adjusting_table.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module JaroWinkler
+  DEFAULT_ADJ_TABLE = Hash.new { |h, k| h[k] = Hash.new(&h.default_proc) }
+  [
+    %w[A E], %w[A I], %w[A O], %w[A U], %w[B V], %w[E I], %w[E O], %w[E U], %w[I O],
+    %w[I U], %w[O U], %w[I Y], %w[E Y], %w[C G], %w[E F], %w[W U], %w[W V], %w[X K],
+    %w[S Z], %w[X S], %w[Q C], %w[U V], %w[M N], %w[L I], %w[Q O], %w[P R], %w[I J],
+    %w[2 Z], %w[5 S], %w[8 B], %w[1 I], %w[1 L], %w[0 O], %w[0 Q], %w[C K], %w[G J],
+    ['E', ' '], ['Y', ' '], ['S', ' ']
+  ].each do |s1, s2|
+    DEFAULT_ADJ_TABLE[s1][s2] = DEFAULT_ADJ_TABLE[s2][s1] = true
+  end
+end

data/lib/jaro_winkler/jaro_winkler_pure.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+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 }
+  }.freeze
+
+  class << self
+    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
+
+    private
+
+    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 = codes1.length
+        len2 = codes2.length
+        max_4 = len1 > 4 ? 4 : len1
+        prefix = 0
+        prefix += 1 while prefix < max_4 && codes1[prefix] == codes2[prefix]
+        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 = codes1.length
+      len2 = 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 = 0
+      flags2 = 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
+end

data/lib/jaro_winkler/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module JaroWinkler
+  VERSION = '1.5.1'
+end

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification
+name: jaro_winkler
+version: !ruby/object:Gem::Version
+  version: 1.5.1
+platform: universal-java-10
+authors:
+- Jian Weihang
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2018-06-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  name: bundler
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+  name: rake
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: rake-compiler
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: minitest
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |-
+  jaro_winkler is an implementation of Jaro-Winkler \
+    distance algorithm which is written in C extension and will fallback to pure \
+    Ruby version in platforms other than MRI/KRI like JRuby or Rubinius. Both of \
+    C and Ruby implementation support any kind of string encoding, such as \
+    UTF-8, EUC-JP, Big5, etc.
+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/codepoints.c
+- ext/jaro_winkler/codepoints.h
+- ext/jaro_winkler/jaro.c
+- ext/jaro_winkler/jaro.h
+- ext/jaro_winkler/jaro_winkler.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.6.14.1
+signing_key:
+specification_version: 4
+summary: An implementation of Jaro-Winkler distance algorithm written \ in C extension
+  which supports any kind of string encoding.
+test_files: []