refactor: extract key, title and description into an abstract base class for views

Author: yt-ms

src/structurizr/view/abstract_view.py

@@ -0,0 +1,73 @@
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+"""Provide a superclass for all views."""
+
+
+from abc import ABC
+from typing import Dict
+
+from ..abstract_base import AbstractBase
+from ..base_model import BaseModel
+from ..mixin import ViewSetRefMixin
+
+
+__all__ = ("AbstractView", "AbstractViewIO")
+
+
+class AbstractViewIO(BaseModel, ABC):
+    """
+    Define an abstract base class for all views.
+
+    Views include static views, dynamic views, deployment views and filtered views.
+    """
+
+    key: str
+    description: str = ""
+    title: str = ""
+
+
+class AbstractView(ViewSetRefMixin, AbstractBase, ABC):
+    """
+    Define an abstract base class for all views.
+
+    Views include static views, dynamic views, deployment views and filtered views.
+
+    """
+
+    def __init__(
+        self,
+        *,
+        key: str = None,
+        description: str,
+        title: str = "",
+        **kwargs,
+    ):
+        """Initialize a view with a 'private' view set."""
+        super().__init__(**kwargs)
+        self.key = key
+        self.description = description
+        self.title = title
+
+    def __repr__(self) -> str:
+        """Return repr(self)."""
+        return f"{type(self).__name__}(key={self.key})"
+
+    @classmethod
+    def hydrate_arguments(cls, view_io: AbstractViewIO) -> Dict:
+        """Hydrate an AbstractViewIO into the constructor args for AbstractView."""
+        return {
+            "key": view_io.key,
+            "description": view_io.description,
+            "title": view_io.title,
+        }

src/structurizr/view/view.py

@@ -16,14 +16,11 @@
 """Provide a superclass for all views."""
 
 
-from abc import ABC
 from typing import Any, Dict, Iterable, List, Optional, Set
 
 from pydantic import Field
 
-from ..abstract_base import AbstractBase
-from ..base_model import BaseModel
-from ..mixin import ViewSetRefMixin
+from .abstract_view import AbstractView, AbstractViewIO
 from ..model import Element, Model, Relationship, SoftwareSystem
 from .automatic_layout import AutomaticLayout, AutomaticLayoutIO
 from .element_view import ElementView, ElementViewIO
@@ -34,21 +31,18 @@
 __all__ = ("View", "ViewIO")
 
 
-class ViewIO(BaseModel, ABC):
+class ViewIO(AbstractViewIO):
     """
-    Define an abstract base class for all views.
+    Define a base class for non-filtered views.
 
     Views include static views, dynamic views and deployment views.
     """
 
-    key: str
-    description: str = ""
     software_system_id: Optional[str] = Field(default=None, alias="softwareSystemId")
     paper_size: Optional[PaperSize] = Field(default=None, alias="paperSize")
     automatic_layout: Optional[AutomaticLayoutIO] = Field(
         default=None, alias="automaticLayout"
     )
-    title: str = ""
 
     element_views: List[ElementViewIO] = Field(default=(), alias="elements")
     relationship_views: List[RelationshipViewIO] = Field(
@@ -61,9 +55,9 @@ class ViewIO(BaseModel, ABC):
     # )
 
 
-class View(ViewSetRefMixin, AbstractBase, ABC):
+class View(AbstractView):
     """
-    Define an abstract base class for all views.
+    Define a base class for non-filtered views.
 
     Views include static views, dynamic views and deployment views.
 
@@ -73,11 +67,8 @@ def __init__(
         self,
         *,
         software_system: Optional[SoftwareSystem] = None,
-        key: str = None,
-        description: str,
         paper_size: Optional[PaperSize] = None,
         automatic_layout: Optional[AutomaticLayout] = None,
-        title: str = "",
         element_views: Optional[Iterable[ElementView]] = (),
         relationship_views: Optional[Iterable[RelationshipView]] = (),
         layout_merge_strategy: Optional[Any] = None,
@@ -87,33 +78,24 @@ def __init__(
         super().__init__(**kwargs)
         self.software_system = software_system
         self.software_system_id = software_system.id if software_system else None
-        self.key = key
-        self.description = description
         self.paper_size = paper_size
         self.automatic_layout = automatic_layout
-        self.title = title
         self.element_views: Set[ElementView] = set(element_views)
         self._relationship_views: Set[RelationshipView] = set(relationship_views)
 
         # TODO
         self.layout_merge_strategy = layout_merge_strategy
 
-    def __repr__(self) -> str:
-        """Return repr(self)."""
-        return f"{type(self).__name__}(key={self.key})"
-
     @classmethod
     def hydrate_arguments(cls, view_io: ViewIO) -> Dict:
         """Hydrate a ViewIO into the constructor arguments for View."""
         return {
+            **super().hydrate_arguments(view_io),
             # TODO: should we add this here? probably not: "software_system"
-            "key": view_io.key,
-            "description": view_io.description,
             "paper_size": view_io.paper_size,
             "automatic_layout": AutomaticLayout.hydrate(view_io.automatic_layout)
             if view_io.automatic_layout
             else None,
-            "title": view_io.title,
             "element_views": map(ElementView.hydrate, view_io.element_views),
             "relationship_views": map(
                 RelationshipView.hydrate, view_io.relationship_views

tests/unit/view/test_view.py

@@ -23,7 +23,13 @@
 class DerivedView(View):
     """Mock class for testing."""
 
-    pass
+    @classmethod
+    def hydrate(
+        cls,
+        view_io: ViewIO,
+    ):
+        """Hydrate a DerivedView from its IO."""
+        return cls(**cls.hydrate_arguments(view_io))
 
 
 def test_find_element_view():
@@ -173,3 +179,20 @@ def test_copy_layout():
     assert view2.find_element_view(element=sys1).paper_size == PaperSize.A1_Portrait
     rv = view2.find_relationship_view(description="Uses")
     assert rv.paper_size == PaperSize.A3_Portrait
+
+
+def test_hydration_includes_base_fields():
+    """Ensure fields from AbstractView are included when hydrating a View."""
+    view = DerivedView(key="key", title="title", description="description")
+    io = ViewIO.from_orm(view)
+
+    view2 = DerivedView.hydrate(io)
+    assert view2.key == "key"
+    assert view2.title == "title"
+    assert view2.description == "description"
+
+
+def test_repr():
+    """Test __repr__ for views."""
+    view = DerivedView(key="testkey", title="title", description="description")
+    assert repr(view) == "DerivedView(key=testkey)"