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

1081 lines
43 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;
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-11 23:03:07 -04: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 18:40:36 -04:00
use crate::parser::DustTag;
Getting the left and right sides.
2020-05-10 14:22:59 -04:00
use crate::parser::KVPair;
Implement the new partial type in the renderer.
2020-05-17 21:11:55 -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;
Getting the left and right sides.
2020-05-10 14:22:59 -04:00
use crate::parser::RValue;
Implement specials in the renderer.
2020-05-03 14:52:08 -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;
Automatically appending the html escape filter on the renderer side.
2020-05-23 17:57:19 -04:00
use crate::parser::{Filter, TemplateElement};
Combine the render traits into a single context_element file.
2020-04-28 19:09:02 -04:00
use crate::renderer::context_element::ContextElement;
Rendering spans
2020-04-11 18:25:48 -04:00
use crate::renderer::errors::CompileError;
use crate::renderer::errors::RenderError;
Going extreme: removing all fields and unifying all walk errors.
2020-05-09 14:00:19 -04:00
use crate::renderer::errors::WalkError;
Generating the new treeX
2020-05-09 22:05:43 -04:00
use crate::renderer::inline_partial_tree::extract_inline_partials;
use crate::renderer::inline_partial_tree::InlinePartialTreeElement;
Switch the renderer over to using the new is_truthy value and add the injection of $idx and $len into the context tree.
2020-05-24 16:57:24 -04:00
use crate::renderer::iteration_context::IterationContext;
Rename NewParametersContext to ParametersContext.
2020-05-10 22:21:18 -04:00
use crate::renderer::parameters_context::ParametersContext;
Rename the new functions to replace the old functions.
2020-05-24 15:21:30 -04:00
use crate::renderer::walking::walk_path;
Had to update the 1-behind insertion for partial parameters to account for pseudo elements.
2020-05-30 12:24:50 -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
#[derive(Clone, Debug)]
pub struct CompiledTemplate<'a> {
template: Template<'a>,
Rendering spans
2020-04-11 18:25:48 -04:00
pub name: String,
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
}
Rendering spans
2020-04-11 18:25:48 -04:00
pub fn compile_template<'a>(
source: &'a str,
name: String,
) -> Result<CompiledTemplate<'a>, CompileError> {
// TODO: This could use better error management
compiling templates in the same manner as the shim
2020-04-10 20:27:27 -04:00
let (_remaining, parsed_template) = template(source).expect("Failed to compile template");
Rendering spans
2020-04-11 18:25:48 -04:00
Ok(CompiledTemplate {
compiling templates in the same manner as the shim
2020-04-10 20:27:27 -04:00
template: parsed_template,
name: name,
Rendering spans
2020-04-11 18:25:48 -04:00
})
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
}
}
pub fn load_source(&mut self, template: &'a CompiledTemplate) {
Rendering spans
2020-04-11 18:25:48 -04:00
self.templates
.insert(template.name.clone(), &template.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
Rename the new functions to replace the old functions.
2020-05-05 20:46:31 -04:00
pub fn render(
Implement the new render functions.
2020-05-05 19:51:07 -04:00
&'a self,
name: &str,
breadcrumbs: &Vec<&'a dyn ContextElement>,
Generating the new treeX
2020-05-09 22:05:43 -04: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 14:27:42 -04:00
) -> Result<String, RenderError> {
Implement the new render functions.
2020-05-05 19:51:07 -04:00
let main_template = match self.templates.get(name) {
Some(tmpl) => tmpl,
None => {
Simplified the RenderError class.
2020-05-09 14:27:42 -04:00
return Err(RenderError::TemplateNotFound(name.to_owned()));
Implement the new render functions.
2020-05-05 19:51:07 -04:00
}
};
Generating the new treeX
2020-05-09 22:05:43 -04:00
let extracted_inline_partials = extract_inline_partials(main_template);
let new_blocks = InlinePartialTreeElement::new(blocks, extracted_inline_partials);
First attempt at an implementation of the new breadcrumbs for blocks/inline partials.
2020-05-25 19:11:14 -04:00
let new_block_context = BlockContext {
breadcrumbs: breadcrumbs,
blocks: &new_blocks,
};
self.render_body(&main_template.contents, breadcrumbs, &new_block_context)
Implement the new render functions.
2020-05-05 19:51:07 -04:00
}
Cleaning up and factoring out reused code in the renderer.
2020-05-16 17:17:43 -04:00
fn render_maybe_body(
&'a self,
body: &'a Option<Body>,
breadcrumbs: &Vec<&'a dyn ContextElement>,
First attempt at an implementation of the new breadcrumbs for blocks/inline partials.
2020-05-25 19:11:14 -04:00
blocks: &'a BlockContext<'a>,
Cleaning up and factoring out reused code in the renderer.
2020-05-16 17:17:43 -04:00
) -> 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-05 20:46:31 -04:00
fn render_body(
Implement the new render functions.
2020-05-05 19:51:07 -04:00
&'a self,
body: &'a Body,
breadcrumbs: &Vec<&'a dyn ContextElement>,
First attempt at an implementation of the new breadcrumbs for blocks/inline partials.
2020-05-25 19:11:14 -04:00
blocks: &'a BlockContext<'a>,
Simplified the RenderError class.
2020-05-09 14:27:42 -04:00
) -> Result<String, RenderError> {
Implement the new render functions.
2020-05-05 19:51:07 -04: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-09 22:29:58 -04:00
output.push_str(&self.render_tag(dt, breadcrumbs, blocks)?);
Implement the new render functions.
2020-05-05 19:51:07 -04:00
}
}
}
Ok(output)
}
Integrate new_breadcrumbs into the helpers.
2020-05-25 18:08:29 -04:00
/// For rendering a dynamic partial's name
Implement the new partial type in the renderer.
2020-05-17 21:11:55 -04:00
fn render_partial_name(
&'a self,
body: &'a Vec<PartialNameElement>,
breadcrumbs: &Vec<&'a dyn ContextElement>,
First attempt at an implementation of the new breadcrumbs for blocks/inline partials.
2020-05-25 19:11:14 -04:00
blocks: &'a BlockContext<'a>,
Implement the new partial type in the renderer.
2020-05-17 21:11:55 -04:00
) -> 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-05 20:46:31 -04:00
fn render_tag(
Implement the new render functions.
2020-05-05 19:51:07 -04:00
&'a self,
tag: &'a DustTag,
breadcrumbs: &Vec<&'a dyn ContextElement>,
First attempt at an implementation of the new breadcrumbs for blocks/inline partials.
2020-05-25 19:11:14 -04:00
blocks: &'a BlockContext<'a>,
Simplified the RenderError class.
2020-05-09 14:27:42 -04:00
) -> Result<String, RenderError> {
Implement the new render functions.
2020-05-05 19:51:07 -04: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-23 23:41:05 -04:00
DustTag::DTLiteralStringBlock(literal) => return Ok((*literal).to_owned()),
Implement the new render functions.
2020-05-05 19:51:07 -04:00
DustTag::DTReference(reference) => {
Rename the new functions to replace the old functions.
2020-05-24 15:21:30 -04:00
let val = walk_path(breadcrumbs, &reference.path.keys);
Do a truthiness check on references before printing them.
2020-05-06 20:30:03 -04:00
match val {
Need to do loop elements.
2020-05-09 14:10:38 -04:00
Err(WalkError::CantWalk) => return Ok("".to_owned()),
Do a truthiness check on references before printing them.
2020-05-06 20:30:03 -04:00
Ok(final_val) => {
Switch the renderer over to using the new is_truthy value and add the injection of $idx and $len into the context tree.
2020-05-24 16:57:24 -04:00
return if final_val.is_truthy() {
final_val.render(&Self::preprocess_filters(&reference.filters))
Do a truthiness check on references before printing them.
2020-05-06 20:30:03 -04:00
} else {
Switch the renderer over to using the new is_truthy value and add the injection of $idx and $len into the context tree.
2020-05-24 16:57:24 -04:00
Ok("".to_owned())
};
Do a truthiness check on references before printing them.
2020-05-06 20:30:03 -04:00
}
Implement the new render functions.
2020-05-05 19:51:07 -04:00
}
}
DustTag::DTSection(container) => {
Attempted to move section over to the section-specific new breadcrumbs function. I think the problem is, the index context needs to be a higher priority than the new context element, but when referencing data with `{.}` the new context element needs to take priority. I could either combine entries in the context tree so that variables like $idx and $len live side-by-side with real context elements, or try to implement a way to skip over index context elements when walking up the tree.
2020-05-25 23:28:49 -04:00
let injected_context = ParametersContext::new(breadcrumbs, &container.params);
Rename the new functions to replace the old functions.
2020-05-24 15:21:30 -04:00
let val = walk_path(breadcrumbs, &container.path.keys);
Switch the renderer over to using the new is_truthy value and add the injection of $idx and $len into the context tree.
2020-05-24 16:57:24 -04:00
match val {
Err(WalkError::CantWalk) => {
Attempted to move section over to the section-specific new breadcrumbs function. I think the problem is, the index context needs to be a higher priority than the new context element, but when referencing data with `{.}` the new context element needs to take priority. I could either combine entries in the context tree so that variables like $idx and $len live side-by-side with real context elements, or try to implement a way to skip over index context elements when walking up the tree.
2020-05-25 23:28:49 -04:00
let new_breadcrumbs = Self::new_breadcrumbs_section(
Update the new_breadcrumbs function to return an Option to prevent needlessly cloning the breadcrumbs when no new contexts are to be added.
2020-05-25 15:49:30 -04:00
breadcrumbs,
None,
Attempted to move section over to the section-specific new breadcrumbs function. I think the problem is, the index context needs to be a higher priority than the new context element, but when referencing data with `{.}` the new context element needs to take priority. I could either combine entries in the context tree so that variables like $idx and $len live side-by-side with real context elements, or try to implement a way to skip over index context elements when walking up the tree.
2020-05-25 23:28:49 -04:00
Some(&injected_context),
Update the new_breadcrumbs function to return an Option to prevent needlessly cloning the breadcrumbs when no new contexts are to be added.
2020-05-25 15:49:30 -04:00
&container.explicit_context,
None,
);
Switch the renderer over to using the new is_truthy value and add the injection of $idx and $len into the context tree.
2020-05-24 16:57:24 -04:00
return self.render_maybe_body(
&container.else_contents,
Update the new_breadcrumbs function to return an Option to prevent needlessly cloning the breadcrumbs when no new contexts are to be added.
2020-05-25 15:49:30 -04:00
new_breadcrumbs.as_ref().unwrap_or(breadcrumbs),
Switch the renderer over to using the new is_truthy value and add the injection of $idx and $len into the context tree.
2020-05-24 16:57:24 -04:00
blocks,
);
}
Ok(final_val) => {
return if final_val.is_truthy() {
match &container.contents {
// If the body is empty, just shortcut
// to an empty string now rather than
// generating intermediate contexts
// and iterating for nothing.
None => Ok("".to_owned()),
Some(body) => {
let loop_elements: Vec<&dyn ContextElement> =
final_val.get_loop_elements();
if loop_elements.is_empty() {
// Scalar value
Attempted to move section over to the section-specific new breadcrumbs function. I think the problem is, the index context needs to be a higher priority than the new context element, but when referencing data with `{.}` the new context element needs to take priority. I could either combine entries in the context tree so that variables like $idx and $len live side-by-side with real context elements, or try to implement a way to skip over index context elements when walking up the tree.
2020-05-25 23:28:49 -04:00
let new_breadcrumbs = Self::new_breadcrumbs_section(
Integrate the new_breadcrumbs function into sections.
2020-05-25 15:55:52 -04:00
breadcrumbs,
None,
Attempted to move section over to the section-specific new breadcrumbs function. I think the problem is, the index context needs to be a higher priority than the new context element, but when referencing data with `{.}` the new context element needs to take priority. I could either combine entries in the context tree so that variables like $idx and $len live side-by-side with real context elements, or try to implement a way to skip over index context elements when walking up the tree.
2020-05-25 23:28:49 -04:00
Some(&injected_context),
Integrate the new_breadcrumbs function into sections.
2020-05-25 15:55:52 -04:00
&container.explicit_context,
Some(final_val),
);
self.render_body(
body,
new_breadcrumbs.as_ref().unwrap_or(breadcrumbs),
blocks,
)
Switch the renderer over to using the new is_truthy value and add the injection of $idx and $len into the context tree.
2020-05-24 16:57:24 -04:00
} 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)| {
Attempted to move section over to the section-specific new breadcrumbs function. I think the problem is, the index context needs to be a higher priority than the new context element, but when referencing data with `{.}` the new context element needs to take priority. I could either combine entries in the context tree so that variables like $idx and $len live side-by-side with real context elements, or try to implement a way to skip over index context elements when walking up the tree.
2020-05-25 23:28:49 -04:00
let index_context =
Switch the renderer over to using the new is_truthy value and add the injection of $idx and $len into the context tree.
2020-05-24 16:57:24 -04:00
IterationContext::new(i, total_length);
Attempted to move section over to the section-specific new breadcrumbs function. I think the problem is, the index context needs to be a higher priority than the new context element, but when referencing data with `{.}` the new context element needs to take priority. I could either combine entries in the context tree so that variables like $idx and $len live side-by-side with real context elements, or try to implement a way to skip over index context elements when walking up the tree.
2020-05-25 23:28:49 -04:00
let new_breadcrumbs =
Self::new_breadcrumbs_section(
breadcrumbs,
Some(&index_context),
Some(&injected_context),
&container.explicit_context,
Some(array_elem),
);
Switch the renderer over to using the new is_truthy value and add the injection of $idx and $len into the context tree.
2020-05-24 16:57:24 -04:00
self.render_body(
&body,
Integrate the new_breadcrumbs function into sections.
2020-05-25 15:55:52 -04:00
new_breadcrumbs
.as_ref()
.unwrap_or(breadcrumbs),
Switch the renderer over to using the new is_truthy value and add the injection of $idx and $len into the context tree.
2020-05-24 16:57:24 -04:00
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
Attempted to move section over to the section-specific new breadcrumbs function. I think the problem is, the index context needs to be a higher priority than the new context element, but when referencing data with `{.}` the new context element needs to take priority. I could either combine entries in the context tree so that variables like $idx and $len live side-by-side with real context elements, or try to implement a way to skip over index context elements when walking up the tree.
2020-05-25 23:28:49 -04:00
let new_breadcrumbs = Self::new_breadcrumbs_section(
Integrate the new_breadcrumbs function into sections.
2020-05-25 15:55:52 -04:00
breadcrumbs,
None,
Attempted to move section over to the section-specific new breadcrumbs function. I think the problem is, the index context needs to be a higher priority than the new context element, but when referencing data with `{.}` the new context element needs to take priority. I could either combine entries in the context tree so that variables like $idx and $len live side-by-side with real context elements, or try to implement a way to skip over index context elements when walking up the tree.
2020-05-25 23:28:49 -04:00
Some(&injected_context),
Integrate the new_breadcrumbs function into sections.
2020-05-25 15:55:52 -04:00
&container.explicit_context,
None,
);
Switch the renderer over to using the new is_truthy value and add the injection of $idx and $len into the context tree.
2020-05-24 16:57:24 -04:00
return self.render_maybe_body(
&container.else_contents,
Integrate the new_breadcrumbs function into sections.
2020-05-25 15:55:52 -04:00
new_breadcrumbs.as_ref().unwrap_or(breadcrumbs),
Switch the renderer over to using the new is_truthy value and add the injection of $idx and $len into the context tree.
2020-05-24 16:57:24 -04:00
blocks,
);
};
Implement the new render functions.
2020-05-05 19:51:07 -04:00
}
}
}
Add support for the exists tag.
2020-05-06 19:10:09 -04:00
DustTag::DTExists(container) => {
Attempted to move section over to the section-specific new breadcrumbs function. I think the problem is, the index context needs to be a higher priority than the new context element, but when referencing data with `{.}` the new context element needs to take priority. I could either combine entries in the context tree so that variables like $idx and $len live side-by-side with real context elements, or try to implement a way to skip over index context elements when walking up the tree.
2020-05-25 23:28:49 -04:00
let new_breadcrumbs = Self::new_breadcrumbs_partial(
First attempt at an implementation of the new breadcrumbs for blocks/inline partials.
2020-05-25 19:11:14 -04:00
breadcrumbs,
breadcrumbs,
None,
&container.explicit_context,
);
Rename the new functions to replace the old functions.
2020-05-24 15:21:30 -04:00
let val = walk_path(breadcrumbs, &container.path.keys);
Switch the renderer over to using the new is_truthy value and add the injection of $idx and $len into the context tree.
2020-05-24 16:57:24 -04:00
return if val.map(|v| v.is_truthy()).unwrap_or(false) {
Integrated new_breadcrumbs into exists and not exists, and partially integrated it into partials.
2020-05-25 16:03:00 -04:00
self.render_maybe_body(
&container.contents,
new_breadcrumbs.as_ref().unwrap_or(breadcrumbs),
blocks,
)
Switch the renderer over to using the new is_truthy value and add the injection of $idx and $len into the context tree.
2020-05-24 16:57:24 -04:00
} else {
Integrated new_breadcrumbs into exists and not exists, and partially integrated it into partials.
2020-05-25 16:03:00 -04:00
self.render_maybe_body(
&container.else_contents,
new_breadcrumbs.as_ref().unwrap_or(breadcrumbs),
blocks,
)
Cleaning up and factoring out reused code in the renderer.
2020-05-16 17:17:43 -04:00
};
Add support for the exists tag.
2020-05-06 19:10:09 -04: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-06 20:13:33 -04:00
DustTag::DTNotExists(container) => {
Attempted to move section over to the section-specific new breadcrumbs function. I think the problem is, the index context needs to be a higher priority than the new context element, but when referencing data with `{.}` the new context element needs to take priority. I could either combine entries in the context tree so that variables like $idx and $len live side-by-side with real context elements, or try to implement a way to skip over index context elements when walking up the tree.
2020-05-25 23:28:49 -04:00
let new_breadcrumbs = Self::new_breadcrumbs_partial(
First attempt at an implementation of the new breadcrumbs for blocks/inline partials.
2020-05-25 19:11:14 -04:00
breadcrumbs,
breadcrumbs,
None,
&container.explicit_context,
);
Rename the new functions to replace the old functions.
2020-05-24 15:21:30 -04:00
let val = walk_path(breadcrumbs, &container.path.keys);
Switch the renderer over to using the new is_truthy value and add the injection of $idx and $len into the context tree.
2020-05-24 16:57:24 -04:00
return if !val.map(|v| v.is_truthy()).unwrap_or(false) {
Integrated new_breadcrumbs into exists and not exists, and partially integrated it into partials.
2020-05-25 16:03:00 -04:00
self.render_maybe_body(
&container.contents,
new_breadcrumbs.as_ref().unwrap_or(breadcrumbs),
blocks,
)
Switch the renderer over to using the new is_truthy value and add the injection of $idx and $len into the context tree.
2020-05-24 16:57:24 -04:00
} else {
Integrated new_breadcrumbs into exists and not exists, and partially integrated it into partials.
2020-05-25 16:03:00 -04:00
self.render_maybe_body(
&container.else_contents,
new_breadcrumbs.as_ref().unwrap_or(breadcrumbs),
blocks,
)
Cleaning up and factoring out reused code in the renderer.
2020-05-16 17:17:43 -04: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-06 20:13:33 -04:00
}
Renamed the new partial implementation to the old partial name.
2020-05-17 21:17:34 -04:00
DustTag::DTPartial(partial) => {
Implement the new partial type in the renderer.
2020-05-17 21:11:55 -04:00
let partial_name = self.render_partial_name(&partial.name, breadcrumbs, blocks)?;
if partial.params.is_empty() {
Attempted to move section over to the section-specific new breadcrumbs function. I think the problem is, the index context needs to be a higher priority than the new context element, but when referencing data with `{.}` the new context element needs to take priority. I could either combine entries in the context tree so that variables like $idx and $len live side-by-side with real context elements, or try to implement a way to skip over index context elements when walking up the tree.
2020-05-25 23:28:49 -04:00
let new_breadcrumbs = Self::new_breadcrumbs_partial(
First attempt at an implementation of the new breadcrumbs for blocks/inline partials.
2020-05-25 19:11:14 -04:00
breadcrumbs,
breadcrumbs,
None,
&partial.explicit_context,
);
Integrated new_breadcrumbs into exists and not exists, and partially integrated it into partials.
2020-05-25 16:03:00 -04:00
let rendered_content = self.render_template(
&partial_name,
new_breadcrumbs.as_ref().unwrap_or(breadcrumbs),
First attempt at an implementation of the new breadcrumbs for blocks/inline partials.
2020-05-25 19:11:14 -04:00
Some(blocks.blocks),
Integrated new_breadcrumbs into exists and not exists, and partially integrated it into partials.
2020-05-25 16:03:00 -04:00
)?;
Implement the new partial type in the renderer.
2020-05-17 21:11:55 -04:00
return Ok(rendered_content);
} else {
let injected_context = ParametersContext::new(breadcrumbs, &partial.params);
Attempted to move section over to the section-specific new breadcrumbs function. I think the problem is, the index context needs to be a higher priority than the new context element, but when referencing data with `{.}` the new context element needs to take priority. I could either combine entries in the context tree so that variables like $idx and $len live side-by-side with real context elements, or try to implement a way to skip over index context elements when walking up the tree.
2020-05-25 23:28:49 -04:00
let new_breadcrumbs = Self::new_breadcrumbs_partial(
First attempt at an implementation of the new breadcrumbs for blocks/inline partials.
2020-05-25 19:11:14 -04:00
breadcrumbs,
Add a special case to new_breadcrumbs for when theres an injected context but no explicit context or new context element and finish the partial integration.
2020-05-25 16:30:15 -04:00
breadcrumbs,
Some(&injected_context),
&partial.explicit_context,
);
let rendered_content = self.render_template(
&partial_name,
new_breadcrumbs.as_ref().unwrap_or(breadcrumbs),
First attempt at an implementation of the new breadcrumbs for blocks/inline partials.
2020-05-25 19:11:14 -04:00
Some(blocks.blocks),
Add a special case to new_breadcrumbs for when theres an injected context but no explicit context or new context element and finish the partial integration.
2020-05-25 16:30:15 -04:00
)?;
Implement the new partial type in the renderer.
2020-05-17 21:11:55 -04:00
return Ok(rendered_content);
}
}
Cleaning up and factoring out reused code in the renderer.
2020-05-16 17:17:43 -04:00
DustTag::DTInlinePartial(_named_block) => {
I think I have the full extraction code.
2020-05-09 21:30:54 -04:00
// Inline partials are blank during rendering (they get injected into blocks)
return Ok("".to_owned());
}
DustTag::DTBlock(named_block) => {
Attempted to move section over to the section-specific new breadcrumbs function. I think the problem is, the index context needs to be a higher priority than the new context element, but when referencing data with `{.}` the new context element needs to take priority. I could either combine entries in the context tree so that variables like $idx and $len live side-by-side with real context elements, or try to implement a way to skip over index context elements when walking up the tree.
2020-05-25 23:28:49 -04:00
let new_breadcrumbs = Self::new_breadcrumbs_partial(
I did it backwards, I needed to use the explicit context from the block, not the inline partial.
2020-05-25 19:22:20 -04:00
breadcrumbs,
blocks.breadcrumbs,
None,
&named_block.explicit_context,
);
Get rid of the concept of NamedBlock and replace it with a ParameterizedBlock special case that does not support an else block.
2020-05-30 14:39:31 -04:00
return match blocks.blocks.get_block(named_block.path.keys[0]) {
First attempt at an implementation of the new breadcrumbs for blocks/inline partials.
2020-05-25 19:11:14 -04:00
None => self.render_maybe_body(
&named_block.contents,
new_breadcrumbs.as_ref().unwrap_or(breadcrumbs),
blocks,
),
I did it backwards, I needed to use the explicit context from the block, not the inline partial.
2020-05-25 19:22:20 -04:00
Some(inline_partial) => self.render_maybe_body(
inline_partial,
First attempt at an implementation of the new breadcrumbs for blocks/inline partials.
2020-05-25 19:11:14 -04:00
new_breadcrumbs.as_ref().unwrap_or(breadcrumbs),
blocks,
),
Finished implementing Named blocks and inline partials.
2020-05-09 22:48:30 -04:00
};
I think I have the full extraction code.
2020-05-09 21:30:54 -04:00
}
Getting the left and right sides.
2020-05-10 14:22:59 -04:00
DustTag::DTHelperEquals(parameterized_block) => {
Attempted to move section over to the section-specific new breadcrumbs function. I think the problem is, the index context needs to be a higher priority than the new context element, but when referencing data with `{.}` the new context element needs to take priority. I could either combine entries in the context tree so that variables like $idx and $len live side-by-side with real context elements, or try to implement a way to skip over index context elements when walking up the tree.
2020-05-25 23:28:49 -04:00
let new_breadcrumbs = Self::new_breadcrumbs_partial(
First attempt at an implementation of the new breadcrumbs for blocks/inline partials.
2020-05-25 19:11:14 -04:00
breadcrumbs,
Integrate new_breadcrumbs into the helpers.
2020-05-25 18:08:29 -04:00
breadcrumbs,
None,
&parameterized_block.explicit_context,
);
Cleaning up and factoring out reused code in the renderer.
2020-05-16 17:17:43 -04: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 15:22:48 -04: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) => {
Integrate new_breadcrumbs into the helpers.
2020-05-25 18:08:29 -04:00
let rendered_content = self.render_body(
body,
new_breadcrumbs.as_ref().unwrap_or(breadcrumbs),
blocks,
)?;
Add a check to the equality helper to mark identical paths as equal.
2020-05-16 15:22:48 -04:00
Ok(rendered_content)
}
};
}
Cleaning up and factoring out reused code in the renderer.
2020-05-16 17:17:43 -04: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 14:22:59 -04:00
};
Cleaning up and factoring out reused code in the renderer.
2020-05-16 17:17:43 -04:00
let right_side: Result<&dyn ContextElement, WalkError> =
Self::get_rval(breadcrumbs, &param_map, "value")
.unwrap_or(Err(WalkError::CantWalk));
Integrate new_breadcrumbs into the helpers.
2020-05-25 18:08:29 -04:00
PartialEq works with results too.
2020-05-10 21:00:52 -04:00
if left_side == right_side {
Cleaning up and factoring out reused code in the renderer.
2020-05-16 17:17:43 -04:00
return self.render_maybe_body(
&parameterized_block.contents,
Integrate new_breadcrumbs into the helpers.
2020-05-25 18:08:29 -04:00
new_breadcrumbs.as_ref().unwrap_or(breadcrumbs),
Cleaning up and factoring out reused code in the renderer.
2020-05-16 17:17:43 -04:00
blocks,
);
Finish implementing DTHelperEquals.
2020-05-10 21:14:51 -04:00
} else {
Cleaning up and factoring out reused code in the renderer.
2020-05-16 17:17:43 -04:00
return self.render_maybe_body(
&parameterized_block.else_contents,
Integrate new_breadcrumbs into the helpers.
2020-05-25 18:08:29 -04:00
new_breadcrumbs.as_ref().unwrap_or(breadcrumbs),
Cleaning up and factoring out reused code in the renderer.
2020-05-16 17:17:43 -04:00
blocks,
);
Implemented the not equals helper.
2020-05-16 12:26:28 -04:00
}
}
DustTag::DTHelperNotEquals(parameterized_block) => {
Attempted to move section over to the section-specific new breadcrumbs function. I think the problem is, the index context needs to be a higher priority than the new context element, but when referencing data with `{.}` the new context element needs to take priority. I could either combine entries in the context tree so that variables like $idx and $len live side-by-side with real context elements, or try to implement a way to skip over index context elements when walking up the tree.
2020-05-25 23:28:49 -04:00
let new_breadcrumbs = Self::new_breadcrumbs_partial(
First attempt at an implementation of the new breadcrumbs for blocks/inline partials.
2020-05-25 19:11:14 -04:00
breadcrumbs,
Integrate new_breadcrumbs into the helpers.
2020-05-25 18:08:29 -04:00
breadcrumbs,
None,
&parameterized_block.explicit_context,
);
Cleaning up and factoring out reused code in the renderer.
2020-05-16 17:17:43 -04: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 15:30:17 -04: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) => {
Integrate new_breadcrumbs into the helpers.
2020-05-25 18:08:29 -04:00
let rendered_content = self.render_body(
body,
new_breadcrumbs.as_ref().unwrap_or(breadcrumbs),
blocks,
)?;
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 15:30:17 -04:00
Ok(rendered_content)
}
};
}
Cleaning up and factoring out reused code in the renderer.
2020-05-16 17:17:43 -04: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 12:26:28 -04:00
};
Cleaning up and factoring out reused code in the renderer.
2020-05-16 17:17:43 -04: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 12:26:28 -04:00
if left_side != right_side {
Cleaning up and factoring out reused code in the renderer.
2020-05-16 17:17:43 -04:00
return self.render_maybe_body(
&parameterized_block.contents,
Integrate new_breadcrumbs into the helpers.
2020-05-25 18:08:29 -04:00
new_breadcrumbs.as_ref().unwrap_or(breadcrumbs),
Cleaning up and factoring out reused code in the renderer.
2020-05-16 17:17:43 -04:00
blocks,
);
Implemented the not equals helper.
2020-05-16 12:26:28 -04:00
} else {
Cleaning up and factoring out reused code in the renderer.
2020-05-16 17:17:43 -04:00
return self.render_maybe_body(
&parameterized_block.else_contents,
Integrate new_breadcrumbs into the helpers.
2020-05-25 18:08:29 -04:00
new_breadcrumbs.as_ref().unwrap_or(breadcrumbs),
Cleaning up and factoring out reused code in the renderer.
2020-05-16 17:17:43 -04:00
blocks,
);
tentatively seems to be working.
2020-05-10 19:16:55 -04:00
}
Getting the left and right sides.
2020-05-10 14:22:59 -04:00
}
Add a test for gte.
2020-05-16 15:45:57 -04:00
DustTag::DTHelperGreaterThan(parameterized_block) => {
Attempted to move section over to the section-specific new breadcrumbs function. I think the problem is, the index context needs to be a higher priority than the new context element, but when referencing data with `{.}` the new context element needs to take priority. I could either combine entries in the context tree so that variables like $idx and $len live side-by-side with real context elements, or try to implement a way to skip over index context elements when walking up the tree.
2020-05-25 23:28:49 -04:00
let new_breadcrumbs = Self::new_breadcrumbs_partial(
First attempt at an implementation of the new breadcrumbs for blocks/inline partials.
2020-05-25 19:11:14 -04:00
breadcrumbs,
Integrate new_breadcrumbs into the helpers.
2020-05-25 18:08:29 -04:00
breadcrumbs,
None,
&parameterized_block.explicit_context,
);
Cleaning up and factoring out reused code in the renderer.
2020-05-16 17:17:43 -04: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 16:24:36 -04:00
};
Cleaning up and factoring out reused code in the renderer.
2020-05-16 17:17:43 -04: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 16:24:36 -04:00
match (left_side, right_side) {
Initial attempt at implementation, tests not working.
2020-05-16 18:28:23 -04:00
(Err(_), _) | (_, Err(_)) => {
return self.render_maybe_body(
&parameterized_block.else_contents,
Integrate new_breadcrumbs into the helpers.
2020-05-25 18:08:29 -04:00
new_breadcrumbs.as_ref().unwrap_or(breadcrumbs),
Initial attempt at implementation, tests not working.
2020-05-16 18:28:23 -04:00
blocks,
)
}
Have greater than helper very close to correct. Just need to make it compare arrays of scalars.
2020-05-16 16:24:36 -04: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 17:17:43 -04:00
return self.render_maybe_body(
&parameterized_block.contents,
Integrate new_breadcrumbs into the helpers.
2020-05-25 18:08:29 -04:00
new_breadcrumbs.as_ref().unwrap_or(breadcrumbs),
Cleaning up and factoring out reused code in the renderer.
2020-05-16 17:17:43 -04:00
blocks,
);
Have greater than helper very close to correct. Just need to make it compare arrays of scalars.
2020-05-16 16:24:36 -04:00
} else {
Cleaning up and factoring out reused code in the renderer.
2020-05-16 17:17:43 -04:00
return self.render_maybe_body(
&parameterized_block.else_contents,
Integrate new_breadcrumbs into the helpers.
2020-05-25 18:08:29 -04:00
new_breadcrumbs.as_ref().unwrap_or(breadcrumbs),
Cleaning up and factoring out reused code in the renderer.
2020-05-16 17:17:43 -04:00
blocks,
);
Have greater than helper very close to correct. Just need to make it compare arrays of scalars.
2020-05-16 16:24:36 -04:00
}
}
}
Add a test for gte.
2020-05-16 15:45:57 -04:00
}
Implement less-than.
2020-05-16 19:05:03 -04:00
DustTag::DTHelperGreaterThanOrEquals(parameterized_block) => {
Attempted to move section over to the section-specific new breadcrumbs function. I think the problem is, the index context needs to be a higher priority than the new context element, but when referencing data with `{.}` the new context element needs to take priority. I could either combine entries in the context tree so that variables like $idx and $len live side-by-side with real context elements, or try to implement a way to skip over index context elements when walking up the tree.
2020-05-25 23:28:49 -04:00
let new_breadcrumbs = Self::new_breadcrumbs_partial(
First attempt at an implementation of the new breadcrumbs for blocks/inline partials.
2020-05-25 19:11:14 -04:00
breadcrumbs,
Integrate new_breadcrumbs into the helpers.
2020-05-25 18:08:29 -04:00
breadcrumbs,
None,
&parameterized_block.explicit_context,
);
Initial attempt at implementation, tests not working.
2020-05-16 18:28:23 -04: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 18:36:47 -04:00
&parameterized_block.else_contents,
Integrate new_breadcrumbs into the helpers.
2020-05-25 18:08:29 -04:00
new_breadcrumbs.as_ref().unwrap_or(breadcrumbs),
Initial attempt at implementation, tests not working.
2020-05-16 18:28:23 -04:00
blocks,
)
}
(Ok(left_side_unwrapped), Ok(right_side_unwrapped)) => {
Switched over to using operators instead of compare in the renderer.
2020-05-16 23:10:04 -04:00
if left_side_unwrapped >= right_side_unwrapped {
return self.render_maybe_body(
&parameterized_block.contents,
Integrate new_breadcrumbs into the helpers.
2020-05-25 18:08:29 -04:00
new_breadcrumbs.as_ref().unwrap_or(breadcrumbs),
Switched over to using operators instead of compare in the renderer.
2020-05-16 23:10:04 -04:00
blocks,
);
} else {
return self.render_maybe_body(
Initial attempt at implementation, tests not working.
2020-05-16 18:28:23 -04:00
&parameterized_block.else_contents,
Integrate new_breadcrumbs into the helpers.
2020-05-25 18:08:29 -04:00
new_breadcrumbs.as_ref().unwrap_or(breadcrumbs),
Initial attempt at implementation, tests not working.
2020-05-16 18:28:23 -04:00
blocks,
Switched over to using operators instead of compare in the renderer.
2020-05-16 23:10:04 -04:00
);
}
Initial attempt at implementation, tests not working.
2020-05-16 18:28:23 -04:00
}
}
}
Implement less-than.
2020-05-16 19:05:03 -04:00
DustTag::DTHelperLessThan(parameterized_block) => {
Attempted to move section over to the section-specific new breadcrumbs function. I think the problem is, the index context needs to be a higher priority than the new context element, but when referencing data with `{.}` the new context element needs to take priority. I could either combine entries in the context tree so that variables like $idx and $len live side-by-side with real context elements, or try to implement a way to skip over index context elements when walking up the tree.
2020-05-25 23:28:49 -04:00
let new_breadcrumbs = Self::new_breadcrumbs_partial(
First attempt at an implementation of the new breadcrumbs for blocks/inline partials.
2020-05-25 19:11:14 -04:00
breadcrumbs,
Integrate new_breadcrumbs into the helpers.
2020-05-25 18:08:29 -04:00
breadcrumbs,
None,
&parameterized_block.explicit_context,
);
Implement less-than.
2020-05-16 19:05:03 -04: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(
&parameterized_block.else_contents,
Integrate new_breadcrumbs into the helpers.
2020-05-25 18:08:29 -04:00
new_breadcrumbs.as_ref().unwrap_or(breadcrumbs),
Implement less-than.
2020-05-16 19:05:03 -04:00
blocks,
)
}
(Ok(left_side_unwrapped), Ok(right_side_unwrapped)) => {
if left_side_unwrapped < right_side_unwrapped {
return self.render_maybe_body(
&parameterized_block.contents,
Integrate new_breadcrumbs into the helpers.
2020-05-25 18:08:29 -04:00
new_breadcrumbs.as_ref().unwrap_or(breadcrumbs),
Implement less-than.
2020-05-16 19:05:03 -04:00
blocks,
);
} else {
return self.render_maybe_body(
&parameterized_block.else_contents,
Integrate new_breadcrumbs into the helpers.
2020-05-25 18:08:29 -04:00
new_breadcrumbs.as_ref().unwrap_or(breadcrumbs),
Implement less-than.
2020-05-16 19:05:03 -04:00
blocks,
);
}
}
}
}
Implement less than or equals.
2020-05-16 19:06:40 -04:00
DustTag::DTHelperLessThanOrEquals(parameterized_block) => {
Attempted to move section over to the section-specific new breadcrumbs function. I think the problem is, the index context needs to be a higher priority than the new context element, but when referencing data with `{.}` the new context element needs to take priority. I could either combine entries in the context tree so that variables like $idx and $len live side-by-side with real context elements, or try to implement a way to skip over index context elements when walking up the tree.
2020-05-25 23:28:49 -04:00
let new_breadcrumbs = Self::new_breadcrumbs_partial(
First attempt at an implementation of the new breadcrumbs for blocks/inline partials.
2020-05-25 19:11:14 -04:00
breadcrumbs,
Integrate new_breadcrumbs into the helpers.
2020-05-25 18:08:29 -04:00
breadcrumbs,
None,
&parameterized_block.explicit_context,
);
Implement less than or equals.
2020-05-16 19:06:40 -04: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(
&parameterized_block.else_contents,
Integrate new_breadcrumbs into the helpers.
2020-05-25 18:08:29 -04:00
new_breadcrumbs.as_ref().unwrap_or(breadcrumbs),
Implement less than or equals.
2020-05-16 19:06:40 -04:00
blocks,
)
}
(Ok(left_side_unwrapped), Ok(right_side_unwrapped)) => {
Switched over to using operators instead of compare in the renderer.
2020-05-16 23:10:04 -04:00
if left_side_unwrapped <= right_side_unwrapped {
return self.render_maybe_body(
&parameterized_block.contents,
Integrate new_breadcrumbs into the helpers.
2020-05-25 18:08:29 -04:00
new_breadcrumbs.as_ref().unwrap_or(breadcrumbs),
Switched over to using operators instead of compare in the renderer.
2020-05-16 23:10:04 -04:00
blocks,
);
} else {
return self.render_maybe_body(
Implement less than or equals.
2020-05-16 19:06:40 -04:00
&parameterized_block.else_contents,
Integrate new_breadcrumbs into the helpers.
2020-05-25 18:08:29 -04:00
new_breadcrumbs.as_ref().unwrap_or(breadcrumbs),
Implement less than or equals.
2020-05-16 19:06:40 -04:00
blocks,
Switched over to using operators instead of compare in the renderer.
2020-05-16 23:10:04 -04:00
);
}
Implement less than or equals.
2020-05-16 19:06:40 -04:00
}
}
}
Implement the new render functions.
2020-05-05 19:51:07 -04: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 15:29:02 -04: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 14:14:22 -04: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 15:29:02 -04:00
}
}
Add a check to the equality helper to mark identical paths as equal.
2020-05-16 15:22:48 -04: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 17:17:43 -04: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>(
Fix the last case by changing the lifetimes and delete the old fractured implementation.
2020-05-24 15:01:41 -04:00
breadcrumbs: &'b Vec<&'b dyn ContextElement>,
Cleaning up and factoring out reused code in the renderer.
2020-05-16 17:17:43 -04:00
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-16 22:30:04 -04:00
RValue::RVLiteral(literal) => Some(Ok(literal)),
Rename the new functions to replace the old functions.
2020-05-24 15:21:30 -04:00
RValue::RVPath(path) => Some(walk_path(breadcrumbs, &path.keys)),
Cleaning up and factoring out reused code in the renderer.
2020-05-16 17:17:43 -04:00
},
}
}
Automatically appending the html escape filter on the renderer side.
2020-05-23 17:57:19 -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
I was wrong, html escape filter is appended even if an html escape filter is already there.
2020-05-23 18:18:59 -04:00
if !filters.iter().any(|f| f == &Filter::DisableHtmlEncode) {
Automatically appending the html escape filter on the renderer side.
2020-05-23 17:57:19 -04:00
final_filters.push(Filter::HtmlEncode);
}
final_filters
}
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
/// Generate a new breadcrumbs object
///
/// This function generates a new breadcrumbs object based on the
/// new context information provided.
///
First attempt at an implementation of the new breadcrumbs for blocks/inline partials.
2020-05-25 19:11:14 -04:00
/// breadcrumbs are the breadcrumbs that will be used in the final
/// breadcrumbs (unless omitted due to an explicit context)
///
/// explicit_context_breadcrumbs are the breadcrumbs used to
/// evaluate an explicit context path. Most of the time the two
/// breadcrumbs parameters will be identical, but for
/// blocks/inline partials the explicit_context_breadcrumbs will
/// be the breadcrumbs from the start of the partial containing
/// the block.
///
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
/// explicit_context is for contexts specified with a `:path`
/// inside a dust tag.
///
/// injected_context is for any generated context. This includes
/// both parameters on a tag and also the handling of $idx and
/// $len.
///
/// New context element is the element is an element to append to
/// the end, generally for use in section tags which walk to a new
/// context.
///
/// If explicit_context is not None, then the final breadcrumb stack will be:
///
Integrate new_breadcrumbs into the helpers.
2020-05-25 18:08:29 -04:00
/// ```text
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
/// breadcrumbs
/// injected_context
/// new_context_element
/// ```
///
/// However, if explicit_context is not None, then the old
/// breadcrumbs are omitted, leading to the new breadcrumb stack
/// as:
///
Integrate new_breadcrumbs into the helpers.
2020-05-25 18:08:29 -04:00
/// ```text
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
/// injected_context
/// explicit_context
/// new_context_element
/// ```
Attempted to move section over to the section-specific new breadcrumbs function. I think the problem is, the index context needs to be a higher priority than the new context element, but when referencing data with `{.}` the new context element needs to take priority. I could either combine entries in the context tree so that variables like $idx and $len live side-by-side with real context elements, or try to implement a way to skip over index context elements when walking up the tree.
2020-05-25 23:28:49 -04:00
fn new_breadcrumbs_deprecated<'b>(
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
breadcrumbs: &'b Vec<&'b dyn ContextElement>,
First attempt at an implementation of the new breadcrumbs for blocks/inline partials.
2020-05-25 19:11:14 -04:00
explicit_context_breadcrumbs: &'b Vec<&'b dyn ContextElement>,
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
injected_context: Option<&'b dyn ContextElement>,
explicit_context: &Option<Path<'b>>,
new_context_element: Option<&'b dyn ContextElement>,
Update the new_breadcrumbs function to return an Option to prevent needlessly cloning the breadcrumbs when no new contexts are to be added.
2020-05-25 15:49:30 -04:00
) -> Option<Vec<&'b dyn ContextElement>> {
// 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, new_context_element) {
(None, None, None) => return None,
_ => (),
};
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
let mut new_stack = match explicit_context {
Some(_) => Vec::with_capacity(3),
None => breadcrumbs.clone(),
};
Added tests proving that the explicit context is evaluated using the global context of the partial containing the block (NOT the inline partial, which is where the explicit context is written).
2020-05-25 17:53:04 -04:00
// TODO: Can sections have parameters, and if so, what happens then? Currently when there is an injected context or an explicit context it gets inserted behind the current context, so 1->2->3 becomes 1->2->injected->3 or explicit->3. When there is a new context(4) with injected we're doing 1->2->3->injected->4. When there is an explicit context and a new context we're doing explicit->4. But what happens if there is a section with parameters and an explicit context, hitting all the categories? Would it be parameters->explicit->4? I would definitely have to change the parameters to this function since right now iteration variables and parameters are both sharing injected_context.
Add a special case to new_breadcrumbs for when theres an injected context but no explicit context or new context element and finish the partial integration.
2020-05-25 16:30:15 -04:00
injected_context.map(|ctx| {
// Special case: when there is no explicit context or new
// context element, 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 and new context
// element.
match (explicit_context, new_context_element) {
(None, None) => new_stack.insert(std::cmp::max(new_stack.len() - 1, 0), ctx),
_ => new_stack.push(ctx),
}
});
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
explicit_context.as_ref().map(|path| {
First attempt at an implementation of the new breadcrumbs for blocks/inline partials.
2020-05-25 19:11:14 -04:00
walk_path(explicit_context_breadcrumbs, &path.keys).map(|val| {
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
if val.is_truthy() {
new_stack.push(val)
}
});
});
new_context_element.map(|ctx| new_stack.push(ctx));
Update the new_breadcrumbs function to return an Option to prevent needlessly cloning the breadcrumbs when no new contexts are to be added.
2020-05-25 15:49:30 -04:00
Some(new_stack)
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
}
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>(
breadcrumbs: &'b Vec<&'b dyn ContextElement>,
index_context: Option<&'b dyn ContextElement>,
injected_context: Option<&'b dyn ContextElement>,
explicit_context: &Option<Path<'b>>,
new_context_element: Option<&'b dyn ContextElement>,
) -> Option<Vec<&'b dyn ContextElement>> {
// 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,
_ => (),
}
let mut new_stack = match explicit_context {
Some(_) => Vec::with_capacity(4),
None => breadcrumbs.clone(),
};
explicit_context.as_ref().map(|path| {
walk_path(breadcrumbs, &path.keys).map(|val| {
if val.is_truthy() {
new_stack.push(val)
}
});
});
injected_context.map(|ctx| new_stack.push(ctx));
new_context_element.map(|ctx| new_stack.push(ctx));
index_context.map(|ctx| new_stack.push(ctx));
Some(new_stack)
}
Had to update the 1-behind insertion for partial parameters to account for pseudo elements.
2020-05-30 12:24:50 -04:00
fn get_index_of_first_non_pseudo_element<'b, B>(breadcrumbs: &'b Vec<B>) -> Option<usize>
where
B: Borrow<dyn ContextElement + 'a>,
{
breadcrumbs
.iter()
.rposition(|b| !(*b).borrow().is_pseudo_element())
}
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_partial<'b>(
breadcrumbs: &'b Vec<&'b dyn ContextElement>,
explicit_context_breadcrumbs: &'b Vec<&'b dyn ContextElement>,
injected_context: Option<&'b dyn ContextElement>,
explicit_context: &Option<Path<'b>>,
) -> Option<Vec<&'b dyn ContextElement>> {
// 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,
_ => (),
};
let mut new_stack = match explicit_context {
Some(_) => Vec::with_capacity(3),
None => breadcrumbs.clone(),
};
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 {
Had to update the 1-behind insertion for partial parameters to account for pseudo elements.
2020-05-30 12:24:50 -04:00
None => new_stack.insert(
Self::get_index_of_first_non_pseudo_element(&new_stack).unwrap_or(0),
ctx,
),
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
_ => new_stack.push(ctx),
}
});
explicit_context.as_ref().map(|path| {
walk_path(explicit_context_breadcrumbs, &path.keys).map(|val| {
if val.is_truthy() {
new_stack.push(val)
}
});
});
Some(new_stack)
}
Loading the compiled templates into a context
2020-04-10 20:55:44 -04:00
}
initial walkable implementation
2020-04-11 20:31:44 -04:00
First attempt at an implementation of the new breadcrumbs for blocks/inline partials.
2020-05-25 19:11:14 -04:00
struct BlockContext<'a> {
/// The breadcrumbs at the time of entering the current partial
breadcrumbs: &'a Vec<&'a dyn ContextElement>,
blocks: &'a InlinePartialTreeElement<'a>,
}
initial walkable implementation
2020-04-11 20:31:44 -04: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-12 21:54:15 -04:00
use crate::parser::Filter;
Add a Loopable trait for dust sections.
2020-04-28 19:34:52 -04:00
use crate::renderer::context_element::Loopable;
Combine the render traits into a single context_element file.
2020-04-28 19:09:02 -04:00
use crate::renderer::context_element::Renderable;
Add a new trait to ContextElement for Truthiness. Before I was relying on Loopable to both determine truthiness and get a list of elements to loop over. This will no longer work since I need to only set $idx and $len when iterating over actual arrays, as opposed to all truthy values, so I've finally made truthiness explicit.
2020-05-24 16:16:43 -04:00
use crate::renderer::context_element::Truthiness;
Combine the render traits into a single context_element file.
2020-04-28 19:09:02 -04:00
use crate::renderer::context_element::Walkable;
Revived the tests.
2020-05-10 23:26:15 -04:00
use crate::renderer::CompareContextElement;
Fix a bug w.r.t. quoting and escaping boolean values with filters.
2020-05-23 19:34:38 -04:00
use std::cmp::Ordering;
initial walkable implementation
2020-04-11 20:31:44 -04:00
Fix tests.
2020-05-16 22:39:29 -04:00
impl ContextElement for String {}
Add a new trait to ContextElement for Truthiness. Before I was relying on Loopable to both determine truthiness and get a list of elements to loop over. This will no longer work since I need to only set $idx and $len when iterating over actual arrays, as opposed to all truthy values, so I've finally made truthiness explicit.
2020-05-24 16:16:43 -04:00
impl Truthiness for String {
fn is_truthy(&self) -> bool {
!self.is_empty()
}
}
Fix tests.
2020-05-16 22:39:29 -04:00
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> {
Switch the get_loop_elements implementation to only return populated arrays when its an array-like object.
2020-05-24 16:27:13 -04:00
Vec::new()
Fix tests.
2020-05-16 22:39:29 -04:00
}
}
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 {}
Add a new trait to ContextElement for Truthiness. Before I was relying on Loopable to both determine truthiness and get a list of elements to loop over. This will no longer work since I need to only set $idx and $len when iterating over actual arrays, as opposed to all truthy values, so I've finally made truthiness explicit.
2020-05-24 16:16:43 -04:00
impl Truthiness for u64 {
fn is_truthy(&self) -> bool {
true
}
}
Fix tests.
2020-05-16 22:39:29 -04:00
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> {
Switch the get_loop_elements implementation to only return populated arrays when its an array-like object.
2020-05-24 16:27:13 -04:00
Vec::new()
Fix tests.
2020-05-16 22:39:29 -04:00
}
}
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-10 23:26:15 -04:00
impl<I: 'static + ContextElement + Clone> ContextElement for HashMap<String, I> {}
Switching to a combined ContextElement trait for Walkable and Renderable
2020-04-11 22:19:54 -04:00
Add a new trait to ContextElement for Truthiness. Before I was relying on Loopable to both determine truthiness and get a list of elements to loop over. This will no longer work since I need to only set $idx and $len when iterating over actual arrays, as opposed to all truthy values, so I've finally made truthiness explicit.
2020-05-24 16:16:43 -04:00
impl<I: ContextElement> Truthiness for HashMap<String, I> {
fn is_truthy(&self) -> bool {
true
}
}
Revived the tests.
2020-05-10 23:26:15 -04:00
impl<I: ContextElement> Renderable for HashMap<String, I> {
Start of porting over the walk tests.
2020-05-05 20:22:25 -04:00
fn render(&self, _filters: &Vec<Filter>) -> Result<String, RenderError> {
// TODO: handle the filters
Remove CantRender, it was unused.
2020-05-09 13:46:12 -04:00
Ok("[object Object]".to_owned())
initial walkable implementation
2020-04-11 20:31:44 -04:00
}
Start of porting over the walk tests.
2020-05-05 20:22:25 -04:00
}
initial walkable implementation
2020-04-11 20:31:44 -04:00
Revived the tests.
2020-05-10 23:26:15 -04:00
impl<I: ContextElement> Walkable for HashMap<String, I> {
Finished creating WalkError.
2020-05-09 14:22:36 -04: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-05 20:22:25 -04:00
Ok(child)
Adding &str
2020-04-11 21:07:12 -04:00
}
Start of porting over the walk tests.
2020-05-05 20:22:25 -04:00
}
Adding &str
2020-04-11 21:07:12 -04:00
Revived the tests.
2020-05-10 23:26:15 -04:00
impl<I: 'static + ContextElement + Clone> Loopable for HashMap<String, I> {
Finished creating WalkError.
2020-05-09 14:22:36 -04:00
fn get_loop_elements(&self) -> Vec<&dyn ContextElement> {
Switch the get_loop_elements implementation to only return populated arrays when its an array-like object.
2020-05-24 16:27:13 -04:00
Vec::new()
Add a Loopable trait for dust sections.
2020-04-28 19:34:52 -04:00
}
Start of porting over the walk tests.
2020-05-05 20:22:25 -04:00
}
Revived the tests.
2020-05-10 23:26:15 -04: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-05 20:22:25 -04:00
}
First stab at fixing the error, not a full success.
2020-05-16 21:30:51 -04:00
fn partial_compare(&self, other: &dyn ContextElement) -> Option<Ordering> {
// TODO: Implement
None
}
Start of porting over the walk tests.
2020-05-05 20:22:25 -04:00
}
#[test]
Delete old render functions.
2020-05-05 20:43:53 -04:00
fn test_walk_path() {
Revived the tests.
2020-05-10 23:26:15 -04: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-05 20:22:25 -04:00
]
.iter()
.cloned()
.collect();
assert_eq!(
Rename the new functions to replace the old functions.
2020-05-24 15:21:30 -04:00
walk_path(&vec![&context as &dyn ContextElement], &vec!["cat"])
Start of porting over the walk tests.
2020-05-05 20:22:25 -04:00
.unwrap()
.render(&Vec::new())
.unwrap(),
"kitty".to_owned()
);
Finish porting over the walk test.
2020-05-05 20:38:42 -04:00
assert_eq!(
Rename the new functions to replace the old functions.
2020-05-24 15:21:30 -04:00
walk_path(
Finish porting over the walk test.
2020-05-05 20:38:42 -04: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-24 15:21:30 -04:00
walk_path(
Finish porting over the walk test.
2020-05-05 20:38:42 -04: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-05 20:22:25 -04:00
}
initial walkable implementation
2020-04-11 20:31:44 -04:00
}
Reference in New Issue Copy Permalink