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

713 lines
28 KiB
Rust
Raw Normal View History

compiling templates in the same manner as the shim
2020-04-11 00:27:27 +00:00
use crate::parser::template;
Switching render_template to render_body. The body element is re-used as a child element in blocks, so it makes more sense to make a function that renders that as opposed to a function that renders a top-level-only container that contains only a body.
2020-04-12 03:03:07 +00:00
use crate::parser::Body;
Beginning of the render_tag function. Beginning of the render_tag function. At this point I need to figure out how to access elements in the context.
2020-04-11 22:40:36 +00:00
use crate::parser::DustTag;
Getting the left and right sides.
2020-05-10 18:22:59 +00:00
use crate::parser::KVPair;
Implement the new partial type in the renderer.
2020-05-18 01:11:55 +00:00
use crate::parser::PartialNameElement;
Getting the left and right sides.
2020-05-10 18:22:59 +00:00
use crate::parser::RValue;
Implement specials in the renderer.
2020-05-03 18:52:08 +00:00
use crate::parser::Special;
compiling templates in the same manner as the shim
2020-04-11 00:27:27 +00:00
use crate::parser::Template;
Automatically appending the html escape filter on the renderer side.
2020-05-23 21:57:19 +00:00
use crate::parser::{Filter, TemplateElement};
Combine the render traits into a single context_element file.
2020-04-28 23:09:02 +00:00
use crate::renderer::context_element::ContextElement;
Rendering spans
2020-04-11 22:25:48 +00:00
use crate::renderer::errors::CompileError;
use crate::renderer::errors::RenderError;
Going extreme: removing all fields and unifying all walk errors.
2020-05-09 18:00:19 +00:00
use crate::renderer::errors::WalkError;
Generating the new treeX
2020-05-10 02:05:43 +00:00
use crate::renderer::inline_partial_tree::extract_inline_partials;
use crate::renderer::inline_partial_tree::InlinePartialTreeElement;
Rename NewParametersContext to ParametersContext.
2020-05-11 02:21:18 +00:00
use crate::renderer::parameters_context::ParametersContext;
Partial simple is working.
2020-05-09 18:53:53 +00:00
use crate::renderer::walking::walk_path;
Automatically appending the html escape filter on the renderer side.
2020-05-23 21:57:19 +00:00
use std::collections::HashMap;
compiling templates in the same manner as the shim
2020-04-11 00:27:27 +00:00
#[derive(Clone, Debug)]
pub struct CompiledTemplate<'a> {
template: Template<'a>,
Rendering spans
2020-04-11 22:25:48 +00:00
pub name: String,
compiling templates in the same manner as the shim
2020-04-11 00:27:27 +00:00
}
Loading the compiled templates into a context
2020-04-11 00:55:44 +00:00
#[derive(Clone, Debug)]
Rename DustContext to DustRenderer
2020-04-11 00:58:55 +00:00
pub struct DustRenderer<'a> {
Rendering spans
2020-04-11 22:25:48 +00:00
templates: HashMap<String, &'a Template<'a>>,
Loading the compiled templates into a context
2020-04-11 00:55:44 +00:00
}
Rendering spans
2020-04-11 22:25:48 +00:00
pub fn compile_template<'a>(
source: &'a str,
name: String,
) -> Result<CompiledTemplate<'a>, CompileError> {
compiling templates in the same manner as the shim
2020-04-11 00:27:27 +00:00
// TODO: Make this all consuming
Rendering spans
2020-04-11 22:25:48 +00:00
// TODO: This could use better error management
compiling templates in the same manner as the shim
2020-04-11 00:27:27 +00:00
let (_remaining, parsed_template) = template(source).expect("Failed to compile template");
Rendering spans
2020-04-11 22:25:48 +00:00
Ok(CompiledTemplate {
compiling templates in the same manner as the shim
2020-04-11 00:27:27 +00:00
template: parsed_template,
name: name,
Rendering spans
2020-04-11 22:25:48 +00:00
})
compiling templates in the same manner as the shim
2020-04-11 00:27:27 +00:00
}
Loading the compiled templates into a context
2020-04-11 00:55:44 +00:00
Rename DustContext to DustRenderer
2020-04-11 00:58:55 +00:00
impl<'a> DustRenderer<'a> {
pub fn new() -> DustRenderer<'a> {
DustRenderer {
Rendering spans
2020-04-11 22:25:48 +00:00
templates: HashMap::new(),
Loading the compiled templates into a context
2020-04-11 00:55:44 +00:00
}
}
pub fn load_source(&mut self, template: &'a CompiledTemplate) {
Rendering spans
2020-04-11 22:25:48 +00:00
self.templates
.insert(template.name.clone(), &template.template);
Loading the compiled templates into a context
2020-04-11 00:55:44 +00:00
}
Rename DustContext to DustRenderer
2020-04-11 00:58:55 +00:00
Rename the new functions to replace the old functions.
2020-05-06 00:46:31 +00:00
pub fn render(
Implement the new render functions.
2020-05-05 23:51:07 +00:00
&'a self,
name: &str,
breadcrumbs: &Vec<&'a dyn ContextElement>,
Generating the new treeX
2020-05-10 02:05:43 +00:00
) -> Result<String, RenderError> {
self.render_template(name, breadcrumbs, None)
}
fn render_template(
&'a self,
name: &str,
breadcrumbs: &Vec<&'a dyn ContextElement>,
blocks: Option<&'a InlinePartialTreeElement<'a>>,
Simplified the RenderError class.
2020-05-09 18:27:42 +00:00
) -> Result<String, RenderError> {
Implement the new render functions.
2020-05-05 23:51:07 +00:00
let main_template = match self.templates.get(name) {
Some(tmpl) => tmpl,
None => {
Simplified the RenderError class.
2020-05-09 18:27:42 +00:00
return Err(RenderError::TemplateNotFound(name.to_owned()));
Implement the new render functions.
2020-05-05 23:51:07 +00:00
}
};
Generating the new treeX
2020-05-10 02:05:43 +00:00
let extracted_inline_partials = extract_inline_partials(main_template);
let new_blocks = InlinePartialTreeElement::new(blocks, extracted_inline_partials);
Passing the block tree through the render functions.
2020-05-10 02:29:58 +00:00
self.render_body(&main_template.contents, breadcrumbs, &new_blocks)
Implement the new render functions.
2020-05-05 23:51:07 +00:00
}
Cleaning up and factoring out reused code in the renderer.
2020-05-16 21:17:43 +00:00
fn render_maybe_body(
&'a self,
body: &'a Option<Body>,
breadcrumbs: &Vec<&'a dyn ContextElement>,
blocks: &'a InlinePartialTreeElement<'a>,
) -> Result<String, RenderError> {
match body {
None => Ok("".to_owned()),
Some(body) => Ok(self.render_body(body, breadcrumbs, blocks)?),
}
}
Rename the new functions to replace the old functions.
2020-05-06 00:46:31 +00:00
fn render_body(
Implement the new render functions.
2020-05-05 23:51:07 +00:00
&'a self,
body: &'a Body,
breadcrumbs: &Vec<&'a dyn ContextElement>,
Passing the block tree through the render functions.
2020-05-10 02:29:58 +00:00
blocks: &'a InlinePartialTreeElement<'a>,
Simplified the RenderError class.
2020-05-09 18:27:42 +00:00
) -> Result<String, RenderError> {
Implement the new render functions.
2020-05-05 23:51:07 +00:00
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) => {
Passing the block tree through the render functions.
2020-05-10 02:29:58 +00:00
output.push_str(&self.render_tag(dt, breadcrumbs, blocks)?);
Implement the new render functions.
2020-05-05 23:51:07 +00:00
}
}
}
Ok(output)
}
Implement the new partial type in the renderer.
2020-05-18 01:11:55 +00:00
fn render_partial_name(
&'a self,
body: &'a Vec<PartialNameElement>,
breadcrumbs: &Vec<&'a dyn ContextElement>,
blocks: &'a InlinePartialTreeElement<'a>,
) -> Result<String, RenderError> {
let converted_to_template_elements: Vec<TemplateElement<'a>> =
body.into_iter().map(|e| e.into()).collect();
self.render_body(
&Body {
elements: converted_to_template_elements,
},
breadcrumbs,
blocks,
)
}
Rename the new functions to replace the old functions.
2020-05-06 00:46:31 +00:00
fn render_tag(
Implement the new render functions.
2020-05-05 23:51:07 +00:00
&'a self,
tag: &'a DustTag,
breadcrumbs: &Vec<&'a dyn ContextElement>,
Passing the block tree through the render functions.
2020-05-10 02:29:58 +00:00
blocks: &'a InlinePartialTreeElement<'a>,
Simplified the RenderError class.
2020-05-09 18:27:42 +00:00
) -> Result<String, RenderError> {
Implement the new render functions.
2020-05-05 23:51:07 +00:00
match tag {
DustTag::DTComment(_comment) => (),
DustTag::DTSpecial(special) => {
return Ok(match special {
Special::Space => " ",
Special::NewLine => "\n",
Special::CarriageReturn => "\r",
Special::LeftCurlyBrace => "{",
Special::RightCurlyBrace => "}",
}
.to_owned())
}
Add support for literal string blocks.
2020-05-24 03:41:05 +00:00
DustTag::DTLiteralStringBlock(literal) => return Ok((*literal).to_owned()),
Implement the new render functions.
2020-05-05 23:51:07 +00:00
DustTag::DTReference(reference) => {
Rename the new functions to replace the old functions.
2020-05-06 00:46:31 +00:00
let val = walk_path(breadcrumbs, &reference.path.keys);
Do a truthiness check on references before printing them.
2020-05-07 00:30:03 +00:00
match val {
Need to do loop elements.
2020-05-09 18:10:38 +00:00
Err(WalkError::CantWalk) => return Ok("".to_owned()),
Do a truthiness check on references before printing them.
2020-05-07 00:30:03 +00:00
Ok(final_val) => {
Compiles again.
2020-05-09 18:18:45 +00:00
let loop_elements = final_val.get_loop_elements();
Do a truthiness check on references before printing them.
2020-05-07 00:30:03 +00:00
if loop_elements.is_empty() {
return Ok("".to_owned());
} else {
Automatically appending the html escape filter on the renderer side.
2020-05-23 21:57:19 +00:00
return final_val.render(&Self::preprocess_filters(&reference.filters));
Do a truthiness check on references before printing them.
2020-05-07 00:30:03 +00:00
}
}
Implement the new render functions.
2020-05-05 23:51:07 +00:00
}
}
DustTag::DTSection(container) => {
Rename the new functions to replace the old functions.
2020-05-06 00:46:31 +00:00
let val = walk_path(breadcrumbs, &container.path.keys);
Cleaning up and factoring out reused code in the renderer.
2020-05-16 21:17:43 +00:00
let loop_elements: Vec<&dyn ContextElement> = Self::get_loop_elements(val);
Implement the new render functions.
2020-05-05 23:51:07 +00:00
if loop_elements.is_empty() {
// 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
Cleaning up and factoring out reused code in the renderer.
2020-05-16 21:17:43 +00:00
return self.render_maybe_body(&container.else_contents, breadcrumbs, blocks);
Implement the new render functions.
2020-05-05 23:51:07 +00:00
} else {
match &container.contents {
None => return Ok("".to_owned()),
Some(body) => {
let rendered_results: Result<Vec<String>, RenderError> = loop_elements
.into_iter()
.map(|array_elem| {
let mut new_breadcumbs = breadcrumbs.clone();
new_breadcumbs.push(array_elem);
Passing the block tree through the render functions.
2020-05-10 02:29:58 +00:00
self.render_body(&body, &new_breadcumbs, blocks)
Implement the new render functions.
2020-05-05 23:51:07 +00:00
})
.collect();
let rendered_slice: &[String] = &rendered_results?;
return Ok(rendered_slice.join(""));
}
}
}
}
Add support for the exists tag.
2020-05-06 23:10:09 +00:00
DustTag::DTExists(container) => {
let val = walk_path(breadcrumbs, &container.path.keys);
Cleaning up and factoring out reused code in the renderer.
2020-05-16 21:17:43 +00:00
let loop_elements: Vec<&dyn ContextElement> = Self::get_loop_elements(val);
return if loop_elements.is_empty() {
self.render_maybe_body(&container.else_contents, breadcrumbs, blocks)
Add support for the exists tag.
2020-05-06 23:10:09 +00:00
} else {
Cleaning up and factoring out reused code in the renderer.
2020-05-16 21:17:43 +00:00
self.render_maybe_body(&container.contents, breadcrumbs, blocks)
};
Add support for the exists tag.
2020-05-06 23:10:09 +00:00
}
Rendering a reference appears to do a truthiness check because false renders an empty string despite rendering as "false" in an array element.
2020-05-07 00:13:33 +00:00
DustTag::DTNotExists(container) => {
let val = walk_path(breadcrumbs, &container.path.keys);
Cleaning up and factoring out reused code in the renderer.
2020-05-16 21:17:43 +00:00
let loop_elements: Vec<&dyn ContextElement> = Self::get_loop_elements(val);
return if !loop_elements.is_empty() {
self.render_maybe_body(&container.else_contents, breadcrumbs, blocks)
Rendering a reference appears to do a truthiness check because false renders an empty string despite rendering as "false" in an array element.
2020-05-07 00:13:33 +00:00
} else {
Cleaning up and factoring out reused code in the renderer.
2020-05-16 21:17:43 +00:00
self.render_maybe_body(&container.contents, breadcrumbs, blocks)
};
Rendering a reference appears to do a truthiness check because false renders an empty string despite rendering as "false" in an array element.
2020-05-07 00:13:33 +00:00
}
Renamed the new partial implementation to the old partial name.
2020-05-18 01:17:34 +00:00
DustTag::DTPartial(partial) => {
Implement the new partial type in the renderer.
2020-05-18 01:11:55 +00:00
let partial_name = self.render_partial_name(&partial.name, breadcrumbs, blocks)?;
if partial.params.is_empty() {
let rendered_content =
self.render_template(&partial_name, breadcrumbs, Some(blocks))?;
return Ok(rendered_content);
} else {
let injected_context = ParametersContext::new(breadcrumbs, &partial.params);
let mut new_breadcrumbs = breadcrumbs.clone();
new_breadcrumbs.insert(new_breadcrumbs.len() - 1, &injected_context);
let rendered_content =
self.render_template(&partial_name, &new_breadcrumbs, Some(blocks))?;
return Ok(rendered_content);
}
}
Cleaning up and factoring out reused code in the renderer.
2020-05-16 21:17:43 +00:00
DustTag::DTInlinePartial(_named_block) => {
I think I have the full extraction code.
2020-05-10 01:30:54 +00:00
// Inline partials are blank during rendering (they get injected into blocks)
return Ok("".to_owned());
}
DustTag::DTBlock(named_block) => {
Cleaning up and factoring out reused code in the renderer.
2020-05-16 21:17:43 +00:00
return match blocks.get_block(named_block.name) {
None => self.render_maybe_body(&named_block.contents, breadcrumbs, blocks),
Some(interior) => self.render_maybe_body(interior, breadcrumbs, blocks),
Finished implementing Named blocks and inline partials.
2020-05-10 02:48:30 +00:00
};
I think I have the full extraction code.
2020-05-10 01:30:54 +00:00
}
Getting the left and right sides.
2020-05-10 18:22:59 +00:00
DustTag::DTHelperEquals(parameterized_block) => {
Cleaning up and factoring out reused code in the renderer.
2020-05-16 21:17:43 +00:00
let param_map: HashMap<&str, &RValue<'a>> =
Self::get_rval_map(&parameterized_block.params);
Add a check to the equality helper to mark identical paths as equal.
2020-05-16 19:22:48 +00:00
// 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) {
return match &parameterized_block.contents {
None => Ok("".to_owned()),
Some(body) => {
let rendered_content = self.render_body(body, breadcrumbs, blocks)?;
Ok(rendered_content)
}
};
}
Cleaning up and factoring out reused code in the renderer.
2020-05-16 21:17:43 +00:00
let left_side: Result<&dyn ContextElement, WalkError> =
match Self::get_rval(breadcrumbs, &param_map, "key") {
None => return Ok("".to_owned()),
Some(res) => res,
Getting the left and right sides.
2020-05-10 18:22:59 +00:00
};
Cleaning up and factoring out reused code in the renderer.
2020-05-16 21:17:43 +00:00
let right_side: Result<&dyn ContextElement, WalkError> =
Self::get_rval(breadcrumbs, &param_map, "value")
.unwrap_or(Err(WalkError::CantWalk));
PartialEq works with results too.
2020-05-11 01:00:52 +00:00
if left_side == right_side {
Cleaning up and factoring out reused code in the renderer.
2020-05-16 21:17:43 +00:00
return self.render_maybe_body(
&parameterized_block.contents,
breadcrumbs,
blocks,
);
Finish implementing DTHelperEquals.
2020-05-11 01:14:51 +00:00
} else {
Cleaning up and factoring out reused code in the renderer.
2020-05-16 21:17:43 +00:00
return self.render_maybe_body(
&parameterized_block.else_contents,
breadcrumbs,
blocks,
);
Implemented the not equals helper.
2020-05-16 16:26:28 +00:00
}
}
DustTag::DTHelperNotEquals(parameterized_block) => {
Cleaning up and factoring out reused code in the renderer.
2020-05-16 21:17:43 +00:00
let param_map: HashMap<&str, &RValue<'a>> =
Self::get_rval_map(&parameterized_block.params);
Add that check to the not-equals helper and update the json value implementation to mark all non-scalars as not-equals.
2020-05-16 19:30:17 +00:00
// 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) {
return match &parameterized_block.else_contents {
None => Ok("".to_owned()),
Some(body) => {
let rendered_content = self.render_body(body, breadcrumbs, blocks)?;
Ok(rendered_content)
}
};
}
Cleaning up and factoring out reused code in the renderer.
2020-05-16 21:17:43 +00:00
let left_side: Result<&dyn ContextElement, WalkError> =
match Self::get_rval(breadcrumbs, &param_map, "key") {
None => return Ok("".to_owned()),
Some(res) => res,
Implemented the not equals helper.
2020-05-16 16:26:28 +00:00
};
Cleaning up and factoring out reused code in the renderer.
2020-05-16 21:17:43 +00:00
let right_side: Result<&dyn ContextElement, WalkError> =
Self::get_rval(breadcrumbs, &param_map, "value")
.unwrap_or(Err(WalkError::CantWalk));
Implemented the not equals helper.
2020-05-16 16:26:28 +00:00
if left_side != right_side {
Cleaning up and factoring out reused code in the renderer.
2020-05-16 21:17:43 +00:00
return self.render_maybe_body(
&parameterized_block.contents,
breadcrumbs,
blocks,
);
Implemented the not equals helper.
2020-05-16 16:26:28 +00:00
} else {
Cleaning up and factoring out reused code in the renderer.
2020-05-16 21:17:43 +00:00
return self.render_maybe_body(
&parameterized_block.else_contents,
breadcrumbs,
blocks,
);
tentatively seems to be working.
2020-05-10 23:16:55 +00:00
}
Getting the left and right sides.
2020-05-10 18:22:59 +00:00
}
Add a test for gte.
2020-05-16 19:45:57 +00:00
DustTag::DTHelperGreaterThan(parameterized_block) => {
Cleaning up and factoring out reused code in the renderer.
2020-05-16 21:17:43 +00:00
let param_map: HashMap<&str, &RValue<'a>> =
Self::get_rval_map(&parameterized_block.params);
let left_side: Result<&dyn ContextElement, WalkError> =
match Self::get_rval(breadcrumbs, &param_map, "key") {
None => return Ok("".to_owned()),
Some(res) => res,
Have greater than helper very close to correct. Just need to make it compare arrays of scalars.
2020-05-16 20:24:36 +00:00
};
Cleaning up and factoring out reused code in the renderer.
2020-05-16 21:17:43 +00:00
let right_side: Result<&dyn ContextElement, WalkError> =
Self::get_rval(breadcrumbs, &param_map, "value")
.unwrap_or(Err(WalkError::CantWalk));
Have greater than helper very close to correct. Just need to make it compare arrays of scalars.
2020-05-16 20:24:36 +00:00
match (left_side, right_side) {
Initial attempt at implementation, tests not working.
2020-05-16 22:28:23 +00:00
(Err(_), _) | (_, Err(_)) => {
return self.render_maybe_body(
&parameterized_block.else_contents,
breadcrumbs,
blocks,
)
}
Have greater than helper very close to correct. Just need to make it compare arrays of scalars.
2020-05-16 20:24:36 +00:00
(Ok(left_side_unwrapped), Ok(right_side_unwrapped)) => {
if left_side_unwrapped > right_side_unwrapped {
Cleaning up and factoring out reused code in the renderer.
2020-05-16 21:17:43 +00:00
return self.render_maybe_body(
&parameterized_block.contents,
breadcrumbs,
blocks,
);
Have greater than helper very close to correct. Just need to make it compare arrays of scalars.
2020-05-16 20:24:36 +00:00
} else {
Cleaning up and factoring out reused code in the renderer.
2020-05-16 21:17:43 +00:00
return self.render_maybe_body(
&parameterized_block.else_contents,
breadcrumbs,
blocks,
);
Have greater than helper very close to correct. Just need to make it compare arrays of scalars.
2020-05-16 20:24:36 +00:00
}
}
}
Add a test for gte.
2020-05-16 19:45:57 +00:00
}
Implement less-than.
2020-05-16 23:05:03 +00:00
DustTag::DTHelperGreaterThanOrEquals(parameterized_block) => {
Initial attempt at implementation, tests not working.
2020-05-16 22:28:23 +00:00
let param_map: HashMap<&str, &RValue<'a>> =
Self::get_rval_map(&parameterized_block.params);
let left_side: Result<&dyn ContextElement, WalkError> =
match Self::get_rval(breadcrumbs, &param_map, "key") {
None => return Ok("".to_owned()),
Some(res) => res,
};
let right_side: Result<&dyn ContextElement, WalkError> =
Self::get_rval(breadcrumbs, &param_map, "value")
.unwrap_or(Err(WalkError::CantWalk));
match (left_side, right_side) {
(Err(_), _) | (_, Err(_)) => {
return self.render_maybe_body(
Had to manually interpret the `partial_cmp` output instead of using the built-in operators since gte confusingly returns true for mismatched values.
2020-05-16 22:36:47 +00:00
&parameterized_block.else_contents,
Initial attempt at implementation, tests not working.
2020-05-16 22:28:23 +00:00
breadcrumbs,
blocks,
)
}
(Ok(left_side_unwrapped), Ok(right_side_unwrapped)) => {
Switched over to using operators instead of compare in the renderer.
2020-05-17 03:10:04 +00:00
if left_side_unwrapped >= right_side_unwrapped {
return self.render_maybe_body(
&parameterized_block.contents,
breadcrumbs,
blocks,
);
} else {
return self.render_maybe_body(
Initial attempt at implementation, tests not working.
2020-05-16 22:28:23 +00:00
&parameterized_block.else_contents,
breadcrumbs,
blocks,
Switched over to using operators instead of compare in the renderer.
2020-05-17 03:10:04 +00:00
);
}
Initial attempt at implementation, tests not working.
2020-05-16 22:28:23 +00:00
}
}
}
Implement less-than.
2020-05-16 23:05:03 +00:00
DustTag::DTHelperLessThan(parameterized_block) => {
let param_map: HashMap<&str, &RValue<'a>> =
Self::get_rval_map(&parameterized_block.params);
let left_side: Result<&dyn ContextElement, WalkError> =
match Self::get_rval(breadcrumbs, &param_map, "key") {
None => return Ok("".to_owned()),
Some(res) => res,
};
let right_side: Result<&dyn ContextElement, WalkError> =
Self::get_rval(breadcrumbs, &param_map, "value")
.unwrap_or(Err(WalkError::CantWalk));
match (left_side, right_side) {
(Err(_), _) | (_, Err(_)) => {
return self.render_maybe_body(
&parameterized_block.else_contents,
breadcrumbs,
blocks,
)
}
(Ok(left_side_unwrapped), Ok(right_side_unwrapped)) => {
if left_side_unwrapped < right_side_unwrapped {
return self.render_maybe_body(
&parameterized_block.contents,
breadcrumbs,
blocks,
);
} else {
return self.render_maybe_body(
&parameterized_block.else_contents,
breadcrumbs,
blocks,
);
}
}
}
}
Implement less than or equals.
2020-05-16 23:06:40 +00:00
DustTag::DTHelperLessThanOrEquals(parameterized_block) => {
let param_map: HashMap<&str, &RValue<'a>> =
Self::get_rval_map(&parameterized_block.params);
let left_side: Result<&dyn ContextElement, WalkError> =
match Self::get_rval(breadcrumbs, &param_map, "key") {
None => return Ok("".to_owned()),
Some(res) => res,
};
let right_side: Result<&dyn ContextElement, WalkError> =
Self::get_rval(breadcrumbs, &param_map, "value")
.unwrap_or(Err(WalkError::CantWalk));
match (left_side, right_side) {
(Err(_), _) | (_, Err(_)) => {
return self.render_maybe_body(
&parameterized_block.else_contents,
breadcrumbs,
blocks,
)
}
(Ok(left_side_unwrapped), Ok(right_side_unwrapped)) => {
Switched over to using operators instead of compare in the renderer.
2020-05-17 03:10:04 +00:00
if left_side_unwrapped <= right_side_unwrapped {
return self.render_maybe_body(
&parameterized_block.contents,
breadcrumbs,
blocks,
);
} else {
return self.render_maybe_body(
Implement less than or equals.
2020-05-16 23:06:40 +00:00
&parameterized_block.else_contents,
breadcrumbs,
blocks,
Switched over to using operators instead of compare in the renderer.
2020-05-17 03:10:04 +00:00
);
}
Implement less than or equals.
2020-05-16 23:06:40 +00:00
}
}
}
Implement the new render functions.
2020-05-05 23:51:07 +00:00
}
Ok("".to_owned())
}
Render the else block in sections if the path does not exist or if the path can't be walked. This fixes all existing compliance tests.
2020-05-03 19:29:02 +00:00
/// Gets the elements to loop over for a section.
///
/// If the value is falsey, and therefore should render the else
/// block, this will return an empty vector.
fn get_loop_elements<'b>(
Ported the get_loop_elements wrapper.
2020-05-09 18:14:22 +00:00
walk_result: Result<&'b dyn ContextElement, WalkError>,
) -> Vec<&'b dyn ContextElement> {
match walk_result {
Err(WalkError::CantWalk) => Vec::new(),
Ok(walk_target) => walk_target.get_loop_elements(),
Render the else block in sections if the path does not exist or if the path can't be walked. This fixes all existing compliance tests.
2020-05-03 19:29:02 +00:00
}
}
Add a check to the equality helper to mark identical paths as equal.
2020-05-16 19:22:48 +00:00
fn are_paths_identical<'b>(param_map: &HashMap<&str, &RValue<'b>>) -> bool {
match (param_map.get("key"), param_map.get("value")) {
(None, _) => false,
(_, None) => false,
(Some(key_rval), Some(value_rval)) => match (key_rval, value_rval) {
(RValue::RVPath(key_path), RValue::RVPath(value_path)) => {
key_path.keys == value_path.keys
}
_ => false,
},
}
}
Cleaning up and factoring out reused code in the renderer.
2020-05-16 21:17:43 +00:00
fn get_rval_map<'b>(params: &'b Vec<KVPair<'b>>) -> HashMap<&'b str, &'b RValue<'b>> {
params
.iter()
.map(|pair: &KVPair<'b>| (pair.key, &pair.value))
.collect()
}
fn get_rval<'b>(
breadcrumbs: &Vec<&'b dyn ContextElement>,
param_map: &HashMap<&str, &'b RValue<'b>>,
key: &str,
) -> Option<Result<&'b dyn ContextElement, WalkError>> {
match param_map.get(key) {
None => None,
Some(rval) => match rval {
Transition to new literals compiling. Tests still need work, as does the implementation for json.
2020-05-17 02:30:04 +00:00
RValue::RVLiteral(literal) => Some(Ok(literal)),
Cleaning up and factoring out reused code in the renderer.
2020-05-16 21:17:43 +00:00
RValue::RVPath(path) => Some(walk_path(breadcrumbs, &path.keys)),
},
}
}
Automatically appending the html escape filter on the renderer side.
2020-05-23 21:57:19 +00: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
I was wrong, html escape filter is appended even if an html escape filter is already there.
2020-05-23 22:18:59 +00:00
if !filters.iter().any(|f| f == &Filter::DisableHtmlEncode) {
Automatically appending the html escape filter on the renderer side.
2020-05-23 21:57:19 +00:00
final_filters.push(Filter::HtmlEncode);
}
final_filters
}
Loading the compiled templates into a context
2020-04-11 00:55:44 +00:00
}
initial walkable implementation
2020-04-12 00:31:44 +00:00
#[cfg(test)]
mod tests {
use super::*;
Added the signature for passing filters into the render function. Added the signature for passing filters into the render function but I am not yet using the filters.
2020-04-13 01:54:15 +00:00
use crate::parser::Filter;
Add a Loopable trait for dust sections.
2020-04-28 23:34:52 +00:00
use crate::renderer::context_element::Loopable;
Combine the render traits into a single context_element file.
2020-04-28 23:09:02 +00:00
use crate::renderer::context_element::Renderable;
use crate::renderer::context_element::Walkable;
Revived the tests.
2020-05-11 03:26:15 +00:00
use crate::renderer::CompareContextElement;
Fix a bug w.r.t. quoting and escaping boolean values with filters.
2020-05-23 23:34:38 +00:00
use std::cmp::Ordering;
initial walkable implementation
2020-04-12 00:31:44 +00:00
Fix tests.
2020-05-17 02:39:29 +00:00
impl ContextElement for String {}
impl Renderable for String {
fn render(&self, _filters: &Vec<Filter>) -> Result<String, RenderError> {
Ok(self.clone())
}
}
impl Loopable for String {
fn get_loop_elements(&self) -> Vec<&dyn ContextElement> {
if self.is_empty() {
Vec::new()
} else {
vec![self]
}
}
}
impl Walkable for String {
fn walk(&self, segment: &str) -> Result<&dyn ContextElement, WalkError> {
Err(WalkError::CantWalk)
}
}
impl CompareContextElement for String {
fn equals(&self, other: &dyn ContextElement) -> bool {
match other.to_any().downcast_ref::<Self>() {
None => false,
Some(other_string) => self == other_string,
}
}
fn partial_compare(&self, other: &dyn ContextElement) -> Option<Ordering> {
match other.to_any().downcast_ref::<Self>() {
None => None,
Some(other_string) => self.partial_cmp(other_string),
}
}
}
impl ContextElement for u64 {}
impl Renderable for u64 {
fn render(&self, _filters: &Vec<Filter>) -> Result<String, RenderError> {
Ok(self.to_string())
}
}
impl Loopable for u64 {
fn get_loop_elements(&self) -> Vec<&dyn ContextElement> {
vec![self]
}
}
impl Walkable for u64 {
fn walk(&self, segment: &str) -> Result<&dyn ContextElement, WalkError> {
Err(WalkError::CantWalk)
}
}
impl CompareContextElement for u64 {
fn equals(&self, other: &dyn ContextElement) -> bool {
match other.to_any().downcast_ref::<Self>() {
None => false,
Some(other_num) => self == other_num,
}
}
fn partial_compare(&self, other: &dyn ContextElement) -> Option<Ordering> {
match other.to_any().downcast_ref::<Self>() {
None => None,
Some(other_num) => self.partial_cmp(other_num),
}
}
}
Revived the tests.
2020-05-11 03:26:15 +00:00
impl<I: 'static + ContextElement + Clone> ContextElement for HashMap<String, I> {}
Switching to a combined ContextElement trait for Walkable and Renderable
2020-04-12 02:19:54 +00:00
Revived the tests.
2020-05-11 03:26:15 +00:00
impl<I: ContextElement> Renderable for HashMap<String, I> {
Start of porting over the walk tests.
2020-05-06 00:22:25 +00:00
fn render(&self, _filters: &Vec<Filter>) -> Result<String, RenderError> {
// TODO: handle the filters
Remove CantRender, it was unused.
2020-05-09 17:46:12 +00:00
Ok("[object Object]".to_owned())
initial walkable implementation
2020-04-12 00:31:44 +00:00
}
Start of porting over the walk tests.
2020-05-06 00:22:25 +00:00
}
initial walkable implementation
2020-04-12 00:31:44 +00:00
Revived the tests.
2020-05-11 03:26:15 +00:00
impl<I: ContextElement> Walkable for HashMap<String, I> {
Finished creating WalkError.
2020-05-09 18:22:36 +00:00
fn walk(&self, segment: &str) -> Result<&dyn ContextElement, WalkError> {
let child = self.get(segment).ok_or(WalkError::CantWalk)?;
Start of porting over the walk tests.
2020-05-06 00:22:25 +00:00
Ok(child)
Adding &str
2020-04-12 01:07:12 +00:00
}
Start of porting over the walk tests.
2020-05-06 00:22:25 +00:00
}
Adding &str
2020-04-12 01:07:12 +00:00
Revived the tests.
2020-05-11 03:26:15 +00:00
impl<I: 'static + ContextElement + Clone> Loopable for HashMap<String, I> {
Finished creating WalkError.
2020-05-09 18:22:36 +00:00
fn get_loop_elements(&self) -> Vec<&dyn ContextElement> {
vec![self]
Add a Loopable trait for dust sections.
2020-04-28 23:34:52 +00:00
}
Start of porting over the walk tests.
2020-05-06 00:22:25 +00:00
}
Revived the tests.
2020-05-11 03:26:15 +00:00
impl<I: 'static + ContextElement + Clone> CompareContextElement for HashMap<String, I> {
fn equals(&self, other: &dyn ContextElement) -> bool {
false
Start of porting over the walk tests.
2020-05-06 00:22:25 +00:00
}
First stab at fixing the error, not a full success.
2020-05-17 01:30:51 +00:00
fn partial_compare(&self, other: &dyn ContextElement) -> Option<Ordering> {
// TODO: Implement
None
}
Start of porting over the walk tests.
2020-05-06 00:22:25 +00:00
}
#[test]
Delete old render functions.
2020-05-06 00:43:53 +00:00
fn test_walk_path() {
Revived the tests.
2020-05-11 03:26:15 +00:00
let context: HashMap<String, String> = [
("cat".to_string(), "kitty".to_string()),
("dog".to_string(), "doggy".to_string()),
("tiger".to_string(), "murderkitty".to_string()),
]
.iter()
.cloned()
.collect();
let number_context: HashMap<String, u64> = [
("cat".to_string(), 1),
("dog".to_string(), 2),
("tiger".to_string(), 3),
]
.iter()
.cloned()
.collect();
let deep_context: HashMap<String, HashMap<String, String>> = [
(
"cat".to_string(),
[("food".to_string(), "meat".to_string())]
.iter()
.cloned()
.collect(),
),
(
"dog".to_string(),
[("food".to_string(), "meat".to_string())]
.iter()
.cloned()
.collect(),
),
(
"tiger".to_string(),
[("food".to_string(), "people".to_string())]
.iter()
.cloned()
.collect(),
),
Start of porting over the walk tests.
2020-05-06 00:22:25 +00:00
]
.iter()
.cloned()
.collect();
assert_eq!(
Rename the new functions to replace the old functions.
2020-05-06 00:46:31 +00:00
walk_path(&vec![&context as &dyn ContextElement], &vec!["cat"])
Start of porting over the walk tests.
2020-05-06 00:22:25 +00:00
.unwrap()
.render(&Vec::new())
.unwrap(),
"kitty".to_owned()
);
Finish porting over the walk test.
2020-05-06 00:38:42 +00:00
assert_eq!(
Rename the new functions to replace the old functions.
2020-05-06 00:46:31 +00:00
walk_path(
Finish porting over the walk test.
2020-05-06 00:38:42 +00:00
&vec![&number_context as &dyn ContextElement],
&vec!["tiger"]
)
.unwrap()
.render(&Vec::new())
.unwrap(),
"3".to_owned()
);
assert_eq!(
Rename the new functions to replace the old functions.
2020-05-06 00:46:31 +00:00
walk_path(
Finish porting over the walk test.
2020-05-06 00:38:42 +00:00
&vec![&deep_context as &dyn ContextElement],
&vec!["tiger", "food"]
)
.unwrap()
.render(&Vec::new())
.unwrap(),
"people".to_owned()
);
Start of porting over the walk tests.
2020-05-06 00:22:25 +00:00
}
initial walkable implementation
2020-04-12 00:31:44 +00:00
}
Reference in New Issue Copy Permalink