public void Can_parse_template_with_filter_without_whitespace()
{
var fragments = TemplatePageUtils.ParseTemplatePage("<h1>{{title}}</h1>");
Assert.That(fragments.Count, Is.EqualTo(3));
var strFragment1 = fragments[0] as PageStringFragment;
var varFragment2 = fragments[1] as PageVariableFragment;
var strFragment3 = fragments[2] as PageStringFragment;
Assert.That(strFragment1.Value, Is.EqualTo("<h1>"));
Assert.That(varFragment2.Binding, Is.EqualTo("title"));
Assert.That(varFragment2.FilterExpressions.Length, Is.EqualTo(0));
fragments = TemplatePageUtils.ParseTemplatePage("<h1>{{title|filter}}</h1>");
Assert.That(fragments.Count, Is.EqualTo(3));
strFragment1 = fragments[0] as PageStringFragment;
varFragment2 = fragments[1] as PageVariableFragment;
strFragment3 = fragments[2] as PageStringFragment;
Assert.That(strFragment1.Value, Is.EqualTo("<h1>"));
Assert.That(varFragment2.OriginalText, Is.EqualTo("{{title|filter}}"));
Assert.That(varFragment2.Binding, Is.EqualTo("title"));
Assert.That(varFragment2.FilterExpressions.Length, Is.EqualTo(1));
Assert.That(varFragment2.FilterExpressions[0].Name, Is.EqualTo("filter"));
Assert.That(varFragment2.FilterExpressions[0].Args.Count, Is.EqualTo(0));
Assert.That(strFragment3.Value, Is.EqualTo("</h1>"));
}
public void Can_parse_template_with_filter()
{
var fragments = TemplatePageUtils.ParseTemplatePage("<h1>{{ title | filter }}</h1>");
Assert.That(fragments.Count, Is.EqualTo(3));
var strFragment1 = fragments[0] as PageStringFragment;
var varFragment2 = fragments[1] as PageVariableFragment;
var strFragment3 = fragments[2] as PageStringFragment;
Assert.That(strFragment1.Value, Is.EqualTo("<h1>"));
Assert.That(varFragment2.OriginalText, Is.EqualTo("{{ title | filter }}"));
Assert.That(varFragment2.Name, Is.EqualTo("title"));
Assert.That(varFragment2.FilterCommands.Count, Is.EqualTo(1));
Assert.That(varFragment2.FilterCommands[0].Name, Is.EqualTo("filter"));
Assert.That(varFragment2.FilterCommands[0].Args.Count, Is.EqualTo(0));
Assert.That(strFragment3.Value, Is.EqualTo("</h1>"));
fragments = TemplatePageUtils.ParseTemplatePage("<h1>{{ title | filter() }}</h1>");
varFragment2 = fragments[1] as PageVariableFragment;
Assert.That(varFragment2.OriginalText, Is.EqualTo("{{ title | filter() }}"));
Assert.That(varFragment2.Name, Is.EqualTo("title"));
Assert.That(varFragment2.FilterCommands.Count, Is.EqualTo(1));
Assert.That(varFragment2.FilterCommands[0].Name, Is.EqualTo("filter"));
Assert.That(varFragment2.FilterCommands[0].Args.Count, Is.EqualTo(0));
}
public void Can_parse_template_with_multiple_filters_and_multiple_args()
{
var fragments = TemplatePageUtils.ParseTemplatePage("<h1>{{ title | filter1 | filter2(1) | filter3(1,2.2,'a',\"b\",true) }}</h1>");
Assert.That(fragments.Count, Is.EqualTo(3));
var strFragment1 = fragments[0] as PageStringFragment;
var varFragment2 = fragments[1] as PageVariableFragment;
var strFragment3 = fragments[2] as PageStringFragment;
Assert.That(strFragment1.Value, Is.EqualTo("<h1>"));
Assert.That(varFragment2.OriginalText, Is.EqualTo("{{ title | filter1 | filter2(1) | filter3(1,2.2,'a',\"b\",true) }}"));
Assert.That(varFragment2.Binding, Is.EqualTo("title"));
Assert.That(varFragment2.FilterExpressions.Length, Is.EqualTo(3));
Assert.That(varFragment2.FilterExpressions[0].Name, Is.EqualTo("filter1"));
Assert.That(varFragment2.FilterExpressions[0].Args.Count, Is.EqualTo(0));
Assert.That(varFragment2.FilterExpressions[1].Name, Is.EqualTo("filter2"));
Assert.That(varFragment2.FilterExpressions[1].Args.Count, Is.EqualTo(1));
Assert.That(varFragment2.FilterExpressions[2].Args[0], Is.EqualTo("1"));
Assert.That(varFragment2.FilterExpressions[2].Name, Is.EqualTo("filter3"));
Assert.That(varFragment2.FilterExpressions[2].Args.Count, Is.EqualTo(5));
Assert.That(varFragment2.FilterExpressions[2].Args[0], Is.EqualTo("1"));
Assert.That(varFragment2.FilterExpressions[2].Args[1], Is.EqualTo("2.2"));
Assert.That(varFragment2.FilterExpressions[2].Args[2], Is.EqualTo("'a'"));
Assert.That(varFragment2.FilterExpressions[2].Args[3], Is.EqualTo("\"b\""));
Assert.That(varFragment2.FilterExpressions[2].Args[4], Is.EqualTo("true"));
Assert.That(strFragment3.Value, Is.EqualTo("</h1>"));
}
public void Can_parse_template_with_multiple_variables_and_filters()
{
var fragments = TemplatePageUtils.ParseTemplatePage("<h1>{{ title | filter1 }}</h1>\n<p>{{ content | filter2(a) }}</p>");
Assert.That(fragments.Count, Is.EqualTo(5));
var strFragment1 = fragments[0] as PageStringFragment;
var varFragment2 = fragments[1] as PageVariableFragment;
var strFragment3 = fragments[2] as PageStringFragment;
var varFragment4 = fragments[3] as PageVariableFragment;
var strFragment5 = fragments[4] as PageStringFragment;
Assert.That(strFragment1.Value, Is.EqualTo("<h1>"));
Assert.That(varFragment2.OriginalText, Is.EqualTo("{{ title | filter1 }}"));
Assert.That(varFragment2.Binding, Is.EqualTo("title"));
Assert.That(varFragment2.FilterExpressions.Length, Is.EqualTo(1));
Assert.That(varFragment2.FilterExpressions[0].Name, Is.EqualTo("filter1"));
Assert.That(varFragment2.FilterExpressions[0].Args.Count, Is.EqualTo(0));
Assert.That(strFragment3.Value, Is.EqualTo("</h1>\n<p>"));
Assert.That(varFragment4.OriginalText, Is.EqualTo("{{ content | filter2(a) }}"));
Assert.That(varFragment4.Binding, Is.EqualTo("content"));
Assert.That(varFragment4.FilterExpressions.Length, Is.EqualTo(1));
Assert.That(varFragment4.FilterExpressions[0].Name, Is.EqualTo("filter2"));
Assert.That(varFragment4.FilterExpressions[0].Args.Count, Is.EqualTo(1));
Assert.That(varFragment4.FilterExpressions[0].Args[0], Is.EqualTo("a"));
Assert.That(strFragment5.Value, Is.EqualTo("</p>"));
}
public void Can_parse_template_with_only_variable()
{
var fragments = TemplatePageUtils.ParseTemplatePage("{{ filter }}");
Assert.That(fragments.Count, Is.EqualTo(1));
Assert.That(((PageVariableFragment)fragments[0]).Binding, Is.EqualTo("filter"));
}
public void Can_parse_filter_with_different_arg_types()
{
var fragments = TemplatePageUtils.ParseTemplatePage("{{ array(['a',1,'c']) }}");
var varFragment = fragments[0] as PageVariableFragment;
Assert.That(varFragment.Expression.Name, Is.EqualTo("array"));
Assert.That(varFragment.Expression.Args.Count, Is.EqualTo(1));
}
public void Can_parse_filter_with_different_arg_types()
{
var fragments = TemplatePageUtils.ParseTemplatePage("{{ array(['a',1,'c']) }}");
var varFragment = (PageVariableFragment)fragments[0];
Assert.That(varFragment.OriginalText, Is.EqualTo("{{ array(['a',1,'c']) }}"));
Assert.That(varFragment.InitialExpression.Name, Is.EqualTo("array"));
Assert.That(varFragment.InitialExpression.Arguments.Length, Is.EqualTo(1));
}
public void Can_parse_template_with_no_vars()
{
Assert.That(TemplatePageUtils.ParseTemplatePage("").Count, Is.EqualTo(0));
var fragments = TemplatePageUtils.ParseTemplatePage("<h1>title</h1>");
Assert.That(fragments.Count, Is.EqualTo(1));
var strFragment = fragments[0] as PageStringFragment;
Assert.That(strFragment.Value, Is.EqualTo("<h1>title</h1>"));
}
public void Can_parse_templates_within_literals()
{
JsToken token;
"'<li>{{it}}</li>'".ParseJsExpression(out token);
Assert.That(token, Is.EqualTo(new JsLiteral("<li>{{it}}</li>")));
var fragments = TemplatePageUtils.ParseTemplatePage("<ul>{{ '<li>{{it}}</li>' }}</ul>");
Assert.That(fragments.Count, Is.EqualTo(3));
}
public void Can_parse_template_with_arg_and_multiple_filters()
{
var fragments = TemplatePageUtils.ParseTemplatePage("{{ ' - {{it}}' | forEach(items) | markdown }}");
var varFragment = fragments[0] as PageVariableFragment;
Assert.That(varFragment.FilterExpressions.Length, Is.EqualTo(2));
Assert.That(varFragment.FilterExpressions[0].Name, Is.EqualTo("forEach"));
Assert.That(varFragment.FilterExpressions[0].Args.Count, Is.EqualTo(1));
Assert.That(varFragment.FilterExpressions[0].Args[0], Is.EqualTo("items"));
Assert.That(varFragment.FilterExpressions[1].Name, Is.EqualTo("markdown"));
}
public void Can_parse_templates_within_literals()
{
object value;
JsBinding binding;
"'<li>{{it}}</li>''".ToStringSegment().ParseNextToken(out value, out binding);
Assert.That(value, Is.EqualTo("<li>{{it}}</li>"));
var fragments = TemplatePageUtils.ParseTemplatePage("<ul>{{ '<li>{{it}}</li>' }}</ul>");
Assert.That(fragments.Count, Is.EqualTo(3));
}
public void Does_remove_new_line_between_var_literals()
{
var fragments = TemplatePageUtils.ParseTemplatePage("{{ 'foo' | assignTo: bar }}\n{{ bar }}");
Assert.That(fragments.Count, Is.EqualTo(2));
fragments = TemplatePageUtils.ParseTemplatePage("{{ 'foo' | assignTo: bar }}\r\n{{ bar }}");
Assert.That(fragments.Count, Is.EqualTo(2));
fragments = TemplatePageUtils.ParseTemplatePage("{{ ['foo'] | do: assign('bar', it) }}\n{{ bar }}");
Assert.That(fragments.Count, Is.EqualTo(2));
fragments = TemplatePageUtils.ParseTemplatePage("{{ do: assign('bar', 'foo') }}\n{{ bar }}");
Assert.That(fragments.Count, Is.EqualTo(2));
}
public void Can_parse_template_with_variable()
{
var fragments = TemplatePageUtils.ParseTemplatePage("<h1>{{ title }}</h1>");
Assert.That(fragments.Count, Is.EqualTo(3));
var strFragment1 = fragments[0] as PageStringFragment;
var varFragment2 = fragments[1] as PageVariableFragment;
var strFragment3 = fragments[2] as PageStringFragment;
Assert.That(strFragment1.Value.ToString(), Is.EqualTo("<h1>"));
Assert.That(varFragment2.OriginalText.ToString(), Is.EqualTo("{{ title }}"));
Assert.That(varFragment2.Binding, Is.EqualTo("title"));
Assert.That(varFragment2.FilterExpressions.Length, Is.EqualTo(0));
Assert.That(strFragment3.Value.ToString(), Is.EqualTo("</h1>"));
}
public void Can_use_cleaner_whitespace_sensitive_syntax_for_string_arguments()
{
var fragments1 = TemplatePageUtils.ParseTemplatePage(
@"{{
products
| where: it.UnitsInStock = 0
| select: { it.productName | raw } is sold out!\n
}}");
var fragments2 = TemplatePageUtils.ParseTemplatePage(
@"{{ products
| where: it.UnitsInStock = 0
| select: { it.productName | raw } is sold out!\n }}");
// i.e. is rewritten and is equivalent to:
var fragments3 = TemplatePageUtils.ParseTemplatePage(
@"{{ products | where(′it.UnitsInStock = 0′) | select(′{{ it.productName | raw }} is sold out!\n′)}}");
Assert.That(fragments3.Count, Is.EqualTo(1));
Assert.That(fragments1.Count, Is.EqualTo(1));
var varFragment1 = fragments1[0] as PageVariableFragment;
Assert.That(varFragment1.FilterExpressions[0].Name, Is.EqualTo("where"));
Assert.That(varFragment1.FilterExpressions[0].Arguments.Length, Is.EqualTo(1));
Assert.That(varFragment1.FilterExpressions[0].Arguments[0], Is.EqualTo(
new JsLiteral("it.UnitsInStock = 0")
));
Assert.That(varFragment1.FilterExpressions[1].Name, Is.EqualTo("select"));
Assert.That(varFragment1.FilterExpressions[1].Arguments.Length, Is.EqualTo(1));
Assert.That(varFragment1.FilterExpressions[1].Arguments[0], Is.EqualTo(
new JsLiteral("{{ it.productName | raw }} is sold out!\\n")
));
foreach (var fragments in new[] { fragments2, fragments3 })
{
var varFragment = fragments[0] as PageVariableFragment;
Assert.That(varFragment.FilterExpressions[0].Name, Is.EqualTo(varFragment1.FilterExpressions[0].Name));
Assert.That(varFragment.FilterExpressions[0].Arguments.Length, Is.EqualTo(varFragment1.FilterExpressions[0].Arguments.Length));
Assert.That(varFragment.FilterExpressions[0].Arguments[0], Is.EqualTo(varFragment1.FilterExpressions[0].Arguments[0]));
Assert.That(varFragment.FilterExpressions[1].Name, Is.EqualTo(varFragment1.FilterExpressions[1].Name));
Assert.That(varFragment.FilterExpressions[1].Arguments.Length, Is.EqualTo(varFragment1.FilterExpressions[1].Arguments.Length));
Assert.That(varFragment.FilterExpressions[1].Arguments[0], Is.EqualTo(varFragment1.FilterExpressions[1].Arguments[0]));
}
}
public void Does_parse_Raw_block_body_as_string()
{
var fragments = TemplatePageUtils.ParseTemplatePage("BEFORE {{#raw}} Hi, {{ {{ name }} }} {{/raw}} AFTER");
Assert.That(fragments.Count, Is.EqualTo(3));
Assert.That(((PageStringFragment)fragments[0]).Value.ToString(), Is.EqualTo("BEFORE "));
var statement = fragments[1] as PageBlockFragment;
Assert.That(statement, Is.Not.Null);
Assert.That(statement.Name, Is.EqualTo("raw"));
Assert.That(statement.Argument.ToString(), Is.EqualTo(""));
Assert.That(statement.Body.Length, Is.EqualTo(1));
Assert.That(((PageStringFragment)statement.Body[0]).Value.ToString(), Is.EqualTo(" Hi, {{ {{ name }} }} "));
Assert.That(((PageStringFragment)fragments[2]).Value.ToString(), Is.EqualTo(" AFTER"));
}
public void Can_parse_pages_starting_with_values()
{
var fragments = TemplatePageUtils.ParseTemplatePage(
@"{{ [c.CustomerId, o.OrderId, o.OrderDate] | jsv }}\n");
var varFragment = (PageVariableFragment)fragments[0];
Assert.That(varFragment.Value, Is.EqualTo(new[]
{
new JsExpression("c.CustomerId"),
new JsExpression("o.OrderId"),
new JsExpression("o.OrderDate"),
}));
var newLine = (PageStringFragment)fragments[1];
Assert.That(newLine.Value, Is.EqualTo("\\n"));
}
public void Can_parse_pages_starting_with_values()
{
var fragments = TemplatePageUtils.ParseTemplatePage(
@"{{ [c.CustomerId, o.OrderId, o.OrderDate] | jsv }}\n");
var varFragment = (PageVariableFragment)fragments[0];
Assert.That(varFragment.Expression, Is.EqualTo(new JsArrayExpression(
new JsMemberExpression(new JsIdentifier("c"), new JsIdentifier("CustomerId")),
new JsMemberExpression(new JsIdentifier("o"), new JsIdentifier("OrderId")),
new JsMemberExpression(new JsIdentifier("o"), new JsIdentifier("OrderDate"))
)));
Assert.That(varFragment.OriginalText, Is.EqualTo("{{ [c.CustomerId, o.OrderId, o.OrderDate] | jsv }}"));
var newLine = (PageStringFragment)fragments[1];
Assert.That(newLine.Value, Is.EqualTo("\\n"));
}
public void Does_parse_template_with_Block_Statement()
{
var fragments = TemplatePageUtils.ParseTemplatePage("BEFORE {{#bold}} Hi, {{name}}! {{/bold}} AFTER");
Assert.That(fragments.Count, Is.EqualTo(3));
Assert.That(((PageStringFragment)fragments[0]).Value.ToString(), Is.EqualTo("BEFORE "));
var statement = fragments[1] as PageBlockFragment;
Assert.That(statement, Is.Not.Null);
Assert.That(statement.Name, Is.EqualTo("bold"));
Assert.That(statement.Argument.ToString(), Is.EqualTo(""));
Assert.That(((PageStringFragment)statement.Body[0]).Value.ToString(), Is.EqualTo(" Hi, "));
Assert.That(((PageVariableFragment)statement.Body[1]).Binding, Is.EqualTo("name"));
Assert.That(((PageStringFragment)statement.Body[2]).Value.ToString(), Is.EqualTo("! "));
Assert.That(((PageStringFragment)fragments[2]).Value.ToString(), Is.EqualTo(" AFTER"));
}
public void Does_parse_template_with_if_else_statement()
{
var fragments = TemplatePageUtils.ParseTemplatePage("BEFORE {{#if a < b}}YES{{else}}NO{{/if}} AFTER");
Assert.That(fragments.Count, Is.EqualTo(3));
Assert.That(((PageStringFragment)fragments[0]).Value.ToString(), Is.EqualTo("BEFORE "));
var statement = fragments[1] as PageBlockFragment;
Assert.That(statement, Is.Not.Null);
Assert.That(statement.Name, Is.EqualTo("if"));
Assert.That(statement.Argument.ToString(), Is.EqualTo("a < b"));
Assert.That(((PageStringFragment)statement.Body[0]).Value.ToString(), Is.EqualTo("YES"));
Assert.That(statement.ElseBlocks[0].Argument.ToString(), Is.EqualTo(""));
Assert.That(((PageStringFragment)statement.ElseBlocks[0].Body[0]).Value.ToString(), Is.EqualTo("NO"));
Assert.That(((PageStringFragment)fragments[2]).Value.ToString(), Is.EqualTo(" AFTER"));
}
public void Can_detect_invalid_syntax()
{
try
{
var fragments = TemplatePageUtils.ParseTemplatePage("{{ arg | filter(' 1) }}");
Assert.Fail("should throw");
}
catch (ArgumentException e)
{
e.Message.Print();
}
try
{
var fragments = TemplatePageUtils.ParseTemplatePage("square = {{ 'square-partial | partial({ ten }) }}");
Assert.Fail("should throw");
}
catch (ArgumentException e)
{
e.Message.Print();
}
try
{
var fragments = TemplatePageUtils.ParseTemplatePage("{{ arg | filter({ unterminated:1) }}");
Assert.Fail("should throw");
}
catch (ArgumentException e)
{
e.Message.Print();
}
try
{
var fragments = TemplatePageUtils.ParseTemplatePage("{{ arg | filter([ 1) }}");
Assert.Fail("should throw");
}
catch (ArgumentException e)
{
e.Message.Print();
}
}
public void Does_remove_new_line_between_var_literals()
{
var fragments = TemplatePageUtils.ParseTemplatePage("{{ 'foo' | assignTo: bar }}\n{{ bar }}");
Assert.That(fragments.Count, Is.EqualTo(2));
fragments = TemplatePageUtils.ParseTemplatePage("{{ 'foo' | assignTo: bar }}\r\n{{ bar }}");
Assert.That(fragments.Count, Is.EqualTo(2));
fragments = TemplatePageUtils.ParseTemplatePage("{{ ['foo'] | do: assign('bar', it) }}\n{{ bar }}");
Assert.That(fragments.Count, Is.EqualTo(2));
fragments = TemplatePageUtils.ParseTemplatePage("{{ do: assign('bar', 'foo') }}\n{{ bar }}");
Assert.That(fragments.Count, Is.EqualTo(2));
fragments = TemplatePageUtils.ParseTemplatePage("{{ 10 | times | do: assign('bar', 'foo') }}\n{{ bar }}");
Assert.That(fragments.Count, Is.EqualTo(2));
fragments = TemplatePageUtils.ParseTemplatePage("{{ 10 | times | do: assign('bar', 'foo') }}\nbar");
Assert.That(fragments.Count, Is.EqualTo(2));
var stringFragment = (PageStringFragment)fragments[1];
Assert.That(stringFragment.Value, Is.EqualTo("bar"));
}
public void Can_parse_template_with_filter_with_multiple_args()
{
var fragments = TemplatePageUtils.ParseTemplatePage("<h1>{{ title | filter(1,2.2,'a',\"b\",true) }}</h1>");
Assert.That(fragments.Count, Is.EqualTo(3));
var strFragment1 = fragments[0] as PageStringFragment;
var varFragment2 = fragments[1] as PageVariableFragment;
var strFragment3 = fragments[2] as PageStringFragment;
Assert.That(strFragment1.Value, Is.EqualTo("<h1>"));
Assert.That(varFragment2.OriginalText, Is.EqualTo("{{ title | filter(1,2.2,'a',\"b\",true) }}"));
Assert.That(varFragment2.Binding, Is.EqualTo("title"));
Assert.That(varFragment2.FilterExpressions.Length, Is.EqualTo(1));
Assert.That(varFragment2.FilterExpressions[0].Name, Is.EqualTo("filter"));
Assert.That(varFragment2.FilterExpressions[0].Arguments.Length, Is.EqualTo(5));
Assert.That(varFragment2.FilterExpressions[0].Arguments[0], Is.EqualTo(new JsLiteral(1)));
Assert.That(varFragment2.FilterExpressions[0].Arguments[1], Is.EqualTo(new JsLiteral(2.2)));
Assert.That(varFragment2.FilterExpressions[0].Arguments[2], Is.EqualTo(new JsLiteral("a")));
Assert.That(varFragment2.FilterExpressions[0].Arguments[3], Is.EqualTo(new JsLiteral("b")));
Assert.That(varFragment2.FilterExpressions[0].Arguments[4], Is.EqualTo(JsLiteral.True));
Assert.That(strFragment3.Value, Is.EqualTo("</h1>"));
}
