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())
