feat: Add template components (#263)

Co-authored-by: sourcery-ai[bot] <58596630+sourcery-ai[bot]@users.noreply.github.com>

Author: fsbraun

.github/workflows/codecov.yml

@@ -22,6 +22,9 @@ jobs:
         os: [
             ubuntu-latest,
         ]
+        exclude:
+          - python-version: "3.12"
+            requirements-file: dj42_cms311.txt
 
     steps:
     - uses: actions/checkout@v4
@@ -32,9 +35,9 @@ jobs:
       uses: actions/setup-python@v5
       with:
         python-version: ${{ matrix.python-version }}
-    - name: Intall dependencies
+    - name: Install dependencies
       run: |
-        pip install -r tests/requirements/${{ matrix.requirements-file }}
+        pip install -U -r tests/requirements/${{ matrix.requirements-file }}
     - name: Run coverage
       run: |
         coverage run -m pytest

djangocms_frontend/apps.py

@@ -8,7 +8,9 @@ class DjangocmsFrontendConfig(apps.AppConfig):
 
     def ready(self):
         from . import plugin_tag
+        from . import component_pool
 
+        component_pool.setup()
         plugin_tag.setup()
         checks.register(check_settings)
         checks.register(check_installed_apps)

djangocms_frontend/cms_plugins.py

@@ -1,23 +1,26 @@
 from cms.plugin_pool import plugin_pool
 
-from .component_pool import components
 from .ui_plugin_base import CMSUIPluginBase
 
 
 class CMSUIPlugin(CMSUIPluginBase):
     pass
 
 
-# Loop through the values in the components' registry
-for _, plugin, slot_plugins in components._registry.values():
-    # Add the plugin to the global namespace
-    globals()[plugin.__name__] = plugin
-    # Register the plugin with the plugin pool
-    plugin_pool.register_plugin(plugin)
+def update_plugin_pool():
+    from .component_pool import components
 
-    # Loop through the slot plugins associated with the current plugin
-    for slot_plugin in slot_plugins:
-        # Add the slot plugin to the global namespace
-        globals()[slot_plugin.__name__] = slot_plugin
-        # Register the slot plugin with the plugin pool
-        plugin_pool.register_plugin(slot_plugin)
+    # Loop through the values in the components' registry
+    for _, plugin, slot_plugins in components._registry.values():
+        if plugin.__name__ not in plugin_pool.plugins:
+            # Add the plugin to the global namespace
+            globals()[plugin.__name__] = plugin
+            # Register the plugin with the plugin pool
+            plugin_pool.register_plugin(plugin)
+
+            # Loop through the slot plugins associated with the current plugin
+            for slot_plugin in slot_plugins:
+                # Add the slot plugin to the global namespace
+                globals()[slot_plugin.__name__] = slot_plugin
+                # Register the slot plugin with the plugin pool
+                plugin_pool.register_plugin(slot_plugin)

djangocms_frontend/component_base.py

@@ -1,16 +1,12 @@
 import importlib
 import typing
 
-from cms.api import add_plugin
-from cms.plugin_base import CMSPluginBase
 from django import forms
 from django.apps import apps
 from django.utils.encoding import force_str
 from django.utils.translation import gettext_lazy as _
 from entangled.forms import EntangledModelForm
 
-from .ui_plugin_base import CMSUIComponent
-
 
 def _import_or_empty(module, name):
     try:
@@ -31,6 +27,14 @@ def _get_mixin_classes(mixins: list, suffix: str = "") -> list[type]:
     return [_import_or_empty(module, name) for module, name in mixins]
 
 
+class classproperty:
+    def __init__(self, fget):
+        self.fget = fget
+
+    def __get__(self, obj, owner):
+        return self.fget(owner)
+
+
 class Slot:
     """Slat class as syntactic surgar to more easily define slot plugins"""
 
@@ -104,7 +108,7 @@ def plugin_model_factory(cls) -> type:
             from djangocms_frontend.models import FrontendUIItem
 
             app_config = apps.get_containing_app_config(cls.__module__)
-            if app_config is None:
+            if app_config is None:  # pragma: no cover
                 raise ValueError(f"Cannot find app_config for {cls.__module__}")
             cls._model = type(
                 cls.__name__,
@@ -124,13 +128,15 @@ def plugin_model_factory(cls) -> type:
                         },
                     ),
                     "get_short_description": cls.get_short_description,
-                    "__module__": "djangocms_frontend.contrib.component.models",
+                    "__module__": cls.__module__,
                 },
             )
         return cls._model
 
     @classmethod
     def plugin_factory(cls) -> type:
+        from .ui_plugin_base import CMSUIComponent
+
         if cls._plugin is None:
             mixins = getattr(cls._component_meta, "mixins", [])
             slots = cls.get_slot_plugins()
@@ -168,12 +174,15 @@ def plugin_factory(cls) -> type:
                         if hasattr(cls, "get_render_template")
                         else {}
                     ),
+                    "__module__": cls.__module__,
                 },
             )
         return cls._plugin
 
     @classmethod
     def slot_plugin_factory(cls) -> list[type]:
+        from cms.plugin_base import CMSPluginBase
+
         slots = cls.get_slot_plugins()
         return [
             type(
@@ -184,7 +193,9 @@ def slot_plugin_factory(cls) -> list[type]:
                     "module": getattr(cls._component_meta, "module", _("Component")),
                     "allow_children": True,
                     "edit_disabled": True,
-                    "parent_classes": cls.__name__ + "Plugin",
+                    "is_local": False,
+                    "show_add_form": False,
+                    "parent_classes": [cls.__name__ + "Plugin"],
                     "render_template": cls.slot_template,
                     **slot.kwargs,
                 },
@@ -200,8 +211,7 @@ def get_registration(cls) -> tuple[type, type, list[type]]:
             cls.slot_plugin_factory(),
         )
 
-    @classmethod
-    @property
+    @classproperty
     def _component_meta(cls) -> typing.Optional[type]:
         return getattr(cls, "Meta", None)
 
@@ -214,6 +224,8 @@ def get_short_description(self) -> str:
 
     def save_model(self, request, obj, form: forms.Form, change: bool) -> None:
         """Auto-creates slot plugins upon creation of component plugin instance"""
+        from cms.api import add_plugin
+        from .ui_plugin_base import CMSUIComponent
 
         super(CMSUIComponent, self).save_model(request, obj, form, change)
         if not change:

djangocms_frontend/component_pool.py

@@ -1,14 +1,121 @@
+from collections import defaultdict
+import importlib
+import os
+from collections.abc import Iterator
 import warnings
 
+from django import forms
+from django.apps import apps
+from django.template.loader import get_template
 from django.utils.module_loading import autodiscover_modules
 
+from sekizai.context import SekizaiContext
+
+from djangocms_frontend import settings
+from djangocms_frontend.component_base import CMSFrontendComponent
+
+
+def find_cms_component_templates() -> list[tuple[str, str]]:
+    templates = []
+    for app in apps.get_app_configs():
+        app_template_dir = os.path.join(app.path, "templates", app.label, "cms_components")
+        if os.path.exists(app_template_dir):
+            for root, _, files in os.walk(app_template_dir):
+                for file in files:
+                    if file.endswith(".html") or file.endswith(".htm"):
+                        relative_path = os.path.relpath(os.path.join(root, file), app_template_dir)
+                        templates.append((app.module.__name__, f"{app.label}/cms_components/{relative_path}"))
+    return templates
+
+
+class CMSAutoComponentDiscovery:
+    default_field_context = {
+        "djanghocms_text": "djangocms_text.fields.TextFormField",
+        "djanghocms_text_ckeditor": "djangocms_text_ckeditor.fields.TextFormField",
+        "djangocms_link": "djangocms_link.fields.LinkFormField",
+        "djangocms_frontend": [
+            "djangocms_frontend.contrib.image.fields.ImageFormField",
+            "djangocms_frontend.contrib.icon.fields.IconPickerField",
+        ],
+    }
+
+    def __init__(self, register_to):
+        self.default_field_context.update(settings.COMPONENT_FIELDS)
+        templates = find_cms_component_templates()
+        auto_components = self.scan_templates_for_component_declaration(templates)
+        for component in auto_components:
+            register_to.register(component)
+
+    def get_field_context(self) -> dict:
+        field_context = {}
+        for key, value in self.default_field_context.items():
+            if apps.is_installed(key):
+                if not isinstance(value, list):
+                    value = [value]
+                for field in value:
+                    if "." in field:
+                        module, field_name = field.rsplit(".", 1)
+                        field_context[field_name] = importlib.import_module(module).__dict__[field_name]
+        return field_context
+
+    @staticmethod
+    def component_factory(module, component: tuple, fields: list[tuple], template: str) -> CMSFrontendComponent:
+        args, kwargs = component
+        (name,) = args
+
+        kwargs["render_template"] = template
+        meta = type("Meta", (), kwargs)
+        return type(
+            name,
+            (CMSFrontendComponent,),
+            {
+                "Meta": meta,
+                "__module__": module,
+                **{
+                    # Django template engine instantiates objects -- re-instantiate them here
+                    args[0]: args[1].__class__(**kwargs)
+                    for args, kwargs in fields
+                    if isinstance(args[1], forms.Field)
+                },
+            },
+        )
+
+    def scan_templates_for_component_declaration(
+        self, templates: list[tuple[str, str]]
+    ) -> Iterator[CMSFrontendComponent]:
+        from django.forms import fields
+
+        field_context = self.get_field_context()
+        for module, template_name in templates:
+            # Create a new context for each template
+            context = SekizaiContext(
+                {"_cms_components": defaultdict(list), "forms": fields, "instance": {}, **field_context}
+            )
+            try:
+                template = get_template(template_name)
+                template.template.render(context)
+                cms_component = context["_cms_components"].get("cms_component", [])
+                discovered_fields = context["_cms_components"].get("fields", [])
+                if len(cms_component) == 1:
+                    yield self.component_factory(module, cms_component[0], discovered_fields, template_name)
+                elif len(cms_component) > 1:  # pragma: no cover
+                    raise ValueError(f"Multiple cms_component tags found in {template_name}")
+            except Exception:  # pragma: no cover
+                # Skip all templates that do not render
+                import logging
+
+                logger = logging.getLogger(__name__)
+                logger.error(
+                    f"Error rendering template {template_name} to scan for cms frontend components", exc_info=True
+                )
+
 
 class Components:
     _registry: dict = {}
     _discovered: bool = False
 
     def register(self, component):
-        if component.__name__ in self._registry:
+        if component.__name__ in self._registry:  # pragma: no cover
             warnings.warn(f"Component {component.__name__} already registered", stacklevel=2)
             return component
         self._registry[component.__name__] = component.get_registration()
@@ -20,6 +127,26 @@ def __getitem__(self, item):
 
 components = Components()
 
-if not components._discovered:
-    autodiscover_modules("cms_components", register_to=components)
-    components._discovered = True
+
+def setup():
+    global components
+
+    if not components._discovered:
+        from .cms_plugins import update_plugin_pool
+
+        # First discover components in cms_components module
+        autodiscover_modules("cms_components", register_to=components)
+        # The discover auto components by their templates
+        CMSAutoComponentDiscovery(register_to=components)
+        update_plugin_pool()
+        components._discovered = True
+
+        if text_config := apps.get_app_config("djangocms_text"):
+            # Hack - update inline editable fields in case djangocms_text is installed
+            # BEFORE djangocms_frontend in INSTALLED_APPS
+            if text_config.inline_models:
+                # Already initialized? Need to initialize again
+                # to reflect inline fields in of just discovered components
+                from djangocms_text.apps import discover_inline_editable_models
+
+                text_config.inline_models = discover_inline_editable_models()

djangocms_frontend/contrib/link/cms_plugins.py

@@ -42,7 +42,7 @@ class LinkPluginMixin:
     def render(self, context, instance, placeholder):
         if "request" in context:
             instance._cms_page = getattr(context["request"], "current_page", None)
-        context["link"] = instance.get_link()
+        context["mixin_link"] = instance.get_link()
         return super().render(context, instance, placeholder)
 
     def get_form(self, request, obj=None, change=False, **kwargs):
@@ -97,4 +97,4 @@ def get_render_template(self, context, instance, placeholder):
     if "djangocms_link" in django_settings.INSTALLED_APPS:
         from djangocms_link.cms_plugins import LinkPlugin
 
-        LinkPlugin.parent_classes = [None]  # Remove it from the list of valid plugins
+        LinkPlugin.parent_classes = [""]  # Remove it from the list of valid plugins

djangocms_frontend/contrib/link/templates/djangocms_frontend/bootstrap5/link/default/link.html

@@ -1 +1 @@
-{% load cms_tags frontend %}{% if link %}<a href="{{ link }}"{% if instance.target %} target="{{ instance.target }}"{% endif %}{{ instance.get_attributes }}>{% endif %}{% if instance.icon_left %}{% include "djangocms_frontend/bootstrap5/link/default/icon.html" with icon_class=instance.icon_left attribute_class="me-1" %}{% endif %}{% for plugin in instance.child_plugin_instances %}{% render_plugin plugin %}{% empty %}{{ instance.name }}{% endfor %}{% if instance.icon_right %}{% include "djangocms_frontend/bootstrap5/link/default/icon.html" with icon_class=instance.icon_right attribute_class="ms-1" %}{% endif %}{% if link %}</a>{% endif %}
+{% load cms_tags frontend %}{% if mixin_link %}<a href="{{ mixin_link }}"{% if instance.target %} target="{{ instance.target }}"{% endif %}{{ instance.get_attributes }}>{% endif %}{% if instance.icon_left %}{% include "djangocms_frontend/bootstrap5/link/default/icon.html" with icon_class=instance.icon_left attribute_class="me-1" %}{% endif %}{% for plugin in instance.child_plugin_instances %}{% render_plugin plugin %}{% empty %}{{ instance.name }}{% endfor %}{% if instance.icon_right %}{% include "djangocms_frontend/bootstrap5/link/default/icon.html" with icon_class=instance.icon_right attribute_class="ms-1" %}{% endif %}{% if link %}</a>{% endif %}

djangocms_frontend/fields.py

@@ -1,4 +1,5 @@
 from django import forms
+from django.apps import apps
 from django.core.exceptions import ValidationError
 from django.db import models
 from django.utils.safestring import mark_safe
@@ -9,6 +10,19 @@
 from .helpers import first_choice
 
 
+if apps.is_installed("djangocms_text"):
+    from djangocms_text.fields import HTMLFormField  # noqa F401
+
+    HTMLsanitized = True
+elif apps.is_installed("djangocms_text_ckeditor"):  # pragma: no cover
+    from djangocms_text_ckeditor.fields import HTMLFormField  # noqa F401
+
+    HTMLsanitized = True
+else:  # pragma: no cover
+    HTMLFormField = forms.CharField
+    HTMLsanitized = False
+
+
 class TemplateChoiceMixin:
     """Mixin that hides the template field if only one template is available and is selected"""
 
@@ -168,12 +182,3 @@ class Media:
     def __init__(self, *args, **kwargs):
         kwargs.setdefault("attrs", {"class": "auto-field"})
         super().__init__(*args, **kwargs)
-
-
-try:
-    from djangocms_text_ckeditor.fields import HTMLFormField  # noqa
-
-    HTMLsanitized = True
-except ModuleNotFoundError:
-    HTMLFormField = forms.CharField
-    HTMLsanitized = False

djangocms_frontend/settings.py

@@ -76,6 +76,7 @@
 
 FORM_OPTIONS = getattr(django_settings, "DJANGOCMS_FRONTEND_FORM_OPTIONS", {})
 
+COMPONENT_FIELDS = getattr(django_settings, "DJANGOCMS_FRONTEND_COMPONENT_FIELDS", {})
 
 framework = getattr(django_settings, "DJANGOCMS_FRONTEND_FRAMEWORK", "bootstrap5")
 theme = getattr(django_settings, "DJANGOCMS_FRONTEND_THEME", "djangocms_frontend")