jaro_winkler 1.5.1-java → 1.5.2-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: a3fd3fabbc7662b62ead8988ef48c53a89d75b6f
-  data.tar.gz: 7ba3eff5e134aadab37aa52f22665d78e66f6dcd
+SHA256:
+  metadata.gz: 47ffec43f4a902a16038fa817a68df9f5caea07ad68c4afe43c87b934b2ea1c8
+  data.tar.gz: 6a6cfd3195c5c03de0204fa25426a20ab0882cb8f012540022ac205f7c2cefad
 SHA512:
-  metadata.gz: 3ee03982e280949d7069e5f25d4e1c5103b047abe5853e6497f5926a3cc5155c11f0876fc93461f7f26b1eb0985d9cf987b109d5898386928419032533cd1c8f
-  data.tar.gz: 902531a857d93d74bce572bfc8c604e61dcaf5853794ad36d530208bf70c85d2f43b84624550bbee1e4ddc0fac80fe3be91d96764390d060b1b7230f96c24520
+  metadata.gz: 5cb9917bb131d2d5b51f99c1733dfb6ae6c695b1707edf8ff6f688d6a959c31536d5531cb31e020e6fe85df516ba1351f1f87d178d2f9aefa43beb7e99a916b5
+  data.tar.gz: 92973324ff6da1ba02bddd4d9a7a69b9badbc8c2556d2176b753e263e185ed0de84dd74310548f4ece54e47f558d581a1ab738e80a60c985438315c3a8a830d6

data/lib/jaro_winkler/jaro_winkler_pure.rb

@@ -14,10 +14,12 @@ module JaroWinkler
 
   class << self
     def distance(str1, str2, options = {})
+      validate!(str1, str2)
       _distance str1.codepoints.to_a, str2.codepoints.to_a, options
     end
 
     def jaro_distance(str1, str2, options = {})
+      validate!(str1, str2)
       _jaro_distance str1.codepoints.to_a, str2.codepoints.to_a, options
     end
 
@@ -125,5 +127,9 @@ module JaroWinkler
       m = similar_count / 10.0 + m if options[:adj_table]
       (m / len1 + m / len2 + (m - t) / m) / 3
     end
+
+    def validate!(str1, str2)
+      raise TypeError unless str1.is_a?(String) && str2.is_a?(String)
+    end
   end
 end

data/lib/jaro_winkler/version.rb

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

metadata

@@ -1,22 +1,22 @@
 --- !ruby/object:Gem::Specification
 name: jaro_winkler
 version: !ruby/object:Gem::Version
-  version: 1.5.1
+  version: 1.5.2
 platform: java
 authors:
 - Jian Weihang
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-06-13 00:00:00.000000000 Z
+date: 2019-01-04 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'
-  name: bundler
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -25,12 +25,12 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.7'
 - !ruby/object:Gem::Dependency
+  name: rake
   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
@@ -39,12 +39,12 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '12.0'
 - !ruby/object:Gem::Dependency
+  name: rake-compiler
   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
@@ -53,12 +53,12 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
+  name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  name: minitest
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -77,13 +77,6 @@ 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
@@ -92,7 +85,7 @@ homepage: https://github.com/tonytonyjan/jaro_winkler
 licenses:
 - MIT
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -107,9 +100,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project:
-rubygems_version: 2.6.14.1
-signing_key:
+rubyforge_project: 
+rubygems_version: 2.7.3
+signing_key: 
 specification_version: 4
 summary: An implementation of Jaro-Winkler distance algorithm written \ in C extension
   which supports any kind of string encoding.

data/ext/jaro_winkler/adj_matrix.c

@@ -1,97 +0,0 @@
-#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

@@ -1,22 +0,0 @@
-#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

@@ -1,61 +0,0 @@
-#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

@@ -1,13 +0,0 @@
-#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

@@ -1,121 +0,0 @@
-#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

@@ -1,17 +0,0 @@
-#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

@@ -1,70 +0,0 @@
-#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);
-}