amatch 0.2.8 → 0.2.9

data/.travis.yml

@@ -1,6 +1,7 @@
 rvm:
   - 1.8.7
   - 1.9.2
+  - 1.9.3
   - ruby-head
   - ree
   - rbx

data/CHANGES

@@ -1,3 +1,10 @@
+2011-11-14 (0.2.9)
+    * Provide amatch/rude and amatch/polite for require (the latter doesn't
+      extend ::String on its own)
+    * pair_distance_similar method now can take an optional regexp argument for
+      tokenizing.
+2011-09-26 (0.2.8)
+    * Depend on tins library.
 2011-08-06 (0.2.7)
     * Fix some violations of ISO C90 standard.
 2011-07-16 (0.2.6)

data/VERSION

@@ -1 +1 @@
-0.2.8
+0.2.9

data/amatch.gemspec

@@ -2,38 +2,38 @@
 
 Gem::Specification.new do |s|
   s.name = "amatch"
-  s.version = "0.2.8"
+  s.version = "0.2.9"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Florian Frank"]
-  s.date = "2011-09-25"
+  s.date = "2011-11-15"
   s.description = "Amatch is a library for approximate string matching and searching in strings.\nSeveral algorithms can be used to do this, and it's also possible to compute a\nsimilarity metric number between 0.0 and 1.0 for two given strings.\n"
   s.email = "flori@ping.de"
   s.executables = ["agrep.rb"]
   s.extensions = ["ext/extconf.rb"]
-  s.extra_rdoc_files = ["README.rdoc", "lib/amatch/version.rb", "ext/amatch.c", "ext/pair.c"]
-  s.files = [".gitignore", ".travis.yml", "CHANGES", "COPYING", "Gemfile", "README.rdoc", "Rakefile", "VERSION", "amatch.gemspec", "bin/agrep.rb", "ext/amatch.c", "ext/common.h", "ext/extconf.rb", "ext/pair.c", "ext/pair.h", "install.rb", "lib/amatch/.keep", "lib/amatch/version.rb", "tests/test_hamming.rb", "tests/test_jaro.rb", "tests/test_jaro_winkler.rb", "tests/test_levenshtein.rb", "tests/test_longest_subsequence.rb", "tests/test_longest_substring.rb", "tests/test_pair_distance.rb", "tests/test_sellers.rb"]
+  s.extra_rdoc_files = ["README.rdoc", "lib/amatch/polite.rb", "lib/amatch/rude.rb", "lib/amatch/version.rb", "lib/amatch.rb", "ext/amatch_ext.c", "ext/pair.c"]
+  s.files = [".gitignore", ".travis.yml", "CHANGES", "COPYING", "Gemfile", "README.rdoc", "Rakefile", "VERSION", "amatch.gemspec", "bin/agrep.rb", "ext/amatch_ext.c", "ext/common.h", "ext/extconf.rb", "ext/pair.c", "ext/pair.h", "install.rb", "lib/amatch.rb", "lib/amatch/.keep", "lib/amatch/polite.rb", "lib/amatch/rude.rb", "lib/amatch/version.rb", "tests/test_hamming.rb", "tests/test_jaro.rb", "tests/test_jaro_winkler.rb", "tests/test_levenshtein.rb", "tests/test_longest_subsequence.rb", "tests/test_longest_substring.rb", "tests/test_pair_distance.rb", "tests/test_sellers.rb"]
   s.homepage = "http://github.com/flori/amatch"
   s.rdoc_options = ["--title", "Amatch - Approximate Matching", "--main", "README.rdoc"]
   s.require_paths = ["lib", "ext"]
   s.rubygems_version = "1.8.10"
   s.summary = "Approximate String Matching library"
-  s.test_files = ["tests/test_sellers.rb", "tests/test_jaro.rb", "tests/test_longest_subsequence.rb", "tests/test_longest_substring.rb", "tests/test_hamming.rb", "tests/test_pair_distance.rb", "tests/test_levenshtein.rb", "tests/test_jaro_winkler.rb"]
+  s.test_files = ["tests/test_hamming.rb", "tests/test_jaro.rb", "tests/test_jaro_winkler.rb", "tests/test_levenshtein.rb", "tests/test_longest_subsequence.rb", "tests/test_longest_substring.rb", "tests/test_pair_distance.rb", "tests/test_sellers.rb"]
 
   if s.respond_to? :specification_version then
     s.specification_version = 3
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_development_dependency(%q<gem_hadar>, ["~> 0.1.0"])
+      s.add_development_dependency(%q<gem_hadar>, ["~> 0.1.1"])
       s.add_development_dependency(%q<test-unit>, ["~> 2.3"])
       s.add_runtime_dependency(%q<tins>, ["~> 0.3"])
     else
-      s.add_dependency(%q<gem_hadar>, ["~> 0.1.0"])
+      s.add_dependency(%q<gem_hadar>, ["~> 0.1.1"])
       s.add_dependency(%q<test-unit>, ["~> 2.3"])
       s.add_dependency(%q<tins>, ["~> 0.3"])
     end
   else
-    s.add_dependency(%q<gem_hadar>, ["~> 0.1.0"])
+    s.add_dependency(%q<gem_hadar>, ["~> 0.1.1"])
     s.add_dependency(%q<test-unit>, ["~> 2.3"])
     s.add_dependency(%q<tins>, ["~> 0.3"])
   end

data/ext/{amatch.c → amatch_ext.c}

@@ -20,7 +20,7 @@
  */
 
 
-static VALUE rb_mAmatch, rb_cLevenshtein, rb_cSellers, rb_cHamming,
+static VALUE rb_mAmatch, rb_mAmatchStringMethods, rb_cLevenshtein, rb_cSellers, rb_cHamming,
              rb_cPairDistance, rb_cLongestSubsequence, rb_cLongestSubstring,
              rb_cJaro, rb_cJaroWinkler;
 
@@ -55,17 +55,17 @@ VALUE rb_##klass##_new(VALUE klass2, VALUE pattern)                     \
 static void rb_##klass##_free(type *amatch)                 \
 {                                                           \
     MEMZERO(amatch->pattern, char, amatch->pattern_len);    \
-    free(amatch->pattern);                                  \
+    xfree(amatch->pattern);                                 \
     MEMZERO(amatch, type, 1);                               \
-    free(amatch);                                           \
+    xfree(amatch);                                          \
 }
 
 #define DEF_PATTERN_ACCESSOR(type)                              \
 static void type##_pattern_set(type *amatch, VALUE pattern)     \
 {                                                               \
     Check_Type(pattern, T_STRING);                              \
-    free(amatch->pattern);                                      \
-    amatch->pattern_len = RSTRING_LEN(pattern);                 \
+    xfree(amatch->pattern);                                     \
+    amatch->pattern_len = (int) RSTRING_LEN(pattern);           \
     amatch->pattern = ALLOC_N(char, amatch->pattern_len);       \
     MEMCPY(amatch->pattern, RSTRING_PTR(pattern), char,         \
         RSTRING_LEN(pattern));                                  \
@@ -147,21 +147,21 @@ VALUE function(VALUE self, VALUE value)                                 \
 #define OPTIMIZE_TIME                                   \
     if (amatch->pattern_len < RSTRING_LEN(string)) {    \
         a_ptr = amatch->pattern;                        \
-        a_len = amatch->pattern_len;                    \
+        a_len = (int) amatch->pattern_len;              \
         b_ptr = RSTRING_PTR(string);                    \
-        b_len = RSTRING_LEN(string);                    \
+        b_len = (int) RSTRING_LEN(string);              \
     } else {                                            \
         a_ptr = RSTRING_PTR(string);                    \
-        a_len = RSTRING_LEN(string);                    \
+        a_len = (int) RSTRING_LEN(string);              \
         b_ptr = amatch->pattern;                        \
-        b_len = amatch->pattern_len;                    \
+        b_len = (int) amatch->pattern_len;              \
     }
 
 #define DONT_OPTIMIZE                                   \
         a_ptr = amatch->pattern;                        \
-        a_len = amatch->pattern_len;                    \
+        a_len = (int) amatch->pattern_len;              \
         b_ptr = RSTRING_PTR(string);                    \
-        b_len = RSTRING_LEN(string);                    \
+        b_len = (int) RSTRING_LEN(string);              \
 
 /*
  * C structures of the Amatch classes
@@ -215,10 +215,10 @@ DEF_PATTERN_ACCESSOR(Jaro)
 DEF_ITERATE_STRINGS(Jaro)
 
 typedef struct JaroWinklerStruct {
-    char *pattern;
-    int   pattern_len;
-    int   ignore_case;
-    float scaling_factor;
+    char   *pattern;
+    int    pattern_len;
+    int    ignore_case;
+    double scaling_factor;
 } JaroWinkler;
 
 DEF_ALLOCATOR(JaroWinkler)
@@ -271,8 +271,8 @@ static VALUE Levenshtein_match(General *amatch, VALUE string)
 
     result = INT2FIX(v[p][b_len]);
 
-    free(v[0]);
-    free(v[1]);
+    xfree(v[0]);
+    xfree(v[1]);
 
     return result;
 }
@@ -303,8 +303,8 @@ static VALUE Levenshtein_similar(General *amatch, VALUE string)
     } else {
         result = rb_float_new(1.0 - ((double) v[p][b_len]) / a_len);
     }
-    free(v[0]);
-    free(v[1]);
+    xfree(v[0]);
+    xfree(v[1]);
     return result;
 }
 
@@ -332,8 +332,8 @@ static VALUE Levenshtein_search(General *amatch, VALUE string)
 
     result = INT2FIX(min);
 
-    free(v[0]);
-    free(v[1]);
+    xfree(v[0]);
+    xfree(v[1]);
     
     return result;
 }
@@ -385,8 +385,8 @@ static VALUE Sellers_match(Sellers *amatch, VALUE string)
     COMPUTE_SELLERS_DISTANCE
 
     result = rb_float_new(v[p][b_len]);
-    free(v[0]);
-    free(v[1]);
+    xfree(v[0]);
+    xfree(v[1]);
     return result;
 }
 
@@ -430,8 +430,8 @@ static VALUE Sellers_similar(Sellers *amatch, VALUE string)
     } else {
         result = rb_float_new(1.0 - v[p][b_len] / (a_len * max_weight));
     }
-    free(v[0]);
-    free(v[1]);
+    xfree(v[0]);
+    xfree(v[1]);
     return result;
 }
 
@@ -457,8 +457,8 @@ static VALUE Sellers_search(Sellers *amatch, VALUE string)
         if (v[p][i] < min) min = v[p][i];
     }
     result = rb_float_new(min);
-    free(v[0]);
-    free(v[1]);
+    xfree(v[0]);
+    xfree(v[1]);
     
     return result;
 }
@@ -467,8 +467,7 @@ static VALUE Sellers_search(Sellers *amatch, VALUE string)
  * Pair distances are computed here:
  */
 
-static VALUE PairDistance_match(
-        PairDistance *amatch, VALUE string, VALUE regexp, int use_regexp)
+static VALUE PairDistance_match(PairDistance *amatch, VALUE string, VALUE regexp, int use_regexp)
 {
     double result;
     VALUE tokens;
@@ -564,8 +563,8 @@ static VALUE Hamming_similar(General *amatch, VALUE string)
         c = (c + 1) % 2;                                    \
     }                                                       \
     result = l[p][0];                                       \
-    free(l[0]);                                             \
-    free(l[1]);
+    xfree(l[0]);                                             \
+    xfree(l[1]);
 
 
 static VALUE LongestSubsequence_match(General *amatch, VALUE string)
@@ -619,8 +618,8 @@ static VALUE LongestSubsequence_similar(General *amatch, VALUE string)
         p = c;                                              \
         c = (c + 1) % 2;                                    \
     }                                                       \
-    free(l[0]);                                             \
-    free(l[1]);
+    xfree(l[0]);                                             \
+    xfree(l[1]);
 
 static VALUE LongestSubstring_match(General *amatch, VALUE string)
 {
@@ -692,8 +691,8 @@ static VALUE LongestSubstring_similar(General *amatch, VALUE string)
         t = t / 2;                                                                  \
         result = (((double)m)/a_len + ((double)m)/b_len + ((double)(m-t))/m)/3.0;   \
     }                                                                               \
-    free(l[0]);                                                                     \
-    free(l[1]);
+    xfree(l[0]);                                                                     \
+    xfree(l[1]);
 
 
 #define LOWERCASE_STRINGS                                       \
@@ -811,7 +810,7 @@ DEF_CONSTRUCTOR(Levenshtein, General)
  * Uses this Amatch::Levenshtein instance to match Amatch::Levenshtein#pattern
  * against <code>strings</code>. It returns the number operations, the Sellers
  * distance. <code>strings</code> has to be either a String or an Array of
- * Strings. The returned <code>results</code> are either a Float or an Array of
+ * Strings. The returned <code>results</code> is either a Float or an Array of
  * Floats respectively.
  */
 static VALUE rb_Levenshtein_match(VALUE self, VALUE strings)
@@ -827,7 +826,7 @@ static VALUE rb_Levenshtein_match(VALUE self, VALUE strings)
  * against <code>strings</code>, and compute a Levenshtein distance metric
  * number between 0.0 for very unsimilar strings and 1.0 for an exact match.
  * <code>strings</code> has to be either a String or an Array of Strings. The
- * returned <code>results</code> are either a Fixnum or an Array of Fixnums
+ * returned <code>results</code> is either a Fixnum or an Array of Fixnums
  * respectively.
  */
 static VALUE rb_Levenshtein_similar(VALUE self, VALUE strings)
@@ -843,7 +842,7 @@ static VALUE rb_Levenshtein_similar(VALUE self, VALUE strings)
  * to match against <code>strings</code>. It returns a Levenshtein distance
  * metric number between 0.0 for very unsimilar strings and 1.0 for an exact
  * match. <code>strings</code> has to be either a String or an Array of
- * Strings. The returned <code>results</code> are either a Float or an Array of
+ * Strings. The returned <code>results</code> is either a Float or an Array of
  * Floats respectively.
  */
 static VALUE rb_str_levenshtein_similar(VALUE self, VALUE strings)
@@ -859,7 +858,7 @@ static VALUE rb_str_levenshtein_similar(VALUE self, VALUE strings)
  * edit distance (the sum of character operations) as a Fixnum value, by greedy
  * trimming prefixes or postfixes of the match. <code>strings</code> has
  * to be either a String or an Array of Strings. The returned
- * <code>results</code> are either a Float or an Array of Floats respectively.
+ * <code>results</code> is either a Float or an Array of Floats respectively.
  */
 static VALUE rb_Levenshtein_search(VALUE self, VALUE strings)
 {                                                                            
@@ -998,7 +997,7 @@ DEF_CONSTRUCTOR(Sellers, Sellers)
  * <code>strings</code>, while taking into account the given weights. It
  * returns the number of weighted character operations, the Sellers distance.
  * <code>strings</code> has to be either a String or an Array of Strings. The
- * returned <code>results</code> are either a Float or an Array of Floats
+ * returned <code>results</code> is either a Float or an Array of Floats
  * respectively.
  */
 static VALUE rb_Sellers_match(VALUE self, VALUE strings)
@@ -1014,7 +1013,7 @@ static VALUE rb_Sellers_match(VALUE self, VALUE strings)
  * against <code>strings</code> (taking into account the given weights), and
  * compute a Sellers distance metric number between 0.0 for very unsimilar
  * strings and 1.0 for an exact match. <code>strings</code> has to be either a
- * String or an Array of Strings. The returned <code>results</code> are either
+ * String or an Array of Strings. The returned <code>results</code> is either
  * a Fixnum or an Array of Fixnums
  * respectively.
  */
@@ -1031,7 +1030,7 @@ static VALUE rb_Sellers_similar(VALUE self, VALUE strings)
  * distance (the sum of weighted character operations) as a Float value, by
  * greedy trimming prefixes or postfixes of the match. <code>strings</code> has
  * to be either a String or an Array of Strings. The returned
- * <code>results</code> are either a Float or an Array of Floats respectively.
+ * <code>results</code> is either a Float or an Array of Floats respectively.
  */
 static VALUE rb_Sellers_search(VALUE self, VALUE strings)
 {                                                                            
@@ -1089,7 +1088,7 @@ DEF_CONSTRUCTOR(PairDistance, PairDistance)
  * splitting should be omitted, call the method with nil as <code>regexp</code>
  * explicitly.
  *
- * The returned <code>results</code> are either a Float or an
+ * The returned <code>results</code> is either a Float or an
  * Array of Floats respectively.
  */
 static VALUE rb_PairDistance_match(int argc, VALUE *argv, VALUE self)
@@ -1125,19 +1124,30 @@ static VALUE rb_PairDistance_match(int argc, VALUE *argv, VALUE self)
 }
 
 /*
- * call-seq: pair_distance_similar(strings) -> results
+ * call-seq: pair_distance_similar(strings, regexp = nil) -> results
  *
  * If called on a String, this string is used as a Amatch::PairDistance#pattern
  * to match against <code>strings</code> using /\s+/ as the tokenizing regular
  * expression. It returns a pair distance metric number between 0.0 for very
  * unsimilar strings and 1.0 for an exact match. <code>strings</code> has to be
- * either a String or an Array of Strings. The returned <code>results</code>
- * are either a Float or an Array of Floats respectively.
+ * either a String or an Array of Strings.
+ *
+ * The returned <code>results</code> is either a Float or an Array of Floats
+ * respectively.
  */
-static VALUE rb_str_pair_distance_similar(VALUE self, VALUE strings)
+static VALUE rb_str_pair_distance_similar(int argc, VALUE *argv, VALUE self)
 {
-    VALUE amatch = rb_PairDistance_new(rb_cPairDistance, self);
-    return rb_PairDistance_match(1, &strings, amatch);
+    VALUE amatch, string, regexp = Qnil;
+    rb_scan_args(argc, argv, "11",  &string, &regexp);
+    amatch = rb_PairDistance_new(rb_cPairDistance, self);
+    if (NIL_P(regexp)) {
+        return rb_PairDistance_match(1, &string, amatch);
+    } else {
+        VALUE *args = alloca(2);
+        args[0] = string;
+        args[1] = regexp;
+        return rb_PairDistance_match(2, args, amatch);
+    }
 }
 
 /* 
@@ -1175,7 +1185,7 @@ DEF_CONSTRUCTOR(Hamming, General)
  * <code>strings</code>, that is compute the hamming distance between
  * <code>pattern</code> and <code>strings</code>. <code>strings</code> has to
  * be either a String or an Array of Strings. The returned <code>results</code>
- * are either a Fixnum or an Array of Fixnums respectively.
+ * is either a Fixnum or an Array of Fixnums respectively.
  */
 static VALUE rb_Hamming_match(VALUE self, VALUE strings)
 {                                                                            
@@ -1190,7 +1200,7 @@ static VALUE rb_Hamming_match(VALUE self, VALUE strings)
  * <code>strings</code>, and compute a Hamming distance metric number between
  * 0.0 for very unsimilar strings and 1.0 for an exact match.
  * <code>strings</code> has to be either a String or an Array of Strings. The
- * returned <code>results</code> are either a Fixnum or an Array of Fixnums
+ * returned <code>results</code> is either a Fixnum or an Array of Fixnums
  * respectively.
  */
 static VALUE rb_Hamming_similar(VALUE self, VALUE strings)
@@ -1207,7 +1217,7 @@ static VALUE rb_Hamming_similar(VALUE self, VALUE strings)
  * number between 0.0 for very unsimilar strings and 1.0 for an exact match.
  * <code>strings</code>
  * has to be either a String or an Array of Strings. The returned
- * <code>results</code> are either a Float or an Array of Floats respectively.
+ * <code>results</code> is either a Float or an Array of Floats respectively.
  */
 static VALUE rb_str_hamming_similar(VALUE self, VALUE strings)
 {
@@ -1251,7 +1261,7 @@ DEF_CONSTRUCTOR(LongestSubsequence, General)
  * LongestSubsequence#pattern against <code>strings</code>, that is compute the
  * length of the longest common subsequence. <code>strings</code> has to be
  * either a String or an Array of Strings. The returned <code>results</code>
- * are either a Fixnum or an Array of Fixnums respectively.
+ * is either a Fixnum or an Array of Fixnums respectively.
  */
 static VALUE rb_LongestSubsequence_match(VALUE self, VALUE strings)
 {                                                                            
@@ -1266,7 +1276,7 @@ static VALUE rb_LongestSubsequence_match(VALUE self, VALUE strings)
  * Amatch::LongestSubsequence#pattern against <code>strings</code>, and compute
  * a longest substring distance metric number between 0.0 for very unsimilar
  * strings and 1.0 for an exact match. <code>strings</code> has to be either a
- * String or an Array of Strings. The returned <code>results</code> are either
+ * String or an Array of Strings. The returned <code>results</code> is either
  * a Fixnum or an Array of Fixnums
  */
 static VALUE rb_LongestSubsequence_similar(VALUE self, VALUE strings)
@@ -1283,7 +1293,7 @@ static VALUE rb_LongestSubsequence_similar(VALUE self, VALUE strings)
  * returns a longest subsequence distance metric number between 0.0 for very
  * unsimilar strings and 1.0 for an exact match. <code>strings</code> has to be
  * either a String or an Array of Strings. The returned <code>results</code>
- * are either a Float or an Array of Floats respectively.
+ * is either a Float or an Array of Floats respectively.
  */
 static VALUE rb_str_longest_subsequence_similar(VALUE self, VALUE strings)
 {                                                                            
@@ -1328,7 +1338,7 @@ DEF_CONSTRUCTOR(LongestSubstring, General)
  * LongestSubstring#pattern against <code>strings</code>, that is compute the
  * length of the longest common substring. <code>strings</code> has to be
  * either a String or an Array of Strings. The returned <code>results</code>
- * are either a Fixnum or an Array of Fixnums respectively.
+ * is either a Fixnum or an Array of Fixnums respectively.
  */
 static VALUE rb_LongestSubstring_match(VALUE self, VALUE strings)
 {
@@ -1343,7 +1353,7 @@ static VALUE rb_LongestSubstring_match(VALUE self, VALUE strings)
  * Amatch::LongestSubstring#pattern against <code>strings</code>, and compute a
  * longest substring distance metric number between 0.0 for very unsimilar
  * strings and 1.0 for an exact match. <code>strings</code> has to be either a
- * String or an Array of Strings. The returned <code>results</code> are either
+ * String or an Array of Strings. The returned <code>results</code> is either
  * a Fixnum or an Array of Fixnums
  * respectively.
  */
@@ -1361,7 +1371,7 @@ static VALUE rb_LongestSubstring_similar(VALUE self, VALUE strings)
  * returns a longest substring distance metric number between 0.0 for very
  * unsimilar strings and 1.0 for an exact match. <code>strings</code> has to be
  * either a String or an Array of Strings. The returned <code>results</code>
- * are either a Float or an Array of Floats respectively.
+ * is either a Float or an Array of Floats respectively.
  */
 static VALUE rb_str_longest_substring_similar(VALUE self, VALUE strings)
 {                                                                            
@@ -1419,7 +1429,7 @@ DEF_CONSTRUCTOR(Jaro, Jaro)
  * Jaro#pattern against <code>strings</code>, that is compute the
  * jaro metric with the strings. <code>strings</code> has to be
  * either a String or an Array of Strings. The returned <code>results</code>
- * are either a Float or an Array of Floats respectively.
+ * is either a Float or an Array of Floats respectively.
  */
 static VALUE rb_Jaro_match(VALUE self, VALUE strings)
 {
@@ -1435,7 +1445,7 @@ static VALUE rb_Jaro_match(VALUE self, VALUE strings)
  * returns a Jaro metric number between 0.0 for very
  * unsimilar strings and 1.0 for an exact match. <code>strings</code> has to be
  * either a String or an Array of Strings. The returned <code>results</code>
- * are either a Float or an Array of Floats respectively.
+ * is either a Float or an Array of Floats respectively.
  */
 static VALUE rb_str_jaro_similar(VALUE self, VALUE strings)
 {
@@ -1518,7 +1528,7 @@ DEF_CONSTRUCTOR(JaroWinkler, JaroWinkler)
  * Jaro#pattern against <code>strings</code>, that is compute the
  * jaro metric with the strings. <code>strings</code> has to be
  * either a String or an Array of Strings. The returned <code>results</code>
- * are either a Float or an Array of Floats respectively.
+ * is either a Float or an Array of Floats respectively.
  */
 static VALUE rb_JaroWinkler_match(VALUE self, VALUE strings)
 {
@@ -1542,10 +1552,17 @@ static VALUE rb_str_jarowinkler_similar(VALUE self, VALUE strings)
     return rb_JaroWinkler_match(amatch, strings);
 }
 
-void Init_amatch()
+/*
+ * This is the namespace module that includes all other classes, modules, and
+ * constants.
+ */
+
+void Init_amatch_ext()
 {
     rb_require("amatch/version");
     rb_mAmatch = rb_define_module("Amatch");
+    /* This module can be mixed into ::String or its subclasses to mixin the similary methods directly. */
+    rb_mAmatchStringMethods = rb_define_module_under(rb_mAmatch, "StringMethods");
 
     /* Levenshtein */
     rb_cLevenshtein = rb_define_class_under(rb_mAmatch, "Levenshtein", rb_cObject);
@@ -1556,7 +1573,7 @@ void Init_amatch()
     rb_define_method(rb_cLevenshtein, "match", rb_Levenshtein_match, 1);
     rb_define_method(rb_cLevenshtein, "search", rb_Levenshtein_search, 1);
     rb_define_method(rb_cLevenshtein, "similar", rb_Levenshtein_similar, 1);
-    rb_define_method(rb_cString, "levenshtein_similar", rb_str_levenshtein_similar, 1);
+    rb_define_method(rb_mAmatchStringMethods, "levenshtein_similar", rb_str_levenshtein_similar, 1);
 
     /* Sellers */
     rb_cSellers = rb_define_class_under(rb_mAmatch, "Sellers", rb_cObject);
@@ -1583,9 +1600,9 @@ void Init_amatch()
     rb_define_method(rb_cHamming, "pattern=", rb_General_pattern_set, 1);
     rb_define_method(rb_cHamming, "match", rb_Hamming_match, 1);
     rb_define_method(rb_cHamming, "similar", rb_Hamming_similar, 1);
-    rb_define_method(rb_cString, "hamming_similar", rb_str_hamming_similar, 1);
+    rb_define_method(rb_mAmatchStringMethods, "hamming_similar", rb_str_hamming_similar, 1);
 
-    /* Pair Distance Metric */
+    /* Pair Distance Metric / Dice Coefficient */
     rb_cPairDistance = rb_define_class_under(rb_mAmatch, "PairDistance", rb_cObject);
     rb_define_alloc_func(rb_cPairDistance, rb_PairDistance_s_allocate);
     rb_define_method(rb_cPairDistance, "initialize", rb_PairDistance_initialize, 1);
@@ -1593,7 +1610,7 @@ void Init_amatch()
     rb_define_method(rb_cPairDistance, "pattern=", rb_PairDistance_pattern_set, 1);
     rb_define_method(rb_cPairDistance, "match", rb_PairDistance_match, -1);
     rb_define_alias(rb_cPairDistance, "similar", "match");
-    rb_define_method(rb_cString, "pair_distance_similar", rb_str_pair_distance_similar, 1);
+    rb_define_method(rb_mAmatchStringMethods, "pair_distance_similar", rb_str_pair_distance_similar, -1);
 
     /* Longest Common Subsequence */
     rb_cLongestSubsequence = rb_define_class_under(rb_mAmatch, "LongestSubsequence", rb_cObject);
@@ -1603,7 +1620,7 @@ void Init_amatch()
     rb_define_method(rb_cLongestSubsequence, "pattern=", rb_General_pattern_set, 1);
     rb_define_method(rb_cLongestSubsequence, "match", rb_LongestSubsequence_match, 1);
     rb_define_method(rb_cLongestSubsequence, "similar", rb_LongestSubsequence_similar, 1);
-    rb_define_method(rb_cString, "longest_subsequence_similar", rb_str_longest_subsequence_similar, 1);
+    rb_define_method(rb_mAmatchStringMethods, "longest_subsequence_similar", rb_str_longest_subsequence_similar, 1);
 
     /* Longest Common Substring */
     rb_cLongestSubstring = rb_define_class_under(rb_mAmatch, "LongestSubstring", rb_cObject);
@@ -1613,7 +1630,7 @@ void Init_amatch()
     rb_define_method(rb_cLongestSubstring, "pattern=", rb_General_pattern_set, 1);
     rb_define_method(rb_cLongestSubstring, "match", rb_LongestSubstring_match, 1);
     rb_define_method(rb_cLongestSubstring, "similar", rb_LongestSubstring_similar, 1);
-    rb_define_method(rb_cString, "longest_substring_similar", rb_str_longest_substring_similar, 1);
+    rb_define_method(rb_mAmatchStringMethods, "longest_substring_similar", rb_str_longest_substring_similar, 1);
 
     /* Jaro */
     rb_cJaro = rb_define_class_under(rb_mAmatch, "Jaro", rb_cObject);
@@ -1625,7 +1642,7 @@ void Init_amatch()
     rb_define_method(rb_cJaro, "ignore_case=", rb_Jaro_ignore_case_set, 1);
     rb_define_method(rb_cJaro, "match", rb_Jaro_match, 1);
     rb_define_alias(rb_cJaro, "similar", "match");
-    rb_define_method(rb_cString, "jaro_similar", rb_str_jaro_similar, 1);
+    rb_define_method(rb_mAmatchStringMethods, "jaro_similar", rb_str_jaro_similar, 1);
 
     /* Jaro-Winkler */
     rb_cJaroWinkler = rb_define_class_under(rb_mAmatch, "JaroWinkler", rb_cObject);
@@ -1639,7 +1656,7 @@ void Init_amatch()
     rb_define_method(rb_cJaroWinkler, "scaling_factor=", rb_JaroWinkler_scaling_factor_set, 1);
     rb_define_method(rb_cJaroWinkler, "match", rb_JaroWinkler_match, 1);
     rb_define_alias(rb_cJaroWinkler, "similar", "match");
-    rb_define_method(rb_cString, "jarowinkler_similar", rb_str_jarowinkler_similar, 1);
+    rb_define_method(rb_mAmatchStringMethods, "jarowinkler_similar", rb_str_jarowinkler_similar, 1);
 
     id_split = rb_intern("split");
     id_to_f = rb_intern("to_f");

data/ext/extconf.rb

@@ -3,4 +3,4 @@ require 'rbconfig'
 if CONFIG['CC'] == 'gcc'
   CONFIG['CC'] = 'gcc -Wall '
 end
-create_makefile 'amatch' 
+create_makefile 'amatch_ext' 

data/ext/pair.c

@@ -7,7 +7,7 @@ static int predict_length(VALUE tokens)
     int i, l, result;
     for (i = 0, result = 0; i < RARRAY_LEN(tokens); i++) {
         VALUE t = rb_ary_entry(tokens, i);
-        l = RSTRING_LEN(t) - 1;
+        l = (int) RSTRING_LEN(t) - 1;
         if (l > 0) result += l;
     }
     return result;

data/lib/amatch.rb

@@ -0,0 +1,3 @@
+module Amatch
+end
+require 'amatch/rude'

data/lib/amatch/polite.rb

@@ -0,0 +1,7 @@
+module Amatch
+end
+require 'amatch_ext'
+module Amatch
+  # alias
+  DiceCoefficient = PairDistance
+end

data/lib/amatch/rude.rb

@@ -0,0 +1,7 @@
+require 'amatch_ext'
+module Amatch
+  DiceCoefficient = PairDistance
+end
+class ::String
+  include ::Amatch::StringMethods
+end

data/lib/amatch/version.rb

@@ -1,6 +1,6 @@
 module Amatch
   # Amatch version
-  VERSION         = '0.2.8'
+  VERSION         = '0.2.9'
   VERSION_ARRAY   = VERSION.split(/\./).map { |x| x.to_i } # :nodoc:
   VERSION_MAJOR   = VERSION_ARRAY[0] # :nodoc:
   VERSION_MINOR   = VERSION_ARRAY[1] # :nodoc:

data/tests/test_jaro.rb

@@ -1,5 +1,5 @@
 require 'test/unit'
-require File.dirname(__FILE__) + "/../ext/amatch"
+require 'amatch'
 
 class TestJaro < Test::Unit::TestCase
   include Amatch

data/tests/test_levenshtein.rb

@@ -11,6 +11,10 @@ class TestLevenshtein < Test::Unit::TestCase
     @long     = Levenshtein.new('A' * 160)
   end
 
+  def test_version
+    assert_kind_of String, Amatch::VERSION
+  end
+
   def test_match
     assert_equal 4,     @simple.match('')
     assert_equal 0,     @simple.match('test')

data/tests/test_pair_distance.rb

@@ -15,6 +15,10 @@ class TestPairDistance < Test::Unit::TestCase
     @long     = PairDistance.new('A' * 160)
   end
 
+  def test_alternative_constant
+    assert_equal PairDistance, DiceCoefficient
+  end
+
   def test_empty
     assert_in_delta 1, @empty.match(''), D
     assert_in_delta 0, @empty.match('not empty'), D
@@ -55,6 +59,8 @@ class TestPairDistance < Test::Unit::TestCase
     assert_in_delta 0.6,        @single.match('test aaa bbb'), D
     assert_in_delta 0.6,        @single.match('bbb aaa test'), D
     assert_in_delta 0.8571428,  @single.pattern.pair_distance_similar('atest'), D
+    assert_in_delta 1.0,  @france.pattern.pair_distance_similar('of france, republic', /[, ]+/), D
+    assert_in_delta 0.9230769,  @france.pattern.pair_distance_similar('of france, republik', /[, ]+/), D
   end
 
   def test_csv

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: amatch
 version: !ruby/object:Gem::Version
-  version: 0.2.8
+  version: 0.2.9
   prerelease: 
 platform: ruby
 authors:
@@ -9,22 +9,22 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-09-25 00:00:00.000000000Z
+date: 2011-11-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: gem_hadar
-  requirement: &2156333160 !ruby/object:Gem::Requirement
+  requirement: &2152298700 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.1.0
+        version: 0.1.1
   type: :development
   prerelease: false
-  version_requirements: *2156333160
+  version_requirements: *2152298700
 - !ruby/object:Gem::Dependency
   name: test-unit
-  requirement: &2156332280 !ruby/object:Gem::Requirement
+  requirement: &2152312400 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,10 +32,10 @@ dependencies:
         version: '2.3'
   type: :development
   prerelease: false
-  version_requirements: *2156332280
+  version_requirements: *2152312400
 - !ruby/object:Gem::Dependency
   name: tins
-  requirement: &2156331380 !ruby/object:Gem::Requirement
+  requirement: &2152310440 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -43,7 +43,7 @@ dependencies:
         version: '0.3'
   type: :runtime
   prerelease: false
-  version_requirements: *2156331380
+  version_requirements: *2152310440
 description: ! 'Amatch is a library for approximate string matching and searching
   in strings.
 
@@ -59,8 +59,11 @@ extensions:
 - ext/extconf.rb
 extra_rdoc_files:
 - README.rdoc
+- lib/amatch/polite.rb
+- lib/amatch/rude.rb
 - lib/amatch/version.rb
-- ext/amatch.c
+- lib/amatch.rb
+- ext/amatch_ext.c
 - ext/pair.c
 files:
 - .gitignore
@@ -73,13 +76,16 @@ files:
 - VERSION
 - amatch.gemspec
 - bin/agrep.rb
-- ext/amatch.c
+- ext/amatch_ext.c
 - ext/common.h
 - ext/extconf.rb
 - ext/pair.c
 - ext/pair.h
 - install.rb
+- lib/amatch.rb
 - lib/amatch/.keep
+- lib/amatch/polite.rb
+- lib/amatch/rude.rb
 - lib/amatch/version.rb
 - tests/test_hamming.rb
 - tests/test_jaro.rb
@@ -119,11 +125,11 @@ signing_key:
 specification_version: 3
 summary: Approximate String Matching library
 test_files:
-- tests/test_sellers.rb
+- tests/test_hamming.rb
 - tests/test_jaro.rb
+- tests/test_jaro_winkler.rb
+- tests/test_levenshtein.rb
 - tests/test_longest_subsequence.rb
 - tests/test_longest_substring.rb
-- tests/test_hamming.rb
 - tests/test_pair_distance.rb
-- tests/test_levenshtein.rb
-- tests/test_jaro_winkler.rb
+- tests/test_sellers.rb