tre_regex 0.2.1-x86_64-linux-musl → 0.2.2-x86_64-linux-musl

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a97a9dfcb628db7da557e73385b3fac07455238f1cbc01b9bad82fbade3377aa
-  data.tar.gz: af28d4d591b9d3b2d5660794031785bb968d25173ed2dae53636138f91fa7e2d
+  metadata.gz: 36bd0de0f0a67c19b0869ad5f5d17e41147122cc6d0451fb2090fb3841385008
+  data.tar.gz: 15715b7d00b3dce17df3ac94d5765006b3be551ed729355f3861c7ded7268715
 SHA512:
-  metadata.gz: 07ab5cf743d11d07ec8253d1bcd246a9d78602b61b564ae0c83e3ef6479fccabe87a1a85cfe44f31f9a933b6931a98948cddf10560c8502b9af69f10299c337d
-  data.tar.gz: e96fbd3886331f6da5aa3ea2bed0939d45855209421215d94d1c58b16ddf0b4019fbab0386c3056df562089e49f81716808bb959d394b78548a89612fe538361
+  metadata.gz: 310f3a3c62bf398f44d1838989bcb2c2ae61d955381b340bed093e8b8592d91914e7c0e8d2f512c9b72a70038cb4a1de9645ba3a4098cdd8eeeef59749ebcdd3
+  data.tar.gz: 759b303f5d2a2da88197dfccc5335ec660424729a28a1501e560e725e1b101945a04846287483aabc010bdc7ad1dae85765d72d5a775d6db9e4b4b67134a0cad

data/README.md

@@ -87,10 +87,10 @@ regex = TreRegex::Regex.new('cat')
 # Returns an array of match hashes
 regex.match_all('cat, cot, cut', max_errors: 1).to_a
 # => [
-#   {match: "cat", submatches: [], index: 0, end_index: 3, cost: 0, errors: {insertions: 0, deletions: 0, substitutions: 0}},
+#  {match: "cat", submatches: [], index: 0, end_index: 3, cost: 0, errors: {insertions: 0, deletions: 0, substitutions: 0}},
 #  {match: "cot", submatches: [], index: 5, end_index: 8, cost: 1, errors: {insertions: 0, deletions: 0, substitutions: 1}},
 #  {match: "cut", submatches: [], index: 10, end_index: 13, cost: 1, errors: {insertions: 0, deletions: 0, substitutions: 1}}
-#    ]
+# ]
 ```
 
 ### Capture Groups (Submatches)
@@ -240,10 +240,10 @@ regex = TreRegex::Regex.new('cat')
 # but it also matches "" at the end of the string (3 deletions)!
 regex.match_all('cot, cow', max_errors: 3).to_a
 # => [
-#     {match: "cot", submatches: [], index: 0, end_index: 3, cost: 1, errors: {insertions: 0, deletions: 0, substitutions: 1}},
-#     {match: "cow", submatches: [], index: 5, end_index: 8, cost: 2, errors: {insertions: 0, deletions: 0, substitutions: 2}},
-#     {match: "", submatches: [], index: 8, end_index: 8, cost: 3, errors: {insertions: 0, deletions: 3, substitutions: 0}}
-#    ]
+#  {match: "cot", submatches: [], index: 0, end_index: 3, cost: 1, errors: {insertions: 0, deletions: 0, substitutions: 1}},
+#  {match: "cow", submatches: [], index: 5, end_index: 8, cost: 2, errors: {insertions: 0, deletions: 0, substitutions: 2}},
+#  {match: "", submatches: [], index: 8, end_index: 8, cost: 3, errors: {insertions: 0, deletions: 3, substitutions: 0}}
+# ]
 ```
 
 **Best Practice**: if you need a high `max_errors` limit but want to prevent the engine from matching empty strings, explicitly cap the `max_deletions` option so that at least one character of your pattern must survive
@@ -252,9 +252,9 @@ regex.match_all('cot, cow', max_errors: 3).to_a
 # Allow 3 total errors, but strictly forbid the engine from deleting more than 2 characters
 regex.match_all('cot, cow', max_errors: 3, max_deletions: 2).to_a
 # => [
-#     {match: "cot", submatches: [], index: 0, end_index: 3, cost: 1, errors: {insertions: 0, deletions: 0, substitutions: 1}},
-#     {match: "cow", submatches: [], index: 5, end_index: 8, cost: 2, errors: {insertions: 0, deletions: 0, substitutions: 2}}
-#    ] # The empty match is mathematically prevented
+#  {match: "cot", submatches: [], index: 0, end_index: 3, cost: 1, errors: {insertions: 0, deletions: 0, substitutions: 1}},
+#  {match: "cow", submatches: [], index: 5, end_index: 8, cost: 2, errors: {insertions: 0, deletions: 0, substitutions: 2}}
+# ] # The empty match is mathematically prevented
 ```
 
 ### POSIX vs. PCRE Syntax

data/lib/tre_regex/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module TreRegex
-  VERSION = '0.2.1'
+  VERSION = '0.2.2'
 end

data/lib/tre_regex.rb

@@ -199,43 +199,71 @@ module TreRegex
       end
     end
 
+    # Helper to safely align TRE's raw byte offsets to valid UTF-8 boundaries
+    def align_bounds(text, absolute_so, absolute_eo)
+      safe_so = absolute_so.clamp(0, text.bytesize)
+
+      # Shift start backward to the nearest valid character boundary
+      # (byte & 0xC0) == 0x80 checks if the byte is a UTF-8 continuation byte
+      safe_so -= 1 while safe_so.positive? && (text.getbyte(safe_so) & 0xC0) == 0x80
+
+      safe_eo = absolute_eo.clamp(0, text.bytesize)
+
+      # Shift end forward to the nearest valid character boundary
+      safe_eo += 1 while safe_eo < text.bytesize && (text.getbyte(safe_eo) & 0xC0) == 0x80
+
+      safe_so = safe_eo if safe_so > safe_eo
+
+      [safe_so, safe_eo]
+    end
+
     def extract_match_payload(text, byte_off, char_off, m_info)
       pmatch_array, nmatch, match_data = m_info
+      abs_so, abs_eo = primary_match_bounds(text, byte_off, pmatch_array)
 
-      # Read the full match boundaries from index 0
-      full_rm = Native::RegMatch.new(pmatch_array)
-      rm_so = full_rm[:rm_so]
-      rm_eo = full_rm[:rm_eo]
+      match_str = text.byteslice(abs_so...abs_eo) || ''
+      start_index = char_off + (text.byteslice(byte_off...abs_so) || '').length
+
+      payload = format_payload(
+        match_str, start_index, match_data,
+        extract_submatches(text, byte_off, pmatch_array, nmatch)
+      )
 
-      prefix_len = (text.byteslice(byte_off, rm_so) || '').length
-      match_str = text.byteslice((byte_off + rm_so)...(byte_off + rm_eo))
+      [payload, abs_eo - byte_off, start_index - char_off + match_str.length]
+    end
 
-      payload = {
+    def primary_match_bounds(text, byte_off, pmatch_array)
+      full_rm = Native::RegMatch.new(pmatch_array)
+      align_bounds(text, byte_off + full_rm[:rm_so], byte_off + full_rm[:rm_eo])
+    end
+
+    def format_payload(match_str, start_index, match_data, submatches)
+      {
         match: match_str,
-        submatches: extract_submatches(text, byte_off, pmatch_array, nmatch),
-        index: char_off + prefix_len,
-        end_index: char_off + prefix_len + match_str.length,
+        submatches:,
+        index: start_index,
+        end_index: start_index + match_str.length,
         cost: match_data[:cost],
         errors: parse_errors(match_data)
       }
-
-      [payload, rm_eo, prefix_len + match_str.length]
     end
 
     def extract_submatches(text, byte_off, pmatch_array, nmatch)
       submatches = (1...nmatch).map do |i|
         # Advance the memory pointer by the size of the struct for each index
         rm = Native::RegMatch.new(pmatch_array + (i * Native::RegMatch.size))
-        sub_so = rm[:rm_so]
-        sub_eo = rm[:rm_eo]
-
-        # Safely extract the group, inserting nil if it was optional and unmatched
-        sub_so == -1 ? nil : text.byteslice((byte_off + sub_so)...(byte_off + sub_eo))
+        raw_so = rm[:rm_so]
+        raw_eo = rm[:rm_eo]
+
+        if raw_so == -1 || raw_so > raw_eo
+          nil
+        else
+          abs_so, abs_eo = align_bounds(text, byte_off + raw_so, byte_off + raw_eo)
+          text.byteslice(abs_so...abs_eo)
+        end
       end
 
-      # Cleanup: Remove trailing nil values (unused capture groups)
       submatches.pop while submatches.last.nil? && !submatches.empty?
-
       submatches
     end
 

data/tre_regex.gemspec

@@ -11,7 +11,7 @@ Gem::Specification.new do |spec|
 
   spec.summary = 'A fast Ruby FFI wrapper for the TRE approximate regex matching library'
   spec.description = [
-    'TreRegex provides a high-performance Ruby interface to the TRE C library using FFI.',
+    'TreRegex provides a high-performance Ruby interface to the TRE C library.',
     'It brings robust approximate (fuzzy) regular expression matching to Ruby, featuring',
     'multi-byte Unicode string safety, and granular error limits'
   ].join(' ')

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tre_regex
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.2
 platform: x86_64-linux-musl
 authors:
 - Oleksii Vasyliev
@@ -23,9 +23,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '1.0'
-description: TreRegex provides a high-performance Ruby interface to the TRE C library
-  using FFI. It brings robust approximate (fuzzy) regular expression matching to Ruby,
-  featuring multi-byte Unicode string safety, and granular error limits
+description: TreRegex provides a high-performance Ruby interface to the TRE C library.
+  It brings robust approximate (fuzzy) regular expression matching to Ruby, featuring
+  multi-byte Unicode string safety, and granular error limits
 email:
 - leopard.not.a@gmail.com
 executables: []