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

Ported over the comparison helpers to using the new tap function.

Browse Source
This commit is contained in:
Tom Alexander 2020-06-07 16:49:15 -04:00
parent b35874f19e
commit a749f91e8e
Signed by: talexander
GPG Key ID: D3A179C9A53C0EDE
1 changed files with 191 additions and 215 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

406
src/renderer/renderer.rs
View File

@ -375,43 +375,46 @@ impl<'a> DustRenderer<'a> {
let param_map = let param_map =
ParametersContext::new(self, breadcrumbs, &parameterized_block.params); ParametersContext::new(self, breadcrumbs, &parameterized_block.params);
if !param_map.contains_key("key") { let left_side = self.tap(breadcrumbs, &param_map, "key");
return Ok("".to_owned()); let right_side = self.tap(breadcrumbs, &param_map, "value");
}
let left_side = param_map let left_side_ce = left_side.as_ref().map(|maybe_ice| {
.walk("key") maybe_ice
.map(|ice| ice.into_context_element(self, breadcrumbs)); .as_ref()
let right_side = param_map .map(|ice| ice.get_context_element_reference())
.walk("value") });
.map(|ice| ice.into_context_element(self, breadcrumbs)); let right_side_ce = right_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 });
// (javascript object equality). return match (left_side_ce, right_side_ce) {
if Self::are_paths_identical(&left_side, &right_side) // If "key" is not present at all, return a blank string
|| left_side.as_ref().map(|maybe_ice| { (None, _) => Ok("".to_owned()),
maybe_ice (Some(_maybe_left_ce), _) => {
.as_ref() // Special case: when comparing two RVPaths, if the
.map(|ice| ice.get_context_element_reference()) // path points to the same value then they are
}) == right_side.as_ref().map(|maybe_ice| { // equal. This is particularly important for objects
maybe_ice // which compare memory locations rather than contents
.as_ref() // (javascript object equality).
.map(|ice| ice.get_context_element_reference()) if Self::are_paths_identical(&left_side_ce, &right_side_ce)
}) || left_side_ce.unwrap_or(Err(&WalkError::CantWalk))
{ == right_side_ce.unwrap_or(Err(&WalkError::CantWalk))
return self.render_maybe_body( {
&parameterized_block.contents, self.render_maybe_body(
new_breadcrumbs.as_ref().unwrap_or(breadcrumbs), &parameterized_block.contents,
blocks, new_breadcrumbs.as_ref().unwrap_or(breadcrumbs),
); blocks,
} else { )
return self.render_maybe_body( } else {
&parameterized_block.else_contents, self.render_maybe_body(
new_breadcrumbs.as_ref().unwrap_or(breadcrumbs), &parameterized_block.else_contents,
blocks, new_breadcrumbs.as_ref().unwrap_or(breadcrumbs),
); blocks,
} )
}
}
};
} }
DustTag::DTHelperNotEquals(parameterized_block) => { DustTag::DTHelperNotEquals(parameterized_block) => {
let new_breadcrumbs = self.new_breadcrumbs_partial( let new_breadcrumbs = self.new_breadcrumbs_partial(
@ -424,43 +427,46 @@ impl<'a> DustRenderer<'a> {
let param_map = let param_map =
ParametersContext::new(self, breadcrumbs, &parameterized_block.params); ParametersContext::new(self, breadcrumbs, &parameterized_block.params);
if !param_map.contains_key("key") { let left_side = self.tap(breadcrumbs, &param_map, "key");
return Ok("".to_owned()); let right_side = self.tap(breadcrumbs, &param_map, "value");
}
let left_side = param_map let left_side_ce = left_side.as_ref().map(|maybe_ice| {
.walk("key") maybe_ice
.map(|ice| ice.into_context_element(self, breadcrumbs)); .as_ref()
let right_side = param_map .map(|ice| ice.get_context_element_reference())
.walk("value") });
.map(|ice| ice.into_context_element(self, breadcrumbs)); let right_side_ce = right_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 });
// (javascript object equality). return match (left_side_ce, right_side_ce) {
if Self::are_paths_identical(&left_side, &right_side) // If "key" is not present at all, return a blank string
|| left_side.as_ref().map(|maybe_ice| { (None, _) => Ok("".to_owned()),
maybe_ice (Some(_maybe_left_ce), _) => {
.as_ref() // Special case: when comparing two RVPaths, if the
.map(|ice| ice.get_context_element_reference()) // path points to the same value then they are
}) == right_side.as_ref().map(|maybe_ice| { // equal. This is particularly important for objects
maybe_ice // which compare memory locations rather than contents
.as_ref() // (javascript object equality).
.map(|ice| ice.get_context_element_reference()) if Self::are_paths_identical(&left_side_ce, &right_side_ce)
}) || left_side_ce.unwrap_or(Err(&WalkError::CantWalk))
{ == right_side_ce.unwrap_or(Err(&WalkError::CantWalk))
return self.render_maybe_body( {
&parameterized_block.else_contents, self.render_maybe_body(
new_breadcrumbs.as_ref().unwrap_or(breadcrumbs), &parameterized_block.else_contents,
blocks, new_breadcrumbs.as_ref().unwrap_or(breadcrumbs),
); blocks,
} else { )
return self.render_maybe_body( } else {
&parameterized_block.contents, self.render_maybe_body(
new_breadcrumbs.as_ref().unwrap_or(breadcrumbs), &parameterized_block.contents,
blocks, new_breadcrumbs.as_ref().unwrap_or(breadcrumbs),
); blocks,
} )
}
}
};
} }
DustTag::DTHelperGreaterThan(parameterized_block) => { DustTag::DTHelperGreaterThan(parameterized_block) => {
let new_breadcrumbs = self.new_breadcrumbs_partial( let new_breadcrumbs = self.new_breadcrumbs_partial(
@ -472,41 +478,36 @@ impl<'a> DustRenderer<'a> {
let param_map = let param_map =
ParametersContext::new(self, breadcrumbs, &parameterized_block.params); ParametersContext::new(self, breadcrumbs, &parameterized_block.params);
if !param_map.contains_key("key") {
return Ok("".to_owned()); let left_side = self.tap(breadcrumbs, &param_map, "key");
} let right_side = self.tap(breadcrumbs, &param_map, "value");
let left_side = param_map
.walk("key") let left_side_ce = left_side.as_ref().map(|maybe_ice| {
.map(|ice| ice.into_context_element(self, breadcrumbs)); maybe_ice
let right_side = param_map .as_ref()
.walk("value") .map(|ice| ice.get_context_element_reference())
.map(|ice| ice.into_context_element(self, breadcrumbs)); });
match (left_side, right_side) { let right_side_ce = right_side.as_ref().map(|maybe_ice| {
(Ok(Some(left_side_unwrapped)), Ok(Some(right_side_unwrapped))) => { maybe_ice
if left_side_unwrapped.get_context_element_reference() .as_ref()
> right_side_unwrapped.get_context_element_reference() .map(|ice| ice.get_context_element_reference())
{ });
return self.render_maybe_body( return match (left_side_ce, right_side_ce) {
&parameterized_block.contents, // If "key" is not present at all, return a blank string
new_breadcrumbs.as_ref().unwrap_or(breadcrumbs), (None, _) => Ok("".to_owned()),
blocks, (Some(Ok(left_value)), Some(Ok(right_value))) if left_value > right_value => {
); self.render_maybe_body(
} else { &parameterized_block.contents,
return self.render_maybe_body(
&parameterized_block.else_contents,
new_breadcrumbs.as_ref().unwrap_or(breadcrumbs),
blocks,
);
}
}
_ => {
return self.render_maybe_body(
&parameterized_block.else_contents,
new_breadcrumbs.as_ref().unwrap_or(breadcrumbs), new_breadcrumbs.as_ref().unwrap_or(breadcrumbs),
blocks, blocks,
) )
} }
} _ => self.render_maybe_body(
&parameterized_block.else_contents,
new_breadcrumbs.as_ref().unwrap_or(breadcrumbs),
blocks,
),
};
} }
DustTag::DTHelperGreaterThanOrEquals(parameterized_block) => { DustTag::DTHelperGreaterThanOrEquals(parameterized_block) => {
let new_breadcrumbs = self.new_breadcrumbs_partial( let new_breadcrumbs = self.new_breadcrumbs_partial(
@ -518,41 +519,36 @@ impl<'a> DustRenderer<'a> {
let param_map = let param_map =
ParametersContext::new(self, breadcrumbs, &parameterized_block.params); ParametersContext::new(self, breadcrumbs, &parameterized_block.params);
if !param_map.contains_key("key") {
return Ok("".to_owned()); let left_side = self.tap(breadcrumbs, &param_map, "key");
} let right_side = self.tap(breadcrumbs, &param_map, "value");
let left_side = param_map
.walk("key") let left_side_ce = left_side.as_ref().map(|maybe_ice| {
.map(|ice| ice.into_context_element(self, breadcrumbs)); maybe_ice
let right_side = param_map .as_ref()
.walk("value") .map(|ice| ice.get_context_element_reference())
.map(|ice| ice.into_context_element(self, breadcrumbs)); });
match (left_side, right_side) { let right_side_ce = right_side.as_ref().map(|maybe_ice| {
(Ok(Some(left_side_unwrapped)), Ok(Some(right_side_unwrapped))) => { maybe_ice
if left_side_unwrapped.get_context_element_reference() .as_ref()
>= right_side_unwrapped.get_context_element_reference() .map(|ice| ice.get_context_element_reference())
{ });
return self.render_maybe_body( return match (left_side_ce, right_side_ce) {
&parameterized_block.contents, // If "key" is not present at all, return a blank string
new_breadcrumbs.as_ref().unwrap_or(breadcrumbs), (None, _) => Ok("".to_owned()),
blocks, (Some(Ok(left_value)), Some(Ok(right_value))) if left_value >= right_value => {
); self.render_maybe_body(
} else { &parameterized_block.contents,
return self.render_maybe_body(
&parameterized_block.else_contents,
new_breadcrumbs.as_ref().unwrap_or(breadcrumbs),
blocks,
);
}
}
_ => {
return self.render_maybe_body(
&parameterized_block.else_contents,
new_breadcrumbs.as_ref().unwrap_or(breadcrumbs), new_breadcrumbs.as_ref().unwrap_or(breadcrumbs),
blocks, blocks,
) )
} }
} _ => self.render_maybe_body(
&parameterized_block.else_contents,
new_breadcrumbs.as_ref().unwrap_or(breadcrumbs),
blocks,
),
};
} }
DustTag::DTHelperLessThan(parameterized_block) => { DustTag::DTHelperLessThan(parameterized_block) => {
let new_breadcrumbs = self.new_breadcrumbs_partial( let new_breadcrumbs = self.new_breadcrumbs_partial(
@ -564,41 +560,36 @@ impl<'a> DustRenderer<'a> {
let param_map = let param_map =
ParametersContext::new(self, breadcrumbs, &parameterized_block.params); ParametersContext::new(self, breadcrumbs, &parameterized_block.params);
if !param_map.contains_key("key") {
return Ok("".to_owned()); let left_side = self.tap(breadcrumbs, &param_map, "key");
} let right_side = self.tap(breadcrumbs, &param_map, "value");
let left_side = param_map
.walk("key") let left_side_ce = left_side.as_ref().map(|maybe_ice| {
.map(|ice| ice.into_context_element(self, breadcrumbs)); maybe_ice
let right_side = param_map .as_ref()
.walk("value") .map(|ice| ice.get_context_element_reference())
.map(|ice| ice.into_context_element(self, breadcrumbs)); });
match (left_side, right_side) { let right_side_ce = right_side.as_ref().map(|maybe_ice| {
(Ok(Some(left_side_unwrapped)), Ok(Some(right_side_unwrapped))) => { maybe_ice
if left_side_unwrapped.get_context_element_reference() .as_ref()
< right_side_unwrapped.get_context_element_reference() .map(|ice| ice.get_context_element_reference())
{ });
return self.render_maybe_body( return match (left_side_ce, right_side_ce) {
&parameterized_block.contents, // If "key" is not present at all, return a blank string
new_breadcrumbs.as_ref().unwrap_or(breadcrumbs), (None, _) => Ok("".to_owned()),
blocks, (Some(Ok(left_value)), Some(Ok(right_value))) if left_value < right_value => {
); self.render_maybe_body(
} else { &parameterized_block.contents,
return self.render_maybe_body(
&parameterized_block.else_contents,
new_breadcrumbs.as_ref().unwrap_or(breadcrumbs),
blocks,
);
}
}
_ => {
return self.render_maybe_body(
&parameterized_block.else_contents,
new_breadcrumbs.as_ref().unwrap_or(breadcrumbs), new_breadcrumbs.as_ref().unwrap_or(breadcrumbs),
blocks, blocks,
) )
} }
} _ => self.render_maybe_body(
&parameterized_block.else_contents,
new_breadcrumbs.as_ref().unwrap_or(breadcrumbs),
blocks,
),
};
} }
DustTag::DTHelperLessThanOrEquals(parameterized_block) => { DustTag::DTHelperLessThanOrEquals(parameterized_block) => {
let new_breadcrumbs = self.new_breadcrumbs_partial( let new_breadcrumbs = self.new_breadcrumbs_partial(
@ -610,41 +601,36 @@ impl<'a> DustRenderer<'a> {
let param_map = let param_map =
ParametersContext::new(self, breadcrumbs, &parameterized_block.params); ParametersContext::new(self, breadcrumbs, &parameterized_block.params);
if !param_map.contains_key("key") {
return Ok("".to_owned()); let left_side = self.tap(breadcrumbs, &param_map, "key");
} let right_side = self.tap(breadcrumbs, &param_map, "value");
let left_side = param_map
.walk("key") let left_side_ce = left_side.as_ref().map(|maybe_ice| {
.map(|ice| ice.into_context_element(self, breadcrumbs)); maybe_ice
let right_side = param_map .as_ref()
.walk("value") .map(|ice| ice.get_context_element_reference())
.map(|ice| ice.into_context_element(self, breadcrumbs)); });
match (left_side, right_side) { let right_side_ce = right_side.as_ref().map(|maybe_ice| {
(Ok(Some(left_side_unwrapped)), Ok(Some(right_side_unwrapped))) => { maybe_ice
if left_side_unwrapped.get_context_element_reference() .as_ref()
<= right_side_unwrapped.get_context_element_reference() .map(|ice| ice.get_context_element_reference())
{ });
return self.render_maybe_body( return match (left_side_ce, right_side_ce) {
&parameterized_block.contents, // If "key" is not present at all, return a blank string
new_breadcrumbs.as_ref().unwrap_or(breadcrumbs), (None, _) => Ok("".to_owned()),
blocks, (Some(Ok(left_value)), Some(Ok(right_value))) if left_value <= right_value => {
); self.render_maybe_body(
} else { &parameterized_block.contents,
return self.render_maybe_body(
&parameterized_block.else_contents,
new_breadcrumbs.as_ref().unwrap_or(breadcrumbs),
blocks,
);
}
}
_ => {
return self.render_maybe_body(
&parameterized_block.else_contents,
new_breadcrumbs.as_ref().unwrap_or(breadcrumbs), new_breadcrumbs.as_ref().unwrap_or(breadcrumbs),
blocks, blocks,
) )
} }
} _ => self.render_maybe_body(
&parameterized_block.else_contents,
new_breadcrumbs.as_ref().unwrap_or(breadcrumbs),
blocks,
),
};
} }
DustTag::DTHelperSep(parameterized_block) => { DustTag::DTHelperSep(parameterized_block) => {
let new_breadcrumbs = self.new_breadcrumbs_partial( let new_breadcrumbs = self.new_breadcrumbs_partial(
@ -803,13 +789,13 @@ impl<'a> DustRenderer<'a> {
name: &P, name: &P,
) -> Option<Result<IceResult<'a>, WalkError>> ) -> Option<Result<IceResult<'a>, WalkError>>
where where
P: Borrow<str>, P: AsRef<str> + ?Sized,
{ {
if !parameters.contains_key(name.borrow()) { if !parameters.contains_key(name.as_ref()) {
return None; return None;
} }
let val = parameters let val = parameters
.walk("key") .walk(name.as_ref())
.map(|ice| ice.into_context_element(self, breadcrumbs)); .map(|ice| ice.into_context_element(self, breadcrumbs));
match val { match val {
Ok(Some(ice_result)) => Some(Ok(ice_result)), Ok(Some(ice_result)) => Some(Ok(ice_result)),
@ -924,21 +910,11 @@ impl<'a> DustRenderer<'a> {
} }
fn are_paths_identical<'b>( fn are_paths_identical<'b>(
left_side: &Result<Option<IceResult<'b>>, WalkError>, left_side: &Option<Result<&dyn ContextElement, &WalkError>>,
right_side: &Result<Option<IceResult<'b>>, WalkError>, right_side: &Option<Result<&dyn ContextElement, &WalkError>>,
) -> bool { ) -> bool {
let left_resolved = left_side.as_ref().map(|maybe_ice| { match (left_side, right_side) {
maybe_ice (Some(Ok(lce)), Some(Ok(rce))) => (*lce) as *const _ == (*rce) as *const _,
.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, _ => false,
} }
} }