amatch 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4fc4761462d177bcebf7212934afe5658a103b8dd6b32083d32ab1ee98a93459
-  data.tar.gz: 9d73b4f9e4ab4033f3d9f72dd7c3b0bf37fdefff78008675a15abbd7f4960e77
+  metadata.gz: ee7dfaff2010838080964bb4ba77162407ecf382c3d179950b2ecde3233df3a1
+  data.tar.gz: c5e4f46463f7858fd681c8ec2179d0a6245499a73b1188285f40c21535be7bfc
 SHA512:
-  metadata.gz: a808291e86d7660209c4a4c34639c2c1f024a25e28b84ce09d1415b775ea7989c2dc489a69684506f737c7b3603eec4f260ec60aae8a967ccd56e8f0ad573922
-  data.tar.gz: 91e485ecdd534ab4678fedba873db8bb6f2612fc3f0a9fc002ca849e1e9c6bd42f0e57a6a76ddf674c3e0d34e56187f022f52b78f53719596cdaf9aa7531502e
+  metadata.gz: 457706eed2e4af628996d96afc4f0296fd713439fd0ebcb04d637649beef6d3a74da0955a5f0fe693bac1a142b3424b77cc59038966454ce022ce668a0c520a2
+  data.tar.gz: 88d63c103f527c18ff413f9810ad231ae81a218b8c1f824756d7568a963c2679c6ee28a293bebd68a715e08bfecbedb5da512da09a52ca2114a0cf6ebc902c0c

data/.envrc

@@ -0,0 +1 @@
+export OLLAMA_CHAT_TOOLS_TEST_RUNNER="bundle exec test-unit"

data/CHANGES.md

@@ -1,5 +1,29 @@
 # Changes
 
+## 2026-06-05 v0.7.0
+
+### Added
+- Improved `README.md` with a project roadmap, better structure, and technical
+  clarifications.
+- Documented the `Amatch::DiceCoefficient` alias for `PairDistance`.
+- Clarified that `PairDistance` utilizes multisets for frequency-sensitive
+  matching.
+- Added advanced usage examples for regex tokenization in `PairDistance#match`.
+- Added a `changelog` configuration block to the `Rakefile` targeting
+  `CHANGES.md` to automate release documentation.
+
+### Changed
+
+- Updated matcher structs to use `TypedData_Make_Struct` and
+  `TypedData_Get_Struct`, removing dependency on deprecated `Data_*` accessors.
+- Switched matcher allocation to `Data_Make_Struct` to ensure Ruby manages
+  memory immediately upon object creation and prevent buffer leaks.
+- Standardized the CI test runner to use `bundle exec rake clobber test`.
+- Updated CI configuration in `.all_images.yml` with hooks to remove `Gemfile.lock` to prevent conflicts between macOS and Alpine Linux.
+- Added `.envrc` to export `OLLAMA_CHAT_TOOLS_TEST_RUNNER`.
+- Updated the Ruby version used in CI from **4.0-rc-alpine** to **4.0-alpine**.
+- Updated `amatch.gemspec` configuration.
+
 ## 2025-12-19 v0.6.0
 
 - Moved the `debug` gem from regular dependencies to development dependencies

data/README.md

@@ -1,124 +1,181 @@
-# amatch - Approximate Matching Extension for Ruby
-
-## Description
-
-This is a collection of classes that can be used for Approximate
-matching, searching, and comparing of Strings. They implement algorithms
-that compute the Levenshtein edit distance, Sellers edit distance, the
-Hamming distance, the longest common subsequence length, the longest common
-substring length, the pair distance metric, the Jaro-Winkler metric.
-
-## Installation
-
-To install this extension as a gem type
-
- # gem install amatch
-
-into the shell.
-
-## Download
-
-The homepage of this library is located at
-
-* https://github.com/flori/amatch
-
-## Examples
-
-    require 'amatch'
-    # => true
-    include Amatch
-    # => Object
-    
-    m = Sellers.new("pattern")
-    # => #<Amatch::Sellers:0x40366324>
-    m.match("pattren")
-    # => 2.0
-    m.substitution = m.insertion = 3
-    # => 3
-    m.match("pattren")
-    # => 4.0
-    m.reset_weights
-    # => #<Amatch::Sellers:0x40366324>
-    m.match(["pattren","parent"])
-    # => [2.0, 4.0]
-    m.search("abcpattrendef")
-    # => 2.0
-    
-    m = Levenshtein.new("pattern")
-    # => #<Amatch::Levenshtein:0x4035919c>
-    m.match("pattren")
-    # => 2
-    m.search("abcpattrendef")
-    # => 2
-    "pattern language".levenshtein_similar("language of patterns")
-    # => 0.2
-    
-    m = Amatch::DamerauLevenshtein.new("pattern")
-    # => #<Amatch::DamerauLevenshtein:0x007fc3483dd278>
-    m.match("pattren")
-    # => 1
-    "pattern language".damerau_levenshtein_similar("language of patterns")
-    # => 0.19999999999999996
-    
-    m = Hamming.new("pattern")
-    # => #<Amatch::Hamming:0x40350858>
-    m.match("pattren")
-    # => 2
-    "pattern language".hamming_similar("language of patterns")
-    # => 0.1
-    
-    m = PairDistance.new("pattern")
-    # => #<Amatch::PairDistance:0x40349be8>
-    m.match("pattr en")
-    # => 0.545454545454545
-    m.match("pattr en", nil)
-    # => 0.461538461538462
-    m.match("pattr en", /t+/)
-    # => 0.285714285714286
-    "pattern language".pair_distance_similar("language of patterns")
-    # => 0.928571428571429
-    
-    m = LongestSubsequence.new("pattern")
-    # => #<Amatch::LongestSubsequence:0x4033e900>
-    m.match("pattren")
-    # => 6
-    "pattern language".longest_subsequence_similar("language of patterns")
-    # => 0.4
-    
-    m = LongestSubstring.new("pattern")
-    # => #<Amatch::LongestSubstring:0x403378d0>
-    m.match("pattren")
-    # => 4
-    "pattern language".longest_substring_similar("language of patterns")
-    # => 0.4
-   
-    m = Jaro.new("pattern")
-    # => #<Amatch::Jaro:0x363b70>
-    m.match("paTTren")
-    # => 0.952380952380952
-    m.ignore_case = false
-    m.match("paTTren")
-    # => 0.742857142857143
-    "pattern language".jaro_similar("language of patterns")
-    # => 0.672222222222222
-   
-    m = JaroWinkler.new("pattern")
-    # #<Amatch::JaroWinkler:0x3530b8>
-    m.match("paTTren")
-    # => 0.971428571712403
-    m.ignore_case = false
-    m.match("paTTren")
-    # => 0.79428571505206
-    m.scaling_factor = 0.05
-    m.match("pattren")
-    # => 0.961904762046678
-    "pattern language".jarowinkler_similar("language of patterns")
-    # => 0.672222222222222
-
-## Author
-
-Florian Frank mailto:flori@ping.de
-
-## License
+# amatch - Approximate Matching Extension for Ruby 📏
+
+## Description 📝
+
+`amatch` is a high-performance collection of classes used for approximate
+matching, searching, and comparing strings. It provides an efficient Ruby
+interface to several industry-standard algorithms for calculating edit distance
+and string similarity.
+
+## Supported Algorithms 🧩
+
+The library implements a wide array of metrics to suit different matching needs:
+
+*   **Levenshtein Distance**: The classic "edit distance" (insertions,
+    deletions, substitutions).
+*   **Sellers Algorithm**: A variation of Levenshtein optimized for searching a
+    pattern within a longer text.
+*   **Damerau-Levenshtein**: Similar to Levenshtein but considers
+    transpositions of two adjacent characters as a single edit.
+*   **Hamming Distance**: Measures the number of positions at which
+    corresponding symbols are different (only for strings of equal length).
+*   **Jaro-Winkler**: A metric geared towards short strings like names, giving
+    more weight to prefix matches.
+*   **Pair Distance**: A flexible distance metric based on character pairs
+    (also available as `Amatch::DiceCoefficient`). Unlike set-based measures,
+    this implementation uses multisets, meaning it is sensitive to the frequency
+    of repeated character pairs.
+*   **Longest Common Subsequence/Substring**: Finds the longest shared
+    sequences between two strings.
+
+## Installation 📦
+
+You can install the extension as a gem:
+
+```shell
+gem install amatch
+```
+
+Alternatively, if you prefer manual installation:
+
+```shell
+ruby install.rb
+# or
+rake install
+```
+
+## Usage 🛠️
+
+### Basic Setup
+
+To get started, simply require the library and include the `Amatch` module to
+add similarity methods directly to the `String` class.
+
+```ruby
+require 'amatch'
+include Amatch
+```
+
+### Edit Distance Algorithms 📉
+
+These algorithms return the "cost" to transform one string into another. Lower
+values indicate higher similarity.
+
+#### Levenshtein & Damerau-Levenshtein
+
+```ruby
+# Standard Levenshtein
+m = Levenshtein.new("pattern")
+m.match("pattren") # => 2
+"pattern language".levenshtein_similar("language of patterns") # => 0.2
+
+# Damerau-Levenshtein (handles transpositions)
+m = Amatch::DamerauLevenshtein.new("pattern")
+m.match("pattren") # => 1
+"pattern language".damerau_levenshtein_similar("language of patterns") # => 0.2
+```
+
+#### Sellers (Pattern Searching)
+
+Sellers is particularly useful for finding the best match of a pattern within a
+larger body of text.
+
+```ruby
+m = Sellers.new("pattern")
+m.match("pattren") # => 2.0
+
+# You can customize weights for different edit types
+m.substitution = m.insertion = 3
+m.match("pattren") # => 4.0
+
+m.reset_weights
+m.search("abcpattrendef") # => 2.0
+```
+
+#### Hamming Distance
+
+Used primarily for strings of equal length to count substitutions.
+
+```ruby
+m = Hamming.new("pattern")
+m.match("pattren") # => 2
+"pattern language".hamming_similar("language of patterns") # => 0.1
+```
+
+### Similarity Metrics 📈
+
+These algorithms typically return a score between `0.0` and `1.0`, where `1.0`
+is a perfect match.
+
+#### Jaro-Winkler
+
+Highly effective for record linkage and matching names.
+
+```ruby
+m = JaroWinkler.new("pattern")
+m.match("paTTren") # => 0.9714...
+m.ignore_case = false
+m.match("paTTren") # => 0.7942...
+
+# Custom scaling factor for prefix bonus
+m.scaling_factor = 0.05
+m.match("pattren") # => 0.9619...
+
+"pattern language".jarowinkler_similar("language of patterns") # => 0.6722...
+```
+
+#### Jaro
+
+The base metric for the Winkler variation.
+
+```ruby
+m = Jaro.new("pattern")
+m.match("paTTren") # => 0.9523...
+"pattern language".jaro_similar("language of patterns") # => 0.6722...
+```
+
+#### Other Metrics (Pair Distance, LCS, Longest Substring)
+
+```ruby
+# Pair Distance
+# Note: This implementation uses multisets, meaning it considers character 
+# frequencies rather than just unique pairs.
+m = PairDistance.new("pattern")
+m.match("pattr en") # => 0.5454...
+
+# Pro Tip: Pass a regex as the second argument to match based on tokens
+#  (e.g., words) rather than individual characters. This is particularly
+# useful for natural language.
+m.match("language of patterns", /\s+/)
+"pattern language".pair_distance_similar("language of patterns", /\s+/) # => 0.9285...
+
+# Longest Common Subsequence
+m = LongestSubsequence.new("pattern")
+m.match("pattren") # => 6
+"pattern language".longest_subsequence_similar("language of patterns") # => 0.4
+
+# Longest Common Substring
+m = LongestSubstring.new("pattern")
+m.match("pattren") # => 4
+"pattern language".longest_substring_similar("language of patterns") # => 0.4
+```
+
+## Performance ⚡
+
+`amatch` is implemented as a C extension to ensure maximum throughput when
+processing large datasets or complex string comparisons.
+
+![performance](http://cs304915.userapi.com/v304915401/5c97/BAzazF5E4Fo.jpg)
+
+## Download 📥
+
+The homepage of this library is located at:
+* [https://github.com/flori/amatch](https://github.com/flori/amatch)
+
+## Author 👨‍💻
+
+[Florian Frank](mailto:flori@ping.de)
+
+## License 📄
 
 Apache License, Version 2.0 – See the COPYING file in the source archive.

data/Rakefile

@@ -23,6 +23,10 @@ GemHadar do
   readme      'README.md'
   require_paths %w[lib ext]
 
+  changelog do
+    filename 'CHANGES.md'
+  end
+
   required_ruby_version '>=2.4'
 
   dependency             'tins',      '~>1'

data/ext/amatch_ext.c

@@ -10,23 +10,32 @@ static VALUE rb_mAmatch, rb_mAmatchStringMethods, rb_cLevenshtein,
 
 static ID id_split, id_to_f;
 
-#define GET_STRUCT(klass)                 \
-    klass *amatch;                        \
-    Data_Get_Struct(self, klass, amatch);
+#define GET_STRUCT(klass)                                           \
+    klass *amatch;                                                  \
+    TypedData_Get_Struct(self, klass, &rb_##klass##_data_type,      \
+        amatch);
 
-#define DEF_ALLOCATOR(type)                                             \
-static type *type##_allocate()                                          \
-{                                                                       \
-    type *obj = ALLOC(type);                                            \
-    MEMZERO(obj, type, 1);                                              \
-    return obj;                                                         \
-}
+#define DEF_DATA_TYPE(type)                                         \
+static size_t rb_##type##_memsize(const void *ptr)                  \
+{                                                                   \
+    return ptr ? sizeof(type) : 0;                                  \
+}                                                                   \
+                                                                    \
+static const rb_data_type_t rb_##type##_data_type = {               \
+    "Amatch::" #type,                                               \
+    {NULL, rb_##type##_free, rb_##type##_memsize,},                 \
+    NULL, NULL, 0,                                                  \
+};
+
+#define MAKE_STRUCT(klass, type, amatch)                            \
+    TypedData_Make_Struct(klass, type, &rb_##type##_data_type,      \
+        amatch)
 
 #define DEF_CONSTRUCTOR(klass, type)                                    \
 static VALUE rb_##klass##_s_allocate(VALUE klass2)                      \
 {                                                                       \
-    type *amatch = type##_allocate();                                   \
-    return Data_Wrap_Struct(klass2, NULL, rb_##klass##_free, amatch);   \
+    type *amatch;                                                       \
+    return MAKE_STRUCT(klass2, type, amatch);                           \
 }                                                                       \
 VALUE rb_##klass##_new(VALUE klass2, VALUE pattern)                     \
 {                                                                       \
@@ -35,9 +44,10 @@ VALUE rb_##klass##_new(VALUE klass2, VALUE pattern)                     \
     return obj;                                                         \
 }
 
-#define DEF_RB_FREE(klass, type)                            \
-static void rb_##klass##_free(type *amatch)                 \
+#define DEF_RB_FREE(type)                                   \
+static void rb_##type##_free(void *ptr)                     \
 {                                                           \
+    type *amatch = ptr;                                     \
     MEMZERO(amatch->pattern, char, amatch->pattern_len);    \
     xfree(amatch->pattern);                                 \
     MEMZERO(amatch, type, 1);                               \
@@ -156,7 +166,8 @@ typedef struct GeneralStruct {
     int         pattern_len;
 } General;
 
-DEF_ALLOCATOR(General)
+DEF_RB_FREE(General)
+DEF_DATA_TYPE(General)
 DEF_PATTERN_ACCESSOR(General)
 DEF_ITERATE_STRINGS(General)
 
@@ -168,7 +179,8 @@ typedef struct SellersStruct {
     double      insertion;
 } Sellers;
 
-DEF_ALLOCATOR(Sellers)
+DEF_RB_FREE(Sellers)
+DEF_DATA_TYPE(Sellers)
 DEF_PATTERN_ACCESSOR(Sellers)
 DEF_ITERATE_STRINGS(Sellers)
 
@@ -185,7 +197,8 @@ typedef struct PairDistanceStruct {
     PairArray   *pattern_pair_array;
 } PairDistance;
 
-DEF_ALLOCATOR(PairDistance)
+DEF_RB_FREE(PairDistance)
+DEF_DATA_TYPE(PairDistance)
 DEF_PATTERN_ACCESSOR(PairDistance)
 
 typedef struct JaroStruct {
@@ -194,7 +207,8 @@ typedef struct JaroStruct {
     int   ignore_case;
 } Jaro;
 
-DEF_ALLOCATOR(Jaro)
+DEF_RB_FREE(Jaro)
+DEF_DATA_TYPE(Jaro)
 DEF_PATTERN_ACCESSOR(Jaro)
 DEF_ITERATE_STRINGS(Jaro)
 
@@ -205,7 +219,8 @@ typedef struct JaroWinklerStruct {
     double scaling_factor;
 } JaroWinkler;
 
-DEF_ALLOCATOR(JaroWinkler)
+DEF_RB_FREE(JaroWinkler)
+DEF_DATA_TYPE(JaroWinkler)
 DEF_PATTERN_ACCESSOR(JaroWinkler)
 DEF_ITERATE_STRINGS(JaroWinkler)
 
@@ -908,7 +923,6 @@ static VALUE JaroWinkler_match(JaroWinkler *amatch, VALUE string)
   * strings that differ a lot.
   */
 
-DEF_RB_FREE(Levenshtein, General)
 
 /*
  * call-seq: new(pattern)
@@ -1001,7 +1015,6 @@ static VALUE rb_Levenshtein_search(VALUE self, VALUE strings)
  * distances than strings that differ a lot.
  */
 
-DEF_RB_FREE(DamerauLevenshtein, General)
 
 /*
  * call-seq: new(pattern)
@@ -1089,7 +1102,6 @@ static VALUE rb_DamerauLevenshtein_search(VALUE self, VALUE strings)
  * distance.
  */
 
-DEF_RB_FREE(Sellers, Sellers)
 
 /*
  * Document-method: substitution
@@ -1271,7 +1283,6 @@ static VALUE rb_Sellers_search(VALUE self, VALUE strings)
  * http://citeseer.lcs.mit.edu/gravano01using.html in "Using q-grams in a DBMS
  * for Approximate String Processing."
  */
-DEF_RB_FREE(PairDistance, PairDistance)
 
 /*
  * call-seq: new(pattern)
@@ -1375,7 +1386,6 @@ static VALUE rb_str_pair_distance_similar(int argc, VALUE *argv, VALUE self)
  *  counted as different characters.
  */
 
-DEF_RB_FREE(Hamming, General)
 
 /*
  * call-seq: new(pattern)
@@ -1451,7 +1461,6 @@ static VALUE rb_str_hamming_similar(VALUE self, VALUE strings)
  *  between "test" and "east" is "e", "s", "t" and the length of the
  *  sequence is 3.
  */
-DEF_RB_FREE(LongestSubsequence, General)
 
 /*
  * call-seq: new(pattern)
@@ -1528,7 +1537,6 @@ static VALUE rb_str_longest_subsequence_similar(VALUE self, VALUE strings)
  * substring length is 4.
  */
 
-DEF_RB_FREE(LongestSubstring, General)
 
 /*
  * call-seq: new(pattern)
@@ -1599,7 +1607,6 @@ static VALUE rb_str_longest_substring_similar(VALUE self, VALUE strings)
  * The Jaro metric computes the similarity between 0 (no match)
  * and 1 (exact match) by looking for matching and transposed characters.
  */
-DEF_RB_FREE(Jaro, Jaro)
 
 /*
  * Document-method: ignore_case
@@ -1676,7 +1683,6 @@ static VALUE rb_str_jaro_similar(VALUE self, VALUE strings)
  * It is a variant of the Jaro metric, with additional weighting towards
  * common prefixes.
  */
-DEF_RB_FREE(JaroWinkler, JaroWinkler)
 
 /*
  * Document-method: ignore_case

data/lib/amatch/version.rb

@@ -1,6 +1,6 @@
 module Amatch
   # Amatch version
-  VERSION         = '0.6.0'
+  VERSION         = '0.7.0'
   VERSION_ARRAY   = VERSION.split('.').map(&:to_i) # :nodoc:
   VERSION_MAJOR   = VERSION_ARRAY[0] # :nodoc:
   VERSION_MINOR   = VERSION_ARRAY[1] # :nodoc:

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: amatch
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Florian Frank
@@ -13,16 +13,16 @@ dependencies:
   name: gem_hadar
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '2.10'
+        version: 2.17.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '2.10'
+        version: 2.17.1
 - !ruby/object:Gem::Dependency
   name: debug
   requirement: !ruby/object:Gem::Requirement
@@ -126,6 +126,7 @@ extra_rdoc_files:
 - lib/amatch/rude.rb
 - lib/amatch/version.rb
 files:
+- ".envrc"
 - ".utilsrc"
 - CHANGES.md
 - COPYING
@@ -180,7 +181,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.2
+rubygems_version: 4.0.10
 specification_version: 4
 summary: Approximate String Matching library
 test_files: