use std::collections::BTreeMap;
use femstache_eval::{
EvalError, EvalErrorKind, EvalResult, StringValue, TemplateEnv, TemplateInput, Value,
check_pat, eval_expr,
};
use femstache_loader::{LoaderError, TemplateLoader};
use femstache_parser::nodes::{
Control, Document, DocumentNode, DocumentNodes, ForControlExpr, IfControlCond, IfControlEnd,
Stache,
};
use crate::output::Output;
pub struct TemplateRenderer<'i, I: TemplateInput> {
env: TemplateEnv<'i, I>,
blocks: BTreeMap<String, String>,
loader: Option<TemplateLoader>,
}
impl<'i, I: TemplateInput> TemplateRenderer<'i, I> {
pub fn new(
env: TemplateEnv<'i, I>,
blocks: BTreeMap<String, String>,
loader: Option<TemplateLoader>,
) -> Self {
Self {
env,
blocks,
loader,
}
}
pub fn render_document(&mut self, document: &Document, output: &mut Output) -> EvalResult<()> {
if let Some(meta) = &document.meta
&& let Some(inherit) = &meta.inherit
{
if let Some(loader) = self.loader.as_mut() {
let template = loader
.load(inherit.path.as_str())
.map_err(|err| EvalError::new(EvalErrorKind::Loader(err), inherit.span()))?;
self.env.push();
self.render_document_nodes(&document.nodes, &mut Output::null(output.escape()))?;
self.env.pop();
self.env.push();
self.render_document(template.document(), output)?;
self.env.pop();
} else {
return Err(EvalError::new(
EvalErrorKind::Loader(LoaderError::NoLoader),
meta.span(),
));
}
} else {
self.render_document_nodes(&document.nodes, output)?;
}
Ok(())
}
pub fn render_document_nodes(
&mut self,
nodes: &DocumentNodes,
output: &mut Output,
) -> EvalResult<()> {
for node in &nodes.nodes {
self.render_document_node(node, output)?;
}
Ok(())
}
pub fn render_document_node(
&mut self,
node: &DocumentNode,
output: &mut Output,
) -> EvalResult<()> {
match node {
DocumentNode::Output(o) => {
output.push(&o.data);
Ok(())
}
DocumentNode::Stache(s) => self.render_stache(s, output),
DocumentNode::Control(c) => self.render_control(c, output),
}
}
pub fn render_stache(&mut self, stache: &Stache, output: &mut Output) -> EvalResult<()> {
let val = eval_expr(&self.env, &stache.expr)?;
let s = val
.as_string()
.ok_or_else(|| EvalError::new(EvalErrorKind::InvalidType, stache.expr.span()))?;
match s {
StringValue::Regular(s) => output.push_escaped(s),
StringValue::Raw(s) => output.push(s),
}
Ok(())
}
pub fn render_if_control(
&mut self,
cond: &IfControlCond,
inner: &DocumentNodes,
close: &IfControlEnd,
output: &mut Output,
) -> EvalResult<()> {
match cond {
IfControlCond::Bool(cond) => {
let cond = eval_expr(&self.env, &cond.expr)?;
if cond.is_truthy() {
self.env.push();
self.render_document_nodes(inner, output)?;
self.env.pop();
} else {
self.render_if_control_end(close, output)?;
}
}
IfControlCond::Let(cond) => {
let val = eval_expr(&self.env, &cond.expr)?;
self.env.push();
if check_pat(&mut self.env, &cond.pat, val)? {
self.render_document_nodes(inner, output)?;
} else {
self.env.pop();
self.env.push();
self.render_if_control_end(close, output)?;
}
self.env.pop();
}
}
Ok(())
}
pub fn render_if_control_end(
&mut self,
if_end: &IfControlEnd,
output: &mut Output,
) -> EvalResult<()> {
match if_end {
IfControlEnd::End(_) => {}
IfControlEnd::Else(control) => {
self.render_document_nodes(&control.inner, output)?;
}
IfControlEnd::ElseIf(control) => {
self.render_if_control(&control.open.cond, &control.inner, &control.close, output)?;
}
}
Ok(())
}
pub fn render_control(&mut self, control: &Control, output: &mut Output) -> EvalResult<()> {
match control {
Control::IfControl(if_control) => {
self.render_if_control(
&if_control.open.cond,
&if_control.inner,
&if_control.close,
output,
)?;
}
Control::ForControl(for_control) => match &for_control.open.expr {
ForControlExpr::List(l) => {
let value = eval_expr(&self.env, &l.expr)?;
let list = value
.into_list()
.ok_or_else(|| EvalError::new(EvalErrorKind::InvalidType, l.expr.span()))?;
for item in list {
self.env.push();
self.env.set(&for_control.open.var.data, item);
self.render_document_nodes(&for_control.inner, output)?;
self.env.pop();
}
}
ForControlExpr::Dict(d) => {
let value = eval_expr(&self.env, &d.expr)?;
let dict = value
.into_dict()
.ok_or_else(|| EvalError::new(EvalErrorKind::InvalidType, d.expr.span()))?;
for (key, val) in dict {
self.env.push();
let mut map = BTreeMap::new();
map.insert("key".to_owned(), Value::string(key));
map.insert("val".to_owned(), val);
self.env.set(&for_control.open.var.data, Value::Struct(map));
self.render_document_nodes(&for_control.inner, output)?;
self.env.pop();
}
}
},
Control::BlockControl(block_control) => {
self.env.push();
if let Some(block) = self.blocks.get(block_control.open.name.as_str()) {
output.push(block);
} else {
let key = block_control.open.name.as_str().to_owned();
let mut block = Output::string(output.escape());
self.env.push();
self.render_document_nodes(&block_control.inner, &mut block)?;
let block = block.into_inner();
output.push(&block);
self.blocks.insert(key, block);
self.env.pop();
}
self.env.pop();
}
Control::IncludeControl(include_control) => {
if let Some(loader) = self.loader.as_mut() {
let template = loader.load(include_control.path.as_str()).map_err(|err| {
EvalError::new(EvalErrorKind::Loader(err), include_control.span())
})?;
self.env.push();
self.render_document(template.document(), output)?;
self.env.pop();
} else {
return Err(EvalError::new(
EvalErrorKind::Loader(LoaderError::NoLoader),
include_control.span(),
));
}
}
Control::LetControl(let_control) => {
let value = eval_expr(&self.env, &let_control.expr)?;
self.env.set(&let_control.var.data, value);
}
}
Ok(())
}
}