Files
marqdo/plugins/web-rust-archive/src/render.rs
T
cflmyandCursor ca40c698a2 refactor(web): start Go ABI rewrite of plugins/web (W-G0)
Archive the Rust web plugin and add a Go c-shared skeleton with ABI v2
bridge, build script, design doc/ADR, and smoke test so multi-language
plugins and full web parity can proceed wave by wave.

Co-authored-by: Cursor <cursoragent@cursor.com>
2026-09-10 14:47:43 +08:00

1251 lines
40 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! Minimal HTML shell for assembled pages / parts.
use serde_json::{json, Map, Value};
use crate::db;
use crate::markdown;
use crate::table::{
as_bind, as_nav_rows, nav_label_href, nav_media_when_class, 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())
}
/// Normalize a form mount selector to a bare HTML id (`#foo` → `foo`).
fn form_mount_id(target: &str) -> Option<&str> {
let t = target.trim().trim_start_matches('#');
if t.is_empty() {
return None;
}
// Keep injection conservative: id must be a simple token (no spaces / quotes).
if t.chars().any(|c| c.is_whitespace() || c == '"' || c == '\'' || c == '<' || c == '>') {
return None;
}
Some(t)
}
/// Inject `payload` as the inner HTML of the first element with `id="…"` / `id='…'`.
/// Returns `None` if no matching open+close pair is found (caller falls back to sibling form).
pub(crate) fn inject_html_into_id(haystack: &str, id: &str, payload: &str) -> Option<String> {
let id = form_mount_id(id)?;
let patterns = [format!("id=\"{id}\""), format!("id='{id}'")];
for pat in &patterns {
let Some(idx) = haystack.find(pat.as_str()) else {
continue;
};
let tag_start = haystack[..idx].rfind('<')?;
// Reject closing tags / comments accidentally matching.
let after_lt = haystack.as_bytes().get(tag_start + 1).copied()?;
if after_lt == b'/' || after_lt == b'!' {
continue;
}
let name_end = haystack[tag_start + 1..]
.find(|c: char| c.is_whitespace() || c == '>' || c == '/')
.map(|i| tag_start + 1 + i)
.unwrap_or(idx);
let tag_name = haystack[tag_start + 1..name_end].trim();
if tag_name.is_empty() {
continue;
}
let after_id = idx + pat.len();
let open_gt = haystack[after_id..].find('>')? + after_id;
// Skip self-closing `<div id="x" />`.
if haystack.as_bytes().get(open_gt.saturating_sub(1)) == Some(&b'/') {
continue;
}
let close = format!("</{tag_name}>");
// Case-insensitive close search for HTML friendliness.
let rest = &haystack[open_gt + 1..];
let close_rel = rest
.to_ascii_lowercase()
.find(&close.to_ascii_lowercase())?;
let close_idx = open_gt + 1 + close_rel;
let mut out = String::with_capacity(haystack.len() + payload.len());
out.push_str(&haystack[..open_gt + 1]);
out.push_str(payload);
out.push_str(&haystack[close_idx..]);
return Some(out);
}
None
}
/// Append intro + optional form: either inject into `form_target` mount inside intro, or sibling.
fn push_intro_and_form(
buf: &mut String,
intro: &str,
args: &Value,
form_data: Option<&Value>,
form_errors: Option<&Value>,
csrf: Option<&str>,
) {
let form = args.get("form");
let form_id = args
.get("form_id")
.and_then(|v| v.as_str())
.unwrap_or("form");
let target = args
.get("form_target")
.or_else(|| args.get("target"))
.or_else(|| args.get("form_slot"))
.or_else(|| args.get("表单插槽"))
.and_then(|v| v.as_str())
.unwrap_or("");
let form_html = form.map(|f| {
crate::form::render_body(f, form_id, form_data, form_errors, csrf)
});
if let Some(ref html) = form_html {
if !target.is_empty() && !intro.is_empty() {
if let Some(injected) = inject_html_into_id(intro, target, html) {
buf.push_str(&format!("<div class=\"main-intro\">{injected}</div>"));
return;
}
}
}
if !intro.is_empty() {
buf.push_str(&format!("<div class=\"main-intro\">{intro}</div>"));
}
if let Some(html) = form_html {
buf.push_str(&html);
}
}
/// 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))
}
}
}
#[derive(Clone, Debug)]
struct NavLink {
label: String,
href: String,
class: String,
media: String,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum NavWhen {
Always,
Hide,
Auth,
Guest,
}
fn parse_nav_when(raw: &str) -> NavWhen {
let t = raw.trim();
if t.is_empty()
|| matches!(
t,
"*" | "always" | "Always" | "真" | "yes" | "on" | "show" | "all"
)
{
return NavWhen::Always;
}
if matches!(
t,
"hide" | "never" | "off" | "no" | "假" | "否" | "0" | "false" | "False"
) {
return NavWhen::Hide;
}
if matches!(
t,
"auth" | "user" | "登录" | "已登录" | "logged_in" | "logged-in"
) {
return NavWhen::Auth;
}
if matches!(
t,
"guest" | "anon" | "anonymous" | "访客" | "匿名" | "未登录"
) {
return NavWhen::Guest;
}
// Unknown token: keep visible (forward-compatible).
NavWhen::Always
}
/// `Some(true)` logged in, `Some(false)` guest, `None` unknown (do not filter auth/guest).
fn page_auth_state(page: Option<&Value>) -> Option<bool> {
let page = page?;
if let Some(v) = page
.get("_nav_user")
.or_else(|| page.get("user"))
.or_else(|| page.get("username"))
.or_else(|| page.get("_user"))
{
match v {
Value::Null => Some(false),
Value::Bool(b) => Some(*b),
Value::String(s) => Some(!s.trim().is_empty()),
Value::Number(n) => Some(n.as_i64().unwrap_or(0) != 0),
_ => Some(true),
}
} else if let Some(v) = page.get("_logged_in").or_else(|| page.get("logged_in")) {
match v {
Value::Bool(b) => Some(*b),
Value::String(s) => Some(matches!(
s.trim(),
"1" | "true" | "True" | "yes" | "on" | "真" | "是"
)),
Value::Number(n) => Some(n.as_i64().unwrap_or(0) != 0),
_ => None,
}
} else {
None
}
}
fn nav_when_visible(when: NavWhen, auth: Option<bool>) -> bool {
match when {
NavWhen::Always => true,
NavWhen::Hide => false,
NavWhen::Auth => auth.unwrap_or(true), // unknown → keep (compat)
NavWhen::Guest => match auth {
Some(logged_in) => !logged_in,
None => true,
},
}
}
fn resolve_links(raw: Option<&Value>, db_url: Option<&str>, page: Option<&Value>) -> Vec<NavLink> {
let Some(raw) = raw else {
return Vec::new();
};
let auth = page_auth_state(page);
let binds = as_bind(raw);
let arr = binds.as_array().cloned().unwrap_or_default();
let rows: Vec<Map<String, Value>> = if !arr.is_empty() {
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, 0);
let projected = project_rows(
&arr,
&data
.get("rows")
.and_then(|v| v.as_array())
.cloned()
.unwrap_or_default(),
);
projected
.as_array()
.cloned()
.unwrap_or_default()
.into_iter()
.filter_map(|it| it.as_object().cloned())
.collect()
} else {
arr.into_iter()
.filter_map(|b| b.as_object().cloned())
.collect()
}
} else {
as_nav_rows(raw)
};
let mut out = Vec::new();
for m in rows {
let (label, href) = nav_label_href(&m);
if label.is_empty() {
continue;
}
let (media, when_raw, class) = nav_media_when_class(&m);
// DB-projected rows may use title/href without media keys on bind.
let when_raw = if when_raw.is_empty() {
m.get("when")
.or_else(|| m.get("当"))
.map(text)
.unwrap_or_default()
} else {
when_raw
};
let media = if media.is_empty() {
m.get("media")
.or_else(|| m.get("媒体"))
.map(text)
.unwrap_or_default()
} else {
media
};
let when = parse_nav_when(&when_raw);
if !nav_when_visible(when, auth) {
continue;
}
out.push(NavLink {
label,
href,
class,
media,
});
}
out
}
fn nav_media_class_map(links: &[NavLink]) -> (String, Vec<(String, String)>) {
nav_media_class_map_many(&[links])
}
fn nav_media_class_map_many(groups: &[&[NavLink]]) -> (String, Vec<(String, String)>) {
let mut pairs: Vec<(String, String)> = Vec::new();
let mut css = String::new();
for links in groups {
for link in *links {
let media = link.media.trim();
if media.is_empty() || pairs.iter().any(|(m, _)| m == media) {
continue;
}
let class = format!("nav-mq-{}", pairs.len());
css.push_str(&format!(
"@media not {media} {{ li.{class} {{ display:none !important; }} }}\n"
));
pairs.push((media.to_string(), class));
}
}
(css, pairs)
}
fn render_ul(links: &[NavLink], class: &str) -> String {
let (_css, mq_pairs) = nav_media_class_map(links);
render_ul_with_mq(links, class, &mq_pairs)
}
fn render_ul_with_mq(links: &[NavLink], class: &str, mq_pairs: &[(String, String)]) -> String {
let mut s = format!("<ul class=\"{}\">", esc(class));
for link in links {
let mq = link.media.trim();
let mq_class = if mq.is_empty() {
""
} else {
mq_pairs
.iter()
.find(|(m, _)| m == mq)
.map(|(_, c)| c.as_str())
.unwrap_or("")
};
let mut li_class = String::new();
if !link.class.is_empty() {
li_class.push_str(&link.class);
}
if !mq_class.is_empty() {
if !li_class.is_empty() {
li_class.push(' ');
}
li_class.push_str(mq_class);
}
if li_class.is_empty() {
s.push_str(&format!(
"<li><a href=\"{}\">{}</a></li>",
esc(&link.href),
esc(&link.label)
));
} else {
s.push_str(&format!(
"<li class=\"{}\"><a href=\"{}\">{}</a></li>",
esc(&li_class),
esc(&link.href),
esc(&link.label)
));
}
}
s.push_str("</ul>");
s
}
fn resolve_main(args: &Value, db_url: Option<&str>) -> (String, Vec<Map<String, Value>>, Option<i64>) {
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(), None);
};
let binds = as_bind(main);
let arr = binds.as_array().cloned().unwrap_or_default();
if arr.is_empty() {
return (intro, Vec::new(), None);
}
let Some(url) = db_url else {
return (intro, Vec::new(), None);
};
let Some(table) = crate::table::bind_table_name(&arr) else {
return (intro, Vec::new(), None);
};
let limit = args
.get("paginate")
.and_then(|p| p.get("limit"))
.and_then(|v| v.as_i64())
.unwrap_or(200);
let offset = args
.get("paginate")
.and_then(|p| p.get("offset"))
.and_then(|v| v.as_i64())
.unwrap_or(0);
let data = select_page_data(url, &table, args, limit, offset);
let total = data.get("total").and_then(|v| v.as_i64());
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, total)
}
/// 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,
offset: 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());
let paginate = args.get("paginate").is_some();
db::select_order(
url,
table,
limit,
where_v.as_ref(),
order.filter(|s| !s.trim().is_empty()),
if paginate || offset > 0 {
Some(offset)
} else {
None
},
None,
)
.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_VARS: &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); }
a { color:var(--ink); text-decoration:none; }
a:hover { color:var(--accent); }
"#;
const SHELL_LAYOUT: &str = r#"
body { 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"; }
@media (max-width:720px) {
body.has-sidebar { grid-template-columns:1fr; grid-template-areas:"top" "main" "foot" "side"; }
body.has-sidebar aside.side { border-right:0; border-top:1px solid var(--line); }
}
body.layout-stacked { display:flex; flex-direction:column; min-height:100vh; }
body.layout-stacked header.topnav, body.layout-stacked aside.side, body.layout-stacked main.main, body.layout-stacked footer.foot { width:100%; }
body.layout-stacked aside.side { border-right:0; border-bottom:1px solid var(--line); }
body.layout-bare { display:block; min-height:100vh; }
body.layout-bare main.main { padding:1.5rem 1.25rem 2rem; }
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; }
"#;
const SHELL_WIDGETS: &str = r#"
.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-body.md { line-height: 1.75; }
.article-body.md pre { background:#f5f5f4; border:1px solid var(--line); border-radius:6px; padding:1rem; overflow-x:auto; }
.article-body.md code { font-size:.9em; }
.pagination { display:flex; gap:1rem; align-items:center; margin:1.5rem 0; font-size:.95rem; }
.pagination a { color:var(--accent); text-decoration:none; }
.pagination a:hover { text-decoration:underline; }
.pagination .page-status { color:var(--muted); }
"#;
fn normalize_shell_css(raw: &str) -> &'static str {
match raw.trim().to_ascii_lowercase().as_str() {
"" | "full" | "default" => "full",
"minimal" | "min" | "vars" => "minimal",
"off" | "none" | "false" | "0" => "off",
_ => "full",
}
}
fn shell_css_for(mode: &str) -> String {
match normalize_shell_css(mode) {
"off" => String::new(),
"minimal" => SHELL_VARS.to_string(),
_ => format!("{SHELL_VARS}{SHELL_LAYOUT}{SHELL_WIDGETS}"),
}
}
fn normalize_layout(raw: &str) -> String {
match raw.trim().to_ascii_lowercase().as_str() {
"" | "auto" | "default" => String::new(),
"sidebar" | "side" => "sidebar".into(),
"stacked" | "stack" | "column" => "stacked".into(),
"bare" | "main" | "none" => "bare".into(),
"rail" => "rail".into(),
other => other.to_string(),
}
}
fn resolve_shell_css(args: &Value) -> String {
let raw = args
.get("shell_css")
.or_else(|| args.get("壳样式"))
.and_then(|v| v.as_str())
.unwrap_or("full");
shell_css_for(raw)
}
fn resolve_layout(args: &Value) -> String {
let raw = args
.get("layout")
.or_else(|| args.get("布局"))
.and_then(|v| v.as_str())
.unwrap_or("");
normalize_layout(raw)
}
fn head_html(args: &Value, default_title: &str) -> String {
let meta = args.get("meta").and_then(|v| v.as_object());
let page_title = meta
.and_then(|m| m.get("title"))
.map(text)
.filter(|s| !s.is_empty())
.unwrap_or_else(|| default_title.to_string());
let mut s = format!("<title>{}</title>", esc(&page_title));
if let Some(m) = meta {
for (k, v) in m {
if k == "title" {
continue;
}
let val = text(v);
if val.is_empty() {
continue;
}
match k.as_str() {
"description" => {
s.push_str(&format!(
"<meta name=\"description\" content=\"{}\"/>",
esc(&val)
));
}
"canonical" => {
s.push_str(&format!("<link rel=\"canonical\" href=\"{}\"/>", esc(&val)));
}
"icon" | "favicon" => {
s.push_str(&format!(
"<link rel=\"icon\" href=\"{}\"/>",
esc(&val)
));
}
"apple-touch-icon" | "apple_touch_icon" => {
s.push_str(&format!(
"<link rel=\"apple-touch-icon\" href=\"{}\"/>",
esc(&val)
));
}
k if k.starts_with("og:") => {
s.push_str(&format!(
"<meta property=\"{}\" content=\"{}\"/>",
esc(k),
esc(&val)
));
}
other => {
s.push_str(&format!(
"<meta name=\"{}\" content=\"{}\"/>",
esc(other),
esc(&val)
));
}
}
}
}
if let Some(head) = args.get("head") {
let links = crate::assets::head_links_from_json(head);
let asset_version = args
.get("asset_version")
.or_else(|| args.get("资源版本"))
.and_then(|v| v.as_str())
.unwrap_or("");
s.push_str(&crate::assets::render_head_links_with_version(
&links,
asset_version,
));
}
s
}
fn render_pagination(args: &Value, total: i64, item_count: usize) -> String {
let Some(p) = args.get("paginate") else {
return String::new();
};
let offset = p.get("offset").and_then(|v| v.as_i64()).unwrap_or(0);
let limit = p.get("limit").and_then(|v| v.as_i64()).unwrap_or(10);
if limit <= 0 {
return String::new();
}
let path = p
.get("path")
.and_then(|v| v.as_str())
.unwrap_or("/")
.to_string();
let mut s = String::from("<nav class=\"pagination\" aria-label=\"Pagination\">");
if offset > 0 {
let prev = offset.saturating_sub(limit);
s.push_str(&format!(
"<a class=\"page-prev\" href=\"{}?offset={}\">← Previous</a> ",
esc(&path),
prev
));
}
let end = offset + item_count as i64;
s.push_str(&format!(
"<span class=\"page-status\">{}–{} of {}</span> ",
offset + 1,
end.min(total),
total
));
if end < total {
s.push_str(&format!(
"<a class=\"page-next\" href=\"{}?offset={}\">Next →</a>",
esc(&path),
end
));
}
s.push_str("</nav>");
s
}
pub fn render_page(args: &Value, db_url: Option<&str>, csrf: Option<&str>) -> String {
render_page_ex(args, db_url, None, None, csrf)
}
/// 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>,
csrf: Option<&str>,
) -> String {
let title = args
.get("title")
.and_then(|v| v.as_str())
.unwrap_or("Marqdo Web");
let shell = resolve_shell_css(args);
let layout = resolve_layout(args);
let parts = args
.get("parts")
.and_then(|v| v.as_object())
.cloned()
.unwrap_or_default();
let nav = resolve_links(args.get("nav"), db_url, Some(args));
let side = resolve_links(args.get("sidebar"), db_url, Some(args));
let foot = resolve_links(args.get("footer"), db_url, Some(args));
let (intro, items, total) = resolve_main(args, db_url);
let (nav_css, mq_pairs) = nav_media_class_map_many(&[&nav, &side, &foot]);
let extra_owned = {
let base = args
.get("styles_css")
.and_then(|v| v.as_str())
.unwrap_or("");
if nav_css.is_empty() {
base.to_string()
} else {
format!("{base}\n{nav_css}")
}
};
let extra = extra_owned.as_str();
let has_side = args.get("sidebar").is_some() || !side.is_empty();
let bare = layout == "bare";
let body_class = match layout.as_str() {
"bare" => "layout-bare".to_string(),
"stacked" => "layout-stacked".to_string(),
"rail" => {
if has_side {
"has-rail has-sidebar".into()
} else {
"has-rail no-sidebar".into()
}
}
"sidebar" => {
if has_side {
"has-sidebar".into()
} else {
"no-sidebar".into()
}
}
"" => {
if has_side {
"has-sidebar".into()
} else {
"no-sidebar".into()
}
}
other => other.to_string(),
};
let mut main_html = String::new();
if let Some(images) = args.get("images_html").and_then(|v| v.as_str()) {
if !images.is_empty() {
main_html.push_str(images);
}
}
push_intro_and_form(
&mut main_html,
&intro,
args,
form_data,
form_errors,
csrf,
);
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>");
}
if let Some(t) = total {
main_html.push_str(&render_pagination(args, t, items.len()));
}
}
let style_block = if shell.is_empty() && extra.is_empty() {
String::new()
} else {
format!("<style>{shell}{extra}</style>")
};
let show_chrome = !bare;
let side_html = if show_chrome && has_side {
format!(
"<aside class=\"{}\"{}><span class=\"side-label\">侧栏</span>{}</aside>",
slot_class(args, "sidebar", "side"),
slot_attrs("sidebar", &parts, args),
render_ul_with_mq(&side, "side-nav", &mq_pairs)
)
} else {
String::new()
};
let header_html = if show_chrome {
format!(
"<header class=\"{}\"{}>{}</header>",
slot_class(args, "nav", "topnav"),
slot_attrs("nav", &parts, args),
render_ul_with_mq(&nav, "nav", &mq_pairs)
)
} else {
String::new()
};
let footer_html = if show_chrome {
format!(
"<footer class=\"{}\"{}>{}</footer>",
slot_class(args, "footer", "foot"),
slot_attrs("footer", &parts, args),
render_ul_with_mq(&foot, "foot-nav", &mq_pairs)
)
} else {
String::new()
};
format!(
r#"<!DOCTYPE html>
<html lang="zh-CN"><head>
<meta charset="utf-8"/>
<meta name="viewport" content="width=device-width, initial-scale=1"/>
{head}
{style_block}
</head>
<body class="{body_class}">
{header_html}
{side_html}
<main class="{main_class}"{main_attrs}>{main_html}</main>
{footer_html}
</body></html>"#,
head = head_html(args, title),
main_class = slot_class(args, "main", "main"),
main_attrs = slot_attrs("main", &parts, args),
)
}
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, Some(args));
format!(
"<header class=\"topnav\" data-slot=\"nav\">{}</header>",
render_ul(&links, "nav")
)
}
"sidebar" => {
let links = resolve_links(args.get("sidebar"), db_url, Some(args));
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, Some(args));
format!(
"<footer class=\"foot\" data-slot=\"footer\">{}</footer>",
render_ul(&links, "foot-nav")
)
}
_ => {
let (intro, items, _total) = resolve_main(args, db_url);
let mut body = String::new();
if let Some(images) = args.get("images_html").and_then(|v| v.as_str()) {
if !images.is_empty() {
body.push_str(images);
}
}
push_intro_and_form(&mut body, &intro, args, None, 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(&markdown::to_html(&body));
}
s.push_str("</article>");
s
}
#[cfg(test)]
mod shell_tests {
use super::*;
use serde_json::json;
#[test]
fn shell_off_omits_sidebar_grid() {
let page = json!({
"title": "t",
"shell_css": "off",
"layout": "stacked",
"sidebar": [{"label": "A", "href": "/a"}],
});
let html = render_page(&page, None, None);
assert!(html.contains("layout-stacked"));
assert!(!html.contains("has-sidebar"));
assert!(!html.contains("grid-template-columns:14rem"));
}
#[test]
fn shell_minimal_keeps_vars_not_cards() {
let page = json!({ "title": "t", "shell_css": "minimal" });
let html = render_page(&page, None, None);
assert!(html.contains("--ink:"));
assert!(!html.contains(".content.cards article"));
assert!(!html.contains("grid-template-columns:14rem"));
}
#[test]
fn layout_bare_skips_aside() {
let page = json!({
"title": "t",
"layout": "bare",
"sidebar": [{"label": "A", "href": "/a"}],
"nav": [{"label": "Home", "href": "/"}],
});
let html = render_page(&page, None, None);
assert!(html.contains("layout-bare"));
assert!(!html.contains("<aside"));
assert!(!html.contains("<header"));
}
#[test]
fn default_full_keeps_sidebar_grid() {
let page = json!({
"title": "t",
"sidebar": [{"label": "A", "href": "/a"}],
});
let html = render_page(&page, None, None);
assert!(html.contains("has-sidebar"));
assert!(html.contains("grid-template-columns:14rem"));
}
}
#[cfg(test)]
mod nav_tests {
use super::*;
use serde_json::json;
#[test]
fn when_hide_omits_item() {
let page = json!({
"title": "t",
"shell_css": "off",
"nav": [
{"label": "Home", "href": "/"},
{"label": "Secret", "href": "/x", "when": "hide"},
],
});
let html = render_page(&page, None, None);
assert!(html.contains(">Home<"), "{html}");
assert!(!html.contains("/x"), "{html}");
}
#[test]
fn when_auth_guest_respects_logged_in() {
let nav = json!([
{"front": "Public", "back": "/"},
{"front": "Admin", "back": "/admin", "when": "auth"},
{"front": "Login", "back": "/login", "when": "guest"},
]);
let guest = json!({
"title": "t",
"shell_css": "off",
"_logged_in": false,
"nav": nav,
});
let g = render_page(&guest, None, None);
assert!(g.contains("/login"), "{g}");
assert!(!g.contains("/admin"), "{g}");
let user = json!({
"title": "t",
"shell_css": "off",
"_logged_in": true,
"_nav_user": "alice",
"nav": nav,
});
let u = render_page(&user, None, None);
assert!(u.contains("/admin"), "{u}");
assert!(!u.contains("/login"), "{u}");
}
#[test]
fn media_emits_class_and_css() {
let page = json!({
"title": "t",
"shell_css": "off",
"nav": [
{"label": "Wide", "href": "/w", "media": "(min-width: 900px)"},
{"label": "Home", "href": "/"},
],
});
let html = render_page(&page, None, None);
assert!(html.contains("nav-mq-0"), "{html}");
assert!(html.contains("@media not (min-width: 900px)"), "{html}");
assert!(html.contains(">Home<"), "{html}");
}
#[test]
fn inject_html_into_id_replaces_inner() {
let intro = r#"<div class="cols"><div id="left">L</div><div id="form-mount"></div></div>"#;
let out = inject_html_into_id(intro, "#form-mount", "<form class=\"site-form\">x</form>")
.expect("inject");
assert!(out.contains(r#"<div id="form-mount"><form class="site-form">x</form></div>"#), "{out}");
assert!(out.contains(r#"<div id="left">L</div>"#), "{out}");
}
#[test]
fn form_target_mounts_inside_intro() {
let page = json!({
"title": "Compose",
"shell_css": "off",
"intro": "<div class=\"cols\"><div id=\"a\">A</div><div id=\"qd-note-form-mount\"></div></div>",
"form_id": "note",
"form_target": "#qd-note-form-mount",
"form": {
"title": "note",
"show_meta": false,
"fields": [{"name": "title", "label": "Title", "type": "text"}]
}
});
let html = render_page(&page, None, None);
assert_eq!(html.matches("class=\"site-form\"").count(), 1, "{html}");
let mount_at = html.find("id=\"qd-note-form-mount\"").expect("mount");
let form_at = html.find("class=\"site-form\"").expect("form");
assert!(form_at > mount_at, "{html}");
assert!(
html.contains("qd-note-form-mount\"><div class=\"site-form\""),
"{html}"
);
// Sibling fallback would place site-form after </div></div> of main-intro.
let intro_end = html.find("class=\"main-intro\"").expect("intro")
+ html[html.find("class=\"main-intro\"").unwrap()..]
.find("</div>")
.expect("intro close");
// With injection, site-form is before the outer main-intro close — already asserted by adjacency.
let _ = intro_end;
}
}