use serde_json::Value;
use tera::Context;
use super::{Block, BlockError, BlockRenderCtx};
pub fn default_render<B: Block + ?Sized>(
block: &B,
value: &Value,
ctx: &BlockRenderCtx<'_>,
) -> Result<String, BlockError> {
let template = block.template().map_or_else(
|| format!("blocks/{}.html", block.type_name()),
str::to_owned,
);
let value_object = match value {
Value::Object(_) => value.clone(),
Value::Null => Value::Object(serde_json::Map::new()),
scalar => {
let mut map = serde_json::Map::new();
if let Some(first) = block.fields().into_iter().next() {
map.insert(first.name().to_owned(), scalar.clone());
}
Value::Object(map)
}
};
let mut computed = serde_json::Map::new();
for field in block.fields() {
if let super::BlockField::Computed { name, render, .. } = field {
computed.insert(name, Value::String(render(&value_object, ctx)));
}
}
let mut tera_ctx = Context::new();
let extras = block.extra_context(&value_object, ctx);
for (k, v) in extras {
tera_ctx.insert(&k, &v);
}
tera_ctx.insert("value", &value_object);
tera_ctx.insert("block_type", &block.type_name());
tera_ctx.insert("computed", &Value::Object(computed));
ctx.tera
.render(&template, &tera_ctx)
.map_err(|source| BlockError::TemplateRender {
block_type: block.type_name().to_owned(),
template,
source,
})
}
pub fn prerender_stream(value: &Value, ctx: &BlockRenderCtx<'_>) -> Result<String, BlockError> {
let items = match value {
Value::Array(items) => items,
Value::Null => return Ok(String::new()),
_ => {
return Err(BlockError::Shape {
block_type: "<stream>".to_owned(),
path: String::new(),
reason: "expected JSON array of block entries".to_owned(),
})
}
};
let mut out = String::new();
for (idx, entry) in items.iter().enumerate() {
let Some(type_name) = entry.get("type").and_then(Value::as_str) else {
tracing::warn!(target: "rustango_cms::block", index = idx, "stream entry has no `type`; skipped");
out.push_str(&failed_block_marker("<missing type>"));
continue;
};
let inner_value = entry.get("value").unwrap_or(&Value::Null);
match crate::page_builder::resolve_block(ctx.dyn_blocks, type_name) {
Some(block) => match block.render(inner_value, ctx) {
Ok(rendered) if crate::template_inspector::active() => {
let template = block.template().map_or_else(|| format!("blocks/{type_name}.html"), str::to_owned);
let template = if ctx.tera.get_template_names().any(|n| n == template) {
template
} else {
format!("{type_name} block (built-in markup)")
};
out.push_str(&crate::template_inspector::mark(&template, &rendered));
}
Ok(rendered) => out.push_str(&rendered),
Err(e) => {
tracing::warn!(
target: "rustango_cms::block",
block_type = type_name, index = idx, error = %e,
"block failed to render; the rest of the stream still renders"
);
out.push_str(&failed_block_marker(type_name));
}
},
None => {
out.push_str(&format!(
"<div class=\"rcms-stream-drift\" data-unknown-type=\"{}\">\
Schema drift: unknown block type \"{}\" — \
was it removed without a migration?\
</div>",
tera::escape_html(type_name),
tera::escape_html(type_name),
));
}
}
}
Ok(out)
}
fn failed_block_marker(type_name: &str) -> String {
format!(
"<div class=\"rcms-stream-error\" data-block-type=\"{}\" hidden></div>",
tera::escape_html(type_name)
)
}