table_string_replacer 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: cb11a5cfd1ec0a7dec1a8131c2b5324552fceaf90df427b973793740fc85d385
+  data.tar.gz: bbf93bcb1e70775d92d24fa95a7d7f6427a86deb16c06ce1fcd57ac5f62e4890
+SHA512:
+  metadata.gz: c88257041447a1c505760949f57163c12819097280aef4cf319dcb1288fe38613a6832531b1ff55370ca989e8fdbad610939871f6164bca5a0ddce0000615ddf
+  data.tar.gz: 19d525e54a7c6baa90c82fba83a72eedbbcce4b3cd92918010040e2ebb0d950c0cb97bf89ad1f38862d38fde96d2506f3404239d3699bb3051120428bcadd26b

data/CHANGELOG.md

@@ -0,0 +1,23 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.2.0] - 2023-03-18
+
+### Added
+- Thread safety guarantees for all methods
+- Benchmarking utility to compare with native Ruby 
+- Support for PHP serialized data with proper string length adjustment
+
+### Fixed
+- Memory leaks in the C extension
+
+## [0.1.0] - 2023-03-01
+
+### Added
+- Initial release
+- Basic batch replacement functionality
+- C extension for performance 

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2023 Your Name
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE. 

data/README.md

@@ -0,0 +1,69 @@
+# TableStringReplacer
+
+A C extension for Ruby that provides optimized string replacement operations, with special handling for PHP serialized strings (commonly used in WordPress).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'table_string_replacer'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install table_string_replacer
+
+## Usage
+
+```ruby
+require 'table_string_replacer'
+
+# Simple batch replacement
+content = "Hello world, hello ruby"
+replacements = [
+  ["Hello", "Hi"],
+  ["world", "everyone"],
+  ["ruby", "Rails"]
+]
+
+# Perform all replacements in a single pass
+result = TableStringReplacer.batch_replace(content, replacements)
+# => "Hi everyone, hello Rails"
+
+# For WordPress serialized data
+serialized = 's:15:"http://old.com/";'
+old_str = "http://old.com"
+new_str = "https://new.com"
+
+# This will handle the PHP serialized string length correctly
+result = TableStringReplacer.serialized_str_replace(serialized, old_str, new_str)
+# => 's:16:"https://new.com/";'
+```
+
+## Performance
+
+This gem is especially useful for batch operations on large strings where you need to make multiple replacements in a single pass. The C extension is typically much faster than Ruby's native string replacement for large inputs.
+
+```ruby
+# Check if the C extension is faster for your workload
+TableStringReplacer.faster_than_ruby?(your_string, your_replacements)
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` 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 the created tag, 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/yourusername/table_string_replacer.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT). 

data/ext/table_string_replacer/extconf.rb

@@ -0,0 +1,20 @@
+require 'mkmf'
+
+# Check for strcasestr function
+have_func('strcasestr')
+have_header('string.h')
+have_header('stdlib.h')
+have_header('ctype.h')
+
+# Add optimization flags for best performance
+$CFLAGS << ' -O3 -fPIC -fomit-frame-pointer -ffast-math -funroll-loops'
+
+# Platform-specific optimizations
+if RUBY_PLATFORM =~ /x86_64|i386/
+  $CFLAGS << ' -msse4.2' if try_cflags('-msse4.2')
+end
+
+# Thread safety flags
+$CFLAGS << ' -pthread' unless $CFLAGS.include?('-pthread')
+
+create_makefile('table_string_replacer/table_string_replacer') 

data/ext/table_string_replacer/table_string_replacer.c

@@ -0,0 +1,318 @@
+#include <ruby.h>
+#include <string.h>
+#include <ctype.h>
+#include <stdlib.h>
+
+// Thread-local Boyer-Moore search buffer size
+#define BM_BUFFER_SIZE 256
+
+#ifndef HAVE_STRCASESTR
+char *strcasestr(const char *haystack, const char *needle) {
+    size_t needle_len = strlen(needle);
+    size_t haystack_len = strlen(haystack);
+    
+    // Use Boyer-Moore-like approach for better performance
+    int skip[BM_BUFFER_SIZE];
+    size_t i, j;
+    
+    // Initialize skip table
+    for (i = 0; i < BM_BUFFER_SIZE; i++)
+        skip[i] = needle_len;
+    
+    for (i = 0; i < needle_len - 1; i++)
+        skip[toupper((unsigned char)needle[i]) % BM_BUFFER_SIZE] = needle_len - i - 1;
+    
+    // Search
+    for (i = 0; i <= haystack_len - needle_len; i += skip[toupper((unsigned char)haystack[i + needle_len - 1]) % BM_BUFFER_SIZE]) {
+        for (j = 0; j < needle_len; j++) {
+            if (toupper((unsigned char)haystack[i + j]) != toupper((unsigned char)needle[j]))
+                break;
+        }
+        
+        if (j == needle_len)
+            return (char*)(haystack + i);
+    }
+    
+    return NULL;
+}
+#endif
+
+// Fast serialized PHP string replacement with improved memory handling
+static VALUE rb_serialized_str_replace(VALUE self, VALUE orig_str, VALUE old_str, VALUE new_str) {
+    // Ensure strings are properly initialized
+    Check_Type(orig_str, T_STRING);
+    Check_Type(old_str, T_STRING);
+    Check_Type(new_str, T_STRING);
+    
+    char *orig = RSTRING_PTR(orig_str);
+    char *old = RSTRING_PTR(old_str);
+    char *new = RSTRING_PTR(new_str);
+    
+    long orig_len = RSTRING_LEN(orig_str);
+    long old_len = RSTRING_LEN(old_str);
+    long new_len = RSTRING_LEN(new_str);
+    
+    // Early optimization: if old and new are identical, return original
+    if (old_len == new_len && memcmp(old, new, old_len) == 0) {
+        return rb_str_dup(orig_str);
+    }
+    
+    // Estimate result size more accurately to avoid reallocations
+    long max_replacements = orig_len / (old_len > 0 ? old_len : 1);
+    long size_diff = new_len - old_len;
+    long estimated_result_len = orig_len + (size_diff > 0 ? size_diff * max_replacements : 0) + 128;
+    
+    // Pre-allocate result buffer
+    VALUE result = rb_str_new(NULL, estimated_result_len);
+    char *res_ptr = RSTRING_PTR(result);
+    long res_len = 0;
+    
+    long i = 0;
+    while (i < orig_len) {
+        // Check for serialized string marker
+        if (i + 2 < orig_len && orig[i] == 's' && orig[i+1] == ':') {
+            char *endptr;
+            long len_pos = i + 2;
+            
+            // Extract length value more safely
+            if (len_pos < orig_len) {
+                long len_val = strtol(orig + len_pos, &endptr, 10);
+                
+                // Verify we found a valid PHP serialized string
+                if (endptr && *endptr == ':' && (endptr+1) < orig + orig_len && *(endptr+1) == '"') {
+                    long content_start = (endptr + 2) - orig;
+                    
+                    // Make sure content_start is within bounds
+                    if (content_start < orig_len) {
+                        // Only search within the actual serialized string content
+                        long search_limit = content_start + len_val;
+                        if (search_limit > orig_len) search_limit = orig_len;
+                        
+                        char *found = strcasestr(orig + content_start, old);
+                        
+                        // Found match within the serialized string content
+                        if (found && found < orig + search_limit) {
+                            // Verify we have enough space in result buffer (resize if needed)
+                            long needed_len = res_len + (found - (orig + i)) + new_len + 100;
+                            if (needed_len > estimated_result_len) {
+                                rb_str_resize(result, needed_len * 2);
+                                res_ptr = RSTRING_PTR(result);
+                                estimated_result_len = needed_len * 2;
+                            }
+                        
+                            // Calculate new serialized string length
+                            long new_len_val = len_val - old_len + new_len;
+                            
+                            // Update the serialized string length indicator
+                            char len_buf[32];
+                            int len_digits = snprintf(len_buf, sizeof(len_buf), "s:%ld:", new_len_val);
+                            
+                            // Copy prefix up to the 's:' marker
+                            memcpy(res_ptr + res_len, orig + i, 2);
+                            res_len += 2;
+                            
+                            // Copy new length
+                            memcpy(res_ptr + res_len, len_buf + 2, len_digits - 2);
+                            res_len += len_digits - 2;
+                            
+                            // Copy from length end to the found match position
+                            long pre_len = found - (orig + content_start);
+                            memcpy(res_ptr + res_len, endptr, pre_len + 2);
+                            res_len += pre_len + 2;
+                            
+                            // Copy the new replacement string
+                            memcpy(res_ptr + res_len, new, new_len);
+                            res_len += new_len;
+                            
+                            // Skip to after the replacement point
+                            i = found - orig + old_len;
+                            continue;
+                        }
+                    }
+                }
+            }
+        }
+        
+        // If we didn't perform a replacement, copy the current character
+        if (res_len >= estimated_result_len) {
+            rb_str_resize(result, estimated_result_len * 2);
+            res_ptr = RSTRING_PTR(result);
+            estimated_result_len *= 2;
+        }
+        res_ptr[res_len++] = orig[i++];
+    }
+    
+    // Set final string length and terminate
+    rb_str_resize(result, res_len);
+    
+    return result;
+}
+
+// Optimized batch string replacement
+static VALUE rb_batch_replace(VALUE self, VALUE orig_str, VALUE replacements) {
+    Check_Type(orig_str, T_STRING);
+    Check_Type(replacements, T_ARRAY);
+    
+    long replacements_count = RARRAY_LEN(replacements);
+    if (replacements_count == 0) {
+        return rb_str_dup(orig_str);
+    }
+    
+    char *orig = RSTRING_PTR(orig_str);
+    long orig_len = RSTRING_LEN(orig_str);
+    
+    // For small number of replacements, use a simpler algorithm
+    if (replacements_count <= 3) {
+        VALUE result = rb_str_dup(orig_str);
+        
+        for (long i = 0; i < replacements_count; i++) {
+            VALUE pair = rb_ary_entry(replacements, i);
+            VALUE old_val = rb_ary_entry(pair, 0);
+            VALUE new_val = rb_ary_entry(pair, 1);
+            
+            // Use Ruby's gsub! for simplicity with small numbers of replacements
+            result = rb_funcall(result, rb_intern("gsub!"), 2, old_val, new_val);
+            if (NIL_P(result)) {
+                // If no replacements were made, restore original
+                result = rb_str_dup(orig_str);
+            }
+        }
+        
+        return result;
+    }
+    
+    // For larger numbers of replacements, use a more efficient algorithm
+    // Calculate maximum possible result length
+    long max_result_len = orig_len;
+    for (long i = 0; i < replacements_count; i++) {
+        VALUE pair = rb_ary_entry(replacements, i);
+        VALUE old_str = rb_ary_entry(pair, 0);
+        VALUE new_str = rb_ary_entry(pair, 1);
+        
+        long old_len = RSTRING_LEN(old_str);
+        long new_len = RSTRING_LEN(new_str);
+        
+        if (new_len > old_len) {
+            // Add extra space for each potential replacement
+            long potential_replacements = old_len > 0 ? orig_len / old_len : 0;
+            max_result_len += potential_replacements * (new_len - old_len);
+        }
+    }
+    
+    // Allocate result buffer with extra room
+    VALUE result = rb_str_new(NULL, max_result_len + 1024);
+    char *res_ptr = RSTRING_PTR(result);
+    long res_len = 0;
+    
+    // Store pattern data for faster lookup
+    char **patterns = ALLOCA_N(char*, replacements_count);
+    char **replacements_ptr = ALLOCA_N(char*, replacements_count);
+    long *pattern_lens = ALLOCA_N(long, replacements_count);
+    long *replacement_lens = ALLOCA_N(long, replacements_count);
+    
+    for (long i = 0; i < replacements_count; i++) {
+        VALUE pair = rb_ary_entry(replacements, i);
+        VALUE old_str = rb_ary_entry(pair, 0);
+        VALUE new_str = rb_ary_entry(pair, 1);
+        
+        patterns[i] = RSTRING_PTR(old_str);
+        pattern_lens[i] = RSTRING_LEN(old_str);
+        replacements_ptr[i] = RSTRING_PTR(new_str);
+        replacement_lens[i] = RSTRING_LEN(new_str);
+    }
+    
+    // Process the string in a single pass
+    long i = 0;
+    while (i < orig_len) {
+        int matched = 0;
+        
+        // Find longest matching pattern at current position
+        long best_match_len = 0;
+        long best_match_idx = -1;
+        
+        for (long j = 0; j < replacements_count; j++) {
+            long pattern_len = pattern_lens[j];
+            
+            // Skip if we don't have enough characters left
+            if (i + pattern_len > orig_len || pattern_len <= 0) continue;
+            
+            // Only consider if this would be a longer match
+            if (pattern_len > best_match_len) {
+                // Check if this pattern matches at current position
+                if (memcmp(orig + i, patterns[j], pattern_len) == 0) {
+                    best_match_len = pattern_len;
+                    best_match_idx = j;
+                    matched = 1;
+                }
+            }
+        }
+        
+        if (matched) {
+            // Apply the best match
+            long replace_len = replacement_lens[best_match_idx];
+            
+            // Ensure we have room in the result buffer
+            if (res_len + replace_len >= max_result_len) {
+                max_result_len *= 2;
+                rb_str_resize(result, max_result_len);
+                res_ptr = RSTRING_PTR(result);
+            }
+            
+            // Copy replacement string
+            memcpy(res_ptr + res_len, replacements_ptr[best_match_idx], replace_len);
+            res_len += replace_len;
+            
+            // Advance past the matched pattern
+            i += best_match_len;
+        } else {
+            // No match, copy the current character
+            if (res_len >= max_result_len) {
+                max_result_len *= 2;
+                rb_str_resize(result, max_result_len);
+                res_ptr = RSTRING_PTR(result);
+            }
+            res_ptr[res_len++] = orig[i++];
+        }
+    }
+    
+    // Resize to actual length
+    rb_str_resize(result, res_len);
+    
+    return result;
+}
+
+// Benchmark function to measure performance
+static VALUE rb_benchmark(VALUE self, VALUE iterations, VALUE orig_str, VALUE replacements) {
+    Check_Type(iterations, T_FIXNUM);
+    Check_Type(orig_str, T_STRING);
+    Check_Type(replacements, T_ARRAY);
+    
+    long iter = FIX2LONG(iterations);
+    VALUE result = Qnil;
+    
+    for (long i = 0; i < iter; i++) {
+        // Free the previous result to avoid memory buildup
+        if (!NIL_P(result)) {
+            result = Qnil;
+        }
+        result = rb_batch_replace(self, orig_str, replacements);
+    }
+    
+    return result;
+}
+
+// Module initialization
+void Init_table_string_replacer() {
+    VALUE mStringReplacer = rb_define_module("TableStringReplacer");
+    
+    // Core functionality
+    rb_define_singleton_method(mStringReplacer, "serialized_str_replace", rb_serialized_str_replace, 3);
+    rb_define_singleton_method(mStringReplacer, "batch_replace", rb_batch_replace, 2);
+    
+    // Benchmarking utility
+    rb_define_singleton_method(mStringReplacer, "benchmark", rb_benchmark, 3);
+    
+    // Constants for thread safety documentation
+    rb_define_const(mStringReplacer, "THREAD_SAFE", Qtrue);
+    rb_define_const(mStringReplacer, "VERSION", rb_str_new_cstr(RSTRING_PTR(rb_const_get(mStringReplacer, rb_intern("VERSION")))));
+} 

data/lib/table_string_replacer/benchmarking.rb

@@ -0,0 +1,78 @@
+module TableStringReplacer
+  # Benchmarking utilities for TableStringReplacer
+  module Benchmarking
+    # Compares performance between this gem and Ruby's native string replacement
+    #
+    # @param str [String] Input string to test against
+    # @param replacements [Array<Array<String, String>>] Array of [old, new] pairs
+    # @param iterations [Integer] Number of times to run the test
+    # @return [Hash] Timing results showing performance comparison
+    def self.compare_with_ruby(str, replacements, iterations = 1000)
+      require 'benchmark'
+      
+      # Clone inputs to ensure we have identical test cases
+      ruby_str = str.dup
+      c_str = str.dup
+      
+      # Convert replacements for Ruby's format if needed
+      ruby_replacements = {}
+      replacements.each { |old, new| ruby_replacements[old] = new }
+      
+      results = {}
+      
+      results[:ruby] = Benchmark.measure do
+        iterations.times do
+          ruby_replacements.each do |old, new|
+            ruby_str.gsub!(old, new)
+          end
+        end
+      end
+      
+      results[:c_extension] = Benchmark.measure do
+        iterations.times do
+          c_str = TableStringReplacer.batch_replace(c_str, replacements)
+        end
+      end
+      
+      results[:speedup] = results[:ruby].real / results[:c_extension].real
+      
+      results
+    end
+    
+    # Tests thread safety by running multiple threads simultaneously
+    #
+    # @param threads [Integer] Number of threads to run concurrently
+    # @param iterations [Integer] Number of replacements per thread
+    # @return [Boolean] True if all threads completed successfully
+    def self.test_thread_safety(threads = 10, iterations = 1000)
+      replacements = [["old1", "new1"], ["old2", "new2"], ["old3", "new3"]]
+      str = "This is old1 test string with old2 and old3 values"
+      
+      # Create arrays to store results
+      results = []
+      errors = []
+      
+      # Create and start threads
+      thread_group = Array.new(threads) do |i|
+        Thread.new do
+          begin
+            thread_result = nil
+            iterations.times do
+              thread_result = TableStringReplacer.batch_replace(str, replacements)
+            end
+            results[i] = thread_result
+          rescue => e
+            errors << e
+          end
+        end
+      end
+      
+      # Wait for all threads to complete
+      thread_group.each(&:join)
+      
+      # Check results
+      success = errors.empty? && results.compact.size == threads
+      success ? true : { success: false, errors: errors }
+    end
+  end
+end 

data/lib/table_string_replacer/version.rb

@@ -0,0 +1,3 @@
+module TableStringReplacer
+	VERSION = "0.2.0"
+end 

data/lib/table_string_replacer.rb

@@ -0,0 +1,31 @@
+require "table_string_replacer/version"
+# Load the compiled C extension
+require "table_string_replacer/table_string_replacer"
+
+module TableStringReplacer
+	class Error < StandardError; end
+	
+	# This module provides high-performance string replacements
+	# optimized for WordPress serialized data.
+	#
+	# All methods are thread-safe and can be called concurrently
+	# from multiple threads without any issues.
+	
+	# Returns true if a benchmark shows this gem is faster than 
+	# native Ruby string replacement for your workload
+	#
+	# @param str [String] Sample input string 
+	# @param replacements [Array<Array<String, String>>] Array of [old, new] pairs
+	# @return [Boolean] true if the C extension is faster
+	def self.faster_than_ruby?(str, replacements)
+		start_time = Time.now
+		100.times { str.gsub(replacements.first[0], replacements.first[1]) }
+		ruby_time = Time.now - start_time
+		
+		start_time = Time.now
+		100.times { TableStringReplacer.batch_replace(str, replacements) }
+		c_time = Time.now - start_time
+		
+		c_time < ruby_time
+	end
+end 

metadata

@@ -0,0 +1,56 @@
+--- !ruby/object:Gem::Specification
+name: table_string_replacer
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- ANKIT KHANDELWAL
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-03-18 00:00:00.000000000 Z
+dependencies: []
+description: A C extension that provides optimized string replacement, specially handling
+  PHP serialized strings
+email:
+- bv-ankit@blogvault.net
+executables: []
+extensions:
+- ext/table_string_replacer/extconf.rb
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- ext/table_string_replacer/extconf.rb
+- ext/table_string_replacer/table_string_replacer.c
+- lib/table_string_replacer.rb
+- lib/table_string_replacer/benchmarking.rb
+- lib/table_string_replacer/version.rb
+homepage: https://github.com/bv-ankit/table_string_replacer
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/bv-ankit/table_string_replacer
+  source_code_uri: https://github.com/bv-ankit/table_string_replacer
+  changelog_uri: https://github.com/bv-ankit/table_string_replacer/blob/master/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.5.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.18
+signing_key:
+specification_version: 4
+summary: Fast string replacement operations with PHP serialization support
+test_files: []