re: compiled regex

Author: adsharma

native/src/regex_wrapper.cpp

@@ -1,8 +1,40 @@
 // regex_wrapper.cpp
 #include <regex>
 #include <string>
+#include <unordered_map>
+#include <memory>
+
+// A map to store compiled regex objects
+std::unordered_map<int, std::shared_ptr<std::regex>> regex_cache;
+int next_id = 0;
 
 extern "C" {
+    // Compile a regex pattern and return an ID
+    int compile_pattern(const char* pattern) {
+        try {
+            auto re = std::make_shared<std::regex>(pattern);
+            int id = next_id++;
+            regex_cache[id] = re;
+            return id;
+        } catch (const std::regex_error&) {
+            return -1; // Return -1 to indicate an error
+        }
+    }
+
+    // Match a compiled regex against text
+    bool match_compiled(int id, const char* text) {
+        auto it = regex_cache.find(id);
+        if (it != regex_cache.end()) {
+            return std::regex_match(text, *it->second);
+        }
+        return false; // Return false if the ID is not found
+    }
+
+    // Release a compiled regex by ID
+    void release_compiled(int id) {
+        regex_cache.erase(id);
+    }
+
     bool match(const char* pattern, const char* text) {
         try {
             std::regex re(pattern);

src/stdlib/_cffi_util.py

@@ -4,7 +4,7 @@
 import cffi
 
 
-def load_library(lib_name):
+def load_library(lib_name, interface=""):
     """
     Load a shared library based on the operating system.
 
@@ -30,11 +30,7 @@ def load_library(lib_name):
     )
 
     ffi = cffi.FFI()
-    ffi.cdef(
-        """
-             bool match(const char* pattern, const char* text);
-             """
-    )
+    ffi.cdef(interface)
     lib_path = Path(__file__).parent.parent / "lib" / lib_filename
 
     return ffi.dlopen(str(lib_path))

src/stdlib/re.py

@@ -1,7 +1,15 @@
 from stdlib._cffi_util import load_library
 
+# Define the C interface
+interface = """
+    int compile_pattern(const char* pattern);
+    bool match_compiled(int id, const char* text);
+    void release_compiled(int id);
+    bool match(const char* pattern, const char* text);
+"""
+
 # Load the shared library
-lib = load_library("regex_wrapper")
+lib = load_library("regex_wrapper", interface)
 
 
 def match(pattern: str, text: str) -> bool:
@@ -10,6 +18,28 @@ def match(pattern: str, text: str) -> bool:
     )
 
 
+# Python wrapper class
+class CompiledRegex:
+    def __init__(self, pattern):
+        self.id = lib.compile_pattern(
+            pattern.encode("utf-8")
+        )  # pyright: ignore [reportAttributeAccessIssue]
+        if self.id == -1:
+            raise ValueError("Invalid regex pattern")
+
+    def match(self, text):
+        return lib.match_compiled(
+            self.id, text.encode("utf-8")
+        )  # pyright: ignore [reportAttributeAccessIssue]
+
+    def __del__(self):
+        lib.release_compiled(self.id)  # pyright: ignore [reportAttributeAccessIssue]
+
+
+def compile(pattern: str) -> CompiledRegex:
+    return CompiledRegex(pattern)
+
+
 # Example usage
 if __name__ == "__main__":
     pattern = r"^\d{3}-\d{2}-\d{4}$"

tests/test_re.py

@@ -1,3 +1,8 @@
+import pytest
+
+from stdlib.re import CompiledRegex
+
+
 def test_match_simple_pattern(regex_matcher):
     """Test matching a simple pattern."""
     assert regex_matcher(r"^\d{3}-\d{2}-\d{4}$", "123-45-6789") == True
@@ -52,3 +57,58 @@ def test_match_with_anchors(regex_matcher):
     assert (
         regex_matcher(r"exact", "not exact") == False
     )  # "not exact" is not the full string
+
+
+# Test valid regex compilation and matching
+def test_valid_regex():
+    regex = CompiledRegex(r"\d+")  # Compile a regex pattern for digits
+    assert regex.match("123") is True  # Should match
+    assert regex.match("abc") is False  # Should not match
+
+
+# Test invalid regex pattern
+def test_invalid_regex():
+    with pytest.raises(ValueError, match="Invalid regex pattern"):
+        CompiledRegex(r"*invalid*")  # Invalid regex pattern
+
+
+# Test matching with a compiled regex
+def test_match_compiled():
+    regex = CompiledRegex(r"[A-Za-z]+")  # Compile a regex pattern for letters
+    assert regex.match("Hello") is True  # Should match
+    assert regex.match("123") is False  # Should not match
+
+
+# Test multiple regex instances
+def test_multiple_regex_instances():
+    regex1 = CompiledRegex(r"\d{3}")  # Compile a regex pattern for exactly 3 digits
+    regex2 = CompiledRegex(r"[a-z]+")  # Compile a regex pattern for lowercase letters
+
+    assert regex1.match("123") is True  # Should match
+    assert regex1.match("12") is False  # Should not match
+
+    assert regex2.match("abc") is True  # Should match
+    assert regex2.match("ABC") is False  # Should not match
+
+
+# Test releasing compiled regex
+def test_release_compiled():
+    regex = CompiledRegex(r"\w+")  # Compile a regex pattern for word characters
+    assert regex.match("word") is True  # Should match
+    del regex  # Release the compiled regex
+    # No direct way to test if the C++ object was released, but this ensures no crashes
+
+
+# Test edge cases
+def test_edge_cases():
+    # Empty pattern
+    regex = CompiledRegex(r"")
+    assert regex.match("") is True  # Should match empty string
+    assert regex.match("a") is True  # Should match any string
+
+    # Complex pattern
+    regex = CompiledRegex(
+        r"^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}$"
+    )  # Email regex
+    assert regex.match("test@example.com") is True  # Should match
+    assert regex.match("invalid-email") is False  # Should not match