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

Switch the parser over to a new partial implementation for dynamic partials.

Browse Source
This commit is contained in:
Tom Alexander 2020-05-17 20:44:17 -04:00
parent 52ba4fd0a3
commit 402d8679e2
Signed by: talexander
GPG Key ID: D3A179C9A53C0EDE
2 changed files with 179 additions and 10 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

188
src/parser/parser.rs
View File

@ -34,6 +34,7 @@ pub enum DustTag<'a> {
DTBlock(NamedBlock<'a>),
DTInlinePartial(NamedBlock<'a>),
DTPartial(Partial<'a>),
DTNewPartial(NewPartial<'a>),
DTHelperEquals(ParameterizedBlock<'a>),
DTHelperNotEquals(ParameterizedBlock<'a>),
DTHelperGreaterThan(ParameterizedBlock<'a>),
@ -112,6 +113,12 @@ pub struct ParameterizedBlock<'a> {
pub else_contents: Option<Body<'a>>,
}
#[derive(Clone, Debug, PartialEq)]
pub struct NewPartial<'a> {
pub name: Vec<PartialNameElement>,
pub params: Vec<KVPair<'a>>,
}
#[derive(Clone, Debug, PartialEq)]
pub struct Partial<'a> {
pub name: String,
@ -136,6 +143,17 @@ pub struct KVPair<'a> {
pub value: RValue<'a>,
}
#[derive(Clone, Debug, PartialEq)]
pub enum PartialNameElement {
PNSpan {
contents: String,
},
PNReference {
path: Vec<String>,
filters: Vec<Filter>,
},
}
#[derive(Clone, Debug, PartialEq)]
pub struct Body<'a> {
pub elements: Vec<TemplateElement<'a>>,
@ -153,6 +171,28 @@ pub enum TemplateElement<'a> {
TEIgnoredWhitespace(IgnoredWhitespace<'a>),
}
impl From<TemplateElement<'_>> for PartialNameElement {
fn from(original: TemplateElement) -> Self {
match original {
TemplateElement::TESpan(span) => PartialNameElement::PNSpan {
contents: span.contents.to_owned(),
},
TemplateElement::TETag(DustTag::DTReference(reference)) => {
PartialNameElement::PNReference {
path: reference
.path
.keys
.into_iter()
.map(|s| s.to_owned())
.collect(),
filters: reference.filters,
}
}
_ => panic!("Only spans and references can be used in partial names."),
}
}
}
/// Any element significant to dust that isn't plain text
///
/// These elements are always wrapped in curly braces
@ -166,7 +206,7 @@ fn dust_tag(i: &str) -> IResult<&str, DustTag> {
conditional("{^", DustTag::DTNotExists),
named_block("{+", DustTag::DTBlock),
named_block("{<", DustTag::DTInlinePartial),
partial("{>", DustTag::DTPartial),
new_partial("{>", DustTag::DTNewPartial),
parameterized_block("{@", "gte", DustTag::DTHelperGreaterThanOrEquals),
parameterized_block("{@", "lte", DustTag::DTHelperLessThanOrEquals),
parameterized_block("{@", "eq", DustTag::DTHelperEquals),
@ -467,6 +507,91 @@ where
}
}
fn new_partial_with_plain_tag<'a>(
open_matcher: &'static str,
) -> impl Fn(&'a str) -> IResult<&'a str, NewPartial<'a>> {
move |i: &'a str| {
let (i, (name, params)) = delimited(
tag(open_matcher),
tuple((
key,
opt(delimited(
space1,
separated_list1(space1, key_value_pair),
space0,
)),
)),
tag("/}"),
)(i)?;
Ok((
i,
NewPartial {
name: vec![PartialNameElement::PNSpan {
contents: name.to_owned(),
}],
params: params.unwrap_or(Vec::new()),
},
))
}
}
fn new_partial_quoted_tag(i: &str) -> IResult<&str, Vec<TemplateElement>> {
// TODO: make all consuming
many1(alt((
map(span, TemplateElement::TESpan),
map(map(reference, DustTag::DTReference), TemplateElement::TETag),
)))(i)
}
fn new_partial_with_quoted_tag<'a>(
open_matcher: &'static str,
) -> impl Fn(&'a str) -> IResult<&'a str, NewPartial<'a>> {
move |i: &'a str| {
let (i, (name, params)) = delimited(
tag(open_matcher),
tuple((
verify(quoted_string, |s: &String| {
new_partial_quoted_tag(s.as_str()).is_ok()
}),
opt(delimited(
space1,
separated_list1(space1, key_value_pair),
space0,
)),
)),
tag("/}"),
)(i)?;
let (_remaining, template_name_elements) = new_partial_quoted_tag(name.as_str())
.expect("A successful parse was verified earlier with a call to verify()");
let partial_name_elements = template_name_elements
.into_iter()
.map(|e| e.into())
.collect();
Ok((
i,
NewPartial {
name: partial_name_elements,
params: params.unwrap_or(Vec::new()),
},
))
}
}
fn new_partial<'a, F>(
open_matcher: &'static str,
constructor: F,
) -> impl Fn(&'a str) -> IResult<&'a str, DustTag<'a>>
where
F: Fn(NewPartial<'a>) -> DustTag<'a>,
{
let plain = new_partial_with_plain_tag(open_matcher);
let quoted = new_partial_with_quoted_tag(open_matcher);
move |i: &'a str| map(alt((&plain, &quoted)), &constructor)(i)
}
fn partial<'a, F>(
open_matcher: &'static str,
constructor: F,
@ -911,8 +1036,11 @@ mod tests {
dust_tag(r#"{>foo bar=baz animal="cat"/}"#),
Ok((
"",
DustTag::DTPartial(Partial {
name: "foo".to_owned(),
DustTag::DTNewPartial(NewPartial {
name: vec![PartialNameElement::PNSpan {
contents: "foo".to_owned()
},],
params: vec![
KVPair {
key: "bar",
@ -934,8 +1062,44 @@ mod tests {
dust_tag(r#"{>"template name * with * special \" characters" bar=baz animal="cat"/}"#),
Ok((
"",
DustTag::DTPartial(Partial {
name: r#"template name * with * special " characters"#.to_owned(),
DustTag::DTNewPartial(NewPartial {
name: vec![PartialNameElement::PNSpan {
contents: r#"template name * with * special " characters"#.to_owned()
},],
params: vec![
KVPair {
key: "bar",
value: RValue::RVPath(Path { keys: vec!["baz"] })
},
KVPair {
key: "animal",
value: RValue::RVLiteral(OwnedLiteral::LString("cat".to_owned()))
}
]
})
))
);
}
#[test]
fn test_dynamic_partial() {
assert_eq!(
dust_tag(r#"{>"dynamic{ref}template" bar=baz animal="cat"/}"#),
Ok((
"",
DustTag::DTNewPartial(NewPartial {
name: vec![
PartialNameElement::PNSpan {
contents: "dynamic".to_owned()
},
PartialNameElement::PNReference {
path: vec!["ref".to_owned()],
filters: Vec::new()
},
PartialNameElement::PNSpan {
contents: "template".to_owned()
}
],
params: vec![
KVPair {
key: "bar",
@ -957,8 +1121,10 @@ mod tests {
dust_tag(r#"{>foo a="foo" b=179/}"#),
Ok((
"",
DustTag::DTPartial(Partial {
name: "foo".to_owned(),
DustTag::DTNewPartial(NewPartial {
name: vec![PartialNameElement::PNSpan {
contents: "foo".to_owned()
},],
params: vec![
KVPair {
key: "a",
@ -1125,9 +1291,11 @@ mod tests {
keys: vec!["level3", "level4"]
},
contents: Some(Body {
elements: vec![TemplateElement::TETag(DustTag::DTPartial(
Partial {
name: "partialtwo".to_owned(),
elements: vec![TemplateElement::TETag(DustTag::DTNewPartial(
NewPartial {
name: vec![PartialNameElement::PNSpan {
contents: "partialtwo".to_owned()
},],
params: vec![
KVPair {
key: "v1",

1
src/renderer/inline_partial_tree.rs
View File

@ -95,6 +95,7 @@ fn extract_inline_partials_from_tag<'a, 'b>(
};
}
DustTag::DTPartial(..) => (),
DustTag::DTNewPartial(..) => (),
DustTag::DTInlinePartial(named_block) => {
blocks.insert(&named_block.name, &named_block.contents);
}