360 lines
16 KiB
Python
360 lines
16 KiB
Python
"""Рендер страниц: разрешение 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
|