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

All tests passing!

Browse Source
This commit is contained in:
Tom Alexander 2020-06-07 01:04:00 -04:00
parent 4789a7d931
commit b1a85165b0
Signed by: talexander
GPG Key ID: D3A179C9A53C0EDE
2 changed files with 89 additions and 88 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

55
src/renderer/parameters_context.rs
View File

@ -22,7 +22,7 @@ use std::rc::Rc;
#[derive(Debug)]
pub struct ParametersContext<'a> {
params: HashMap<&'a str, (&'a RValue<'a>, BreadcrumbTreeElement<'a>)>,
params: HashMap<&'a str, (&'a RValue<'a>, Option<BreadcrumbTreeElement<'a>>)>,
}
impl<'a> ParametersContext<'a> {
@ -39,27 +39,26 @@ impl<'a> ParametersContext<'a> {
// then those are resolved at the time of access rather than
// the time of assignment, so we leave them into their
// original IntoContextElement state.
let rendered_params: HashMap<&'a str, (&'a RValue<'a>, BreadcrumbTreeElement<'a>)> = params
.iter()
.map(|kvpair| {
let k = kvpair.key;
let v: Option<BreadcrumbTreeElement<'a>> = match &kvpair.value {
RValue::RVLiteral(owned_literal) => {
Some(BreadcrumbTreeElement::from_borrowed(&kvpair.value))
}
RValue::RVPath(path) => kvpair
.value
.into_context_element(renderer, breadcrumbs)
.map(std::convert::From::from),
RValue::RVTemplate(template) => {
Some(BreadcrumbTreeElement::from_borrowed(&kvpair.value))
}
};
v.map(|some_v| (k, (&kvpair.value, some_v)))
})
// TODO: Should a None value here be the same as a key not existing, or should we store the Nones?
.filter_map(|pair| pair)
.collect();
let rendered_params: HashMap<&'a str, (&'a RValue<'a>, Option<BreadcrumbTreeElement<'a>>)> =
params
.iter()
.map(|kvpair| {
let k = kvpair.key;
let v: Option<BreadcrumbTreeElement<'a>> = match &kvpair.value {
RValue::RVLiteral(owned_literal) => {
Some(BreadcrumbTreeElement::from_borrowed(&kvpair.value))
}
RValue::RVPath(path) => kvpair
.value
.into_context_element(renderer, breadcrumbs)
.map(std::convert::From::from),
RValue::RVTemplate(template) => {
Some(BreadcrumbTreeElement::from_borrowed(&kvpair.value))
}
};
(k, (&kvpair.value, v))
})
.collect();
ParametersContext {
params: rendered_params,
@ -69,6 +68,10 @@ impl<'a> ParametersContext<'a> {
pub fn get_original_rvalue(&self, segment: &str) -> Option<&'a RValue<'a>> {
self.params.get(segment).map(|(rvalue, _bte)| *rvalue)
}
pub fn contains_key(&self, segment: &str) -> bool {
self.params.contains_key(segment)
}
}
impl<'a> IntoContextElement for ParametersContext<'a> {
@ -83,10 +86,10 @@ impl<'a> IntoContextElement for ParametersContext<'a> {
impl<'a> Walkable for ParametersContext<'a> {
fn walk(&self, segment: &str) -> Result<&dyn IntoContextElement, WalkError> {
self.params
.get(segment)
.map(|(_rvalue, bte)| bte.borrow())
.ok_or(WalkError::CantWalk)
match self.params.get(segment).map(|(_rvalue, bte)| bte) {
Some(Some(bte)) => Ok(bte.borrow()),
_ => Err(WalkError::CantWalk),
}
}
fn is_pseudo_element(&self) -> bool {

122
src/renderer/renderer.rs
View File

@ -394,23 +394,24 @@ impl<'a> DustRenderer<'a> {
};
}
let left_side = match param_map
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))
{
Err(WalkError::CantWalk) | Ok(None) => return Ok("".to_owned()),
Ok(Some(res)) => res,
};
.map(|ice| ice.into_context_element(self, breadcrumbs));
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())
})
{
if 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),
@ -453,23 +454,24 @@ impl<'a> DustRenderer<'a> {
};
}
let left_side = match param_map
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))
{
Err(WalkError::CantWalk) | Ok(None) => return Ok("".to_owned()),
Ok(Some(res)) => res,
};
.map(|ice| ice.into_context_element(self, breadcrumbs));
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())
})
{
if 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),
@ -493,19 +495,18 @@ impl<'a> DustRenderer<'a> {
let param_map =
ParametersContext::new(self, breadcrumbs, &parameterized_block.params);
let left_side = match param_map
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))
{
Err(WalkError::CantWalk) | Ok(None) => return Ok("".to_owned()),
Ok(Some(res)) => res,
};
.map(|ice| ice.into_context_element(self, breadcrumbs));
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()
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(
@ -540,19 +541,18 @@ impl<'a> DustRenderer<'a> {
let param_map =
ParametersContext::new(self, breadcrumbs, &parameterized_block.params);
let left_side = match param_map
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))
{
Err(WalkError::CantWalk) | Ok(None) => return Ok("".to_owned()),
Ok(Some(res)) => res,
};
.map(|ice| ice.into_context_element(self, breadcrumbs));
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()
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(
@ -587,19 +587,18 @@ impl<'a> DustRenderer<'a> {
let param_map =
ParametersContext::new(self, breadcrumbs, &parameterized_block.params);
let left_side = match param_map
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))
{
Err(WalkError::CantWalk) | Ok(None) => return Ok("".to_owned()),
Ok(Some(res)) => res,
};
.map(|ice| ice.into_context_element(self, breadcrumbs));
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()
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(
@ -634,19 +633,18 @@ impl<'a> DustRenderer<'a> {
let param_map =
ParametersContext::new(self, breadcrumbs, &parameterized_block.params);
let left_side = match param_map
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))
{
Err(WalkError::CantWalk) | Ok(None) => return Ok("".to_owned()),
Ok(Some(res)) => res,
};
.map(|ice| ice.into_context_element(self, breadcrumbs));
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()
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(