mirror of
https://github.com/pewdiepie-archdaemon/odysseus.git
synced 2026-10-06 06:52:20 +02:00
Léo
03d55dfe3c
static/style.css was 47,530 lines. It is now nine files under static/css/: tokens.css holds the :root custom properties, light theme and density classes, and style-part-01..08 carry the rest in their original order. Nothing was rewritten; every line moved verbatim and the <link> order in index.html reproduces the original file byte for byte. Cut points are brace-depth zero and outside block comments, so no rule or comment is split. All 47,531 source lines are accounted for across the fragments. The computed-style baseline recorded before the split is reproduced exactly, which is the evidence that the cascade is unchanged rather than an argument that it should be. Three things the split broke and this fixes: - The harness self-test swapped two conflicting .attach-strip blocks inside style.css to prove the digest is order-sensitive. It rewrote one hardcoded URL, so with the file gone it silently measured an unmodified page. It now searches every stylesheet, rewrites whichever holds the pair, and fails loudly if none does. - Four tests asserted the cache-bust token by matching /static/style.css?v=. They check the real invariant now, that every app stylesheet shares one token with app.js, through stylesheet_cache_version(). - The three panel stylesheets carried their own tokens, so a browser could hold half an old cascade and half a new one. All app stylesheets now bust together.
86 lines
3.0 KiB
Python
86 lines
3.0 KiB
Python
"""Read the app's CSS the way the browser does.
|
|
|
|
``static/style.css`` no longer holds every rule: panel styles live in separate
|
|
files that ``static/index.html`` loads eagerly, in a fixed order, right after
|
|
it. The cascade is the concatenation of those files in that order.
|
|
|
|
A test that asserts on a rule must therefore look at all of them. Reading
|
|
``static/style.css`` alone ties the test to whichever file a rule happens to
|
|
sit in today, so it goes red the next time a rule moves without anything about
|
|
the rendered page having changed.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import re
|
|
from pathlib import Path
|
|
|
|
_STATIC = Path(__file__).resolve().parents[2] / "static"
|
|
_INDEX = _STATIC / "index.html"
|
|
|
|
# Only same-origin app stylesheets. Vendored <link>s under static/lib are not
|
|
# part of the cascade these tests reason about.
|
|
_LINK = re.compile(
|
|
r"""<link\b[^>]*\brel\s*=\s*["']stylesheet["'][^>]*\bhref\s*=\s*["']/static/([^"'?]+)([^"']*)["']""",
|
|
re.I,
|
|
)
|
|
|
|
|
|
def _entries() -> list[tuple[Path, str]]:
|
|
html = _INDEX.read_text(encoding="utf-8")
|
|
out = []
|
|
for m in _LINK.finditer(html):
|
|
rel, query = m.group(1), m.group(2)
|
|
if rel.startswith("lib/"):
|
|
continue
|
|
out.append((_STATIC / rel, "/static/" + rel + query))
|
|
if not out:
|
|
raise AssertionError(f"no app stylesheet <link> tags found in {_INDEX}")
|
|
missing = [p for p, _u in out if not p.is_file()]
|
|
if missing:
|
|
raise AssertionError(f"index.html links stylesheets that do not exist: {missing}")
|
|
return out
|
|
|
|
|
|
def stylesheet_paths() -> list[Path]:
|
|
"""Every app stylesheet on disk, in the order index.html loads it."""
|
|
return [p for p, _u in _entries()]
|
|
|
|
|
|
def stylesheet_urls() -> list[str]:
|
|
"""The same stylesheets as request URLs, query string included."""
|
|
return [u for _p, u in _entries()]
|
|
|
|
|
|
def stylesheet_link_tags() -> str:
|
|
"""The <link> tags to drop into a synthetic page so it gets the whole
|
|
cascade, not just style.css."""
|
|
return "".join(f'<link rel="stylesheet" href="{u}">' for u in stylesheet_urls())
|
|
|
|
|
|
def app_css() -> str:
|
|
"""The whole cascade as one string, in load order."""
|
|
return "\n".join(p.read_text(encoding="utf-8") for p in stylesheet_paths())
|
|
|
|
|
|
def stylesheet_cache_version() -> str:
|
|
"""The single ``?v=`` token every app stylesheet link carries.
|
|
|
|
The stylesheet is split across several files that must be busted together:
|
|
shipping one fragment under a stale token serves a browser half of an old
|
|
cascade and half of a new one. Tests that used to read the version off
|
|
``style.css`` ask for it here instead, so they keep checking the invariant
|
|
rather than a filename.
|
|
"""
|
|
versions = set()
|
|
for url in stylesheet_urls():
|
|
m = re.search(r"\?v=([^&]+)$", url)
|
|
if not m:
|
|
raise AssertionError(f"app stylesheet has no cache-bust token: {url}")
|
|
versions.add(m.group(1))
|
|
if len(versions) != 1:
|
|
raise AssertionError(
|
|
f"app stylesheets disagree on their cache-bust token: {sorted(versions)}"
|
|
)
|
|
return versions.pop()
|