use crate::parser::template; use crate::parser::Body; use crate::parser::DustTag; use crate::parser::Filter; use crate::parser::KVPair; use crate::parser::PartialNameElement; use crate::parser::Path; use crate::parser::RValue; use crate::parser::Special; use crate::parser::Template; use crate::parser::TemplateElement; use crate::renderer::breadcrumb_tree::BreadcrumbTreeElement; use crate::renderer::context_element::ContextElement; use crate::renderer::context_element::IntoContextElement; use crate::renderer::context_element::Walkable; use crate::renderer::errors::CompileError; use crate::renderer::errors::RenderError; use crate::renderer::errors::WalkError; use crate::renderer::inline_partial_tree::extract_inline_partials; use crate::renderer::inline_partial_tree::InlinePartialTreeElement; use crate::renderer::iteration_context::IterationContext; use crate::renderer::parameters_context::ParametersContext; use crate::renderer::tree_walking::walk_path; use std::borrow::Borrow; use std::collections::HashMap; use std::rc::Rc; #[derive(Clone, Debug)] pub struct DustRenderer<'a> { templates: HashMap>, } pub fn compile_template<'a>(source: &'a str) -> Result, CompileError> { let (_remaining, parsed_template) = template(source).map_err(|err| CompileError { message: "Failed to compile template".to_owned(), })?; Ok(parsed_template) } impl<'a> DustRenderer<'a> { pub fn new() -> DustRenderer<'a> { DustRenderer { templates: HashMap::new(), } } pub fn load_source(&mut self, template: &'a Template, name: String) { self.templates.insert(name, template); } pub fn render(&'a self, name: &str, context: Option<&C>) -> Result where C: IntoContextElement, { let breadcrumbs = context .map(|ctx| vec![BreadcrumbTreeElement::from_borrowed(ctx)]) .unwrap_or(Vec::new()); self.render_template(name, breadcrumbs.as_ref(), None) } pub fn render_template( &'a self, name: &str, breadcrumbs: &'a Vec>, blocks: Option<&'a InlinePartialTreeElement<'a>>, ) -> Result { let main_template = match self.templates.get(name) { Some(tmpl) => tmpl, None => { return Err(RenderError::TemplateNotFound(name.to_owned())); } }; let extracted_inline_partials = extract_inline_partials(main_template); let new_blocks = InlinePartialTreeElement::new(blocks, extracted_inline_partials); let new_block_context = BlockContext { breadcrumbs: breadcrumbs, blocks: &new_blocks, }; self.render_body(&main_template.contents, breadcrumbs, &new_block_context) } fn render_maybe_body( &'a self, body: &'a Option, breadcrumbs: &'a Vec>, blocks: &'a BlockContext<'a>, ) -> Result { match body { None => Ok("".to_owned()), Some(body) => Ok(self.render_body(body, breadcrumbs, blocks)?), } } fn render_body( &'a self, body: &'a Body, breadcrumbs: &'a Vec>, blocks: &'a BlockContext<'a>, ) -> Result { 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, breadcrumbs, blocks)?); } } } Ok(output) } /// For rendering a dynamic partial's name or an rvalue template pub fn render_partial_name( &'a self, body: &'a Vec, breadcrumbs: &'a Vec>, ) -> Result { let converted_to_template_elements: Vec> = body.into_iter().map(|e| e.into()).collect(); // Simple templates like partial names and reference rvalues // cannot contain blocks or inline partials, so we use a blank // BlockContext. let empty_block_context = BlockContext { breadcrumbs: &Vec::new(), blocks: &InlinePartialTreeElement::new(None, HashMap::new()), }; self.render_body( &Body { elements: converted_to_template_elements, }, breadcrumbs, &empty_block_context, ) } fn render_tag( &'a self, tag: &'a DustTag, breadcrumbs: &'a Vec>, blocks: &'a BlockContext<'a>, ) -> Result { match tag { DustTag::DTComment(_comment) => (), DustTag::DTSpecial(special) => { return Ok(match special { Special::Space => " ", Special::NewLine => "\n", Special::CarriageReturn => "\r", Special::LeftCurlyBrace => "{", Special::RightCurlyBrace => "}", } .to_owned()) } DustTag::DTLiteralStringBlock(literal) => return Ok((*literal).to_owned()), DustTag::DTReference(reference) => { let val = walk_path(breadcrumbs, &reference.path.keys) .map(|ice| ice.into_context_element(self, breadcrumbs)); match val { Err(WalkError::CantWalk) | Ok(None) => return Ok("".to_owned()), Ok(Some(final_val)) => { return if final_val.get_context_element_reference().is_truthy() { final_val .get_context_element_reference() .render(&Self::preprocess_filters(&reference.filters)) } else { Ok("".to_owned()) }; } } } DustTag::DTSection(container) => { let injected_context = ParametersContext::new(self, breadcrumbs, &container.params); let val = walk_path(breadcrumbs, &container.path.keys) .map(|ice| ice.into_context_element(self, breadcrumbs)); match val { Err(WalkError::CantWalk) | Ok(None) => { let new_breadcrumbs = self.new_breadcrumbs_section( breadcrumbs, None, Some(&injected_context), &container.explicit_context, None, ); return self.render_maybe_body( &container.else_contents, new_breadcrumbs.as_ref().unwrap_or(breadcrumbs), blocks, ); } Ok(Some(final_val)) => { let context_element = final_val.get_context_element_reference(); return if context_element.is_truthy() { match &container.contents { None => Ok("".to_owned()), Some(body) => { let loop_elements: Vec<&dyn ContextElement> = context_element.get_loop_elements(); if loop_elements.is_empty() { // Scalar value let new_breadcrumbs = self.new_breadcrumbs_section( breadcrumbs, None, Some(&injected_context), &container.explicit_context, Some(context_element), ); self.render_body( body, new_breadcrumbs.as_ref().unwrap_or(breadcrumbs), blocks, ) } else { // Array-like value let total_length = loop_elements.len(); let rendered_results: Result, RenderError> = loop_elements .into_iter() .enumerate() .map(|(i, array_elem)| { let index_context = IterationContext::new(i, total_length); let new_breadcrumbs = self .new_breadcrumbs_section( breadcrumbs, Some(&index_context), Some(&injected_context), &container.explicit_context, Some(array_elem), ); self.render_body( &body, new_breadcrumbs .as_ref() .unwrap_or(breadcrumbs), blocks, ) }) .collect(); let rendered_slice: &[String] = &rendered_results?; return Ok(rendered_slice.join("")); } } } } else { // 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 let new_breadcrumbs = self.new_breadcrumbs_section( breadcrumbs, None, Some(&injected_context), &container.explicit_context, None, ); self.render_maybe_body( &container.else_contents, new_breadcrumbs.as_ref().unwrap_or(breadcrumbs), blocks, ) }; } } } DustTag::DTExists(container) => { let new_breadcrumbs = self.new_breadcrumbs_partial( breadcrumbs, breadcrumbs, None, &container.explicit_context, ); let val = walk_path(breadcrumbs, &container.path.keys) .map(|ice| ice.into_context_element(self, breadcrumbs)); return match val { Ok(Some(v)) if v.get_context_element_reference().is_truthy() => self .render_maybe_body( &container.contents, new_breadcrumbs.as_ref().unwrap_or(breadcrumbs), blocks, ), _ => self.render_maybe_body( &container.else_contents, new_breadcrumbs.as_ref().unwrap_or(breadcrumbs), blocks, ), }; } DustTag::DTNotExists(container) => { let new_breadcrumbs = self.new_breadcrumbs_partial( breadcrumbs, breadcrumbs, None, &container.explicit_context, ); let val = walk_path(breadcrumbs, &container.path.keys) .map(|ice| ice.into_context_element(self, breadcrumbs)); return match val { Ok(Some(v)) if v.get_context_element_reference().is_truthy() => self .render_maybe_body( &container.else_contents, new_breadcrumbs.as_ref().unwrap_or(breadcrumbs), blocks, ), _ => self.render_maybe_body( &container.contents, new_breadcrumbs.as_ref().unwrap_or(breadcrumbs), blocks, ), }; } DustTag::DTPartial(partial) => { let partial_name = self.render_partial_name(&partial.name, breadcrumbs)?; if partial.params.is_empty() { let new_breadcrumbs = self.new_breadcrumbs_partial( breadcrumbs, breadcrumbs, None, &partial.explicit_context, ); let rendered_content = self.render_template( &partial_name, new_breadcrumbs.as_ref().unwrap_or(breadcrumbs), Some(blocks.blocks), )?; return Ok(rendered_content); } else { let injected_context = ParametersContext::new(self, breadcrumbs, &partial.params); let new_breadcrumbs = self.new_breadcrumbs_partial( breadcrumbs, breadcrumbs, Some(&injected_context), &partial.explicit_context, ); let rendered_content = self.render_template( &partial_name, new_breadcrumbs.as_ref().unwrap_or(breadcrumbs), Some(blocks.blocks), )?; return Ok(rendered_content); } } DustTag::DTInlinePartial(_named_block) => { // Inline partials are blank during rendering (they get injected into blocks) return Ok("".to_owned()); } DustTag::DTBlock(named_block) => { let new_breadcrumbs = self.new_breadcrumbs_partial( breadcrumbs, blocks.breadcrumbs, None, &named_block.explicit_context, ); return match blocks.blocks.get_block(named_block.path.keys[0]) { None => self.render_maybe_body( &named_block.contents, new_breadcrumbs.as_ref().unwrap_or(breadcrumbs), blocks, ), Some(inline_partial) => self.render_maybe_body( inline_partial, new_breadcrumbs.as_ref().unwrap_or(breadcrumbs), blocks, ), }; } DustTag::DTHelperEquals(parameterized_block) => { let new_breadcrumbs = self.new_breadcrumbs_partial( breadcrumbs, breadcrumbs, None, ¶meterized_block.explicit_context, ); let param_map = ParametersContext::new(self, breadcrumbs, ¶meterized_block.params); // Special case: when comparing two RVPaths, if the // path is equal then dust assumes the values are // equal (otherwise, non-scalar values are // automatically not equal) if Self::are_paths_identical(¶m_map, "key", "value") { return match ¶meterized_block.contents { None => Ok("".to_owned()), Some(body) => { let rendered_content = self.render_body( body, new_breadcrumbs.as_ref().unwrap_or(breadcrumbs), blocks, )?; Ok(rendered_content) } }; } let left_side = match param_map .walk("key") .map(|ice| ice.into_context_element(self, breadcrumbs)) { Err(WalkError::CantWalk) | Ok(None) => return Ok("".to_owned()), Ok(Some(res)) => res, }; let right_side = param_map .walk("value") .map(|ice| ice.into_context_element(self, breadcrumbs)); if Ok(Some(left_side.get_context_element_reference())) == right_side.as_ref().map(|maybe_ice| { maybe_ice .as_ref() .map(|ice| ice.get_context_element_reference()) }) { return self.render_maybe_body( ¶meterized_block.contents, new_breadcrumbs.as_ref().unwrap_or(breadcrumbs), blocks, ); } else { return self.render_maybe_body( ¶meterized_block.else_contents, new_breadcrumbs.as_ref().unwrap_or(breadcrumbs), blocks, ); } } DustTag::DTHelperNotEquals(parameterized_block) => { let new_breadcrumbs = self.new_breadcrumbs_partial( breadcrumbs, breadcrumbs, None, ¶meterized_block.explicit_context, ); let param_map = ParametersContext::new(self, breadcrumbs, ¶meterized_block.params); // Special case: when comparing two RVPaths, if the // path is equal then dust assumes the values are // equal (otherwise, non-scalar values are // automatically not equal) if Self::are_paths_identical(¶m_map, "key", "value") { return match ¶meterized_block.else_contents { None => Ok("".to_owned()), Some(body) => { let rendered_content = self.render_body( body, new_breadcrumbs.as_ref().unwrap_or(breadcrumbs), blocks, )?; Ok(rendered_content) } }; } let left_side = match param_map .walk("key") .map(|ice| ice.into_context_element(self, breadcrumbs)) { Err(WalkError::CantWalk) | Ok(None) => return Ok("".to_owned()), Ok(Some(res)) => res, }; let right_side = param_map .walk("value") .map(|ice| ice.into_context_element(self, breadcrumbs)); if Ok(Some(left_side.get_context_element_reference())) != right_side.as_ref().map(|maybe_ice| { maybe_ice .as_ref() .map(|ice| ice.get_context_element_reference()) }) { return self.render_maybe_body( ¶meterized_block.contents, new_breadcrumbs.as_ref().unwrap_or(breadcrumbs), blocks, ); } else { return self.render_maybe_body( ¶meterized_block.else_contents, new_breadcrumbs.as_ref().unwrap_or(breadcrumbs), blocks, ); } } DustTag::DTHelperGreaterThan(parameterized_block) => { let new_breadcrumbs = self.new_breadcrumbs_partial( breadcrumbs, breadcrumbs, None, ¶meterized_block.explicit_context, ); let param_map = ParametersContext::new(self, breadcrumbs, ¶meterized_block.params); let left_side = match param_map .walk("key") .map(|ice| ice.into_context_element(self, breadcrumbs)) { Err(WalkError::CantWalk) | Ok(None) => return Ok("".to_owned()), Ok(Some(res)) => res, }; let right_side = param_map .walk("value") .map(|ice| ice.into_context_element(self, breadcrumbs)); match (right_side) { Ok(Some(right_side_unwrapped)) => { if left_side.get_context_element_reference() > right_side_unwrapped.get_context_element_reference() { return self.render_maybe_body( ¶meterized_block.contents, new_breadcrumbs.as_ref().unwrap_or(breadcrumbs), blocks, ); } else { return self.render_maybe_body( ¶meterized_block.else_contents, new_breadcrumbs.as_ref().unwrap_or(breadcrumbs), blocks, ); } } _ => { return self.render_maybe_body( ¶meterized_block.else_contents, new_breadcrumbs.as_ref().unwrap_or(breadcrumbs), blocks, ) } } } DustTag::DTHelperGreaterThanOrEquals(parameterized_block) => { let new_breadcrumbs = self.new_breadcrumbs_partial( breadcrumbs, breadcrumbs, None, ¶meterized_block.explicit_context, ); let param_map = ParametersContext::new(self, breadcrumbs, ¶meterized_block.params); let left_side = match param_map .walk("key") .map(|ice| ice.into_context_element(self, breadcrumbs)) { Err(WalkError::CantWalk) | Ok(None) => return Ok("".to_owned()), Ok(Some(res)) => res, }; let right_side = param_map .walk("value") .map(|ice| ice.into_context_element(self, breadcrumbs)); match (right_side) { Ok(Some(right_side_unwrapped)) => { if left_side.get_context_element_reference() >= right_side_unwrapped.get_context_element_reference() { return self.render_maybe_body( ¶meterized_block.contents, new_breadcrumbs.as_ref().unwrap_or(breadcrumbs), blocks, ); } else { return self.render_maybe_body( ¶meterized_block.else_contents, new_breadcrumbs.as_ref().unwrap_or(breadcrumbs), blocks, ); } } _ => { return self.render_maybe_body( ¶meterized_block.else_contents, new_breadcrumbs.as_ref().unwrap_or(breadcrumbs), blocks, ) } } } DustTag::DTHelperLessThan(parameterized_block) => { let new_breadcrumbs = self.new_breadcrumbs_partial( breadcrumbs, breadcrumbs, None, ¶meterized_block.explicit_context, ); let param_map = ParametersContext::new(self, breadcrumbs, ¶meterized_block.params); let left_side = match param_map .walk("key") .map(|ice| ice.into_context_element(self, breadcrumbs)) { Err(WalkError::CantWalk) | Ok(None) => return Ok("".to_owned()), Ok(Some(res)) => res, }; let right_side = param_map .walk("value") .map(|ice| ice.into_context_element(self, breadcrumbs)); match (right_side) { Ok(Some(right_side_unwrapped)) => { if left_side.get_context_element_reference() < right_side_unwrapped.get_context_element_reference() { return self.render_maybe_body( ¶meterized_block.contents, new_breadcrumbs.as_ref().unwrap_or(breadcrumbs), blocks, ); } else { return self.render_maybe_body( ¶meterized_block.else_contents, new_breadcrumbs.as_ref().unwrap_or(breadcrumbs), blocks, ); } } _ => { return self.render_maybe_body( ¶meterized_block.else_contents, new_breadcrumbs.as_ref().unwrap_or(breadcrumbs), blocks, ) } } } DustTag::DTHelperLessThanOrEquals(parameterized_block) => { let new_breadcrumbs = self.new_breadcrumbs_partial( breadcrumbs, breadcrumbs, None, ¶meterized_block.explicit_context, ); let param_map = ParametersContext::new(self, breadcrumbs, ¶meterized_block.params); let left_side = match param_map .walk("key") .map(|ice| ice.into_context_element(self, breadcrumbs)) { Err(WalkError::CantWalk) | Ok(None) => return Ok("".to_owned()), Ok(Some(res)) => res, }; let right_side = param_map .walk("value") .map(|ice| ice.into_context_element(self, breadcrumbs)); match (right_side) { Ok(Some(right_side_unwrapped)) => { if left_side.get_context_element_reference() <= right_side_unwrapped.get_context_element_reference() { return self.render_maybe_body( ¶meterized_block.contents, new_breadcrumbs.as_ref().unwrap_or(breadcrumbs), blocks, ); } else { return self.render_maybe_body( ¶meterized_block.else_contents, new_breadcrumbs.as_ref().unwrap_or(breadcrumbs), blocks, ); } } _ => { return self.render_maybe_body( ¶meterized_block.else_contents, new_breadcrumbs.as_ref().unwrap_or(breadcrumbs), blocks, ) } } } _ => panic!("Unsupported tag"), } Ok("".to_owned()) } fn new_breadcrumbs_section<'b>( &'b self, breadcrumbs: &'b Vec>, index_context: Option<&'b dyn IntoContextElement>, injected_context: Option<&'b dyn IntoContextElement>, explicit_context: &Option>, new_context_element: Option<&'b dyn ContextElement>, ) -> Option>> { // If none of the additional contexts are present, return None // to signal that the original breadcrumbs should be used // rather than incurring a copy here. match ( index_context, injected_context, explicit_context, new_context_element, ) { (None, None, None, None) => return None, _ => (), } // If there is an explicit context, then drop all the current // context let mut new_stack = match explicit_context { Some(_) => Vec::with_capacity(4), None => breadcrumbs.clone(), }; explicit_context.as_ref().map(|path| { walk_path(breadcrumbs, &path.keys) .map(|ice| ice.into_context_element(self, breadcrumbs)) .ok() .flatten() .map(|val| { if val.get_context_element_reference().is_truthy() { new_stack.push(std::convert::From::from(val)) } }); }); injected_context.map(|ctx| new_stack.push(BreadcrumbTreeElement::from_borrowed(ctx))); new_context_element.map(|ctx| { new_stack.push(BreadcrumbTreeElement::from_borrowed( ctx.from_context_element(), )) }); index_context.map(|ctx| new_stack.push(BreadcrumbTreeElement::from_borrowed(ctx))); Some(new_stack) } fn new_breadcrumbs_partial<'b>( &'b self, breadcrumbs: &'b Vec>, explicit_context_breadcrumbs: &'a Vec>, injected_context: Option<&'b dyn IntoContextElement>, explicit_context: &Option>, ) -> Option>> { // If none of the additional contexts are present, return None // to signal that the original breadcrumbs should be used // rather than incurring a copy here. match (injected_context, explicit_context) { (None, None) => return None, _ => (), }; // If there is an explicit context, then drop all the current // context let mut new_stack = match explicit_context { Some(_) => Vec::with_capacity(3), None => breadcrumbs.clone(), }; injected_context.map(|ctx| { // Special case: when there is no explicit context, the // injected context gets inserted 1 spot behind the // current context. Otherwise, the injected context gets // added after the current context but before the explicit // context. match explicit_context { None => new_stack.insert( Self::get_index_of_first_non_pseudo_element(&new_stack).unwrap_or(0), BreadcrumbTreeElement::from_borrowed(ctx), ), _ => new_stack.push(BreadcrumbTreeElement::from_borrowed(ctx)), } }); explicit_context.as_ref().map(|path| { // TODO: should resolving the value here use // explicit_context_maybe_breadcrumbs or // maybe_breadcrumbs? walk_path(explicit_context_breadcrumbs, &path.keys) .map(|ice| ice.into_context_element(self, breadcrumbs)) .ok() .flatten() .map(|val| { if val.get_context_element_reference().is_truthy() { new_stack.push(std::convert::From::from(val)); } }); }); Some(new_stack) } fn are_paths_identical<'b>( param_map: &ParametersContext<'b>, left_key: &str, right_key: &str, ) -> bool { match ( param_map.get_original_rvalue(left_key), param_map.get_original_rvalue(right_key), ) { (None, _) => false, (_, None) => false, (Some(key_rval), Some(value_rval)) => match (key_rval, value_rval) { (RValue::RVPath(key_path), RValue::RVPath(value_path)) => { key_path.keys == value_path.keys } _ => false, }, } } fn preprocess_filters(filters: &Vec) -> Vec { let mut final_filters: Vec = filters .into_iter() .filter(|f| f != &&Filter::DisableHtmlEncode) .map(|f| f.clone()) .collect(); // If the user has not specified any escaping filter (|s or // |h), automatically add an html escape filter if !filters.iter().any(|f| f == &Filter::DisableHtmlEncode) { final_filters.push(Filter::HtmlEncode); } final_filters } fn get_index_of_first_non_pseudo_element<'b>( breadcrumbs: &'b Vec>, ) -> Option { breadcrumbs.iter().rposition(|b| { !std::borrow::Borrow::::borrow(b).is_pseudo_element() }) } } struct BlockContext<'a> { /// The breadcrumbs at the time of entering the current partial breadcrumbs: &'a Vec>, blocks: &'a InlinePartialTreeElement<'a>, }