#36 improve the type signature of find_ancestor_of_type

Author: alessiostalla

pylasu/model/traversing.py

@@ -1,3 +1,5 @@
+from typing import TypeVar, Type
+
 from . import Position
 from .model import Node
 from ..support import extension_method
@@ -56,8 +58,10 @@ def walk_descendants(self: Node, walker=walk, restrict_to=Node):
             yield node
 
 
+T = TypeVar("T")
+
 @extension_method(Node)
-def find_ancestor_of_type(self: Node, target: type):
+def find_ancestor_of_type(self: Node, target: Type[T]) -> T:
     """Returns the nearest ancestor of this node that is an instance of the target type.
 
     Note that type is not strictly forced to be a subtype of Node. This is intended to support trait types like

pylasu/testing/testing.py

@@ -1,67 +0,0 @@
-import unittest
-
-from pylasu.model import Node
-
-
-def assert_asts_are_equal(
-        case: unittest.TestCase,
-        expected: Node, actual: Node,
-        context: str = "<root>", consider_position: bool = False
-):
-    if expected.node_type != actual.node_type:
-        case.fail(f"{context}: expected node of type {expected.node_type}, "
-                  f"but found {actual.node_type}")
-    if consider_position:
-        case.assertEqual(expected.position, actual.position, f"{context}.position")
-    for expected_property in expected.properties:
-        try:
-            actual_property = next(filter(lambda p: p.name == expected_property.name, actual.properties))
-        except StopIteration:
-            case.fail(f"No property {expected_property.name} found at {context}")
-        actual_prop_value = actual_property.value
-        expected_prop_value = expected_property.value
-        if expected_property.provides_nodes:
-            if expected_property.multiple:
-                assert_multi_properties_are_equal(
-                    case, expected_property, expected_prop_value, actual_prop_value, context, consider_position)
-            else:
-                assert_single_properties_are_equal(case, expected_property, expected_prop_value, actual_prop_value,
-                                                   context, consider_position)
-        # TODO not yet supported elif expected_property.property_type == PropertyType.REFERENCE:
-        else:
-            case.assertEqual(
-                expected_prop_value, actual_prop_value,
-                f"{context}, comparing property {expected_property.name} of {expected.node_type}")
-
-
-def assert_single_properties_are_equal(case, expected_property, expected_prop_value, actual_prop_value, context,
-                                       consider_position):
-    if expected_prop_value is None and actual_prop_value is not None:
-        case.assertEqual(expected_prop_value, actual_prop_value,
-                         f"{context}.{expected_property.name}")
-    elif expected_prop_value is not None and actual_prop_value is None:
-        case.assertEqual(expected_prop_value, actual_prop_value,
-                         f"{context}.{expected_property.name}")
-    elif expected_prop_value is None and actual_prop_value is None:
-        # that is ok
-        pass
-    else:
-        case.assertIsInstance(actual_prop_value, Node)
-        assert_asts_are_equal(
-            case, expected_prop_value, actual_prop_value,
-            context=f"{context}.{expected_property.name}",
-            consider_position=consider_position)
-
-
-def assert_multi_properties_are_equal(case, expected_property, expected_prop_value, actual_prop_value, context,
-                                      consider_position):
-    # TODO IgnoreChildren
-    case.assertEqual(actual_prop_value is None, expected_prop_value is None,
-                     f"{context}.{expected_property.name} nullness")
-    if actual_prop_value is not None and expected_prop_value is not None:
-        case.assertEqual(len(actual_prop_value), len(expected_prop_value),
-                         f"{context}.{expected_property.name} length")
-    for expected_it, actual_it, i in \
-            zip(expected_prop_value, actual_prop_value, range(len(expected_prop_value))):
-        assert_asts_are_equal(case, expected_it, actual_it, f"{context}[{i}]",
-                              consider_position=consider_position)

tests/test_traversing.py

@@ -1,7 +1,8 @@
 import unittest
 
 from pylasu.model import pos
-from tests.fixtures import box
+from pylasu.model.traversing import find_ancestor_of_type
+from tests.fixtures import box, Box
 
 
 class TraversingTest(unittest.TestCase):
@@ -42,3 +43,8 @@ def test_walk_ancestors(self):
         box.assign_parents()
         item4 = box.contents[2].contents[0].contents[1]
         self.assertEqual(["small", "big", "root"], [n.name for n in item4.walk_ancestors()])
+
+    def test_find_ancestor_of_type(self):
+        box.assign_parents()
+        item = box.contents[1]
+        self.assertEqual(box, find_ancestor_of_type(item, Box))