Files
marqdo/src/host/foreign_doc.rs
T
cflmy fb28eee62f feat(foreign): own view sessions and clear outputs
foreign.session returns a handle from ordinary kernel/cell tables; view consumes only the 会话 binding. Sessions live in host foreign_doc. Without 会话, view cells run stateless one-shot. Add /api/session/clear and a Clear outputs button for every view page; clearing keeps persistent kernel state.
2026-10-18 12:42:15 +08:00

1280 lines
43 KiB
Rust

//! Document session: cells, kernels, execution journal, state store.
//!
//! Stateful cells live here, owned by the foreign runtime. The view reads a
//! `会话 = > foreign.session ...` handle; no table names are reserved, and a
//! document without that handle gets stateless one-shot cells.
use std::collections::{HashMap, HashSet};
use std::path::{Path, PathBuf};
use sha2::{Digest, Sha256};
use crate::foreign::registry;
use crate::host::foreign_session;
use crate::host::HostContext;
use crate::value::Value;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum CellStatus {
Never,
Running,
Clean,
Dirty,
Stale,
Error,
Unlisted,
}
impl CellStatus {
fn as_str(self) -> &'static str {
match self {
Self::Never => "never",
Self::Running => "running",
Self::Clean => "clean",
Self::Dirty => "dirty",
Self::Stale => "stale",
Self::Error => "error",
Self::Unlisted => "unlisted",
}
}
}
#[derive(Debug, Clone)]
pub struct Cell {
pub name: String,
pub lang: String,
pub source: String,
pub line_start: u32,
pub line_end: u32,
pub source_hash: String,
pub kernel: String,
pub listed: bool,
pub status: CellStatus,
pub runs: u64,
pub last_ms: u64,
pub last_ok: bool,
pub last_error: String,
}
#[derive(Debug, Clone)]
pub struct KernelDecl {
pub name: String,
pub lang: String,
pub cmd: Option<String>,
pub implicit: bool,
}
#[derive(Debug, Clone)]
pub struct JournalRecord {
pub seq: u64,
pub cell: String,
pub kernel: String,
pub lang: String,
pub ok: bool,
pub code: i64,
pub ms: u64,
pub timestamp_ms: i64,
pub error: String,
}
pub struct DocumentSession {
pub path: PathBuf,
root: PathBuf,
pub persistent: bool,
pub cells: Vec<Cell>,
pub kernels: Vec<KernelDecl>,
pub order: Vec<String>,
pub journal: Vec<JournalRecord>,
pub value_store: HashMap<String, Value>,
pub cursor: usize,
pub opened_ms: i64,
host: HostContext,
kernel_sessions: HashMap<String, String>,
seq: u64,
}
fn hash_source(source: &str) -> String {
let mut h = Sha256::new();
h.update(source.as_bytes());
format!("{:x}", h.finalize())
}
fn now_ms() -> i64 {
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_millis() as i64)
.unwrap_or(0)
}
/// Convert a table value into row maps. Handles both row tables (`| @ | ... |`)
/// and ordinary column tables; no source text is scanned.
fn table_rows(v: &Value) -> Result<Vec<HashMap<String, Value>>, String> {
match v {
Value::None => Ok(Vec::new()),
Value::List(rows) => {
let mut out = Vec::with_capacity(rows.len());
for (i, row) in rows.iter().enumerate() {
let Value::Map(pairs) = row else {
return Err(format!("view table row {} is not a map", i + 1));
};
out.push(
pairs
.iter()
.filter(|(k, _)| k != "@")
.map(|(k, v)| (k.clone(), v.clone()))
.collect(),
);
}
Ok(out)
}
Value::Map(cols) => {
// A single-row table may evaluate to a map of scalar fields rather
// than a column map. Treat that map as one record.
if !cols.iter().all(|(_, v)| matches!(v, Value::List(_))) {
let row = cols
.iter()
.filter(|(k, _)| k != "@")
.map(|(k, v)| (k.clone(), v.clone()))
.collect();
return Ok(vec![row]);
}
let mut width = 0usize;
for (_, value) in cols {
let Value::List(xs) = value else {
unreachable!();
};
width = width.max(xs.len());
}
let mut out = Vec::with_capacity(width);
for i in 0..width {
let mut row = HashMap::new();
for (name, value) in cols {
if let Value::List(xs) = value {
if let Some(v) = xs.get(i) {
row.insert(name.clone(), v.clone());
}
}
}
out.push(row);
}
Ok(out)
}
_ => Err("view plan binding is not a table".into()),
}
}
fn plan_tables(
bindings: &HashMap<String, Value>,
) -> Result<(Option<Vec<HashMap<String, Value>>>, Option<Vec<HashMap<String, Value>>>), String> {
let Some(plan) = bindings.get("会话") else {
return Ok((None, None));
};
let Value::Map(fields) = plan else {
return Err("`会话` must be a foreign.session handle".into());
};
let field = |name: &str| {
fields
.iter()
.find(|(k, _)| k == name)
.map(|(_, v)| v.clone())
};
let kind = field("kind").map(|v| value_text(&v)).unwrap_or_default();
if kind != "foreign-session" {
return Err("`会话` must be a foreign.session handle".into());
}
let kernels = match field("kernels") {
Some(Value::None) | None => None,
Some(v) => Some(table_rows(&v)?),
};
let cells = match field("cells") {
Some(Value::None) | None => None,
Some(v) => Some(table_rows(&v)?),
};
Ok((kernels, cells))
}
fn col_value<'a>(row: &'a HashMap<String, Value>, names: &[&str]) -> Option<&'a Value> {
for n in names {
if let Some(v) = row.get(*n) {
if !matches!(v, Value::None) {
return Some(v);
}
}
}
None
}
fn value_text(v: &Value) -> String {
match v {
Value::Text(s) => s.clone(),
Value::None => String::new(),
other => other.as_display(),
}
}
fn col_text(row: &HashMap<String, Value>, names: &[&str]) -> Option<String> {
col_value(row, names).map(value_text).filter(|s| !s.trim().is_empty())
}
/// Evaluate the entry object's declarations with the real interpreter. Tables
/// are ordinary Marqdo values; the view does not re-parse source text.
fn capture_bindings(
path: &Path,
root: &Path,
module: &crate::ast::Module,
source: &str,
) -> Result<HashMap<String, Value>, String> {
let mut host = HostContext::for_capture(Some(path), crate::host::HostCaps::default());
host.cwd = path.parent().unwrap_or_else(|| Path::new(".")).to_path_buf();
host.fs_root = Some(root.to_path_buf());
host.entry_path = Some(path.to_path_buf());
host.entry_source = Some(source.to_string());
host.entry_metadata = module.metadata.clone();
let mut interp = crate::interp::Interpreter::with_capture(Some(path), false).with_host(host);
interp
.capture_declarations(module, &["会话"])
.map_err(|e| format!("view plan evaluation: {e}"))
}
fn collect_cells(stmts: &[crate::ast::Stmt], out: &mut Vec<Cell>, seen: &mut HashSet<String>) -> Result<(), String> {
for stmt in stmts {
match stmt {
crate::ast::Stmt::Assign {
name,
value: crate::ast::Expr::Code(c),
span,
end_line,
} => {
if !seen.insert(name.clone()) {
return Err(format!(
"cell `{name}` is assigned more than once (line {})",
span.line
));
}
out.push(Cell {
name: name.clone(),
lang: c.lang.clone(),
source: c.source.clone(),
line_start: span.line,
line_end: *end_line,
source_hash: hash_source(&c.source),
kernel: String::new(),
listed: false,
status: CellStatus::Never,
runs: 0,
last_ms: 0,
last_ok: false,
last_error: String::new(),
});
}
crate::ast::Stmt::Branch { arms, .. } => {
for arm in arms {
collect_cells(&arm.body, out, seen)?;
}
}
crate::ast::Stmt::While { body, .. } | crate::ast::Stmt::ForEach { body, .. } => {
collect_cells(body, out, seen)?;
}
_ => {}
}
}
Ok(())
}
impl DocumentSession {
pub fn open(path: &Path, root: &Path) -> Result<Self, String> {
let source = std::fs::read_to_string(path)
.map_err(|e| format!("read {}: {e}", path.display()))?;
let bind_ctx = crate::binding::BindingContext::from_binds(
&[],
crate::binding::cwd_for_path(Some(path)),
);
let module = crate::load::load_module_with_ctx(path, &bind_ctx)
.map_err(|e| format!("load {}: {e}", path.display()))?;
let entry = module
.functions
.iter()
.find(|f| f.name == "main" && f.is_object())
.or_else(|| {
let objs: Vec<_> = module.functions.iter().filter(|f| f.is_object()).collect();
if objs.len() == 1 {
Some(objs[0])
} else {
None
}
})
.ok_or_else(|| "notebook: no `# main` (or sole object) to index".to_string())?;
let mut cells = Vec::new();
let mut seen = HashSet::new();
collect_cells(&entry.body, &mut cells, &mut seen)?;
let declarations = capture_bindings(path, root, &module, &source)?;
let persistent = declarations.contains_key("会话");
let (plan_kernels, plan_cells) = plan_tables(&declarations)?;
let mut kernels: Vec<KernelDecl> = Vec::new();
let mut kernel_map: HashMap<String, KernelDecl> = HashMap::new();
if let Some(rows) = plan_kernels {
if rows.is_empty() {
return Err("foreign.session: at least one kernel row is required".into());
}
for row in rows {
let name = col_text(&row, &["名称", "Name", "name"])
.ok_or_else(|| "foreign.session kernels: missing 名称/Name".to_string())?;
let lang = col_text(&row, &["语言", "Language", "language", "lang"])
.ok_or_else(|| format!("foreign.session[{name}]: missing 语言/Language"))?;
let lang = registry::canonical(&lang);
let cmd = col_text(&row, &["命令", "Command", "command", "cmd"]);
if kernel_map.contains_key(&name) {
return Err(format!("foreign.session: kernel `{name}` is declared twice"));
}
let decl = KernelDecl {
name: name.clone(),
lang,
cmd,
implicit: false,
};
kernel_map.insert(name.clone(), decl.clone());
kernels.push(decl);
}
}
let mut order: Vec<String> = Vec::new();
let session_rows = plan_cells;
if let Some(rows) = session_rows {
if rows.is_empty() {
return Err("foreign.session cells: at least one cell row is required".into());
}
let by_name: HashMap<String, usize> = cells
.iter()
.enumerate()
.map(|(i, c)| (c.name.clone(), i))
.collect();
let mut listed = HashSet::new();
for row in rows {
let cell_name = col_text(&row, &["单元", "Cell", "cell", "单元名"])
.ok_or_else(|| "foreign.session cells: missing 单元/Cell".to_string())?;
let kernel_name = col_text(&row, &["内核", "Kernel", "kernel"])
.ok_or_else(|| format!("foreign.session[{cell_name}]: missing 内核/Kernel"))?;
let Some(&ci) = by_name.get(&cell_name) else {
return Err(format!("foreign.session: unknown cell `{cell_name}`"));
};
if !listed.insert(cell_name.clone()) {
return Err(format!("foreign.session: cell `{cell_name}` is listed twice"));
}
let kernel = resolve_kernel(&mut kernels, &mut kernel_map, &kernel_name)?;
if registry::canonical(&cells[ci].lang) != registry::canonical(&kernel.lang) {
return Err(format!(
"foreign.session: cell `{cell_name}` ({}) cannot use kernel `{}` ({})",
cells[ci].lang, kernel.name, kernel.lang
));
}
cells[ci].kernel = kernel.name.clone();
cells[ci].listed = true;
order.push(cell_name);
}
for cell in &mut cells {
if !cell.listed {
cell.status = CellStatus::Unlisted;
}
}
} else if persistent {
for cell in &mut cells {
let kernel = ensure_default_kernel(
&mut kernels,
&mut kernel_map,
&cell.lang,
);
cell.kernel = kernel;
cell.listed = true;
order.push(cell.name.clone());
}
} else {
for cell in &mut cells {
cell.kernel = "one-shot".into();
cell.listed = true;
order.push(cell.name.clone());
}
}
let mut host = HostContext::default();
let doc_dir = path.parent().unwrap_or_else(|| Path::new("."));
host.cwd = doc_dir.to_path_buf();
host.fs_root = Some(root.to_path_buf());
host.entry_path = Some(path.to_path_buf());
host.entry_source = Some(source);
Ok(Self {
path: path.to_path_buf(),
root: root.to_path_buf(),
persistent,
cells,
kernels,
order,
journal: Vec::new(),
value_store: HashMap::new(),
cursor: 0,
opened_ms: now_ms(),
host,
kernel_sessions: HashMap::new(),
seq: 0,
})
}
/// Re-read the document, preserving kernels/state/journal. Changed cells become dirty.
pub fn reload(&mut self, root: &Path) -> Result<(), String> {
let mut fresh = Self::open(&self.path, root)?;
let old: HashMap<String, Cell> = self
.cells
.iter()
.cloned()
.map(|c| (c.name.clone(), c))
.collect();
for c in &mut fresh.cells {
if let Some(o) = old.get(&c.name) {
c.runs = o.runs;
c.last_ms = o.last_ms;
c.last_ok = o.last_ok;
c.last_error = o.last_error.clone();
c.status = if o.source_hash != c.source_hash || o.kernel != c.kernel {
CellStatus::Dirty
} else if o.status == CellStatus::Running {
CellStatus::Dirty
} else {
o.status
};
}
}
fresh.host = std::mem::replace(&mut self.host, HostContext::default());
fresh.kernel_sessions = std::mem::take(&mut self.kernel_sessions);
fresh.value_store = std::mem::take(&mut self.value_store);
fresh.journal = std::mem::take(&mut self.journal);
fresh.seq = self.seq;
fresh.cursor = self.cursor.min(fresh.order.len());
fresh.opened_ms = self.opened_ms;
let known: HashSet<String> = fresh.kernels.iter().map(|k| k.name.clone()).collect();
let orphans: Vec<String> = fresh
.kernel_sessions
.keys()
.filter(|k| !known.contains(*k))
.cloned()
.collect();
for k in orphans {
if let Some(id) = fresh.kernel_sessions.remove(&k) {
let _ = foreign_session::close(&mut fresh.host, &Value::Text(id));
}
}
*self = fresh;
Ok(())
}
pub fn title(&self) -> String {
self.path
.file_stem()
.and_then(|s| s.to_str())
.unwrap_or("session")
.trim_end_matches(".mq")
.to_string()
}
fn cell_index(&self, name: &str) -> Option<usize> {
self.cells.iter().position(|c| c.name == name)
}
fn kernel(&self, name: &str) -> Option<&KernelDecl> {
self.kernels.iter().find(|k| k.name == name)
}
fn ensure_kernel_session(&mut self, kernel_name: &str) -> Result<String, String> {
if let Some(id) = self.kernel_sessions.get(kernel_name) {
if self.host.foreign_sessions.contains_key(id) {
return Ok(id.clone());
}
}
let decl = self
.kernel(kernel_name)
.ok_or_else(|| format!("unknown kernel `{kernel_name}`"))?
.clone();
let cmd_value = decl.cmd.map(Value::Text);
let lang = Value::Text(decl.lang.clone());
let id = foreign_session::open(
&mut self.host,
&lang,
cmd_value.as_ref(),
None,
None,
None,
)?;
let id = match id {
Value::Text(s) => s,
_ => return Err("session_open returned non-text id".into()),
};
self.kernel_sessions
.insert(kernel_name.to_string(), id.clone());
Ok(id)
}
fn record_result(&mut self, cell: &str, kernel: &str, record: &Value) -> Result<(), String> {
let field = |k: &str| match record {
Value::Map(entries) => entries
.iter()
.find(|(kk, _)| kk == k)
.map(|(_, v)| v.clone()),
_ => None,
};
let ok = matches!(field("ok"), Some(Value::Bool(true)));
let ms = match field("ms") {
Some(Value::Int(n)) => n as u64,
_ => 0,
};
let error = field("error")
.and_then(|v| v.reveal_text().map(|s| s.to_string()))
.unwrap_or_default();
let code = match field("code") {
Some(Value::Int(n)) => n,
_ => 0,
};
let lang = self
.cell_index(cell)
.map(|i| self.cells[i].lang.clone())
.unwrap_or_default();
if let Some(i) = self.cell_index(cell) {
let c = &mut self.cells[i];
c.runs += 1;
c.last_ms = ms;
c.last_ok = ok;
c.last_error = error.clone();
c.status = if ok { CellStatus::Clean } else { CellStatus::Error };
}
self.seq += 1;
self.journal.push(JournalRecord {
seq: self.seq,
cell: cell.to_string(),
kernel: kernel.to_string(),
lang,
ok,
code,
ms,
timestamp_ms: now_ms(),
error,
});
Ok(())
}
pub fn run_cell(&mut self, cell_name: &str, kernel_override: Option<&str>) -> Result<Value, String> {
let ci = self
.cell_index(cell_name)
.ok_or_else(|| format!("unknown cell `{cell_name}`"))?;
if !self.cells[ci].listed && kernel_override.is_none() {
return Err(format!("cell `{cell_name}` is not listed in the foreign session"));
}
if !self.persistent {
self.cells[ci].kernel = "one-shot".into();
self.cells[ci].status = CellStatus::Running;
let lang = self.cells[ci].lang.clone();
let source = self.cells[ci].source.clone();
let result = crate::host::foreign::invoke_for_view(
&self.root,
&lang,
&source,
None,
None,
None,
);
return match result {
Ok(record) => {
self.record_result(cell_name, "one-shot", &record)?;
Ok(record)
}
Err(e) => {
if let Some(i) = self.cell_index(cell_name) {
self.cells[i].status = CellStatus::Error;
self.cells[i].last_error = e.clone();
}
Err(e)
}
};
}
let kernel = match kernel_override {
Some(k) => {
if self.kernel(k).is_none() {
return Err(format!("unknown kernel `{k}`"));
}
let ci_lang = registry::canonical(&self.cells[ci].lang);
let klang = registry::canonical(
&self.kernel(k).map(|d| d.lang.clone()).unwrap_or_default(),
);
if ci_lang != klang {
return Err(format!(
"cell `{cell_name}` ({}) cannot run in kernel `{k}` ({klang})",
self.cells[ci].lang
));
}
self.cells[ci].kernel = k.to_string();
self.cells[ci].listed = true;
k.to_string()
}
None => self.cells[ci].kernel.clone(),
};
self.cells[ci].status = CellStatus::Running;
let result = (|| -> Result<Value, String> {
let id = self.ensure_kernel_session(&kernel)?;
let source = Value::Text(self.cells[ci].source.clone());
let record = foreign_session::eval(
&mut self.host,
&Value::Text(id),
None,
Some(&source),
None,
None,
)?;
self.record_result(cell_name, &kernel, &record)?;
Ok(record)
})();
if result.is_err() {
self.cells[ci].status = CellStatus::Error;
}
result
}
pub fn step(&mut self) -> Result<Value, String> {
if self.cursor >= self.order.len() {
return Ok(Value::Map(vec![
("done".into(), Value::Bool(true)),
("cursor".into(), Value::Int(self.cursor as i64)),
]));
}
let name = self.order[self.cursor].clone();
let record = self.run_cell(&name, None)?;
let ci = self.cell_index(&name).unwrap_or(0);
let kernel = self.cells[ci].kernel.clone();
self.cursor += 1;
let mut fields = match record {
Value::Map(m) => m,
other => vec![("result".into(), other)],
};
fields.push(("cell".into(), Value::Text(name)));
fields.push(("kernel".into(), Value::Text(kernel)));
fields.push(("cursor".into(), Value::Int(self.cursor as i64)));
Ok(Value::Map(fields))
}
pub fn run_all(&mut self, restart: bool) -> Result<Value, String> {
if restart {
self.restart_all()?;
}
self.cursor = 0;
let mut records = Vec::new();
let mut failed = 0i64;
for name in self.order.clone() {
let record = self.run_cell(&name, None)?;
let ok = match &record {
Value::Map(m) => matches!(
m.iter().find(|(k, _)| k == "ok").map(|(_, v)| v),
Some(Value::Bool(true))
),
_ => false,
};
if !ok {
failed += 1;
}
let mut m = match record {
Value::Map(m) => m,
other => vec![("result".into(), other)],
};
m.push(("cell".into(), Value::Text(name)));
records.push(Value::Map(m));
self.cursor += 1;
}
Ok(Value::Map(vec![
("ok".into(), Value::Bool(failed == 0)),
("ran".into(), Value::Int(self.order.len() as i64)),
("failed".into(), Value::Int(failed)),
("records".into(), Value::List(records)),
]))
}
pub fn restart_kernel(&mut self, name: &str) -> Result<Value, String> {
if let Some(id) = self.kernel_sessions.remove(name) {
let _ = foreign_session::close(&mut self.host, &Value::Text(id));
}
for c in &mut self.cells {
if c.kernel == name {
c.status = CellStatus::Never;
c.last_error.clear();
}
}
Ok(Value::Bool(true))
}
pub fn restart_all(&mut self) -> Result<Value, String> {
let names: Vec<String> = self.kernel_sessions.keys().cloned().collect();
for name in names {
self.restart_kernel(&name)?;
}
self.cursor = 0;
for c in &mut self.cells {
c.status = if c.listed { CellStatus::Never } else { CellStatus::Unlisted };
}
Ok(Value::Bool(true))
}
pub fn assign_kernel(&mut self, cell: &str, kernel: &str) -> Result<Value, String> {
let ci = self
.cell_index(cell)
.ok_or_else(|| format!("unknown cell `{cell}`"))?;
let decl = self
.kernel(kernel)
.ok_or_else(|| format!("unknown kernel `{kernel}`"))?
.clone();
if registry::canonical(&self.cells[ci].lang) != registry::canonical(&decl.lang) {
return Err(format!(
"cell `{cell}` ({}) cannot use kernel `{kernel}` ({})",
self.cells[ci].lang, decl.lang
));
}
self.cells[ci].kernel = kernel.to_string();
self.cells[ci].listed = true;
self.cells[ci].status = CellStatus::Dirty;
Ok(Value::None)
}
pub fn state_list(&mut self) -> Result<Value, String> {
let marqdo = self
.value_store
.iter()
.map(|(k, v)| (k.clone(), v.clone()))
.collect::<Vec<_>>();
let mut kernels = Vec::new();
for k in &self.kernels {
let live = self.kernel_sessions.get(&k.name).cloned();
let mut vars = Vec::new();
if let Some(id) = live {
if self.host.foreign_sessions.contains_key(&id) {
if let Ok(names) = foreign_session::names(&mut self.host, &Value::Text(id)) {
if let Value::List(xs) = names {
vars = xs;
}
}
}
}
kernels.push(Value::Map(vec![
("name".into(), Value::Text(k.name.clone())),
("lang".into(), Value::Text(k.lang.clone())),
("vars".into(), Value::List(vars)),
]));
}
Ok(Value::Map(vec![
("marqdo".into(), Value::Map(marqdo)),
("kernels".into(), Value::List(kernels)),
]))
}
pub fn push_value(&mut self, kernel: &str, name: &str, value: Value) -> Result<Value, String> {
let id = self.ensure_kernel_session(kernel)?;
foreign_session::set(
&mut self.host,
&Value::Text(id),
&Value::Text(name.to_string()),
&value,
)?;
self.value_store.insert(name.to_string(), value);
Ok(Value::None)
}
pub fn pull_value(&mut self, kernel: &str, name: &str) -> Result<Value, String> {
let id = self.ensure_kernel_session(kernel)?;
let value = foreign_session::get(
&mut self.host,
&Value::Text(id),
&Value::Text(name.to_string()),
)?;
self.value_store
.insert(name.to_string(), value.clone());
Ok(value)
}
pub fn summary(&self) -> Value {
let cells = self
.cells
.iter()
.map(|c| {
Value::Map(vec![
("name".into(), Value::Text(c.name.clone())),
("lang".into(), Value::Text(c.lang.clone())),
("kernel".into(), Value::Text(c.kernel.clone())),
("listed".into(), Value::Bool(c.listed)),
("status".into(), Value::Text(c.status.as_str().into())),
("line_start".into(), Value::Int(c.line_start as i64)),
("line_end".into(), Value::Int(c.line_end as i64)),
("runs".into(), Value::Int(c.runs as i64)),
("last_ms".into(), Value::Int(c.last_ms as i64)),
("last_ok".into(), Value::Bool(c.last_ok)),
("last_error".into(), Value::Text(c.last_error.clone())),
])
})
.collect();
let kernels = self
.kernels
.iter()
.map(|k| {
Value::Map(vec![
("name".into(), Value::Text(k.name.clone())),
("lang".into(), Value::Text(k.lang.clone())),
("implicit".into(), Value::Bool(k.implicit)),
(
"live".into(),
Value::Bool(self.kernel_sessions.contains_key(&k.name)),
),
])
})
.collect();
Value::Map(vec![
("title".into(), Value::Text(self.title())),
("path".into(), Value::Text(self.path.display().to_string())),
("persistent".into(), Value::Bool(self.persistent)),
("cells".into(), Value::List(cells)),
("kernels".into(), Value::List(kernels)),
("order".into(), Value::List(
self.order.iter().cloned().map(Value::Text).collect(),
)),
("cursor".into(), Value::Int(self.cursor as i64)),
("journal".into(), Value::List(
self.journal
.iter()
.map(|j| {
Value::Map(vec![
("seq".into(), Value::Int(j.seq as i64)),
("cell".into(), Value::Text(j.cell.clone())),
("kernel".into(), Value::Text(j.kernel.clone())),
("lang".into(), Value::Text(j.lang.clone())),
("ok".into(), Value::Bool(j.ok)),
("code".into(), Value::Int(j.code)),
("ms".into(), Value::Int(j.ms as i64)),
("timestamp_ms".into(), Value::Int(j.timestamp_ms)),
("error".into(), Value::Text(j.error.clone())),
])
})
.collect(),
)),
("opened_ms".into(), Value::Int(self.opened_ms)),
])
}
/// Clear displayed outputs and per-cell records; kernels and live state survive.
pub fn clear_outputs(&mut self) -> Value {
for cell in &mut self.cells {
cell.runs = 0;
cell.last_ms = 0;
cell.last_ok = false;
cell.last_error.clear();
if cell.listed {
cell.status = CellStatus::Never;
}
}
self.journal.clear();
self.cursor = 0;
self.summary()
}
pub fn journal_json(&self) -> Value {
Value::List(
self.journal
.iter()
.map(|j| {
Value::Map(vec![
("seq".into(), Value::Int(j.seq as i64)),
("cell".into(), Value::Text(j.cell.clone())),
("kernel".into(), Value::Text(j.kernel.clone())),
("lang".into(), Value::Text(j.lang.clone())),
("ok".into(), Value::Bool(j.ok)),
("code".into(), Value::Int(j.code)),
("ms".into(), Value::Int(j.ms as i64)),
("timestamp_ms".into(), Value::Int(j.timestamp_ms)),
("error".into(), Value::Text(j.error.clone())),
])
})
.collect(),
)
}
pub fn close(&mut self) {
let ids: Vec<String> = self.kernel_sessions.values().cloned().collect();
for id in ids {
let _ = foreign_session::close(&mut self.host, &Value::Text(id));
}
self.kernel_sessions.clear();
}
}
fn resolve_kernel(
kernels: &mut Vec<KernelDecl>,
map: &mut HashMap<String, KernelDecl>,
name: &str,
) -> Result<KernelDecl, String> {
if let Some(k) = map.get(name) {
return Ok(k.clone());
}
if registry::preset_spec(name).is_some() {
let lang = registry::canonical(name);
let decl = KernelDecl {
name: lang.clone(),
lang,
cmd: None,
implicit: true,
};
map.insert(decl.name.clone(), decl.clone());
kernels.push(decl.clone());
return Ok(decl);
}
Err(format!(
"foreign.session: kernel `{name}` is not declared in kernels"
))
}
fn ensure_default_kernel(
kernels: &mut Vec<KernelDecl>,
map: &mut HashMap<String, KernelDecl>,
lang: &str,
) -> String {
let lang = registry::canonical(lang);
let name = format!("default:{lang}");
if !map.contains_key(&name) {
let decl = KernelDecl {
name: name.clone(),
lang,
cmd: None,
implicit: true,
};
map.insert(name.clone(), decl.clone());
kernels.push(decl);
}
name
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn table_rows_reads_row_records_and_columns() {
let row_table = Value::List(vec![Value::Map(vec![
("@".into(), Value::Text("1".into())),
("名称".into(), Value::Text("分析".into())),
("语言".into(), Value::Text("python".into())),
])]);
let rows = table_rows(&row_table).unwrap();
assert_eq!(rows.len(), 1);
assert_eq!(col_text(&rows[0], &["名称"]).as_deref(), Some("分析"));
let column_table = Value::Map(vec![
("名称".into(), Value::List(vec![Value::Text("分析".into())])),
("语言".into(), Value::List(vec![Value::Text("python".into())])),
]);
let rows = table_rows(&column_table).unwrap();
assert_eq!(rows.len(), 1);
assert_eq!(col_text(&rows[0], &["语言"]).as_deref(), Some("python"));
}
#[test]
fn plan_uses_evaluated_bindings() {
let root = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"));
let path = root.join(format!(
"target/view-plan-{}-{}.mq.md",
std::process::id(),
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_nanos())
.unwrap_or(0)
));
let source = r#"---
title: evaluated plan test
import foreign:lib/foreign.mq.md
---
# main
`lang` = python
`分析内核` =
| @ | 名称 | 语言 |
|---|------|------|
| 1 | 分析 | `lang` |
`分析单元` =
| @ | 单元 | 内核 |
|---|------|------|
| 1 | 单元 | 分析 |
`会话` = > foreign.session kernels=`分析内核` cells=`分析单元`
`单元` =
```python
print(1)
```
"#;
std::fs::write(&path, source).unwrap();
let s = DocumentSession::open(&path, &root).unwrap();
assert_eq!(s.cells.len(), 1);
assert_eq!(s.cells[0].kernel, "分析");
assert_eq!(s.kernels[0].lang, "python");
let _ = std::fs::remove_file(&path);
}
#[test]
fn view_open_accepts_a_document_without_cells() {
let root = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"));
let path = root.join(format!(
"target/view-empty-{}-{}.mq.md",
std::process::id(),
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_nanos())
.unwrap_or(0)
));
std::fs::write(&path, "# main\n\n> print text=hello\n").unwrap();
let s = DocumentSession::open(&path, &root).unwrap();
assert!(s.cells.is_empty());
let _ = std::fs::remove_file(&path);
}
fn node_available() -> bool {
std::process::Command::new("node")
.args(["-e", "process.exit(0)"])
.output()
.map(|o| o.status.success())
.unwrap_or(false)
}
fn field(record: &Value, key: &str) -> Option<Value> {
match record {
Value::Map(entries) => entries
.iter()
.find(|(k, _)| k == key)
.map(|(_, v)| v.clone()),
_ => None,
}
}
#[test]
fn shared_state_and_isolation() {
if !node_available() {
return;
}
let root = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"));
let path = root.join(format!(
"target/notebook-test-{}-{}.mq.md",
std::process::id(),
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_nanos())
.unwrap_or(0)
));
let source = r#"---
title: shared state test
import foreign:lib/foreign.mq.md
---
# main
`内核表` =
| 名称 | 语言 | 命令 | 说明 |
|------|------|------|------|
| 分析 | node | | shared |
| 绘图 | node | | isolated |
`会话表` =
| 单元 | 内核 | 说明 |
|------|------|------|
| 设置 | 分析 | write |
| 读取 | 分析 | read |
| 隔离 | 绘图 | isolated |
`会话` = > foreign.session kernels=`内核表` cells=`会话表`
`设置` =
```node
let shared = 41;
```
`读取` =
```node
console.log(shared + 1);
```
`隔离` =
```node
console.log(typeof shared === "undefined" ? "isolated" : "leaked");
```
"#;
std::fs::write(&path, source).unwrap();
let mut s = DocumentSession::open(&path, &root).unwrap();
assert_eq!(
s.order,
vec!["设置".to_string(), "读取".to_string(), "隔离".to_string()]
);
let r = s.run_cell("设置", None).unwrap();
assert_eq!(field(&r, "ok"), Some(Value::Bool(true)));
let r = s.run_cell("读取", None).unwrap();
assert_eq!(
field(&r, "stdout").and_then(|v| v.reveal_text().map(|s| s.to_string())),
Some("42\n".to_string())
);
let r = s.run_cell("隔离", None).unwrap();
assert_eq!(
field(&r, "stdout").and_then(|v| v.reveal_text().map(|s| s.to_string())),
Some("isolated\n".to_string())
);
s.restart_all().unwrap();
let r = s.run_cell("读取", None).unwrap();
assert_eq!(field(&r, "ok"), Some(Value::Bool(false)));
s.close();
let _ = std::fs::remove_file(&path);
}
#[test]
fn magic_table_names_without_session_are_ignored() {
if !node_available() {
return;
}
let root = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"));
let path = root.join(format!(
"target/view-stateless-{}-{}.mq.md",
std::process::id(),
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_nanos())
.unwrap_or(0)
));
let source = r#"# main
`内核表` =
| 名称 | 语言 |
|------|------|
| 分析 | node |
`会话表` =
| 单元 | 内核 |
|------|------|
| a | 分析 |
`a` =
```node
console.log("stateless");
```
"#;
std::fs::write(&path, source).unwrap();
let mut s = DocumentSession::open(&path, &root).unwrap();
assert!(!s.persistent);
assert!(s.kernels.is_empty(), "magic tables must not create kernels");
assert_eq!(s.order, vec!["a".to_string()]);
assert_eq!(s.cells[0].kernel, "one-shot");
let r = s.run_cell("a", None).unwrap();
assert_eq!(
field(&r, "stdout").and_then(|v| v.reveal_text().map(|s| s.to_string())),
Some("stateless\n".to_string())
);
assert_eq!(s.cells[0].status, CellStatus::Clean);
s.clear_outputs();
assert_eq!(s.cells[0].status, CellStatus::Never);
assert!(s.journal.is_empty());
s.close();
let _ = std::fs::remove_file(&path);
}
#[test]
fn clear_outputs_keeps_persistent_kernel_state() {
if !node_available() {
return;
}
let root = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"));
let path = root.join(format!(
"target/view-clear-{}-{}.mq.md",
std::process::id(),
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_nanos())
.unwrap_or(0)
));
let source = r#"---
title: clear outputs
import foreign:lib/foreign.mq.md
---
# main
`内核` =
| 名称 | 语言 |
|------|------|
| 分析 | node |
`单元` =
| 单元 | 内核 |
|------|------|
| a | 分析 |
`会话` = > foreign.session kernels=`内核` cells=`单元`
`a` =
```node
globalThis.kept = (globalThis.kept || 0) + 1;
console.log(globalThis.kept);
```
"#;
std::fs::write(&path, source).unwrap();
let mut s = DocumentSession::open(&path, &root).unwrap();
let r = s.run_cell("a", None).unwrap();
assert_eq!(
field(&r, "stdout").and_then(|v| v.reveal_text().map(|s| s.to_string())),
Some("1\n".to_string())
);
s.clear_outputs();
assert_eq!(s.cells[0].status, CellStatus::Never);
assert!(s.journal.is_empty());
let r = s.run_cell("a", None).unwrap();
assert_eq!(
field(&r, "stdout").and_then(|v| v.reveal_text().map(|s| s.to_string())),
Some("2\n".to_string()),
"clear outputs must not restart the kernel"
);
s.close();
let _ = std::fs::remove_file(&path);
}
#[test]
fn reload_marks_changed_cell_dirty() {
if !node_available() {
return;
}
let root = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"));
let path = root.join(format!(
"target/notebook-reload-{}-{}.mq.md",
std::process::id(),
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_nanos())
.unwrap_or(0)
));
let src = "# main\n\n`a` =\n```node\nconsole.log(1);\n```\n";
std::fs::write(&path, src).unwrap();
let mut s = DocumentSession::open(&path, &root).unwrap();
let r = s.run_cell("a", None).unwrap();
assert_eq!(field(&r, "ok"), Some(Value::Bool(true)));
assert_eq!(s.cells[0].status, CellStatus::Clean);
let src2 = "# main\n\n`a` =\n```node\nconsole.log(2);\n```\n";
std::fs::write(&path, src2).unwrap();
s.reload(&root).unwrap();
assert_eq!(s.cells[0].status, CellStatus::Dirty);
assert!(s.cells[0].source.contains("console.log(2)"));
s.close();
let _ = std::fs::remove_file(&path);
}
}