remove abstract layout and rename Layout.trigger to Layout.dispatch

rmorshea · rmorshea · commit 111bda3589ea · 2020-09-03T00:17:20.000-07:00
diff --git a/docs/source/core-concepts.rst b/docs/source/core-concepts.rst
@@ -73,7 +73,7 @@ ever be removed from the model. Then you'll just need to call and await a
 The layout also handles the triggering event handlers. Normally this is done
 automatically by a :ref:`Renderer <Layout Renderer>`, but for now we'll to it manually.
 To do use we can use a trick to hard-code the ``event_handler_id`` so we can pass it,
-and a fake event, to the layout's :meth:`~idom.core.layout.Layout.trigger` method. Then
+and a fake event, to the layout's :meth:`~idom.core.layout.Layout.dispatch` method. Then
 we just have to re-render the layout and see what changed:
 
 .. testcode::
@@ -102,7 +102,7 @@ we just have to re-render the layout and see what changed:
         patch_1 = await layout.render()
 
         fake_event = LayoutEvent(event_handler_id, [{}])
-        await layout.trigger(fake_event)
+        await layout.dispatch(fake_event)
         patch_2 = await layout.render()
 
         for change in patch_2.changes:
diff --git a/idom/core/__init__.py b/idom/core/__init__.py
@@ -1,12 +1,12 @@
 from .element import element, Element, AbstractElement, ElementConstructor
 from .events import event, Events, EventHandler
-from .layout import Layout, AbstractLayout
+from .layout import Layout, Layout
 from .render import AbstractRenderer, SharedStateRenderer, SingleStateRenderer
 from .vdom import vdom
 
 __all__ = [
     "AbstractElement",
-    "AbstractLayout",
+    "Layout",
     "AbstractRenderer",
     "element",
     "Element",
diff --git a/idom/core/layout.py b/idom/core/layout.py
@@ -38,15 +38,18 @@ class LayoutEvent(NamedTuple):
     """A list of event data passed to the event handler."""
 
 
-class AbstractLayout(HasAsyncResources, abc.ABC):
-    """Renders the models generated by :class:`AbstractElement` objects.
+class ElementState(NamedTuple):
+    model: Dict[str, Any]
+    path: List[int]
+    element_obj: AbstractElement
+    event_handler_ids: Set[str]
+    child_elements_ids: List[str]
+    life_cycle_hook: LifeCycleHook
 
-    Parameters:
-        root: The root element of the layout.
-        loop: What loop the layout should be using to schedule tasks.
-    """
 
-    __slots__ = ["_loop", "_root"]
+class Layout(HasAsyncResources):
+
+    __slots__ = ["_root", "_event_handlers"]
 
     if not hasattr(abc.ABC, "__weakref__"):  # pragma: no cover
         __slots__.append("__weakref__")
@@ -55,71 +58,23 @@ def __init__(
         self, root: "AbstractElement", loop: Optional[asyncio.AbstractEventLoop] = None
     ) -> None:
         super().__init__()
-        if loop is None:
-            loop = asyncio.get_event_loop()
         if not isinstance(root, AbstractElement):
             raise TypeError("Expected an AbstractElement, not %r" % root)
-        self._loop = loop
         self._root = root
-
-    @property
-    def loop(self) -> asyncio.AbstractEventLoop:
-        """The event loop the layout is using."""
-        return self._loop
+        self._event_handlers: Dict[str, EventHandler] = {}
 
     @property
     def root(self) -> str:
         """Id of the root element."""
         return self._root.id
 
-    @abc.abstractmethod
-    async def render(self) -> LayoutUpdate:
-        """Await an update to the model."""
-
-    @abc.abstractmethod
-    def update(self, element: AbstractElement) -> None:
-        """Schedule the element to be re-renderer."""
-
-    @abc.abstractmethod
-    async def trigger(self, event: LayoutEvent) -> None:
-        """Trigger an event handler
-
-        Parameters:
-            event: Event data passed to the event handler.
-        """
-
-    def __repr__(self) -> str:
-        return f"{type(self).__name__}({self._root})"
-
-
-class ElementState(NamedTuple):
-    model: Dict[str, Any]
-    path: List[int]
-    element_obj: AbstractElement
-    event_handler_ids: Set[str]
-    child_elements_ids: List[str]
-    life_cycle_hook: LifeCycleHook
-
-
-class Layout(AbstractLayout):
-
-    __slots__ = "_event_handlers", "_rendering_queue"
-
-    def __init__(
-        self, root: "AbstractElement", loop: Optional[asyncio.AbstractEventLoop] = None
-    ) -> None:
-        super().__init__(root, loop)
-        self._event_handlers: Dict[str, EventHandler] = {}
-        self._rendering_queue = _ElementQueue()
-        self._rendering_queue.put(self._root)
-
     def update(self, element: "AbstractElement") -> None:
         try:
             self._rendering_queue.put(element)
         except CannotAccessResource:
             logger.info(f"Did not update {element} - resources of {self} are closed")
 
-    async def trigger(self, event: LayoutEvent) -> None:
+    async def dispatch(self, event: LayoutEvent) -> None:
         # It is possible for an element in the frontend to produce an event
         # associated with a backend model that has been deleted. We only handle
         # events if the element and the handler exist in the backend. Otherwise
@@ -134,6 +89,12 @@ async def render(self) -> Dict[str, Any]:
             if element.id in self._element_states:
                 return await self._create_layout_update(element)
 
+    @async_resource
+    async def _rendering_queue(self) -> AsyncIterator["_ElementQueue"]:
+        queue = _ElementQueue()
+        queue.put(self._root)
+        yield queue
+
     @async_resource
     async def _element_states(self) -> AsyncIterator[ElementState]:
         root_element_state = self._create_element_state(self._root, "")
diff --git a/idom/core/render.py b/idom/core/render.py
@@ -7,8 +7,8 @@
 from .layout import (
     LayoutEvent,
     LayoutUpdate,
-    AbstractLayout,
-    AbstractLayout,
+    Layout,
+    Layout,
 )
 from .utils import HasAsyncResources, async_resource
 
@@ -23,12 +23,12 @@ class StopRendering(Exception):
 class AbstractRenderer(HasAsyncResources, abc.ABC):
     """A base class for implementing :class:`~idom.core.layout.Layout` renderers."""
 
-    def __init__(self, layout: AbstractLayout) -> None:
+    def __init__(self, layout: Layout) -> None:
         super().__init__()
         self._layout = layout
 
     @async_resource
-    async def layout(self) -> AsyncIterator[AbstractLayout]:
+    async def layout(self) -> AsyncIterator[Layout]:
         async with self._layout as layout:
             yield layout
 
@@ -40,7 +40,7 @@ async def task_group(self) -> AsyncIterator[TaskGroup]:
     async def run(self, send: SendCoroutine, recv: RecvCoroutine, context: Any) -> None:
         """Start an unending loop which will drive the layout.
 
-        This will call :meth:`AbstractLayouTaskGroupTaskGroupt.render` and :meth:`AbstractLayout.trigger`
+        This will call :meth:`AbstractLayouTaskGroupTaskGroupt.render` and :meth:`Layout.dispatch`
         to render new models and execute events respectively.
         """
         await self.task_group.spawn(self._outgoing_loop, send, context)
@@ -56,13 +56,11 @@ async def _incoming_loop(self, recv: RecvCoroutine, context: Any) -> None:
             await self._incoming(self.layout, context, await recv())
 
     @abc.abstractmethod
-    async def _outgoing(self, layout: AbstractLayout, context: Any) -> Any:
+    async def _outgoing(self, layout: Layout, context: Any) -> Any:
         ...
 
     @abc.abstractmethod
-    async def _incoming(
-        self, layout: AbstractLayout, context: Any, message: Any
-    ) -> None:
+    async def _incoming(self, layout: Layout, context: Any, message: Any) -> None:
         ...
 
 
@@ -74,17 +72,15 @@ class SingleStateRenderer(AbstractRenderer):
         be ``None`` since it's not used.
     """
 
-    def __init__(self, layout: AbstractLayout) -> None:
+    def __init__(self, layout: Layout) -> None:
         super().__init__(layout)
         self._current_model_as_json = ""
 
-    async def _outgoing(self, layout: AbstractLayout, context: Any) -> LayoutUpdate:
+    async def _outgoing(self, layout: Layout, context: Any) -> LayoutUpdate:
         return await layout.render()
 
-    async def _incoming(
-        self, layout: AbstractLayout, context: Any, event: LayoutEvent
-    ) -> None:
-        await layout.trigger(event)
+    async def _incoming(self, layout: Layout, context: Any, event: LayoutEvent) -> None:
+        await layout.dispatch(event)
         return None
 
 
@@ -95,7 +91,7 @@ class SharedStateRenderer(SingleStateRenderer):
     :meth:`SharedStateRenderer.run`
     """
 
-    def __init__(self, layout: AbstractLayout) -> None:
+    def __init__(self, layout: Layout) -> None:
         super().__init__(layout)
         self._update_queues: Dict[str, asyncio.Queue[LayoutUpdate]] = {}
 
@@ -120,7 +116,7 @@ async def _render_loop(self) -> None:
             for queue in self._update_queues.values():
                 await queue.put(update)
 
-    async def _outgoing(self, layout: AbstractLayout, context: str) -> LayoutUpdate:
+    async def _outgoing(self, layout: Layout, context: str) -> LayoutUpdate:
         return await self._updates[context].get()
 
     @async_resource
diff --git a/idom/server/base.py b/idom/server/base.py
@@ -4,7 +4,7 @@
 from threading import Thread
 
 from idom.core.element import ElementConstructor, AbstractElement
-from idom.core.layout import AbstractLayout, Layout
+from idom.core.layout import Layout, Layout
 from idom.core.render import (
     AbstractRenderer,
     SendCoroutine,
@@ -32,7 +32,7 @@ class AbstractRenderServer(Generic[_App, _Config]):
 
     _loop: AbstractEventLoop
     _renderer_type: Type[AbstractRenderer]
-    _layout_type: Type[AbstractLayout] = Layout
+    _layout_type: Type[Layout] = Layout
 
     def __init__(
         self, constructor: ElementConstructor, *args: Any, **kwargs: Any
@@ -142,7 +142,7 @@ def _make_layout(
         self,
         parameters: Dict[str, Any],
         loop: Optional[AbstractEventLoop] = None,
-    ) -> AbstractLayout:
+    ) -> Layout:
         return self._layout_type(self._make_root_element(parameters), loop)
 
     def _make_root_element(self, parameters: Dict[str, Any]) -> AbstractElement:
diff --git a/tests/test_core/test_layout.py b/tests/test_core/test_layout.py
@@ -243,7 +243,7 @@ async def Inner():
         # the the old `Inner` element should be deleted. Thus there should be one
         # changed element in the set of `live_elements` the old `Inner` deleted and new
         # `Inner` added.
-        await layout.trigger(idom.core.layout.LayoutEvent("force-update", []))
+        await layout.dispatch(idom.core.layout.LayoutEvent("force-update", []))
         await layout.render()
         assert len(live_elements - last_live_elements) == 1
 
