Files
marqdo/src/view/render.rs
T
cflmyandCursor dc853fb580 release: bump to 2.1.2 (EK production chain + View V0–V3 bar)
Ship evidence/closure invalidation, verify/adjudicate, reuse_execute and
agent bind/publish gates, document.extract, KnowledgePresentation + SSE
page_token, and upload max_bytes with the 45-test offline gate.

Co-authored-by: Cursor <cursoragent@cursor.com>
2026-10-24 22:52:03 +08:00

2049 lines
74 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.
//! Render Marqdo AST as HTML fragments for `view`.
//!
//! Comments are not in the AST; they are interleaved from classified source lines.
//! Expressions are shown in surface syntax, never Rust `Debug`.
use std::collections::HashMap;
use crate::ast::{
Arg, BinaryOp, CallExpr, Expr, Function, InterpPart, Literal, Module, Stmt, UnaryOp,
};
use crate::host::writeback;
use crate::lex::{classify_source, ClassifiedLine, LineKind};
use crate::view::html::escape;
use pulldown_cmark::{html, Options, Parser};
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum StructureMode {
/// Documentation browse: fun anchors, no breakpoint gutters
Browse,
/// Debugger: breakpoint gutters on statements
Debug,
}
pub struct FileViewModel {
#[allow(dead_code)]
pub rel_path: String,
pub source: String,
pub structure_html: String,
pub outline_html: String,
pub stdout: String,
pub stderr: String,
pub ok: bool,
/// Text shown in the live-view preset stdin box.
pub preset_stdin: String,
/// One entry per `input` / `输入` call (prompt text; may be empty).
/// Empty vec → page does not use input; hide the preset form.
pub input_prompts: Vec<String>,
/// Live view: program uses `input` but no stdin yet — execution deferred until form submit.
pub awaiting_input: bool,
/// Live view: stdin present — skip blocking page-load run; client auto-starts Stream SSE.
pub auto_stream: bool,
/// Show the LLM/agent Stream panel (live view only; gated on ext llm/agent import).
pub show_stream: bool,
/// SVG plots from math lib (embedded in Execution).
pub plots: Vec<String>,
/// HTML for Variables panel (entry bindings after run).
#[allow(dead_code)]
pub bindings_html: String,
/// ViewExecutionReport JSON for AI / call-picker (empty if no run).
pub trace_json: String,
/// Static semantic facts; generated without evaluating the document.
pub knowledge_html: String,
/// Visible when semantic analysis fails (V0); empty when analysis succeeded or was skipped.
pub knowledge_error: String,
/// V2: page token for SSE stale-packet rejection (empty when unknown).
pub page_token: String,
}
/// A compact, textual (not colour-only) explanation of executable knowledge.
/// View deliberately compiles semantics without running the target, so a page
/// can show binding/effect/verification facts even in `--no-exec` exports.
///
/// V0: skip module/type container cards by default; rename lock digest accurately.
pub fn render_knowledge_html(project: &crate::sema::SemanticProject, rel: &str) -> String {
let artifacts: Vec<_> = project
.artifacts
.iter()
.filter(|artifact| {
artifact.source.file == rel && artifact.kind != "module" && artifact.kind != "type"
})
.collect();
let steps: Vec<_> = project.steps.iter().filter(|step| step.source.file == rel).collect();
if artifacts.is_empty() && steps.is_empty() {
return String::new();
}
let mut out = String::from(r#"<div class="knowledge-panel" aria-label="Executable knowledge">"#);
if !steps.is_empty() {
out.push_str(r#"<article class="knowledge-card knowledge-steps"><h3>文档中的步骤</h3><p class="knowledge-hint">结构步骤(非实际执行时序)</p><ol class="knowledge-step-list">"#);
for step in &steps {
let label = project
.refs
.iter()
.find(|r| r.id == step.reference)
.map(|r| r.label.as_str())
.unwrap_or(step.reference.as_str());
let line = step.source.line;
let target_ids = if step.calls.is_empty() {
String::new()
} else {
format!(
r#" <span class="knowledge-step-targets">→ {}</span>"#,
escape(&step.calls.iter().map(|id| id.as_str()).collect::<Vec<_>>().join(", "))
)
};
// Structure pane uses #stmt-{line}; jump there for source navigation.
out.push_str(&format!(
"<li class=\"knowledge-step\" data-step-kind=\"{0}\" data-line=\"{1}\"><a href=\"#stmt-{1}\"><code class=\"ks-kind\">{0}</code> {2}</a>{3}</li>",
escape(&step.kind),
line,
escape(label),
target_ids,
));
}
out.push_str("</ol></article>");
}
for artifact in artifacts {
let target = artifact.symbol_id.as_ref().map(|id| id.as_str()).unwrap_or(artifact.artifact_id.0.as_str());
let signature = artifact.signature.as_ref().map(|sig| {
let params = sig.params.iter().map(|param| format!("{}: {}{}", param.name, param.ty, if param.required { "" } else { "?" })).collect::<Vec<_>>().join(", ");
format!("({params}) → {}", sig.returns)
}).unwrap_or_else(|| "declaration".into());
let effects = artifact.effects.values().join(", ");
let deps = if artifact.dependencies.is_empty() { "none".to_string() } else { artifact.dependencies.iter().map(|id| id.0.as_str()).collect::<Vec<_>>().join(", ") };
// Short digest for display; full value in title for copy.
let digest = &artifact.hashes.artifact.0;
let digest_short = if digest.len() > 20 {
format!("{}…", &digest[..20])
} else {
digest.clone()
};
let evidence_note = match artifact.verification.evidence.as_str() {
"sourced" => "已关联来源,内容尚未核验",
"verified" => "证据已核验",
"unverified" => "尚无来源记录",
other => other,
};
out.push_str(&format!(
r#"<article class="knowledge-card" id="knowledge-{name}"><h3>{name} <span class="ks-kind">{kind}</span></h3><dl><dt>Target</dt><dd><code>{target}</code></dd><dt>Signature</dt><dd><code>{sig}</code></dd><dt>Effects</dt><dd>{effects}</dd><dt>Verification</dt><dd>parse: {parse}; resolve: {resolve}; contract: {contract}; tests: {tests}; evidence: {evidence}({evidence_note})</dd><dt>制品摘要</dt><dd><code title="{digest}">{digest_short}</code> <span class="knowledge-hint">(未检查锁定状态)</span></dd><dt>Depends on</dt><dd><code>{deps}</code></dd><dt>Execution</dt><dd>尚无该知识的运行记录(知识预览不执行)。</dd></dl></article>"#,
name = escape(&artifact.display_name),
kind = escape(&artifact.kind),
target = escape(target),
sig = escape(&signature),
effects = escape(&effects),
parse = escape(&artifact.verification.parse),
resolve = escape(&artifact.verification.resolve),
contract = escape(&artifact.verification.contract),
tests = escape(&artifact.verification.tests),
evidence = escape(&artifact.verification.evidence),
evidence_note = escape(evidence_note),
digest = escape(digest),
digest_short = escape(&digest_short),
deps = escape(&deps),
));
}
out.push_str("</div>");
out
}
/// Collect prompt strings from every `input` / `输入` call in the module (pre-order).
pub fn collect_input_prompts(module: &Module) -> Vec<String> {
let mut out = Vec::new();
for fun in &module.functions {
collect_input_prompts_fun(fun, &mut out);
}
out
}
/// Stream panel is for LLM/agent token streaming — only when those ext packages are imported.
pub fn uses_stream_panel(module: &Module) -> bool {
module.imports.iter().any(|imp| import_enables_stream(&imp.path))
}
fn import_enables_stream(path: &str) -> bool {
let norm = path.replace('\\', "/");
let lower = norm.to_ascii_lowercase();
lower.contains("ext/ai/llm")
|| lower.contains("/llm.mq.md")
|| lower.ends_with("llm.mq.md")
|| lower.contains("ext/llm")
|| norm.contains("ext/ai/大模型")
|| norm.contains("大模型.mq.md")
|| lower.contains("ext/ai/agent")
|| lower.contains("/agent.mq.md")
|| lower.ends_with("agent.mq.md")
|| lower.contains("ext/agent")
|| norm.contains("ext/ai/智能体")
|| norm.contains("智能体.mq.md")
}
fn collect_input_prompts_fun(fun: &Function, out: &mut Vec<String>) {
for stmt in &fun.body {
collect_input_prompts_stmt(stmt, out);
}
for child in &fun.children {
collect_input_prompts_fun(child, out);
}
}
fn collect_input_prompts_stmt(stmt: &Stmt, out: &mut Vec<String>) {
match stmt {
Stmt::Assign { value, .. } | Stmt::Return { value, .. } | Stmt::Expr { value, .. } => {
collect_input_prompts_expr(value, out);
}
Stmt::Call { call, .. } => {
push_input_prompt(call, out);
for a in &call.args {
match a {
Arg::Positional(e) | Arg::Named { value: e, .. } => {
collect_input_prompts_expr(e, out);
}
}
}
}
Stmt::Branch { arms, .. } => {
for arm in arms {
if let Some(c) = &arm.condition {
collect_input_prompts_expr(c, out);
}
for s in &arm.body {
collect_input_prompts_stmt(s, out);
}
}
}
Stmt::While {
condition, body, ..
} => {
collect_input_prompts_expr(condition, out);
for s in body {
collect_input_prompts_stmt(s, out);
}
}
Stmt::ForEach { body, .. } => {
for s in body {
collect_input_prompts_stmt(s, out);
}
}
}
}
fn collect_input_prompts_expr(expr: &Expr, out: &mut Vec<String>) {
match expr {
Expr::Occluded { payload, .. } => {
if let Some(inner) = payload {
collect_input_prompts_expr(inner, out);
}
}
Expr::Call(call) => {
push_input_prompt(call, out);
for a in &call.args {
match a {
Arg::Positional(e) | Arg::Named { value: e, .. } => {
collect_input_prompts_expr(e, out);
}
}
}
}
Expr::Unary { expr, .. } => collect_input_prompts_expr(expr, out),
Expr::Binary { left, right, .. } => {
collect_input_prompts_expr(left, out);
collect_input_prompts_expr(right, out);
}
Expr::List(items) => {
for e in items {
collect_input_prompts_expr(e, out);
}
}
Expr::Map(pairs) => {
for (_, e) in pairs {
collect_input_prompts_expr(e, out);
}
}
Expr::Index { base, .. } => collect_input_prompts_expr(base, out),
Expr::Literal(_) | Expr::Var(_) | Expr::Interp(_) | Expr::Formula(_) | Expr::Code(_) => {}
}
}
fn push_input_prompt(call: &CallExpr, out: &mut Vec<String>) {
if crate::aliases::canonical_builtin(&call.callee) != Some("input") {
return;
}
for a in &call.args {
if let Arg::Named { name, value } = a {
if crate::aliases::canonical_param("input", name) == "prompt" {
out.push(prompt_expr_text(value));
return;
}
}
}
if let Some(Arg::Positional(value)) = call.args.first() {
out.push(prompt_expr_text(value));
return;
}
out.push(String::new());
}
fn prompt_expr_text(expr: &Expr) -> String {
match expr {
Expr::Literal(Literal::Text(t)) => t.clone(),
Expr::Literal(lit) => lit_display(lit),
other => expr_display(other),
}
}
/// Browse Structure without run annotations (empty callouts).
pub fn render_module_structure(module: &Module, source: &str) -> String {
render_module_structure_mode(module, source, StructureMode::Browse)
}
/// Browse Structure: document surface with optional result annotations.
pub fn render_module_structure_with_annots(
module: &Module,
source: &str,
annots: &[crate::view::annot::ViewAnnot],
) -> String {
crate::view::document::render_module_document(module, source, annots)
}
pub fn render_module_structure_mode(
module: &Module,
source: &str,
mode: StructureMode,
) -> String {
match mode {
StructureMode::Browse => render_module_structure_with_annots(module, source, &[]),
StructureMode::Debug => render_module_structure_cards(module, source, mode),
}
}
/// Legacy AST-card Structure (debug + tests that need card markup).
pub fn render_module_structure_cards(
module: &Module,
source: &str,
mode: StructureMode,
) -> String {
let lines = classify_source(source);
let writebacks = writeback::writeback_map(source);
let mut out = String::new();
if !module.imports.is_empty() || !module.uses.is_empty() {
out.push_str("<div class=\"card\"><span class=\"badge\">import</span>");
for imp in &module.imports {
let label = format!("{}:{}", imp.bind, imp.path);
out.push_str(&format!("<span class=\"chip\">{}</span>", escape(&label)));
}
for u in &module.uses {
let label = format!("{}:{}", u.bind, u.path.join("."));
out.push_str(&format!("<span class=\"chip\">{}</span>", escape(&label)));
}
out.push_str("</div>");
}
let body_start = skip_frontmatter_end(&lines).unwrap_or(1);
let mut cursor = body_start;
if module.functions.is_empty() {
out.push_str(&emit_comments(&lines, cursor, u32::MAX));
if out.is_empty() {
out.push_str("<p class=\"meta\">(empty module)</p>");
}
return out;
}
// Leading comments before first function
let first = module.functions[0].span.line;
out.push_str(&emit_comments(&lines, cursor, first));
cursor = first;
for (i, fun) in module.functions.iter().enumerate() {
if i > 0 {
out.push_str(&emit_comments(&lines, cursor, fun.span.line));
}
let (html, next) = render_fun(fun, &lines, 0, "", mode, &writebacks);
out.push_str(&html);
cursor = next;
}
// Trailing comments after last function tree
out.push_str(&emit_comments(&lines, cursor, u32::MAX));
out
}
pub fn render_function_outline(module: &Module) -> String {
if module.functions.is_empty() {
return String::new();
}
let mut out = String::from(
r#"<div class="outline-panel" id="fn-outline">
<input type="search" id="fn-search" class="fn-search" placeholder="Search functions…" autocomplete="off" spellcheck="false"/>
<ul class="outline-tree">"#,
);
for fun in &module.functions {
out.push_str(&outline_fun(fun, ""));
}
out.push_str("</ul></div>");
out
}
/// Right rail: collapsible Functions + Variables (+ optional writeback HTML appended by caller).
pub fn render_right_rail(module: &Module, bindings_html: &str, writeback_html: &str) -> String {
let fn_inner = if module.functions.is_empty() {
r#"<p class="vars-empty">No functions</p>"#.to_string()
} else {
let mut tree = String::from(
r#"<input type="search" id="fn-search" class="fn-search" placeholder="Search functions…" autocomplete="off" spellcheck="false"/>
<ul class="outline-tree">"#,
);
for fun in &module.functions {
tree.push_str(&outline_fun(fun, ""));
}
tree.push_str("</ul>");
tree
};
let vars = if bindings_html.is_empty() {
r#"<p class="vars-empty">No bindings</p>"#
} else {
bindings_html
};
format!(
r#"<div class="outline-rail" id="outline-rail">
<details class="outline-section" open>
<summary class="outline-summary">Functions</summary>
<div class="outline-panel" id="fn-outline">{fn_inner}</div>
</details>
<details class="outline-section" open>
<summary class="outline-summary">Variables</summary>
<div class="vars-panel" id="vars-panel">{vars}</div>
</details>
{wb}
</div>"#,
fn_inner = fn_inner,
vars = vars,
wb = writeback_html,
)
}
/// Render entry bindings: visible preview in the rail; click card → inspect dialog.
pub fn render_bindings_html(bindings: &HashMap<String, crate::value::Value>) -> String {
if bindings.is_empty() {
return String::new();
}
let mut names: Vec<&String> = bindings.keys().collect();
names.sort();
let mut out = String::from(r#"<ul class="vars-list">"#);
for (i, name) in names.into_iter().enumerate() {
let Some(val) = bindings.get(name) else {
continue;
};
let kind = value_kind_label(val);
let preview = render_value_preview_html(val);
let full = render_value_rich(val, 0);
out.push_str(&format!(
r#"<li class="vars-item vars-card" data-var-id="{id}" role="button" tabindex="0" title="Click to inspect">
<div class="vars-head">
<span class="vars-name">{name}</span>
<span class="vars-kind">{kind}</span>
</div>
<div class="vars-preview">{preview}</div>
<div class="vars-full" id="var-full-{id}" data-var-name="{name}" hidden>{full}</div>
</li>"#,
name = escape(name),
kind = escape(&kind),
preview = preview,
id = i,
full = full,
));
}
out.push_str("</ul>");
out
}
/// Compact inline preview (may truncate visually via CSS).
fn render_value_preview_html(v: &crate::value::Value) -> String {
use crate::value::Value;
match v {
Value::Formula(e) => {
let tex = match e {
crate::formula::Expr::Matrix { source, .. } => escape(source),
_ => escape(&formula_ascii_to_tex(&e.as_display())),
};
format!(r#"<div class="math-block math-sm">$${}$$</div>"#, tex)
}
Value::List(xs) => {
if let Some((_, _, complex)) = detect_matrix(xs) {
return render_matrix_grid(xs, complex);
}
render_value_html(v, 0)
}
Value::Map(pairs) => {
if let Some(Value::List(rows)) = pairs
.iter()
.find(|(k, _)| k == "matrix" || k == "矩阵")
.map(|(_, v)| v)
{
if let Some((_, _, complex)) = detect_matrix(rows) {
return render_matrix_grid(rows, complex);
}
}
// Prefer a short key/value peek for objects.
let mut s = String::from(r#"<table class="vars-table vars-peek"><tbody>"#);
for (k, val) in pairs.iter().take(6) {
if k == "matrix" || k == "矩阵" || k == "ops" {
s.push_str(&format!(
"<tr><td class=\"vars-key\">{}</td><td class=\"vars-muted\">…</td></tr>",
escape(k)
));
continue;
}
s.push_str(&format!(
"<tr><td class=\"vars-key\">{}</td><td>{}</td></tr>",
escape(k),
escape(&brief_preview_cell(val))
));
}
if pairs.len() > 6 {
s.push_str(
r#"<tr><td colspan="2" class="vars-muted">…</td></tr>"#,
);
}
s.push_str("</tbody></table>");
s
}
other => format!(
r#"<span class="vars-scalar">{}</span>"#,
escape(&other.as_display())
),
}
}
fn brief_preview_cell(v: &crate::value::Value) -> String {
use crate::value::Value;
match v {
Value::List(xs) => format!("List({})", xs.len()),
Value::Map(xs) => format!("Map({})", xs.len()),
Value::Formula(_) => "formula".into(),
other => {
let s = other.as_display();
if s.chars().count() > 36 {
format!("{}…", s.chars().take(36).collect::<String>())
} else {
s
}
}
}
}
fn value_kind_label(v: &crate::value::Value) -> String {
use crate::value::Value;
match v {
Value::None => "none".into(),
Value::Bool(_) => "bool".into(),
Value::Int(_) => "int".into(),
Value::Num(_) => "num".into(),
Value::Text(_) => "text".into(),
Value::Secret(_) => "secret".into(),
Value::Formula(crate::formula::Expr::Matrix { rows, .. }) => {
format!("formula · {}×{}", rows.len(), rows.first().map(|r| r.len()).unwrap_or(0))
}
Value::Formula(_) => "formula".into(),
Value::Code(c) => format!("code · {}", c.lang),
Value::List(xs) => {
if let Some((r, c, _)) = detect_matrix(xs) {
format!("matrix · {r}×{c}")
} else {
format!("list · {}", xs.len())
}
}
Value::Map(pairs) => {
if let Some(t) = pairs.iter().find(|(k, _)| k == "_type").and_then(|(_, v)| match v {
Value::Text(s) => Some(s.as_str()),
_ => None,
}) {
if let Some(Value::List(rows)) = pairs
.iter()
.find(|(k, _)| k == "matrix" || k == "矩阵")
.map(|(_, v)| v)
{
if let Some((r, c, _)) = detect_matrix(rows) {
return format!("{t} · {r}×{c}");
}
}
t.to_string()
} else {
format!("map · {}", pairs.len())
}
}
}
}
/// Complex or real matrix: rows × cols, and whether cells are complex maps.
fn detect_matrix(xs: &[crate::value::Value]) -> Option<(usize, usize, bool)> {
use crate::value::Value;
if xs.is_empty() {
return None;
}
let mut cols = None;
let mut complex = false;
for row in xs {
let Value::List(cells) = row else {
return None;
};
if cells.is_empty() {
return None;
}
match cols {
None => cols = Some(cells.len()),
Some(c) if c != cells.len() => return None,
_ => {}
}
for c in cells {
match c {
Value::Num(_) | Value::Int(_) => {}
Value::Map(m)
if m.iter().any(|(k, _)| k == "re")
&& m.iter().any(|(k, _)| k == "im") =>
{
complex = true;
}
_ => return None,
}
}
}
Some((xs.len(), cols.unwrap_or(0), complex))
}
fn format_complex_cell(v: &crate::value::Value) -> String {
use crate::value::Value;
match v {
Value::Num(n) => format_matrix_num(*n),
Value::Int(i) => i.to_string(),
Value::Map(m) => {
let re = m
.iter()
.find(|(k, _)| k == "re")
.and_then(|(_, v)| match v {
Value::Num(n) => Some(*n),
Value::Int(i) => Some(*i as f64),
_ => None,
})
.unwrap_or(0.0);
let im = m
.iter()
.find(|(k, _)| k == "im")
.and_then(|(_, v)| match v {
Value::Num(n) => Some(*n),
Value::Int(i) => Some(*i as f64),
_ => None,
})
.unwrap_or(0.0);
if im.abs() < 1e-12 {
format_matrix_num(re)
} else if re.abs() < 1e-12 {
format!("{}i", format_matrix_num(im))
} else {
format!("{}{:+}i", format_matrix_num(re), im)
}
}
other => other.as_display(),
}
}
fn format_matrix_num(n: f64) -> String {
if n.fract().abs() < 1e-12 && n.abs() < 1e15 {
format!("{}", n as i64)
} else {
let s = format!("{n:.6}");
s.trim_end_matches('0').trim_end_matches('.').to_string()
}
}
fn render_matrix_grid(xs: &[crate::value::Value], complex: bool) -> String {
let mut s = String::from(r#"<div class="matrix-wrap"><table class="matrix-grid">"#);
if complex {
s.push_str(r#"<caption class="matrix-cap">complex amplitudes</caption>"#);
}
s.push_str("<tbody>");
for row in xs {
let crate::value::Value::List(cells) = row else {
continue;
};
s.push_str("<tr>");
for c in cells {
let label = escape(&format_complex_cell(c));
let mag = match c {
crate::value::Value::Num(n) => n.abs(),
crate::value::Value::Int(i) => (*i as f64).abs(),
crate::value::Value::Map(m) => {
let re = m
.iter()
.find(|(k, _)| k == "re")
.and_then(|(_, v)| match v {
crate::value::Value::Num(n) => Some(*n),
_ => None,
})
.unwrap_or(0.0);
let im = m
.iter()
.find(|(k, _)| k == "im")
.and_then(|(_, v)| match v {
crate::value::Value::Num(n) => Some(*n),
_ => None,
})
.unwrap_or(0.0);
(re * re + im * im).sqrt()
}
_ => 0.0,
};
let heat = mag.clamp(0.0, 1.0);
let bg = format!(
"rgba(74, 111, 165, {:.3})",
0.06 + heat * 0.42
);
s.push_str(&format!(
r#"<td class="matrix-cell" style="background:{bg}"><span>{label}</span></td>"#
));
}
s.push_str("</tr>");
}
s.push_str("</tbody></table></div>");
s
}
const BIND_MAX_DEPTH: usize = 3;
/// Full rich HTML for the inspect dialog (matrices get a dedicated grid).
fn render_value_rich(v: &crate::value::Value, depth: usize) -> String {
use crate::value::Value;
match v {
Value::List(xs) => {
if let Some((_, _, complex)) = detect_matrix(xs) {
return render_matrix_grid(xs, complex);
}
if let Some(keys) = record_keys(xs) {
return render_records_table(xs, &keys, depth);
}
render_value_html(v, depth)
}
Value::Map(pairs) => {
// Prefer pretty matrix when object carries `matrix` / `矩阵`.
if let Some(Value::List(rows)) = pairs
.iter()
.find(|(k, _)| k == "matrix" || k == "矩阵")
.map(|(_, v)| v)
{
if let Some((_, _, complex)) = detect_matrix(rows) {
let mut s = String::from(r#"<div class="var-rich">"#);
if let Some(Value::Text(t)) =
pairs.iter().find(|(k, _)| k == "_type").map(|(_, v)| v)
{
s.push_str(&format!(
r#"<p class="var-rich-meta"><span class="var-chip">{}</span>"#,
escape(t)
));
if let Some(Value::Text(n)) =
pairs.iter().find(|(k, _)| k == "name" || k == "名").map(|(_, v)| v)
{
s.push_str(&format!(
r#" <span class="var-chip muted">{}</span>"#,
escape(n)
));
}
s.push_str("</p>");
}
s.push_str(&render_matrix_grid(rows, complex));
// Other keys (skip matrix / _type / name noise)
let rest: Vec<_> = pairs
.iter()
.filter(|(k, _)| {
k != "matrix"
&& k != "矩阵"
&& k != "_type"
&& k != "name"
&& k != "名"
&& k != "custom"
})
.collect();
if !rest.is_empty() {
s.push_str(r#"<details class="var-rich-more"><summary>Other fields</summary>"#);
s.push_str(r#"<table class="vars-table"><tbody>"#);
for (k, val) in rest {
s.push_str(&format!(
"<tr><td class=\"vars-key\">{}</td><td>{}</td></tr>",
escape(k),
cell_html(val, depth)
));
}
s.push_str("</tbody></table></details>");
}
s.push_str("</div>");
return s;
}
}
render_value_html(v, depth)
}
Value::Formula(e) => {
let tex = match e {
crate::formula::Expr::Matrix { source, .. } => escape(source),
_ => escape(&formula_ascii_to_tex(&e.as_display())),
};
format!(
r#"<div class="var-rich"><div class="math-block math-lg">$${}$$</div></div>"#,
tex
)
}
other => render_value_html(other, depth),
}
}
fn render_value_html(v: &crate::value::Value, depth: usize) -> String {
use crate::value::Value;
match v {
Value::List(xs) => {
if let Some((_, _, complex)) = detect_matrix(xs) {
return render_matrix_grid(xs, complex);
}
if let Some(keys) = record_keys(xs) {
return render_records_table(xs, &keys, depth);
}
let mut s = String::from(r#"<table class="vars-table"><thead><tr><th>#</th><th>value</th></tr></thead><tbody>"#);
for (i, item) in xs.iter().enumerate() {
s.push_str(&format!(
"<tr><td class=\"vars-idx\">{}</td><td>{}</td></tr>",
i + 1,
cell_html(item, depth)
));
}
if xs.is_empty() {
s.push_str(r#"<tr><td colspan="2" class="vars-empty">∅</td></tr>"#);
}
s.push_str("</tbody></table>");
s
}
Value::Map(pairs) => {
let mut s = String::from(
r#"<table class="vars-table"><thead><tr><th>key</th><th>value</th></tr></thead><tbody>"#,
);
for (k, val) in pairs {
s.push_str(&format!(
"<tr><td class=\"vars-key\">{}</td><td>{}</td></tr>",
escape(k),
cell_html(val, depth)
));
}
if pairs.is_empty() {
s.push_str(r#"<tr><td colspan="2" class="vars-empty">∅</td></tr>"#);
}
s.push_str("</tbody></table>");
s
}
Value::Formula(e) => {
let tex = match e {
crate::formula::Expr::Matrix { source, .. } => escape(source),
_ => escape(&formula_ascii_to_tex(&e.as_display())),
};
format!(r#"<div class="math-block">$${}$$</div>"#, tex)
}
other => format!(r#"<span class="vars-scalar">{}</span>"#, escape(&other.as_display())),
}
}
fn cell_html(v: &crate::value::Value, depth: usize) -> String {
use crate::value::Value;
match v {
Value::List(_) | Value::Map(_) if depth >= BIND_MAX_DEPTH => {
format!(
r#"<details class="vars-nested"><summary>{}</summary><span class="vars-scalar">{}</span></details>"#,
escape(&brief_type(v)),
escape(&v.as_display())
)
}
Value::List(_) | Value::Map(_) => render_value_html(v, depth + 1),
Value::Formula(e) => {
let tex = match e {
crate::formula::Expr::Matrix { source, .. } => escape(source),
_ => escape(&formula_ascii_to_tex(&e.as_display())),
};
format!(r#"<div class="math-block">$${}$$</div>"#, tex)
}
other => escape(&other.as_display()),
}
}
fn brief_type(v: &crate::value::Value) -> String {
use crate::value::Value;
match v {
Value::List(xs) => format!("List({})", xs.len()),
Value::Map(xs) => format!("Map({})", xs.len()),
_ => "…".into(),
}
}
fn record_keys(xs: &[crate::value::Value]) -> Option<Vec<String>> {
use crate::value::Value;
if xs.is_empty() {
return None;
}
let mut keys: Vec<String> = Vec::new();
for (i, item) in xs.iter().enumerate() {
let Value::Map(pairs) = item else {
return None;
};
if i == 0 {
keys = pairs.iter().map(|(k, _)| k.clone()).collect();
if keys.is_empty() {
return None;
}
}
}
Some(keys)
}
fn render_records_table(
xs: &[crate::value::Value],
keys: &[String],
depth: usize,
) -> String {
use crate::value::Value;
let mut s = String::from(r#"<table class="vars-table"><thead><tr><th>#</th>"#);
for k in keys {
s.push_str(&format!("<th>{}</th>", escape(k)));
}
s.push_str("</tr></thead><tbody>");
for (i, item) in xs.iter().enumerate() {
let Value::Map(pairs) = item else {
continue;
};
s.push_str(&format!(r#"<tr><td class="vars-idx">{}</td>"#, i + 1));
for k in keys {
let cell = pairs
.iter()
.find(|(kk, _)| kk == k)
.map(|(_, v)| cell_html(v, depth))
.unwrap_or_else(|| String::from(""));
s.push_str(&format!("<td>{cell}</td>"));
}
s.push_str("</tr>");
}
s.push_str("</tbody></table>");
s
}
fn outline_fun(fun: &Function, parent_path: &str) -> String {
let fn_path = fn_path(parent_path, &fun.name);
let mut s = format!(
"<li class=\"outline-item\" data-fn=\"{}\" data-fn-path=\"{}\">\
<a href=\"#fn-{}\">{}</a> <span class=\"ol-meta\">h{}</span>",
escape(&fun.name),
escape(&fn_path),
fun.span.line,
escape(&fun.name),
fun.level,
);
if !fun.params.is_empty() {
s.push_str(" <span class=\"ol-params\">");
for (i, p) in fun.params.iter().enumerate() {
if i > 0 {
s.push(' ');
}
if p.inferred {
s.push_str(&format!(
"<span class=\"ol-param inferred\" title=\"inferred\">{}</span>",
escape(&p.name)
));
} else {
s.push_str(&format!(
"<span class=\"ol-param\" title=\"explicit\">{}</span>",
escape(&p.name)
));
}
}
s.push_str("</span>");
}
if !fun.children.is_empty() {
s.push_str("<ul>");
for child in &fun.children {
s.push_str(&outline_fun(child, &fn_path));
}
s.push_str("</ul>");
}
s.push_str("</li>");
s
}
fn fn_path(parent_path: &str, name: &str) -> String {
if parent_path.is_empty() {
name.to_string()
} else {
format!("{parent_path}/{name}")
}
}
/// Line after closing frontmatter `---`, or 1 if none.
fn skip_frontmatter_end(lines: &[ClassifiedLine]) -> Option<u32> {
let first_code = lines.iter().find(|l| l.kind == LineKind::Code)?;
if first_code.text.trim() != "---" {
return Some(1);
}
for l in lines.iter().skip_while(|l| l.line_no <= first_code.line_no) {
if l.kind == LineKind::Code && l.text.trim() == "---" {
return Some(l.line_no + 1);
}
}
Some(1)
}
fn emit_comments(lines: &[ClassifiedLine], from_line: u32, before_line: u32) -> String {
let mut s = String::new();
let mut paragraph: Vec<String> = Vec::new();
let flush = |paragraph: &mut Vec<String>, s: &mut String| {
if paragraph.is_empty() {
return;
}
// Soft-wrapped source lines → one Markdown paragraph (spaces between).
let text = paragraph.join(" ");
paragraph.clear();
s.push_str(&format!(
"<div class=\"card comment-card\"><span class=\"badge\">comment</span><div class=\"comment-text\">{}</div></div>",
comment_markdown_to_html(&text)
));
};
for l in lines {
if l.line_no < from_line {
continue;
}
if l.line_no >= before_line {
break;
}
match l.kind {
LineKind::Comment => {
let text = l.text.trim();
if !text.is_empty() {
paragraph.push(text.to_string());
}
}
LineKind::Blank | LineKind::Writeback | LineKind::Code => flush(&mut paragraph, &mut s),
}
}
flush(&mut paragraph, &mut s);
s
}
/// Render narrative comments as Markdown (links, emphasis, code, lists, …).
pub(crate) fn comment_markdown_to_html(md: &str) -> String {
let mut opts = Options::empty();
opts.insert(Options::ENABLE_STRIKETHROUGH);
opts.insert(Options::ENABLE_TABLES);
opts.insert(Options::ENABLE_TASKLISTS);
let parser = Parser::new_ext(md, opts);
let mut out = String::new();
html::push_html(&mut out, parser);
out
}
fn render_fun(
fun: &Function,
lines: &[ClassifiedLine],
depth: usize,
parent_path: &str,
mode: StructureMode,
writebacks: &HashMap<u32, String>,
) -> (String, u32) {
let fn_path = fn_path(parent_path, &fun.name);
let mut s = String::new();
let nest = if depth > 0 { " nested" } else { "" };
s.push_str(&format!(
"<div class=\"card fun-card{nest}\" id=\"fn-{}\" data-fn=\"{}\" data-fn-path=\"{}\">",
fun.span.line,
escape(&fun.name),
escape(&fn_path),
));
s.push_str(&format!(
"<div><span class=\"badge\">fn · h{}</span><strong>{}</strong></div>",
fun.level,
escape(&fun.name)
));
if !fun.params.is_empty() {
s.push_str("<div class=\"params\">");
for p in &fun.params {
let (cls, title) = if p.inferred {
("chip inferred", "inferred from prose / body")
} else {
("chip", "explicit + param")
};
s.push_str(&format!(
"<span class=\"{cls}\" data-param-name=\"{name}\" data-fn=\"{fn}\" title=\"{title}\">{name}<span class=\"chip-val\"></span></span>",
cls = cls,
title = title,
name = escape(&p.name),
fn = escape(&fun.name),
));
}
s.push_str("</div>");
}
let mut cursor = fun.span.line + 1;
// Comments / gap before first body stmt or child
let first_body = fun.body.first().map(stmt_start);
let first_child = fun.children.first().map(|c| c.span.line);
let first_content = match (first_body, first_child) {
(Some(a), Some(b)) => Some(a.min(b)),
(Some(a), None) => Some(a),
(None, Some(b)) => Some(b),
(None, None) => None,
};
if let Some(fc) = first_content {
s.push_str(&emit_comments(lines, cursor, fc));
cursor = fc;
}
// Interleave body stmts and nested functions by source line
let mut bi = 0usize;
let mut ci = 0usize;
while bi < fun.body.len() || ci < fun.children.len() {
let stmt_line = fun.body.get(bi).map(stmt_start);
let child_line = fun.children.get(ci).map(|c| c.span.line);
let take_stmt = match (stmt_line, child_line) {
(Some(sl), Some(cl)) => sl <= cl,
(Some(_), None) => true,
(None, Some(_)) => false,
(None, None) => break,
};
if take_stmt {
let stmt = &fun.body[bi];
let start = stmt_start(stmt);
s.push_str(&emit_comments(lines, cursor, start));
let (html, end) = render_stmt(stmt, lines, mode, writebacks);
s.push_str(&html);
cursor = end;
bi += 1;
} else {
let child = &fun.children[ci];
s.push_str(&emit_comments(lines, cursor, child.span.line));
let (html, end) = render_fun(child, lines, depth + 1, &fn_path, mode, writebacks);
s.push_str(&format!("<div class=\"nested\">{html}</div>"));
cursor = end;
ci += 1;
}
}
s.push_str("</div>");
(s, cursor)
}
fn stmt_start(stmt: &Stmt) -> u32 {
match stmt {
Stmt::Assign { span, .. }
| Stmt::Return { span, .. }
| Stmt::Call { span, .. }
| Stmt::Expr { span, .. }
| Stmt::Branch { span, .. }
| Stmt::While { span, .. }
| Stmt::ForEach { span, .. } => span.line,
}
}
fn stmt_end_line(stmt: &Stmt) -> u32 {
match stmt {
Stmt::Assign { end_line, .. } => end_line + 1,
Stmt::Return { span, .. } | Stmt::Call { span, .. } | Stmt::Expr { span, .. } => {
span.line + 1
}
Stmt::Branch { arms, span, .. } => {
let mut end = span.line + 1;
for arm in arms {
for st in &arm.body {
end = end.max(stmt_end_line(st));
}
}
end
}
Stmt::While { body, span, .. } | Stmt::ForEach { body, span, .. } => {
let mut end = span.line + 1;
for st in body {
end = end.max(stmt_end_line(st));
}
end
}
}
}
fn output_card(line: u32, writebacks: &HashMap<u32, String>) -> String {
match writebacks.get(&line) {
Some(body) => render_output_card(line, body),
None => String::new(),
}
}
/// Live view + static site: text `<pre>` and/or `<img>` for image writebacks.
pub fn render_output_card(line: u32, combined: &str) -> String {
if combined.trim().is_empty() {
return String::new();
}
let badges = writeback_badges(combined);
let mut body_html = String::new();
let mut buf_text = String::new();
let flush_text = |buf: &mut String, out: &mut String| {
if buf.is_empty() {
return;
}
out.push_str(&format!(
r#"<pre class="output-body">{}</pre>"#,
escape(buf.trim_end())
));
buf.clear();
};
for line_s in combined.lines() {
let t = line_s.trim();
if let Some(url) = extract_md_image_url(t) {
flush_text(&mut buf_text, &mut body_html);
body_html.push_str(&format!(
r#"<figure class="wb-figure"><img class="wb-image" src="{src}" alt="writeback"/><figcaption class="wb-image-url">{cap}</figcaption></figure>"#,
src = escape(&url),
cap = escape(&url),
));
} else {
if !buf_text.is_empty() {
buf_text.push('\n');
}
buf_text.push_str(line_s);
}
}
flush_text(&mut buf_text, &mut body_html);
let has_img = body_html.contains("wb-image");
format!(
r#"<div class="card output-card{img_cls}" id="wb-{line}" data-wb="1"><div class="wb-badges">{badges}</div>{body}</div>"#,
line = line,
img_cls = if has_img { " output-card-image" } else { "" },
badges = badges,
body = body_html,
)
}
fn extract_md_image_url(line: &str) -> Option<String> {
let t = line.trim();
let rest = t.strip_prefix("![")?;
let alt_end = rest.find("](")?;
let after = &rest[alt_end + 2..];
let url_end = after.rfind(')')?;
let url = after[..url_end].trim();
if url.is_empty() {
None
} else {
Some(url.to_string())
}
}
/// Document-surface marker for a writeback source line (comment or image).
pub fn render_writeback_source_line(line_no: u32, text: &str) -> String {
let trimmed = text.trim();
let is_image = trimmed.starts_with("![") && trimmed.contains("marqdo-out");
let kind = if is_image { "image" } else { "comment" };
let label = if is_image {
"writeback · image"
} else {
"writeback"
};
format!(
r#"<div class="doc-block doc-writeback" data-line="{line}" data-wb-kind="{kind}"><span class="wb-source-badge">{label}</span><code class="wb-source-text">{text}</code></div>"#,
line = line_no,
kind = kind,
label = label,
text = escape(trimmed),
)
}
fn writeback_badges(body: &str) -> String {
let mut keys = Vec::new();
for line in body.lines() {
if let Some(rest) = line.strip_prefix('[') {
if let Some(end) = rest.find(']') {
let k = &rest[..end];
if !k.is_empty() && !keys.iter().any(|x| x == k) {
keys.push(k.to_string());
}
}
}
}
if keys.is_empty() {
return r#"<span class="badge wb-badge">output</span>"#.into();
}
keys.into_iter()
.map(|k| {
let cls = match k.as_str() {
"ok" => "wb-ok",
"error" => "wb-error",
"trace" => "wb-trace",
_ => "wb-other",
};
format!(r#"<span class="badge wb-badge {cls}">{k}</span>"#, k = escape(&k))
})
.collect::<Vec<_>>()
.join(" ")
}
/// Outline links to writeback cards (`#wb-{line}`).
pub fn render_writeback_outline(source: &str) -> String {
let map = writeback::writeback_map(source);
if map.is_empty() {
return String::new();
}
let mut lines: Vec<u32> = map.keys().copied().filter(|l| *l > 0).collect();
lines.sort_unstable();
if lines.is_empty() {
return String::new();
}
let mut out = String::from(
r#"<div class="wb-outline" id="wb-outline"><div class="wb-outline-title">Writebacks</div><ul class="outline-tree">"#,
);
for line in lines {
let body = map.get(&line).map(|s| s.as_str()).unwrap_or("");
let label = if body.contains("[error]") {
"error"
} else if body.contains("[ok]") {
"ok"
} else if body.contains("[trace]") {
"trace"
} else {
"output"
};
out.push_str(&format!(
r##"<li class="outline-item"><a href="#wb-{line}">L{line} · {label}</a></li>"##,
line = line,
label = label,
));
}
out.push_str("</ul></div>");
out
}
/// `<TAB>` M8: occlusion card — the description reads as prose, the payload as a
/// code chip, stubs get a badge. Shared by bind / expr / return statements.
fn occl_card(name: Option<&str>, label: &str, payload: Option<&Expr>) -> String {
let pre = match name {
Some(n) => format!(
"<code class=\"expr occl-name\">`{}` =</code>",
escape(n)
),
None => String::new(),
};
let val = match payload {
Some(e) => format!(
"<code class=\"occl-code\">{}</code>",
escape(&expr_display(e))
),
None => String::from(
"<span class=\"occl-stub\" title=\"空载荷:未接通或待补返回值\">桩</span>",
),
};
format!(
"<div class=\"card occl-card\"><span class=\"badge\">遮蔽</span>{pre}<span class=\"occl-label\">{}</span>{val}</div>",
escape(label)
)
}
fn render_stmt(
stmt: &Stmt,
lines: &[ClassifiedLine],
mode: StructureMode,
writebacks: &HashMap<u32, String>,
) -> (String, u32) {
let end = stmt_end_line(stmt);
let line = stmt_start(stmt);
let inner = match stmt {
Stmt::Assign {
name,
value: Expr::Occluded { label, payload },
..
} => occl_card(Some(name), label, payload.as_deref()),
Stmt::Expr {
value: Expr::Occluded { label, payload },
..
} => occl_card(None, label, payload.as_deref()),
Stmt::Return {
value: Expr::Occluded { label, payload },
..
} => occl_card(None, label, payload.as_deref()),
Stmt::Assign {
name,
value: Expr::Formula(e),
..
} => {
// Matrix fences keep original LaTeX/`[[…]]` source — feed KaTeX as-is.
// Scalar ASCII formulas go through formula_ascii_to_tex.
let tex = match e {
crate::formula::Expr::Matrix { source, .. } => escape(source),
_ => escape(&formula_ascii_to_tex(&e.as_display())),
};
format!(
"<div class=\"card formula-card\"><span class=\"badge\">formula</span> \
<code class=\"expr\">`{}` =</code> \
<div class=\"math-block\">$${}$$</div></div>",
escape(name),
tex
)
}
Stmt::Assign {
name,
value: Expr::Code(c),
..
} => {
let placeholder = escape(&crate::foreign::default_cmd_display(&c.lang));
let lang = escape(&c.lang);
let src = escape(&c.source);
format!(
r#"<div class="card code-card" data-lang="{lang}" data-code-name="{name}">
<div class="code-head">
<span class="badge">code</span>
<code class="expr">`{name}` =</code>
<span class="code-lang">{lang}</span>
<button type="button" class="nb-clean" title="Clear this output">Clean</button>
<button type="button" class="nb-persist" title="Persist this result with writeback">Persist</button>
</div>
<pre class="code-body"><code class="language-{lang}">{src}</code></pre>
<div class="code-foot">
<div class="code-actions">
<input type="text" class="code-cmd" placeholder="{placeholder}" spellcheck="false" autocomplete="off"/>
<button type="button" class="code-run">Run</button>
</div>
</div>
<pre class="code-out" hidden></pre>
</div>"#,
lang = lang,
name = escape(name),
placeholder = placeholder,
src = src,
)
}
Stmt::Assign { name, value, .. } => format!(
"<div class=\"card\"><span class=\"badge\">bind</span> <code class=\"expr\">`{}` = {}</code></div>",
escape(name),
escape(&expr_display(value))
),
Stmt::Return { value, .. } => format!(
"<div class=\"card ret-card\"><span class=\"badge\">return</span><code class=\"expr\">{}</code></div>",
escape(&expr_display(value))
),
Stmt::Call { call, .. } => format!(
"<div class=\"card call-card\"><span class=\"badge\">call</span><code class=\"expr\">{}</code></div>",
escape(&call_display(call))
),
Stmt::Expr { value, .. } => format!(
"<div class=\"card\"><span class=\"badge\">expr</span><code class=\"expr\">{}</code></div>",
escape(&expr_display(value))
),
Stmt::Branch { arms, .. } => {
let mut body =
String::from("<div class=\"card branch-card\"><span class=\"badge\">branch</span>");
let mut arm_cursor = stmt_start(stmt) + 1;
for arm in arms {
let label = match &arm.condition {
None => "else".to_string(),
Some(c) => expr_display(c),
};
// comments before first stmt in arm (approx: between arms hard; use body starts)
let arm_first = arm.body.first().map(stmt_start);
body.push_str(&format!(
"<div class=\"arm\"><span class=\"badge\">arm</span><code class=\"expr\">{}</code>",
escape(&label)
));
if let Some(af) = arm_first {
body.push_str(&emit_comments(lines, arm_cursor, af));
arm_cursor = af;
}
body.push_str("<div class=\"nested\">");
for st in &arm.body {
let start = stmt_start(st);
body.push_str(&emit_comments(lines, arm_cursor, start));
let (h, e) = render_stmt(st, lines, mode, writebacks);
body.push_str(&h);
arm_cursor = e;
}
body.push_str("</div></div>");
}
body.push_str("</div>");
body
}
Stmt::While {
condition, body, ..
} => {
let mut body_html = format!(
"<div class=\"card loop-card\"><span class=\"badge\">while</span><code class=\"expr\">{}</code><div class=\"nested\">",
escape(&expr_display(condition))
);
let mut cursor = stmt_start(stmt) + 1;
for st in body {
let start = stmt_start(st);
body_html.push_str(&emit_comments(lines, cursor, start));
let (h, e) = render_stmt(st, lines, mode, writebacks);
body_html.push_str(&h);
cursor = e;
}
body_html.push_str("</div></div>");
body_html
}
Stmt::ForEach {
item,
collection,
body,
..
} => {
let mut body_html = format!(
"<div class=\"card loop-card\"><span class=\"badge\">foreach</span><code class=\"expr\">[{}]({})</code><div class=\"nested\">",
escape(item),
escape(collection)
);
let mut cursor = stmt_start(stmt) + 1;
for st in body {
let start = stmt_start(st);
body_html.push_str(&emit_comments(lines, cursor, start));
let (h, e) = render_stmt(st, lines, mode, writebacks);
body_html.push_str(&h);
cursor = e;
}
body_html.push_str("</div></div>");
body_html
}
};
let inner = format!("{}{}", inner, output_card(line, writebacks));
(stmt_shell(line, &inner, mode), end)
}
fn stmt_shell(line: u32, inner: &str, mode: StructureMode) -> String {
match mode {
StructureMode::Browse => format!(
r#"<div class="stmt" data-line="{line}" id="stmt-{line}"><div class="stmt-body">{inner}</div></div>"#,
line = line,
inner = inner,
),
StructureMode::Debug => format!(
r#"<div class="stmt" data-line="{line}" id="stmt-{line}"><button type="button" class="bp-gutter" title="Toggle breakpoint" aria-label="Breakpoint line {line}"></button><div class="stmt-body">{inner}</div></div>"#,
line = line,
inner = inner,
),
}
}
fn call_display(call: &CallExpr) -> String {
let mut s = String::new();
let bracket = call.bracket_marked || !call.pre_modifiers.is_empty();
if bracket {
for m in &call.pre_modifiers {
s.push_str(m);
s.push(' ');
}
s.push('[');
if let Some(recv) = &call.receiver {
s.push('`');
s.push_str(recv);
s.push('`');
s.push('.');
s.push_str(&call.callee);
} else if let Some(path) = &call.path {
s.push_str(&path.join("."));
} else {
s.push_str(&call.callee);
}
s.push(']');
} else {
s.push_str("> ");
if let Some(recv) = &call.receiver {
s.push('`');
s.push_str(recv);
s.push('`');
s.push('.');
s.push_str(&call.callee);
} else if let Some(path) = &call.path {
s.push_str(&path.join("."));
} else {
s.push_str(&call.callee);
}
}
for a in &call.args {
match a {
Arg::Positional(e) => {
s.push(' ');
s.push_str(&expr_display(e));
}
Arg::Named { name, value } => {
s.push(' ');
s.push_str(name);
s.push('=');
s.push_str(&expr_display(value));
}
}
}
s
}
/// Surface-syntax preview for view (not Debug).
pub fn expr_display(expr: &Expr) -> String {
expr_prec(expr, 0)
}
fn expr_prec(expr: &Expr, parent_prec: u8) -> String {
match expr {
// `<TAB>` M2: show the occlusion surface (label + payload).
Expr::Occluded { label, payload } => match payload {
Some(inner) => format!("[{}]({})", label, expr_prec(inner, 0)),
None => format!("[{}]()", label),
},
Expr::Literal(lit) => lit_display(lit),
Expr::Var(name) => format!("`{name}`"),
Expr::Interp(parts) => {
let mut s = String::new();
for p in parts {
match p {
InterpPart::Lit(t) => s.push_str(t),
InterpPart::Var(n) => {
s.push('`');
s.push_str(n);
s.push('`');
}
InterpPart::Index { base, labels } => {
// Preferred surface: nested `[key](base)` (legacy footnote still parses).
let mut inner = format!("`{base}`");
for label in labels {
inner = format!("[{label}]({inner})");
}
s.push_str(&inner);
}
}
}
s
}
Expr::Unary { op, expr } => {
let prec = 5;
let inner = match op {
UnaryOp::Not => format!("not {}", expr_prec(expr, prec)),
UnaryOp::Neg => format!("-{}", expr_prec(expr, prec)),
};
wrap(inner, prec, parent_prec)
}
Expr::Binary { op, left, right } => {
let (sym, prec) = bin_sym_prec(*op);
let inner = format!(
"{} {} {}",
expr_prec(left, prec),
sym,
expr_prec(right, prec + 1) // left-assoc bias
);
wrap(inner, prec, parent_prec)
}
Expr::Call(call) => call_display(call),
Expr::List(items) => {
let parts: Vec<String> = items.iter().map(|e| expr_prec(e, 0)).collect();
format!("[{}]", parts.join(", "))
}
Expr::Map(pairs) => {
let parts: Vec<String> = pairs
.iter()
.map(|(k, e)| format!("{}: {}", k, expr_prec(e, 0)))
.collect();
format!("{{{}}}", parts.join(", "))
}
Expr::Index { base, label } => {
let key = match label {
crate::ast::IndexKey::Lit(s) => s.clone(),
crate::ast::IndexKey::Var(n) => format!("`{n}`"),
};
// Preferred surface: GFM link shape (legacy footnote still accepted by parser).
format!("[{}]({})", key, expr_prec(base, 0))
}
Expr::Formula(e) => format!("$$ {} $$", e.as_display()),
Expr::Code(c) => format!("```{} …```", c.lang),
}
}
/// Best-effort ASCII formula → TeX for KaTeX in view Structure.
pub(crate) fn formula_ascii_to_tex_pub(ascii: &str) -> String {
formula_ascii_to_tex(ascii)
}
/// Formula assign card for document surface embedding (single visual layer).
pub(crate) fn render_formula_assign_card(name: &str, tex: &str) -> String {
format!(
r#"<div class="card formula-card" data-formula-name="{name}">
<div class="formula-head"><span class="badge">formula</span> <span class="formula-name">{name}</span></div>
<div class="math-block">$${tex}$$</div>
</div>"#,
name = escape(name),
tex = escape(tex),
)
}
/// Foreign code assign card for document surface embedding (single visual layer).
/// Head → body → foot(actions) so the source is never collapsed under the Run row.
pub(crate) fn render_code_assign_card(name: &str, lang: &str, source: &str) -> String {
let placeholder = escape(&crate::foreign::default_cmd_display(lang));
format!(
r#"<div class="card code-card" data-lang="{lang}" data-code-name="{name}">
<div class="code-head">
<span class="badge">code</span>
<span class="code-name">{name}</span>
<span class="code-lang">{lang}</span>
<button type="button" class="nb-clean" title="Clear this output">Clean</button>
<button type="button" class="nb-persist" title="Persist this result with writeback">Persist</button>
</div>
<pre class="code-body"><code class="language-{lang}">{src}</code></pre>
<div class="code-foot">
<div class="code-actions">
<input type="text" class="code-cmd" placeholder="{placeholder}" spellcheck="false" autocomplete="off"/>
<button type="button" class="code-run">Run</button>
</div>
</div>
<pre class="code-out" hidden></pre>
</div>"#,
lang = escape(lang),
name = escape(name),
placeholder = placeholder,
src = escape(source),
)
}
fn formula_ascii_to_tex(ascii: &str) -> String {
let mut out = String::new();
let chars: Vec<char> = ascii.chars().collect();
let mut i = 0usize;
while i < chars.len() {
let c = chars[i];
if c == '*' {
// multiplication: a*b → a \cdot b
out.push_str(r" \cdot ");
i += 1;
continue;
}
if c == '^' {
out.push('^');
i += 1;
if i < chars.len() && chars[i] == '(' {
out.push('{');
i += 1;
let start = i;
let mut depth = 1i32;
while i < chars.len() && depth > 0 {
match chars[i] {
'(' => depth += 1,
')' => depth -= 1,
_ => {}
}
if depth > 0 {
i += 1;
}
}
out.push_str(&chars[start..i].iter().collect::<String>());
if i < chars.len() && chars[i] == ')' {
i += 1;
}
out.push('}');
} else if i < chars.len() {
out.push('{');
out.push(chars[i]);
out.push('}');
i += 1;
}
continue;
}
// TeX specials that may appear in identifiers rarely
match c {
'{' | '}' | '%' | '&' | '#' | '$' => {
out.push('\\');
out.push(c);
}
_ => out.push(c),
}
i += 1;
}
out
}
fn wrap(inner: String, prec: u8, parent_prec: u8) -> String {
if prec < parent_prec {
format!("({inner})")
} else {
inner
}
}
fn bin_sym_prec(op: BinaryOp) -> (&'static str, u8) {
match op {
BinaryOp::Or => ("or", 1),
BinaryOp::And => ("and", 2),
BinaryOp::Eq => ("==", 3),
BinaryOp::Ne => ("!=", 3),
BinaryOp::Lt => ("<", 3),
BinaryOp::Le => ("<=", 3),
BinaryOp::Gt => (">", 3),
BinaryOp::Ge => (">=", 3),
BinaryOp::Add => ("+", 4),
BinaryOp::Sub => ("-", 4),
BinaryOp::Mul => ("*", 5),
BinaryOp::Div => ("/", 5),
}
}
fn lit_display(lit: &Literal) -> String {
match lit {
Literal::None => "None".into(),
Literal::Bool(true) => "True".into(),
Literal::Bool(false) => "False".into(),
Literal::Int(n) => n.to_string(),
Literal::Num(n) => crate::formula::format_num(*n),
Literal::Text(t) => t.clone(),
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::ast::{Arg, BinaryOp, CallExpr, Expr, Literal};
#[test]
fn expr_gt_is_surface() {
let e = Expr::Binary {
op: BinaryOp::Gt,
left: Box::new(Expr::Var("x".into())),
right: Box::new(Expr::Literal(Literal::Int(0))),
};
assert_eq!(expr_display(&e), "`x` > 0");
assert!(!expr_display(&e).contains("Binary"));
}
#[test]
fn structure_keeps_comments_and_surface_expr() {
let src = include_str!("../../tests/structure/nested-call.mq.md");
let module = crate::parse::parse_source(src).unwrap();
let html = render_module_structure(&module, src);
assert!(html.contains("doc-prose") || html.contains("打印一句问候"), "{html}");
assert!(html.contains("print"));
assert!(!html.contains("Binary {"));
assert!(!html.contains("Literal(Int"));
}
#[test]
fn comments_render_as_paragraphs() {
let src = "段首说明\n续行仍属同段\n\n下一段\n\n# main\n\n> print text=x\n";
let module = crate::parse::parse_source(src).unwrap();
let html = render_module_structure(&module, src);
let blocks = html.matches("doc-prose").count();
assert!(blocks >= 2, "blank line should split comment paragraphs: {html}");
assert!(html.contains("段首说明 续行仍属同段") || html.contains("段首说明</p>") || html.contains("段首说明"));
assert!(html.contains("下一段"));
}
#[test]
fn comments_render_markdown_links() {
let src = "见[仓库](https://github.com/cflmy/marqdo)与 `code`\n\n# main\n\n> print text=x\n";
let module = crate::parse::parse_source(src).unwrap();
let html = render_module_structure(&module, src);
assert!(
html.contains("<a href=\"https://github.com/cflmy/marqdo\">仓库</a>"),
"{html}"
);
assert!(html.contains("<code>code</code>"), "{html}");
assert!(!html.contains("[仓库](https://github.com/cflmy/marqdo)"));
}
#[test]
fn collect_input_prompts_from_fixture() {
let src = include_str!("../../tests/keywords/input.mq.md");
let module = crate::parse::parse_source(src).unwrap();
let prompts = collect_input_prompts(&module);
assert_eq!(prompts, vec!["Name:".to_string()]);
}
#[test]
fn collect_input_prompts_absent_without_input() {
let src = include_str!("../../tests/structure/hello.mq.md");
let module = crate::parse::parse_source(src).unwrap();
assert!(collect_input_prompts(&module).is_empty());
}
#[test]
fn structure_omits_imported_lib_bodies() {
let src = "---\ntitle: t\nimport:\n text: lib/text.mq.md\n---\n\n# main\n\n> print text=hi\n";
let local = crate::parse::parse_source(src).unwrap();
let html = render_module_structure(&local, src);
assert!(html.contains("doc-imports") || html.contains("lib/text.mq.md"), "{html}");
assert!(html.contains("lib/text.mq.md"), "{html}");
assert!(html.contains("main"), "{html}");
assert!(!html.contains("trim"), "{html}");
assert!(html.contains("data-line="), "{html}");
assert_eq!(local.functions.len(), 1);
assert_eq!(local.functions[0].name, "main");
}
#[test]
fn structure_formula_assign_not_comment() {
let src = include_str!("../../tests/lib/math-formula.mq.md");
let module = crate::parse::parse_source(src).unwrap();
let html = render_module_structure(&module, src);
assert!(html.contains("badge\">formula"), "{html}");
assert!(html.contains("math-block"), "{html}");
assert!(html.contains("$$"), "{html}");
assert!(
!html.contains("comment-text\">x^2 - 2")
&& !html.contains("comment-text\"><p>x^2 - 2"),
"formula fence leaked into comments: {html}"
);
}
#[test]
fn structure_code_card() {
let src = include_str!("../../tests/lib/foreign-python.mq.md");
let module = crate::parse::parse_source(src).unwrap();
let html = render_module_structure(&module, src);
assert!(html.contains("code-card"), "{html}");
assert!(html.contains("code-run"), "{html}");
assert!(html.contains("hello-from-python"), "{html}");
assert!(!html.contains("python name=hi"), "{html}");
}
#[test]
fn formula_ascii_to_tex_pow_and_mul() {
assert_eq!(formula_ascii_to_tex("x^2 - 2"), "x^{2} - 2");
assert_eq!(formula_ascii_to_tex("2*x"), r"2 \cdot x");
}
#[test]
fn structure_mode_browse_vs_debug() {
let src = include_str!("../../tests/structure/nested-call.mq.md");
let module = crate::parse::parse_source(src).unwrap();
let browse = render_module_structure_mode(&module, src, StructureMode::Browse);
let debug = render_module_structure_mode(&module, src, StructureMode::Debug);
assert!(browse.contains("id=\"fn-"), "{browse}");
assert!(browse.contains("document-surface"), "{browse}");
assert!(!browse.contains("bp-gutter"), "{browse}");
assert!(debug.contains("bp-gutter"), "{debug}");
assert!(debug.contains("id=\"stmt-"), "{debug}");
assert!(debug.contains("card"), "{debug}");
}
#[test]
fn browse_preserves_prose_unified_line() {
let src = include_str!("../../tests/markup-v03/inc-prose.mq.md");
let module = crate::parse::parse_source(src).unwrap();
let html = render_module_structure(&module, src);
assert!(html.contains("对于输入变量"), "{html}");
assert!(html.contains("mq-anchor"), "{html}");
assert!(!html.contains("badge\">bind"), "{html}");
}
#[test]
fn function_outline_lists_nested_names() {
let src = include_str!("../../tests/structure/nested-call.mq.md");
let module = crate::parse::parse_source(src).unwrap();
let outline = render_function_outline(&module);
assert!(outline.contains("outline-item"), "{outline}");
assert!(outline.contains("data-fn=\"main\""), "{outline}");
assert!(outline.contains("data-fn=\"问候\""), "{outline}");
assert!(outline.contains("data-fn-path=\"main/问候\""), "{outline}");
assert!(outline.contains("href=\"#fn-"), "{outline}");
assert!(outline.contains("ol-meta\">h"), "{outline}");
}
#[test]
fn right_rail_has_functions_and_variables() {
let src = include_str!("../../tests/structure/hello.mq.md");
let module = crate::parse::parse_source(src).unwrap();
let mut bind = HashMap::new();
bind.insert(
"xs".into(),
crate::value::Value::List(vec![
crate::value::Value::Text("a".into()),
crate::value::Value::Text("b".into()),
]),
);
let html = render_right_rail(&module, &render_bindings_html(&bind), "");
assert!(html.contains("outline-rail"), "{html}");
assert!(html.contains("Functions"), "{html}");
assert!(html.contains("Variables"), "{html}");
assert!(html.contains("vars-panel"), "{html}");
assert!(html.contains("vars-card"), "{html}");
assert!(html.contains(">xs<") || html.contains("vars-name\">xs"), "{html}");
}
#[test]
fn output_card_renders_image_writeback() {
let html = render_output_card(3, "[ok]\n![](plots/a.svg)");
assert!(html.contains("output-card-image"), "{html}");
assert!(html.contains(r#"src="plots/a.svg""#), "{html}");
assert!(html.contains("wb-ok") || html.contains(">ok<"), "{html}");
let text = render_output_card(1, "plain-42");
assert!(text.contains("output-body"), "{text}");
assert!(!text.contains("wb-image"), "{text}");
let src = render_writeback_source_line(4, "![marqdo-out](plots/a.svg)");
assert!(src.contains(r#"data-wb-kind="image""#), "{src}");
assert!(src.contains("writeback · image"), "{src}");
}
#[test]
fn structure_marks_inferred_params() {
let src = include_str!("../../tests/markup-v03/inc-prose.mq.md");
let module = crate::parse::parse_source(src).unwrap();
let add = module
.functions
.iter()
.find(|f| f.name == "加一函数")
.expect("加一函数");
assert!(add.params.iter().any(|p| p.name == "n" && p.inferred));
let html = render_module_structure(&module, src);
assert!(
html.contains("chip inferred")
&& (html.contains(">n<") || html.contains(r#"data-param-name="n""#)),
"expected inferred chip for n: {html}"
);
let outline = render_function_outline(&module);
assert!(
outline.contains("ol-param inferred") && outline.contains(">n<"),
"expected outline inferred param: {outline}"
);
}
#[test]
fn stream_panel_gated_on_llm_or_agent_import() {
let hello = crate::parse::parse_source(include_str!("../../tests/structure/hello.mq.md"))
.unwrap();
assert!(!uses_stream_panel(&hello));
let llm = crate::parse::parse_source(include_str!("../../tests/ext/llm-import.mq.md")).unwrap();
assert!(uses_stream_panel(&llm));
}
#[test]
fn call_display_bracket_without_modifiers() {
let call = CallExpr {
callee: "parse".into(),
path: Some(vec!["json".into(), "parse".into()]),
receiver: None,
args: vec![Arg::Named {
name: "text".into(),
value: Expr::Literal(Literal::Text("{}".into())),
}],
pre_modifiers: vec![],
bracket_marked: true,
};
let d = call_display(&call);
assert!(d.starts_with("[json.parse]"), "{d}");
assert!(!d.starts_with("> "), "{d}");
}
#[test]
fn call_display_gt_when_not_bracket() {
let call = CallExpr {
callee: "print".into(),
path: None,
receiver: None,
args: vec![Arg::Named {
name: "text".into(),
value: Expr::Literal(Literal::Text("hi".into())),
}],
pre_modifiers: vec![],
bracket_marked: false,
};
let d = call_display(&call);
assert!(d.starts_with("> print"), "{d}");
}
}