no copy of defined web modules

instead use a shim where we look up registered file paths

Author: rmorshea

.pre-commit-config.yaml

@@ -3,7 +3,6 @@ repos:
     rev: stable
     hooks:
       - id: black
-        language_version: python3.6
   - repo: https://github.com/PyCQA/flake8
     rev: 3.7.9
     hooks:

docs/source/widgets/custom_chart.py

@@ -5,8 +5,8 @@
 
 
 here = Path(__file__).parent
-with (here / "custom_chart.js").open() as f:
-    ClickableChart = idom.Module("chart", source=f).Import("ClickableChart")
+custom_chart_path = here / "custom_chart.js"
+ClickableChart = idom.Module("chart", source=custom_chart_path).Import("ClickableChart")
 
 
 data = [

idom/client/__init__.py

@@ -1,20 +1,22 @@
 from .manage import (
-    web_module,
+    web_module_url,
+    find_path,
+    delete_web_modules,
+    register_web_module,
     web_module_exists,
     web_module_path,
-    define_web_module,
-    delete_web_modules,
     install,
     installed,
     restore,
 )
 
 __all__ = [
-    "web_module",
+    "web_module_url",
+    "find_path",
+    "delete_web_modules",
+    "register_web_module",
     "web_module_exists",
     "web_module_path",
-    "define_web_module",
-    "delete_web_modules",
     "install",
     "installed",
     "restore",

idom/client/manage.py

@@ -15,44 +15,68 @@
 NODE_MODULES = STATIC_DIR / "node_modules"
 WEB_MODULES = STATIC_DIR / "web_modules"
 
+STATIC_SHIMS: Dict[str, Path] = {}
 
-def web_module(name: str) -> str:
+
+def find_path(url_path: str) -> Optional[Path]:
+    url_path = url_path.strip("/")
+
+    builtin_path = STATIC_DIR.joinpath(*url_path.split("/"))
+    if builtin_path.exists():
+        return builtin_path
+
+    return STATIC_SHIMS.get(url_path)
+
+
+def web_module_path(name: str) -> Optional[Path]:
+    return find_path(f"web_modules/{name}.js")
+
+
+def web_module_url(name: str) -> str:
     path = f"../{WEB_MODULES.name}/{name}.js"
     if not web_module_exists(name):
         raise ValueError(f"Module '{path}' does not exist.")
     return path
 
 
-def web_module_path(name: str) -> Optional[Path]:
-    path = _create_web_module_os_path(name).with_suffix(".js")
-    return path if path.is_file() else None
-
-
 def web_module_exists(name: str) -> bool:
-    return web_module_path(name) is not None
+    return find_path(f"web_modules/{name}.js") is not None
 
 
-def define_web_module(name: str, source: str) -> str:
-    path = _create_web_module_os_path(name).with_suffix(".js")
-    with path.open("w+") as f:
-        f.write(source)
-    return web_module(name)
+def register_web_module(name: str, source: Union[str, Path]) -> str:
+    source_path = source if isinstance(source, Path) else Path(source)
+    if web_module_exists(name):
+        raise ValueError(f"Web module {name} already exists")
+    if not source_path.is_file():
+        raise ValueError(f"Web modules source {source} does not exist or is not a file")
+    STATIC_SHIMS[f"web_modules/{name}.js"] = source
+    return web_module_url(name)
 
 
 def delete_web_modules(names: Sequence[str], skip_missing: bool = False) -> None:
     paths = []
-    for n in _to_list_of_str(names):
+    for name in _to_list_of_str(names):
         exists = False
-        path = _create_web_module_os_path(n)
-        js_path = path.with_suffix(".js")
-        if path.is_dir():
+
+        dir_name = f"web_modules/{name}"
+        js_name = f"web_modules/{name}.js"
+        path = find_path(dir_name)
+        js_path = find_path(js_name)
+
+        if path is not None:
             paths.append(path)
             exists = True
-        if js_path.is_file():
+
+        if js_name in STATIC_SHIMS:
+            del STATIC_SHIMS[js_name]
+            exists = True
+        elif js_path is not None:
             paths.append(js_path)
             exists = True
+
         if not exists and not skip_missing:
-            raise ValueError(f"Module '{n}' does not exist.")
+            raise ValueError(f"Module '{name}' does not exist.")
+
     for p in paths:
         _delete_os_paths(p)
 
@@ -109,6 +133,7 @@ def restore() -> None:
         _delete_os_paths(WEB_MODULES, NODE_MODULES)
         _run_subprocess(["npm", "install"], STATIC_DIR)
         _run_subprocess(["npm", "run", "snowpack"], STATIC_DIR)
+    STATIC_SHIMS.clear()
 
 
 def _package_json() -> Dict[str, Any]:
@@ -141,15 +166,6 @@ def _run_subprocess(args: List[str], cwd: Union[str, Path]) -> None:
     return None
 
 
-def _create_web_module_os_path(name: str) -> Path:
-    path = WEB_MODULES
-    for n in name.split("/"):
-        if not path.exists():
-            path.mkdir()
-        path /= n
-    return path
-
-
 def _delete_os_paths(*paths: Path) -> None:
     for p in paths:
         if p.is_file():

idom/server/sanic.py

@@ -16,7 +16,7 @@
     RecvCoroutine,
 )
 from idom.core.layout import LayoutEvent
-from idom.client.manage import STATIC_DIR
+from idom.client.manage import find_path
 
 from .base import AbstractRenderServer
 
@@ -88,10 +88,10 @@ async def client_files(
                 request: request.Request, path: str
             ) -> response.HTTPResponse:
                 file_extensions = [".html", ".js", ".json"]
-                abs_path = STATIC_DIR.joinpath(*path.split("/"))
+                abs_path = find_path(path)
                 return (
                     (await response.file_stream(str(abs_path)))
-                    if abs_path.exists() and abs_path.suffix in file_extensions
+                    if abs_path is not None and abs_path.suffix in file_extensions
                     else response.text(f"Could not find: {path!r}", status=404)
                 )
 

idom/widgets/utils.py

@@ -1,4 +1,5 @@
-from typing import Any, Callable, Tuple, Optional, Dict, Union, IO
+from pathlib import Path
+from typing import Any, Callable, Tuple, Optional, Dict, Union
 
 from typing_extensions import Protocol
 
@@ -33,29 +34,28 @@ def __init__(
         self,
         name: str,
         install: Union[bool, str] = False,
-        source: Optional[IO[str]] = None,
+        source: Optional[Union[str, Path]] = None,
         replace: bool = False,
     ) -> None:
         self._installed = False
         if install and source:
             raise ValueError("Both 'install' and 'source' were given.")
         elif (install or source) and not replace and client.web_module_exists(name):
-            self._module = client.web_module(name)
+            self._module = client.web_module_url(name)
             self._installed = True
             self._name = name
         elif source is not None:
-            client.define_web_module(name, source.read())
-            self._module = client.web_module(name)
+            self._module = client.register_web_module(name, source)
             self._installed = True
             self._name = name
         elif isinstance(install, str):
             client.install([install], [name])
-            self._module = client.web_module(name)
+            self._module = client.web_module_url(name)
             self._installed = True
             self._name = name
         elif install is True:
             client.install(name)
-            self._module = client.web_module(name)
+            self._module = client.web_module_url(name)
             self._installed = True
             self._name = name
         else:
@@ -77,7 +77,7 @@ def Import(self, name: str, *args: Any, **kwargs: Any) -> "Import":
     def delete(self) -> None:
         if not self._installed:
             raise ValueError("Module is not installed locally")
-        client.delete_web_modules([self._module])
+        client.delete_web_modules([self._name])
 
     def __repr__(self) -> str:  # pragma: no cover
         return f"{type(self).__name__}({self._module!r})"

tests/test_client/test_manage.py

@@ -1,3 +1,4 @@
+from pathlib import Path
 from subprocess import CalledProcessError
 from unittest import mock
 
@@ -12,11 +13,17 @@
 def test_install():
     client.delete_web_modules(["jquery"], skip_missing=True)
     client.install("jquery")
+
     assert client.web_module_exists("jquery")
+    assert client.web_module_exists("/jquery")  # works with a leading slash too
     assert "jquery" in client.installed()
     with assert_file_is_touched(client.web_module_path("jquery")):
         client.install("jquery", force=True)
-    assert "jquery" in client.installed()
+
+    with pytest.raises(ValueError, match="already exists"):
+        # can't register a module with the same name
+        client.register_web_module("jquery", Path() / "some-module.js")
+
     client.delete_web_modules("jquery")
     assert not client.web_module_exists("jquery")
     assert "jquery" not in client.installed()
@@ -27,12 +34,12 @@ def test_install_namespace_package():
     client.install("@material-ui/core")
     assert client.web_module_exists("@material-ui/core")
     expected = "../web_modules/@material-ui/core.js"
-    assert client.web_module("@material-ui/core") == expected
+    assert client.web_module_url("@material-ui/core") == expected
 
 
 def test_raise_on_missing_import_path():
     with pytest.raises(ValueError, match="does not exist"):
-        client.web_module("module/that/does/not/exist")
+        client.web_module_url("module/that/does/not/exist")
 
 
 called_process_error = CalledProcessError(1, "failing-cmd")
@@ -44,3 +51,11 @@ def test_bad_subprocess_call(subprocess_run, caplog):
     with pytest.raises(CalledProcessError):
         client.install(["victory"])
     assert "an error occured" in caplog.text
+
+
+def test_cannot_register_module_from_non_existant_source():
+    with pytest.raises(ValueError, match="does not exist"):
+        client.register_web_module("my-module", Path() / "a-non-existant-file.js")
+
+    with pytest.raises(ValueError, match="is not a file"):
+        client.register_web_module("my-module", Path("/"))

tests/test_widgets/test_utils.py

@@ -1,4 +1,3 @@
-from io import StringIO
 from pathlib import Path
 
 import pytest
@@ -12,7 +11,7 @@
 
 def test_module_cannot_have_source_and_install():
     with pytest.raises(ValueError, match=r"Both .* were given."):
-        idom.Module("something", install="something", source=StringIO())
+        idom.Module("something", install="something", source=HERE / "something.js")
 
 
 @pytest.fixture
@@ -27,7 +26,7 @@ def test_install(driver, display, victory):
     driver.find_element_by_class_name("VictoryContainer")
 
     assert client.web_module_exists("victory")
-    assert client.web_module("victory") == "../web_modules/victory.js"
+    assert client.web_module_url("victory") == "../web_modules/victory.js"
 
 
 @pytest.mark.slow
@@ -41,16 +40,19 @@ def test_delete_module(victory):
 
 @pytest.mark.slow
 def test_custom_module(driver, display, victory):
-    with open(HERE / "my_chart.js") as f:
-        my_chart = Module("my/chart", source=f)
+    my_chart = Module("my/chart", source=HERE / "my_chart.js")
 
     assert client.web_module_exists("my/chart")
-    assert client.web_module("my/chart") == "../web_modules/my/chart.js"
+    assert client.web_module_url("my/chart") == "../web_modules/my/chart.js"
 
     display(my_chart.Import("Chart"))
 
     driver.find_element_by_class_name("VictoryContainer")
 
+    my_chart.delete()
+
+    assert not client.web_module_exists("my/chart")
+
 
 def test_module_deletion():
     # also test install