more tests + check js module exports

Author: rmorshea

docs/source/examples/material_ui_slider.py

@@ -3,8 +3,8 @@
 import idom
 
 
-material_ui = idom.Module("@material-ui/core")
-MaterialSlider = material_ui.Import("Slider", fallback="loading...")
+material_ui = idom.Module("@material-ui/core", fallback="loading...")
+MaterialSlider = material_ui.Import("Slider")
 
 
 @idom.element

docs/source/examples/victory_chart.py

@@ -1,8 +1,8 @@
 import idom
 
-victory = idom.Module("victory")
+victory = idom.Module("victory", fallback="loading...")
 
-VictoryBar = victory.Import("VictoryBar", fallback="loading...")
+VictoryBar = victory.Import("VictoryBar")
 
 idom.run(
     idom.element(

idom/__init__.py

@@ -24,7 +24,7 @@
 from .client.module import Module, Import
 from .client.protocol import client_implementation as client
 
-from .server.utils import run
+from .server.prefab import run
 
 from . import widgets
 

idom/cli/commands.py

@@ -47,7 +47,7 @@ def restore():
 @show.command()
 def build_config() -> None:
     """Show the state of IDOM's build config"""
-    typer.echo(json.dumps(manage_client.build_config_file().to_dicts(), indent=2))
+    typer.echo(json.dumps(manage_client.build_config().config, indent=2))
     return None
 
 

idom/client/build_config.py

@@ -91,9 +91,16 @@ def update_config_items(self, config_items: Iterable[BuildConfigItem]) -> None:
             self.config["by_source"][conf["source_name"]] = conf
 
     @_modified_by_transaction
-    def get_js_dependency_alias(self, source_name: str, dependency_name: str) -> str:
+    def get_js_dependency_alias(
+        self,
+        source_name: str,
+        dependency_name: str,
+    ) -> Optional[str]:
         aliases_by_src = self._derived_properties["js_dependency_aliases_by_source"]
-        return aliases_by_src[source_name][dependency_name]
+        try:
+            return aliases_by_src[source_name][dependency_name]
+        except KeyError:
+            return None
 
     @_modified_by_transaction
     def all_aliased_js_dependencies(self) -> List[str]:
@@ -132,13 +139,6 @@ def __repr__(self) -> str:
         return f"{type(self).__name__}({self.config})"
 
 
-def find_build_config_item_in_python_file(
-    module_name: str, path: Path
-) -> Optional[BuildConfigItem]:
-    with path.open() as f:
-        return find_build_config_item_in_python_source(module_name, f.read())
-
-
 def find_python_packages_build_config_items(
     paths: Optional[List[str]] = None,
 ) -> Tuple[List[BuildConfigItem], List[Exception]]:
@@ -173,6 +173,13 @@ def find_python_packages_build_config_items(
     return build_configs, failures
 
 
+def find_build_config_item_in_python_file(
+    module_name: str, path: Path
+) -> Optional[BuildConfigItem]:
+    with path.open() as f:
+        return find_build_config_item_in_python_source(module_name, f.read())
+
+
 def find_build_config_item_in_python_source(
     module_name: str, module_src: str
 ) -> Optional[BuildConfigItem]:

idom/client/manage.py

@@ -9,51 +9,58 @@
     BuildConfigItem,
     find_python_packages_build_config_items,
 )
-from .utils import open_modifiable_json
+from .utils import open_modifiable_json, find_js_module_exports
 
 from idom.cli import console
 
 
 APP_DIR = Path(__file__).parent / "app"
 BUILD_DIR = APP_DIR / "build"
+_BUILD_CONFIG: Optional[BuildConfig] = None
 
 
 def build_config() -> BuildConfig:
-    return BuildConfig(BUILD_DIR)
+    global _BUILD_CONFIG
+    if _BUILD_CONFIG is None:
+        _BUILD_CONFIG = BuildConfig(BUILD_DIR)
+    return _BUILD_CONFIG
 
 
-def find_path(url_path: str) -> Optional[Path]:
-    url_path = url_path.strip("/")
-
-    builtin_path = BUILD_DIR.joinpath(*url_path.split("/"))
-    if builtin_path.exists():
-        return builtin_path
-    else:
-        return None
+def web_module_exports(source_name: str, package_name: str) -> List[str]:
+    dep_alias = build_config().get_js_dependency_alias(source_name, package_name)
+    if dep_alias is None:
+        return []
+    module_file = find_client_build_path(f"web_modules/{dep_alias}.js")
+    if module_file is None:
+        return []
+    return find_js_module_exports(module_file)
 
 
 def web_module_url(source_name: str, package_name: str) -> Optional[str]:
-    config = build_config().configs.get(source_name)
-    if config is None:
-        return None
-    if package_name not in config.js_dependency_aliases:
+    dep_alias = build_config().get_js_dependency_alias(source_name, package_name)
+    if dep_alias is None:
         return None
-    alias = config.js_dependency_aliases[package_name]
-    if find_path(f"web_modules/{alias}.js") is None:
+    if find_client_build_path(f"web_modules/{dep_alias}.js") is None:
         return None
     # need to go back a level since the JS that import this is in `core_components`
-    return f"../web_modules/{alias}.js"
+    return f"../web_modules/{dep_alias}.js"
+
+
+def find_client_build_path(rel_path: str) -> Optional[Path]:
+    if rel_path.startswith("/"):
+        raise ValueError(f"{rel_path!r} is not a relative path")
+    builtin_path = BUILD_DIR.joinpath(*rel_path.split("/"))
+    if builtin_path.exists():
+        return builtin_path
+    else:
+        return None
 
 
-def build(
-    config_items: Optional[Iterable[BuildConfigItem]] = None,
-    output_dir: Path = BUILD_DIR,
-) -> None:
+def build(config_items: Iterable[BuildConfigItem] = ()) -> None:
     config = build_config()
 
     with config.transaction():
-        if config_items is not None:
-            config.update_config_items(config_items)
+        config.update_config_items(config_items)
 
         with console.spinner("Discovering dependencies"):
             configs, errors = find_python_packages_build_config_items()
@@ -88,10 +95,10 @@ def build(
         with console.spinner("Building client"):
             _npm_run_build(temp_app_dir)
 
-        if output_dir.exists():
-            shutil.rmtree(output_dir)
+        if BUILD_DIR.exists():
+            shutil.rmtree(BUILD_DIR)
 
-        shutil.copytree(temp_build_dir, output_dir, symlinks=True)
+        shutil.copytree(temp_build_dir, BUILD_DIR, symlinks=True)
 
 
 def restore() -> None:

idom/client/module.py

@@ -8,7 +8,7 @@
 
 
 class Module:
-    """A Javascript module
+    """An importable client-side module
 
     Parameters:
         url_or_name:
@@ -35,12 +35,19 @@ class Module:
         files or loading modules that have been installed by some other means:
     """
 
-    __slots__ = "url", "installed"
+    __slots__ = "url", "installed", "fallback", "exports"
 
-    def __init__(self, url_or_name: str, source_name: Optional[str] = None) -> None:
+    def __init__(
+        self,
+        url_or_name: str,
+        source_name: Optional[str] = None,
+        fallback: Optional[str] = None,
+        check_exports: bool = True,
+    ) -> None:
         if _is_url(url_or_name):
             self.url = url_or_name
             self.installed = False
+            self.exports = []
         else:
             if source_name is None:
                 module_name: str = inspect.currentframe().f_back.f_globals["__name__"]
@@ -52,6 +59,14 @@ def __init__(self, url_or_name: str, source_name: Optional[str] = None) -> None:
                 )
             self.url = url
             self.installed = True
+            if check_exports:
+                self.exports = client.current.web_module_exports(
+                    source_name,
+                    url_or_name,
+                )
+            else:
+                self.exports = []
+        self.fallback = fallback
 
     def Import(self, name: str, *args: Any, **kwargs: Any) -> "Import":
         """Return  an :class:`Import` for the given :class:`Module` and ``name``
@@ -65,6 +80,17 @@ def Import(self, name: str, *args: Any, **kwargs: Any) -> "Import":
         Where ``name`` is the given name, and ``module`` is the :attr:`Module.url` of
         this :class:`Module` instance.
         """
+        if (
+            self.installed
+            and self.exports
+            # if 'default' is exported there's not much we can infer
+            and "default" not in self.exports
+        ):
+            if name not in self.exports:
+                raise ValueError(
+                    f"{self} does not export {name!r}, available options are {self.exports}"
+                )
+        kwargs.setdefault("fallback", self.fallback)
         return Import(self.url, name, *args, **kwargs)
 
     def __repr__(self) -> str:  # pragma: no cover

idom/client/utils.py

@@ -1,7 +1,8 @@
+import re
 import json
 from pathlib import Path
 from contextlib import contextmanager
-from typing import Iterator, Any
+from typing import Iterator, Any, List
 
 
 @contextmanager
@@ -13,3 +14,18 @@ def open_modifiable_json(path: Path) -> Iterator[Any]:
 
     with path.open("w") as f:
         json.dump(data, f)
+
+
+_JS_MODULE_EXPORT_PATTERN = re.compile(r";export{(.*)};")
+
+
+def find_js_module_exports(path: Path) -> List[str]:
+    names: List[str] = []
+    if path.suffix != ".js":
+        # we only know how to do this for javascript modules
+        return []
+    with path.open() as f:
+        for match in _JS_MODULE_EXPORT_PATTERN.findall(f.read()):
+            for export in match.split(","):
+                names.append(export.split(" as ", 1)[1].strip())
+    return names

idom/server/__init__.py

@@ -1,4 +1,4 @@
 from .base import AbstractRenderServer
-from .utils import run, multiview_server, hotswap_server
+from .prefab import run, multiview_server, hotswap_server
 
 __all__ = ["run", "multiview_server", "hotswap_server", "AbstractRenderServer"]

idom/server/utils.py renamed to idom/server/prefab.py

@@ -1,5 +1,5 @@
-from socket import socket
 from importlib import import_module
+from socket import socket
 from typing import Any, Dict, Optional, Tuple, Type, TypeVar, cast
 
 from idom.core.element import ElementConstructor
@@ -53,7 +53,7 @@ def run(
     if server_type is None:  # pragma: no cover
         raise ValueError("No default server available.")
     if port is None:  # pragma: no cover
-        port = find_available_port(host)
+        port = _find_available_port(host)
 
     server = server_type(element, server_options)
 
@@ -152,7 +152,7 @@ def hotswap_server(
     return mount, server
 
 
-def find_available_port(host: str) -> int:
+def _find_available_port(host: str) -> int:
     """Get a port that's available for the given host"""
     sock = socket()
     sock.bind((host, 0))