Refactor Component loading strategy in ComponentRegistry (#148)

Author: joshuadavidthomas

CHANGELOG.md

@@ -27,6 +27,7 @@ and this project attempts to adhere to [Semantic Versioning](https://semver.org/
 ### Changed
 
 - **Internal**: Renamed `TemplateConfigurator` to `AutoConfigurator` and consolidated configuration logic.
+- **Internal**: Refactored component and asset loading strategy to track relationships between templates and components, affecting `ComponentRegistry.discover_components` and the `{% bird:asset %}` templatetag.
 
 ### Deprecated
 
@@ -35,6 +36,12 @@ and this project attempts to adhere to [Semantic Versioning](https://semver.org/
 ### Removed
 
 - Removed the deprecated `ENABLE_BIRD_ID_ATTR` setting.
+- Removed automatically discovering templates in `BASE_DIR/templates`. Templates must now be in directories configured in Django's template engine settings or app template directories.
+- Removed component scanning functionality from `BirdLoader`.
+
+### Fixed
+
+- Fixed asset loading in `{% bird:asset %}` templatetags to only render assets from components actually used in the current template by tracking template-component relationships during component discovery.
 
 ## [0.12.1]
 

src/django_bird/components.py

@@ -1,11 +1,13 @@
 from __future__ import annotations
 
+from collections import defaultdict
+from collections.abc import Generator
 from dataclasses import dataclass
 from dataclasses import field
 from hashlib import md5
 from pathlib import Path
 from threading import Lock
-from typing import TYPE_CHECKING
+from typing import Any
 
 from cachetools import LRUCache
 from django.conf import settings
@@ -14,23 +16,22 @@
 from django.template.base import NodeList
 from django.template.base import TextNode
 from django.template.context import Context
-from django.template.exceptions import TemplateDoesNotExist
 from django.template.loader import select_template
 
-from django_bird.params import Param
-from django_bird.params import Params
-from django_bird.params import Value
-from django_bird.staticfiles import Asset
-from django_bird.templatetags.tags.slot import DEFAULT_SLOT
-from django_bird.templatetags.tags.slot import SlotNode
-
 from .conf import app_settings
+from .params import Param
+from .params import Params
+from .params import Value
+from .staticfiles import Asset
 from .staticfiles import AssetType
+from .templates import gather_bird_tag_template_usage
 from .templates import get_component_directories
+from .templates import get_files_from_dirs
 from .templates import get_template_names
-
-if TYPE_CHECKING:
-    from django_bird.templatetags.tags.bird import BirdNode
+from .templates import scan_template_for_bird_tag
+from .templatetags.tags.bird import BirdNode
+from .templatetags.tags.slot import DEFAULT_SLOT
+from .templatetags.tags.slot import SlotNode
 
 
 @dataclass(frozen=True, slots=True)
@@ -73,6 +74,15 @@ def path(self):
     def source(self):
         return self.template.template.source
 
+    @property
+    def used_in(self):
+        return components.get_template_usage(self.name)
+
+    @classmethod
+    def from_abs_path(cls, path: Path, root: Path) -> Component | None:
+        name = str(path.relative_to(root).with_suffix("")).replace("/", ".")
+        return cls.from_name(name)
+
     @classmethod
     def from_name(cls, name: str):
         template_names = get_template_names(name)
@@ -180,41 +190,39 @@ def id(self):
 
 class ComponentRegistry:
     def __init__(self, maxsize: int = 100):
+        self._component_usage: dict[str, set[Path]] = defaultdict(set)
         self._components: LRUCache[str, Component] = LRUCache(maxsize=maxsize)
+        self._template_usage: dict[Path, set[str]] = defaultdict(set)
 
     def discover_components(self) -> None:
         component_dirs = get_component_directories()
+        component_paths = get_files_from_dirs(component_dirs)
+        for component_abs_path, root_abs_path in component_paths:
+            if component_abs_path.suffix != ".html":
+                continue
 
-        for component_dir in component_dirs:
-            component_dir = Path(component_dir)
-
-            if not component_dir.is_dir():
+            component = Component.from_abs_path(component_abs_path, root_abs_path)
+            if component is None:
                 continue
 
-            for component_path in component_dir.rglob("*.html"):
-                component_name = str(
-                    component_path.relative_to(component_dir).with_suffix("")
-                ).replace("/", ".")
-                try:
-                    component = Component.from_name(component_name)
-                    self._components[component_name] = component
-                except TemplateDoesNotExist:
-                    continue
-
-    def clear(self) -> None:
-        """Clear the registry. Mainly useful for testing."""
-        self._components.clear()
+            if component.name not in self._components:
+                self._components[component.name] = component
 
-    def get_component(self, name: str) -> Component:
-        try:
-            if not settings.DEBUG:
-                return self._components[name]
-        except KeyError:
-            pass
+        templates_using_bird_tag = gather_bird_tag_template_usage()
+        for template_abs_path, root_abs_path in templates_using_bird_tag:
+            if self._template_usage.get(template_abs_path, None) is not None:
+                continue
 
-        component = Component.from_name(name)
-        self._components[name] = component
-        return component
+            template_name = template_abs_path.relative_to(root_abs_path)
+            for component_name in scan_template_for_bird_tag(str(template_name)):
+                self._template_usage[template_abs_path].add(component_name)
+                self._component_usage[component_name].add(template_abs_path)
+
+    def reset(self) -> None:
+        """Reset the registry, used for testing."""
+        self._component_usage = defaultdict(set)
+        self._components.clear()
+        self._template_usage = defaultdict(set)
 
     def get_assets(self, asset_type: AssetType | None = None) -> frozenset[Asset]:
         return frozenset(
@@ -224,5 +232,25 @@ def get_assets(self, asset_type: AssetType | None = None) -> frozenset[Asset]:
             if asset_type is None or asset.type == asset_type
         )
 
+    def get_component(self, name: str) -> Component:
+        if name in self._components and not settings.DEBUG:
+            return self._components[name]
+
+        self._components[name] = Component.from_name(name)
+        if name not in self._component_usage:
+            self._component_usage[name] = set()
+        return self._components[name]
+
+    def get_component_usage(
+        self, template_path: str | Path
+    ) -> Generator[Component, Any, None]:
+        path = Path(template_path) if isinstance(template_path, str) else template_path
+        for component_name in self._template_usage.get(path, set()):
+            yield Component.from_name(component_name)
+
+    def get_template_usage(self, component: str | Component) -> frozenset[Path]:
+        name = component.name if isinstance(component, Component) else component
+        return frozenset(self._component_usage.get(name, set()))
+
 
 components = ComponentRegistry()

src/django_bird/loader.py

@@ -4,21 +4,13 @@
 import re
 
 from django.core.cache import cache
-from django.template.base import Node
 from django.template.base import Origin
-from django.template.base import Template
-from django.template.context import Context
 from django.template.engine import Engine
-from django.template.loader_tags import ExtendsNode
-from django.template.loader_tags import IncludeNode
 from django.template.loaders.filesystem import Loader as FileSystemLoader
 
-from ._typing import _has_nodelist
 from ._typing import override
 from .compiler import Compiler
-from .components import components
 from .templatetags.tags.bird import TAG
-from .templatetags.tags.bird import BirdNode
 
 BIRD_TAG_PATTERN = re.compile(rf"{{%\s*{TAG}\s+([^\s%}}]+)")
 
@@ -35,40 +27,9 @@ def get_contents(self, origin: Origin) -> str:
         if not BIRD_TAG_PATTERN.search(contents):
             return contents
 
-        template = Template(contents, origin=origin, engine=self.engine)
-        context = Context()
-        with context.bind_template(template):
-            self._ensure_components_loaded(template, context)
-
         cache_key = f"bird_component_{hashlib.md5(contents.encode()).hexdigest()}"
         compiled = cache.get(cache_key)
         if compiled is None:
             compiled = self.compiler.compile(contents)
             cache.set(cache_key, compiled, timeout=None)
         return compiled
-
-    def _ensure_components_loaded(
-        self, node: Template | Node, context: Context
-    ) -> None:
-        """Ensure all components used in the template are loaded."""
-        if isinstance(node, BirdNode):
-            components.get_component(node.name)
-
-        if not _has_nodelist(node) or node.nodelist is None:
-            return
-
-        for child in node.nodelist:
-            if isinstance(child, BirdNode):
-                components.get_component(child.name)
-
-            if isinstance(child, ExtendsNode):
-                parent_template = child.get_parent(context)
-                self._ensure_components_loaded(parent_template, context)
-
-            if isinstance(child, IncludeNode):
-                template_name = child.template.token.strip("'\"")
-                included_template = self.engine.get_template(template_name)
-                self._ensure_components_loaded(included_template, context)
-
-            if hasattr(child, "nodelist"):
-                self._ensure_components_loaded(child, context)