Init Project Flexly CMS

This commit is contained in:
Alexey Dudin
2026-11-09 15:32:41 +03:00
commit c778db6208
115 changed files with 5098 additions and 0 deletions
+359
View File
@@ -0,0 +1,359 @@
"""Рендер страниц: разрешение props по схеме фрагмента и Jinja в sandbox (ADR-002, ADR-005).
Sandbox — второй эшелон защиты, а не граница безопасности: шаблоны пишет доверенный
разработчик, контентные роли могут менять только данные.
"""
from __future__ import annotations
import datetime as dt
from dataclasses import dataclass, field
from typing import Any
from jinja2 import DictLoader, StrictUndefined
from jinja2.sandbox import SandboxedEnvironment
from markupsafe import Markup, escape
from ..errors import Report
from ..parsing.markdown import render_inline, render_markdown
from .models import Block, Collection, Entry, FieldDef, Fragment
from .registry import Registry
from .resolve import MISSING, Resolver, get_path
from .routes import RouteRef
from .values import Binding, LinkRef, Query, ValueShapeError, classify
ASSETS_HEAD = "<!--@@ASSETS_HEAD@@-->"
ASSETS_BODY = "<!--@@ASSETS_BODY@@-->"
_EMPTY = (None, "", [], {})
@dataclass
class PageView:
"""Страница к рендеру: ручная страница или запись коллекции, превращённая display template."""
id: str
title: str
route: str
layout_id: str
seo: dict
regions: dict[str, list[Block]]
body: str = ""
entry: Entry | None = None
collection: Collection | None = None
source: str = ""
@dataclass
class _State:
view: PageView
ctx: dict
used: set[str] = field(default_factory=set)
class Props:
"""Значения props для шаблона: `props.items` — поле «items», а не метод dict.
Обычный dict в Jinja отдаёт `.items`/`.keys`/`.values` как методы; поэтому поля
фрагментов и группы оборачиваются в этот класс.
"""
__slots__ = ("_d",)
def __init__(self, data: dict):
object.__setattr__(self, "_d", data)
def __getattr__(self, name: str) -> Any:
try:
return self._d[name]
except KeyError:
raise AttributeError(name) from None
def __getitem__(self, name: str) -> Any:
return self._d[name]
def __contains__(self, name: object) -> bool:
return name in self._d
def __iter__(self):
return iter(self._d)
def __len__(self) -> int:
return len(self._d)
def __bool__(self) -> bool:
return bool(self._d)
def _md(text: Any) -> Markup:
return Markup(render_markdown(str(text or "")))
def _md_inline(text: Any) -> Markup:
return Markup(render_inline(str(text or "")))
def _href(link: Any) -> str:
if isinstance(link, dict):
return str(link.get("url") or "")
return "" if link is None else str(link)
def _empty(value: Any) -> bool:
return value is None or value == "" or value == [] or value == {}
def _is_active(url: str, route: str) -> bool:
return url == route or (url != "/" and route.startswith(url))
class Renderer:
def __init__(
self, reg: Registry, table: dict[str, RouteRef], report: Report, *,
strict: bool = True, now: dt.datetime | None = None, build_id: str = "",
):
self.reg = reg
self.table = table
self.report = report
self.strict = strict
self.build_id = build_id
self.now = now or dt.datetime.now(dt.timezone.utc)
self.resolver = Resolver(reg, table, report, strict)
templates = {f"layout/{lid}": l.template for lid, l in reg.layouts.items()}
templates.update({f"fragment/{fid}": f.template for fid, f in reg.fragments.items()})
self.env = SandboxedEnvironment(
loader=DictLoader(templates), autoescape=True, undefined=StrictUndefined,
trim_blocks=True, lstrip_blocks=True,
)
self.env.filters.update(md=_md, md_inline=_md_inline, href=_href)
self.site_ctx = {
"name": reg.site.name, "base_url": reg.site.base_url,
"default_locale": reg.site.default_locale, "locales": reg.site.locales,
"contacts": reg.site.contacts, "features": reg.site.features,
}
self._menus = self._resolve_menus()
self._forms = self._resolve_forms()
# ── диагностика ───────────────────────────────────────────────────────
def _issue(self, code: str, message: str, path: str, hint: str = "") -> None:
self.report.add(code, message, path, "error" if self.strict else "warning", hint)
# ── меню и формы ──────────────────────────────────────────────────────
def _feature_on(self, requires: list[str]) -> bool:
return all(self.reg.site.features.get(str(r)[8:], False) for r in requires)
def _resolve_menus(self) -> dict[str, list[dict]]:
out: dict[str, list[dict]] = {}
for mid, items in self.reg.menus.items():
resolved = []
for i, item in enumerate(items):
if not isinstance(item, dict) or item.get("enabled", True) is False:
continue
if not self._feature_on(item.get("requires") or []):
continue
kind = next((k for k in ("page", "entry", "url") if k in item), None)
if kind is None:
continue
link = self.resolver.link(LinkRef(kind, str(item[kind]), item.get("label")), f"menus/{mid}.yaml:items[{i}]")
if link:
resolved.append({"label": item.get("label"), "url": link["url"]})
out[mid] = resolved
return out
def _resolve_forms(self) -> dict[str, dict]:
out = {}
for fid, form in self.reg.forms.items():
fields = []
for f in form.fields:
policy_url = None
if f.get("policy"):
ref = self.resolver.page_refs.get(str(f["policy"]))
policy_url = ref.route if ref else None
if ref is None:
self._issue("E_FORM_POLICY", f"страница политики «{f['policy']}» не найдена", f"forms/{fid}.yaml")
fields.append({
"key": f["key"], "type": f.get("type", "text"), "label": f.get("label", f["key"]),
"required": bool(f.get("required", False)), "hint": f.get("hint"), "policy_url": policy_url,
})
out[fid] = {"id": fid, "title": form.title, "action": f"/forms/{fid}", "version": form.version, "fields": fields}
return out
def _breadcrumbs(self, view: PageView) -> list[dict]:
crumbs: list[dict] = []
segments = [s for s in view.route.split("/") if s and not s.endswith(".html")]
for i in range(len(segments)):
prefix = "/" + "/".join(segments[: i + 1]) + "/"
ref = self.table.get(prefix)
if ref and ref.page and ref.route != view.route:
crumbs.append({"label": ref.page.title, "url": ref.route})
if view.route != "/" and self.table.get("/") and self.table["/"].page:
crumbs.insert(0, {"label": self.table["/"].page.title, "url": "/"})
if view.collection and view.collection.list_page:
ref = self.table.get(view.collection.list_page)
if ref and ref.page and not any(c["url"] == ref.route for c in crumbs):
crumbs.append({"label": ref.page.title, "url": ref.route})
crumbs.append({"label": view.title, "url": None})
return crumbs
# ── разрешение props ──────────────────────────────────────────────────
def _field(self, fd: FieldDef, raw: Any, st: _State, path: str, required: bool | None = None) -> Any:
required = fd.required if required is None else required
if raw is None and fd.default is not None:
raw = fd.default
try:
value = classify(raw, fd.type if fd.type in ("link", "query") else None)
except ValueShapeError as exc:
self._issue("E_VALUE_SHAPE", str(exc), path)
return None
if isinstance(value, Binding):
got = get_path(st.ctx, value.path)
if got is MISSING:
if required:
self._issue("E_BIND_MISSING", f"привязка «{value.path}» не найдена", path,
hint="проверьте имя поля записи или страницы")
return None
value = got
t = fd.type
given = value is not None # для query: запрос задан, даже если результат пуст
if t == "link":
if isinstance(value, LinkRef):
value = self.resolver.link(value, path)
elif isinstance(value, str):
value = self.resolver.link(LinkRef("url", value), path)
elif isinstance(value, dict) and "url" in value:
value = {"url": value["url"], "label": value.get("label"), "new_tab": bool(value.get("new_tab"))}
elif value is not None:
self._issue("E_VALUE_SHAPE", "ожидается ссылка", path)
value = None
elif t == "query":
if isinstance(value, Query):
value = self.resolver.query(value, path)
elif value is None:
value = []
elif t == "asset" and isinstance(value, str):
rel = value.strip("/")
if not rel.startswith("assets/") or ".." in rel.split("/"):
self._issue("E_ASSET_PATH", "путь ассета должен быть вида assets/...", path)
value = None
elif not (self.reg.root / rel).is_file():
self._issue("E_ASSET_MISSING", f"нет файла {rel}", path)
value = None
else:
value = {"path": rel, "url": "/" + rel}
elif t == "group" and isinstance(value, dict):
value = Props({sub.key: self._field(sub, value.get(sub.key), st, f"{path}.{sub.key}") for sub in fd.fields})
elif t == "list" and isinstance(value, list):
items = []
for i, item in enumerate(value):
item_path = f"{path}[{i}]"
if fd.of:
items.append(self._field(FieldDef(f"[{i}]", fd.of), item, st, item_path, required=False))
else:
group = FieldDef(f"[{i}]", "group", fields=fd.fields)
if isinstance(item, dict) and set(item) == {"bind"}:
got = get_path(st.ctx, item["bind"])
item = None if got is MISSING else got
items.append(self._field(group, item, st, item_path, required=False))
value = items
elif t == "ref" and value is not None:
value = self.resolver.ref_entry(fd.to or "", value, path)
elif t == "refs" and isinstance(value, list):
value = [v for v in (self.resolver.ref_entry(fd.to or "", s, f"{path}[{i}]") for i, s in enumerate(value)) if v]
if value is None and t in ("list", "refs", "multiselect"):
value = []
if _empty(value) and required and not (t == "query" and given):
self._issue("E_REQUIRED", f"обязательное поле «{fd.key}» пусто", path)
return value
def _props(self, block: Block, fragment: Fragment, st: _State, path: str) -> Props:
return Props({fd.key: self._field(fd, block.props.get(fd.key), st, f"{path}.props.{fd.key}") for fd in fragment.fields})
# ── блоки ─────────────────────────────────────────────────────────────
def _block(self, block: Block, st: _State, where: str) -> Markup:
path = f"{where}[{block.id}]"
if block.hidden or not self._feature_on(block.requires):
return Markup("")
fragment = self.reg.fragments.get(block.fragment)
if fragment is None:
self._issue("E_FRAGMENT_UNKNOWN", f"нет фрагмента «{block.fragment}»", path)
return Markup("")
st.used.add(fragment.id)
props = self._props(block, fragment, st, path)
slots = {
name: Markup("".join(str(self._block(c, st, f"{path}.slots.{name}")) for c in block.slots.get(name, [])))
for name in fragment.slots
}
ctx = {**st.ctx, "props": props, "slots": slots, "block": {"id": block.id, "anchor": block.anchor}}
html = self.env.get_template(f"fragment/{fragment.id}").render(ctx)
if block.anchor:
html = f"<a id='{escape(block.anchor)}'></a>" + html
return Markup(html)
def _plain(self, value: Any, st: _State, path: str) -> Any:
try:
value = classify(value, None)
except ValueShapeError as exc:
self._issue("E_VALUE_SHAPE", str(exc), path)
return ""
if isinstance(value, Binding):
got = get_path(st.ctx, value.path)
if got is MISSING:
self._issue("E_BIND_MISSING", f"привязка «{value.path}» не найдена", path)
return ""
return got
return value
def _seo_head(self, st: _State) -> Markup:
v = st.view
seo = {k: self._plain(val, st, f"{v.source}:seo.{k}") for k, val in v.seo.items()}
suffix = str(self.reg.site.defaults.get("seo", {}).get("title_suffix", ""))
title = f"{seo.get('title') or v.title}{suffix}"
parts = [
"<meta charset='utf-8'>",
"<meta name='viewport' content='width=device-width, initial-scale=1'>",
f"<title>{escape(title)}</title>",
]
if seo.get("description"):
parts.append(f"<meta name='description' content='{escape(seo['description'])}'>")
if self.reg.site.base_url:
parts.append(f"<link rel='canonical' href='{escape(self.reg.site.base_url + v.route)}'>")
parts.append(f"<meta property='og:title' content='{escape(title)}'>")
return Markup("\n".join(parts))
# ── страница ──────────────────────────────────────────────────────────
def render(self, view: PageView) -> tuple[str, set[str]]:
layout = self.reg.layouts.get(view.layout_id)
if layout is None:
self._issue("E_LAYOUT_MISSING", f"layout «{view.layout_id}» не найден", view.source)
return "", set()
entry_view = self.resolver.entry_view(view.entry) if view.entry else None
menus = {
mid: [{**item, "active": _is_active(item["url"], view.route)} for item in items]
for mid, items in self._menus.items()
}
ctx = {
"site": self.site_ctx,
"page": {"id": view.id, "title": view.title, "route": view.route, "body": view.body,
"locale": self.reg.site.default_locale, "url": self.reg.site.base_url + view.route},
"entry": entry_view, "data": self.reg.data, "params": {}, "menus": menus,
"forms": self._forms, "breadcrumbs": self._breadcrumbs(view),
"build": {"id": self.build_id, "year": self.now.year},
}
st = _State(view, ctx)
def region(name: str) -> Markup:
rdef = layout.regions.get(name)
if rdef is None:
self._issue("E_REGION_UNKNOWN", f"layout «{layout.id}» не объявляет регион «{name}»", view.source)
return Markup("")
out = []
for b in rdef.fixed:
out.append(str(self._block(b, st, f"layouts/{layout.id}/layout.yaml:regions.{name}.fixed")))
for b in view.regions.get(name, []):
out.append(str(self._block(b, st, f"{view.source}:regions.{name}")))
return Markup("".join(out))
html = self.env.get_template(f"layout/{layout.id}").render({
**ctx, "region": region, "seo_head": lambda: self._seo_head(st),
"assets_head": lambda: Markup(ASSETS_HEAD), "assets_body": lambda: Markup(ASSETS_BODY),
})
return html, st.used