diff --git a/src/renderer/context_element.rs b/src/renderer/context_element.rs index 0dccc2c..14f1aae 100644 --- a/src/renderer/context_element.rs +++ b/src/renderer/context_element.rs @@ -1,9 +1,8 @@ use crate::parser::Filter; use crate::renderer::errors::RenderError; -use crate::renderer::renderer::RenderWrapper; use std::fmt::Debug; -pub trait ContextElement: Debug + RenderWrapper + Walkable + Renderable + Loopable {} +pub trait ContextElement: Debug + Walkable + Renderable + Loopable {} pub trait Walkable { fn walk(&self, segment: &str) -> Result<&dyn ContextElement, RenderError>; diff --git a/src/renderer/renderer.rs b/src/renderer/renderer.rs index 6ad133b..bbd1727 100644 --- a/src/renderer/renderer.rs +++ b/src/renderer/renderer.rs @@ -20,24 +20,6 @@ pub struct DustRenderer<'a> { templates: HashMap>, } -pub trait RenderWrapper { - fn render_body<'a>( - &'a self, - renderer: &'a DustRenderer, - body: &Body, - ) -> Result; -} - -impl RenderWrapper for C { - fn render_body<'a>( - &'a self, - renderer: &'a DustRenderer, - body: &Body, - ) -> Result> { - renderer.render_body(body, self) - } -} - pub fn compile_template<'a>( source: &'a str, name: String, @@ -80,22 +62,6 @@ impl<'a> DustRenderer<'a> { self.new_render_body(&main_template.contents, breadcrumbs) } - pub fn render(&'a self, name: &str, context: &'a C) -> Result> - 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 new_render_body( &'a self, body: &'a Body, @@ -114,23 +80,6 @@ impl<'a> DustRenderer<'a> { Ok(output) } - fn render_body(&'a self, body: &Body, context: &'a C) -> Result> - where - C: ContextElement, - { - let mut output = String::new(); - for elem in &body.elements { - match elem { - TemplateElement::TEIgnoredWhitespace(_) => {} - TemplateElement::TESpan(span) => output.push_str(span.contents), - TemplateElement::TETag(dt) => { - output.push_str(&self.render_tag(dt, context)?); - } - } - } - Ok(output) - } - fn new_render_tag( &'a self, tag: &'a DustTag, @@ -195,68 +144,6 @@ impl<'a> DustRenderer<'a> { Ok("".to_owned()) } - fn render_tag(&'a self, tag: &DustTag, context: &'a C) -> Result> - 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 if let Err(RenderError::CantWalk { .. }) = val { - // If the context type does not support walking, 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); - let loop_elements: Vec<&dyn ContextElement> = self.get_loop_elements(val)?; - 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 => return Ok("".to_owned()), - Some(body) => { - let rendered_results: Result, 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("")); - } - }; - } - } - DustTag::DTSpecial(special) => { - return Ok(match special { - Special::Space => " ", - Special::NewLine => "\n", - Special::CarriageReturn => "\r", - Special::LeftCurlyBrace => "{", - Special::RightCurlyBrace => "}", - } - .to_owned()) - } - _ => (), // TODO: Implement the rest - } - Ok("".to_owned()) - } - /// Gets the elements to loop over for a section. /// /// If the value is falsey, and therefore should render the else @@ -268,12 +155,6 @@ impl<'a> DustRenderer<'a> { if let Err(RenderError::NotFound { .. }) = walk_result { // If reference does not exist in the context, render the else block Ok(vec![]) - } else if let Err(RenderError::WontWalk { .. }) = walk_result { - // If reference does not exist in the context, render the else block - Ok(vec![]) - } else if let Err(RenderError::CantWalk { .. }) = walk_result { - // If the context type does not support walking, render the else block - Ok(vec![]) } else { Ok(walk_result?.get_loop_elements()?) } @@ -335,19 +216,6 @@ fn new_walk_path<'a>( }) } -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::*; @@ -432,7 +300,7 @@ mod tests { } #[test] - fn test_new_walk_path() { + fn test_walk_path() { let context: HashMap<&str, &str> = [("cat", "kitty"), ("dog", "doggy"), ("tiger", "murderkitty")] .iter() @@ -479,46 +347,4 @@ mod tests { "people".to_owned() ); } - - #[test] - fn test_walk_path() { - 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() - ); - } }