mst_parser/

parser.rs

/* src/parser.rs */

use alloc::string::String;
use alloc::vec::Vec;
use crate::ast::{Node, Limits};
use crate::error::Error;

/// State object for the parser to track current limits.
struct ParserState {
    node_count: usize,
    depth: usize,
    max_nodes: usize,
    max_depth: usize,
}

impl ParserState {
    fn new(limits: &Limits) -> Self {
        Self {
            node_count: 0,
            depth: 0,
            max_nodes: limits.max_nodes,
            max_depth: limits.max_depth,
        }
    }

    fn inc_node(&mut self, offset: usize) -> Result<(), Error> {
        if self.node_count >= self.max_nodes {
            return Err(Error::NodeLimitExceeded { limit: self.max_nodes, offset });
        }
        self.node_count += 1;
        Ok(())
    }

    fn enter_depth(&mut self, offset: usize) -> Result<(), Error> {
        if self.depth >= self.max_depth {
            return Err(Error::DepthExceeded { limit: self.max_depth, offset });
        }
        self.depth += 1;
        Ok(())
    }

    fn exit_depth(&mut self, offset: usize) -> Result<(), Error> {
        self.depth = self.depth.checked_sub(1)
            .ok_or(Error::UnbalancedTag { offset })?;
        Ok(())
    }
}

/// A configured template parser.
#[derive(Debug, Clone, Default)]
pub struct Parser {
    limits: Limits,
}

impl Parser {
    /// Creates a new parser with the given limits.
    #[must_use]
    pub fn new(limits: Limits) -> Self {
        Self { limits }
    }

    /// Parses a template string into AST nodes.
    pub fn parse(&self, input: &str) -> Result<Vec<Node>, Error> {
        parse_inner(input, &self.limits)
    }
}

/// Convenience function that parses with default limits.
pub fn parse(input: &str) -> Result<Vec<Node>, Error> {
    Parser::default().parse(input)
}

fn parse_inner(input: &str, limits: &Limits) -> Result<Vec<Node>, Error> {
    let mut state = ParserState::new(limits);
    let mut chars = input.char_indices().peekable();
    parse_recursive(&mut chars, input, &mut state, None)
}

/// Internal recursive parser.
///
/// `var_open_offset`: Some(idx) if we are currently parsing content inside `{{ ... }}` started at `idx`.
fn parse_recursive(
    chars: &mut core::iter::Peekable<core::str::CharIndices<'_>>,
    original_input: &str,
    state: &mut ParserState,
    var_open_offset: Option<usize>,
) -> Result<Vec<Node>, Error> {
    let mut nodes = Vec::new();
    let mut current_text_start = None;

    while let Some((idx, ch)) = chars.next() {
        // Check for '{{' start sequence
        if ch == '{' {
            if let Some(&(_, '{')) = chars.peek() {
                // Found "{{", start of a variable
                
                // 1. Flush any preceding text
                if let Some(start) = current_text_start {
                    if start < idx {
                        let text = &original_input[start..idx];
                        state.inc_node(start)?;
                        nodes.push(Node::Text(String::from(text)));
                        #[cfg(feature = "tracing")]
                        tracing::trace!(text = text, "parsed text node");
                    }
                    current_text_start = None;
                }

                // 2. Consume the second '{'
                chars.next();

                // 3. Parse variable content recursively
                state.inc_node(idx)?; // Count the Variable node itself
                state.enter_depth(idx)?;
                
                #[cfg(feature = "tracing")]
                tracing::debug!(depth = state.depth, "entering variable");

                let parts = parse_recursive(chars, original_input, state, Some(idx))?;
                
                #[cfg(feature = "tracing")]
                tracing::debug!(depth = state.depth, "exiting variable");
                
                state.exit_depth(idx)?;
                nodes.push(Node::Variable { parts });

                continue;
            }
        }

        // Check for '}}' end sequence
        if let Some(open_offset) = var_open_offset {
            if ch == '}' {
                if let Some(&(_, '}')) = chars.peek() {
                    // Found "}}", end of current variable
                    
                    // 1. Flush any preceding text
                    if let Some(start) = current_text_start {
                        if start < idx {
                            let text = &original_input[start..idx];
                            state.inc_node(start)?;
                            nodes.push(Node::Text(String::from(text)));
                            #[cfg(feature = "tracing")]
                            tracing::trace!(text = text, "parsed text node");
                        }
                        // current_text_start = None; // Not needed before return
                    }

                    // 2. Consume the second '}'
                    chars.next();
                    
                    // Check for empty variable
                    if nodes.is_empty() {
                        return Err(Error::EmptyVariable { offset: open_offset });
                    }

                    // Return what we collected for this variable
                    return Ok(nodes);
                }
            }
        }

        // Normal character, track text start
        if current_text_start.is_none() {
            current_text_start = Some(idx);
        }
    }

    // End of input reached
    if let Some(open_offset) = var_open_offset {
        // If we were expecting '}}' but hit EOF, that's an error
        return Err(Error::UnclosedVariable { offset: open_offset });
    }

    // Flush remaining text at EOF for top-level
    if let Some(start) = current_text_start {
        let end_idx = original_input.len();
        if start < end_idx {
            let text = &original_input[start..end_idx];
            state.inc_node(start)?;
            nodes.push(Node::Text(String::from(text)));
            #[cfg(feature = "tracing")]
            tracing::trace!(text = text, "parsed text node");
        }
    }

    Ok(nodes)
}

#[cfg(test)]
mod tests {
    use super::*;
    use alloc::vec;

    #[test]
    fn test_plain_text() {
        let input = "Hello World";
        let nodes = parse(input).unwrap();
        assert_eq!(nodes, vec![Node::Text("Hello World".into())]);
    }

    #[test]
    fn test_simple_variable() {
        let input = "Hello {{name}}!";
        let nodes = parse(input).unwrap();
        assert_eq!(
            nodes,
            vec![
                Node::Text("Hello ".into()),
                Node::Variable {
                    parts: vec![Node::Text("name".into())]
                },
                Node::Text("!".into())
            ]
        );
    }

    #[test]
    fn test_nested_variable() {
        // "key.{{sub}}" -> Variable(Text("key."), Variable(Text("sub")))
        let input = "{{key.{{sub}}}}";
        let nodes = parse(input).unwrap();
        
        match &nodes[0] {
            Node::Variable { parts } => {
                assert_eq!(parts.len(), 2);
                assert_eq!(parts[0], Node::Text("key.".into()));
                match &parts[1] {
                    Node::Variable { parts: sub_parts } => {
                        assert_eq!(sub_parts[0], Node::Text("sub".into()));
                    }
                    _ => panic!("Expected inner variable"),
                }
            }
            _ => panic!("Expected outer variable"),
        }
    }

    #[test]
    fn test_unclosed_variable() {
        let input = "Hello {{name";
        let err = parse(input).unwrap_err();
        match err {
            Error::UnclosedVariable { offset } => assert_eq!(offset, 6),
            _ => panic!("Unexpected error: {:?}", err),
        }
    }

    #[test]
    fn test_depth_limit() {
        let limits = Limits { max_depth: 1, max_nodes: 100 };
        let parser = Parser::new(limits);
        // Depth 0 (root) -> Depth 1 ({{a}}) -> Depth 2 ({{b}}) -> Fail
        let input = "{{a{{b}}}}"; 
        let err = parser.parse(input).unwrap_err();
        match err {
            Error::DepthExceeded { limit, offset } => {
                assert_eq!(limit, 1);
                assert_eq!(offset, 3); // second {{ starts at 3
            },
            _ => panic!("Unexpected error: {:?}", err),
        }
    }

    #[test]
    fn test_node_limit() {
        let limits = Limits { max_depth: 10, max_nodes: 2 };
        let parser = Parser::new(limits);
        // "abc" (1 node) + {{...}} (1 node) + "d" (1 node) = 3 nodes -> Fail
        let input = "abc{{d}}"; 
        let err = parser.parse(input).unwrap_err();
         match err {
            Error::NodeLimitExceeded { limit, offset } => {
                assert_eq!(limit, 2); // Error happens at "d" (node 3)
                assert_eq!(offset, 5); // "d" starts at 5
            },
            _ => panic!("Unexpected error: {:?}", err),
        }
    }
    
    #[test]
    fn test_consecutive_braces() {
        // "{{{" -> First "{{" opens variable. Remaining "{" is text inside variable.
        // Expecting "}}" to close.
        let input = "{{{}}"; 
        let nodes = parse(input).unwrap();
        match &nodes[0] {
            Node::Variable { parts } => {
                assert_eq!(parts[0], Node::Text("{".into()));
            }
            _ => panic!("Expected variable"),
        }
    }

    #[test]
    fn test_empty_variable() {
        let input = "{{}}";
        let err = parse(input).unwrap_err();
        match err {
            Error::EmptyVariable { offset } => assert_eq!(offset, 0),
            _ => panic!("Unexpected error: {:?}", err),
        }
    }

    #[test]
    fn test_top_level_closing_braces() {
        let input = "hello}}world";
        let nodes = parse(input).unwrap();
        assert_eq!(nodes, vec![Node::Text("hello}}world".into())]);
    }
}