def before(self) -> RegularExpression: try: start = self.start_index() parts_before = self.expression.parts()[:start] return RegularExpression(parts_before) except IndexError: return RegularExpression("")
def within(self) -> RegularExpression: try: start, end = self.indices() parts_within = self.expression.parts()[start + 1:end] return RegularExpression(parts_within) except IndexError: return RegularExpression("")
def after(self) -> RegularExpression: try: start, end = self.indices() parts_after = self.expression.parts()[end + 1:] return RegularExpression(parts_after) except IndexError: return self.expression
def __init__(self, expression: Union[RegularExpression, str], latest: int = 0): if isinstance(expression, str): expression = RegularExpression(expression) self.expression = expression self.latest = latest
def test_quantifiers(self): assert RegularExpression("**??++?+?*").parts() == [ "*", "*", "?", "?", "+", "+", "?", "+", "?", "*", ]
def test_braces(self): # Braces assert RegularExpression("(").parts() == ["("] assert RegularExpression("()").parts() == ["(", ")"] assert RegularExpression(")))(").parts() == [")", ")", ")", "("] # Brackets assert RegularExpression("[").parts() == ["["] assert RegularExpression("[]").parts() == ["[", "]"] assert RegularExpression("]]][").parts() == ["]", "]", "]", "["]
def test_between(self): quantifier = QuantifierFactory.get(RegularExpression("{5,6}")) assert quantifier.quantify(String("4")) == "44444"
def test_exactly(self): quantifier = QuantifierFactory.get(RegularExpression("{3}")) assert quantifier.quantify(String("4")) == "444"
def test_question_mark(self): quantifier = QuantifierFactory.get(RegularExpression("?")) assert quantifier.quantify(String("4")) == ""
def all(self) -> RegularExpression: start, end = self.indices() parts = self.expression.parts()[start:end + 1] return RegularExpression(parts)
def test_nested_hierarchies(self): assert list(Peeler(RegularExpression("((abc))"))) == ["((abc))"]
def test_hierarchies_of_same_level_when_group_content_is_equal(self): assert list(Peeler( RegularExpression("(abc)f(abc)"))) == ["(abc)", "f", "(abc)"]
def test_hierarchies_one_after_another(self): assert list(Peeler( RegularExpression("(abc)(abc)"))) == ["(abc)", "(abc)"]
def test_plus(self): quantifier = QuantifierFactory.get(RegularExpression("+")) assert quantifier.quantify(String("4")) == "4"
def test_value_or_more(self): quantifier = QuantifierFactory.get(RegularExpression("{4,}")) assert quantifier.quantify(String("4")) == "4444"
def test_fixed_quantifiers(self): assert RegularExpression("a{0}").parts() == ["a", "{0}"] assert RegularExpression("a{0,}").parts() == ["a", "{0,}"] assert RegularExpression("a{,0}").parts() == ["a", "{,0}"] assert RegularExpression("a{0,0}").parts() == ["a", "{0,0}"]
def test_exists(self): assert not Braces.exists(RegularExpression("ab")) assert Braces.exists(RegularExpression("ab()"))
def test_value_or_less(self): quantifier = QuantifierFactory.get(RegularExpression("{,4}")) assert quantifier.quantify(String("4")) == ""
def test_character_sets(self): assert RegularExpression("a-zA-Z").parts() == ["a-z", "A-Z"]
def def_test_single_hierarchy(self): assert list(Peeler(RegularExpression("(abc)"))) == ["(abc)"]
def test_complex_regular_expressions(self): assert RegularExpression("(abc)+").parts() == ["(", "abc", ")", "+"] assert RegularExpression("[^A-Zd]+?").parts() == [ "[", "^", "A-Z", "d", "]", "+", "?" ]
def test_hierarchies_of_same_level(self): assert list(Peeler( RegularExpression("(abc)d(efg)"))) == ["(abc)", "d", "(efg)"]
def test_string_between_braces(self): assert RegularExpression("(abc)f(abc)").parts() == [ "(", "abc", ")", "f", "(", "abc", ")" ]
def test_hierarchies_of_same_level_of_different_types_of_braces(self): assert (list(Peeler(RegularExpression("(abc)[0-9A-Zf]{6,}"))) == [ "(abc)", "[0-9A-Zf]", "{6,}" ])
def test_string(self): assert RegularExpression("abc").parts() == ["abc"] assert RegularExpression("abc4").parts() == ["abc4"]
def test_no_hierarchy(self): assert list(Peeler(RegularExpression("abc+"))) == ["abc", "+"]
def simple(self) -> str: """Minimal string that would match a given expression.""" return str(Composer(RegularExpression(self.expression)).enter())