rename config "item" to "entry"

Author: rmorshea

idom/client/build_config.py

@@ -23,50 +23,64 @@
 import idom
 
 
-ConfigItem = Dict[str, Any]
+ConfigEntry = Dict[str, Any]
 
 
 class BuildConfig:
 
-    __slots__ = "data", "_path", "_item_info"
+    __slots__ = "data", "_path", "_entry_info"
     _filename = "idom-build-config.json"
-    _default_config = {"version": idom.__version__, "items": {}}
+    _default_config = {"version": idom.__version__, "entries": {}}
 
     def __init__(self, path: Path) -> None:
         self._path = path / self._filename
         self.data = self._load()
-        self._item_info: Dict[str, ConfigItemInfo] = {
-            name: derive_config_item_info(item)
-            for name, item in self.data["items"].items()
+        self._entry_info: Dict[str, ConfigEntryInfo] = {
+            name: derive_config_entry_info(entry)
+            for name, entry in self.data["entries"].items()
         }
 
-    def clear_items(self) -> None:
-        self.data["items"].clear()
-        self._item_info.clear()
+    def get_entry(self, source_name: str) -> ConfigEntry:
+        return self.data["entries"][source_name]
 
-    def update_items(self, config_items: Iterable[Dict[str, Any]]) -> None:
+    def get_entry_info(self, source_name: str) -> "ConfigEntryInfo":
+        return self._entry_info[source_name]
+
+    def clear_entries(self) -> None:
+        self.data["entries"].clear()
+        self._entry_info.clear()
+
+    def update_entries(self, config_entries: Iterable[Dict[str, Any]]) -> None:
         # a useful debug assertion - the error which would result otherwise is confusing
-        assert not isinstance(config_items, dict), "expected list, not a dict"
+        assert not isinstance(config_entries, dict), "expected list, not a dict"
 
         for conf in map(
             # BUG: https://github.com/python/mypy/issues/6697
-            validate_config_item,  # type: ignore
-            config_items,
+            validate_config_entry,  # type: ignore
+            config_entries,
         ):
             src_name = conf["source_name"]
-            self.data["items"][src_name] = conf
-            self._item_info[src_name] = derive_config_item_info(conf)
+            self.data["entries"][src_name] = conf
+            self._entry_info[src_name] = derive_config_entry_info(conf)
+
+    def has_entry(self, source_name: str) -> bool:
+        return source_name in self.data["entries"]
 
-    def has_config_item(self, source_name: str) -> bool:
-        return source_name in self.data["items"]
+    def entry_has_dependency(self, source_name: str, dependency: str) -> bool:
+        name, _ = split_package_name_and_version(dependency)
+        entry_info = self.get_entry_info(source_name)
+        return (
+            name in entry_info.js_dependency_aliases
+            or name == entry_info.js_package_def.name
+        )
 
     def resolve_js_dependency_name(
         self,
         source_name: str,
         dependency_name: str,
     ) -> Optional[str]:
         try:
-            info = self._item_info[source_name]
+            info = self._entry_info[source_name]
         except KeyError:
             return None
         if info.js_package_def is not None:
@@ -82,7 +96,7 @@ def resolve_js_dependency_name(
 
     def all_js_dependencies(self) -> List[str]:
         deps: List[str] = []
-        for info in self._item_info.values():
+        for info in self._entry_info.values():
             if info.js_package_def is not None:
                 deps.append(str(info.js_package_def.path))
             else:
@@ -91,7 +105,7 @@ def all_js_dependencies(self) -> List[str]:
 
     def all_js_dependency_names(self) -> List[str]:
         names: List[str] = []
-        for info in self._item_info.values():
+        for info in self._entry_info.values():
             if info.js_package_def is not None:
                 names.append(info.js_package_def.name)
             else:
@@ -115,9 +129,9 @@ def __repr__(self) -> str:
         return f"{type(self).__name__}({self.data})"
 
 
-def find_python_packages_build_config_items(
+def find_python_packages_build_config_entries(
     paths: Optional[List[str]] = None,
-) -> Tuple[List[ConfigItem], List[Exception]]:
+) -> Tuple[List[ConfigEntry], List[Exception]]:
     """Find javascript dependencies declared by Python modules
 
     Parameters:
@@ -129,7 +143,7 @@ def find_python_packages_build_config_items(
         Mapping of module names to their corresponding list of discovered dependencies.
     """
     failures: List[Exception] = []
-    build_configs: List[ConfigItem] = []
+    build_configs: List[ConfigEntry] = []
     for module_info in iter_modules(paths):
         module_name = module_info.name
         module_loader = module_info.module_finder.find_module(module_name)
@@ -138,7 +152,7 @@ def find_python_packages_build_config_items(
                 module_filename = module_loader.get_filename(module_name)
                 if isinstance(module_filename, bytes):  # pragma: no cover
                     module_filename = module_filename.decode()
-                conf = find_build_config_item_in_python_file(
+                conf = find_build_config_entry_in_python_file(
                     module_name, Path(module_filename)
                 )
             except Exception as cause:
@@ -153,9 +167,9 @@ def find_python_packages_build_config_items(
     return build_configs, failures
 
 
-def find_build_config_item_in_python_file(
+def find_build_config_entry_in_python_file(
     module_name: str, module_path: Path
-) -> Optional[ConfigItem]:
+) -> Optional[ConfigEntry]:
     with module_path.open() as f:
         module_src = f.read()
 
@@ -165,7 +179,7 @@ def find_build_config_item_in_python_file(
             and isinstance(node.targets[0], ast.Name)
             and node.targets[0].id == "idom_build_config"
         ):
-            config_item = validate_config_item(
+            config_entry = validate_config_entry(
                 {
                     "source_name": module_name,
                     **eval(
@@ -177,13 +191,13 @@ def find_build_config_item_in_python_file(
                     ),
                 }
             )
-            if "js_package" in config_item:
+            if "js_package" in config_entry:
                 js_pkg = module_path.parent.joinpath(
-                    *config_item["js_package"].split("/")
+                    *config_entry["js_package"].split("/")
                 )
-                config_item["js_package"] = str(js_pkg.resolve().absolute())
-            config_item.setdefault("source_name", module_name)
-            return config_item
+                config_entry["js_package"] = str(js_pkg.resolve().absolute())
+            config_entry.setdefault("source_name", module_name)
+            return config_entry
 
     return None
 
@@ -208,49 +222,49 @@ class JsPackageDef(NamedTuple):
     name: str
 
 
-class ConfigItemInfo(NamedTuple):
+class ConfigEntryInfo(NamedTuple):
     js_dependency_aliases: Dict[str, str]
     aliased_js_dependencies: List[str]
     js_package_def: Optional[JsPackageDef]
 
 
-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}"
+def derive_config_entry_info(config_entry: Dict[str, Any]) -> ConfigEntryInfo:
+    config_hash = _hash_config_entry(config_entry)
+    alias_suffix = f"{config_entry['source_name']}-{config_hash}"
     aliases: Dict[str, str] = {}
     aliased_js_deps: List[str] = []
-    for dep in config_item.get("js_dependencies", []):
+    for dep in config_entry.get("js_dependencies", []):
         dep_name = split_package_name_and_version(dep)[0]
         dep_alias = f"{dep_name}-{alias_suffix}"
         aliases[dep_name] = dep_alias
         aliased_js_deps.append(f"{dep_alias}@npm:{dep}")
 
     js_pkg_def: Optional[JsPackageDef]
-    if "js_package" in config_item:
-        js_pkg_path = Path(config_item["js_package"])
+    if "js_package" in config_entry:
+        js_pkg_path = Path(config_entry["js_package"])
         js_pkg_json = js_pkg_path / "package.json"
         try:
             with js_pkg_json.open() as f:
                 js_pkg_name = str(json.load(f)["name"])
         except FileNotFoundError as error:
             raise ValueError(
                 f"Path to package {str(js_pkg_json)!r} specified by "
-                f"{config_item['source_name']!r} does not exist"
+                f"{config_entry['source_name']!r} does not exist"
             ) from error
         else:
             js_pkg_def = JsPackageDef(path=js_pkg_path, name=js_pkg_name)
     else:
         js_pkg_def = None
 
-    return ConfigItemInfo(
+    return ConfigEntryInfo(
         js_dependency_aliases=aliases,
         aliased_js_dependencies=aliased_js_deps,
         js_package_def=js_pkg_def,
     )
 
 
-def _hash_config_item(config_item: Dict[str, Any]) -> str:
-    conf_hash = sha256(json.dumps(config_item, sort_keys=True).encode())
+def _hash_config_entry(config_entry: Dict[str, Any]) -> str:
+    conf_hash = sha256(json.dumps(config_entry, sort_keys=True).encode())
     short_hash_int = (
         int(conf_hash.hexdigest(), 16)
         # chop off the last 8 digits (no need for that many)
@@ -263,13 +277,13 @@ def _hash_config_item(config_item: Dict[str, Any]) -> str:
     "type": "object",
     "properties": {
         "version": {"type": "string"},
-        "items": {
+        "entries": {
             "type": "object",
-            "patternProperties": {".*": {"$ref": "#/definitions/ConfigItem"}},
+            "patternProperties": {".*": {"$ref": "#/definitions/ConfigEntry"}},
         },
     },
     "definitions": {
-        "ConfigItem": {
+        "ConfigEntry": {
             "type": "object",
             "properties": {
                 "source_name": {
@@ -291,7 +305,7 @@ def _hash_config_item(config_item: Dict[str, Any]) -> str:
         }
     },
 }
-_CONFIG_ITEM_SCHEMA = _CONFIG_SCHEMA["definitions"]["ConfigItem"]
+_CONFIG_ITEM_SCHEMA = _CONFIG_SCHEMA["definitions"]["ConfigEntry"]
 
 
 _V = TypeVar("_V", bound=Any)
@@ -302,6 +316,6 @@ def validate_config(value: _V) -> _V:
     return value
 
 
-def validate_config_item(value: _V) -> _V:
+def validate_config_entry(value: _V) -> _V:
     validate_schema(value, _CONFIG_ITEM_SCHEMA)
     return value

idom/client/manage.py

@@ -6,8 +6,8 @@
 
 from .build_config import (
     BuildConfig,
-    ConfigItem,
-    find_python_packages_build_config_items,
+    ConfigEntry,
+    find_python_packages_build_config_entries,
 )
 from .utils import open_modifiable_json, find_js_module_exports_in_source
 
@@ -51,19 +51,19 @@ def web_module_exists(source_name: str, package_name: str) -> bool:
         return True
 
 
-def build(config_items: Iterable[ConfigItem] = ()) -> None:
+def build(config_items: Iterable[ConfigEntry] = ()) -> None:
     config = build_config()
     with console.spinner("Discovering dependencies"):
-        py_pkg_configs, errors = find_python_packages_build_config_items()
+        py_pkg_configs, errors = find_python_packages_build_config_entries()
     for e in errors:  # pragma: no cover
         console.echo(f"{e} because {e.__cause__}", message_color="red")
-    config.update_items(py_pkg_configs + list(config_items))
+    config.update_entries(py_pkg_configs + list(config_items))
     _build_and_save_config()
 
 
 def restore() -> None:
     config = build_config()
-    config.clear_items()
+    config.clear_entries()
     _build_and_save_config()
 
 

scripts/install_doc_js_modules.py

@@ -1,18 +1,18 @@
 from pathlib import Path
 
-from idom.client.build_config import find_build_config_item_in_python_file
+from idom.client.build_config import find_build_config_entry_in_python_file
 from idom.client.manage import build, build_config
 
 
 DOCS_PATH = Path(__file__).parent.parent / "docs"
 
 
 def install_doc_js_modules():
-    config_item = find_build_config_item_in_python_file(
+    config_item = find_build_config_entry_in_python_file(
         "__main__", DOCS_PATH / "main.py"
     )
     if config_item is not None:
-        if not build_config().has_config_item(config_item["source_name"]):
+        if not build_config().has_entry(config_item["source_name"]):
             build([config_item])
 
 

tests/conftest.py

@@ -276,7 +276,7 @@ def _clean_last_server_error(last_server_error) -> Iterator[None]:
 def install():
     def add_dependency(*packages):
         config = build_config()
-        if not config.has_config_item("tests"):
+        if not config.has_entry("tests"):
             build_client(
                 [
                     {
@@ -287,7 +287,7 @@ def add_dependency(*packages):
             )
         else:
             to_install = set(packages)
-            already_installed = config.data["items"]["tests"]["js_dependencies"]
+            already_installed = config.get_entry("tests")["js_dependencies"]
             not_installed_pkgs = to_install.difference(already_installed)
             if not_installed_pkgs:
                 build_client(
@@ -307,11 +307,11 @@ def add_dependency(*packages):
 @pytest.fixture
 def temp_build_config():
     config = build_config()
-    original_cfgs = [deepcopy(cfg) for cfg in config.data["items"].values()]
+    original_cfgs = [deepcopy(cfg) for cfg in config.data["entries"].values()]
     try:
         yield config
     finally:
-        config.update_items(original_cfgs)
+        config.update_entries(original_cfgs)
         config.save()