#37 support Optional / Union types in provides_nodes.

Restore assert_asts_are_equal erroneously removed in the previous commit

Author: alessiostalla

.github/workflows/pythonapp.yml

@@ -6,7 +6,7 @@ jobs:
   build:
     strategy:
       matrix:
-        python: [ '3.7', '3.8', '3.9', '3.10', '3.11', '3.12' ]
+        python: [ 3.8', '3.9', '3.10', '3.11', '3.12' ]
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4

pylasu/model/model.py

@@ -1,11 +1,12 @@
 import inspect
 from abc import ABC, abstractmethod, ABCMeta
 from dataclasses import Field, MISSING, dataclass, field
-from typing import Optional, Callable, List
+from typing import Optional, Callable, List, Union
 
 from .position import Position, Source
 from .reflection import Multiplicity, PropertyDescription
 from ..reflection import getannotations, get_type_arguments, is_sequence_type
+from ..reflection.reflection import get_type_origin
 
 
 class internal_property(property):
@@ -79,7 +80,19 @@ def is_internal_property_or_method(value):
 
 
 def provides_nodes(decl_type):
-    return isinstance(decl_type, type) and issubclass(decl_type, Node)
+    if get_type_origin(decl_type) is Union:
+        provides = None
+        for tp in get_type_arguments(decl_type):
+            if tp is type(None):
+                continue
+            arg_provides = provides_nodes(tp)
+            if provides is None:
+                provides = arg_provides
+            elif provides != arg_provides:
+                raise Exception(f"Type {decl_type} mixes nodes and non-nodes")
+        return provides
+    else:
+        return isinstance(decl_type, type) and issubclass(decl_type, Node)
 
 
 class Concept(ABCMeta):

pylasu/model/traversing.py

@@ -60,6 +60,7 @@ def walk_descendants(self: Node, walker=walk, restrict_to=Node):
 
 T = TypeVar("T")
 
+
 @extension_method(Node)
 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.

pylasu/testing/testing.py

@@ -0,0 +1,67 @@
+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/model/test_model.py

@@ -1,6 +1,6 @@
 import dataclasses
 import unittest
-from typing import List
+from typing import List, Optional, Union
 
 from pylasu.model import Node, Position, Point
 from pylasu.model.reflection import Multiplicity
@@ -15,6 +15,7 @@ class SomeNode(Node, Named):
     __private__ = 4
     ref: Node = None
     multiple: List[Node] = dataclasses.field(default_factory=list)
+    multiple_opt: List[Optional[Node]] = dataclasses.field(default_factory=list)
 
     def __post_init__(self):
         self.bar = 5
@@ -30,6 +31,14 @@ class AnotherSymbol(Symbol):
     index: int = dataclasses.field(default=None)
 
 
+@dataclasses.dataclass
+class InvalidNode(Node):
+    attr: int
+    child: SomeNode
+    invalid_prop: Union[Node, str] = None
+    another_child: Node = None
+
+
 class ModelTest(unittest.TestCase):
 
     def test_reference_by_name_unsolved_str(self):
@@ -150,15 +159,20 @@ def frob_node(_: Node):
             pass
 
         pds = [pd for pd in sorted(SomeNode.node_properties, key=lambda x: x.name)]
-        self.assertEqual(5, len(pds), f"{pds} should be 5")
+        self.assertEqual(6, len(pds), f"{pds} should be 6")
         self.assertEqual("bar", pds[0].name)
         self.assertFalse(pds[0].provides_nodes)
         self.assertEqual("foo", pds[1].name)
         self.assertFalse(pds[1].provides_nodes)
         self.assertEqual("multiple", pds[2].name)
         self.assertTrue(pds[2].provides_nodes)
         self.assertEqual(Multiplicity.MANY, pds[2].multiplicity)
-        self.assertEqual("name", pds[3].name)
-        self.assertFalse(pds[3].provides_nodes)
-        self.assertEqual("ref", pds[4].name)
-        self.assertTrue(pds[4].provides_nodes)
+        self.assertEqual("multiple_opt", pds[3].name)
+        self.assertTrue(pds[3].provides_nodes)
+        self.assertEqual(Multiplicity.MANY, pds[3].multiplicity)
+        self.assertEqual("name", pds[4].name)
+        self.assertFalse(pds[4].provides_nodes)
+        self.assertEqual("ref", pds[5].name)
+        self.assertTrue(pds[5].provides_nodes)
+
+        self.assertRaises(Exception, lambda: [x for x in InvalidNode.node_properties])