multi_string_replace 2.0.1 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1485ddac5f7139a2f9f5161625aa14a2c375f08f995c9d996022a1c7b2c57384
-  data.tar.gz: 94943343da93436f1be137e7ceb38f68a53ff81bacc8b5954997ad0c4d25b777
+  metadata.gz: 92a92ffb1350b891f31634d8b7c3ca4d0a6e1582c91b35f548c61f819cbf5ffe
+  data.tar.gz: 86c5acf5d85393669c05054ce79a1fe37a6fdf98d2e62b17803b94cf46670c1d
 SHA512:
-  metadata.gz: 522e1a14c9430326bfa7aeffab8a484f334eed80123361cd039152ba47ada0bc362a10b42953b25abab4987ebdc73f4ae7c9964972390d5c2b01c601bb935239
-  data.tar.gz: dd9d77326cc78330a021294a1364d270f22f4aee96d5621ca09df2476e06feca3c9207a6965a9b775db117585b4f53d6a8d4bda6052c3f9d1f7b2549fdc8d0e7
+  metadata.gz: 465229a147b4287e725669b7ca10bca5e3ea613cda6d22e69f01ba8f9b9808b1018dd0344caeffc941aee2ea6220392d8d959527b2266c8ab84d8ffdacd0ebc4
+  data.tar.gz: 2148c1d0386ef4efd0ae13dd90466af4b7262fd8d01200ea70ba74f152329abb20655db826a98d12a8604651eb9cd8406ca9498f26681a7b0e7f597d17899a79

data/.github/workflows/ci.yml

@@ -0,0 +1,28 @@
+name: CI
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby: [ '3.0', '3.1', '3.2', '3.3', '3.4' ]
+    steps:
+      - 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.1)
+    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,17 +81,52 @@ 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
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake compile` followed by run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
 To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/multi_string_replace. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+Bug reports and pull requests are welcome on GitHub at https://github.com/jedld/multi_string_replace. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
 
 ## License
 
@@ -87,4 +134,4 @@ The gem is available as open source under the terms of the [MIT License](https:/
 
 ## Code of Conduct
 
-Everyone interacting in the MultiStringReplace project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/multi_string_replace/blob/master/CODE_OF_CONDUCT.md).
+Everyone interacting in the MultiStringReplace project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/jedld/multi_string_replace/blob/master/CODE_OF_CONDUCT.md).

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/aho_trie.c

@@ -29,7 +29,7 @@ bool aho_add_trie_node(struct aho_trie * restrict t, struct aho_text_t * restric
 
     for (int text_idx = 0; text_idx < text->len; text_idx++)
     {
-        unsigned int node_text = text->text[text_idx];
+        unsigned char node_text = text->text[text_idx];
         bool find_node = false;
         int child_idx = 0;
 

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.1"
+  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.1
+  version: 3.0.0
 platform: ruby
 authors:
 - Joseph Dayo
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-12-20 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:
@@ -75,9 +74,11 @@ extensions:
 - ext/multi_string_replace/extconf.rb
 extra_rdoc_files: []
 files:
+- ".github/workflows/ci.yml"
 - ".gitignore"
 - ".rspec"
 - ".travis.yml"
+- CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - Gemfile
 - Gemfile.lock
@@ -107,7 +108,6 @@ licenses:
 - MIT
 metadata:
   allowed_push_host: https://rubygems.org
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -122,8 +122,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
-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