multi_string_replace 2.0.2 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b380199fa7395925c1c6e6b2c6db5d67f6f5588d81e1af62ecff883a8866cfcd
-  data.tar.gz: 12f94ee8b8f68535b9eacba3db28bab0a008de85148269cf6cee64a9ab8beabc
+  metadata.gz: 92a92ffb1350b891f31634d8b7c3ca4d0a6e1582c91b35f548c61f819cbf5ffe
+  data.tar.gz: 86c5acf5d85393669c05054ce79a1fe37a6fdf98d2e62b17803b94cf46670c1d
 SHA512:
-  metadata.gz: c8248181f107f7bf4d28859374255d4802728795ff7b0e7308f3dcf68a326d133fd45e1041fe01ea043d5934e38e5fca83b67465f2cdae8c7c79b280a8fdffb8
-  data.tar.gz: eedeec0d330d5e82e48205424f09e2b9fe165dcc0791e8715abce83dcd0519bbcc535c72986b6ee989b9878d3809beaaa25ef7560d97f24efcc7d9f89893ed49
+  metadata.gz: 465229a147b4287e725669b7ca10bca5e3ea613cda6d22e69f01ba8f9b9808b1018dd0344caeffc941aee2ea6220392d8d959527b2266c8ab84d8ffdacd0ebc4
+  data.tar.gz: 2148c1d0386ef4efd0ae13dd90466af4b7262fd8d01200ea70ba74f152329abb20655db826a98d12a8604651eb9cd8406ca9498f26681a7b0e7f597d17899a79

data/.github/workflows/ci.yml

@@ -2,35 +2,27 @@ name: CI
 
 on:
   push:
+    branches: [ master ]
   pull_request:
-  workflow_dispatch:
-#  schedule:
-#    - cron: '42 5 * * *'
+    branches: [ master ]
 
 jobs:
   test:
+    runs-on: ubuntu-latest
     strategy:
       fail-fast: false
       matrix:
-        ruby: [ '3.0' ]
-
-    runs-on: ubuntu-latest
-    name: Ruby ${{matrix.ruby}}
-    container: ruby:${{matrix.ruby}}
-
+        ruby: [ '3.0', '3.1', '3.2', '3.3', '3.4' ]
     steps:
-    - uses: actions/checkout@v3
-
-    - name: Show ruby Version
-      run: |
-        ruby -v
-
-    - name: Install Modules
-      run: ./bin/setup
-
-    - name: Compile
-      run: rake compile
-
-    - name: Run tests
-      run: rake spec
+      - uses: actions/checkout@v4
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+          bundler-cache: true
+      - name: Install dependencies
+        run: bundle install --jobs 4 --retry 3
+      - name: Compile native extension
+        run: rake compile
+      - name: Run specs
+        run: rake spec
 

data/CHANGELOG.md

@@ -0,0 +1,29 @@
+# 2.0.2 (August 10, 2023)
+# 2.0.2 (August 10, 2023)
+
+# 3.0.0 (September 11, 2025)
+
+## Features
+
+- New `MultiStringReplace::Automaton` API to compile patterns once and reuse for faster repeated match/replace.
+
+## Performance
+
+- Faster replace path: cached Ruby method IDs, fewer API calls, preallocated buffers, and deferred string allocation for no-match fast path.
+- Optimized trie setup/clear and memory copies.
+
+## Stability and build
+
+- Fixed Bundler conflicts on Ruby 3.4+; Rakefile avoids dual-Bundler loading.
+- Added GC marking to prevent crashes with the new Automaton.
+- Safer behavior when replacement is missing; falls back to original substring.
+
+## Tooling
+
+- Benchmark script now supports `-f/--file`, `-n/--iters`, and `-A/--automaton` flags.
+- Added GitHub Actions CI across Ruby 3.0–3.4.
+
+## Bug fixes:
+
+  - Prevent segfault with some binary characters. [#10](https://github.com/jedld/multi_string_replace/pull/10)
+  

data/Gemfile.lock

@@ -1,11 +1,12 @@
 PATH
   remote: .
   specs:
-    multi_string_replace (2.0.2)
+    multi_string_replace (3.0.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
+    benchmark (0.4.1)
     diff-lcs (1.3)
     rake (13.0.1)
     rake-compiler (1.0.5)
@@ -28,11 +29,11 @@ PLATFORMS
   ruby
 
 DEPENDENCIES
-  bundler (~> 2.3.26)
+  benchmark
   multi_string_replace!
   rake
   rake-compiler
   rspec (~> 3.0)
 
 BUNDLED WITH
-   2.3.26
+   2.6.9

data/README.md

@@ -58,6 +58,18 @@ Also adds a mreplace method to String which does the same thing:
 "The quick brown fox jumps over the lazy dog brown".mreplace({'brown' => 'black', 'fox' => ->(_, _) { "cat" }})
 ```
 
+### Reuse a compiled automaton (faster for repeated calls)
+
+When running many matches/replacements with the same set of keys, build the automaton once and reuse it:
+
+```ruby
+ac = MultiStringReplace::Automaton.new(['brown', 'fox'])
+ac.match("The quick brown fox")
+ac.replace("The quick brown fox", { 'brown' => 'black', 'fox' => 'wolf' })
+```
+
+This avoids rebuilding the trie/failure links on every call and can improve throughput significantly for repeated workloads.
+
 ## Performance
 
 Performing token replacement on a 200K text file repeated 100 times
@@ -69,7 +81,42 @@ MultiStringReplace   0.196823   0.007979   0.204802 (  0.207219)
 mreplace             0.200593   0.004031   0.204624 (  0.205379)
 ```
 
-Benchmark sources can be found here: <https://github.com/jedld/multi_word_replace/blob/master/bin/benchmark.rb>
+Benchmark source: <https://github.com/jedld/multi_string_replace/blob/master/bin/benchmark.rb>
+
+### Run the benchmark locally
+
+1) Install dependencies
+
+```bash
+bundle install
+```
+
+2) Compile the native extension (recommended for accurate numbers)
+
+```bash
+bundle exec rake compile
+```
+
+3) Run the benchmark script
+
+```bash
+bundle exec ruby bin/benchmark.rb
+```
+
+Notes:
+- The script reads the sample text from `spec/fixtures/test.txt` and will write results to `replaced.txt` and `replaced2.txt` in the repo root.
+- To change the number of iterations or the input text, edit `bin/benchmark.rb` (look for the `100.times` loop and the `spec/fixtures/test.txt` path).
+- For repeated runs with the same keys, consider updating the benchmark to use `MultiStringReplace::Automaton` to showcase the speedup for batched workloads.
+
+Advanced benchmark flags:
+
+```bash
+# choose input and iterations
+bundle exec ruby bin/benchmark.rb -f spec/fixtures/test.txt -n 200
+
+# enable Automaton (reuse compiled trie)
+bundle exec ruby bin/benchmark.rb -A
+```
 
 ## Development
 

data/Rakefile

@@ -1,4 +1,7 @@
-require "bundler/gem_tasks"
+# Load Bundler gem tasks only when needed to avoid conflicts between system Bundler and gem-installed Bundler
+if (ARGV & %w[build release install release:guard_clean release:rubygem_push]).any?
+  require "bundler/gem_tasks"
+end
 require "rspec/core/rake_task"
 require "rake/extensiontask"
 

data/bin/benchmark.rb

@@ -1,6 +1,7 @@
 require "bundler/setup"
 require 'multi_string_replace'
 require 'benchmark'
+require 'optparse'
 
 class String
   def mgsub(key_value_pairs=[].freeze)
@@ -12,7 +13,14 @@ Regexp.union(*regexp_fragments)) do |match|
   end
 end
 
-body = File.read(File.join('spec', 'fixtures', 'test.txt'))
+options = { file: File.join('spec', 'fixtures', 'test.txt'), iters: 100, use_automaton: false }
+OptionParser.new do |opts|
+  opts.on('-f', '--file PATH', 'Input file path') { |v| options[:file] = v }
+  opts.on('-n', '--iters N', Integer, 'Iterations') { |v| options[:iters] = v }
+  opts.on('-A', '--automaton', 'Use Automaton for Msr run') { options[:use_automaton] = true }
+end.parse!(ARGV)
+
+body = File.read(options[:file])
 
 replace = {
   'Lorem' => 'XXXX',
@@ -33,7 +41,12 @@ File.write('replaced.txt', body.gsub(/(#{replace.keys.join('|')})/, replace))
 File.write('replaced2.txt', MultiStringReplace.replace(body, replace))
 
 Benchmark.bmbm do |x|
-  x.report "multi gsub" do 100.times { body.mgsub(replace.map { |k, v| [/#{k}/, v] } ) } end
-  x.report "MultiStringReplace" do 100.times { MultiStringReplace.replace(body, replace) } end
-  x.report "mreplace" do 100.times { body.mreplace(replace) } end
+  x.report "multi gsub" do options[:iters].times { body.mgsub(replace.map { |k, v| [/#{k}/, v] } ) } end
+  if options[:use_automaton]
+    ac = MultiStringReplace::Automaton.new(replace.keys)
+    x.report "MultiStringReplace (Automaton)" do options[:iters].times { ac.replace(body, replace) } end
+  else
+    x.report "MultiStringReplace" do options[:iters].times { MultiStringReplace.replace(body, replace) } end
+  end
+  x.report "mreplace" do options[:iters].times { body.mreplace(replace) } end
 end

data/ext/multi_string_replace/ahocorasick.c

@@ -49,7 +49,9 @@ int aho_add_match_text(struct ahocorasick * restrict aho, const char* text, unsi
 
     a_text->id = aho->accumulate_text_id++;
 
-    memcpy(a_text->text, text, len + 1);
+    // Copy exactly len bytes and add terminator once
+    memcpy(a_text->text, text, len);
+    a_text->text[len] = '\0';
 
     a_text->len = len;
     a_text->prev = NULL;
@@ -113,13 +115,18 @@ bool aho_del_match_text(struct ahocorasick * restrict aho, const int id)
 
 void aho_clear_match_text(struct ahocorasick * restrict aho)
 {
-    for(int i = 0; i < aho->accumulate_text_id; i++)
-    {
-        aho_del_match_text(aho, i);
+    struct aho_text_t* iter = aho->text_list_head;
+    while (iter) {
+        struct aho_text_t* nxt = iter->next;
+        free(iter->text);
+        free(iter);
+        iter = nxt;
     }
-
-    // reset id
+    // reset
     aho->accumulate_text_id = 0;
+    aho->text_list_head = NULL;
+    aho->text_list_tail = NULL;
+    aho->text_list_len = 0;
 }
 
 
@@ -148,7 +155,7 @@ void aho_clear_trie(struct ahocorasick * restrict aho)
 
 unsigned int aho_findtext(struct ahocorasick * restrict aho, const char* data, unsigned long long data_len)
 {
-    int i = 0;
+    unsigned long long i = 0;
     int match_count = 0;
     struct aho_trie_node* travasal_node = NULL;
 
@@ -168,11 +175,7 @@ unsigned int aho_findtext(struct ahocorasick * restrict aho, const char* data, u
         match.id = result->id;
         match.len = result->len;
 
-        match.pos = i - result->len + 1;
-        if (result->len == 1)
-        {
-            match.pos = i;
-        }
+    match.pos = i - result->len + 1;
 
         match_count++;
         if (aho->callback_match)
@@ -187,18 +190,16 @@ unsigned int aho_findtext(struct ahocorasick * restrict aho, const char* data, u
 VALUE aho_replace_text(struct ahocorasick * restrict aho, const char* data,
     unsigned long long data_len, char *values[], long value_sizes[], VALUE ruby_values[])
 {
-    int i = 0;
-    int match_count = 0;
+    unsigned long long i = 0;
     struct aho_trie_node* travasal_node = NULL;
 
     travasal_node = &(aho->trie.root);
-    VALUE main_result = rb_str_new("", 0);
-
-    long last_concat_pos = 0;
+    // Defer allocation until first match; handle no-match fast path
+    VALUE main_result = Qnil;
+    unsigned long long last_concat_pos = 0;
 
     for (i = 0; i < data_len; i++)
     {
-        struct aho_match_t match;
         struct aho_text_t* result;
 
         result = aho_find_trie_node(&travasal_node, data[i]);
@@ -207,43 +208,58 @@ VALUE aho_replace_text(struct ahocorasick * restrict aho, const char* data,
             continue;
         }
 
-        long pos = i - result->len + 1;
-        if (result->len == 1)
-        {
-            pos = i;
-        }
+    const int rlen = result->len;
+    unsigned long long pos = i - rlen + 1;
 
-        // concatenate from last_concat_pos
-        if (pos > last_concat_pos) {
+        // On first match, allocate result and copy prefix if any
+        if (NIL_P(main_result)) {
+            main_result = rb_str_buf_new((long)data_len);
+            if (pos > 0) rb_str_cat(main_result, &data[0], pos);
+        } else if (pos > last_concat_pos) {
             rb_str_cat(main_result, &data[last_concat_pos], pos - last_concat_pos);
         }
         
         // concatenate replace
-        if (values[result->id] == NULL) {
-            VALUE proc_result = rb_funcall(ruby_values[result->id], rb_intern("call"), 2, LONG2NUM(pos), LONG2NUM(pos + result->len));
-            if (RB_TYPE_P(proc_result, T_NIL)) {
-                rb_str_cat(main_result, &data[pos], result->len);
+        const int rid = result->id;
+        if (values[rid] == NULL) {
+            // NULL value indicates either: (1) no replacement supplied, or (2) a proc to compute it
+            if (!NIL_P(ruby_values[rid])) {
+                VALUE proc_result = rb_funcall(ruby_values[rid], rb_intern("call"), 2, LONG2NUM((long)pos), LONG2NUM((long)(pos + rlen)));
+                if (RB_TYPE_P(proc_result, T_NIL)) {
+                    rb_str_cat(main_result, &data[pos], rlen);
+                    last_concat_pos = i + 1;
+                    continue;
+                } else if (RB_TYPE_P(proc_result, T_STRING)) {
+                    rb_str_cat(main_result, StringValuePtr(proc_result), RSTRING_LEN(proc_result));
+                    last_concat_pos = i + 1;
+                    continue;
+                } else {
+                    VALUE string_result = rb_funcall(proc_result, rb_intern("to_s"), 0);
+                    rb_str_cat(main_result, StringValuePtr(string_result), RSTRING_LEN(string_result));
+                    last_concat_pos = i + 1;
+                    continue;
+                }
+            } else {
+                // no replacement provided; keep original slice
+                rb_str_cat(main_result, &data[pos], rlen);
                 last_concat_pos = i + 1;
                 continue;
-            } else if (RB_TYPE_P(proc_result, T_STRING)) {
-                value_sizes[result->id] = RSTRING_LEN(proc_result);
-                values[result->id] = StringValuePtr(proc_result);
-            } else {
-                VALUE string_result = rb_funcall(proc_result, rb_intern("to_s"), 0);
-                value_sizes[result->id] = RSTRING_LEN(string_result);
-                values[result->id] = StringValuePtr(string_result);
             }
         }
 
-        rb_str_cat(main_result, values[result->id], value_sizes[result->id]); 
+        rb_str_cat(main_result, values[rid], value_sizes[rid]); 
         last_concat_pos = i + 1;
     }
 
-    if (last_concat_pos < data_len) {
-        rb_str_cat(main_result, &data[last_concat_pos], data_len - last_concat_pos);
+    if (NIL_P(main_result)) {
+        // No matches; return a copy of input (preserves previous API behavior of returning a new String)
+        return rb_str_new(data, (long)data_len);
+    } else {
+        if (last_concat_pos < data_len) {
+            rb_str_cat(main_result, &data[last_concat_pos], (long)(data_len - last_concat_pos));
+        }
+        return main_result;
     }
-
-    return main_result;
 }
 
 inline void aho_register_match_callback(VALUE rb_result_container, struct ahocorasick * restrict aho,

data/ext/multi_string_replace/extconf.rb

@@ -1,3 +1,13 @@
 require 'mkmf'
-create_header
-create_makefile 'multi_string_replace/multi_string_replace'
+
+# Optional: allow users to tweak optimization flags
+optflags = ENV['MSR_OPTFLAGS'] || '-O3 -fno-strict-aliasing'
+warnflags = ENV['MSR_WARNFLAGS']
+
+with_cflags(optflags) do
+	# avoid treating warnings as errors across diverse compilers
+	with_werror(false) do
+		create_header
+		create_makefile 'multi_string_replace/multi_string_replace'
+	end
+end

data/ext/multi_string_replace/multi_string_replace.c

@@ -14,14 +14,132 @@
 #include "extconf.h"
 #include <stdio.h>
 #include <string.h>
-#include <pthread.h>
 #include "ahocorasick.h"
 
+// Cached Ruby IDs for method lookups
+static ID id_keys;
+static ID id_values;
+static ID id_to_s;
+static ID id_call;
+
+// Forward declaration used by Automaton methods
+void callback_match_pos(VALUE rb_result_container, void *arg, struct aho_match_t* m);
+
+// Automaton wrapper for reuse across calls
+typedef struct {
+  struct ahocorasick aho;
+  VALUE keys_ary; // Ruby array of keys in insertion order (kept for GC safety and lookups)
+  int built;
+} automaton_t;
+
+static void automaton_free(void *ptr) {
+  if (!ptr) return;
+  automaton_t *au = (automaton_t*)ptr;
+  aho_destroy(&au->aho);
+  xfree(au);
+}
+
+static size_t automaton_size(const void *ptr) {
+  return ptr ? sizeof(automaton_t) : 0;
+}
+
+static void automaton_mark(void *ptr) {
+  if (!ptr) return;
+  automaton_t *au = (automaton_t*)ptr;
+  if (!NIL_P(au->keys_ary)) rb_gc_mark(au->keys_ary);
+}
+
+static const rb_data_type_t automaton_type = {
+  "MultiStringReplace::Automaton",
+  { automaton_mark, automaton_free, automaton_size, },
+  0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE automaton_alloc(VALUE klass) {
+  automaton_t *au;
+  VALUE obj = TypedData_Make_Struct(klass, automaton_t, &automaton_type, au);
+  memset(au, 0, sizeof(*au));
+  aho_init(&au->aho);
+  au->built = 0;
+  au->keys_ary = Qnil;
+  return obj;
+}
+
+static VALUE automaton_initialize(VALUE self, VALUE keys) {
+  automaton_t *au;
+  TypedData_Get_Struct(self, automaton_t, &automaton_type, au);
+  Check_Type(keys, T_ARRAY);
+  long size = RARRAY_LEN(keys);
+  au->keys_ary = rb_ary_new_capa(size);
+
+  for (long idx = 0; idx < size; idx++) {
+    VALUE entry = rb_ary_entry(keys, idx);
+    if (!RB_TYPE_P(entry, T_STRING)) {
+      entry = rb_funcall(entry, id_to_s, 0);
+    }
+    rb_ary_push(au->keys_ary, entry); // keep a reference
+    aho_add_match_text(&au->aho, StringValuePtr(entry), RSTRING_LEN(entry));
+  }
+  aho_create_trie(&au->aho);
+  au->built = 1;
+  return self;
+}
+
+static VALUE automaton_match(VALUE self, VALUE body) {
+  automaton_t *au;
+  TypedData_Get_Struct(self, automaton_t, &automaton_type, au);
+  if (!au->built) return rb_hash_new();
+  VALUE result = rb_hash_new();
+  char *target = StringValuePtr(body);
+  aho_register_match_callback(result, &au->aho, callback_match_pos, (void*)target);
+  aho_findtext(&au->aho, target, RSTRING_LEN(body));
+  return result;
+}
+
+static VALUE automaton_replace(VALUE self, VALUE body, VALUE replace) {
+  automaton_t *au;
+  TypedData_Get_Struct(self, automaton_t, &automaton_type, au);
+  if (!au->built) return body;
+  Check_Type(replace, T_HASH);
+
+  long size = RARRAY_LEN(au->keys_ary);
+  char **values = ALLOCA_N(char*, size);
+  long *value_sizes = ALLOCA_N(long, size);
+  VALUE *ruby_val = ALLOCA_N(VALUE, size);
+  for (long i = 0; i < size; i++) { values[i] = NULL; value_sizes[i] = 0; ruby_val[i] = Qnil; }
+
+  // Build arrays aligned with internal ids: id == index of key in keys_ary
+  for (long idx = 0; idx < size; idx++) {
+    VALUE key = rb_ary_entry(au->keys_ary, idx);
+    VALUE value = rb_hash_aref(replace, key);
+    if (NIL_P(value)) {
+      // no replacement provided => keep original text when encountered
+      values[idx] = NULL; // signals "copy original"
+      ruby_val[idx] = Qnil;
+      continue;
+    }
+    if (RB_TYPE_P(value, T_STRING)) {
+      values[idx] = StringValuePtr(value);
+      value_sizes[idx] = RSTRING_LEN(value);
+      ruby_val[idx] = value; // GC keep
+    } else if (rb_respond_to(value, id_call)) {
+      values[idx] = NULL;
+      ruby_val[idx] = value;
+    } else {
+      VALUE s = rb_funcall(value, id_to_s, 0);
+      values[idx] = StringValuePtr(s);
+      value_sizes[idx] = RSTRING_LEN(s);
+      ruby_val[idx] = s;
+    }
+  }
+
+  char *target = StringValuePtr(body);
+  return aho_replace_text(&au->aho, target, RSTRING_LEN(body), values, value_sizes, ruby_val);
+}
+
 void callback_match_pos(VALUE rb_result_container, void *arg, struct aho_match_t* m)
 {
-    
-    unsigned int i = m->pos, idx = 0;
-
+  // Append match position to array keyed by token id
     VALUE key = LONG2NUM(m->id);
     VALUE hash_value = rb_hash_aref(rb_result_container, key);
 
@@ -35,7 +153,6 @@ void callback_match_pos(VALUE rb_result_container, void *arg, struct aho_match_t
 VALUE multi_string_match(VALUE self, VALUE body, VALUE keys)
 {
   Check_Type(keys, T_ARRAY);
-  int state;
   VALUE result = rb_hash_new();
   struct ahocorasick aho;
   aho_init(&aho);
@@ -44,10 +161,8 @@ VALUE multi_string_match(VALUE self, VALUE body, VALUE keys)
   
   for(long idx = 0; idx < size; idx++) {
     VALUE entry = rb_ary_entry(keys, idx);
-    char *key_text;
-
     if (!RB_TYPE_P(entry, T_STRING)) {
-      entry = rb_funcall(entry, rb_intern("to_s"), 0);
+  entry = rb_funcall(entry, id_to_s, 0);
     }
 
     aho_add_match_text(&aho, StringValuePtr(entry), RSTRING_LEN(entry));
@@ -64,18 +179,22 @@ VALUE multi_string_match(VALUE self, VALUE body, VALUE keys)
 VALUE multi_string_replace(VALUE self, VALUE body, VALUE replace)
 {
   Check_Type(replace, T_HASH);
-  int state;
-
   struct ahocorasick aho;
 
   char *target = StringValuePtr(body);
-  VALUE keys = rb_funcall(replace, rb_intern("keys"), 0);
-  VALUE replace_values = rb_funcall(replace, rb_intern("values"), 0);
+  VALUE keys = rb_funcall(replace, id_keys, 0);
+  VALUE replace_values = rb_funcall(replace, id_values, 0);
   long size =  RARRAY_LEN(keys);
 
+  if (size == 0) {
+    // Nothing to replace; return a copy of input (preserves API semantics)
+    return rb_str_dup(body);
+  }
+
   long value_sizes[size];
   char *values[size];
   VALUE ruby_val[size];
+  for (long i = 0; i < size; i++) ruby_val[i] = Qnil; // GC guard and init
   
   aho_init(&aho);
 
@@ -83,25 +202,23 @@ VALUE multi_string_replace(VALUE self, VALUE body, VALUE replace)
     VALUE entry = rb_ary_entry(keys, idx);
     VALUE value = rb_ary_entry(replace_values, idx);
 
-    char *key_text;
-
     if (!RB_TYPE_P(entry, T_STRING)) {
-      entry = rb_funcall(entry, rb_intern("to_s"), 0);
+      entry = rb_funcall(entry, id_to_s, 0);
     }
 
     if (RB_TYPE_P(value, T_STRING)) {
       values[idx] = StringValuePtr(value);
       value_sizes[idx] = RSTRING_LEN(value);
+      ruby_val[idx] = value; // keep VALUE alive
     } else {
-     
-      VALUE responds_value = rb_funcall(value, rb_intern("respond_to?"), 1, rb_str_new_cstr("call"));
-      if (RB_TYPE_P(responds_value, T_TRUE)) {
+      if (rb_respond_to(value, id_call)) {
         values[idx] = NULL;
         ruby_val[idx] = value;
       } else {
-        VALUE value_as_string = rb_funcall(value, rb_intern("to_s"), 0);
+        VALUE value_as_string = rb_funcall(value, id_to_s, 0);
         values[idx] = StringValuePtr(value_as_string);
         value_sizes[idx] = RSTRING_LEN(value_as_string);
+        ruby_val[idx] = value_as_string; // keep VALUE alive
       }
     }
 
@@ -116,6 +233,11 @@ VALUE multi_string_replace(VALUE self, VALUE body, VALUE replace)
 void Init_multi_string_replace()
 {
   int state;
+  // Cache frequently used IDs
+  id_keys = rb_intern("keys");
+  id_values = rb_intern("values");
+  id_to_s = rb_intern("to_s");
+  id_call = rb_intern("call");
   VALUE mod = rb_eval_string_protect("MultiStringReplace", &state);
 
   if (state)
@@ -124,6 +246,15 @@ void Init_multi_string_replace()
   } else {
   rb_define_singleton_method(mod, "match", multi_string_match, 2);
   rb_define_singleton_method(mod, "replace", multi_string_replace, 2);
+
+  // Define Automaton class under module
+  VALUE cAutomaton = rb_define_class_under(mod, "Automaton", rb_cObject);
+  rb_define_alloc_func(cAutomaton, automaton_alloc);
+  rb_define_method(cAutomaton, "initialize", automaton_initialize, 1);
+  rb_define_method(cAutomaton, "match", automaton_match, 1);
+  rb_define_method(cAutomaton, "replace", automaton_replace, 2);
+  // Convenience builder: Automaton.build(keys)
+  rb_define_singleton_method(cAutomaton, "build", RUBY_METHOD_FUNC(rb_class_new_instance), -1);
   }
 
 }

data/lib/multi_string_replace/version.rb

@@ -1,3 +1,3 @@
 module MultiStringReplace
-  VERSION = "2.0.2"
+  VERSION = "3.0.0"
 end

data/multi_string_replace.gemspec

@@ -33,8 +33,8 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
   spec.extensions = ["ext/multi_string_replace/extconf.rb"]
 
-  spec.add_development_dependency "bundler", "~> 2.3.26"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec", "~> 3.0"
   spec.add_development_dependency "rake-compiler"
+  spec.add_development_dependency "benchmark"
 end

metadata

@@ -1,29 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: multi_string_replace
 version: !ruby/object:Gem::Version
-  version: 2.0.2
+  version: 3.0.0
 platform: ruby
 authors:
 - Joseph Dayo
-autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-08-09 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 2.3.26
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 2.3.26
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -66,6 +51,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: benchmark
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: A fast multiple string replace library for ruby. Uses a C implementation
   of the Aho–Corasick Algorithm
 email:
@@ -79,6 +78,7 @@ files:
 - ".gitignore"
 - ".rspec"
 - ".travis.yml"
+- CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - Gemfile
 - Gemfile.lock
@@ -108,7 +108,6 @@ licenses:
 - MIT
 metadata:
   allowed_push_host: https://rubygems.org
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -123,8 +122,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.1
-signing_key: 
+rubygems_version: 3.6.9
 specification_version: 4
 summary: A fast multiple string replace library for ruby. Uses a C implementation
   of the Aho–Corasick Algorithm