Bugfix group string generation

Bump to version 0.8.2

Author: Buba98

README.md

@@ -29,8 +29,7 @@ print(re.next()) # a2b
 ## What is supported
 
 - [x] Character classes
-- [x] Quantifiers for character classes
-- [x] Quantifiers for groups
+- [x] Quantifiers (greedy)
 - [x] Groups (named and unnamed)
 - [x] Alternation
 - [x] Escaped characters

regex_enumerator/regex_tree.py

@@ -209,6 +209,20 @@ def add_reference(self, reference: BackReference):
             return
         self.references.append(reference)
 
+    def _calculate_using_new_charset(self) -> set[str]:
+        assert not self.done
+        if self._done_repetition and self._done_charset:
+            self.done = True
+
+        if self._index_repetition + self._min_len == 0:
+            return {''}
+
+        result = set(self._current_chars)
+        for _ in range(1, self._min_len + self._index_repetition):
+            result.update({pfx + sfx for pfx in result for sfx in self._current_chars})
+                
+        return result
+
     def next(self) -> set[str]:
         assert not self.done
 
@@ -219,12 +233,13 @@ def next(self) -> set[str]:
 
         if self._gen_charset:
             _: set[str] = self._next_charset()
-            # optimize it by using only the new charset
+            # Optimization: use the new charset to calculate the next set of strings
+            res: set[str] = self._calculate_using_new_charset()
         else:
             if not self._done_repetition:
                 self._index_repetition += 1
+            res: set[str] = self._calculate()
 
-        res: set[str] = self._calculate()
         self._gen_charset = not self._gen_charset
         new_res = res - self.current
         if len(new_res) == 0:

setup.py

@@ -5,7 +5,7 @@
 
 setup(
     name='regex_enumerator',
-    version='0.8.1',
+    version='0.8.2',
     packages=find_packages(include=['regex_enumerator', 'regex_enumerator.*']),
     description='Enumerate all strings that match a given regex',
     author='Vincenzo Greco',

tests/test_alternative.py

@@ -42,3 +42,24 @@ def test_alternative_with_character_class_and_literal():
     possibilities = ['', 'd']
 
     f_finite(regexEnumerator, possibilities)
+
+
+def test_alternation_with_character_classes_and_literals():
+    regexEnumerator = RegexEnumerator(r'(a|[0-2])')
+    possibilities = ['a', '0', '1', '2']
+
+    f_finite(regexEnumerator, possibilities)
+
+
+def test_nested_alternation():
+    regexEnumerator = RegexEnumerator(r'((a|b)|c)')
+    possibilities = ['a', 'b', 'c']
+    
+    f_finite(regexEnumerator, possibilities)
+
+
+def test_alternation_with_grouping():
+    regexEnumerator = RegexEnumerator(r'(a(b|c)d|x)')
+    possibilities = ['abd', 'acd', 'x']
+    
+    f_finite(regexEnumerator, possibilities)

tests/test_backreference.py

@@ -43,8 +43,41 @@ def test_zero_width_backreference():
 
     f_finite(regexEnumerator, possibilities)
 
+
 def test_10_backreference():
     regexEnumerator = RegexEnumerator(r'(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)\10')
     possibilities = ['abcdefghijj']
 
     f_finite(regexEnumerator, possibilities)
+
+
+def test_multiple_backreferences():
+    regexEnumerator = RegexEnumerator(r'(a)(b)\2\1')
+    possibilities = ['abba']
+
+    f_finite(regexEnumerator, possibilities)
+
+
+def test_backreference_with_mismatch():
+    regexEnumerator = RegexEnumerator(r'(a)(b)\1')
+    possibilities = ['aba']
+
+    f_finite(regexEnumerator, possibilities)
+
+
+def test_named_group_with_backreference():
+    regexEnumerator = RegexEnumerator(r'(?<letter>[ab])\k<letter>')
+    possibilities = [
+        'aa', 'bb'
+    ]
+
+    f_finite(regexEnumerator, possibilities)
+
+
+def test_named_group_infinite_repetition_with_backreference():
+    regexEnumerator = RegexEnumerator(r'(?<letter>[ab])+\k<letter>')
+    possibilities = [
+        'aa', 'bb', 'abab', 'baba', 'aaaa', 'bbbb'
+    ]
+
+    f_infinite(regexEnumerator, possibilities)

tests/test_char_classes.py

@@ -114,3 +114,12 @@ def test_unicode_character_class():
     possibilities = ['à', 'á', 'â', 'ã', 'ä', 'å']
 
     f_finite(regexEnumerator, possibilities)
+
+
+def test_additional_charset():
+    regexEnumerator = RegexEnumerator(
+        r'[^\w\d\s]', additional_charset=['γ', 'β', 'α'])
+    possibilities = ['!', '"', '#', '$', '%', '&', "'", '(', ')', '*', '+', ',', '-', '.', '/', ':',
+                     ';', '<', '=', '>', '?', '@', '[', '\\', ']', '^', '`', '{', '|', '}', '~', 'α', 'β', 'γ']
+
+    f_finite(regexEnumerator, possibilities)

tests/test_groups.py

@@ -2,64 +2,105 @@
 from .test_function import f_finite, f_infinite
 
 
-def test_single_group_literal_char():
+def test_single_capturing_group_with_literal():
     regexEnumerator = RegexEnumerator(r'(a)')
     possibilities = ['a']
 
     f_finite(regexEnumerator, possibilities)
 
 
-def test_single_character_class():
+def test_single_capturing_group_with_class_single_char():
     regexEnumerator = RegexEnumerator(r'([a])')
     possibilities = ['a']
 
     f_finite(regexEnumerator, possibilities)
 
 
-def test_multiple_character_class():
+def test_single_capturing_group_with_class_multi_char():
     regexEnumerator = RegexEnumerator(r'([a-c])')
     possibilities = ['a', 'b', 'c']
 
     f_finite(regexEnumerator, possibilities)
 
 
-def test_group_with_zero_or_more_quantifier():
+def test_capturing_group_with_star_quantifier():
     regexEnumerator = RegexEnumerator(r'(a)*')
     possibilities = ['', 'a', 'aa', 'aaa', 'aaaa', 'aaaaa']
 
     f_infinite(regexEnumerator, possibilities)
 
 
-def test_named_group():
+def test_named_capturing_group_with_optional_subgroup():
     regexEnumerator = RegexEnumerator(r'(?<name>a[bcd](e)?)')
     possibilities = ['ab', 'abe', 'ac', 'ace', 'ad', 'ade']
 
     f_finite(regexEnumerator, possibilities)
 
 
-def test_group_with_range_quantifier_after_literal():
+def test_literal_followed_by_group_with_star_quantifier():
     regexEnumerator = RegexEnumerator(r'a(b)*')
     possibilities = ['a' + 'b' * i for i in range(6)]
 
     f_infinite(regexEnumerator, possibilities)
 
 
-def test_2_groups_with_range_quantifier():
+def test_two_capturing_groups_with_star_quantifiers():
     regexEnumerator = RegexEnumerator(r'(a)*(b)*')
     possibilities = ['a' * i + 'b' * j for i in range(6) for j in range(6)]
 
     f_infinite(regexEnumerator, possibilities)
 
 
-def test_nested_groups():
+def test_nested_capturing_groups():
     regexEnumerator = RegexEnumerator(r'(a(b(c)))')
     possibilities = ['abc']
 
     f_finite(regexEnumerator, possibilities)
 
 
-def test_group_of_groups():
+def test_capturing_groups_in_sequence():
     regexEnumerator = RegexEnumerator(r'((a)(b))')
     possibilities = ['ab']
 
     f_finite(regexEnumerator, possibilities)
+
+
+def test_non_capturing_group():
+    regexEnumerator = RegexEnumerator(r'(?:a|b)*')
+    possibilities = ['', 'a', 'b', 'aa', 'ab', 'ba', 'bb']
+
+    f_infinite(regexEnumerator, possibilities)
+
+
+def test_non_capturing_group_with_quantifier():
+    regexEnumerator = RegexEnumerator(r'(?:ab)+')
+    possibilities = ['ab', 'abab', 'ababab']
+
+    f_infinite(regexEnumerator, possibilities)
+
+
+def test_named_capturing_group_with_quantifier():
+    regexEnumerator = RegexEnumerator(r'(?<chars>[ab]{1,2})')
+    possibilities = ['a', 'b', 'aa', 'ab', 'ba', 'bb']
+
+    f_finite(regexEnumerator, possibilities)
+
+
+def test_nested_non_capturing_groups():
+    regexEnumerator = RegexEnumerator(r'(?:a(?:b(?:c)))?')
+    possibilities = ['', 'abc']
+
+    f_finite(regexEnumerator, possibilities)
+
+
+def test_group_for_quantifier_scope():
+    regexEnumerator = RegexEnumerator(r'(ab)+')
+    possibilities = ['ab', 'abab', 'ababab']
+
+    f_infinite(regexEnumerator, possibilities)
+
+def test_group_with_char_class_infinite_repetition():
+    regexEnumerator = RegexEnumerator(r'([ab])+')
+    possibilities = ['a', 'b', 'aa', 'ab', 'ba', 'bb']
+
+    f_infinite(regexEnumerator, possibilities)

tests/test_single_char.py renamed to tests/test_literals.py

@@ -2,80 +2,80 @@
 from .test_function import f_finite, f_infinite
 
 
-def test_empty_regex():
+def test_empty_pattern_yields_empty_string():
     regexEnumerator = RegexEnumerator(r'')
     possibilities = ['']
-
     f_finite(regexEnumerator, possibilities)
 
 
-def test_single_literal_char():
+def test_single_literal_character():
     regexEnumerator = RegexEnumerator(r'a')
     possibilities = ['a']
-
     f_finite(regexEnumerator, possibilities)
 
 
-def test_zero_or_more_quantifier():
+def test_zero_or_more_quantifier_on_single_char():
     regexEnumerator = RegexEnumerator(r'a*')
     possibilities = ['', 'a', 'aa', 'aaa', 'aaaa', 'aaaaa']
-
     f_infinite(regexEnumerator, possibilities)
 
 
-def test_one_or_more_quantifier():
+def test_one_or_more_quantifier_on_single_char():
     regexEnumerator = RegexEnumerator(r'a+')
     possibilities = ['a', 'aa', 'aaa', 'aaaa', 'aaaaa']
-
     f_infinite(regexEnumerator, possibilities)
 
 
-def test_zero_or_one_quantifier():
+def test_zero_or_one_quantifier_on_single_char():
     regexEnumerator = RegexEnumerator(r'a?')
     possibilities = ['', 'a']
-
     f_finite(regexEnumerator, possibilities)
 
 
-def test_exact_repetition_quantifier():
+def test_exact_repetition_quantifier_on_single_char():
     regexEnumerator = RegexEnumerator(r'a{2}')
     possibilities = ['aa']
-
     f_finite(regexEnumerator, possibilities)
 
 
-def test_min_repetition_quantifier():
+def test_minimum_repetition_quantifier_on_single_char():
     regexEnumerator = RegexEnumerator(r'a{2,}')
     possibilities = ['aa', 'aaa', 'aaaa', 'aaaaa']
-
     f_infinite(regexEnumerator, possibilities)
 
 
-def test_min_max_repetition_quantifier():
+def test_min_max_repetition_quantifier_on_single_char():
+    # `a{2,4}` yields 'aa', 'aaa', 'aaaa'.
     regexEnumerator = RegexEnumerator(r'a{2,4}')
     possibilities = ['aa', 'aaa', 'aaaa']
-
     f_finite(regexEnumerator, possibilities)
 
 
-def test_zero_repetition_quantifier():
+def test_zero_times_repetition_quantifier_on_single_char():
     regexEnumerator = RegexEnumerator(r'a{0}')
     possibilities = ['']
-
     f_finite(regexEnumerator, possibilities)
 
 
-def test_literal_special_characters():
+def test_escaped_literal_special_characters():
     regexEnumerator = RegexEnumerator(r'\*\+\?')
     possibilities = ['*+?']
+    f_finite(regexEnumerator, possibilities)
 
+
+def test_single_character_class():
+    regexEnumerator = RegexEnumerator(r'[abc]')
+    possibilities = ['a', 'b', 'c']
     f_finite(regexEnumerator, possibilities)
 
 
-def test_additional_charset():
-    regexEnumerator = RegexEnumerator(
-        r'[^\w\d\s]', additional_charset=['γ', 'β', 'α'])
-    possibilities = ['!', '"', '#', '$', '%', '&', "'", '(', ')', '*', '+', ',', '-', '.', '/', ':',
-                     ';', '<', '=', '>', '?', '@', '[', '\\', ']', '^', '`', '{', '|', '}', '~', 'α', 'β', 'γ']
+def test_single_escaped_character():
+    regexEnumerator = RegexEnumerator(r'\n')
+    possibilities = ['\n']
+    f_finite(regexEnumerator, possibilities)
+
 
+def test_literal_dot_character():
+    regexEnumerator = RegexEnumerator(r'\.')
+    possibilities = ['.']
     f_finite(regexEnumerator, possibilities)