Initial upload: regex-humanizer-cli with CI/CD workflow

tests/test_translator.py

@@ -0,0 +1,221 @@
+"""Tests for the regex translator."""
+
+import pytest
+from regex_humanizer.translator import RegexTranslator, translate_regex
+
+
+class TestRegexTranslator:
+    """Test cases for RegexTranslator."""
+
+    def test_translate_simple_literal(self):
+        """Test translating a simple literal."""
+        result = translate_regex("hello")
+        assert "hello" in result.lower() or "hello" in result
+
+    def test_translate_character_class(self):
+        """Test translating a character class."""
+        result = translate_regex("[a-z]")
+        assert "any" in result.lower() and ("a" in result.lower() or "z" in result.lower())
+
+    def test_translate_negated_class(self):
+        """Test translating a negated character class."""
+        result = translate_regex("[^0-9]")
+        assert "except" in result.lower() or "not" in result.lower()
+
+    def test_translate_digit_class(self):
+        """Test translating digit shorthand."""
+        result = translate_regex("\\d")
+        assert "digit" in result.lower()
+
+    def test_translate_non_digit_class(self):
+        """Test translating non-digit shorthand."""
+        result = translate_regex("\\D")
+        assert "non-digit" in result.lower() or "non digit" in result.lower()
+
+    def test_translate_word_class(self):
+        """Test translating word character shorthand."""
+        result = translate_regex("\\w")
+        assert "word" in result.lower()
+
+    def test_translate_whitespace_class(self):
+        """Test translating whitespace shorthand."""
+        result = translate_regex("\\s")
+        assert "whitespace" in result.lower()
+
+    def test_translate_plus_quantifier(self):
+        """Test translating plus quantifier."""
+        result = translate_regex("a+")
+        assert "one or more" in result.lower() or "1 or more" in result.lower()
+
+    def test_translate_star_quantifier(self):
+        """Test translating star quantifier."""
+        result = translate_regex("b*")
+        assert "zero or more" in result.lower() or "0 or more" in result.lower()
+
+    def test_translate_question_quantifier(self):
+        """Test translating question mark quantifier."""
+        result = translate_regex("c?")
+        assert "optional" in result.lower() or "0 or 1" in result.lower()
+
+    def test_translate_range_quantifier(self):
+        """Test translating range quantifier."""
+        result = translate_regex("a{2,5}")
+        assert "between" in result.lower() and ("2" in result or "2" in result.lower())
+
+    def test_translate_exact_quantifier(self):
+        """Test translating exact count quantifier."""
+        result = translate_regex("x{3}")
+        assert "exactly" in result.lower() and "3" in result
+
+    def test_translate_lazy_quantifier(self):
+        """Test translating lazy quantifier."""
+        result = translate_regex(".+?")
+        assert "lazy" in result.lower()
+
+    def test_translate_capturing_group(self):
+        """Test translating a capturing group."""
+        result = translate_regex("(test)")
+        assert "capturing" in result.lower() or "group" in result.lower()
+
+    def test_translate_non_capturing_group(self):
+        """Test translating a non-capturing group."""
+        result = translate_regex("(?:test)")
+        assert "non-capturing" in result.lower()
+
+    def test_translate_named_group(self):
+        """Test translating a named group."""
+        result = translate_regex("(?P<name>test)")
+        assert "name" in result.lower() or "named" in result.lower()
+
+    def test_translate_lookahead(self):
+        """Test translating a positive lookahead."""
+        result = translate_regex("(?=test)")
+        assert "followed" in result.lower()
+
+    def test_translate_negative_lookahead(self):
+        """Test translating a negative lookahead."""
+        result = translate_regex("(?!test)")
+        assert "not followed" in result.lower() or "not" in result.lower()
+
+    def test_translate_lookbehind(self):
+        """Test translating a lookbehind."""
+        result = translate_regex("(?<=test)")
+        assert "preceded" in result.lower()
+
+    def test_translate_negative_lookbehind(self):
+        """Test translating a negative lookbehind."""
+        result = translate_regex("(?<!test)")
+        assert "not preceded" in result.lower()
+
+    def test_translate_anchor_start(self):
+        """Test translating a start anchor."""
+        result = translate_regex("^start")
+        assert "start" in result.lower()
+
+    def test_translate_anchor_end(self):
+        """Test translating an end anchor."""
+        result = translate_regex("end$")
+        assert "end" in result.lower()
+
+    def test_translate_word_boundary(self):
+        """Test translating a word boundary."""
+        result = translate_regex("\\bword\\b")
+        assert "word boundary" in result.lower()
+
+    def test_translate_dot(self):
+        """Test translating a dot."""
+        result = translate_regex(".")
+        assert "any" in result.lower() and "character" in result.lower()
+
+    def test_translate_alternation(self):
+        """Test translating alternation."""
+        result = translate_regex("cat|dog")
+        assert "cat" in result.lower() or "dog" in result.lower()
+
+    def test_translate_complex_pattern(self):
+        """Test translating a complex pattern."""
+        pattern = r"^\d{3}-\d{4}$"
+        result = translate_regex(pattern)
+
+        assert len(result) > 0
+        assert "digit" in result.lower() or "3" in result
+
+    def test_translate_email_pattern(self):
+        """Test translating an email pattern."""
+        pattern = r"[a-z]+@[a-z]+\.[a-z]+"
+        result = translate_regex(pattern)
+
+        assert "any" in result.lower() or "@" in result
+
+    def test_translate_url_pattern(self):
+        """Test translating a URL pattern."""
+        pattern = r"https?://[^\\s]+"
+        result = translate_regex(pattern)
+
+        assert len(result) > 0
+
+    def test_translate_escaped_char(self):
+        """Test translating an escaped character."""
+        result = translate_regex("\\.")
+        assert "." in result or "period" in result.lower()
+
+    def test_translate_whitespace_literal(self):
+        """Test translating a literal space."""
+        result = translate_regex(" ")
+        assert "space" in result.lower()
+
+    def test_translate_tab_literal(self):
+        """Test translating a tab character."""
+        result = translate_regex("\\t")
+        assert "escape" in result.lower() or "\\t" in result or "tab" in result.lower()
+
+    def test_translate_backreference(self):
+        """Test translating a backreference."""
+        result = translate_regex(r"(a)\\1")
+        assert "same as" in result.lower() or "capture" in result.lower() or "\\1" in result
+
+    def test_translate_empty_pattern(self):
+        """Test translating an empty pattern."""
+        result = translate_regex("")
+        assert len(result) >= 0
+
+    def test_translate_with_js_flavor(self):
+        """Test translating with JavaScript flavor."""
+        result = translate_regex("test", flavor="javascript")
+        assert len(result) > 0
+
+    def test_translate_with_python_flavor(self):
+        """Test translating with Python flavor."""
+        result = translate_regex("test", flavor="python")
+        assert len(result) > 0
+
+
+class TestRegexTranslatorClass:
+    """Test the RegexTranslator class directly."""
+
+    def test_translator_initialization(self):
+        """Test translator initialization with default flavor."""
+        translator = RegexTranslator()
+        assert translator.flavor == "pcre"
+
+    def test_translator_custom_flavor(self):
+        """Test translator initialization with custom flavor."""
+        translator = RegexTranslator("javascript")
+        assert translator.flavor == "javascript"
+
+    def test_translate_returns_string(self):
+        """Test that translate returns a string."""
+        translator = RegexTranslator()
+        result = translator.translate("test")
+        assert isinstance(result, str)
+
+    def test_translate_empty_sequence(self):
+        """Test translating an empty sequence node."""
+        from regex_humanizer.parser import RegexParser, NodeType, RegexNode
+
+        parser = RegexParser("")
+        ast = parser.parse()
+        translator = RegexTranslator()
+
+        result = translator._translate_node(ast)
+        assert isinstance(result, str)