simple-module-core 0.0.25__tar.gz → 0.0.27__tar.gz

{simple_module_core-0.0.25 → simple_module_core-0.0.27}/.gitignore

@@ -45,6 +45,7 @@ docs/.vitepress/dist/
 host/client_app/modules.manifest.json
 host/client_app/modules.generated.ts
 host/client_app/modules.generated.css
+host/client_app/modules.assets.json
 
 # Worktrees
 .worktrees/

{simple_module_core-0.0.25 → simple_module_core-0.0.27}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simple_module_core
-Version: 0.0.25
+Version: 0.0.27
 Summary: Module-system primitives for the simple_module framework — ModuleBase, discovery, diagnostics, events
 Project-URL: Homepage, https://github.com/antosubash/simple_module_python
 Project-URL: Repository, https://github.com/antosubash/simple_module_python

{simple_module_core-0.0.25 → simple_module_core-0.0.27}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "simple_module_core"
-version = "0.0.25"
+version = "0.0.27"
 description = "Module-system primitives for the simple_module framework — ModuleBase, discovery, diagnostics, events"
 readme = "README.md"
 license = "MIT"

{simple_module_core-0.0.25 → simple_module_core-0.0.27}/simple_module_core/__init__.py

@@ -1,5 +1,6 @@
 """SimpleModule Core - Module system, menu, permissions, events, and diagnostics."""
 
+from simple_module_core.design_packs import DesignPack, DesignPackRegistry
 from simple_module_core.diagnostics import (
     DiagnosticLevel,
     MigrationDiagnostics,
@@ -40,6 +41,8 @@ from simple_module_core.versioning import FRAMEWORK_API_VERSION, check_framework
 __all__ = [
     "FRAMEWORK_API_VERSION",
     "CircularDependencyError",
+    "DesignPack",
+    "DesignPackRegistry",
     "DiagnosticLevel",
     "Event",
     "EventBus",

simple_module_core-0.0.27/simple_module_core/design_packs.py

@@ -0,0 +1,88 @@
+"""Design-pack registry — modules contribute a selectable look for the public site.
+
+A *design pack* is a stylesheet a module ships that restyles the reader-facing
+site by overriding the base design tokens beneath a ``<value>-root`` class. A
+module declares the packs it provides via
+:meth:`~simple_module_core.module.ModuleBase.register_design_packs`; the host
+collects them into one registry at boot and stores it on
+``app.state.design_packs``.
+
+**The registry supplies the dropdown, not the stylesheet.** A pack's CSS still
+reaches the bundle through the host's ``styles.css`` importing it by package
+specifier. The registry's only job is to stop an administrator selecting a pack
+that no installed module provides — which would otherwise put a class on the
+document with nothing behind it and silently do nothing.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+
+SLUG_RE = re.compile(r"^[a-z0-9][a-z0-9-]*$")
+"""A pack slug: lowercase alphanumerics and dashes, not starting with a dash.
+
+The site root class is ``f"{value}-root"``, so the slug has to be usable as a
+bare CSS identifier fragment.
+"""
+
+
+@dataclass(frozen=True)
+class DesignPack:
+    """One selectable look.
+
+    Args:
+        value: Slug identifying the pack. The public site's root element
+            carries ``f"{value}-root"``, which is the hook the pack's own
+            stylesheet selects on.
+        label: Human-readable name, shown in the branding dropdown.
+    """
+
+    value: str
+    label: str
+
+    def __post_init__(self) -> None:
+        if not SLUG_RE.match(self.value):
+            raise ValueError(
+                f"DesignPack value {self.value!r} is not a usable class-name "
+                f"fragment; it must match {SLUG_RE.pattern}"
+            )
+
+
+class DesignPackRegistry:
+    """Aggregates every module's :class:`DesignPack` declarations.
+
+    Populated once during boot (``register_design_packs`` hook) and read
+    thereafter — by the branding view to build its dropdown, and by the
+    branding API to validate a submitted slug.
+    """
+
+    def __init__(self) -> None:
+        self._packs: dict[str, DesignPack] = {}
+
+    def register(self, pack: DesignPack) -> None:
+        """Add *pack*, rejecting a slug another module already claimed.
+
+        Duplicate slugs are an error rather than a silent overwrite: two packs
+        sharing one root class would leave whichever stylesheet happened to
+        load last in charge, which is not something an administrator could
+        diagnose from the UI.
+        """
+        existing = self._packs.get(pack.value)
+        if existing is not None:
+            raise ValueError(
+                f"Design pack {pack.value!r} is already registered "
+                f"(as {existing.label!r}); slugs must be unique across modules"
+            )
+        self._packs[pack.value] = pack
+
+    def all(self) -> list[DesignPack]:
+        """Every registered pack, in registration order (a copy)."""
+        return list(self._packs.values())
+
+    def has(self, value: str) -> bool:
+        """Return ``True`` if some module registered a pack with this slug."""
+        return value in self._packs
+
+
+__all__ = ["DesignPack", "DesignPackRegistry"]

simple_module_core-0.0.27/simple_module_core/diagnostics/_css.py

@@ -0,0 +1,214 @@
+"""SM022/SM023: module CSS placed in the file with the wrong cascade position.
+
+A module ships its styles in two files, and which one a construct lands in
+decides how it cascades:
+
+* ``theme.css`` is imported **unlayered**, because a ``@theme`` block inside a
+  cascade layer registers no design tokens at all. Unlayered CSS also outranks
+  every layered rule, so a plain rule here would beat any Tailwind utility.
+* ``styles.css`` is imported into ``layer(components)``, so its rules always
+  lose to a utility — which is what you want for component CSS, and useless
+  for ``@theme``.
+
+Both codes are warnings, not errors: the misplaced CSS is legal and builds
+fine, it just cascades in a way the author almost certainly did not intend.
+
+Detection is a line-oriented scan that tracks brace depth, not a CSS parse —
+adding a CSS parser as a runtime dependency to power a lint is not worth it.
+This catches the ordinary mistake of putting a construct in the wrong file; it
+is not a conformance checker, and pathological input (an at-rule assembled by
+preprocessing, say) is out of scope.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from simple_module_core.diagnostics._types import Diagnostic, DiagnosticLevel
+
+if TYPE_CHECKING:
+    from simple_module_core.module import ModuleBase
+
+THEME_CSS = "theme.css"
+STYLES_CSS = "styles.css"
+
+# Constructs that only do anything unlayered, so they belong in theme.css.
+THEME_ONLY_AT_RULES = ("@theme", "@custom-variant", "@utility")
+
+
+def _top_level_preludes(text: str) -> list[tuple[str, int]]:
+    """Return ``(prelude, line_number)`` for every top-level construct.
+
+    A "prelude" is the selector or at-rule text preceding a top-level ``{``,
+    or a whole statement at-rule terminated by ``;`` at depth 0. Anything
+    nested inside braces is skipped, which is what keeps a rule inside
+    ``@layer components { ... }`` from being mistaken for a top-level one.
+
+    Comments and quoted strings are consumed inline rather than pre-stripped,
+    because a brace inside either is not structural. ``content: "{"`` in an
+    icon-font rule would otherwise desynchronise the depth counter for the
+    whole rest of the file — every later top-level construct would be read as
+    nested and silently skipped.
+
+    A quote only opens a string when its partner is found before the line
+    ends, which is the rule CSS itself applies (a string cannot contain a raw
+    newline). Treating every quote as an opener is what makes an *unmatched*
+    one dangerous: the lone apostrophe in ``url(it's.png); }`` would swallow
+    the closing brace on that same line and desync the counter permanently.
+    An unmatched quote is therefore just an ordinary character.
+    """
+    out: list[tuple[str, int]] = []
+    depth = 0
+    buf: list[str] = []
+    line = 1
+    buf_line = 1
+    i = 0
+    n = len(text)
+
+    def flush() -> None:
+        prelude = "".join(buf).strip()
+        if prelude:
+            out.append((prelude, buf_line))
+
+    def string_end(start: int, quote: str) -> int | None:
+        """Index just past the closing quote, or None if it never closes."""
+        j = start + 1
+        while j < n:
+            c = text[j]
+            if c == "\\":
+                # An escape consumes the next character whole — including a
+                # newline, the one way a CSS string legitimately spans lines.
+                j += 2
+                continue
+            if c == "\n":
+                return None
+            if c == quote:
+                return j + 1
+            j += 1
+        return None
+
+    while i < n:
+        ch = text[i]
+
+        if ch == "/" and i + 1 < n and text[i + 1] == "*":
+            end = text.find("*/", i + 2)
+            end = n if end == -1 else end + 2
+            line += text.count("\n", i, end)
+            i = end
+            continue
+
+        if ch == "\\" and i + 1 < n:
+            # CSS escapes apply outside strings too — Tailwind leans on this
+            # heavily (`.mt-\[773px\]`). Consuming the pair keeps an escaped
+            # quote from being mistaken for a string opener, which is also
+            # what stops `\'` repeated across a long line from making
+            # string_end re-scan that line once per quote (quadratic).
+            if depth == 0:
+                if not buf:
+                    buf_line = line
+                buf.append(text[i : i + 2])
+            if text[i + 1] == "\n":
+                line += 1
+            i += 2
+            continue
+
+        if ch in "\"'":
+            end = string_end(i, ch)
+            if end is not None:
+                if depth == 0:
+                    if not buf:
+                        buf_line = line
+                    buf.append(text[i:end])
+                line += text.count("\n", i, end)
+                i = end
+                continue
+            # Unmatched: fall through and treat it as an ordinary character.
+
+        if ch == "{":
+            if depth == 0:
+                flush()
+                buf.clear()
+            depth += 1
+        elif ch == "}":
+            depth = max(0, depth - 1)
+            if depth == 0:
+                buf.clear()
+        elif depth == 0:
+            if ch == ";":
+                flush()
+                buf.clear()
+            elif buf:
+                buf.append(ch)
+            elif not ch.isspace():
+                # Start the buffer at the first non-space character, so
+                # buf_line points at the construct rather than at whatever
+                # blank lines preceded it.
+                buf_line = line
+                buf.append(ch)
+
+        if ch == "\n":
+            line += 1
+        i += 1
+    return out
+
+
+def _is_root_selector(prelude: str) -> bool:
+    """True if every comma-separated part of the selector is :root-based.
+
+    ``:root``, ``:root[data-theme="dark"]`` and a comma-separated list of both
+    are the normal way to declare design tokens, so they are legitimate in
+    theme.css even though they are plain rules.
+    """
+    parts = [p.strip() for p in prelude.split(",") if p.strip()]
+    return bool(parts) and all(p.startswith(":root") for p in parts)
+
+
+def check_module_css(mod: ModuleBase, src_dir: Path) -> list[Diagnostic]:
+    """Warn when module CSS sits in the file with the wrong cascade position."""
+    diagnostics: list[Diagnostic] = []
+
+    styles = src_dir / STYLES_CSS
+    if styles.is_file():
+        for prelude, line in _top_level_preludes(styles.read_text("utf-8")):
+            at_rule = prelude.split()[0].lower() if prelude.split() else ""
+            if at_rule in THEME_ONLY_AT_RULES:
+                diagnostics.append(
+                    Diagnostic(
+                        level=DiagnosticLevel.WARNING,
+                        code="SM022",
+                        message=(
+                            f"{at_rule} in {STYLES_CSS} is inert — that file is "
+                            "imported into layer(components)"
+                        ),
+                        module_name=mod.meta.name,
+                        file=f"{styles}:{line}",
+                        suggestion=(
+                            f"Move the {at_rule} block to {src_dir / THEME_CSS}, which is "
+                            "imported unlayered so its tokens actually register"
+                        ),
+                    )
+                )
+
+    theme = src_dir / THEME_CSS
+    if theme.is_file():
+        for prelude, line in _top_level_preludes(theme.read_text("utf-8")):
+            if prelude.startswith("@") or _is_root_selector(prelude):
+                continue
+            diagnostics.append(
+                Diagnostic(
+                    level=DiagnosticLevel.WARNING,
+                    code="SM023",
+                    message=(
+                        f"Unlayered rule '{prelude}' in {THEME_CSS} outranks every Tailwind utility"
+                    ),
+                    module_name=mod.meta.name,
+                    file=f"{theme}:{line}",
+                    suggestion=(
+                        f"Move it to {src_dir / STYLES_CSS}, which is imported into "
+                        "layer(components) so utilities still win"
+                    ),
+                )
+            )
+
+    return diagnostics

{simple_module_core-0.0.25 → simple_module_core-0.0.27}/simple_module_core/diagnostics/_module.py

@@ -7,6 +7,7 @@ from pathlib import Path
 from typing import TYPE_CHECKING
 
 from simple_module_core.diagnostics._coupling import check_framework_module_coupling
+from simple_module_core.diagnostics._css import check_module_css
 from simple_module_core.diagnostics._inertia_api import check_inertia_api_calls
 from simple_module_core.diagnostics._js_workspace import check_js_workspace_files
 from simple_module_core.diagnostics._pages import check_pages, find_render_calls
@@ -37,6 +38,7 @@ class ModuleDiagnostics:
                 diagnostics.extend(check_pages(mod, src_dir, rendered_pages))
                 diagnostics.extend(check_js_workspace_files(mod, src_dir))
                 diagnostics.extend(check_inertia_api_calls(mod, src_dir))
+                diagnostics.extend(check_module_css(mod, src_dir))
 
         return diagnostics
 

{simple_module_core-0.0.25 → simple_module_core-0.0.27}/simple_module_core/module.py

@@ -10,6 +10,7 @@ from typing import TYPE_CHECKING
 if TYPE_CHECKING:
     from fastapi import APIRouter, FastAPI
 
+    from simple_module_core.design_packs import DesignPackRegistry
     from simple_module_core.events import EventBus
     from simple_module_core.feature_flags import FeatureFlagRegistry
     from simple_module_core.health import HealthRegistry
@@ -137,6 +138,22 @@ class ModuleBase(ABC):
         mutations. Called once at boot, in dependency order.
         """
 
+    def register_design_packs(self, registry: DesignPackRegistry) -> None:
+        """Declare design packs this module ships for the public site.
+
+        A design pack is a stylesheet that restyles the reader-facing site by
+        overriding the base tokens beneath a ``<value>-root`` class. Override
+        this hook to make the pack selectable in branding::
+
+            def register_design_packs(self, registry):
+                registry.register(DesignPack(value="gca", label="Canopy Atlas"))
+
+        Registering only advertises the pack — the stylesheet itself still
+        reaches the bundle through the host's ``styles.css``. Slugs are unique
+        across modules; a collision raises at boot. Called once, in dependency
+        order.
+        """
+
     def register_middleware(self, app: FastAPI) -> None:
         """Add middleware to the application.
 

{simple_module_core-0.0.25 → simple_module_core-0.0.27}/simple_module_core/services.py

@@ -20,6 +20,7 @@ if TYPE_CHECKING:
     from simple_module_db.session import DatabaseState
     from simple_module_hosting.settings import Settings
 
+    from simple_module_core.design_packs import DesignPackRegistry
     from simple_module_core.events import EventBus
     from simple_module_core.feature_flags import FeatureFlagRegistry
     from simple_module_core.health import HealthRegistry
@@ -42,6 +43,7 @@ class Services:
     feature_flags: FeatureFlagRegistry
     health_registry: HealthRegistry
     public_routes: PublicRouteRegistry
+    design_packs: DesignPackRegistry
     i18n_registry: I18nRegistry
     inertia_config: InertiaConfig
     modules: tuple[ModuleBase, ...]

simple_module_core-0.0.27/tests/test_css_diagnostics.py

@@ -0,0 +1,97 @@
+"""SM022/SM023 — module CSS placed in the wrong file.
+
+The theme.css / styles.css split is what makes the cascade rules structural
+rather than merely documented, so putting a construct in the wrong file
+produces surprising-but-legal CSS. Both codes are warnings for that reason:
+the build succeeds either way.
+"""
+
+from __future__ import annotations
+
+
+def _mod():
+    from simple_module_core import ModuleBase, ModuleMeta
+
+    class Styled(ModuleBase):
+        meta = ModuleMeta(name="Styled")
+
+    return Styled()
+
+
+class TestSm022ThemeConstructsInStylesCss:
+    def test_theme_at_rule_in_styles_css(self, tmp_path):
+        """@theme inside styles.css is inert — styles.css is imported layered."""
+        from simple_module_core.diagnostics._css import check_module_css
+
+        (tmp_path / "styles.css").write_text("@theme {\n  --color-x: red;\n}\n")
+
+        diags = check_module_css(_mod(), tmp_path)
+
+        assert [d.code for d in diags] == ["SM022"]
+        assert diags[0].level.value == "warning"
+
+    def test_custom_variant_in_styles_css(self, tmp_path):
+        from simple_module_core.diagnostics._css import check_module_css
+
+        (tmp_path / "styles.css").write_text("@custom-variant dark (&:where(.dark, .dark *));\n")
+
+        assert [d.code for d in check_module_css(_mod(), tmp_path)] == ["SM022"]
+
+    def test_utility_at_rule_in_styles_css(self, tmp_path):
+        from simple_module_core.diagnostics._css import check_module_css
+
+        (tmp_path / "styles.css").write_text("@utility tab-4 {\n  tab-size: 4;\n}\n")
+
+        assert [d.code for d in check_module_css(_mod(), tmp_path)] == ["SM022"]
+
+    def test_reports_the_offending_line(self, tmp_path):
+        from simple_module_core.diagnostics._css import check_module_css
+
+        (tmp_path / "styles.css").write_text(
+            "@layer components {\n  .x { color: red; }\n}\n\n@theme {\n  --a: 1;\n}\n"
+        )
+
+        diags = check_module_css(_mod(), tmp_path)
+
+        assert len(diags) == 1
+        # Line number rides in `file` as path:line, matching _inertia_api.py.
+        assert diags[0].file.endswith("styles.css:5")
+
+
+class TestSm023UnlayeredRulesInThemeCss:
+    def test_plain_rule_in_theme_css(self, tmp_path):
+        """An unlayered rule in theme.css outranks every Tailwind utility."""
+        from simple_module_core.diagnostics._css import check_module_css
+
+        (tmp_path / "theme.css").write_text(".card {\n  padding: 0;\n}\n")
+
+        diags = check_module_css(_mod(), tmp_path)
+
+        assert [d.code for d in diags] == ["SM023"]
+        assert diags[0].level.value == "warning"
+
+    def test_root_block_allowed(self, tmp_path):
+        """:root custom-property blocks are legitimate in theme.css."""
+        from simple_module_core.diagnostics._css import check_module_css
+
+        (tmp_path / "theme.css").write_text("@theme {\n  --a: 1;\n}\n:root {\n  --b: 2;\n}\n")
+
+        assert check_module_css(_mod(), tmp_path) == []
+
+    def test_root_variants_allowed(self, tmp_path):
+        """Dark-mode token blocks keyed off :root are the normal pattern."""
+        from simple_module_core.diagnostics._css import check_module_css
+
+        (tmp_path / "theme.css").write_text(':root,\n:root[data-theme="dark"] {\n  --b: 2;\n}\n')
+
+        assert check_module_css(_mod(), tmp_path) == []
+
+    def test_font_face_allowed(self, tmp_path):
+        """@font-face is explicitly part of what theme.css is for."""
+        from simple_module_core.diagnostics._css import check_module_css
+
+        (tmp_path / "theme.css").write_text(
+            "@font-face {\n  font-family: X;\n  src: url(x.woff2);\n}\n"
+        )
+
+        assert check_module_css(_mod(), tmp_path) == []

simple_module_core-0.0.27/tests/test_css_scanner.py

@@ -0,0 +1,242 @@
+"""The CSS scanner behind SM022/SM023.
+
+`check_module_css` is only as good as its ability to find *top-level*
+constructs, and it does that with a hand-rolled brace-depth scan rather than a
+CSS parse — no parser joins the runtime dependencies to power a lint. These
+tests pin the tokenising rules that scan depends on: comments, quoted strings,
+escapes, and the line numbers reported alongside a finding.
+
+Every case here is a bug that shipped at some point during review: each one is
+a way a stray character silently desynced the depth counter and made the lint
+stop reporting anything at all.
+"""
+
+from __future__ import annotations
+
+
+def _mod():
+    from simple_module_core import ModuleBase, ModuleMeta
+
+    class Styled(ModuleBase):
+        meta = ModuleMeta(name="Styled")
+
+    return Styled()
+
+
+class TestScannerRobustness:
+    def test_nested_at_rule_not_flagged(self, tmp_path):
+        """Only top-level constructs count — brace depth is tracked."""
+        from simple_module_core.diagnostics._css import check_module_css
+
+        (tmp_path / "styles.css").write_text("@layer components {\n  .x { color: red; }\n}\n")
+
+        assert check_module_css(_mod(), tmp_path) == []
+
+    def test_nested_rule_in_theme_css_not_flagged(self, tmp_path):
+        """A rule nested inside @theme is not a top-level rule."""
+        from simple_module_core.diagnostics._css import check_module_css
+
+        (tmp_path / "theme.css").write_text("@theme {\n  --a: 1;\n}\n")
+
+        assert check_module_css(_mod(), tmp_path) == []
+
+    def test_commented_out_construct_is_not_a_finding(self, tmp_path):
+        """A commented-out @theme is not a finding."""
+        from simple_module_core.diagnostics._css import check_module_css
+
+        (tmp_path / "styles.css").write_text("/* @theme { --x: 1; } */\n.y { color: red; }\n")
+
+        assert check_module_css(_mod(), tmp_path) == []
+
+    def test_comment_does_not_shift_line_numbers(self, tmp_path):
+        """Newlines inside a skipped comment must still be counted."""
+        from simple_module_core.diagnostics._css import check_module_css
+
+        (tmp_path / "styles.css").write_text("/* a\n   multi-line\n   comment */\n@theme {\n}\n")
+
+        diags = check_module_css(_mod(), tmp_path)
+
+        assert [d.file.rsplit(":", 1)[1] for d in diags] == ["4"]
+
+    def test_clean_module_has_no_findings(self, tmp_path):
+        from simple_module_core.diagnostics._css import check_module_css
+
+        (tmp_path / "theme.css").write_text("@theme {\n  --color-x: red;\n}\n")
+        (tmp_path / "styles.css").write_text("@layer components {\n  .x { color: red; }\n}\n")
+
+        assert check_module_css(_mod(), tmp_path) == []
+
+    def test_missing_files_are_not_findings(self, tmp_path):
+        from simple_module_core.diagnostics._css import check_module_css
+
+        assert check_module_css(_mod(), tmp_path) == []
+
+    def test_open_brace_in_a_string_does_not_hide_later_findings(self, tmp_path):
+        """A brace inside a string must not desync the depth counter.
+
+        An icon-font rule like `content: "{"` used to leave the scanner
+        permanently one level deep, so every later top-level construct read as
+        nested — silently swallowing the very @theme SM022 exists to catch.
+        """
+        from simple_module_core.diagnostics._css import check_module_css
+
+        (tmp_path / "styles.css").write_text('.icon { content: "{"; }\n@theme {\n  --a: 1;\n}\n')
+
+        diags = check_module_css(_mod(), tmp_path)
+
+        assert [d.code for d in diags] == ["SM022"]
+        assert diags[0].file.endswith("styles.css:2")
+
+    def test_close_brace_in_a_string_is_not_a_finding(self, tmp_path):
+        """A closing brace inside a string must not end the block early."""
+        from simple_module_core.diagnostics._css import check_module_css
+
+        (tmp_path / "theme.css").write_text(':root {\n  --icon-close: "}";\n}\n')
+
+        assert check_module_css(_mod(), tmp_path) == []
+
+    def test_escaped_quote_in_a_string(self, tmp_path):
+        """A backslash-escaped quote does not terminate the string."""
+        from simple_module_core.diagnostics._css import check_module_css
+
+        (tmp_path / "theme.css").write_text(':root {\n  --q: "a\\"{b";\n}\n')
+
+        assert check_module_css(_mod(), tmp_path) == []
+
+    def test_single_quoted_strings_handled(self, tmp_path):
+        from simple_module_core.diagnostics._css import check_module_css
+
+        (tmp_path / "styles.css").write_text(
+            ".icon { content: '{'; }\n@utility tab-4 {\n  tab-size: 4;\n}\n"
+        )
+
+        assert [d.code for d in check_module_css(_mod(), tmp_path)] == ["SM022"]
+
+    def test_unterminated_string_does_not_swallow_the_file(self, tmp_path):
+        """A stray quote must not disable the lint for everything after it.
+
+        A CSS string cannot contain a raw newline, so an unterminated one ends
+        at end-of-line. Without that bound, a single typo'd quote left the
+        scanner permanently "inside a string" and every later brace stopped
+        counting — silently hiding the rest of the file's findings.
+        """
+        from simple_module_core.diagnostics._css import check_module_css
+
+        (tmp_path / "styles.css").write_text(
+            '.a { color: red; }\n.b {\n  content: "unterminated;\n}\n@theme {\n  --b: 1;\n}\n'
+        )
+
+        diags = check_module_css(_mod(), tmp_path)
+
+        assert [d.code for d in diags] == ["SM022"]
+        assert diags[0].file.endswith("styles.css:5")
+
+    def test_apostrophe_in_unquoted_url_does_not_swallow_the_file(self, tmp_path):
+        """An unquoted url() token may hold a lone apostrophe, e.g. inline SVG."""
+        from simple_module_core.diagnostics._css import check_module_css
+
+        (tmp_path / "styles.css").write_text(
+            ".icon {\n"
+            "  background: url(data:image/svg+xml,<text>it's here</text>);\n"
+            "}\n"
+            "@theme {\n"
+            "  --a: 1;\n"
+            "}\n"
+        )
+
+        assert [d.code for d in check_module_css(_mod(), tmp_path)] == ["SM022"]
+
+    def test_stray_quote_does_not_eat_a_brace_on_its_own_line(self, tmp_path):
+        """The unmatched-quote case, with the closing brace on the SAME line.
+
+        Bounding strings at newlines was not enough: the `}` here sits on the
+        stray quote's own line, so it was consumed as string content and the
+        depth counter stayed desynced for the rest of the file. A quote only
+        opens a string if its partner appears before the line ends.
+        """
+        from simple_module_core.diagnostics._css import check_module_css
+
+        (tmp_path / "styles.css").write_text(
+            ".icon { background: url(it's.png); }\n@theme {\n  --a: 1;\n}\n"
+        )
+
+        diags = check_module_css(_mod(), tmp_path)
+
+        assert [d.code for d in diags] == ["SM022"]
+        assert diags[0].file.endswith("styles.css:2")
+
+    def test_multiline_quoted_value_is_not_a_finding(self, tmp_path):
+        """grid-template-areas spreads several complete strings over lines."""
+        from simple_module_core.diagnostics._css import check_module_css
+
+        (tmp_path / "styles.css").write_text(
+            "@layer components {\n"
+            "  .g {\n"
+            "    grid-template-areas:\n"
+            '      "a b"\n'
+            '      "c d";\n'
+            "  }\n"
+            "}\n"
+        )
+
+        assert check_module_css(_mod(), tmp_path) == []
+
+    def test_escaped_selector_is_not_a_string_opener(self, tmp_path):
+        """CSS escapes apply outside strings — Tailwind selectors rely on it."""
+        from simple_module_core.diagnostics._css import check_module_css
+
+        (tmp_path / "styles.css").write_text(
+            ".mt-\\[773px\\] { margin-top: 773px; }\n@theme {\n  --a: 1;\n}\n"
+        )
+
+        diags = check_module_css(_mod(), tmp_path)
+
+        assert [d.code for d in diags] == ["SM022"]
+        assert diags[0].file.endswith("styles.css:2")
+
+    def test_scanner_is_linear_on_pathological_input(self, tmp_path):
+        """A long run of escaped quotes must not make the scan quadratic.
+
+        `doctor` runs this over every installed module, including third-party
+        ones, so a minified or vendored stylesheet must not stall the lint.
+        Before escapes were consumed outside strings, 58KB of `\\'` took ~10s.
+        """
+        import time
+
+        from simple_module_core.diagnostics._css import check_module_css
+
+        (tmp_path / "styles.css").write_text("\\'" * 60_000)
+
+        started = time.perf_counter()
+        check_module_css(_mod(), tmp_path)
+        elapsed = time.perf_counter() - started
+
+        assert elapsed < 2.0, f"scan took {elapsed:.1f}s — likely quadratic again"
+
+    def test_escaped_newline_continues_a_string(self, tmp_path):
+        """A backslash-escaped newline is the one way a string spans lines."""
+        from simple_module_core.diagnostics._css import check_module_css
+
+        (tmp_path / "theme.css").write_text(':root {\n  --a: "x\\\n  y";\n}\n')
+
+        assert check_module_css(_mod(), tmp_path) == []
+
+    def test_brace_inside_a_comment_is_not_structural(self, tmp_path):
+        """An unbalanced brace in a comment must not shift depth either."""
+        from simple_module_core.diagnostics._css import check_module_css
+
+        (tmp_path / "styles.css").write_text("/* } { */\n@theme {\n  --a: 1;\n}\n")
+
+        diags = check_module_css(_mod(), tmp_path)
+
+        assert [d.code for d in diags] == ["SM022"]
+        assert diags[0].file.endswith("styles.css:2")
+
+    def test_import_statement_allowed_in_either_file(self, tmp_path):
+        """A statement at-rule ending in ; is not a rule block."""
+        from simple_module_core.diagnostics._css import check_module_css
+
+        (tmp_path / "theme.css").write_text('@import "other.css";\n')
+        (tmp_path / "styles.css").write_text('@charset "utf-8";\n')
+
+        assert check_module_css(_mod(), tmp_path) == []

simple_module_core-0.0.27/tests/test_design_packs.py

@@ -0,0 +1,105 @@
+"""Tests for DesignPackRegistry — modules contribute site-wide design packs.
+
+A design pack is a stylesheet a module ships that restyles the public site by
+overriding the base tokens beneath a ``<value>-root`` class. The registry is
+what lets branding offer an administrator only the packs an installed module
+actually provides: selecting one nothing ships would put a class on the
+document with no stylesheet behind it, silently doing nothing.
+
+The registry supplies the dropdown, not the stylesheet — a pack's CSS still
+reaches the bundle through the host's ``styles.css``.
+"""
+
+from __future__ import annotations
+
+import dataclasses
+
+import pytest
+from simple_module_core.design_packs import DesignPack, DesignPackRegistry
+
+
+class TestDesignPack:
+    def test_carries_slug_and_label(self):
+        pack = DesignPack(value="gca", label="Canopy Atlas")
+        assert pack.value == "gca"
+        assert pack.label == "Canopy Atlas"
+
+    def test_is_frozen(self):
+        pack = DesignPack(value="gca", label="Canopy Atlas")
+        with pytest.raises(dataclasses.FrozenInstanceError):
+            pack.value = "other"
+
+    @pytest.mark.parametrize("value", ["gca", "g", "7", "canopy-atlas", "a1-b2"])
+    def test_accepts_a_css_safe_slug(self, value):
+        assert DesignPack(value=value, label="X").value == value
+
+    @pytest.mark.parametrize(
+        "value",
+        ["", "-gca", "GCA", "canopy_atlas", "canopy atlas", "gca!", "gca.pack"],
+    )
+    def test_rejects_a_slug_that_would_not_survive_a_class_name(self, value):
+        # The site root class is f"{value}-root", so anything that isn't a bare
+        # lowercase CSS identifier fragment either fails to select or, worse,
+        # silently selects something else.
+        with pytest.raises(ValueError, match="value"):
+            DesignPack(value=value, label="X")
+
+
+class TestDesignPackRegistry:
+    def test_starts_empty(self):
+        assert DesignPackRegistry().all() == []
+
+    def test_registered_pack_is_returned(self):
+        registry = DesignPackRegistry()
+        pack = DesignPack(value="gca", label="Canopy Atlas")
+        registry.register(pack)
+        assert registry.all() == [pack]
+
+    def test_all_preserves_registration_order(self):
+        registry = DesignPackRegistry()
+        first = DesignPack(value="gca", label="Canopy Atlas")
+        second = DesignPack(value="aurora", label="Aurora")
+        registry.register(first)
+        registry.register(second)
+        assert registry.all() == [first, second]
+
+    def test_all_returns_a_copy(self):
+        registry = DesignPackRegistry()
+        registry.register(DesignPack(value="gca", label="Canopy Atlas"))
+        registry.all().clear()
+        assert len(registry.all()) == 1
+
+    def test_duplicate_value_is_rejected(self):
+        # Two modules claiming one root class would leave whichever stylesheet
+        # loaded last in charge — a silent overwrite is the wrong answer.
+        registry = DesignPackRegistry()
+        registry.register(DesignPack(value="gca", label="Canopy Atlas"))
+        with pytest.raises(ValueError, match="gca"):
+            registry.register(DesignPack(value="gca", label="Someone Else's Pack"))
+
+    def test_distinct_values_sharing_a_label_are_allowed(self):
+        registry = DesignPackRegistry()
+        registry.register(DesignPack(value="gca", label="Atlas"))
+        registry.register(DesignPack(value="gca-dark", label="Atlas"))
+        assert [p.value for p in registry.all()] == ["gca", "gca-dark"]
+
+    def test_has_reports_membership(self):
+        # Branding's PUT validates the submitted slug against this.
+        registry = DesignPackRegistry()
+        registry.register(DesignPack(value="gca", label="Canopy Atlas"))
+        assert registry.has("gca")
+        assert not registry.has("aurora")
+
+    def test_has_is_false_on_an_empty_registry(self):
+        assert not DesignPackRegistry().has("gca")
+
+
+class TestPublicSurface:
+    def test_both_names_are_exported_from_the_package_root(self):
+        # Module authors import registries from ``simple_module_core``, the
+        # same way they reach MenuRegistry or PublicRouteRegistry.
+        import simple_module_core
+
+        assert simple_module_core.DesignPack is DesignPack
+        assert simple_module_core.DesignPackRegistry is DesignPackRegistry
+        assert {"DesignPack", "DesignPackRegistry"} <= set(simple_module_core.__all__)

{simple_module_core-0.0.25 → simple_module_core-0.0.27}/tests/test_module_base.py

@@ -125,6 +125,28 @@ class TestModuleNewHooks:
         assert reg.matches("GET", "/api/with-public/datasets/9/tilejson")
         assert not reg.matches("PATCH", "/api/with-public/datasets/9/tilejson")
 
+    async def test_register_design_packs_default_noop(self):
+        from simple_module_core.design_packs import DesignPackRegistry
+
+        mod = DummyModule()
+        reg = DesignPackRegistry()
+        mod.register_design_packs(reg)
+        assert reg.all() == []
+
+    async def test_register_design_packs_override(self):
+        from simple_module_core.design_packs import DesignPack, DesignPackRegistry
+
+        class ModWithPack(ModuleBase):
+            meta = ModuleMeta(name="WithPack")
+
+            def register_design_packs(self, registry):
+                registry.register(DesignPack(value="with-pack", label="With Pack"))
+
+        reg = DesignPackRegistry()
+        ModWithPack().register_design_packs(reg)
+        assert reg.has("with-pack")
+        assert [p.label for p in reg.all()] == ["With Pack"]
+
 
 class TestModuleAssetHooks:
     async def test_template_dirs_default_empty(self):

{simple_module_core-0.0.25 → simple_module_core-0.0.27}/tests/test_services.py

@@ -30,6 +30,7 @@ class TestServices:
         assert s.feature_flags is _SENTINEL_FLAGS
         assert s.health_registry is _SENTINEL_HEALTH
         assert s.public_routes is _SENTINEL_PUBLIC_ROUTES
+        assert s.design_packs is _SENTINEL_DESIGN_PACKS
         assert s.i18n_registry is _SENTINEL_I18N
         assert s.inertia_config is _SENTINEL_INERTIA
         assert s.modules == ()
@@ -43,6 +44,7 @@ _SENTINEL_PERMS = object()
 _SENTINEL_FLAGS = object()
 _SENTINEL_HEALTH = object()
 _SENTINEL_PUBLIC_ROUTES = object()
+_SENTINEL_DESIGN_PACKS = object()
 _SENTINEL_I18N = object()
 _SENTINEL_INERTIA = object()
 
@@ -58,6 +60,7 @@ def _make_services() -> Services:
         feature_flags=_SENTINEL_FLAGS,  # type: ignore[arg-type]
         health_registry=_SENTINEL_HEALTH,  # type: ignore[arg-type]
         public_routes=_SENTINEL_PUBLIC_ROUTES,  # type: ignore[arg-type]
+        design_packs=_SENTINEL_DESIGN_PACKS,  # type: ignore[arg-type]
         i18n_registry=_SENTINEL_I18N,  # type: ignore[arg-type]
         inertia_config=_SENTINEL_INERTIA,  # type: ignore[arg-type]
         modules=(),