duster/src/renderer/renderer.rs

use crate::parser::template;
use crate::parser::DustTag;
use crate::parser::Template;
use crate::parser::TemplateElement;
use crate::renderer::errors::CompileError;
use crate::renderer::errors::RenderError;
use crate::renderer::renderable::Renderable;
use crate::renderer::walkable::Walkable;
use std::collections::HashMap;
use std::ops::Index;

#[derive(Clone, Debug)]
pub struct CompiledTemplate<'a> {
    template: Template<'a>,
    pub name: String,
}

#[derive(Clone, Debug)]
pub struct DustRenderer<'a> {
    templates: HashMap<String, &'a Template<'a>>,
}

pub fn compile_template<'a>(
    source: &'a str,
    name: String,
) -> Result<CompiledTemplate<'a>, CompileError> {
    // TODO: Make this all consuming
    // TODO: This could use better error management
    let (_remaining, parsed_template) = template(source).expect("Failed to compile template");
    Ok(CompiledTemplate {
        template: parsed_template,
        name: name,
    })
}

impl<'a> DustRenderer<'a> {
    pub fn new() -> DustRenderer<'a> {
        DustRenderer {
            templates: HashMap::new(),
        }
    }

    pub fn load_source(&mut self, template: &'a CompiledTemplate) {
        self.templates
            .insert(template.name.clone(), &template.template);
    }

    pub fn render<C>(&self, name: &str, context: &C) -> Result<String, RenderError>
    where
        C: Index<&'a str>,
        <C as std::ops::Index<&'a str>>::Output: Renderable,
    {
        let main_template = match self.templates.get(name) {
            Some(tmpl) => tmpl,
            None => {
                return Err(RenderError {
                    message: format!("No template named {} in context", name),
                });
            }
        };
        self.render_template(main_template, context)
    }

    fn render_template<C>(&self, template: &Template, context: &C) -> Result<String, RenderError>
    where
        C: Index<&'a str>,
        <C as std::ops::Index<&'a str>>::Output: Renderable,
    {
        let mut output = String::new();
        for elem in &template.contents.elements {
            match elem {
                TemplateElement::TESpan(span) => output.push_str(span.contents),
                TemplateElement::TETag(dt) => {
                    output.push_str(&self.render_tag(dt, context)?);
                }
            }
        }
        Ok(output)
    }

    fn render_tag<C>(&self, tag: &DustTag, context: &C) -> Result<String, RenderError>
    where
        C: Index<&'a str>,
        <C as std::ops::Index<&'a str>>::Output: Renderable,
    {
        match tag {
            DustTag::DTComment(comment) => (),
            DustTag::DTReference(reference) => {
                let val = context.index("name");
                return Ok(val.render());
            }
            _ => (), // TODO: Implement the rest
        }
        Ok("".to_owned())
    }
}

fn walk_path<'a, C>(context: &'a C, path: &Vec<&str>) -> &'a C
where
    C: Walkable<Output = C>,
{
    let mut output: &C = context;

    for elem in path.iter() {
        output = context.walk(elem);
    }

    output
}

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

    impl<'a> Walkable for HashMap<&str, &str> {
        type Output = str;

        fn walk(&self, segment: &str) -> &str {
            self.get(segment).unwrap()
        }
    }

    impl<'a> Walkable for str {
        type Output = str;

        fn walk(&self, segment: &str) -> &str {
            panic!("Tried to walk down a str");
        }
    }

    #[test]
    fn test_walk_path() {
        let context: HashMap<&str, &str> = [
            ("cat", "kitty"),
            ("dog", "doggy"),
            ("tiger", "murder kitty"),
        ]
        .iter()
        .cloned()
        .collect();
        assert_eq!(context.walk("cat"), "kitty");
    }
}