add class based component implementation

Author: rmorshea

src/idom/__init__.py

@@ -1,12 +1,14 @@
+from dataclasses import replace
+
 from . import config, html, log, web
 from .core import hooks
-from .core.component import Component, component
+from .core.component import component
 from .core.dispatcher import Stop
 from .core.events import EventHandler, event
 from .core.layout import Layout
 from .core.vdom import vdom
 from .server.prefab import run
-from .utils import Ref, html_to_vdom
+from .utils import Ref, html_to_vdom, state
 from .widgets import hotswap, multiview
 
 
@@ -15,7 +17,6 @@
 
 __all__ = [
     "component",
-    "Component",
     "config",
     "event",
     "EventHandler",
@@ -27,7 +28,9 @@
     "log",
     "multiview",
     "Ref",
+    "replace",
     "run",
+    "state",
     "Stop",
     "vdom",
     "web",

src/idom/core/component.py

@@ -8,19 +8,40 @@
 import inspect
 import warnings
 from functools import wraps
-from typing import Any, Callable, Dict, Optional, Tuple, Union
+from typing import Any, Callable, Dict, Optional, Tuple, Type, TypeVar, Union, overload
 
+from .hooks import use_effect, use_state
 from .proto import ComponentType, VdomDict
 
 
-def component(
-    function: Callable[..., Union[ComponentType, VdomDict]]
-) -> Callable[..., "Component"]:
+_Class = TypeVar("_Class", bound=Type[ComponentType])
+
+
+@overload
+def component(function_or_class: _Class) -> _Class:
+    ...
+
+
+@overload
+def component(function_or_class: Callable[..., Any]) -> Callable[..., ComponentType]:
+    ...
+
+
+def component(function_or_class: Any) -> Callable[..., ComponentType]:
     """A decorator for defining an :class:`Component`.
 
     Parameters:
         function: The function that will render a :class:`VdomDict`.
     """
+    if not inspect.isclass(function_or_class):
+        return _wrap_function(function_or_class)
+    else:
+        return _wrap_class(function_or_class)
+
+
+def _wrap_function(
+    function: Callable[..., ComponentType | VdomDict]
+) -> Callable[..., Component]:
     sig = inspect.signature(function)
     key_is_kwarg = "key" in sig.parameters and sig.parameters["key"].kind in (
         inspect.Parameter.KEYWORD_ONLY,
@@ -77,3 +98,110 @@ def __repr__(self) -> str:
                 return f"{self._func.__name__}({id(self)}, {items})"
             else:
                 return f"{self._func.__name__}({id(self)})"
+
+
+_Wrapped = TypeVar("_Wrapped", bound=Any)
+
+
+def _wrap_class(cls: type[_Wrapped]) -> type[_Wrapped]:
+    """Modifies the given class such that it can operate as a stateful component
+
+    Adds the following attributes to the class:
+
+    - ``key``
+    - ``state``
+    - ``_set_state``
+
+    And wraps the following methods with extra logic that is opaque to the user:
+
+    - ``__init__``
+    - ``render``
+    """
+
+    if hasattr(cls, "__slots__"):
+        raise ValueError("Component classes cannot have __slots__")
+
+    original_render = cls.render
+    original_init = getattr(cls, "__init__", object.__init__)
+
+    def __init__(  # noqa: N807
+        self: Any,
+        *args: Any,
+        key: Optional[Any] = None,
+        **kwargs: Any,
+    ) -> None:
+        self.key = key
+        # initialize with a no-op set state callback
+        self._set_state = lambda _: None
+        cls.__init__.inherited_method(self)
+        if not hasattr(self, "state"):
+            raise AttributeError(f"{self} did not initialize a 'state' attribute")
+
+    def render(self: Any) -> Any:
+        self.state, self._set_state = use_state(self.state)  # noqa: ROH101
+        use_effect(getattr(self, "effect", None), args=[])  # noqa: ROH101
+        return cls.render.inherited_method(self)
+
+    cls.__init__ = _OwnerInheritorDescriptor(__init__, original_init)
+    cls.render = _OwnerInheritorDescriptor(render, original_render)
+
+    # need to manually set up descriptor
+    cls.__init__.__set_name__(cls, "__init__")
+    cls.render.__set_name__(cls, "render")
+
+    cls.state = _StateDescriptor()
+
+    return cls
+
+
+class _OwnerInheritorDescriptor:
+    """Show one value for the owner of this descriptor and another for the owner's subclass
+
+    Example:
+        .. code-block::
+
+            class Owner:
+                method = _OwnerInheritorDescriptor(
+                    own_method=lambda self: 1,
+                    inherited_method=lambda self: 2,
+                )
+
+            class Inheritor(Owner):
+                def method(self):
+                    return super().method()
+
+            assert Owner().method() == 1
+            assert Inheritor().method() == 2
+    """
+
+    owner: type[Any]
+
+    def __init__(
+        self,
+        own_method: Any,
+        inherited_method: Any,
+    ) -> None:
+        self.own_method = own_method
+        self.inherited_method = inherited_method
+
+    def __set_name__(self, cls: type[Any], name: str) -> None:
+        self.owner = cls
+
+    def __get__(self, obj: Any | None, cls: type[Any]) -> Any:
+        if obj is None:
+            return self
+        elif cls is self.owner:
+            return self.own_method.__get__(obj, cls)
+        else:
+            return self.inherited_method.__get__(obj, cls)
+
+
+class _StateDescriptor:
+    """Simple descriptor that call ``obj._set_state`` of the value changes"""
+
+    def __get__(self, obj: Any, cls: Any) -> Any:
+        return self if obj is None else obj._state
+
+    def __set__(self, obj: Any, new: Any) -> None:
+        obj._set_state(new)
+        obj._state = new

src/idom/utils.py

@@ -3,8 +3,45 @@
 =================
 """
 
+from dataclasses import dataclass
 from html.parser import HTMLParser as _HTMLParser
-from typing import Any, Callable, Dict, Generic, List, Optional, Tuple, TypeVar
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    Generic,
+    List,
+    Optional,
+    Tuple,
+    Type,
+    TypeVar,
+    overload,
+)
+
+
+_Class = TypeVar("_Class", bound=Type[Any])
+
+
+@overload
+def state(cls: _Class) -> _Class:
+    ...
+
+
+@overload
+def state(cls: None) -> Callable[[_Class], _Class]:
+    ...
+
+
+@overload
+def state(**kwargs: Any) -> Callable[[_Class], _Class]:
+    ...
+
+
+def state(cls: Optional[_Class] = None, **kwargs: Any) -> Any:
+    if cls is not None:
+        return dataclass(frozen=True, **kwargs)(cls)
+    else:
+        return dataclass(frozen=True, **kwargs)
 
 
 _RefValue = TypeVar("_RefValue")