more testing

Author: rmorshea

idom/cli/settings.py

@@ -8,14 +8,26 @@
 IDOM_CLI_DEBUG = False
 
 
+_to_str = {
+    bool: lambda x: str(int(x)),
+    str: lambda x: x,
+    list: lambda x: ",".join(x),
+}
+
+_from_str = {
+    bool: lambda x: bool(int(x)),
+    str: lambda x: x,
+    list: lambda x: x.split(","),
+}
+
+
 def _load_from_environ():
     gs = globals()
     for k, v in globals().items():
         if k.startswith("IDOM_"):
-            if isinstance(v, bool):
-                gs[k] = bool(int(os.environ.setdefault(k, str(int(v)))))
-            else:
-                gs[k] = os.environ.setdefault(k, v)
+            v_type = type(v)
+            default = _to_str[v_type](v)
+            gs[k] = _from_str[v_type](os.environ.setdefault(k, default))
             NAMES.append(k)
 
 

idom/client/build_config.py

@@ -3,8 +3,6 @@
 import json
 import ast
 from copy import deepcopy
-from functools import wraps
-from contextlib import contextmanager
 from hashlib import sha256
 from pathlib import Path
 from importlib.machinery import SourceFileLoader
@@ -14,114 +12,71 @@
     Dict,
     Optional,
     Any,
-    Iterator,
     Iterable,
     TypeVar,
     Tuple,
-    Callable,
-    TypedDict,
+    NamedTuple,
 )
 
 from jsonschema import validate as validate_schema
 
 import idom
 
 
-_Self = TypeVar("_Self")
-_Method = TypeVar("_Method", bound=Callable[..., Any])
-
-BuildConfigItem = Dict[str, Any]
-
-
-def _requires_open_transaction(method: _Method) -> _Method:
-    @wraps(method)
-    def wrapper(self: BuildConfig, *args: Any, **kwargs: Any) -> Any:
-        if not self._transaction_open:
-            raise RuntimeError(
-                f"BuildConfig method {method.__name__!r} must be used in a transaction."
-            )
-        return method(self, *args, **kwargs)
-
-    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(
-                f"BuildConfig method {method.__name__!r} cannot be used in a transaction."
-            )
-        return method(self, *args, **kwargs)
-
-    return wrapper
+ConfigItem = Dict[str, Any]
 
 
 class BuildConfig:
 
-    __slots__ = "config", "_path", "_transaction_open", "_derived_properties"
+    __slots__ = "data", "_path", "_item_info"
     _filename = "idom-build-config.json"
-    _default_config = {"version": idom.__version__, "by_source": {}}
+    _default_config = {"version": idom.__version__, "items": {}}
 
     def __init__(self, path: Path) -> None:
         self._path = path / self._filename
-        self.config = self._load()
-        self._derived_properties = derive_config_properties(self.config)
-        self._transaction_open = False
-
-    @contextmanager
-    def transaction(self: _Self) -> Iterator[_Self]:
-        """Open a transaction to modify the config file state"""
-        self._transaction_open = True
-        old_config = deepcopy(self.config)
-        try:
-            yield self
-        except Exception:
-            self.config = old_config
-            raise
-        else:
-            self._save()
-            self._derived_properties = derive_config_properties(self.config)
-        finally:
-            self._transaction_open = False
+        self.data = self._load()
+        self._item_info: Dict[str, ConfigItemInfo] = {
+            name: derive_config_item_info(item)
+            for name, item in self.data["items"].items()
+        }
 
-    @_requires_open_transaction
-    def update_config_items(self, config_items: Iterable[BuildConfigItem]) -> None:
+    def update(self, config_items: Iterable[ConfigItem]) -> None:
         for conf in map(validate_config_item, config_items):
-            self.config["by_source"][conf["source_name"]] = conf
+            src_name = conf["source_name"]
+            self.data["items"][src_name] = conf
+            self._item_info[src_name] = derive_config_item_info(conf)
+
+    def has_config_item(self, source_name: str) -> bool:
+        return source_name in self.data["items"]
 
-    @_modified_by_transaction
     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"]
         try:
-            return aliases_by_src[source_name][dependency_name]
+            return self._item_info[source_name].js_dependency_aliases[dependency_name]
         except KeyError:
             return None
 
-    @_modified_by_transaction
     def all_aliased_js_dependencies(self) -> List[str]:
         return [
             dep
-            for aliased_deps in self._derived_properties[
-                "aliased_js_dependencies_by_source"
-            ].values()
-            for dep in aliased_deps
+            for info in self._item_info.values()
+            for dep in info.aliased_js_dependencies
         ]
 
-    @_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.values()
+            alias
+            for info in self._item_info.values()
+            for alias in info.js_dependency_aliases.values()
         ]
 
+    def save(self) -> None:
+        with self._path.open("w") as f:
+            json.dump(validate_config(self.data), f)
+
     def _load(self) -> Dict[str, Any]:
         if not self._path.exists():
             return deepcopy(self._default_config)
@@ -131,17 +86,13 @@ def _load(self) -> Dict[str, Any]:
                     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})"
+        return f"{type(self).__name__}({self.data})"
 
 
 def find_python_packages_build_config_items(
     paths: Optional[List[str]] = None,
-) -> Tuple[List[BuildConfigItem], List[Exception]]:
+) -> Tuple[List[ConfigItem], List[Exception]]:
     """Find javascript dependencies declared by Python modules
 
     Parameters:
@@ -153,7 +104,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[BuildConfigItem] = []
+    build_configs: List[ConfigItem] = []
     for module_info in iter_modules(paths):
         module_name = module_info.name
         module_loader = module_info.module_finder.find_module(module_name)
@@ -175,14 +126,14 @@ def find_python_packages_build_config_items(
 
 def find_build_config_item_in_python_file(
     module_name: str, path: Path
-) -> Optional[BuildConfigItem]:
+) -> Optional[ConfigItem]:
     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]:
+) -> Optional[ConfigItem]:
     for node in ast.parse(module_src).body:
         if isinstance(node, ast.Assign) and (
             len(node.targets) == 1
@@ -212,28 +163,13 @@ def split_package_name_and_version(pkg: str) -> Tuple[str, str]:
         return pkg, ""
 
 
-class _DerivedConfigProperties(TypedDict):
-    js_dependency_aliases_by_source: Dict[str, Dict[str, str]]
-    aliased_js_dependencies_by_source: Dict[str, List[str]]
-
+class ConfigItemInfo(NamedTuple):
+    js_dependency_aliases: Dict[str, str]
+    aliased_js_dependencies: List[str]
 
-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():
-        cfg_hash = _hash_config_item(cfg)
-        aliases, aliased_js_deps = _config_item_js_dependencies(cfg, cfg_hash)
-        js_dependency_aliases_by_source[src] = aliases
-        aliased_js_dependencies_by_source[src] = aliased_js_deps
-    return {
-        "js_dependency_aliases_by_source": js_dependency_aliases_by_source,
-        "aliased_js_dependencies_by_source": aliased_js_dependencies_by_source,
-    }
 
-
-def _config_item_js_dependencies(
-    config_item: Dict[str, Any], config_hash: str
-) -> Tuple[Dict[str, str], List[str]]:
+def derive_config_item_info(config_item: Dict[str, Any]) -> ConfigItemInfo:
+    config_hash = _hash_config_item(config_item)
     alias_suffix = f"{config_item['source_name']}-{config_hash}"
     aliases: Dict[str, str] = {}
     aliased_js_deps: List[str] = []
@@ -242,7 +178,10 @@ def _config_item_js_dependencies(
         dep_alias = f"{dep_name}-{alias_suffix}"
         aliases[dep_name] = dep_alias
         aliased_js_deps.append(f"{dep_alias}@npm:{dep}")
-    return aliases, aliased_js_deps
+    return ConfigItemInfo(
+        js_dependency_aliases=aliases,
+        aliased_js_dependencies=aliased_js_deps,
+    )
 
 
 def _hash_config_item(config_item: Dict[str, Any]) -> str:
@@ -259,7 +198,7 @@ def _hash_config_item(config_item: Dict[str, Any]) -> str:
     "type": "object",
     "properties": {
         "version": {"type": "string"},
-        "by_source": {
+        "items": {
             "type": "object",
             "patternProperties": {".*": {"$ref": "#/definitions/ConfigItem"}},
         },
@@ -278,6 +217,7 @@ def _hash_config_item(config_item: Dict[str, Any]) -> str:
                 },
             },
             "requiredProperties": ["source_name"],
+            "additionalProperties": False,
         }
     },
 }

idom/client/manage.py

@@ -6,7 +6,7 @@
 
 from .build_config import (
     BuildConfig,
-    BuildConfigItem,
+    ConfigItem,
     find_python_packages_build_config_items,
 )
 from .utils import open_modifiable_json, find_js_module_exports_in_source
@@ -51,27 +51,13 @@ def web_module_exists(source_name: str, package_name: str) -> bool:
         return True
 
 
-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: Iterable[BuildConfigItem] = ()) -> None:
+def build(config_items: Iterable[ConfigItem] = ()) -> None:
     config = build_config()
-
-    with config.transaction():
-        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.update_config_items(configs)
+    with console.spinner("Discovering dependencies"):
+        py_pkg_configs, errors = find_python_packages_build_config_items()
+        for e in errors:  # pragma: no cover
+            console.echo(f"{e} because {e.__cause__}", color="red")
+    config.update(py_pkg_configs + config_items)
 
     with TemporaryDirectory() as tempdir:
         tempdir_path = Path(tempdir)
@@ -105,10 +91,13 @@ def build(config_items: Iterable[BuildConfigItem] = ()) -> None:
 
         shutil.copytree(temp_build_dir, BUILD_DIR, symlinks=True)
 
+    config.save()
+
 
 def restore() -> None:
     with console.spinner("Restoring"):
-        shutil.rmtree(BUILD_DIR)
+        if BUILD_DIR.exists():
+            shutil.rmtree(BUILD_DIR)
         _run_subprocess(["npm", "install"], APP_DIR)
         _run_subprocess(["npm", "run", "build"], APP_DIR)
 
@@ -121,12 +110,12 @@ def _web_module_alias_and_file_path(
         raise WebModuleError(
             f"Package {package_name!r} is not declared as a dependency of {source_name!r}"
         )
-    module_file = find_client_build_path(f"web_modules/{alias}.js")
-    if module_file is None:
+    builtin_path = BUILD_DIR.joinpath("web_modules", *f"{alias}.js".split("/"))
+    if not builtin_path.exists():
         raise WebModuleError(
             f"Dependency {package_name!r} of {source_name!r} was not installed"
         )
-    return alias, module_file
+    return alias, builtin_path
 
 
 def _npm_install(packages: Sequence[str], cwd: Path) -> None: