copperlace 0.4.2

Procedural text renderer for generative grammar configuration
Documentation
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))
    }
}