use super::error::RenderError;
use super::nodes::{
ArrayIterationSource, BindMode, BindNode, ForEachNode, ProcessorPipelineNode, RuleCallNode,
TextGeneratorNode, VecNode,
};
use super::processor::ProcessorRegistry;
enum TemplateToken {
Literal(String),
Expression(String),
Statement(String),
}
pub(crate) fn template_to_node(
template: &str,
processors: &ProcessorRegistry,
) -> Result<Box<dyn TextGeneratorNode>, RenderError> {
let tokens = tokenize_template(template)?;
let mut parser = TemplateParser {
tokens: &tokens,
index: 0,
processors,
};
let nodes = parser.parse_nodes(false)?;
Ok(Box::new(VecNode::new(nodes)))
}
fn tokenize_template(template: &str) -> Result<Vec<TemplateToken>, RenderError> {
let mut tokens = Vec::new();
let mut literal = String::new();
let mut chars = template.char_indices().peekable();
while let Some((index, character)) = chars.next() {
match character {
'\\' => match chars.peek() {
Some((_, next_character)) if matches!(next_character, '{' | '}') => {
literal.push(*next_character);
chars.next();
}
_ => literal.push(character),
},
'{' => {
if !literal.is_empty() {
tokens.push(TemplateToken::Literal(std::mem::take(&mut literal)));
}
if let Some((_, '%')) = chars.peek() {
chars.next();
let statement_start = index + character.len_utf8() + '%'.len_utf8();
let mut statement_end = None;
let mut previous_percent_index = None;
for (statement_index, statement_character) in chars.by_ref() {
if statement_character == '}'
&& let Some(percent_index) = previous_percent_index
{
statement_end = Some(percent_index);
break;
}
previous_percent_index = if statement_character == '%' {
Some(statement_index)
} else {
None
};
}
let Some(statement_end) = statement_end else {
return Err(RenderError::InvalidExpression(
"unmatched opening statement delimiter in template".to_string(),
));
};
let statement = template[statement_start..statement_end].trim();
tokens.push(TemplateToken::Statement(statement.to_string()));
} else {
let expression_start = index + character.len_utf8();
let mut expression_end = None;
for (expression_index, expression_character) in chars.by_ref() {
if expression_character == '}' {
expression_end = Some(expression_index);
break;
}
}
let Some(expression_end) = expression_end else {
return Err(RenderError::InvalidExpression(
"unmatched opening brace in template".to_string(),
));
};
let expression = template[expression_start..expression_end].trim();
tokens.push(TemplateToken::Expression(expression.to_string()));
}
}
'%' => {
if let Some((_, '}')) = chars.peek() {
return Err(RenderError::InvalidExpression(
"unmatched closing statement delimiter in template".to_string(),
));
} else {
literal.push(character);
}
}
'}' => {
return Err(RenderError::InvalidExpression(
"unmatched closing brace in template".to_string(),
));
}
_ => literal.push(character),
}
}
if !literal.is_empty() {
tokens.push(TemplateToken::Literal(literal));
}
Ok(tokens)
}
struct TemplateParser<'a> {
tokens: &'a [TemplateToken],
index: usize,
processors: &'a ProcessorRegistry,
}
impl TemplateParser<'_> {
fn parse_nodes(
&mut self,
inside_loop: bool,
) -> Result<Vec<Box<dyn TextGeneratorNode>>, RenderError> {
let mut nodes = Vec::new();
while let Some(token) = self.tokens.get(self.index) {
match token {
TemplateToken::Literal(value) => {
nodes.push(Box::new(value.clone()) as Box<dyn TextGeneratorNode>);
self.index += 1;
}
TemplateToken::Expression(expression) => {
nodes.push(expression_to_node(expression, self.processors)?);
self.index += 1;
}
TemplateToken::Statement(statement) if statement == "endfor" => {
if !inside_loop {
return Err(RenderError::InvalidExpression(statement.clone()));
}
self.index += 1;
return Ok(nodes);
}
TemplateToken::Statement(statement) if statement.starts_with("for ") => {
let (variable_name, source_name) = parse_for_statement(statement)?;
self.index += 1;
let body = Box::new(VecNode::new(self.parse_nodes(true)?));
nodes.push(Box::new(ForEachNode::new(
variable_name,
Box::new(ArrayIterationSource::new(source_name)),
body,
)));
}
TemplateToken::Statement(statement) => {
nodes.push(statement_to_node(statement, self.processors)?);
self.index += 1;
}
}
}
if inside_loop {
return Err(RenderError::InvalidExpression(
"missing endfor for template loop".to_string(),
));
}
Ok(nodes)
}
}
pub(crate) fn parse_for_statement(statement: &str) -> Result<(String, String), RenderError> {
let parts = statement.split_whitespace().collect::<Vec<_>>();
if parts.len() != 4 || parts[0] != "for" || parts[2] != "in" {
return Err(RenderError::InvalidExpression(statement.to_string()));
}
let variable_name = parts[1];
let source_name = parts[3];
if variable_name == "loop" || !is_identifier(variable_name) || !is_source_path(source_name) {
return Err(RenderError::InvalidExpression(statement.to_string()));
}
Ok((variable_name.to_string(), source_name.to_string()))
}
fn is_source_path(value: &str) -> bool {
value.split('.').all(|segment| {
!segment.is_empty()
&& segment
.chars()
.all(|character| !matches!(character, '|' | ':' | '!' | '{' | '}' | '%'))
})
}
fn is_identifier(value: &str) -> bool {
let mut characters = value.chars();
let Some(first) = characters.next() else {
return false;
};
(first.is_alphabetic() || first == '_')
&& characters.all(|character| character.is_alphanumeric() || matches!(character, '_' | '-'))
}
fn statement_to_node(
statement: &str,
processors: &ProcessorRegistry,
) -> Result<Box<dyn TextGeneratorNode>, RenderError> {
let (base_expression, processor_names) = parse_pipeline(statement, processors)?;
if let Some((name, source)) = base_expression.split_once(":=") {
return bind_node(
statement,
name,
source,
processor_names,
BindMode::Overwrite,
);
}
if let Some((name, source)) = base_expression.split_once(':') {
return bind_node(
statement,
name,
source,
processor_names,
BindMode::IfMissing,
);
}
Err(RenderError::InvalidExpression(statement.to_string()))
}
fn expression_to_node(
expression: &str,
processors: &ProcessorRegistry,
) -> Result<Box<dyn TextGeneratorNode>, RenderError> {
let (base_expression, processor_names) = parse_pipeline(expression, processors)?;
if base_expression.contains(':') {
return Err(RenderError::InvalidExpression(expression.to_string()));
}
let name = base_expression.trim();
if name.is_empty() {
return Err(RenderError::InvalidExpression(expression.to_string()));
}
let (name, unique) = parse_unique_call(name, expression)?;
Ok(pipeline_node(rule_call_node(name, unique), processor_names))
}
fn parse_pipeline<'a>(
expression: &'a str,
processors: &ProcessorRegistry,
) -> Result<(&'a str, Vec<String>), RenderError> {
let mut parts = expression.split('|').map(str::trim);
let base_expression = parts
.next()
.filter(|base_expression| !base_expression.is_empty())
.ok_or_else(|| RenderError::InvalidExpression(expression.to_string()))?;
let processor_names = parts
.map(|processor_name| {
if processor_name.is_empty() {
return Err(RenderError::InvalidExpression(expression.to_string()));
}
if !processors.contains_key(processor_name) {
return Err(RenderError::UnknownProcessor(processor_name.to_string()));
}
Ok(processor_name.to_string())
})
.collect::<Result<Vec<_>, _>>()?;
Ok((base_expression, processor_names))
}
fn bind_node(
expression: &str,
name: &str,
source: &str,
processor_names: Vec<String>,
mode: BindMode,
) -> Result<Box<dyn TextGeneratorNode>, RenderError> {
let name = name.trim();
let source = source.trim();
if name.is_empty() || source.is_empty() {
return Err(RenderError::InvalidExpression(expression.to_string()));
}
let (source, unique) = parse_unique_call(source, expression)?;
let node = pipeline_node(rule_call_node(source, unique), processor_names);
Ok(Box::new(BindNode::new(name.to_string(), node, mode)))
}
fn parse_unique_call<'a>(name: &'a str, expression: &str) -> Result<(&'a str, bool), RenderError> {
let Some(name) = name.strip_suffix('!') else {
return Ok((name, false));
};
let name = name.trim_end();
if name.is_empty() {
return Err(RenderError::InvalidExpression(expression.to_string()));
}
Ok((name, true))
}
fn rule_call_node(name: &str, unique: bool) -> Box<dyn TextGeneratorNode> {
if unique {
Box::new(RuleCallNode::new_unique(name.to_string()))
} else {
Box::new(RuleCallNode::new(name.to_string()))
}
}
fn pipeline_node(
node: Box<dyn TextGeneratorNode>,
processors: Vec<String>,
) -> Box<dyn TextGeneratorNode> {
if processors.is_empty() {
node
} else {
Box::new(ProcessorPipelineNode::new(node, processors))
}
}