Remove component discovery at startup (#214)

* Remove component discovery at startup

This change removes the upfront component discovery at application startup
and replaces it with on-demand discovery when templates are rendered. This should
significantly improve startup performance for applications with many components.

Key changes:
- Remove ComponentRegistry.discover_components() method
- Update get_component_names_used_in_template() to perform on-demand scanning
- Add find_components_in_template() function for template scanning
- Update BirdAssetFinder to scan components directly when needed
- Update tests to work with on-demand component discovery

* Fix static file collection for components with same name in different directories

This commit improves how django-bird collects static assets from components:
- Add from_template method to derive component name from template paths
- Modify Component initialization to handle same-named components in different dirs
- Update static file collection to include assets from all components regardless of precedence

* fix tests

* update changelog

Author: joshuadavidthomas

CHANGELOG.md

@@ -27,9 +27,18 @@ and this project attempts to adhere to [Semantic Versioning](https://semver.org/
 - Added management command `generate_asset_manifest` for pre-computing template-component relationships
 - Added automatic fallback to component scanning in development mode (when DEBUG=True)
 
+### Changed
+
+- Improved static file collection to include assets from all component directories
+
+### Fixed
+
+- Fixed bug where assets from components with the same name in different directories weren't being properly collected
+
 ### Removed
 
 - Removed automatic component scanning at application startup for faster initialization
+- **Internal**: Removed `ComponentRegistry.discover_components` method.
 
 ## [0.16.2]
 

src/django_bird/components.py

@@ -26,13 +26,12 @@
 from .plugins import pm
 from .staticfiles import Asset
 from .staticfiles import AssetType
-from .templates import gather_bird_tag_template_usage
+from .templates import find_components_in_template
 from .templates import get_component_directories
 from .templates import get_template_names
 from .templatetags.tags.bird import BirdNode
 from .templatetags.tags.slot import DEFAULT_SLOT
 from .templatetags.tags.slot import SlotNode
-from .utils import get_files_from_dirs
 
 
 @dataclass(frozen=True, slots=True)
@@ -76,17 +75,34 @@ def source(self):
         return self.template.template.source
 
     @classmethod
-    def from_abs_path(cls, path: Path, root: Path) -> Component:
-        name = str(path.relative_to(root).with_suffix("")).replace("/", ".")
-        return cls.from_name(name)
+    def from_abs_path(cls, path: Path) -> Component:
+        template = select_template([str(path)])
+        return cls.from_template(template)
 
     @classmethod
-    def from_name(cls, name: str):
+    def from_name(cls, name: str) -> Component:
         template_names = get_template_names(name)
         template = select_template(template_names)
+        return cls.from_template(template)
+
+    @classmethod
+    def from_template(cls, template: DjangoTemplate) -> Component:
+        template_path = Path(template.template.origin.name)
+
+        for component_dir in get_component_directories():
+            try:
+                relative_path = template_path.relative_to(component_dir)
+                name = str(relative_path.with_suffix("")).replace("/", ".")
+                break
+            except ValueError:
+                continue
+        else:
+            name = template_path.stem
+
         assets: list[Iterable[Asset]] = pm.hook.collect_component_assets(
             template_path=Path(template.template.origin.name)
         )
+
         return cls(
             name=name, template=template, assets=frozenset(itertools.chain(*assets))
         )
@@ -182,24 +198,6 @@ def __init__(self):
         self._components: dict[str, Component] = {}
         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
-
-            component = Component.from_abs_path(component_abs_path, root_abs_path)
-
-            if component.name not in self._components:
-                self._components[component.name] = component
-
-        templates_using_bird_tag = gather_bird_tag_template_usage()
-        for template_abs_path, component_names in templates_using_bird_tag:
-            self._template_usage[template_abs_path] = component_names
-            for component_name in component_names:
-                self._component_usage[component_name].add(template_abs_path)
-
     def reset(self) -> None:
         """Reset the registry, used for testing."""
         self._component_usage = defaultdict(set)
@@ -227,8 +225,19 @@ def get_component_names_used_in_template(
         self, template_path: str | Path
     ) -> set[str]:
         """Get names of components used in a template."""
-        path = Path(template_path) if isinstance(template_path, str) else template_path
-        return self._template_usage.get(path, set())
+
+        path = Path(template_path)
+
+        if path in self._template_usage:
+            return self._template_usage[path]
+
+        components = find_components_in_template(template_path)
+
+        self._template_usage[path] = components
+        for component_name in components:
+            self._component_usage[component_name].add(path)
+
+        return components
 
     def get_component_usage(
         self, template_path: str | Path

src/django_bird/staticfiles.py

@@ -1,8 +1,8 @@
 from __future__ import annotations
 
+import logging
 from collections.abc import Callable
 from collections.abc import Iterable
-from collections.abc import Sequence
 from dataclasses import dataclass
 from enum import Enum
 from pathlib import Path
@@ -25,6 +25,9 @@
 from .conf import app_settings
 from .templates import get_component_directories
 from .templatetags.tags.asset import AssetTag
+from .utils import get_files_from_dirs
+
+logger = logging.getLogger(__name__)
 
 if TYPE_CHECKING:
     from .components import Component
@@ -174,14 +177,6 @@ def __init__(self, *args: Any, prefix: str, **kwargs: Any):
 
 @final
 class BirdAssetFinder(BaseFinder):
-    def __init__(
-        self, app_names: Sequence[str] | None = None, *args: Any, **kwargs: Any
-    ) -> None:
-        from .components import components
-
-        self.components = components
-        super().__init__(*args, **kwargs)
-
     @override
     def check(self, **kwargs: Any) -> list[CheckMessage]:
         return []
@@ -237,12 +232,34 @@ def list(
     ) -> Iterable[tuple[str, FileSystemStorage]]:
         """
         Return (relative_path, storage) pairs for all assets.
+
+        This method is used by Django's collectstatic command to find
+        all assets that should be collected.
         """
-        self.components.discover_components()
 
-        for asset in self.components.get_assets():
-            if ignore_patterns and any(
-                asset.relative_path.match(pattern) for pattern in set(ignore_patterns)
-            ):
+        from django_bird.components import Component
+
+        component_dirs = get_component_directories()
+
+        for path, _ in get_files_from_dirs(component_dirs):
+            if path.suffix != ".html":
+                continue
+
+            try:
+                component = Component.from_abs_path(path)
+
+                for asset in component.assets:
+                    if ignore_patterns and any(
+                        asset.relative_path.match(pattern)
+                        for pattern in set(ignore_patterns)
+                    ):
+                        logger.debug(
+                            f"Skipping asset {asset.path} due to ignore pattern"
+                        )
+                        continue
+
+                    yield str(asset.relative_path), asset.storage
+
+            except Exception as e:
+                logger.error(f"Error loading component {path}: {e}")
                 continue
-            yield str(asset.relative_path), asset.storage

src/django_bird/templates.py

@@ -130,18 +130,34 @@ def _process_template_chunk(  # pragma: no cover
 ) -> list[tuple[Path, set[str]]]:
     results: list[tuple[Path, set[str]]] = []
     for path, root in templates:
-        visitor = NodeVisitor(Engine.get_default())
         template_name = str(path.relative_to(root))
-        try:
-            template = Engine.get_default().get_template(template_name)
-        except (TemplateDoesNotExist, TemplateSyntaxError):
-            continue
+        components = find_components_in_template(template_name)
+        if components:
+            results.append((path, components))
+    return results
+
+
+def find_components_in_template(template_path: str | Path) -> set[str]:
+    """Find all component names used in a specific template.
+
+    Args:
+        template_path: Path to the template file or template name
+
+    Returns:
+        set[str]: Set of component names used in the template
+    """
+    template_name = str(template_path)
+
+    visitor = NodeVisitor(Engine.get_default())
+    try:
+        template = Engine.get_default().get_template(template_name)
         context = Context()
         with context.bind_template(template):
             visitor.visit(template, context)
-        if visitor.components:
-            results.append((path, visitor.components))
-    return results
+        return visitor.components
+    except (TemplateDoesNotExist, TemplateSyntaxError):
+        # If we can't load the template, return an empty set
+        return set()
 
 
 NodeVisitorMethod = Callable[[Template | Node, Context], None]

tests/templatetags/test_asset.py

@@ -98,8 +98,6 @@ def test_template_inheritence(self, create_template, templates_dir, registry):
             {% endblock %}
         """)
 
-        registry.discover_components()
-
         template = create_template(child_path)
 
         rendered = template.render({})
@@ -151,8 +149,6 @@ def test_template_inheritence_no_bird_usage(
             {% endblock %}
         """)
 
-        registry.discover_components()
-
         template = create_template(child_path)
 
         rendered = template.render({})
@@ -230,8 +226,6 @@ def test_component_render_order(self, create_template, templates_dir, registry):
             </html>
         """)
 
-        registry.discover_components()
-
         template = create_template(template_path)
 
         rendered = template.render({})
@@ -294,8 +288,6 @@ def test_asset_duplication(self, create_template, templates_dir, registry):
             {% endblock %}
         """)
 
-        registry.discover_components()
-
         template = get_template(child_path.name)
 
         rendered = template.render({})
@@ -359,8 +351,6 @@ def test_unused_component_asset_not_rendered(
             {% endblock %}
         """)
 
-        registry.discover_components()
-
         template = create_template(child_path)
 
         rendered = template.render({})
@@ -424,8 +414,6 @@ def test_asset_tag_with_manifest_in_production(
         </html>
         """)
 
-        registry.discover_components()
-
         manifest_data = generate_asset_manifest()
 
         manifest_path = static_root / "django_bird"
@@ -467,8 +455,6 @@ def test_asset_tag_in_debug_mode(
         </html>
         """)
 
-        registry.discover_components()
-
         manifest_data = {"not/a/real/template.html": ["not-button"]}
 
         manifest_path = static_root / "django_bird"
@@ -516,8 +502,6 @@ def test_asset_tag_fallback_when_template_not_in_manifest(
         <html><body>Other template</body></html>
         """)
 
-        registry.discover_components()
-
         manifest_data = {str(other_path): ["button"]}
 
         manifest_path = static_root / "django_bird"