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

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

Browse Source
master
Tom Alexander 4 years ago
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

406
src/renderer/renderer.rs
Unescape Escape View File

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

Write Preview
Loading…
Cancel
Save