talexander/duster
1
0
Fork 0
Code Issues Pull Requests Releases Activity

All tests working.

Browse Source
This commit is contained in:
Tom Alexander 2020-06-07 01:35:58 -04:00
parent 865cba6f4e
commit 4e1259f1c7
Signed by: talexander
GPG Key ID: D3A179C9A53C0EDE
1 changed files with 55 additions and 56 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

111
src/renderer/renderer.rs
View File

@ -11,6 +11,7 @@ use crate::parser::Template;
use crate::parser::TemplateElement; use crate::parser::TemplateElement;
use crate::renderer::breadcrumb_tree::BreadcrumbTreeElement; use crate::renderer::breadcrumb_tree::BreadcrumbTreeElement;
use crate::renderer::context_element::ContextElement; use crate::renderer::context_element::ContextElement;
use crate::renderer::context_element::IceResult;
use crate::renderer::context_element::IntoContextElement; use crate::renderer::context_element::IntoContextElement;
use crate::renderer::context_element::Walkable; use crate::renderer::context_element::Walkable;
use crate::renderer::errors::CompileError; use crate::renderer::errors::CompileError;
@ -376,24 +377,6 @@ impl<'a> DustRenderer<'a> {
let param_map = let param_map =
ParametersContext::new(self, breadcrumbs, &parameterized_block.params); ParametersContext::new(self, breadcrumbs, &parameterized_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(&param_map, "key", "value") {
return match &parameterized_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)
}
};
}
if !param_map.contains_key("key") { if !param_map.contains_key("key") {
return Ok("".to_owned()); return Ok("".to_owned());
} }
@ -403,15 +386,22 @@ impl<'a> DustRenderer<'a> {
let right_side = param_map let right_side = param_map
.walk("value") .walk("value")
.map(|ice| ice.into_context_element(self, breadcrumbs)); .map(|ice| ice.into_context_element(self, breadcrumbs));
if left_side.as_ref().map(|maybe_ice| { // Special case: when comparing two RVPaths, if the
maybe_ice // path points to the same value then they are
.as_ref() // equal. This is particularly important for objects
.map(|ice| ice.get_context_element_reference()) // which compare memory locations rather than contents
}) == right_side.as_ref().map(|maybe_ice| { // (javascript object equality).
maybe_ice if Self::new_are_paths_identical(&left_side, &right_side)
.as_ref() || left_side.as_ref().map(|maybe_ice| {
.map(|ice| ice.get_context_element_reference()) maybe_ice
}) { .as_ref()
.map(|ice| ice.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( return self.render_maybe_body(
&parameterized_block.contents, &parameterized_block.contents,
new_breadcrumbs.as_ref().unwrap_or(breadcrumbs), new_breadcrumbs.as_ref().unwrap_or(breadcrumbs),
@ -436,24 +426,6 @@ impl<'a> DustRenderer<'a> {
let param_map = let param_map =
ParametersContext::new(self, breadcrumbs, &parameterized_block.params); ParametersContext::new(self, breadcrumbs, &parameterized_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(&param_map, "key", "value") {
return match &parameterized_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)
}
};
}
if !param_map.contains_key("key") { if !param_map.contains_key("key") {
return Ok("".to_owned()); return Ok("".to_owned());
} }
@ -463,23 +435,30 @@ impl<'a> DustRenderer<'a> {
let right_side = param_map let right_side = param_map
.walk("value") .walk("value")
.map(|ice| ice.into_context_element(self, breadcrumbs)); .map(|ice| ice.into_context_element(self, breadcrumbs));
if left_side.as_ref().map(|maybe_ice| { // Special case: when comparing two RVPaths, if the
maybe_ice // path points to the same value then they are
.as_ref() // equal. This is particularly important for objects
.map(|ice| ice.get_context_element_reference()) // which compare memory locations rather than contents
}) != right_side.as_ref().map(|maybe_ice| { // (javascript object equality).
maybe_ice if Self::new_are_paths_identical(&left_side, &right_side)
.as_ref() || left_side.as_ref().map(|maybe_ice| {
.map(|ice| ice.get_context_element_reference()) maybe_ice
}) { .as_ref()
.map(|ice| ice.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( return self.render_maybe_body(
&parameterized_block.contents, &parameterized_block.else_contents,
new_breadcrumbs.as_ref().unwrap_or(breadcrumbs), new_breadcrumbs.as_ref().unwrap_or(breadcrumbs),
blocks, blocks,
); );
} else { } else {
return self.render_maybe_body( return self.render_maybe_body(
&parameterized_block.else_contents, &parameterized_block.contents,
new_breadcrumbs.as_ref().unwrap_or(breadcrumbs), new_breadcrumbs.as_ref().unwrap_or(breadcrumbs),
blocks, blocks,
); );
@ -800,6 +779,26 @@ impl<'a> DustRenderer<'a> {
} }
} }
fn new_are_paths_identical<'b>(
left_side: &Result<Option<IceResult<'b>>, WalkError>,
right_side: &Result<Option<IceResult<'b>>, WalkError>,
) -> bool {
let left_resolved = left_side.as_ref().map(|maybe_ice| {
maybe_ice
.as_ref()
.map(|ice| ice.get_context_element_reference())
});
let right_resolved = right_side.as_ref().map(|maybe_ice| {
maybe_ice
.as_ref()
.map(|ice| ice.get_context_element_reference())
});
match (left_resolved, right_resolved) {
(Ok(Some(lce)), Ok(Some(rce))) => lce as *const _ == rce as *const _,
_ => false,
}
}
fn preprocess_filters(filters: &Vec<Filter>) -> Vec<Filter> { fn preprocess_filters(filters: &Vec<Filter>) -> Vec<Filter> {
let mut final_filters: Vec<Filter> = filters let mut final_filters: Vec<Filter> = filters
.into_iter() .into_iter()