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:
1 parent
7645dd4c1f
commit
da9fc75b1e
20 files changed
+1518
-93
No files matched your search
@@ -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}"),
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
@@ -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
@@ -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, ¶ms);
|
||||
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, ¶ms);
|
||||
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
@@ -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
@@ -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
@@ -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());
|
||||
|
||||
Reference in new issue
Block a user