remove ClientImplementation

now that the client-side JS mounting functions accept a importSourceUrl
to define the import source URL prefix, we can get rid of this now

Author: rmorshea

docs/source/javascript-modules.rst

@@ -106,23 +106,6 @@ that can run directly in the browser. This means we can't use fancy syntax like
 .. example:: super_simple_chart
 
 
-Alternate Client Implementations
---------------------------------
-
-While it's possible to implement a whole-sale replacement for IDOM's built-in client by
-adhering to IDOM's :ref:`API <Package API>` and :ref:`Specifications`, the easiest way
-to implement a custom client is to create an object that adheres to the
-:class:`~idom.client.protocol.ClientImplementation` protocol and update the ``current``
-value of the :attr:`~idom.client.protocol.client_implementation` ref. An example of
-such an implementation can be seen in
-`IDOM's Jupyter Widgets <https://github.com/idom-team/idom-jupyter>`__.
-
-The following describes the client implementation interface:
-
-.. autoclass:: idom.client.protocol.ClientImplementation
-    :noindex:
-
-
 .. Links
 .. =====
 

idom/__init__.py

@@ -21,7 +21,6 @@
 from .widgets.utils import hotswap, multiview
 
 from .client.module import Module, Import, install
-from .client.protocol import client_implementation as client
 
 from .server.prefab import run
 

idom/client/__init__.py

@@ -1,5 +0,0 @@
-from .protocol import client_implementation
-from .module import Module, Import
-
-
-__all__ = ["client_implementation", "Module", "Import"]

idom/client/manage.py

@@ -113,6 +113,13 @@ def build(packages_to_install: Sequence[str], clean_build: bool = False) -> None
 
         shutil.copytree(temp_build_dir, BUILD_DIR, symlinks=True)
 
+    not_discovered = package_names_to_install.difference(web_module_names())
+    if not_discovered:
+        raise RuntimeError(  # pragma: no cover
+            f"Successfuly installed {list(package_names_to_install)} but "
+            f"failed to discover {list(not_discovered)} post-install."
+        )
+
 
 def _npm_install(packages: List[str], cwd: Path) -> None:
     _run_subprocess(["npm", "install"] + packages, cwd)

idom/client/module.py

@@ -1,11 +1,9 @@
 from pathlib import Path
 from typing import Any, Optional, Union, List, Tuple, Dict, overload
 from urllib.parse import urlparse
-
 from idom.core.vdom import VdomDict, ImportSourceDict, make_vdom_constructor
 
-from . import manage as builtin_client
-from .protocol import client_implementation as client
+from . import manage
 from .utils import get_package_name
 
 
@@ -39,14 +37,8 @@ def install(
 
     pkg_names = {get_package_name(pkg) for pkg in packages}
 
-    if ignore_installed or pkg_names.difference(client.current.web_module_names()):
-        builtin_client.build(packages)
-        not_discovered = pkg_names.difference(client.current.web_module_names())
-        if not_discovered:
-            raise RuntimeError(
-                f"Successfuly installed {list(pkg_names)} but client implementation "
-                f"{client.current} failed to discover {list(not_discovered)}."
-            )
+    if ignore_installed or pkg_names.difference(manage.web_module_names()):
+        manage.build(packages)
 
     return (
         Module(pkg_names.pop(), fallback=fallback)
@@ -90,16 +82,16 @@ def __init__(
         self._export_names: Optional[List[str]] = None
         if source_file is not None:
             self.url = (
-                client.current.web_module_url(url_or_name)
-                if client.current.web_module_exists(url_or_name)
-                else client.current.add_web_module(url_or_name, source_file)
+                manage.web_module_url(url_or_name)
+                if manage.web_module_exists(url_or_name)
+                else manage.add_web_module(url_or_name, source_file)
             )
             if check_exports:
-                self._export_names = client.current.web_module_exports(url_or_name)
-        elif client.current.web_module_exists(url_or_name):
-            self.url = client.current.web_module_url(url_or_name)
+                self._export_names = manage.web_module_exports(url_or_name)
+        elif manage.web_module_exists(url_or_name):
+            self.url = manage.web_module_url(url_or_name)
             if check_exports:
-                self._export_names = client.current.web_module_exports(url_or_name)
+                self._export_names = manage.web_module_exports(url_or_name)
         elif _is_url(url_or_name):
             self.url = url_or_name
         else:

idom/client/protocol.py

@@ -110,15 +110,6 @@ def create():
         d.quit()
 
 
-@pytest.fixture
-def client_implementation():
-    original = idom.client.current
-    try:
-        yield idom.client
-    finally:
-        idom.client.current = original
-
-
 @pytest.fixture(scope="session")
 def driver_is_headless(pytestconfig: Config):
     return bool(pytestconfig.option.headless)

tests/conftest.py

@@ -1,10 +1,23 @@
+from contextlib import contextmanager
 from functools import wraps
 from weakref import ref
 
 
 import idom
 
 
+@contextmanager
+def patch_slots_object(obj, attr, new_value):
+    # we do this since `mock.patch..object attempts to use __dict__
+    # which is not necessarilly present on an object with __slots__`
+    old_value = getattr(obj, attr)
+    setattr(obj, attr, new_value)
+    try:
+        yield new_value
+    finally:
+        setattr(obj, attr, old_value)
+
+
 class HookCatcher:
     """Utility for capturing a LifeCycleHook from an element
 

tests/general_utils.py

@@ -2,7 +2,9 @@
 
 import pytest
 import idom
-from idom import Module, install
+from idom import Module
+
+from tests.general_utils import patch_slots_object
 
 HERE = Path(__file__).parent
 
@@ -31,20 +33,6 @@ def test_installed_module(driver, display, victory):
     driver.find_element_by_class_name("VictoryContainer")
 
 
-def test_install_checks_client_implementation(client_implementation):
-    class MockClientImplementation:
-        def web_module_names(self):
-            return set()
-
-    client_implementation.current = MockClientImplementation()
-
-    with pytest.raises(
-        RuntimeError,
-        match=r"Successfuly installed .* but client implementation .* failed to discover .*",
-    ):
-        install("jquery@3.5.0", ignore_installed=True)
-
-
 def test_reference_pre_installed_module(victory):
     assert victory.url == idom.Module("victory").url
 
@@ -55,37 +43,6 @@ def test_module_from_url():
     assert jquery.url == url
 
 
-def test_module_uses_current_client_implementation(client_implementation):
-    class MockClientImplementation:
-        def web_module_url(self, package_name):
-            return f"./mock/url/to/module-{package_name}.js"
-
-        def web_module_exports(self, package_name):
-            return ["x", "y", "z"]
-
-        def web_module_exists(self, package_name):
-            return package_name == "fake-name"
-
-        def web_module_names(self):
-            raise NotImplementedError()
-
-        def web_module_path(self, package_name):
-            raise NotImplementedError()
-
-        def add_web_module(self, package_name, source):
-            raise NotImplementedError()
-
-    client_implementation.current = MockClientImplementation()
-
-    fake = Module("fake-name")
-    assert fake.url == "./mock/url/to/module-fake-name.js"
-    assert list(fake.exports) == ["x", "y", "z"]
-    assert fake.fallback is None
-
-    with pytest.raises(ValueError, match="does not export 'DoesNotExist'"):
-        fake.declare("DoesNotExist")
-
-
 def test_module_from_source(driver, driver_wait, display):
     test_module = Module("test-module", source_file=HERE / "test_js_module.js")
 
@@ -106,3 +63,9 @@ def ShowButton():
     client_button = driver.find_element_by_id("test-button")
     client_button.click()
     driver_wait.until(lambda dvr: response_data.current == 10)
+
+
+def test_module_checks_export_names(victory):
+    with patch_slots_object(victory, "_export_names", []):
+        with pytest.raises(ValueError, match="does not export"):
+            victory.decalare("VictoryBar")