rework config using jsonschema

Author: rmorshea

idom/__init__.py

@@ -3,6 +3,12 @@
     DistributionNotFound as _DistributionNotFound,
 )
 
+try:
+    __version__ = _get_distribution(__name__).version
+except _DistributionNotFound:  # pragma: no cover
+    # package is not installed
+    __version__ = "0.0.0"
+
 from . import cli
 from .utils import Ref, html_to_vdom
 
@@ -22,12 +28,6 @@
 
 from . import widgets
 
-try:
-    __version__ = _get_distribution(__name__).version
-except _DistributionNotFound:  # pragma: no cover
-    # package is not installed
-    __version__ = "0.0.0"
-
 # try to automatically setup the dialect's import hook
 try:
     import pyalect

idom/cli/commands.py

@@ -23,7 +23,7 @@ def build(
         "--entrypoint",
         "-e",
         help="A python file containing a build config",
-    )
+    ),
 ) -> None:
     """Configure and build the client"""
     if entrypoint is None:

idom/client/build_config.py

@@ -15,22 +15,22 @@
     Optional,
     Any,
     Iterator,
+    Iterable,
     TypeVar,
     Tuple,
     Callable,
     TypedDict,
 )
 
-from fastjsonschema import compile as compile_schema
+from jsonschema import validate as validate_schema
 
 import idom
-from .utils import split_package_name_and_version
 
 
 _Self = TypeVar("_Self")
 _Method = TypeVar("_Method", bound=Callable[..., Any])
 
-_ConfigItem = Dict[str, Any]
+BuildConfigItem = Dict[str, Any]
 
 
 def _requires_open_transaction(method: _Method) -> _Method:
@@ -43,16 +43,26 @@ def wrapper(self: BuildConfig, *args: Any, **kwargs: Any) -> Any:
     return wrapper
 
 
+def _modified_by_transaction(method: _Method) -> _Method:
+    @wraps(method)
+    def wrapper(self: BuildConfig, *args: Any, **kwargs: Any) -> Any:
+        if self._transaction_open:
+            raise RuntimeError("Wait for transaction to end before using this method.")
+        return method(self, *args, **kwargs)
+
+    return wrapper
+
+
 class BuildConfig:
 
-    __slots__ = "config", "_path", "_transaction_open"
+    __slots__ = "config", "_path", "_transaction_open", "_derived_properties"
     _filename = "idom-build-config.json"
     _default_config = {"version": idom.__version__, "by_source": {}}
 
     def __init__(self, path: Path) -> None:
         self._path = path / self._filename
         self.config = self._load()
-        self._derived_properties = _derive_config_properties(self.config)
+        self._derived_properties = derive_config_properties(self.config)
         self._transaction_open = False
 
     @contextmanager
@@ -67,13 +77,21 @@ def transaction(self: _Self) -> Iterator[_Self]:
             raise
         else:
             self._save()
+            self._derived_properties = derive_config_properties(self.config)
         finally:
             self._transaction_open = False
 
+    @_requires_open_transaction
+    def update_config_items(self, config_items: Iterable[BuildConfigItem]) -> None:
+        for conf in map(validate_config_item, config_items):
+            self.config["by_source"][conf["source_name"]] = conf
+
+    @_modified_by_transaction
     def get_js_dependency_alias(self, source_name: str, dependency_name: str) -> str:
         aliases_by_src = self._derived_properties["js_dependency_aliases_by_source"]
         return aliases_by_src[source_name][dependency_name]
 
+    @_modified_by_transaction
     def all_aliased_js_dependencies(self) -> List[str]:
         return [
             dep
@@ -83,27 +101,43 @@ def all_aliased_js_dependencies(self) -> List[str]:
             for dep in aliased_deps
         ]
 
+    @_modified_by_transaction
+    def all_js_dependency_aliases(self) -> List[str]:
+        return [
+            als
+            for aliases in self._derived_properties[
+                "js_dependency_aliases_by_source"
+            ].values()
+            for als in aliases
+        ]
+
     def _load(self) -> Dict[str, Any]:
-        with self._path.open() as f:
-            return validate_config(
-                json.loads(f.read() or "null") or self._default_config
-            )
+        if not self._path.exists():
+            return deepcopy(self._default_config)
+        else:
+            with self._path.open() as f:
+                return validate_config(
+                    json.loads(f.read() or "null") or self._default_config
+                )
 
     def _save(self) -> None:
         with self._path.open("w") as f:
             json.dump(validate_config(self.config), f)
 
+    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[_ConfigItem]:
+) -> 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[_ConfigItem], List[Exception]]:
+) -> Tuple[List[BuildConfigItem], List[Exception]]:
     """Find javascript dependencies declared by Python modules
 
     Parameters:
@@ -115,7 +149,7 @@ def find_python_packages_build_config_items(
         Mapping of module names to their corresponding list of discovered dependencies.
     """
     failures: List[Tuple[str, Exception]] = []
-    build_configs: List[_ConfigItem] = []
+    build_configs: List[BuildConfigItem] = []
     for module_info in iter_modules(paths):
         module_name = module_info.name
         module_loader = module_info.module_finder.find_module(module_name)
@@ -137,7 +171,7 @@ def find_python_packages_build_config_items(
 
 def find_build_config_item_in_python_source(
     module_name: str, module_src: str
-) -> Optional[_ConfigItem]:
+) -> Optional[BuildConfigItem]:
     for node in ast.parse(module_src).body:
         if isinstance(node, ast.Assign) and (
             len(node.targets) == 1
@@ -153,12 +187,26 @@ def find_build_config_item_in_python_source(
     return None
 
 
+def split_package_name_and_version(pkg: str) -> Tuple[str, str]:
+    at_count = pkg.count("@")
+    if pkg.startswith("@"):
+        if at_count == 1:
+            return pkg, ""
+        else:
+            name, version = pkg[1:].split("@", 1)
+            return ("@" + name), version
+    elif at_count:
+        return tuple(pkg.split("@", 1))
+    else:
+        return pkg, ""
+
+
 class _DerivedConfigProperties(TypedDict):
     js_dependency_aliases_by_source: Dict[str, Dict[str, str]]
     aliased_js_dependencies_by_source: Dict[str, List[str]]
 
 
-def _derive_config_properties(config: Dict[str, Any]) -> _DerivedConfigProperties:
+def derive_config_properties(config: Dict[str, Any]) -> _DerivedConfigProperties:
     js_dependency_aliases_by_source = {}
     aliased_js_dependencies_by_source = {}
     for src, cfg in config["by_source"].items():
@@ -178,7 +226,7 @@ def _config_item_js_dependencies(
     alias_suffix = f"{config_item['source_name']}-{config_hash}"
     aliases: Dict[str, str] = {}
     aliased_js_deps: List[str] = []
-    for dep in config_item["js_dependencies"]:
+    for dep in config_item.get("js_dependencies", []):
         dep_name = split_package_name_and_version(dep)[0]
         dep_alias = f"{dep_name}-{alias_suffix}"
         aliases[dep_name] = dep_alias
@@ -209,16 +257,29 @@ def _hash_config_item(config_item: Dict[str, Any]) -> str:
         "ConfigItem": {
             "type": "object",
             "properties": {
-                "source_name": {"type": "string"},
+                "source_name": {
+                    "type": "string",
+                    "pattern": r"^[\w\d\-]+$",
+                },
                 "js_dependencies": {
                     "type": "array",
                     "items": {"type": "string"},
                 },
             },
+            "requiredProperties": ["source_name"],
         }
     },
 }
 
 
-validate_config = compile_schema(_CONFIG_SCHEMA)
-validate_config_item = compile_schema(_CONFIG_SCHEMA["definitions"]["ConfigItem"])
+_V = TypeVar("_V")
+
+
+def validate_config(value: _V) -> _V:
+    validate_schema(value, _CONFIG_SCHEMA)
+    return value
+
+
+def validate_config_item(value: _V) -> _V:
+    validate_schema(value, _CONFIG_SCHEMA["definitions"]["ConfigItem"])
+    return value

idom/client/manage.py

@@ -5,11 +5,11 @@
 from typing import Optional, Iterable, Sequence, List
 
 from .build_config import (
-    BuildConfigFile,
+    BuildConfig,
     BuildConfigItem,
     find_python_packages_build_config_items,
 )
-from .utils import open_modifiable_json, split_package_name_and_version
+from .utils import open_modifiable_json
 
 from idom.cli import console
 
@@ -18,8 +18,8 @@
 BUILD_DIR = APP_DIR / "build"
 
 
-def build_config_file() -> BuildConfigFile:
-    return BuildConfigFile(BUILD_DIR)
+def build_config() -> BuildConfig:
+    return BuildConfig(BUILD_DIR)
 
 
 def find_path(url_path: str) -> Optional[Path]:
@@ -33,7 +33,7 @@ def find_path(url_path: str) -> Optional[Path]:
 
 
 def web_module_url(source_name: str, package_name: str) -> Optional[str]:
-    config = build_config_file().configs.get(source_name)
+    config = build_config().configs.get(source_name)
     if config is None:
         return None
     if package_name not in config.js_dependency_aliases:
@@ -46,57 +46,52 @@ def web_module_url(source_name: str, package_name: str) -> Optional[str]:
 
 
 def build(
-    configs: Optional[Iterable[BuildConfigItem]] = None,
+    config_items: Optional[Iterable[BuildConfigItem]] = None,
     output_dir: Path = BUILD_DIR,
 ) -> None:
-    with build_config_file().transaction() as config_file:
-        if configs is not None:
-            config_file.add(configs, ignore_existing=True)
+    config = build_config()
+
+    with config.transaction():
+        if config_items is not None:
+            config.update_config_items(config_items)
 
         with console.spinner("Discovering dependencies"):
             configs, errors = find_python_packages_build_config_items()
             for e in errors:
                 console.echo(f"{e} because {e.__cause__}", color="red")
-            config_file.add(configs, ignore_existing=True)
-
-        with TemporaryDirectory() as tempdir:
-            tempdir_path = Path(tempdir)
-            temp_app_dir = tempdir_path / "app"
-            temp_build_dir = temp_app_dir / "build"
-            package_json_path = temp_app_dir / "package.json"
-
-            # copy over the whole APP_DIR directory into the temp one
-            shutil.copytree(APP_DIR, temp_app_dir, symlinks=True)
-
-            packages_to_install = [
-                dep
-                for conf in config_file.configs.values()
-                for dep in conf.js_dependencies
-            ]
-
-            with open_modifiable_json(package_json_path) as package_json:
-                snowpack_config = package_json.setdefault("snowpack", {})
-                snowpack_config.setdefault("install", []).extend(
-                    [
-                        split_package_name_and_version(dep)[0]
-                        for dep in packages_to_install
-                    ]
-                )
-
-            with console.spinner(
-                f"Installing {len(packages_to_install)} dependencies"
-                if packages_to_install
-                else "Installing dependencies"
-            ):
-                _npm_install(packages_to_install, temp_app_dir)
-
-            with console.spinner("Building client"):
-                _npm_run_build(temp_app_dir)
-
-            if output_dir.exists():
-                shutil.rmtree(output_dir)
-
-            shutil.copytree(temp_build_dir, output_dir, symlinks=True)
+            config.update_config_items(configs)
+
+    with TemporaryDirectory() as tempdir:
+        tempdir_path = Path(tempdir)
+        temp_app_dir = tempdir_path / "app"
+        temp_build_dir = temp_app_dir / "build"
+        package_json_path = temp_app_dir / "package.json"
+
+        # copy over the whole APP_DIR directory into the temp one
+        shutil.copytree(APP_DIR, temp_app_dir, symlinks=True)
+
+        packages_to_install = config.all_aliased_js_dependencies()
+
+        with open_modifiable_json(package_json_path) as package_json:
+            snowpack_config = package_json.setdefault("snowpack", {})
+            snowpack_config.setdefault("install", []).extend(
+                config.all_js_dependency_aliases()
+            )
+
+        with console.spinner(
+            f"Installing {len(packages_to_install)} dependencies"
+            if packages_to_install
+            else "Installing dependencies"
+        ):
+            _npm_install(packages_to_install, temp_app_dir)
+
+        with console.spinner("Building client"):
+            _npm_run_build(temp_app_dir)
+
+        if output_dir.exists():
+            shutil.rmtree(output_dir)
+
+        shutil.copytree(temp_build_dir, output_dir, symlinks=True)
 
 
 def restore() -> None: