re: implement search, findall and sub

Author: adsharma

native/src/regex_wrapper.cpp

@@ -43,4 +43,54 @@ extern "C" {
             return false;
         }
     }
+
+    // Search for a regex pattern in a string
+    const char* search_pattern(int id, const char* text) {
+        auto it = regex_cache.find(id);
+        if (it == regex_cache.end()) {
+            return nullptr; // Return nullptr if the ID is not found
+        }
+
+        std::smatch match;
+        std::string str(text);
+        if (std::regex_search(str, match, *it->second)) {
+            return match.str().c_str(); // Return the matched substring
+        }
+        return nullptr; // Return nullptr if no match is found
+    }
+
+    // Find all matches of a regex pattern in a string
+    const char* findall_pattern(int id, const char* text) {
+        auto it = regex_cache.find(id);
+        if (it == regex_cache.end()) {
+            return nullptr; // Return nullptr if the ID is not found
+        }
+
+        std::string str(text);
+        std::smatch match;
+        std::string result;
+        std::string::const_iterator searchStart(str.cbegin());
+
+        while (std::regex_search(searchStart, str.cend(), match, *it->second)) {
+            result += match.str() + "\n"; // Append each match to the result string
+            searchStart = match.suffix().first;
+        }
+
+        if (!result.empty()) {
+            return result.c_str(); // Return all matches as a single string separated by newlines
+        }
+        return nullptr; // Return nullptr if no matches are found
+    }
+
+    // Substitute all occurrences of a regex pattern in a string
+    const char* substitute_pattern(int id, const char* text, const char* replacement) {
+        auto it = regex_cache.find(id);
+        if (it == regex_cache.end()) {
+            return nullptr; // Return nullptr if the ID is not found
+        }
+
+        std::string str(text);
+        std::string result = std::regex_replace(str, *it->second, replacement);
+        return result.c_str(); // Return the modified string
+    }
 }

src/stdlib/re.py

@@ -21,19 +21,40 @@ def match(pattern: str, text: str) -> bool:
 # Python wrapper class
 class CompiledRegex:
     def __init__(self, pattern):
-        self.id = lib.compile_pattern(  # pyright: ignore [reportAttributeAccessIssue]
-            pattern.encode("utf-8")
-        )
+        self.id = lib.compile_pattern(pattern.encode("utf-8"))  # type: ignore
         if self.id == -1:
             raise ValueError("Invalid regex pattern")
 
     def match(self, text):
-        return lib.match_compiled(  # pyright: ignore [reportAttributeAccessIssue]
-            self.id, text.encode("utf-8")
-        )
+        return lib.match_compiled(self.id, text.encode("utf-8"))  # type: ignore
 
     def __del__(self):
-        lib.release_compiled(self.id)  # pyright: ignore [reportAttributeAccessIssue]
+        lib.release_compiled(self.id)  # type: ignore
+
+    def search(self, text: str) -> str | None:
+        # Search for the compiled regex in the text
+        result = lib.search_pattern(self.id, text.encode("utf-8"))  # type: ignore
+        if result:
+            return result.decode("utf-8")
+        return None
+
+    def findall(self, text: str) -> list[str]:
+        # Find all matches of the compiled regex in the text
+        result = lib.search_pattern(self.id, text.encode("utf-8"))  # type: ignore
+        if result:
+            return result.decode("utf-8").split("\n")[
+                :-1
+            ]  # Split by newline and remove the last empty string
+        return []
+
+    def sub(self, replacement: str, text: str) -> str:
+        # Substitute all occurrences of the compiled regex in the text
+        result = lib.substitute_pattern(  # type: ignore
+            self.id, text.encode("utf-8"), replacement.encode("utf-8")
+        )
+        if result:
+            return result.decode("utf-8")
+        return text  # Return the original text if substitution fails
 
 
 def compile(pattern: str) -> CompiledRegex:

tests/test_re.py

@@ -112,3 +112,72 @@ def test_edge_cases():
     )  # Email regex
     assert regex.match("test@example.com") is True  # Should match
     assert regex.match("invalid-email") is False  # Should not match
+
+
+# Fixture to create a CompiledRegex object for testing
+@pytest.fixture
+def compiled_regex():
+    return CompiledRegex(r"\d+")
+
+
+# Test cases for the `search` method
+def test_search_found(compiled_regex):
+    text = "There are 123 apples and 456 oranges."
+    result = compiled_regex.search(text)
+    assert result == "123"  # First match should be "123"
+
+
+def test_search_not_found(compiled_regex):
+    text = "There are no numbers here."
+    result = compiled_regex.search(text)
+    assert result is None  # No match should return None
+
+
+# Test cases for the `findall` method
+def test_findall_multiple_matches(compiled_regex):
+    text = "There are 123 apples and 456 oranges."
+    result = compiled_regex.findall(text)
+    assert result == ["123", "456"]  # All matches should be returned
+
+
+def test_findall_no_matches(compiled_regex):
+    text = "There are no numbers here."
+    result = compiled_regex.findall(text)
+    assert result == []  # No matches should return an empty list
+
+
+def test_findall_empty_string(compiled_regex):
+    text = ""
+    result = compiled_regex.findall(text)
+    assert result == []  # Empty string should return an empty list
+
+
+# Test cases for the `sub` method
+def test_sub_single_replacement(compiled_regex):
+    text = "There are 123 apples."
+    result = compiled_regex.sub("NUM", text)
+    assert result == "There are NUM apples."  # Single replacement
+
+
+def test_sub_multiple_replacements(compiled_regex):
+    text = "There are 123 apples and 456 oranges."
+    result = compiled_regex.sub("NUM", text)
+    assert result == "There are NUM apples and NUM oranges."  # Multiple replacements
+
+
+def test_sub_no_matches(compiled_regex):
+    text = "There are no numbers here."
+    result = compiled_regex.sub("NUM", text)
+    assert result == text  # No matches, original text should be returned
+
+
+def test_sub_empty_string(compiled_regex):
+    text = ""
+    result = compiled_regex.sub("NUM", text)
+    assert result == ""  # Empty string should remain unchanged
+
+
+# Edge case: Invalid regex pattern
+def test_invalid_regex_pattern():
+    with pytest.raises(ValueError):
+        CompiledRegex(r"*invalid")  # Invalid regex pattern should raise ValueError