Add Site Studio themes and Theme Manager

Support categorized fragments, theme presets, block widths, and server-backed theme editing with onboarding and preview.

Include Site Studio, design sources, specification and verification reports; remove the legacy studio-site example.
This commit is contained in:
2026-11-13 14:04:49 +03:00
parent 231490bb7c
commit 0d171915d7
408 changed files with 11812 additions and 550 deletions
+319
View File
@@ -0,0 +1,319 @@
"""Stage 4 contracts: universal refs, shared fragments and the clean Site Studio example."""
import shutil
import tempfile
import unittest
from pathlib import Path
from theme_fixture import seed, write
from site_engine.build.pipeline import build_site, preview_page
from site_engine.core.models import FieldDef, parse_fields
from site_engine.core.registry import load_site
from site_engine.core.resolve import Resolver
from site_engine.core.routes import build_route_table
from site_engine.core.validate import check_value, validate_release, validate_workspace
from site_engine.core.values import Query
from site_engine.errors import EngineError, Report
from site_engine.parsing import frontmatter
from site_engine.parsing.yamlio import dump_yaml, load_yaml
from site_engine.services.documents import DocumentService
from site_engine.web.admin.forms import FormData, build_view, parse_field
ROOT = Path(__file__).resolve().parents[1]
class GenericReferenceTest(unittest.TestCase):
def setUp(self):
self.tmp = tempfile.TemporaryDirectory()
self.addCleanup(self.tmp.cleanup)
self.root = Path(self.tmp.name)
self.site, self.out = self.root / "site", self.root / "dist"
seed(self.site)
def resolver(self, strict=True):
self.reg = load_site(self.site)
self.report = Report()
return Resolver(self.reg, build_route_table(self.reg, self.report), self.report, strict)
def card(self, ref):
write(
self.site,
"pages/card.md",
frontmatter.dumps(
{
"title": "Рекомендация",
"status": "published",
"regions": {
"main": [
{
"id": "entry_card_test",
"fragment": "entry_card",
"props": {"title": "Рекомендуем", "entry": ref},
},
]
},
}
),
)
def test_generic_and_fixed_ref_resolve_same_entry(self):
resolver = self.resolver()
self.assertEqual(
resolver.ref_entry("*", "articles/first", "ref"),
resolver.ref_entry("articles", "first", "ref"),
)
self.assertEqual(self.report.errors, [])
def test_generic_ref_shape_rejects_partial_paths_and_non_strings(self):
for value in (
"first",
"articles/first/extra",
"../first",
"articles/../first",
"1bad/first",
"articles/UPPER",
{},
42,
):
with self.subTest(value=value):
resolver = self.resolver()
self.assertIsNone(resolver.ref_entry("*", value, "ref"))
self.assertIn("E_REF_FORMAT", self.report.codes())
def test_missing_collection_and_slug_have_distinct_diagnostics(self):
for value, code in (
("missing/first", "E_REF_COLLECTION"),
("articles/missing", "E_REF_MISSING"),
):
resolver = self.resolver()
self.assertIsNone(resolver.ref_entry("*", value, "ref"))
self.assertIn(code, self.report.codes())
def test_generic_ref_requires_published_target_while_fixed_contract_is_preserved(self):
path = self.site / "content/articles/first.md"
meta, body = frontmatter.parse(path.read_text())
meta["status"] = "draft"
path.write_text(frontmatter.dumps(meta, body))
resolver = self.resolver()
self.assertTrue(resolver.ref_entry("*", "articles/first", "ref"))
self.assertIn("E_REF_UNPUBLISHED", self.report.codes())
resolver = self.resolver(strict=False)
self.assertTrue(resolver.ref_entry("*", "articles/first", "ref"))
self.assertFalse(self.report.errors)
self.assertTrue(self.report.warnings)
resolver = self.resolver()
self.assertTrue(resolver.ref_entry("articles", "first", "ref"))
self.assertFalse(self.report.issues)
def test_static_shape_and_schema_parser_support_wildcard_without_changing_fixed_targets(self):
report = Report()
fields = parse_fields(
[
{"key": "entry", "type": "ref", "to": "*"},
{"key": "old", "type": "refs", "to": "not-yet-present"},
],
"fields",
report,
)
self.assertTrue(report.ok)
check_value(fields[0], "first", "props.entry", report)
self.assertIn("E_REF_FORMAT", report.codes())
report = Report()
check_value(
FieldDef("items", "refs", to="*"), ["articles/first", "first"], "props.items", report
)
self.assertEqual(len(report.errors), 1)
self.assertIn("[1]", report.errors[0].path)
report = Report()
parse_fields([{"key": "entry", "type": "ref", "to": 3}], "fields", report)
self.assertIn("E_FIELD_REF", report.codes())
def test_choices_prefix_only_generic_refs_and_only_published_candidates(self):
ctx = {
"entries": {"articles": ["first", "draft"], "cases": ["case"]},
"published_entries": {"articles": ["first"]},
}
generic = build_view(FieldDef("entry", "ref", to="*"), "articles/first", "p.entry", ctx)
self.assertEqual(generic["datalist"], ["articles/first"])
fixed = build_view(FieldDef("entry", "ref", to="articles"), "first", "p.entry", ctx)
self.assertEqual(fixed["datalist"], ["first", "draft"])
errors = []
value = parse_field(
FieldDef("entry", "ref", to="*"),
FormData.from_pairs([("p.entry", "articles/first")]),
"p.entry",
errors,
)
self.assertEqual(value, "articles/first")
self.assertFalse(errors)
def test_entry_card_build_and_failed_publish_preserves_current(self):
self.card("articles/first")
result = build_site(self.site, self.out)
html = (self.out / "current/card/index.html").read_text()
self.assertIn('href="/articles/first/"', html)
self.assertIn("Первая статья", html)
self.card("articles/missing")
with self.assertRaises(EngineError) as err:
build_site(self.site, self.out)
self.assertIn("E_REF_MISSING", err.exception.report.codes())
self.assertEqual((self.out / "current").resolve(), result.output_dir.resolve())
def test_generic_refs_in_unused_collection_fields_are_validated_recursively(self):
p = self.site / "collections/articles.yaml"
v = load_yaml(p.read_text())
v["fields"].append(
{
"key": "related",
"type": "group",
"fields": [{"key": "items", "type": "refs", "to": "*"}],
}
)
p.write_text(dump_yaml(v))
p = self.site / "content/articles/first.md"
meta, body = frontmatter.parse(p.read_text())
meta["related"] = {"items": ["articles/missing"]}
p.write_text(frontmatter.dumps(meta, body))
reg = load_site(self.site)
self.assertIn("E_REF_MISSING", validate_workspace(reg).codes())
meta["status"] = "draft"
p.write_text(frontmatter.dumps(meta, body))
reg = load_site(self.site)
report = validate_workspace(reg)
self.assertFalse(report.errors)
self.assertIn("E_REF_MISSING", report.codes())
def test_disabled_collection_excluded_from_queries_routes_refs_and_release_completeness(self):
p = self.site / "site.yaml"
v = load_yaml(p.read_text())
v["features"] = {"articles": False}
p.write_text(dump_yaml(v))
p = self.site / "collections/articles.yaml"
v = load_yaml(p.read_text())
v["requires"] = ["feature.articles"]
v["fields"].append({"key": "missing", "type": "text", "required": True})
p.write_text(dump_yaml(v))
resolver = self.resolver()
self.assertEqual(resolver.query(Query("articles"), "query"), [])
resolver.ref_entry("*", "articles/first", "ref")
self.assertIn("E_REF_UNPUBLISHED", self.report.codes())
table = build_route_table(self.reg, Report())
self.assertFalse(table["/articles/first/"].published)
self.assertFalse(validate_release(self.reg, table).errors)
result = build_site(self.site, self.out)
self.assertEqual(result.pages, 1)
self.assertFalse((self.out / "current/articles/first").exists())
def test_unknown_feature_requirement_is_diagnosed(self):
p = self.site / "collections/articles.yaml"
v = load_yaml(p.read_text())
v["requires"] = ["feature.unknown"]
p.write_text(dump_yaml(v))
self.assertIn("E_REQUIRES_UNKNOWN", validate_workspace(load_site(self.site)).codes())
def test_malformed_collection_requirements_are_not_silently_ignored(self):
path = self.site / "collections/articles.yaml"
value = load_yaml(path.read_text())
for bad in (None, False, 0, "feature.articles", {"feature.articles": True}, [3]):
with self.subTest(value=bad):
value["requires"] = bad
path.write_text(dump_yaml(value))
self.assertIn("E_COLLECTION_REQUIRES", load_site(self.site).report.codes())
def test_document_choices_exclude_taxonomy_targets_without_public_pages(self):
write(
self.site,
"collections/tags.yaml",
dump_yaml({"id": "tags", "kind": "taxonomy", "fields": []}),
)
write(self.site, "content/tags/tag.md", frontmatter.dumps({"status": "published"}))
choices = DocumentService(self.site).get("index").schema["choices"]
self.assertEqual(choices["entries"]["tags"], ["tag"])
self.assertNotIn("tags", choices["published_entries"])
self.assertEqual(choices["published_entries"]["articles"], ["first"])
class SiteStudioExampleTest(unittest.TestCase):
def setUp(self):
self.tmp = tempfile.TemporaryDirectory()
self.addCleanup(self.tmp.cleanup)
self.root = Path(self.tmp.name)
self.site = self.root / "site"
self.out = self.root / "dist"
shutil.copytree(ROOT / "examples/site-studio", self.site)
def test_clean_example_has_13_published_pages_and_no_local_builtin_shadows(self):
reg = load_site(self.site)
self.assertFalse(reg.report.errors)
self.assertTrue(all(f.builtin for f in reg.fragments.values()))
self.assertEqual(len(reg.pages), 9)
self.assertEqual(sum(len(v) for v in reg.entries.values()), 8)
report = validate_workspace(reg)
self.assertFalse(report.errors, report.issues)
result = build_site(self.site, self.out)
self.assertEqual(result.pages, 13)
self.assertEqual(load_yaml((self.site / "site.yaml").read_text())["schema"], 1)
self.assertFalse((self.out / "current/cases/booking").exists())
self.assertNotIn("missing-cover", (self.out / "current/index.html").read_text())
def test_display_uses_real_bindings_assets_and_optional_entry_fields(self):
build_site(self.site, self.out)
html = (self.out / "current/services/bots/index.html").read_text()
self.assertIn('src="/assets/bots.webp"', html)
self.assertIn("Автоматизируем заявки", html)
self.assertIn("Умный бот для бизнеса", html)
self.assertNotIn("{{ entry.", html)
self.assertIn("STUDIO / SERVICES", html)
self.assertIn("<title>Telegram-боты —", html)
self.assertIn("content='Автоматизируем заявки", html)
def test_intentionally_incomplete_booking_is_previewable_with_visible_diagnostic(self):
html, report = preview_page(self.site, "cases/booking")
self.assertIn("Бот для онлайн-записи", html)
self.assertIn("E_ASSET_MISSING", report.codes())
def test_shared_lists_render_more_than_three_without_truncation(self):
p = self.site / "pages/index.md"
meta, body = frontmatter.parse(p.read_text())
for b in meta["regions"]["main"]:
if b["fragment"] in ("steps", "card_grid"):
b["props"]["items"] += [{"title": "Четвёртый"}, {"title": "Пятый"}]
p.write_text(frontmatter.dumps(meta, body))
build_site(self.site, self.out)
html = (self.out / "current/index.html").read_text()
self.assertEqual(html.count("Пятый"), 2)
self.assertIn("aria-hidden='true'>05</span>", html)
def test_collection_list_renders_more_than_three_entries(self):
meta, body = frontmatter.parse((self.site / "content/services/bots.md").read_text())
for i in range(4):
meta["slug"] = f"additional-{i}"
write(self.site, f"content/services/additional-{i}.md", frontmatter.dumps(meta, body))
path = self.site / "pages/index.md"
meta, body = frontmatter.parse(path.read_text())
meta["regions"]["main"][1]["props"]["source"]["query"]["limit"] = 10
path.write_text(frontmatter.dumps(meta, body))
build_site(self.site, self.out)
html = (self.out / "current/index.html").read_text()
self.assertEqual(html.count('class="f-collection_list__item"'), 6)
def test_form_schema_has_keys_enabled_fields_consent_and_page_ids(self):
reg = load_site(self.site)
f = reg.forms["form_contact"]
self.assertEqual(f.success["page"], "thank-you")
self.assertNotIn("telegram", [v["key"] for v in f.fields])
self.assertEqual(f.raw["status"], "active")
self.assertEqual(reg.forms["form_brief"].raw["status"], "draft")
self.assertTrue(any(v["key"] == "consent" and v["policy"] == "privacy" for v in f.fields))
build_site(self.site, self.out)
html = (self.out / "current/request/index.html").read_text()
self.assertIn('type="email"', html)
self.assertIn('type="tel"', html)
self.assertIn('action="/forms/form_contact"', html)
self.assertIn("name='form_version'", html)
self.assertIn("Приём заявок пока не подключён", html)
if __name__ == "__main__":
unittest.main()