use std::collections::HashMap;
use errors::Result;
use parser::ast::{Block, MacroDefinition, Node};
use parser::{parse, remove_whitespace};
#[derive(Debug, Clone)]
pub struct Template {
pub name: String,
pub path: Option<String>,
pub ast: Vec<Node>,
pub from_extend: bool,
pub macros: HashMap<String, MacroDefinition>,
pub imported_macro_files: Vec<(String, String)>,
pub parent: Option<String>,
pub blocks: HashMap<String, Block>,
pub parents: Vec<String>,
pub blocks_definitions: HashMap<String, Vec<(String, Block)>>,
}
impl Template {
pub fn new(tpl_name: &str, tpl_path: Option<String>, input: &str) -> Result<Template> {
let ast = remove_whitespace(parse(input)?, None);
let mut blocks = HashMap::new();
fn find_blocks(ast: &[Node], blocks: &mut HashMap<String, Block>) -> Result<()> {
for node in ast {
match *node {
Node::Block(_, ref block, _) => {
if blocks.contains_key(&block.name) {
bail!("Block `{}` is duplicated", block.name);
}
blocks.insert(block.name.to_string(), block.clone());
find_blocks(&block.body, blocks)?;
}
_ => continue,
};
}
Ok(())
}
find_blocks(&ast, &mut blocks)?;
let mut macros = HashMap::new();
let mut imported_macro_files = vec![];
let mut parent = None;
for node in &ast {
match *node {
Node::Extends(_, ref name) => parent = Some(name.to_string()),
Node::MacroDefinition(_, ref macro_def, _) => {
if macros.contains_key(¯o_def.name) {
bail!("Macro `{}` is duplicated", macro_def.name);
}
macros.insert(macro_def.name.clone(), macro_def.clone());
}
Node::ImportMacro(_, ref tpl_name, ref namespace) => {
imported_macro_files.push((tpl_name.to_string(), namespace.to_string()));
}
_ => continue,
}
}
Ok(Template {
name: tpl_name.to_string(),
path: tpl_path,
ast,
parent,
blocks,
macros,
imported_macro_files,
parents: vec![],
blocks_definitions: HashMap::new(),
from_extend: false,
})
}
}
#[cfg(test)]
mod tests {
use super::Template;
#[test]
fn test_can_parse_ok_template() {
Template::new("hello", None, "Hello {{ world }}.").unwrap();
}
#[test]
fn test_can_find_parent_template() {
let tpl = Template::new("hello", None, "{% extends \"base.html\" %}").unwrap();
assert_eq!(tpl.parent.unwrap(), "base.html".to_string());
}
#[test]
fn test_can_find_blocks() {
let tpl = Template::new(
"hello",
None,
"{% extends \"base.html\" %}{% block hey %}{% endblock hey %}",
).unwrap();
assert_eq!(tpl.parent.unwrap(), "base.html".to_string());
assert_eq!(tpl.blocks.contains_key("hey"), true);
}
#[test]
fn test_can_find_nested_blocks() {
let tpl = Template::new(
"hello",
None,
"{% extends \"base.html\" %}{% block hey %}{% block extrahey %}{% endblock extrahey %}{% endblock hey %}",
).unwrap();
assert_eq!(tpl.parent.unwrap(), "base.html".to_string());
assert_eq!(tpl.blocks.contains_key("hey"), true);
assert_eq!(tpl.blocks.contains_key("extrahey"), true);
}
#[test]
fn test_can_find_macros() {
let tpl = Template::new("hello", None, "{% macro hey() %}{% endmacro hey %}").unwrap();
assert_eq!(tpl.macros.contains_key("hey"), true);
}
#[test]
fn test_can_find_imported_macros() {
let tpl = Template::new("hello", None, "{% import \"macros.html\" as macros %}").unwrap();
assert_eq!(
tpl.imported_macro_files,
vec![("macros.html".to_string(), "macros".to_string())]
);
}
}