Refactor Collector to use meta inheritance and add tests

Author: Евгений Блинов

cstvis/collector.py

@@ -1,17 +1,19 @@
-from dataclasses import dataclass, field
 from functools import partial
 from typing import Any, Callable, Dict, List, Optional, Union
 
 from libcst import CSTNode
+from printo import repred
 
 from cstvis.dto import Context
 from cstvis.wrapper import CallableWrapper
 
 
-@dataclass
+@repred(getters={'meta': lambda x: x._meta}, filters={'meta': lambda x: x})
 class Collector:
-    _filters: List[CallableWrapper[bool]] = field(default_factory=list)
-    _converters: List[CallableWrapper[CSTNode]] = field(default_factory=list)
+    def __init__(self, meta: Optional[Dict[str, Any]] = None) -> None:
+        self._meta: Dict[str, Any] = meta if meta else {}
+        self._filters: List[CallableWrapper[bool]] = []
+        self._converters: List[CallableWrapper[CSTNode]] = []
 
     def __add__(self, other: 'Collector') -> 'Collector':
         if not isinstance(other, type(self)):
@@ -30,12 +32,21 @@ def filter(self, function: Optional[Union[Callable[[CSTNode], bool], Callable[[C
         if function is None:
             return partial(self.filter, meta=meta)  # type: ignore[return-value]
 
-        self._filters.append(CallableWrapper(function, meta=meta))
+        self._add_to_collection(function, meta, self._filters)
         return function
 
     def converter(self, function: Optional[Union[Callable[[CSTNode], CSTNode], Callable[[CSTNode, Context], CSTNode]]] = None, meta: Optional[Dict[str, Any]] = None) -> Union[Union[Callable[[CSTNode], CSTNode], Callable[[CSTNode, Context], CSTNode]], Callable[[Union[Callable[[CSTNode], CSTNode], Callable[[CSTNode, Context], CSTNode]]], Union[Callable[[CSTNode], CSTNode], Callable[[CSTNode, Context], CSTNode]]]]:
         if function is None:
             return partial(self.converter, meta=meta)  # type: ignore[return-value]
 
-        self._converters.append(CallableWrapper(function, meta=meta))
+        self._add_to_collection(function, meta, self._converters)
         return function
+
+    def _add_to_collection(self, function, meta, collection) -> None:
+        if meta is not None:
+            meta = meta.copy()
+            meta.update(self._meta)
+        elif self._meta:
+            meta = self._meta.copy()
+
+        collection.append(CallableWrapper(function, meta=meta))

tests/test_collector.py

@@ -84,3 +84,69 @@ def test_add_wrong_things_to_collector():
 
     with pytest.raises(TypeError, match=match('Collector objects can only be added to other collector objects.')):
         Collector() + 'kek'
+
+
+def test_repr():
+    assert repr(Collector()) == 'Collector()'
+    assert repr(Collector(meta={'lol': 'kek'})) == "Collector(meta={'lol': 'kek'})"
+
+
+def test_meta_for_collector_but_not_for_converter_or_filter():
+    meta = {'lol': 'kek'}
+    collector = Collector(meta=meta)
+
+    @collector.converter
+    def some_converter(node, context):  # noqa: ARG001
+        return node
+
+    @collector.filter
+    def some_filter(node, context):  # noqa: ARG001
+        return False
+
+    collector._converters[0].meta == meta
+    collector._converters[0].meta is not meta
+
+    collector._filters[0].meta == meta
+    collector._filters[0].meta is not meta
+
+
+def test_meta_for_converter_or_filter_but_not_for_collector():
+    meta = {'lol': 'kek'}
+    collector = Collector()
+
+    @collector.converter(meta=meta)
+    def some_converter(node, context):  # noqa: ARG001
+        return node
+
+    @collector.filter(meta=meta)
+    def some_filter(node, context):  # noqa: ARG001
+        return False
+
+    collector._converters[0].meta == meta
+    collector._converters[0].meta is not meta
+
+    collector._filters[0].meta == meta
+    collector._filters[0].meta is not meta
+
+
+def test_meta_for_for_converter_or_filter_and_for_collector():
+    meta_1 = {'lol_1': 'kek_1', 'lol_2': 'kek_2'}
+    meta_2 = {'lol_2': 'kek_2-2', 'lol_3': 'kek_3'}
+
+    collector = Collector(meta=meta_1)
+
+    @collector.converter(meta=meta_2)
+    def some_converter(node, context):  # noqa: ARG001
+        return node
+
+    @collector.filter(meta=meta_2)
+    def some_filter(node, context):  # noqa: ARG001
+        return False
+
+    collector._converters[0].meta == {'lol_1': 'kek_1', 'lol_2': 'kek_2-2', 'lol_3': 'kek_3'}
+    collector._converters[0].meta is not meta_1
+    collector._converters[0].meta is not meta_2
+
+    collector._filters[0].meta == {'lol_1': 'kek_1', 'lol_2': 'kek_2-2', 'lol_3': 'kek_3'}
+    collector._filters[0].meta is not meta_1
+    collector._filters[0].meta is not meta_2