def test_create_wrapper_full(self):
data = {
"name": "test",
"rxtype_name": "re",
"child_types": ["alpha_lower", "digit"],
"child_count": 3,
"is_modifiable": False,
"strip_child_mods": True,
"uniform_child_types": True,
"display_function_name": "or",
"compile_function_name": "or",
}
wrappers = RxWrapperSet(self.char_sets, init_wrappers=False)
wrapper = wrappers.create_wrapper(**data)
mock_node = MockNode(children=[
MockNode(_d("f"), _d("f")),
MockNode(_d("j"), _d("j")),
])
self.assertEqual(wrapper.name, data["name"])
self.assertEqual(wrapper.rxtype.name, data["rxtype_name"])
self.assertEqual(wrapper.child_types, data["child_types"])
self.assertEqual(wrapper.child_count, data["child_count"])
self.assertFalse(wrapper.is_modifiable)
self.assertTrue(wrapper.strip_child_mods)
self.assertTrue(wrapper.uniform_child_types)
self.assertEqual(wrapper.display_function(mock_node), d_or(mock_node))
self.assertIn(wrapper.compile_function(mock_node), ["f", "j"])
def create_wrapper(
self,
name: str,
rxtype_name: str,
child_types: Optional[Sequence[str]] = None,
child_count: Optional[int] = None,
is_modifiable: Optional[bool] = None,
strip_child_mods: Optional[bool] = None,
uniform_child_types: Optional[bool] = None,
compile_function_name: Optional[str] = None,
display_function_name: Optional[str] = None,
is_char_set: Optional[bool] = None,
display_value: Optional[str] = None,
char_value: Optional[str] = None,
char_set: Optional[Iterable[str]] = None,
) -> RxWrapper:
func_name = self.get_wrapper_func_name(name)
display_value = display_value or char_value
if display_value:
display_value = display_value.format(char_value)
else:
if (display_function_name not in rxwrapper_functions["display"]
and func_name not in rxwrapper_functions["display"]):
raise TypeError(
"valid display function name or display value required")
if (compile_function_name not in rxwrapper_functions["compile"]
and func_name not in rxwrapper_functions["compile"]):
raise TypeError(
"valid compile function name or display value required")
rxtype = self._rxtypes[rxtype_name]
display_function = rxwrapper_functions["display"].get(
display_function_name or func_name, _d(display_value))
compile_function = rxwrapper_functions["compile"].get(
compile_function_name or func_name, _d(display_value))
if is_char_set:
if not char_value:
raise TypeError("char set wrappers require a char value")
name = f"{name}({char_value})"
return RxWrapper(
name,
display_function,
rxtype,
child_types,
child_count,
is_modifiable,
compile_function,
strip_child_mods,
uniform_child_types,
)
def test_create_wrapper_defaults_func_name(self):
wrappers = RxWrapperSet(self.char_sets, init_wrappers=False)
set_wrapper = wrappers.create_wrapper("set", "re")
mock_node = MockNode(children=[
MockNode(_d("a"), _d("a"), rxtype=RxType("test")),
], )
self.assertEqual(set_wrapper.display_function(mock_node),
d_set(mock_node))
self.assertEqual(set_wrapper.compile_function(mock_node),
c_set(mock_node))
def test_expand_set_range(self):
mock_node = MockNode(
name="range",
char_sets=self.char_sets,
children=[
MockNode(_d("f"), _d("f")),
MockNode(_d("j"), _d("j")),
],
)
result = expand_set(mock_node)
self.assertSetEqual(result, set(["f", "g", "h", "i", "j"]))
def test__d_meta(self):
data = r"\d"
result = _d(data)(None)
self.assertEqual(result, data)
def test__d(self):
data = "a"
result = _d(data)(None)
self.assertEqual(result, data)