// rustfmt doesn't do a very good job on nom parser invocations.
#![cfg_attr(rustfmt, rustfmt_skip)]
use nom;
use std::str;
use shared::Syntax;
#[derive(Debug)]
pub enum Expr<'a> {
NumLit(&'a str),
StrLit(&'a str),
Var(&'a str),
Path(Vec<&'a str>),
Array(Vec<Expr<'a>>),
Attr(Box<Expr<'a>>, &'a str),
Index(Box<Expr<'a>>, Box<Expr<'a>>),
Filter(&'a str, Vec<Expr<'a>>),
Unary(&'a str, Box<Expr<'a>>),
BinOp(&'a str, Box<Expr<'a>>, Box<Expr<'a>>),
Range(&'a str, Option<Box<Expr<'a>>>, Option<Box<Expr<'a>>>),
Group(Box<Expr<'a>>),
MethodCall(Box<Expr<'a>>, &'a str, Vec<Expr<'a>>),
}
#[derive(Debug)]
pub enum MatchVariant<'a> {
Path(Vec<&'a str>),
Name(&'a str),
NumLit(&'a str),
StrLit(&'a str),
}
#[derive(Debug)]
pub enum MatchParameter<'a> {
Name(&'a str),
NumLit(&'a str),
StrLit(&'a str),
}
#[derive(Debug)]
pub enum Target<'a> {
Name(&'a str),
}
#[derive(Clone, Copy, Debug)]
pub struct WS(pub bool, pub bool);
#[derive(Debug)]
pub struct Macro<'a> {
pub ws1: WS,
pub args: Vec<&'a str>,
pub nodes: Vec<Node<'a>>,
pub ws2: WS,
}
#[derive(Debug)]
pub enum Node<'a> {
Lit(&'a str, &'a str, &'a str),
Comment(WS),
Expr(WS, Expr<'a>),
Call(WS, Option<&'a str>, &'a str, Vec<Expr<'a>>),
LetDecl(WS, Target<'a>),
Let(WS, Target<'a>, Expr<'a>),
Cond(Vec<(WS, Option<Expr<'a>>, Vec<Node<'a>>)>, WS),
Match(WS, Expr<'a>, Option<&'a str>, Vec<When<'a>>, WS),
Loop(WS, Target<'a>, Expr<'a>, Vec<Node<'a>>, WS),
Extends(Expr<'a>),
BlockDef(WS, &'a str, Vec<Node<'a>>, WS),
Include(WS, &'a str),
Import(WS, &'a str, &'a str),
Macro(&'a str, Macro<'a>),
}
pub type Cond<'a> = (WS, Option<Expr<'a>>, Vec<Node<'a>>);
pub type When<'a> = (
WS,
Option<MatchVariant<'a>>,
Vec<MatchParameter<'a>>,
Vec<Node<'a>>,
);
type Input<'a> = nom::types::CompleteByteSlice<'a>;
#[allow(non_snake_case)]
fn Input(input: &[u8]) -> Input {
nom::types::CompleteByteSlice(input)
}
fn split_ws_parts(s: &[u8]) -> Node {
if s.is_empty() {
let rs = str::from_utf8(&s).unwrap();
return Node::Lit(rs, rs, rs);
}
let is_ws = |c: &u8| *c != b' ' && *c != b'\t' && *c != b'\r' && *c != b'\n';
let start = s.iter().position(&is_ws);
let res = if start.is_none() {
(s, &s[0..0], &s[0..0])
} else {
let start = start.unwrap();
let end = s.iter().rposition(&is_ws);
if end.is_none() {
(&s[..start], &s[start..], &s[0..0])
} else {
let end = end.unwrap();
(&s[..start], &s[start..end + 1], &s[end + 1..])
}
};
Node::Lit(
str::from_utf8(res.0).unwrap(),
str::from_utf8(res.1).unwrap(),
str::from_utf8(res.2).unwrap(),
)
}
enum ContentState {
Any,
Brace(usize),
End(usize),
}
fn take_content<'a>(
i: Input<'a>,
s: &'a Syntax<'a>,
) -> Result<(Input<'a>, Node<'a>), nom::Err<Input<'a>>> {
use parser::ContentState::*;
let bs = s.block_start.as_bytes()[0];
let be = s.block_start.as_bytes()[1];
let cs = s.comment_start.as_bytes()[0];
let ce = s.comment_start.as_bytes()[1];
let es = s.expr_start.as_bytes()[0];
let ee = s.expr_start.as_bytes()[1];
let mut state = Any;
for (idx, c) in i.iter().enumerate() {
state = match state {
Any => {
if *c == bs || *c == es || *c == cs {
Brace(idx)
} else {
Any
}
}
Brace(start) => {
if *c == be || *c == ee || *c == ce {
End(start)
} else {
Any
}
}
End(_) => panic!("cannot happen"),
};
if let End(_) = state {
break;
}
}
match state {
Any | Brace(_) => Ok((Input(&i[..0]), split_ws_parts(i.0))),
End(0) => Err(nom::Err::Error(error_position!(
i,
nom::ErrorKind::Custom(0)
))),
End(start) => Ok((Input(&i[start..]), split_ws_parts(&i[..start]))),
}
}
fn identifier(input: Input) -> Result<(Input, &str), nom::Err<Input>> {
if !nom::is_alphabetic(input[0]) && input[0] != b'_' {
return Err(nom::Err::Error(error_position!(
input,
nom::ErrorKind::Custom(0)
)));
}
for (i, ch) in input.iter().enumerate() {
if i == 0 || nom::is_alphanumeric(*ch) || *ch == b'_' {
continue;
}
return Ok((Input(&input[i..]), str::from_utf8(&input[..i]).unwrap()));
}
Ok((Input(&input[1..]), str::from_utf8(&input[..1]).unwrap()))
}
named!(num_lit<Input, &str>, map!(nom::digit,
|s| str::from_utf8(s.0).unwrap()
));
named!(expr_num_lit<Input, Expr>, map!(num_lit,
|s| Expr::NumLit(s)
));
named!(expr_array_lit<Input, Expr>, do_parse!(
ws!(tag_s!("[")) >>
first: expr_any >>
rest: many0!(do_parse!(
ws!(tag_s!(",")) >>
part: expr_any >>
(part)
)) >>
ws!(tag_s!("]")) >>
({
let mut elements = vec![first];
elements.extend(rest);
Expr::Array(elements)
})
));
named!(variant_num_lit<Input, MatchVariant>, map!(num_lit,
|s| MatchVariant::NumLit(s)
));
named!(param_num_lit<Input, MatchParameter>, map!(num_lit,
|s| MatchParameter::NumLit(s)
));
named!(expr_str_lit<Input, Expr>, map!(
delimited!(char!('"'), take_until!("\""), char!('"')),
|s| Expr::StrLit(str::from_utf8(&s).unwrap())
));
named!(variant_str_lit<Input, MatchVariant>, map!(
delimited!(char!('"'), is_not!("\""), char!('"')),
|s| MatchVariant::StrLit(str::from_utf8(&s).unwrap())
));
named!(param_str_lit<Input, MatchParameter>, map!(
delimited!(char!('"'), is_not!("\""), char!('"')),
|s| MatchParameter::StrLit(str::from_utf8(&s).unwrap())
));
named!(expr_var<Input, Expr>, map!(identifier,
|s| Expr::Var(s))
);
named!(expr_path<Input, Expr>, do_parse!(
start: call!(identifier) >>
rest: many1!(do_parse!(
tag_s!("::") >>
part: identifier >>
(part)
)) >>
({
let mut path = vec![start];
path.extend(rest);
Expr::Path(path)
})
));
named!(variant_path<Input, MatchVariant>, do_parse!(
start: call!(identifier) >>
rest: many1!(do_parse!(
tag_s!("::") >>
part: identifier >>
(part)
)) >>
({
let mut path = vec![start];
path.extend(rest);
MatchVariant::Path(path)
})
));
named!(target_single<Input, Target>, map!(identifier,
|s| Target::Name(s)
));
named!(variant_name<Input, MatchVariant>, map!(identifier,
|s| MatchVariant::Name(s)
));
named!(param_name<Input, MatchParameter>, map!(identifier,
|s| MatchParameter::Name(s)
));
named!(arguments<Input, Vec<Expr>>, do_parse!(
tag_s!("(") >>
args: opt!(do_parse!(
arg0: ws!(expr_any) >>
args: many0!(do_parse!(
tag_s!(",") >>
argn: ws!(expr_any) >>
(argn)
)) >>
({
let mut res = vec![arg0];
res.extend(args);
res
})
)) >>
tag_s!(")") >>
(args.unwrap_or_default())
));
named!(parameters<Input, Vec<&str>>, do_parse!(
tag_s!("(") >>
vals: opt!(do_parse!(
arg0: ws!(identifier) >>
args: many0!(do_parse!(
tag_s!(",") >>
argn: ws!(identifier) >>
(argn)
)) >>
({
let mut res = vec![arg0];
res.extend(args);
res
})
)) >>
tag_s!(")") >>
(vals.unwrap_or_default())
));
named!(with_parameters<Input, Vec<MatchParameter>>, do_parse!(
tag_s!("with") >>
ws!(tag_s!("(")) >>
vals: opt!(do_parse!(
arg0: ws!(match_parameter) >>
args: many0!(do_parse!(
tag_s!(",") >>
argn: ws!(match_parameter) >>
(argn)
)) >>
({
let mut res = vec![arg0];
res.extend(args);
res
})
)) >>
tag_s!(")") >>
(vals.unwrap_or_default())
));
named!(expr_group<Input, Expr>, map!(
delimited!(char!('('), expr_any, char!(')')),
|s| Expr::Group(Box::new(s))
));
named!(expr_single<Input, Expr>, alt!(
expr_num_lit |
expr_str_lit |
expr_path |
expr_array_lit |
expr_var |
expr_group
));
named!(match_variant<Input, MatchVariant>, alt!(
variant_path |
variant_name |
variant_num_lit |
variant_str_lit
));
named!(match_parameter<Input, MatchParameter>, alt!(
param_name |
param_num_lit |
param_str_lit
));
named!(attr<Input, (&str, Option<Vec<Expr>>)>, do_parse!(
tag_s!(".") >>
attr: alt!(num_lit | identifier) >>
args: opt!(arguments) >>
(attr, args)
));
named!(expr_attr<Input, Expr>, do_parse!(
obj: expr_single >>
attrs: many0!(attr) >>
({
let mut res = obj;
for (aname, args) in attrs {
res = if args.is_some() {
Expr::MethodCall(Box::new(res), aname, args.unwrap())
} else {
Expr::Attr(Box::new(res), aname)
};
}
res
})
));
named!(expr_index<Input, Expr>, do_parse!(
obj: expr_attr >>
key: opt!(do_parse!(
ws!(tag_s!("[")) >>
key: expr_any >>
ws!(tag_s!("]")) >>
(key)
)) >>
(match key {
Some(key) => Expr::Index(Box::new(obj), Box::new(key)),
None => obj,
})
));
named!(filter<Input, (&str, Option<Vec<Expr>>)>, do_parse!(
tag_s!("|") >>
fname: identifier >>
args: opt!(arguments) >>
(fname, args)
));
named!(expr_filtered<Input, Expr>, do_parse!(
obj: expr_index >>
filters: many0!(filter) >>
({
let mut res = obj;
for (fname, args) in filters {
res = Expr::Filter(fname, {
let mut args = match args {
Some(inner) => inner,
None => Vec::new(),
};
args.insert(0, res);
args
});
}
res
})
));
named!(expr_unary<Input, Expr>, do_parse!(
op: opt!(alt!(tag_s!("!") | tag_s!("-"))) >>
expr: expr_filtered >>
(match op {
Some(op) => Expr::Unary(str::from_utf8(op.0).unwrap(), Box::new(expr)),
None => expr,
})
));
macro_rules! expr_prec_layer {
( $name:ident, $inner:ident, $( $op:expr ),* ) => {
named!($name<Input, Expr>, do_parse!(
left: $inner >>
op_and_right: opt!(pair!(ws!(alt!($( tag_s!($op) )|*)), expr_any)) >>
(match op_and_right {
Some((op, right)) => Expr::BinOp(
str::from_utf8(op.0).unwrap(), Box::new(left), Box::new(right)
),
None => left,
})
));
}
}
expr_prec_layer!(expr_muldivmod, expr_unary, "*", "/", "%");
expr_prec_layer!(expr_addsub, expr_muldivmod, "+", "-");
expr_prec_layer!(expr_shifts, expr_addsub, ">>", "<<");
expr_prec_layer!(expr_band, expr_shifts, "&");
expr_prec_layer!(expr_bxor, expr_band, "^");
expr_prec_layer!(expr_bor, expr_bxor, "|");
expr_prec_layer!(expr_compare, expr_bor,
"==", "!=", ">=", ">", "<=", "<"
);
expr_prec_layer!(expr_and, expr_compare, "&&");
expr_prec_layer!(expr_or, expr_and, "||");
named!(range_right<Input, Expr>, do_parse!(
ws!(tag_s!("..")) >>
incl: opt!(ws!(tag_s!("="))) >>
right: opt!(expr_or) >>
(Expr::Range(if incl.is_some() { "..=" } else { ".." }, None, right.map(Box::new)))
));
named!(expr_any<Input, Expr>, alt!(
range_right |
do_parse!(
left: expr_or >>
rest: range_right >> (match rest {
Expr::Range(op, _, right) => Expr::Range(op, Some(Box::new(left)), right),
_ => unreachable!(),
})
) |
expr_or
));
named_args!(expr_node<'a>(s: &'a Syntax<'a>) <Input<'a>, Node<'a>>, do_parse!(
call!(tag_expr_start, s) >>
pws: opt!(tag_s!("-")) >>
expr: ws!(expr_any) >>
nws: opt!(tag_s!("-")) >>
call!(tag_expr_end, s) >>
(Node::Expr(WS(pws.is_some(), nws.is_some()), expr))
));
named!(block_call<Input, Node>, do_parse!(
pws: opt!(tag_s!("-")) >>
ws!(tag_s!("call")) >>
scope: opt!(do_parse!(
scope: ws!(identifier) >>
ws!(tag_s!("::")) >>
(scope)
)) >>
name: ws!(identifier) >>
args: ws!(arguments) >>
nws: opt!(tag_s!("-")) >>
(Node::Call(WS(pws.is_some(), nws.is_some()), scope, name, args))
));
named!(cond_if<Input, Expr>, do_parse!(
ws!(tag_s!("if")) >>
cond: ws!(expr_any) >>
(cond)
));
named_args!(cond_block<'a>(s: &'a Syntax<'a>) <Input<'a>, Cond<'a>>, do_parse!(
call!(tag_block_start, s) >>
pws: opt!(tag_s!("-")) >>
ws!(tag_s!("else")) >>
cond: opt!(cond_if) >>
nws: opt!(tag_s!("-")) >>
call!(tag_block_end, s) >>
block: call!(parse_template, s) >>
(WS(pws.is_some(), nws.is_some()), cond, block)
));
named_args!(block_if<'a>(s: &'a Syntax<'a>) <Input<'a>, Node<'a>>, do_parse!(
pws1: opt!(tag_s!("-")) >>
cond: ws!(cond_if) >>
nws1: opt!(tag_s!("-")) >>
call!(tag_block_end, s) >>
block: call!(parse_template, s) >>
elifs: many0!(call!(cond_block, s)) >>
call!(tag_block_start, s) >>
pws2: opt!(tag_s!("-")) >>
ws!(tag_s!("endif")) >>
nws2: opt!(tag_s!("-")) >>
({
let mut res = Vec::new();
res.push((WS(pws1.is_some(), nws1.is_some()), Some(cond), block));
res.extend(elifs);
Node::Cond(res, WS(pws2.is_some(), nws2.is_some()))
})
));
named_args!(match_else_block<'a>(s: &'a Syntax<'a>) <Input<'a>, When<'a>>, do_parse!(
call!(tag_block_start, s) >>
pws: opt!(tag_s!("-")) >>
ws!(tag_s!("else")) >>
nws: opt!(tag_s!("-")) >>
call!(tag_block_end, s) >>
block: call!(parse_template, s) >>
(WS(pws.is_some(), nws.is_some()), None, vec![], block)
));
named_args!(when_block<'a>(s: &'a Syntax<'a>) <Input<'a>, When<'a>>, do_parse!(
call!(tag_block_start, s) >>
pws: opt!(tag_s!("-")) >>
ws!(tag_s!("when")) >>
variant: ws!(match_variant) >>
params: opt!(ws!(with_parameters)) >>
nws: opt!(tag_s!("-")) >>
call!(tag_block_end, s) >>
block: call!(parse_template, s) >>
(WS(pws.is_some(), nws.is_some()), Some(variant), params.unwrap_or_default(), block)
));
named_args!(block_match<'a>(s: &'a Syntax<'a>) <Input<'a>, Node<'a>>, do_parse!(
pws1: opt!(tag_s!("-")) >>
ws!(tag_s!("match")) >>
expr: ws!(expr_any) >>
nws1: opt!(tag_s!("-")) >>
call!(tag_block_end, s) >>
inter: opt!(call!(take_content, s)) >>
arms: many1!(call!(when_block, s)) >>
else_arm: opt!(call!(match_else_block, s)) >>
ws!(call!(tag_block_start, s)) >>
pws2: opt!(tag_s!("-")) >>
ws!(tag_s!("endmatch")) >>
nws2: opt!(tag_s!("-")) >>
({
let mut arms = arms;
if let Some(arm) = else_arm {
arms.push(arm);
}
let inter = match inter {
Some(Node::Lit(lws, val, rws)) => {
assert!(val.is_empty(),
"only whitespace allowed between match and first when, found {}", val);
assert!(rws.is_empty(),
"only whitespace allowed between match and first when, found {}", rws);
Some(lws)
},
None => None,
_ => panic!("only literals allowed between match and first when"),
};
Node::Match(
WS(pws1.is_some(), nws1.is_some()),
expr,
inter,
arms,
WS(pws2.is_some(), nws2.is_some()),
)
})
));
named!(block_let<Input, Node>, do_parse!(
pws: opt!(tag_s!("-")) >>
ws!(tag_s!("let")) >>
var: ws!(target_single) >>
val: opt!(do_parse!(
ws!(tag_s!("=")) >>
val: ws!(expr_any) >>
(val)
)) >>
nws: opt!(tag_s!("-")) >>
(if val.is_some() {
Node::Let(WS(pws.is_some(), nws.is_some()), var, val.unwrap())
} else {
Node::LetDecl(WS(pws.is_some(), nws.is_some()), var)
})
));
named_args!(block_for<'a>(s: &'a Syntax<'a>) <Input<'a>, Node<'a>>, do_parse!(
pws1: opt!(tag_s!("-")) >>
ws!(tag_s!("for")) >>
var: ws!(target_single) >>
ws!(tag_s!("in")) >>
iter: ws!(expr_any) >>
nws1: opt!(tag_s!("-")) >>
call!(tag_block_end, s) >>
block: call!(parse_template, s) >>
call!(tag_block_start, s) >>
pws2: opt!(tag_s!("-")) >>
ws!(tag_s!("endfor")) >>
nws2: opt!(tag_s!("-")) >>
(Node::Loop(WS(pws1.is_some(), nws1.is_some()),
var, iter, block,
WS(pws2.is_some(), nws2.is_some())))
));
named!(block_extends<Input, Node>, do_parse!(
ws!(tag_s!("extends")) >>
name: ws!(expr_str_lit) >>
(Node::Extends(name))
));
named_args!(block_block<'a>(s: &'a Syntax<'a>) <Input<'a>, Node<'a>>, do_parse!(
pws1: opt!(tag_s!("-")) >>
ws!(tag_s!("block")) >>
name: ws!(identifier) >>
nws1: opt!(tag_s!("-")) >>
call!(tag_block_end, s) >>
contents: call!(parse_template, s) >>
call!(tag_block_start, s) >>
pws2: opt!(tag_s!("-")) >>
ws!(tag_s!("endblock")) >>
opt!(ws!(tag_s!(name))) >>
nws2: opt!(tag_s!("-")) >>
(Node::BlockDef(WS(pws1.is_some(), nws1.is_some()),
name, contents,
WS(pws2.is_some(), nws2.is_some())))
));
named!(block_include<Input, Node>, do_parse!(
pws: opt!(tag_s!("-")) >>
ws!(tag_s!("include")) >>
name: ws!(expr_str_lit) >>
nws: opt!(tag_s!("-")) >>
(Node::Include(WS(pws.is_some(), nws.is_some()), match name {
Expr::StrLit(s) => s,
_ => panic!("include path must be a string literal"),
}))
));
named!(block_import<Input, Node>, do_parse!(
pws: opt!(tag_s!("-")) >>
ws!(tag_s!("import")) >>
name: ws!(expr_str_lit) >>
ws!(tag_s!("as")) >>
scope: ws!(identifier) >>
nws: opt!(tag_s!("-")) >>
(Node::Import(WS(pws.is_some(), nws.is_some()), match name {
Expr::StrLit(s) => s,
_ => panic!("import path must be a string literal"),
}, scope))
));
named_args!(block_macro<'a>(s: &'a Syntax<'a>) <Input<'a>, Node<'a>>, do_parse!(
pws1: opt!(tag_s!("-")) >>
ws!(tag_s!("macro")) >>
name: ws!(identifier) >>
params: ws!(parameters) >>
nws1: opt!(tag_s!("-")) >>
call!(tag_block_end, s) >>
contents: call!(parse_template, s) >>
call!(tag_block_start, s) >>
pws2: opt!(tag_s!("-")) >>
ws!(tag_s!("endmacro")) >>
nws2: opt!(tag_s!("-")) >>
({
if name == "super" {
panic!("invalid macro name 'super'");
}
Node::Macro(
name,
Macro {
ws1: WS(pws1.is_some(), nws1.is_some()),
args: params,
nodes: contents,
ws2: WS(pws2.is_some(), nws2.is_some())
}
)
})
));
named_args!(block_node<'a>(s: &'a Syntax<'a>) <Input<'a>, Node<'a>>, do_parse!(
call!(tag_block_start, s) >>
contents: alt!(
block_call |
block_let |
call!(block_if, s) |
call!(block_for, s) |
call!(block_match, s) |
block_extends |
block_include |
block_import |
call!(block_block, s) |
call!(block_macro, s)
) >>
call!(tag_block_end, s) >>
(contents)
));
named_args!(block_comment<'a>(s: &'a Syntax<'a>) <Input<'a>, Node<'a>>, do_parse!(
call!(tag_comment_start, s) >>
pws: opt!(tag_s!("-")) >>
inner: take_until_s!(s.comment_end) >>
call!(tag_comment_end, s) >>
(Node::Comment(WS(pws.is_some(), inner.len() > 1 && inner[inner.len() - 1] == b'-')))
));
named_args!(parse_template<'a>(s: &'a Syntax<'a>)<Input<'a>, Vec<Node<'a>>>, many0!(alt!(
call!(take_content, s) |
call!(block_comment, s) |
call!(expr_node, s) |
call!(block_node, s)
)));
named_args!(tag_block_start<'a>(s: &'a Syntax<'a>) <Input<'a>, Input<'a>>, tag!(s.block_start));
named_args!(tag_block_end<'a>(s: &'a Syntax<'a>) <Input<'a>, Input<'a>>, tag!(s.block_end));
named_args!(tag_comment_start<'a>(s: &'a Syntax<'a>) <Input<'a>, Input<'a>>, tag!(s.comment_start));
named_args!(tag_comment_end<'a>(s: &'a Syntax<'a>) <Input<'a>, Input<'a>>, tag!(s.comment_end));
named_args!(tag_expr_start<'a>(s: &'a Syntax<'a>) <Input<'a>, Input<'a>>, tag!(s.expr_start));
named_args!(tag_expr_end<'a>(s: &'a Syntax<'a>) <Input<'a>, Input<'a>>, tag!(s.expr_end));
pub fn parse<'a>(src: &'a str, syntax: &'a Syntax<'a>) -> Vec<Node<'a>> {
match parse_template(Input(src.as_bytes()), syntax) {
Ok((left, res)) => {
if !left.is_empty() {
let s = str::from_utf8(left.0).unwrap();
panic!("unable to parse template:\n\n{:?}", s);
} else {
res
}
}
Err(nom::Err::Error(err)) => panic!("problems parsing template source: {:?}", err),
Err(nom::Err::Failure(err)) => panic!("problems parsing template source: {:?}", err),
Err(nom::Err::Incomplete(_)) => panic!("parsing incomplete"),
}
}
#[cfg(test)]
mod tests {
use shared::Syntax;
fn check_ws_split(s: &str, res: &(&str, &str, &str)) {
let node = super::split_ws_parts(s.as_bytes());
match node {
super::Node::Lit(lws, s, rws) => {
assert_eq!(lws, res.0);
assert_eq!(s, res.1);
assert_eq!(rws, res.2);
}
_ => {
panic!("fail");
}
}
}
#[test]
fn test_ws_splitter() {
check_ws_split("", &("", "", ""));
check_ws_split("a", &("", "a", ""));
check_ws_split("\ta", &("\t", "a", ""));
check_ws_split("b\n", &("", "b", "\n"));
check_ws_split(" \t\r\n", &(" \t\r\n", "", ""));
}
#[test]
#[should_panic]
fn test_invalid_block() {
super::parse("{% extend \"blah\" %}", &Syntax::default());
}
#[test]
fn test_parse_filter() {
super::parse("{{ strvar|e }}", &Syntax::default());
}
#[test]
fn change_delimiters_parse_filter() {
let syntax = Syntax {
expr_start: "{~",
expr_end: "~}",
..Syntax::default()
};
super::parse("{~ strvar|e ~}", &syntax);
}
}