Files
marqdo/plugins/web/src/render.rs
T
cflmyandCursor da9fc75b1e Add marqdo-blog example with GFM-table style assembly
Introduce web_style ABI (样式装配) so themes are GFM style tables
(|选择器|属性|值|, optional |媒体| column for @media) assembled by
functions instead of hand-written CSS strings — 文档即代码. The new
examples/marqdo-blog shows a full blog: card grid, dynamic /post/{slug},
tag archive, WebSocket live widget, and session-gated admin CRUD, plus a
smoke test (15 checks) and README.

Co-authored-by: Cursor <cursoragent@cursor.com>
2026-08-26 13:03:55 +08:00

599 lines
20 KiB
Rust

//! Minimal HTML shell for assembled pages / parts.
use serde_json::{json, Map, Value};
use crate::db;
use crate::table::{as_bind, normalize_ref, normalize_slot, parse_site_path, project_rows, SitePath};
fn esc(s: &str) -> String {
s.replace('&', "&amp;")
.replace('<', "&lt;")
.replace('>', "&gt;")
.replace('"', "&quot;")
}
fn text(v: &Value) -> String {
match v {
Value::Null => String::new(),
Value::String(s) => s.clone(),
Value::Bool(b) => b.to_string(),
Value::Number(n) => n.to_string(),
other => other.to_string(),
}
}
fn class_attr(css: &str) -> String {
if css.is_empty() {
String::new()
} else {
format!(" class=\"{}\"", esc(css))
}
}
fn is_simple_ident(s: &str) -> bool {
!s.is_empty()
&& s.chars()
.all(|c| c.is_ascii_alphanumeric() || c == '_' || !c.is_ascii())
}
/// True when `back` is a DB field path (`table.col` / `mod.table.col`), not a URL or site path.
fn is_db_bind_back(back: &str) -> bool {
let s = normalize_ref(back);
if s.is_empty()
|| s.contains("://")
|| s.starts_with('/')
|| s.starts_with('#')
|| s.starts_with('?')
{
return false;
}
match parse_site_path(&s) {
SitePath::DbField { .. } => true,
SitePath::LibMember { lib, member } => is_simple_ident(&lib) && is_simple_ident(&member),
SitePath::Plain(p) => {
let parts: Vec<&str> = p.split('.').filter(|x| !x.is_empty()).collect();
parts.len() == 2 && parts.iter().all(|x| is_simple_ident(x))
}
}
}
fn resolve_links(raw: Option<&Value>, db_url: Option<&str>) -> Vec<(String, String)> {
let Some(raw) = raw else {
return Vec::new();
};
let binds = as_bind(raw);
let arr = binds.as_array().cloned().unwrap_or_default();
if arr.is_empty() {
return Vec::new();
}
let has_db = arr
.iter()
.any(|b| b.get("back").and_then(|v| v.as_str()).is_some_and(is_db_bind_back));
if has_db {
let Some(url) = db_url else {
return Vec::new();
};
let table = crate::table::bind_table_name(&arr);
let Some(table) = table else {
return Vec::new();
};
let data = select_page_data(url, &table, raw, 200);
let rows = data
.get("rows")
.and_then(|v| v.as_array())
.cloned()
.unwrap_or_default();
let projected = project_rows(&arr, &rows);
let mut out = Vec::new();
for it in projected.as_array().cloned().unwrap_or_default() {
let m = it.as_object().cloned().unwrap_or_default();
let label = m
.get("title")
.or_else(|| m.get("label"))
.map(text)
.unwrap_or_default();
let href = m
.get("href")
.or_else(|| m.get("path"))
.map(text)
.unwrap_or_else(|| "#".into());
if !label.is_empty() {
out.push((label, href));
}
}
return out;
}
// static: front=label back=href (URLs with `.` must stay here)
arr.into_iter()
.map(|b| {
let label = b.get("front").map(text).unwrap_or_default();
let href = b.get("back").map(text).unwrap_or_else(|| "#".into());
(label, href)
})
.filter(|(l, _)| !l.is_empty())
.collect()
}
fn render_ul(links: &[(String, String)], class: &str) -> String {
let mut s = format!("<ul class=\"{}\">", esc(class));
for (label, href) in links {
s.push_str(&format!(
"<li><a href=\"{}\">{}</a></li>",
esc(href),
esc(label)
));
}
s.push_str("</ul>");
s
}
fn resolve_main(args: &Value, db_url: Option<&str>) -> (String, Vec<Map<String, Value>>) {
let intro = args
.get("intro")
.and_then(|v| v.as_str())
.unwrap_or("")
.to_string();
let Some(main) = args.get("main") else {
return (intro, Vec::new());
};
let binds = as_bind(main);
let arr = binds.as_array().cloned().unwrap_or_default();
if arr.is_empty() {
return (intro, Vec::new());
}
let Some(url) = db_url else {
return (intro, Vec::new());
};
let Some(table) = crate::table::bind_table_name(&arr) else {
return (intro, Vec::new());
};
let data = select_page_data(url, &table, args, 200);
let rows = data
.get("rows")
.and_then(|v| v.as_array())
.cloned()
.unwrap_or_default();
let projected = project_rows(&arr, &rows);
let items = projected
.as_array()
.cloned()
.unwrap_or_default()
.into_iter()
.filter_map(|v| v.as_object().cloned())
.collect();
(intro, items)
}
/// Run the page's DB query: `where` (with `{param}` placeholders resolved from
/// `params`) and optional `order`, then project through the bind table.
fn select_page_data(
url: &str,
table: &str,
args: &Value,
limit: i64,
) -> Value {
let mut where_v = args.get("query").cloned();
if let Some(m) = where_v.as_ref().and_then(|v| v.as_object()) {
if m.iter().any(|(_, v)| v.as_str().is_some_and(|s| s.contains('{'))) {
let mut resolved = Map::new();
for (k, v) in m {
let v = match v {
Value::String(s) => Value::String(resolve_params(s.as_str(), args)),
other => other.clone(),
};
resolved.insert(k.clone(), v);
}
where_v = Some(Value::Object(resolved));
}
}
let order = args.get("order").and_then(|v| v.as_str());
if order.is_some_and(|s| !s.trim().is_empty()) {
db::select_order(url, table, limit, where_v.as_ref(), order)
} else {
db::select(url, table, limit, where_v.as_ref())
}
.unwrap_or(json!({ "rows": [] }))
}
/// Replace `{param}` placeholders with values from `args["params"]` (a map).
fn resolve_params(s: &str, args: &Value) -> String {
let params = args
.get("params")
.and_then(|v| v.as_object())
.cloned()
.unwrap_or_default();
let mut out = String::new();
let mut rest = s;
while let Some(start) = rest.find('{') {
out.push_str(&rest[..start]);
rest = &rest[start + 1..];
if let Some(end) = rest.find('}') {
let key = &rest[..end];
let val = params
.get(key)
.map(text)
.unwrap_or_else(|| format!("{{{key}}}"));
out.push_str(&val);
rest = &rest[end + 1..];
} else {
out.push('{');
break;
}
}
out.push_str(rest);
out
}
fn field_css(obj: &Map<String, Value>, field: &str) -> String {
obj.get("_css")
.and_then(|v| v.as_object())
.and_then(|m| m.get(field))
.and_then(|v| v.as_str())
.unwrap_or("")
.to_string()
}
fn part_src_prefix(args: &Value) -> String {
match args.get("_route").and_then(|v| v.as_str()) {
Some(r) if !r.is_empty() && r != "/" => {
let mut p = r.to_string();
while p.len() > 1 && p.ends_with('/') {
p.pop();
}
if p.starts_with('/') {
p
} else {
format!("/{p}")
}
}
_ => String::new(),
}
}
fn slot_attrs(slot: &str, parts: &Map<String, Value>, page: &Value) -> String {
let prefix = part_src_prefix(page);
let mut a = format!(" data-slot=\"{}\"", esc(slot));
for (id, cfg) in parts {
let s = cfg
.get("slot")
.or_else(|| cfg.get("fragment"))
.and_then(|v| v.as_str())
.unwrap_or("");
if s == slot || (slot == "sidebar" && id == "side") || (slot == "main" && id == "index") {
a.push_str(&format!(
" data-slot-src=\"{}/_part/{}\"",
esc(&prefix),
esc(id)
));
break;
}
}
a
}
fn slot_class(args: &Value, slot: &str, base: &str) -> String {
let extra = args
.get("slot_class")
.and_then(|v| v.as_object())
.and_then(|m| m.get(slot))
.and_then(|v| v.as_str())
.unwrap_or("");
if extra.is_empty() {
base.to_string()
} else {
format!("{base} {extra}")
}
}
const SHELL_CSS: &str = r#"
:root { --ink:#1c1917; --muted:#57534e; --paper:#fafaf9; --line:#e7e5e4; --accent:#0f766e; }
body { margin:0; font-family: "IBM Plex Sans", "Noto Sans SC", sans-serif; background:var(--paper); color:var(--ink); display:grid; min-height:100vh; grid-template-rows:auto 1fr auto; }
body.has-sidebar { grid-template-columns:14rem 1fr; grid-template-areas:"top top" "side main" "foot foot"; }
body.no-sidebar { grid-template-areas:"top" "main" "foot"; }
header.topnav { grid-area:top; border-bottom:1px solid var(--line); padding:.85rem 1.25rem; background:#fff; }
aside.side { grid-area:side; border-right:1px solid var(--line); padding:1.25rem 1rem; background:#f5f5f4; }
main.main { grid-area:main; padding:1.5rem 1.25rem 2rem; }
footer.foot { grid-area:foot; border-top:1px solid var(--line); padding:.85rem 1.25rem; color:var(--muted); background:#fff; }
ul.nav, ul.side-nav, ul.foot-nav { list-style:none; margin:0; padding:0; display:flex; flex-wrap:wrap; gap:.35rem 1rem; }
ul.side-nav { flex-direction:column; }
a { color:var(--ink); text-decoration:none; }
a:hover { color:var(--accent); }
.content.cards { display:grid; gap:1rem; margin-top:1.25rem; grid-template-columns:repeat(auto-fill,minmax(16rem,1fr)); }
.content.cards article { background:#fff; border:1px solid var(--line); border-radius:6px; padding:1rem; }
.main-intro h1 { margin:0 0 .75rem; font-size:2rem; }
.main-intro p { color:var(--muted); }
.site-form { margin-top:1.25rem; max-width:28rem; }
.site-form form { display:grid; gap:.85rem; }
.site-form label { display:grid; gap:.25rem; font-size:.9rem; }
.site-form input, .site-form textarea { padding:.5rem .6rem; border:1px solid var(--line); border-radius:4px; font:inherit; background:#fff; }
.site-form input[readonly] { background:#f5f5f4; color:var(--muted); }
.site-form .err { color:#b91c1c; font-size:.85rem; }
.site-form .actions { display:flex; gap:.75rem; align-items:center; flex-wrap:wrap; }
.site-form button { background:var(--accent); color:#fff; border:0; padding:.55rem 1rem; border-radius:4px; cursor:pointer; }
.site-form .meta { color:var(--muted); font-size:.9rem; }
.article { background:#fff; border:1px solid var(--line); border-radius:8px; padding:2rem; margin-top:1.5rem; }
.article-meta { color:var(--muted); font-size:.85rem; }
.article-title { margin:0 0 .75rem; font-size:2rem; }
.article-tags { margin-bottom:1rem; }
.article-body { line-height:1.75; color:var(--ink); }
.article-p { margin:0 0 1rem; white-space:pre-line; }
.article-h2 { margin:1.5rem 0 .75rem; }
.article-code { background:#f5f5f4; border:1px solid var(--line); border-radius:6px; padding:1rem; overflow-x:auto; font-size:.9rem; }
"#;
pub fn render_page(args: &Value, db_url: Option<&str>) -> String {
render_page_ex(args, db_url, None, None)
}
/// Like `render_page`, optionally replaying form POST data/errors into the embedded form.
pub fn render_page_ex(
args: &Value,
db_url: Option<&str>,
form_data: Option<&Value>,
form_errors: Option<&Value>,
) -> String {
let title = args
.get("title")
.and_then(|v| v.as_str())
.unwrap_or("Marqdo Web");
let extra = args
.get("styles_css")
.and_then(|v| v.as_str())
.unwrap_or("");
let parts = args
.get("parts")
.and_then(|v| v.as_object())
.cloned()
.unwrap_or_default();
let nav = resolve_links(args.get("nav"), db_url);
let side = resolve_links(args.get("sidebar"), db_url);
let foot = resolve_links(args.get("footer"), db_url);
let (intro, items) = resolve_main(args, db_url);
let has_side = args.get("sidebar").is_some() || !side.is_empty();
let body_class = if has_side {
"has-sidebar"
} else {
"no-sidebar"
};
let mut main_html = String::new();
if !intro.is_empty() {
main_html.push_str(&format!("<div class=\"main-intro\">{intro}</div>"));
}
if let Some(form) = args.get("form") {
let form_id = args
.get("form_id")
.and_then(|v| v.as_str())
.unwrap_or("form");
main_html.push_str(&crate::form::render_body(
form,
form_id,
form_data,
form_errors,
));
}
if !items.is_empty() {
let is_detail = args
.get("detail")
.and_then(|v| v.as_bool())
.unwrap_or(false);
if is_detail {
main_html.push_str(&render_article(&items[0]));
} else {
main_html.push_str("<section class=\"content cards\">");
for it in &items {
main_html.push_str(&render_card(args, it));
}
main_html.push_str("</section>");
}
}
format!(
r#"<!DOCTYPE html>
<html lang="zh-CN"><head>
<meta charset="utf-8"/>
<meta name="viewport" content="width=device-width, initial-scale=1"/>
<title>{title}</title>
<style>{SHELL_CSS}{extra}</style>
</head>
<body class="{body_class}">
<header class="{nav_class}"{nav_attrs}>{nav_ul}</header>
{side_html}
<main class="{main_class}"{main_attrs}>{main_html}</main>
<footer class="{foot_class}"{foot_attrs}>{foot_ul}</footer>
</body></html>"#,
title = esc(title),
nav_class = slot_class(args, "nav", "topnav"),
nav_attrs = slot_attrs("nav", &parts, args),
nav_ul = render_ul(&nav, "nav"),
side_html = if has_side {
format!(
"<aside class=\"{}\"{}><span class=\"side-label\">侧栏</span>{}</aside>",
slot_class(args, "sidebar", "side"),
slot_attrs("sidebar", &parts, args),
render_ul(&side, "side-nav")
)
} else {
String::new()
},
main_class = slot_class(args, "main", "main"),
main_attrs = slot_attrs("main", &parts, args),
foot_class = slot_class(args, "footer", "foot"),
foot_attrs = slot_attrs("footer", &parts, args),
foot_ul = render_ul(&foot, "foot-nav"),
)
}
pub fn render_fragment(args: &Value, db_url: Option<&str>) -> String {
let slot = args
.get("fragment")
.or_else(|| args.get("slot"))
.and_then(|v| v.as_str())
.map(normalize_slot)
.unwrap_or_else(|| "main".into());
match slot.as_str() {
"nav" => {
let links = resolve_links(args.get("nav"), db_url);
format!(
"<header class=\"topnav\" data-slot=\"nav\">{}</header>",
render_ul(&links, "nav")
)
}
"sidebar" => {
let links = resolve_links(args.get("sidebar"), db_url);
format!(
"<aside class=\"side\" data-slot=\"sidebar\"><span class=\"side-label\">侧栏</span>{}</aside>",
render_ul(&links, "side-nav")
)
}
"footer" => {
let links = resolve_links(args.get("footer"), db_url);
format!(
"<footer class=\"foot\" data-slot=\"footer\">{}</footer>",
render_ul(&links, "foot-nav")
)
}
_ => {
let (intro, items) = resolve_main(args, db_url);
let mut body = String::new();
if !intro.is_empty() {
body.push_str(&format!("<div class=\"main-intro\">{intro}</div>"));
}
if let Some(form) = args.get("form") {
let form_id = args
.get("form_id")
.and_then(|v| v.as_str())
.unwrap_or("form");
body.push_str(&crate::form::render_body(form, form_id, None, None));
}
if !items.is_empty() {
let is_detail = args
.get("detail")
.and_then(|v| v.as_bool())
.unwrap_or(false);
if is_detail {
body.push_str(&render_article(&items[0]));
} else {
body.push_str("<section class=\"content cards\">");
for it in &items {
body.push_str(&render_card(args, it));
}
body.push_str("</section>");
}
}
format!("<main class=\"main\" data-slot=\"main\">{body}</main>")
}
}
}
/// Render a single list card from a projected DB row.
fn render_card(args: &Value, it: &Map<String, Value>) -> String {
let title = it.get("title").map(text).unwrap_or_default();
let body = it.get("body").map(text).unwrap_or_default();
let href = it.get("href").map(text).unwrap_or_default();
let meta = it.get("meta").map(text).unwrap_or_default();
let tag = it.get("tag").map(text).unwrap_or_default();
let tc = class_attr(&field_css(it, "title"));
let bc = class_attr(&field_css(it, "body"));
let mut card = String::from("<article class=\"card\">");
if !href.is_empty() {
let prefix = args
.get("link_prefix")
.and_then(|v| v.as_str())
.unwrap_or("/post/");
card.push_str(&format!(
"<a class=\"card-link\" href=\"{}\">",
esc(&format!("{prefix}{href}"))
));
}
if !meta.is_empty() {
card.push_str(&format!(
"<div class=\"card-meta\">{}</div>",
esc(&meta)
));
}
card.push_str(&format!("<h2{tc}>{}</h2>", esc(&title)));
if !tag.is_empty() {
card.push_str(&format!(
"<div class=\"card-tag\">{}</div>",
esc(&tag)
));
}
if !body.is_empty() {
card.push_str(&format!("<p{bc}>{}</p>", esc(&body)));
}
if !href.is_empty() {
card.push_str("</a>");
}
card.push_str("</article>");
card
}
/// Render a single article (detail page) from a projected DB row.
fn render_article(it: &Map<String, Value>) -> String {
let title = it.get("title").map(text).unwrap_or_default();
let body = it.get("body").map(text).unwrap_or_default();
let meta = it.get("meta").map(text).unwrap_or_default();
let tag = it.get("tag").map(text).unwrap_or_default();
let mut s = String::from("<article class=\"article\">");
if !meta.is_empty() {
s.push_str(&format!(
"<div class=\"article-meta\">{}</div>",
esc(&meta)
));
}
s.push_str(&format!("<h1 class=\"article-title\">{}</h1>", esc(&title)));
if !tag.is_empty() {
s.push_str(&format!(
"<div class=\"article-tags\">{}</div>",
esc(&tag)
));
}
if !body.is_empty() {
s.push_str(&render_article_body(&body));
}
s.push_str("</article>");
s
}
/// Split a Markdown-ish article body into block elements.
fn render_article_body(body: &str) -> String {
let mut s = String::from("<div class=\"article-body\">");
for para in body.split("\n\n") {
let para = para.trim();
if para.is_empty() {
continue;
}
if let Some(code) = para.strip_prefix("```") {
let code = code.strip_suffix("```").unwrap_or(code);
s.push_str(&format!(
"<pre class=\"article-code\">{}</pre>",
esc(code)
));
continue;
}
if let Some(h) = para.strip_prefix("## ") {
s.push_str(&format!(
"<h2 class=\"article-h2\">{}</h2>",
esc(h.trim())
));
continue;
}
if let Some(h) = para.strip_prefix("# ") {
s.push_str(&format!(
"<h2 class=\"article-h2\">{}</h2>",
esc(h.trim())
));
continue;
}
s.push_str(&format!(
"<p class=\"article-p\">{}</p>",
esc(para).replace('\n', "<br/>")
));
}
s.push_str("</div>");
s
}