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>
This commit is contained in:
cflmyandCursor committed 2026-08-26 13:03:55 +08:00
1 parent 7645dd4c1f
commit da9fc75b1e
20 files changed
+1518 -93

No files matched your search

+8 -4
View File
@@ -134,10 +134,14 @@ pub fn compose_main(
SitePath::DbField { table, field } => format!("{table}.{field}"),
SitePath::Plain(s) => s,
SitePath::LibMember { lib, member } => {
let v = call_lib(&format!("{lib}.{member}"))?;
match v {
Value::String(s) => s,
other => other.to_string(),
// Try a module member (e.g. `theme.hero`); if the lib is unknown,
// treat `a.b` as a DB field `a.b` (table `a`, column `b`).
match call_lib(&format!("{lib}.{member}")) {
Ok(v) => match v {
Value::String(s) => s,
other => other.to_string(),
},
Err(_) => format!("{lib}.{member}"),
}
}
};
+36
View File
@@ -272,6 +272,20 @@ pub fn select(
table: &str,
limit: i64,
where_v: Option<&Value>,
) -> Result<Value, String> {
select_order(url, table, limit, where_v, None)
}
/// Like `select`, with an optional `ORDER BY`.
///
/// `order` is a column name, optionally prefixed with `-` for descending
/// (`"created_at"`, `"-created_at"`). Comma-separated lists are allowed.
pub fn select_order(
url: &str,
table: &str,
limit: i64,
where_v: Option<&Value>,
order: Option<&str>,
) -> Result<Value, String> {
let table = ident(table)?;
let (clauses, mut vals) = parse_where(where_v)?;
@@ -281,6 +295,28 @@ pub fn select(
sql.push_str(" WHERE ");
sql.push_str(&clauses.join(" AND "));
}
if let Some(order) = order {
let order = order.trim();
if !order.is_empty() {
let parts: Vec<&str> = order
.split(',')
.map(|p| p.trim())
.filter(|p| !p.is_empty())
.collect();
let mut exprs = Vec::new();
for part in parts {
let (col, dir) = match part.strip_prefix('-') {
Some(col) => (col, " DESC"),
None => (part, ""),
};
exprs.push(format!("\"{}\"{}", ident(col)?, dir));
}
if !exprs.is_empty() {
sql.push_str(" ORDER BY ");
sql.push_str(&exprs.join(", "));
}
}
}
sql.push_str(&format!(" LIMIT ?{}", vals.len() + 1));
vals.push(rusqlite::types::Value::Integer(limit));
let mut stmt = conn.prepare(&sql).map_err(|e| e.to_string())?;
+64 -34
View File
@@ -6,7 +6,6 @@ use std::path::PathBuf;
use std::sync::Arc;
use axum::extract::{Form, Path, Query, State};
use axum::http::Uri;
use axum::response::{Html, IntoResponse, Redirect, Response};
use axum::routing::get;
use axum::Router;
@@ -28,7 +27,6 @@ struct AppState {
forms: HashMap<String, Value>,
/// Page that owns an embedded form (for re-render on validation errors).
form_owners: HashMap<String, Value>,
routes: HashMap<String, Value>,
/// Admin users table (`|用户名|密码|`) when login-gated admin is configured.
auth_users: Option<Value>,
session_ttl: u64,
@@ -82,7 +80,6 @@ pub fn listen(
admin,
forms,
form_owners,
routes: routes.clone(),
auth_users,
session_ttl,
});
@@ -103,12 +100,52 @@ pub fn listen(
.route("/admin/{table}/{id}/delete", get(admin_delete));
// Register each author route as an exact GET path + `{path}/_part/{id}`.
// Paths containing `{param}` become dynamic routes (e.g. `/post/{slug}`);
// the captured params are injected into the page before rendering.
let mut paths: Vec<String> = routes.keys().cloned().collect();
paths.sort();
for path in paths {
app = app.route(&path, get(routed_page));
let part_path = format!("{path}/_part/{{id}}");
app = app.route(&part_path, get(routed_part));
let page = routes.get(&path).cloned().unwrap_or_default();
let dynamic = path.contains('{');
if dynamic {
let page_for_render = page.clone();
app = app.route(
&path,
get(async move |State(st): State<Arc<AppState>>, Path(params): Path<HashMap<String, String>>| {
let mut p = page_for_render.clone();
inject_params(&mut p, &params);
Html(render::render_page(&p, st.db_url.as_deref())).into_response()
}),
);
// Dynamic `{path}/_part/{id}` with the same path params.
let part_path = format!("{path}/_part/{{id}}");
let page_for_part = page.clone();
app = app.route(
&part_path,
get(async move |State(st): State<Arc<AppState>>, Path((params, id)): Path<(HashMap<String, String>, String)>| {
let mut p = page_for_part.clone();
inject_params(&mut p, &params);
render_part_from_page(&p, &id, st.db_url.as_deref())
}),
);
} else {
let page_for_render = page.clone();
app = app.route(
&path,
get(async move |State(st): State<Arc<AppState>>| {
Html(render::render_page(&page_for_render, st.db_url.as_deref()))
.into_response()
}),
);
let part_path = format!("{path}/_part/{{id}}");
let page_for_part = page.clone();
app = app.route(
&part_path,
get(async move |State(st): State<Arc<AppState>>, Path(id): Path<String>| {
render_part_from_page(&page_for_part, &id, st.db_url.as_deref())
}),
);
}
}
// WebSocket endpoints (`ws://…/{path}`), echo-mode by default.
@@ -181,15 +218,28 @@ async fn home(State(st): State<Arc<AppState>>) -> Html<String> {
Html(html)
}
async fn routed_page(State(st): State<Arc<AppState>>, uri: Uri) -> Response {
let mut path = uri.path().to_string();
while path.len() > 1 && path.ends_with('/') {
path.pop();
/// Inject captured dynamic-route params into a page copy as `params` (a map),
/// so render can resolve `{param}` placeholders in `query`/`intro`.
fn inject_params(page: &mut Value, params: &HashMap<String, String>) {
if let Some(obj) = page.as_object_mut() {
let mut map = Map::new();
for (k, v) in params {
map.insert(k.clone(), json!(v));
}
obj.insert("params".into(), Value::Object(map));
// Propagate into every part (fragments render independently).
if let Some(parts) = obj.get_mut("parts").and_then(|p| p.as_object_mut()) {
for cfg in parts.values_mut() {
if let Some(m) = cfg.as_object_mut() {
let mut pmap = Map::new();
for (k, v) in params {
pmap.insert(k.clone(), json!(v));
}
m.insert("params".into(), Value::Object(pmap));
}
}
}
}
let Some(page) = st.routes.get(&path) else {
return Html(format!("<p>404 not found: {}</p>", esc(&path))).into_response();
};
Html(render::render_page(page, st.db_url.as_deref())).into_response()
}
fn render_part_from_page(page: &Value, id: &str, db_url: Option<&str>) -> Response {
@@ -206,26 +256,6 @@ async fn home_part(State(st): State<Arc<AppState>>, Path(id): Path<String>) -> R
render_part_from_page(&st.page, &id, st.db_url.as_deref())
}
/// `{route}/_part/{id}` — resolve part against the page mounted at `route`.
async fn routed_part(
State(st): State<Arc<AppState>>,
uri: Uri,
Path(id): Path<String>,
) -> Response {
let full = uri.path();
let marker = format!("/_part/{id}");
let Some(page_path) = full.strip_suffix(&marker) else {
return Html(format!("<p>bad part path {}</p>", esc(full))).into_response();
};
if page_path.is_empty() || page_path == "/" {
return render_part_from_page(&st.page, &id, st.db_url.as_deref());
}
let Some(page) = st.routes.get(page_path) else {
return Html(format!("<p>404 not found: {}</p>", esc(page_path))).into_response();
};
render_part_from_page(page, &id, st.db_url.as_deref())
}
async fn form_get(State(st): State<Arc<AppState>>, Path(id): Path<String>) -> Response {
let Some(frm) = st.forms.get(&id) else {
return Html(format!("<p>unknown form {id}</p>")).into_response();
+104 -2
View File
@@ -9,6 +9,8 @@ mod session;
mod table;
mod ws;
use crate::table::as_css_named;
use std::ffi::{CStr, CString};
use std::os::raw::{c_char, c_int, c_void};
use std::path::PathBuf;
@@ -275,6 +277,71 @@ web_ffi!(web_compose_main, |args: &Value| {
compose::compose_main(&page, &main, |path| call_lib(path))
});
web_ffi!(web_page_query, |args: &Value| {
let page = args.get("page").cloned().unwrap_or(json!({}));
let query = args.get("query").cloned().unwrap_or(json!({}));
let mut obj = page.as_object().cloned().unwrap_or_default();
obj.insert("query".into(), query);
Ok(Value::Object(obj))
});
web_ffi!(web_page_order, |args: &Value| {
let page = args.get("page").cloned().unwrap_or(json!({}));
let order = arg_str(args, "order")?.to_string();
let mut obj = page.as_object().cloned().unwrap_or_default();
obj.insert("order".into(), json!(order));
Ok(Value::Object(obj))
});
web_ffi!(web_page_link_prefix, |args: &Value| {
let page = args.get("page").cloned().unwrap_or(json!({}));
let prefix = arg_str(args, "prefix")?.to_string();
let mut obj = page.as_object().cloned().unwrap_or_default();
obj.insert("link_prefix".into(), json!(prefix));
Ok(Value::Object(obj))
});
web_ffi!(web_page_css, |args: &Value| {
let page = args.get("page").cloned().unwrap_or(json!({}));
let css = arg_str_opt(args, "css").unwrap_or("").to_string();
let mut obj = page.as_object().cloned().unwrap_or_default();
if !css.trim().is_empty() {
let prev = obj
.get("styles_css")
.and_then(|v| v.as_str())
.unwrap_or("")
.to_string();
obj.insert("styles_css".into(), json!(format!("{prev}\n{css}")));
}
Ok(Value::Object(obj))
});
// Assemble a GFM style table into CSS text.
//
// Two shapes are accepted:
// 1. Rule rows `|选择器|属性|值|` → `selector { prop: value; }`
// 2. Property rows `|属性|值|` → `.name { prop: value; }`
//
// The `name` argument names the CSS class for shape 2, and is ignored for
// shape 1. This is how Marqdo-side theme modules turn style tables into a
// stylesheet with 文档即代码 — styles are data, assembly is a function.
web_ffi!(web_style, |args: &Value| {
let name = arg_str_opt(args, "name").unwrap_or("").to_string();
let table = args.get("table").cloned().unwrap_or(json!([]));
Ok(Value::String(as_css_named(&name, &table)))
});
web_ffi!(web_page_detail, |args: &Value| {
let page = args.get("page").cloned().unwrap_or(json!({}));
let on = args
.get("detail")
.and_then(|v| v.as_bool())
.unwrap_or(true);
let mut obj = page.as_object().cloned().unwrap_or_default();
obj.insert("detail".into(), json!(on));
Ok(Value::Object(obj))
});
web_ffi!(web_compose_form, |args: &Value| {
let page = args.get("page").cloned().unwrap_or(json!({}));
let form = args
@@ -335,7 +402,12 @@ web_ffi!(web_db_select, |args: &Value| {
}
Some(v) => Some(v),
};
db::select(&url, &table, limit, where_v)
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, order)
} else {
db::select(&url, &table, limit, where_v)
}
});
web_ffi!(web_db_get, |args: &Value| {
@@ -893,6 +965,36 @@ pub unsafe extern "C" fn marqdo_plugin_init(host: *const MarqdoHostApi) -> c_int
web_compose_components as PluginFn,
),
("web_compose_main", "page,main", web_compose_main as PluginFn),
(
"web_page_query",
"page,query",
web_page_query as PluginFn,
),
(
"web_page_order",
"page,order",
web_page_order as PluginFn,
),
(
"web_page_link_prefix",
"page,prefix",
web_page_link_prefix as PluginFn,
),
(
"web_page_css",
"page,css",
web_page_css as PluginFn,
),
(
"web_page_detail",
"page,detail",
web_page_detail as PluginFn,
),
(
"web_style",
"name,table",
web_style as PluginFn,
),
(
"web_compose_form",
"page,form,id",
@@ -904,7 +1006,7 @@ pub unsafe extern "C" fn marqdo_plugin_init(host: *const MarqdoHostApi) -> c_int
("web_db_insert", "url,table,rows", web_db_insert as PluginFn),
(
"web_db_select",
"url,table,where,limit",
"url,table,where,limit,order",
web_db_select as PluginFn,
),
("web_db_get", "url,table,id", web_db_get as PluginFn),
+203 -34
View File
@@ -1,6 +1,6 @@
//! Minimal HTML shell for assembled pages / parts.
use serde_json::{Map, Value};
use serde_json::{json, Map, Value};
use crate::db;
use crate::table::{as_bind, normalize_ref, normalize_slot, parse_site_path, project_rows, SitePath};
@@ -77,9 +77,7 @@ fn resolve_links(raw: Option<&Value>, db_url: Option<&str>) -> Vec<(String, Stri
let Some(table) = table else {
return Vec::new();
};
let Ok(data) = db::select(url, &table, 200, None) else {
return Vec::new();
};
let data = select_page_data(url, &table, raw, 200);
let rows = data
.get("rows")
.and_then(|v| v.as_array())
@@ -149,9 +147,7 @@ fn resolve_main(args: &Value, db_url: Option<&str>) -> (String, Vec<Map<String,
let Some(table) = crate::table::bind_table_name(&arr) else {
return (intro, Vec::new());
};
let Ok(data) = db::select(url, &table, 200, None) 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())
@@ -168,6 +164,66 @@ fn resolve_main(args: &Value, db_url: Option<&str>) -> (String, Vec<Map<String,
(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())
@@ -255,6 +311,14 @@ a:hover { color:var(--accent); }
.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 {
@@ -311,23 +375,19 @@ pub fn render_page_ex(
));
}
if !items.is_empty() {
main_html.push_str("<section class=\"content cards\">");
for it in &items {
let title = it
.get("title")
.map(text)
.unwrap_or_else(|| "item".into());
let body = it.get("body").map(text).unwrap_or_default();
let tc = class_attr(&field_css(it, "title"));
let bc = class_attr(&field_css(it, "body"));
main_html.push_str("<article>");
main_html.push_str(&format!("<h2{tc}>{}</h2>", esc(&title)));
if !body.is_empty() {
main_html.push_str(&format!("<p{bc}>{}</p>", esc(&body)));
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("</article>");
main_html.push_str("</section>");
}
main_html.push_str("</section>");
}
format!(
@@ -409,21 +469,130 @@ pub fn render_fragment(args: &Value, db_url: Option<&str>) -> String {
body.push_str(&crate::form::render_body(form, form_id, None, None));
}
if !items.is_empty() {
body.push_str("<section class=\"content cards\">");
for it in &items {
let title = it.get("title").map(text).unwrap_or_default();
let b = it.get("body").map(text).unwrap_or_default();
let tc = class_attr(&field_css(it, "title"));
let bc = class_attr(&field_css(it, "body"));
body.push_str(&format!(
"<article><h2{tc}>{}</h2><p{bc}>{}</p></article>",
esc(&title),
esc(&b)
));
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>");
}
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
}
+153 -15
View File
@@ -12,6 +12,8 @@ const SRC_KEYS: &[&str] = &["组件", "导入的页面", "src", "page"];
const STYLE_KEYS: &[&str] = &["样式", "style", "class"];
const PROP_KEYS: &[&str] = &["属性", "property", "prop", "名", "name"];
const VAL_KEYS: &[&str] = &["值", "value"];
const SEL_KEYS: &[&str] = &["选择器", "selector", "sel"];
const MEDIA_KEYS: &[&str] = &["媒体", "media", "mq", "@media"];
pub fn normalize_ref(s: &str) -> String {
let s = s.trim();
@@ -270,42 +272,178 @@ pub fn normalize_slot(name: &str) -> String {
}
}
/// Style table → CSS text for `.name { … }`
/// Style table → CSS text.
///
/// Three table shapes are supported:
/// 1. Rule rows `|媒体|选择器|属性|值|` — rows grouped by `媒体` emit
/// `@media { … }` blocks; rows sharing a selector are merged into one rule.
/// 2. Rule rows `|选择器|属性|值|` — each row emits `selector { prop: value; }`,
/// rows sharing a selector are merged into one rule. `selector` may be any
/// CSS selector (`aside.side`, `ul.side-nav a:hover`).
/// 3. Plain property rows `|属性|值|` — emitted as `.name { prop: value; }`.
///
/// Examples (rule shape):
/// ```text
/// | 媒体 | 选择器 | 属性 | 值 |
/// |------|--------|------|-----|
/// | (max-width: 860px) | aside.side | padding | 1rem 2rem |
///
/// | 选择器 | 属性 | 值 |
/// |--------|------|-----|
/// | aside.side | padding | 2rem 1.25rem |
/// | aside.side | background | #f5f5f4 |
/// | ul.side-nav a:hover | color | var(--accent) |
/// ```
pub fn as_css_named(name: &str, table: &Value) -> String {
let name = normalize_ref(name);
if name.is_empty() {
return String::new();
}
let mut rules = Vec::new();
let mut out = String::new();
match table {
Value::Object(m) => {
// Column-first table object: `{选择器:[…], 属性:[…], 值:[…], 媒体:[…]}`
// (how GFM tables reach the plugin). Row-major maps (one rule per map)
// are handled too: if 选择器 is a scalar, treat it as a single row.
let sels = pick(m, SEL_KEYS).map(as_str_list).unwrap_or_default();
let props = pick(m, PROP_KEYS).map(as_str_list).unwrap_or_default();
let vals = pick(m, VAL_KEYS).map(as_str_list).unwrap_or_default();
for (i, p) in props.iter().enumerate() {
let medias = pick(m, MEDIA_KEYS).map(as_str_list).unwrap_or_default();
let n = props.len().max(sels.len()).max(vals.len());
if n == 0 {
return String::new();
}
let rows: Vec<(String, String, String, String)> = (0..n)
.map(|i| {
(
medias.get(i).cloned().unwrap_or_default(),
sels.get(i).cloned().unwrap_or_default(),
props.get(i).cloned().unwrap_or_default(),
vals.get(i).cloned().unwrap_or_default(),
)
})
.collect();
// Group by media then selector; or plain `.name { … }` when no selectors.
let mut by_media: Vec<(String, Vec<(String, Vec<String>)>)> = Vec::new();
let mut plain: Vec<String> = Vec::new();
for (media, sel, p, v) in rows {
if p.is_empty() {
continue;
}
let v = vals.get(i).cloned().unwrap_or_default();
rules.push(format!(" {p}: {v};"));
let decl = format!(" {p}: {v};");
if !media.is_empty() {
let group = match by_media.iter_mut().find(|(mq, _)| *mq == media) {
Some((_, g)) => g,
None => {
by_media.push((media.clone(), Vec::new()));
let (_, g) = by_media.last_mut().unwrap();
g
}
};
push_rule(group, &sel, decl);
} else if !sel.is_empty() {
let group = match by_media.iter_mut().find(|(mq, _)| mq.is_empty()) {
Some((_, g)) => g,
None => {
by_media.push((String::new(), Vec::new()));
let (_, g) = by_media.last_mut().unwrap();
g
}
};
push_rule(group, &sel, decl);
} else {
plain.push(decl);
}
}
for (media, rules) in by_media {
if media.is_empty() {
for (sel, decls) in rules {
out.push_str(&format!("{} {{\n{}\n}}\n", sel, decls.join("\n")));
}
} else {
let inner = rules
.iter()
.map(|(sel, decls)| format!("{} {{\n{}\n}}", sel, decls.join("\n")))
.collect::<Vec<_>>()
.join("\n");
out.push_str(&format!("@media {} {{\n{}\n}}\n", media, inner));
}
}
if !plain.is_empty() {
out.push_str(&format!(".{} {{\n{}\n}}\n", name, plain.join("\n")));
}
}
Value::Array(rows) => {
// Group rule rows by media query and selector; plain rows as `.name { … }`.
let mut by_media: Vec<(String, Vec<(String, Vec<String>)>)> = Vec::new();
let mut plain: Vec<String> = Vec::new();
for row in rows {
if let Some(m) = row.as_object() {
let p = pick(m, PROP_KEYS).map(cell_str).unwrap_or_default();
let v = pick(m, VAL_KEYS).map(cell_str).unwrap_or_default();
if !p.is_empty() {
rules.push(format!(" {p}: {v};"));
}
let Some(m) = row.as_object() else { continue };
let media = pick(m, MEDIA_KEYS).map(cell_str).unwrap_or_default();
let sel = pick(m, SEL_KEYS).map(cell_str).unwrap_or_default();
let p = pick(m, PROP_KEYS).map(cell_str).unwrap_or_default();
let v = pick(m, VAL_KEYS).map(cell_str).unwrap_or_default();
if p.is_empty() {
continue;
}
let decl = format!(" {p}: {v};");
if !media.is_empty() {
let group = match by_media.iter_mut().find(|(mq, _)| *mq == media) {
Some((_, g)) => g,
None => {
by_media.push((media.clone(), Vec::new()));
let (_, g) = by_media.last_mut().unwrap();
g
}
};
push_rule(group, &sel, decl);
} else if !sel.is_empty() {
let group = match by_media.iter_mut().find(|(mq, _)| mq.is_empty()) {
Some((_, g)) => g,
None => {
by_media.push((String::new(), Vec::new()));
let (_, g) = by_media.last_mut().unwrap();
g
}
};
push_rule(group, &sel, decl);
} else {
plain.push(decl);
}
}
for (media, rules) in by_media {
if media.is_empty() {
for (sel, decls) in rules {
out.push_str(&format!("{} {{\n{}\n}}\n", sel, decls.join("\n")));
}
} else {
let inner = rules
.iter()
.map(|(sel, decls)| format!("{} {{\n{}\n}}", sel, decls.join("\n")))
.collect::<Vec<_>>()
.join("\n");
out.push_str(&format!("@media {} {{\n{}\n}}\n", media, inner));
}
}
if !plain.is_empty() {
out.push_str(&format!(".{} {{\n{}\n}}\n", name, plain.join("\n")));
}
}
_ => {}
}
if rules.is_empty() {
return String::new();
out
}
/// Push `decl` under `sel` into a `(selector, declarations)` group list,
/// merging declarations when the selector already exists.
fn push_rule(groups: &mut Vec<(String, Vec<String>)>, sel: &str, decl: String) {
if sel.is_empty() {
return;
}
match groups.iter_mut().find(|(s, _)| s == sel) {
Some((_, decls)) => decls.push(decl),
None => groups.push((sel.to_string(), vec![decl])),
}
format!(".{} {{\n{}\n}}\n", name, rules.join("\n"))
}
#[derive(Debug, Clone, PartialEq, Eq)]
@@ -370,11 +508,11 @@ pub fn project_rows(binds: &[Value], rows: &[Value]) -> Value {
let class = b.get("css").and_then(|v| v.as_str()).unwrap_or("");
let col = match parse_site_path(back) {
SitePath::DbField { field, .. } => field,
SitePath::LibMember { member, .. } => member,
SitePath::Plain(s) if s.contains('.') => {
s.split('.').next_back().unwrap_or(&s).to_string()
}
SitePath::Plain(s) => s,
SitePath::LibMember { .. } => back.to_string(),
};
if let Some(v) = obj.get(&col).or_else(|| obj.get(front)) {
m.insert(front.to_string(), v.clone());