duster/src/renderer/renderer.rs

use crate::parser::template;
use crate::parser::Body;
use crate::parser::DustTag;
use crate::parser::Template;
use crate::parser::TemplateElement;
use crate::renderer::context_element::ContextElement;
use crate::renderer::errors::CompileError;
use crate::renderer::errors::RenderError;
use std::collections::HashMap;

#[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 trait RenderWrapper {
    fn render_body<'a>(
        &'a self,
        renderer: &'a DustRenderer,
        body: &Body,
    ) -> Result<String, RenderError>;
}

impl<C: ContextElement> RenderWrapper for C {
    fn render_body<'a>(
        &'a self,
        renderer: &'a DustRenderer,
        body: &Body,
    ) -> Result<String, RenderError<'a>> {
        renderer.render_body(body, self)
    }
}

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: &'a C) -> Result<String, RenderError<'a>>
    where
        C: ContextElement,
    {
        let main_template = match self.templates.get(name) {
            Some(tmpl) => tmpl,
            None => {
                return Err(RenderError::Generic(format!(
                    "No template named {} in context",
                    name
                )));
            }
        };
        self.render_body(&main_template.contents, context)
    }

    fn render_body<C>(&self, body: &Body, context: &'a C) -> Result<String, RenderError<'a>>
    where
        C: ContextElement,
    {
        let mut output = String::new();
        for elem in &body.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: &'a C) -> Result<String, RenderError<'a>>
    where
        C: ContextElement,
    {
        match tag {
            DustTag::DTComment(_comment) => (),
            DustTag::DTReference(reference) => {
                let val = walk_path(context, &reference.path.keys);
                if let Err(RenderError::WontWalk { .. }) = val {
                    // If reference does not exist in the context, it becomes an empty string
                    return Ok("".to_owned());
                } else {
                    return val?.render(&reference.filters);
                }
            }
            DustTag::DTSection(container) => {
                let val = walk_path(context, &container.path.keys);
                if let Err(RenderError::WontWalk { .. }) = val {
                    // If reference does not exist in the context, it becomes an empty string
                    return Ok("".to_owned());
                } else {
                    let loop_elements: Vec<&dyn ContextElement> = val?.get_loop_elements()?;
                    if loop_elements.is_empty() {
                        // Oddly enough if the value is falsey (like
                        // an empty array or null), Dust uses the
                        // original context before walking the path as
                        // the context for rendering the else block
                        //
                        // TODO: do filters apply? I don't think so
                        // but I should test
                        return match &container.else_contents {
                            Some(body) => self.render_body(&body, context),
                            None => Ok("".to_owned()),
                        };
                    } else {
                        match container.contents {
                            None => Ok("".to_owned()),
                            Some(body) => {
                                let rendered_results: Result<Vec<String>, RenderError> =
                                    loop_elements
                                        .into_iter()
                                        .map(|array_elem| array_elem.render_body(self, &body))
                                        .collect();
                                let rendered_slice: &[String] = &rendered_results?;
                                return Ok(rendered_slice.join(""));
                            }
                        };
                        return Ok("".to_owned());
                    }
                }
            }
            _ => (), // TODO: Implement the rest
        }
        Ok("".to_owned())
    }
}

fn walk_path<'a>(
    context: &'a dyn ContextElement,
    path: &Vec<&str>,
) -> Result<&'a dyn ContextElement, RenderError<'a>> {
    let mut output = context;

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

    Ok(output)
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::parser::Filter;
    use crate::renderer::context_element::Loopable;
    use crate::renderer::context_element::Renderable;
    use crate::renderer::context_element::Walkable;

    #[test]
    fn test_walk_path() {
        impl ContextElement for u32 {}
        impl ContextElement for &str {}
        impl<I: ContextElement> ContextElement for HashMap<&str, I> {}

        impl Renderable for u32 {
            fn render(&self, _filters: &Vec<Filter>) -> Result<String, RenderError> {
                // TODO: handle the filters
                Ok(self.to_string())
            }
        }

        impl Renderable for &str {
            fn render(&self, _filters: &Vec<Filter>) -> Result<String, RenderError> {
                // TODO: handle the filters
                Ok(self.to_string())
            }
        }

        impl<I: ContextElement> Renderable for HashMap<&str, I> {
            fn render(&self, _filters: &Vec<Filter>) -> Result<String, RenderError> {
                // TODO: handle the filters
                Err(RenderError::CantRender { elem: self })
            }
        }

        impl<I: ContextElement> Walkable for HashMap<&str, I> {
            fn walk(&self, segment: &str) -> Result<&dyn ContextElement, RenderError> {
                let child = self.get(segment).ok_or(RenderError::WontWalk {
                    segment: segment.to_string(),
                    elem: self,
                })?;
                Ok(child)
            }
        }

        impl Walkable for &str {
            fn walk(&self, segment: &str) -> Result<&dyn ContextElement, RenderError> {
                Err(RenderError::CantWalk {
                    segment: segment.to_string(),
                    elem: self,
                })
            }
        }

        impl Walkable for u32 {
            fn walk(&self, segment: &str) -> Result<&dyn ContextElement, RenderError> {
                Err(RenderError::CantWalk {
                    segment: segment.to_string(),
                    elem: self,
                })
            }
        }

        impl Loopable for &str {
            fn get_loop_elements(&self) -> Result<Vec<&dyn ContextElement>, RenderError> {
                if self.is_empty() {
                    Ok(Vec::new())
                } else {
                    Ok(vec![self])
                }
            }
        }

        impl Loopable for u32 {
            fn get_loop_elements(&self) -> Result<Vec<&dyn ContextElement>, RenderError> {
                Ok(vec![self])
            }
        }

        impl<I: ContextElement> Loopable for HashMap<&str, I> {
            fn get_loop_elements(&self) -> Result<Vec<&dyn ContextElement>, RenderError> {
                Ok(vec![self])
            }
        }

        let context: HashMap<&str, &str> =
            [("cat", "kitty"), ("dog", "doggy"), ("tiger", "murderkitty")]
                .iter()
                .cloned()
                .collect();
        let number_context: HashMap<&str, u32> = [("cat", 1), ("dog", 2), ("tiger", 3)]
            .iter()
            .cloned()
            .collect();
        let deep_context: HashMap<&str, HashMap<&str, &str>> = [
            ("cat", [("food", "meat")].iter().cloned().collect()),
            ("dog", [("food", "meat")].iter().cloned().collect()),
            ("tiger", [("food", "people")].iter().cloned().collect()),
        ]
        .iter()
        .cloned()
        .collect();
        assert_eq!(
            walk_path(&context, &vec!["cat"])
                .unwrap()
                .render(&Vec::new())
                .unwrap(),
            "kitty".to_owned()
        );
        assert_eq!(
            walk_path(&number_context, &vec!["tiger"])
                .unwrap()
                .render(&Vec::new())
                .unwrap(),
            "3".to_owned()
        );
        assert_eq!(
            walk_path(&deep_context, &vec!["tiger", "food"])
                .unwrap()
                .render(&Vec::new())
                .unwrap(),
            "people".to_owned()
        );
    }
}