talexander/duster
1
0
Fork 0
Code Issues Pull Requests Releases Activity
duster/src/renderer/renderer.rs

901 lines
38 KiB
Rust
Raw Normal View History

compiling templates in the same manner as the shim
2020-04-10 20:27:27 -04:00
use crate::parser::template;
General structure to the rendering code.
2020-05-31 21:18:54 -04:00
use crate::parser::Body;
use crate::parser::DustTag;
Added back in reference.
2020-05-31 21:26:31 -04:00
use crate::parser::Filter;
Implemented the sep helper.
2020-06-07 15:09:37 -04:00
use crate::parser::OwnedLiteral;
General structure to the rendering code.
2020-05-31 21:18:54 -04:00
use crate::parser::PartialNameElement;
Add tests for explicit context setting that check failure conditions and implement a helper function to generate a new breadcrumb stack.
2020-05-25 15:40:42 -04:00
use crate::parser::Path;
Added back in reference.
2020-05-31 21:26:31 -04:00
use crate::parser::Special;
compiling templates in the same manner as the shim
2020-04-10 20:27:27 -04:00
use crate::parser::Template;
General structure to the rendering code.
2020-05-31 21:18:54 -04:00
use crate::parser::TemplateElement;
Replaced the old renderer file with a new renderer file.
2020-05-31 18:18:21 -04:00
use crate::renderer::breadcrumb_tree::BreadcrumbTreeElement;
Combine the render traits into a single context_element file.
2020-04-28 19:09:02 -04:00
use crate::renderer::context_element::ContextElement;
All tests working.
2020-06-07 01:35:58 -04:00
use crate::renderer::context_element::IceResult;
Starting an IntoContextElement trait to allow for delayed evaluation.
2020-05-30 16:34:32 -04:00
use crate::renderer::context_element::IntoContextElement;
port over the equals/not equals helpers.
2020-06-07 00:03:51 -04:00
use crate::renderer::context_element::Walkable;
Rendering spans
2020-04-11 18:25:48 -04:00
use crate::renderer::errors::CompileError;
General structure to the rendering code.
2020-05-31 21:18:54 -04:00
use crate::renderer::errors::RenderError;
Added back in reference.
2020-05-31 21:26:31 -04:00
use crate::renderer::errors::WalkError;
General structure to the rendering code.
2020-05-31 21:18:54 -04:00
use crate::renderer::inline_partial_tree::extract_inline_partials;
use crate::renderer::inline_partial_tree::InlinePartialTreeElement;
Update IterationContext to be an IntoContextElement and finish implementing section.
2020-06-06 23:08:21 -04:00
use crate::renderer::iteration_context::IterationContext;
Implement IntoContextElement for ParametersContext.
2020-06-06 20:48:29 -04:00
use crate::renderer::parameters_context::ParametersContext;
Remove unused code and clean up warnings.
2020-06-07 13:25:27 -04:00
use crate::renderer::walking::walk_path;
Implement get and tap functions.
2020-06-07 14:45:32 -04:00
use std::borrow::Borrow;
Automatically appending the html escape filter on the renderer side.
2020-05-23 17:57:19 -04:00
use std::collections::HashMap;
compiling templates in the same manner as the shim
2020-04-10 20:27:27 -04:00
Loading the compiled templates into a context
2020-04-10 20:55:44 -04:00
#[derive(Clone, Debug)]
Rename DustContext to DustRenderer
2020-04-10 20:58:55 -04:00
pub struct DustRenderer<'a> {
Rendering spans
2020-04-11 18:25:48 -04:00
templates: HashMap<String, &'a Template<'a>>,
Loading the compiled templates into a context
2020-04-10 20:55:44 -04:00
}
Got rid of most of the Clone traits on the parser types since some of the parser results now contain owned values rather than just references.
2020-05-31 19:01:51 -04:00
pub fn compile_template<'a>(source: &'a str) -> Result<Template<'a>, CompileError> {
Remove unused code and clean up warnings.
2020-06-07 13:25:27 -04:00
let (_remaining, parsed_template) = template(source).map_err(|_err| CompileError {
Got rid of most of the Clone traits on the parser types since some of the parser results now contain owned values rather than just references.
2020-05-31 19:01:51 -04:00
message: "Failed to compile template".to_owned(),
})?;
Ok(parsed_template)
compiling templates in the same manner as the shim
2020-04-10 20:27:27 -04:00
}
Loading the compiled templates into a context
2020-04-10 20:55:44 -04:00
Rename DustContext to DustRenderer
2020-04-10 20:58:55 -04:00
impl<'a> DustRenderer<'a> {
pub fn new() -> DustRenderer<'a> {
DustRenderer {
Rendering spans
2020-04-11 18:25:48 -04:00
templates: HashMap::new(),
Loading the compiled templates into a context
2020-04-10 20:55:44 -04:00
}
}
Got rid of most of the Clone traits on the parser types since some of the parser results now contain owned values rather than just references.
2020-05-31 19:01:51 -04:00
pub fn load_source(&mut self, template: &'a Template, name: String) {
self.templates.insert(name, template);
Loading the compiled templates into a context
2020-04-10 20:55:44 -04:00
}
Rename DustContext to DustRenderer
2020-04-10 20:58:55 -04:00
General structure to the rendering code.
2020-05-31 21:18:54 -04:00
pub fn render<C>(&'a self, name: &str, context: Option<&C>) -> Result<String, RenderError>
where
C: IntoContextElement,
{
Switching back to a Vec because inserting multiple elements into the linked list structure while maintaining ownership of each node proved to be difficult.
2020-06-06 22:24:27 -04:00
let breadcrumbs = context
.map(|ctx| vec![BreadcrumbTreeElement::from_borrowed(ctx)])
.unwrap_or(Vec::new());
General structure to the rendering code.
2020-05-31 21:18:54 -04:00
self.render_template(name, breadcrumbs.as_ref(), None)
}
pub fn render_template(
&'a self,
name: &str,
Switching back to a Vec because inserting multiple elements into the linked list structure while maintaining ownership of each node proved to be difficult.
2020-06-06 22:24:27 -04:00
breadcrumbs: &'a Vec<BreadcrumbTreeElement<'a>>,
General structure to the rendering code.
2020-05-31 21:18:54 -04:00
blocks: Option<&'a InlinePartialTreeElement<'a>>,
) -> Result<String, RenderError> {
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<Body>,
Switching back to a Vec because inserting multiple elements into the linked list structure while maintaining ownership of each node proved to be difficult.
2020-06-06 22:24:27 -04:00
breadcrumbs: &'a Vec<BreadcrumbTreeElement<'a>>,
General structure to the rendering code.
2020-05-31 21:18:54 -04:00
blocks: &'a BlockContext<'a>,
) -> Result<String, RenderError> {
match body {
None => Ok("".to_owned()),
Some(body) => Ok(self.render_body(body, breadcrumbs, blocks)?),
}
}
fn render_body(
&'a self,
body: &'a Body,
Switching back to a Vec because inserting multiple elements into the linked list structure while maintaining ownership of each node proved to be difficult.
2020-06-06 22:24:27 -04:00
breadcrumbs: &'a Vec<BreadcrumbTreeElement<'a>>,
General structure to the rendering code.
2020-05-31 21:18:54 -04:00
blocks: &'a BlockContext<'a>,
) -> Result<String, RenderError> {
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<PartialNameElement>,
Switching back to a Vec because inserting multiple elements into the linked list structure while maintaining ownership of each node proved to be difficult.
2020-06-06 22:24:27 -04:00
breadcrumbs: &'a Vec<BreadcrumbTreeElement<'a>>,
General structure to the rendering code.
2020-05-31 21:18:54 -04:00
) -> Result<String, RenderError> {
let converted_to_template_elements: Vec<TemplateElement<'a>> =
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 {
Switching back to a Vec because inserting multiple elements into the linked list structure while maintaining ownership of each node proved to be difficult.
2020-06-06 22:24:27 -04:00
breadcrumbs: &Vec::new(),
General structure to the rendering code.
2020-05-31 21:18:54 -04:00
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,
Switching back to a Vec because inserting multiple elements into the linked list structure while maintaining ownership of each node proved to be difficult.
2020-06-06 22:24:27 -04:00
breadcrumbs: &'a Vec<BreadcrumbTreeElement<'a>>,
General structure to the rendering code.
2020-05-31 21:18:54 -04:00
blocks: &'a BlockContext<'a>,
) -> Result<String, RenderError> {
match tag {
Added back in reference.
2020-05-31 21:26:31 -04:00
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 {
Switched to returning an Option for into_context_element().
2020-05-31 22:17:58 -04:00
Err(WalkError::CantWalk) | Ok(None) => return Ok("".to_owned()),
Ok(Some(final_val)) => {
Running into lifetime issues again.
2020-05-31 23:47:20 -04:00
return if final_val.get_context_element_reference().is_truthy() {
final_val
.get_context_element_reference()
.render(&Self::preprocess_filters(&reference.filters))
Added back in reference.
2020-05-31 21:26:31 -04:00
} else {
Ok("".to_owned())
};
}
}
}
Need to mix back in parameterscontext.
2020-05-31 21:30:36 -04:00
DustTag::DTSection(container) => {
Implement IntoContextElement for ParametersContext.
2020-06-06 20:48:29 -04:00
let injected_context = ParametersContext::new(self, breadcrumbs, &container.params);
Need to mix back in parameterscontext.
2020-05-31 21:30:36 -04:00
let val = walk_path(breadcrumbs, &container.path.keys)
.map(|ice| ice.into_context_element(self, breadcrumbs));
match val {
Update IterationContext to be an IntoContextElement and finish implementing section.
2020-06-06 23:08:21 -04:00
Err(WalkError::CantWalk) | Ok(None) => {
Implement IntoContextElement for ParametersContext.
2020-06-06 20:48:29 -04:00
let new_breadcrumbs = self.new_breadcrumbs_section(
breadcrumbs,
None,
Some(&injected_context),
&container.explicit_context,
None,
);
Update IterationContext to be an IntoContextElement and finish implementing section.
2020-06-06 23:08:21 -04:00
return self.render_maybe_body(
&container.else_contents,
new_breadcrumbs.as_ref().unwrap_or(breadcrumbs),
blocks,
);
Need to mix back in parameterscontext.
2020-05-31 21:30:36 -04:00
}
Update IterationContext to be an IntoContextElement and finish implementing section.
2020-06-06 23:08:21 -04:00
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<Vec<String>, 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,
)
};
Need to mix back in parameterscontext.
2020-05-31 21:30:36 -04:00
}
}
}
Updated Exists/NotExists for the new architecture.
2020-06-06 23:15:12 -04:00
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,
),
};
}
Updated Partial for the new architecture.
2020-06-06 23:17:50 -04:00
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);
}
}
Inline partials and blocks worked as-is.
2020-06-06 23:18:28 -04:00
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,
),
};
}
port over the equals/not equals helpers.
2020-06-07 00:03:51 -04:00
DustTag::DTHelperEquals(parameterized_block) => {
let new_breadcrumbs = self.new_breadcrumbs_partial(
breadcrumbs,
breadcrumbs,
None,
&parameterized_block.explicit_context,
);
let param_map =
ParametersContext::new(self, breadcrumbs, &parameterized_block.params);
All tests passing!
2020-06-07 01:04:00 -04:00
if !param_map.contains_key("key") {
return Ok("".to_owned());
}
let left_side = param_map
port over the equals/not equals helpers.
2020-06-07 00:03:51 -04:00
.walk("key")
All tests passing!
2020-06-07 01:04:00 -04:00
.map(|ice| ice.into_context_element(self, breadcrumbs));
port over the equals/not equals helpers.
2020-06-07 00:03:51 -04:00
let right_side = param_map
.walk("value")
.map(|ice| ice.into_context_element(self, breadcrumbs));
All tests working.
2020-06-07 01:35:58 -04:00
// 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).
Remove unused code and clean up warnings.
2020-06-07 13:25:27 -04:00
if Self::are_paths_identical(&left_side, &right_side)
All tests working.
2020-06-07 01:35:58 -04:00
|| 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())
})
{
port over the equals/not equals helpers.
2020-06-07 00:03:51 -04:00
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,
);
}
}
DustTag::DTHelperNotEquals(parameterized_block) => {
let new_breadcrumbs = self.new_breadcrumbs_partial(
breadcrumbs,
breadcrumbs,
None,
&parameterized_block.explicit_context,
);
let param_map =
ParametersContext::new(self, breadcrumbs, &parameterized_block.params);
All tests passing!
2020-06-07 01:04:00 -04:00
if !param_map.contains_key("key") {
return Ok("".to_owned());
}
let left_side = param_map
port over the equals/not equals helpers.
2020-06-07 00:03:51 -04:00
.walk("key")
All tests passing!
2020-06-07 01:04:00 -04:00
.map(|ice| ice.into_context_element(self, breadcrumbs));
port over the equals/not equals helpers.
2020-06-07 00:03:51 -04:00
let right_side = param_map
.walk("value")
.map(|ice| ice.into_context_element(self, breadcrumbs));
All tests working.
2020-06-07 01:35:58 -04:00
// 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).
Remove unused code and clean up warnings.
2020-06-07 13:25:27 -04:00
if Self::are_paths_identical(&left_side, &right_side)
All tests working.
2020-06-07 01:35:58 -04:00
|| 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())
})
{
port over the equals/not equals helpers.
2020-06-07 00:03:51 -04:00
return self.render_maybe_body(
All tests working.
2020-06-07 01:35:58 -04:00
&parameterized_block.else_contents,
port over the equals/not equals helpers.
2020-06-07 00:03:51 -04:00
new_breadcrumbs.as_ref().unwrap_or(breadcrumbs),
blocks,
);
} else {
return self.render_maybe_body(
All tests working.
2020-06-07 01:35:58 -04:00
&parameterized_block.contents,
port over the equals/not equals helpers.
2020-06-07 00:03:51 -04:00
new_breadcrumbs.as_ref().unwrap_or(breadcrumbs),
blocks,
);
}
}
port over the remaining helpers.
2020-06-07 00:12:01 -04:00
DustTag::DTHelperGreaterThan(parameterized_block) => {
let new_breadcrumbs = self.new_breadcrumbs_partial(
breadcrumbs,
breadcrumbs,
None,
&parameterized_block.explicit_context,
);
let param_map =
ParametersContext::new(self, breadcrumbs, &parameterized_block.params);
All tests passing!
2020-06-07 01:04:00 -04:00
if !param_map.contains_key("key") {
return Ok("".to_owned());
}
let left_side = param_map
port over the remaining helpers.
2020-06-07 00:12:01 -04:00
.walk("key")
All tests passing!
2020-06-07 01:04:00 -04:00
.map(|ice| ice.into_context_element(self, breadcrumbs));
port over the remaining helpers.
2020-06-07 00:12:01 -04:00
let right_side = param_map
.walk("value")
.map(|ice| ice.into_context_element(self, breadcrumbs));
All tests passing!
2020-06-07 01:04:00 -04:00
match (left_side, right_side) {
(Ok(Some(left_side_unwrapped)), Ok(Some(right_side_unwrapped))) => {
if left_side_unwrapped.get_context_element_reference()
port over the remaining helpers.
2020-06-07 00:12:01 -04:00
> 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,
new_breadcrumbs.as_ref().unwrap_or(breadcrumbs),
blocks,
)
}
}
}
DustTag::DTHelperGreaterThanOrEquals(parameterized_block) => {
let new_breadcrumbs = self.new_breadcrumbs_partial(
breadcrumbs,
breadcrumbs,
None,
&parameterized_block.explicit_context,
);
let param_map =
ParametersContext::new(self, breadcrumbs, &parameterized_block.params);
All tests passing!
2020-06-07 01:04:00 -04:00
if !param_map.contains_key("key") {
return Ok("".to_owned());
}
let left_side = param_map
port over the remaining helpers.
2020-06-07 00:12:01 -04:00
.walk("key")
All tests passing!
2020-06-07 01:04:00 -04:00
.map(|ice| ice.into_context_element(self, breadcrumbs));
port over the remaining helpers.
2020-06-07 00:12:01 -04:00
let right_side = param_map
.walk("value")
.map(|ice| ice.into_context_element(self, breadcrumbs));
All tests passing!
2020-06-07 01:04:00 -04:00
match (left_side, right_side) {
(Ok(Some(left_side_unwrapped)), Ok(Some(right_side_unwrapped))) => {
if left_side_unwrapped.get_context_element_reference()
port over the remaining helpers.
2020-06-07 00:12:01 -04:00
>= 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,
new_breadcrumbs.as_ref().unwrap_or(breadcrumbs),
blocks,
)
}
}
}
DustTag::DTHelperLessThan(parameterized_block) => {
let new_breadcrumbs = self.new_breadcrumbs_partial(
breadcrumbs,
breadcrumbs,
None,
&parameterized_block.explicit_context,
);
let param_map =
ParametersContext::new(self, breadcrumbs, &parameterized_block.params);
All tests passing!
2020-06-07 01:04:00 -04:00
if !param_map.contains_key("key") {
return Ok("".to_owned());
}
let left_side = param_map
port over the remaining helpers.
2020-06-07 00:12:01 -04:00
.walk("key")
All tests passing!
2020-06-07 01:04:00 -04:00
.map(|ice| ice.into_context_element(self, breadcrumbs));
port over the remaining helpers.
2020-06-07 00:12:01 -04:00
let right_side = param_map
.walk("value")
.map(|ice| ice.into_context_element(self, breadcrumbs));
All tests passing!
2020-06-07 01:04:00 -04:00
match (left_side, right_side) {
(Ok(Some(left_side_unwrapped)), Ok(Some(right_side_unwrapped))) => {
if left_side_unwrapped.get_context_element_reference()
port over the remaining helpers.
2020-06-07 00:12:01 -04:00
< 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,
new_breadcrumbs.as_ref().unwrap_or(breadcrumbs),
blocks,
)
}
}
}
DustTag::DTHelperLessThanOrEquals(parameterized_block) => {
let new_breadcrumbs = self.new_breadcrumbs_partial(
breadcrumbs,
breadcrumbs,
None,
&parameterized_block.explicit_context,
);
let param_map =
ParametersContext::new(self, breadcrumbs, &parameterized_block.params);
All tests passing!
2020-06-07 01:04:00 -04:00
if !param_map.contains_key("key") {
return Ok("".to_owned());
}
let left_side = param_map
port over the remaining helpers.
2020-06-07 00:12:01 -04:00
.walk("key")
All tests passing!
2020-06-07 01:04:00 -04:00
.map(|ice| ice.into_context_element(self, breadcrumbs));
port over the remaining helpers.
2020-06-07 00:12:01 -04:00
let right_side = param_map
.walk("value")
.map(|ice| ice.into_context_element(self, breadcrumbs));
All tests passing!
2020-06-07 01:04:00 -04:00
match (left_side, right_side) {
(Ok(Some(left_side_unwrapped)), Ok(Some(right_side_unwrapped))) => {
if left_side_unwrapped.get_context_element_reference()
port over the remaining helpers.
2020-06-07 00:12:01 -04:00
<= 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,
new_breadcrumbs.as_ref().unwrap_or(breadcrumbs),
blocks,
)
}
}
}
Implemented the sep helper.
2020-06-07 15:09:37 -04:00
DustTag::DTHelperSep(parameterized_block) => {
let new_breadcrumbs = self.new_breadcrumbs_partial(
breadcrumbs,
breadcrumbs,
None,
&parameterized_block.explicit_context,
);
let index = self.get(breadcrumbs, &vec!["$idx"]);
let len = self.get(breadcrumbs, &vec!["$len"]);
match (index, len) {
(Err(_), _) | (_, Err(_)) => {
return self.render_maybe_body(
&parameterized_block.contents,
new_breadcrumbs.as_ref().unwrap_or(breadcrumbs),
blocks,
)
}
(Ok(index_resolved), Ok(len_resolved)) => {
// Iteration contexts use OwnedLiteral::LPositiveinteger
let index_cast = index_resolved
.get_context_element_reference()
.to_any()
.downcast_ref::<OwnedLiteral>();
let len_cast = len_resolved
.get_context_element_reference()
.to_any()
.downcast_ref::<OwnedLiteral>();
match (index_cast, len_cast) {
(
Some(OwnedLiteral::LPositiveInteger(index_number)),
Some(OwnedLiteral::LPositiveInteger(len_number)),
) => {
if *index_number == len_number - 1 {
return Ok("".to_owned());
} else {
return self.render_maybe_body(
&parameterized_block.contents,
new_breadcrumbs.as_ref().unwrap_or(breadcrumbs),
blocks,
);
}
}
_ => return Ok("".to_owned()),
}
}
}
}
Implement get and tap functions.
2020-06-07 14:45:32 -04:00
DustTag::DTHelperFirst(parameterized_block) => {}
DustTag::DTHelperLast(parameterized_block) => {}
General structure to the rendering code.
2020-05-31 21:18:54 -04:00
}
port over the remaining helpers.
2020-06-07 00:12:01 -04:00
General structure to the rendering code.
2020-05-31 21:18:54 -04:00
Ok("".to_owned())
}
Implement get and tap functions.
2020-06-07 14:45:32 -04:00
/// Read a value from the context tree
pub fn get<P>(
&'a self,
breadcrumbs: &'a Vec<BreadcrumbTreeElement<'a>>,
name: &Vec<P>,
) -> Result<IceResult<'a>, WalkError>
where
P: Borrow<str>,
{
let val =
walk_path(breadcrumbs, name).map(|ice| ice.into_context_element(self, breadcrumbs));
match val {
Ok(Some(ice_result)) => Ok(ice_result),
Ok(None) => Err(WalkError::CantWalk),
Err(walk_error) => Err(walk_error),
}
}
/// Read a value from the parameters context
///
/// Returns None if the key is not present at all
pub fn tap<P>(
&'a self,
breadcrumbs: &'a Vec<BreadcrumbTreeElement<'a>>,
parameters: &'a ParametersContext<'a>,
name: &P,
) -> Option<Result<IceResult<'a>, WalkError>>
where
P: Borrow<str>,
{
if !parameters.contains_key(name.borrow()) {
return None;
}
let val = parameters
.walk("key")
.map(|ice| ice.into_context_element(self, breadcrumbs));
match val {
Ok(Some(ice_result)) => Some(Ok(ice_result)),
Ok(None) => Some(Err(WalkError::CantWalk)),
Err(walk_error) => Some(Err(walk_error)),
}
}
Add test for priorities while looping and split the new_breadcrumbs function into two separate new_breadcrumbs functions because sections and partials have different orderings.
2020-05-25 22:50:10 -04:00
fn new_breadcrumbs_section<'b>(
General structure to the rendering code.
2020-05-31 21:18:54 -04:00
&'b self,
Fixed new_breadcrumbs_section for the Vec based breadcrumbs.
2020-06-06 22:37:29 -04:00
breadcrumbs: &'b Vec<BreadcrumbTreeElement<'b>>,
Put IntoContextElement everywhere. It compiles again.
2020-05-30 17:50:27 -04:00
index_context: Option<&'b dyn IntoContextElement>,
injected_context: Option<&'b dyn IntoContextElement>,
Add test for priorities while looping and split the new_breadcrumbs function into two separate new_breadcrumbs functions because sections and partials have different orderings.
2020-05-25 22:50:10 -04:00
explicit_context: &Option<Path<'b>>,
new_context_element: Option<&'b dyn ContextElement>,
Fixed new_breadcrumbs_section for the Vec based breadcrumbs.
2020-06-06 22:37:29 -04:00
) -> Option<Vec<BreadcrumbTreeElement<'b>>> {
Add test for priorities while looping and split the new_breadcrumbs function into two separate new_breadcrumbs functions because sections and partials have different orderings.
2020-05-25 22:50:10 -04:00
// 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,
_ => (),
}
Replaced the old renderer file with a new renderer file.
2020-05-31 18:18:21 -04:00
// If there is an explicit context, then drop all the current
// context
Fixed new_breadcrumbs_section for the Vec based breadcrumbs.
2020-06-06 22:37:29 -04:00
let mut new_stack = match explicit_context {
Some(_) => Vec::with_capacity(4),
None => breadcrumbs.clone(),
Add test for priorities while looping and split the new_breadcrumbs function into two separate new_breadcrumbs functions because sections and partials have different orderings.
2020-05-25 22:50:10 -04:00
};
Replaced the old renderer file with a new renderer file.
2020-05-31 18:18:21 -04:00
I think I have solved the lifetime issue. OwnedBreadcrumbTreeElement's needed a lifetime associated with them because IntoContextElement had lifetimes associated with it.
2020-06-06 17:52:46 -04:00
explicit_context.as_ref().map(|path| {
Fixed new_breadcrumbs_section for the Vec based breadcrumbs.
2020-06-06 22:37:29 -04:00
walk_path(breadcrumbs, &path.keys)
.map(|ice| ice.into_context_element(self, breadcrumbs))
Switched to returning an Option for into_context_element().
2020-05-31 22:17:58 -04:00
.ok()
.flatten()
Remove iteration_context, parameters_context, and most of bin.rs. Since I'm changing a pretty core concept of the renderer, I'm going to be rebuilding it piece by piece. In the interest of being able to rapidly change things and check if they are valid through compilation, I need to eliminate most of the old code so I do not have that weighing me down.
2020-05-31 18:27:55 -04:00
.map(|val| {
Running into lifetime issues again.
2020-05-31 23:47:20 -04:00
if val.get_context_element_reference().is_truthy() {
Fixed new_breadcrumbs_section for the Vec based breadcrumbs.
2020-06-06 22:37:29 -04:00
new_stack.push(std::convert::From::from(val))
Remove iteration_context, parameters_context, and most of bin.rs. Since I'm changing a pretty core concept of the renderer, I'm going to be rebuilding it piece by piece. In the interest of being able to rapidly change things and check if they are valid through compilation, I need to eliminate most of the old code so I do not have that weighing me down.
2020-05-31 18:27:55 -04:00
}
});
I think I have solved the lifetime issue. OwnedBreadcrumbTreeElement's needed a lifetime associated with them because IntoContextElement had lifetimes associated with it.
2020-06-06 17:52:46 -04:00
});
Fixed new_breadcrumbs_section for the Vec based breadcrumbs.
2020-06-06 22:37:29 -04:00
injected_context.map(|ctx| new_stack.push(BreadcrumbTreeElement::from_borrowed(ctx)));
Create from_borrowed and from_owned constructors for IceResult and BreadcrumbTreeElement. In an effort to keep track of how often memory is getting heap allocated, I am implementing constructors for IceResult and BreadcrumbTreeElement. This should limit the places that I call Rc::new and allow me to place tracing code into it later to ensure all code paths doing heap allocation make sense.
2020-06-06 20:24:01 -04:00
new_context_element.map(|ctx| {
Fixed new_breadcrumbs_section for the Vec based breadcrumbs.
2020-06-06 22:37:29 -04:00
new_stack.push(BreadcrumbTreeElement::from_borrowed(
Create from_borrowed and from_owned constructors for IceResult and BreadcrumbTreeElement. In an effort to keep track of how often memory is getting heap allocated, I am implementing constructors for IceResult and BreadcrumbTreeElement. This should limit the places that I call Rc::new and allow me to place tracing code into it later to ensure all code paths doing heap allocation make sense.
2020-06-06 20:24:01 -04:00
ctx.from_context_element(),
))
});
Fixed new_breadcrumbs_section for the Vec based breadcrumbs.
2020-06-06 22:37:29 -04:00
index_context.map(|ctx| new_stack.push(BreadcrumbTreeElement::from_borrowed(ctx)));
Replaced the old renderer file with a new renderer file.
2020-05-31 18:18:21 -04:00
Fixed new_breadcrumbs_section for the Vec based breadcrumbs.
2020-06-06 22:37:29 -04:00
Some(new_stack)
Start of porting over the walk tests.
2020-05-05 20:22:25 -04:00
}
Most of new_breadcrumbs_partial, just need to get the return working.
2020-05-31 20:41:27 -04:00
fn new_breadcrumbs_partial<'b>(
Turns out it was just a lifetime issue.
2020-05-31 20:43:07 -04:00
&'b self,
Finished converting back to Vec.
2020-06-06 22:45:58 -04:00
breadcrumbs: &'b Vec<BreadcrumbTreeElement<'b>>,
explicit_context_breadcrumbs: &'a Vec<BreadcrumbTreeElement<'a>>,
Most of new_breadcrumbs_partial, just need to get the return working.
2020-05-31 20:41:27 -04:00
injected_context: Option<&'b dyn IntoContextElement>,
explicit_context: &Option<Path<'b>>,
Finished converting back to Vec.
2020-06-06 22:45:58 -04:00
) -> Option<Vec<BreadcrumbTreeElement<'b>>> {
Most of new_breadcrumbs_partial, just need to get the return working.
2020-05-31 20:41:27 -04:00
// 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
Finished converting back to Vec.
2020-06-06 22:45:58 -04:00
let mut new_stack = match explicit_context {
Some(_) => Vec::with_capacity(3),
None => breadcrumbs.clone(),
Most of new_breadcrumbs_partial, just need to get the return working.
2020-05-31 20:41:27 -04:00
};
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 {
Update IterationContext to be an IntoContextElement and finish implementing section.
2020-06-06 23:08:21 -04:00
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)),
Most of new_breadcrumbs_partial, just need to get the return working.
2020-05-31 20:41:27 -04:00
}
});
Finished converting back to Vec.
2020-06-06 22:45:58 -04:00
I think I have solved the lifetime issue. OwnedBreadcrumbTreeElement's needed a lifetime associated with them because IntoContextElement had lifetimes associated with it.
2020-06-06 17:52:46 -04:00
explicit_context.as_ref().map(|path| {
Most of new_breadcrumbs_partial, just need to get the return working.
2020-05-31 20:41:27 -04:00
// TODO: should resolving the value here use
// explicit_context_maybe_breadcrumbs or
// maybe_breadcrumbs?
Finished converting back to Vec.
2020-06-06 22:45:58 -04:00
walk_path(explicit_context_breadcrumbs, &path.keys)
.map(|ice| ice.into_context_element(self, breadcrumbs))
Switched to returning an Option for into_context_element().
2020-05-31 22:17:58 -04:00
.ok()
.flatten()
Most of new_breadcrumbs_partial, just need to get the return working.
2020-05-31 20:41:27 -04:00
.map(|val| {
Minor syntax fix.
2020-06-06 15:20:43 -04:00
if val.get_context_element_reference().is_truthy() {
Finished converting back to Vec.
2020-06-06 22:45:58 -04:00
new_stack.push(std::convert::From::from(val));
Most of new_breadcrumbs_partial, just need to get the return working.
2020-05-31 20:41:27 -04:00
}
});
I think I have solved the lifetime issue. OwnedBreadcrumbTreeElement's needed a lifetime associated with them because IntoContextElement had lifetimes associated with it.
2020-06-06 17:52:46 -04:00
});
Most of new_breadcrumbs_partial, just need to get the return working.
2020-05-31 20:41:27 -04:00
Finished converting back to Vec.
2020-06-06 22:45:58 -04:00
Some(new_stack)
Most of new_breadcrumbs_partial, just need to get the return working.
2020-05-31 20:41:27 -04:00
}
Added back in reference.
2020-05-31 21:26:31 -04:00
port over the equals/not equals helpers.
2020-06-07 00:03:51 -04:00
fn are_paths_identical<'b>(
All tests working.
2020-06-07 01:35:58 -04:00
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,
}
}
Added back in reference.
2020-05-31 21:26:31 -04:00
fn preprocess_filters(filters: &Vec<Filter>) -> Vec<Filter> {
let mut final_filters: Vec<Filter> = 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
}
Finished converting back to Vec.
2020-06-06 22:45:58 -04:00
Update IterationContext to be an IntoContextElement and finish implementing section.
2020-06-06 23:08:21 -04:00
fn get_index_of_first_non_pseudo_element<'b>(
breadcrumbs: &'b Vec<BreadcrumbTreeElement<'b>>,
) -> Option<usize> {
breadcrumbs.iter().rposition(|b| {
Fix the same issue in the renderer.
2020-06-07 00:37:47 -04:00
!std::borrow::Borrow::<dyn IntoContextElement + 'b>::borrow(b).is_pseudo_element()
Update IterationContext to be an IntoContextElement and finish implementing section.
2020-06-06 23:08:21 -04:00
})
Finished converting back to Vec.
2020-06-06 22:45:58 -04:00
}
initial walkable implementation
2020-04-11 20:31:44 -04:00
}
General structure to the rendering code.
2020-05-31 21:18:54 -04:00
struct BlockContext<'a> {
/// The breadcrumbs at the time of entering the current partial
Switching back to a Vec because inserting multiple elements into the linked list structure while maintaining ownership of each node proved to be difficult.
2020-06-06 22:24:27 -04:00
breadcrumbs: &'a Vec<BreadcrumbTreeElement<'a>>,
General structure to the rendering code.
2020-05-31 21:18:54 -04:00
blocks: &'a InlinePartialTreeElement<'a>,
}
Reference in New Issue Copy Permalink