public void Should_combine_single_substitutions_and_each_substitutions() { var input = @"<html><head></head><body><ul>@Each.Users;<li>Hello @Current;, @Model.Name; says hello!</li>@EndEach;</ul></body></html>"; var model = new { Name = "Nancy", Users = new List <string>() { "Bob", "Jim", "Bill" } }; var output = Parse(input, model.GetType()); AssertSyntaxTree(output, SyntaxTree.WriteString("<html><head></head><body><ul>"), SyntaxTree.Iterate( SyntaxTreeExpression.Property(model.GetType(), "Users"), SyntaxTree.Block( SyntaxTree.WriteString("<li>Hello "), SyntaxTree.WriteExpression(SyntaxTreeExpression.Self(typeof(string), ExpressionScope.CurrentModelOnStack)), SyntaxTree.WriteString(", "), SyntaxTree.WriteExpression(SyntaxTreeExpression.Property(model.GetType(), "Name", ExpressionScope.RootModel)), SyntaxTree.WriteString(" says hello!</li>") ) ), SyntaxTree.WriteString("</ul></body></html>") ); }
public void Should_be_able_to_write_model_field <T>(T model, string expectedResult) { var template = SyntaxTree.Block(SyntaxTree.WriteExpression(SyntaxTreeExpression.Field(model.GetType(), "DataField"))); var result = ExecuteTemplate(template, model); Assert.That(result, Is.EqualTo(expectedResult)); }
public void Should_return_true_for_ifhascollection_when_if_model_has_a_collection_with_items_but_no_bool() { var input = @"<html><head></head><body>@If.HasUsers;<ul>@Each.Users;<li>Hello @Current;, @Model.Name; says hello!</li>@EndEach;</ul>@EndIf;</body></html>"; var model = new { Users = new List <string>() { "Bob", "Jim", "Bill" }, Name = "Nancy" }; var output = Parse(input, model.GetType()); AssertSyntaxTree( output, SyntaxTree.WriteString("<html><head></head><body>"), SyntaxTree.Conditional( SyntaxTreeExpression.HasItems(SyntaxTreeExpression.Property(model.GetType(), "Users")), SyntaxTree.Block( SyntaxTree.WriteString("<ul>"), SyntaxTree.Iterate( SyntaxTreeExpression.Property(model.GetType(), "Users"), SyntaxTree.Block( SyntaxTree.WriteString("<li>Hello "), SyntaxTree.WriteExpression(SyntaxTreeExpression.Self(typeof(string))), SyntaxTree.WriteString(", "), SyntaxTree.WriteExpression(SyntaxTreeExpression.Property(model.GetType(), "Name", ExpressionScope.RootModel)), SyntaxTree.WriteString(" says hello!</li>") ) ), SyntaxTree.WriteString("</ul>") ) ), SyntaxTree.WriteString("</body></html>") ); }
public void Should_be_able_to_write_from_sub_model <T>(T model, string expectedResult) { var template = SyntaxTree.Block(SyntaxTree.WriteExpression(SyntaxTreeExpression.SubModel(SyntaxTreeExpression.Property(model.GetType(), "Sub"), SyntaxTreeExpression.Property(model.GetType().GetProperty("Sub").PropertyType, "SubData")))); var result = ExecuteTemplate(template, model); Assert.That(result, Is.EqualTo(expectedResult)); }
public void Should_be_able_to_nest_conditionals(bool c1, bool c2, string expectedResult) { var model = new { Condition1 = c1, Condition2 = c2 }; var template = SyntaxTree.Block( SyntaxTree.WriteString("Start "), SyntaxTree.Conditional( SyntaxTreeExpression.Property(model.GetType(), "Condition1"), SyntaxTree.Block( SyntaxTree.WriteString("True1 "), SyntaxTree.Conditional( SyntaxTreeExpression.Property(model.GetType(), "Condition2"), SyntaxTree.Block(SyntaxTree.WriteString("True2 ")), SyntaxTree.Block(SyntaxTree.WriteString("False2 ")) ) ), SyntaxTree.Block( SyntaxTree.WriteString("False1 "), SyntaxTree.Conditional( SyntaxTreeExpression.Property(model.GetType(), "Condition2"), SyntaxTree.Block(SyntaxTree.WriteString("True2 ")), SyntaxTree.Block(SyntaxTree.WriteString("False2 ")) ) ) ), SyntaxTree.WriteString("End")); var result = ExecuteTemplate(template, model); Assert.Equal(expectedResult, result); }
public void Should_be_able_to_write_model_property <T>(T model, string expectedResult) { var template = SyntaxTree.Block(SyntaxTree.WriteExpression(SyntaxTreeExpression.Property(model.GetType(), "Data"))); var result = ExecuteTemplate(template, model); Assert.Equal(expectedResult, result); }
public static object[] EmptyBlockCases() { return(new object[] { new object[] { null }, new object[] { SyntaxTree.Block() } }); }
public void Should_throw_when_collection_expression_not_suitable <T>(T model) { Assert.Throws <VeilParserException>(() => { SyntaxTree.Iterate(Expression.Property(model.GetType(), "Items"), SyntaxTree.Block()); }); }
public void Should_not_throw_when_collection_expression_is_a_suitable_type <T>(T model) { Assert.DoesNotThrow(() => { SyntaxTree.Iterate(Expression.Property(model.GetType(), "Items"), SyntaxTree.Block()); }); }
public void Should_be_able_to_write_from_parent_scope_model() { var model = new Model <string> { Name = "Root", SubModels = new[] { new SubModel <string> { Name = "1", Strings = new [] { "A", "B" } }, new SubModel <string> { Name = "2", Strings = new [] { "C", "D" } } } }; var template = SyntaxTree.Block( SyntaxTree.Iterate( SyntaxTreeExpression.Property(model.GetType(), "SubModels", ExpressionScope.RootModel), SyntaxTree.Block( SyntaxTree.Iterate( SyntaxTreeExpression.Property(model.Sub.GetType(), "Strings", ExpressionScope.CurrentModelOnStack), SyntaxTree.Block( SyntaxTree.WriteExpression(SyntaxTreeExpression.Self(typeof(string), ExpressionScope.CurrentModelOnStack)), SyntaxTree.WriteExpression(SyntaxTreeExpression.Property(model.Sub.GetType(), "Name", ExpressionScope.ModelOfParentScope)), SyntaxTree.WriteExpression(SyntaxTreeExpression.Property(model.GetType(), "Name", ExpressionScope.RootModel)) ) ) ) ) ); var result = ExecuteTemplate(template, model); Assert.That(result, Is.EqualTo("A1RootB1RootC2RootD2Root")); }
public void Should_parse_if_block_with_explicit_model_reference() { var input = @"<html><head></head><body>@If.Model.HasUsers;<ul>@Each.Users;<li>Hello @Current;, @Model.Name; says hello!</li>@EndEach;</ul>@EndIf;</body></html>"; var model = new FakeModel("Nancy", new List <string>() { "Bob", "Jim", "Bill" }); var output = Parse(input, model.GetType()); AssertSyntaxTree(output, SyntaxTree.WriteString("<html><head></head><body>"), SyntaxTree.Conditional( SyntaxTreeExpression.Property(model.GetType(), "HasUsers", ExpressionScope.RootModel), SyntaxTree.Block( SyntaxTree.WriteString("<ul>"), SyntaxTree.Iterate( SyntaxTreeExpression.Property(model.GetType(), "Users"), SyntaxTree.Block( SyntaxTree.WriteString("<li>Hello "), SyntaxTree.WriteExpression(SyntaxTreeExpression.Self(typeof(string))), SyntaxTree.WriteString(", "), SyntaxTree.WriteExpression(SyntaxTreeExpression.Property(model.GetType(), "Name", ExpressionScope.RootModel)), SyntaxTree.WriteString(" says hello!</li>") ) ), SyntaxTree.WriteString("</ul>") ) ), SyntaxTree.WriteString("</body></html>") ); }
public void Should_not_render_block_when_ifnot_statements_returns_true() { var input = @"<html><head></head><body>@IfNot.HasUsers;<p>No users found!</p>@EndIf;<ul>@Each.Users;<li>Hello @Current;, @Model.Name; says hello!</li>@EndEach;</ul></body></html>"; var model = new FakeModel("Nancy", new List <string>() { "Bob", "Jim", "Bill" }); var output = Parse(input, model.GetType()); AssertSyntaxTree(output, SyntaxTree.WriteString("<html><head></head><body>"), SyntaxTree.Conditional( SyntaxTreeExpression.Property(model.GetType(), "HasUsers"), SyntaxTree.Block(), SyntaxTree.Block( SyntaxTree.WriteString("<p>No users found!</p>") ) ), SyntaxTree.WriteString("<ul>"), SyntaxTree.Iterate( SyntaxTreeExpression.Property(model.GetType(), "Users"), SyntaxTree.Block( SyntaxTree.WriteString("<li>Hello "), SyntaxTree.WriteExpression(SyntaxTreeExpression.Self(typeof(string))), SyntaxTree.WriteString(", "), SyntaxTree.WriteExpression(SyntaxTreeExpression.Property(model.GetType(), "Name", ExpressionScope.RootModel)), SyntaxTree.WriteString(" says hello!</li>") ) ), SyntaxTree.WriteString("</ul></body></html>") ); }
private static void HandleUnless(HandlebarsParserState state) { var block = SyntaxTree.Block(state.CurrentLocation); var conditional = SyntaxTree.Conditional(state.ParseExpression(state.CurrentToken.Content.Substring(8), state.CurrentLocation.MoveIndex(8)), state.CurrentLocation, SyntaxTree.Block(state.CurrentLocation), block); state.AddNodeToCurrentBlock(conditional); state.BlockStack.PushModelInheritingBlock(block); }
private static void HandleHelperStart(HandlebarsParserState state, IBlockHelperHandler helper) { var block = SyntaxTree.Block(state.CurrentLocation); var helperBlock = SyntaxTree.Helper(SyntaxTreeExpression.Helper(state.CurrentToken.Content.Substring(1), helper, state.CurrentLocation), block, state.CurrentLocation); state.AddNodeToCurrentBlock(helperBlock); state.BlockStack.PushModelInheritingBlock(block); }
public void PushNewBlockWithModel(Type modelInScope) { PushBlock(new HandlebarsParserBlock { Block = SyntaxTree.Block(), ModelInScope = modelInScope }); }
private static void HandleIf(HandlebarsParserState state) { var block = SyntaxTree.Block(); var conditional = SyntaxTree.Conditional(state.ParseExpression(state.CurrentToken.Content.Substring(4)), block); state.AddNodeToCurrentBlock(conditional); state.BlockStack.PushModelInheritingBlock(block); }
public void PushNewBlockWithModel(Type modelInScope, SourceLocation location) { PushBlock(new HandlebarsParserBlock { Block = SyntaxTree.Block(location), ModelInScope = modelInScope }); }
private static void HandleConditionalElse(HandlebarsParserState state) { var block = SyntaxTree.Block(); state.BlockStack.GetCurrentBlockContainer <ConditionalNode>().FalseBlock = block; state.BlockStack.PopBlock(); state.BlockStack.PushModelInheritingBlock(block); }
public void Should_handle_late_binding <T>(T model) { var template = SyntaxTree.Block( SyntaxTree.WriteExpression(Expression.LateBound("Name")) ); var result = ExecuteTemplate(template, model); Assert.That(result, Is.EqualTo("Joe")); }
public void Should_output_literal(string literal, string expectedResult) { var template = SyntaxTree.Block(new WriteLiteralNode { LiteralContent = literal }); var result = ExecuteTemplate(template, new { }); Assert.That(result, Is.EqualTo(expectedResult)); }
public void Should_throw_when_invalid_syntax_node_found() { var template = SyntaxTree.Block(new InvalidSyntaxTreeNode()); Assert.Throws <VeilCompilerException>(() => { ExecuteTemplate(template, new { }); }); }
public void Should_parse_extend_pages() { var result = Parse("{{< Master}}Hello World"); result.ShouldDeepEqual(SyntaxTree.Extend("Master", new Dictionary <string, SyntaxTreeNode> { { "body", SyntaxTree.Block(SyntaxTree.WriteString("Hello World")) } })); }
public void Should_apply_html_encoding_when_requested() { var model = new { Text = "<h1>Hello</h1>" }; var template = SyntaxTree.Block( SyntaxTree.WriteExpression(SyntaxTreeExpression.Property(model.GetType(), "Text", ExpressionScope.RootModel), true) ); var result = ExecuteTemplate(template, model); Assert.That(result, Is.EqualTo("<h1>Hello</h1>")); }
public void Should_render_correct_block_based_on_model_property <T>(T model, string expectedResult) { var template = SyntaxTree.Block(SyntaxTree.Conditional( SyntaxTreeExpression.Property(model.GetType(), "Condition"), SyntaxTree.Block(SyntaxTree.WriteString("True")), SyntaxTree.Block(SyntaxTree.WriteString("False")))); var result = ExecuteTemplate(template, model); Assert.That(result, Is.EqualTo(expectedResult)); }
public void Should_be_able_to_write_from_root_model() { var model = new { Text = "Hello!" }; var template = SyntaxTree.Block( SyntaxTree.WriteExpression(SyntaxTreeExpression.Property(model.GetType(), "Text", ExpressionScope.RootModel)) ); var result = ExecuteTemplate(template, model); Assert.That(result, Is.EqualTo("Hello!")); }
public void Should_render_correct_block_based_on_model_field <T>(T model, string expectedResult) { var template = SyntaxTree.Block(SyntaxTree.Conditional( SyntaxTreeExpression.Field(model.GetType(), "ConditionField"), SyntaxTree.Block(SyntaxTree.WriteString("True")), SyntaxTree.Block(SyntaxTree.WriteString("False")))); var result = ExecuteTemplate(template, model); Assert.Equal(expectedResult, result); }
public void Should_not_throw_if_optional_override_is_missing() { var model = new { }; RegisterTemplate("master", SyntaxTree.Block(SyntaxTree.WriteString("Hello"), SyntaxTree.Override("foo", true))); var template = SyntaxTree.Extend("master"); var result = ExecuteTemplate(template, model); Assert.Equal("Hello", result); }
private static void HandlePositiveConditional(SuperSimpleTemplateParserState state) { var condition = SyntaxTree.Conditional( state.ParseCurrentTokenExpression(), SyntaxTree.Block() ); state.AddNodeToCurrentBlock(condition); state.PushNewScope(condition.TrueBlock); }
private static void HandleEachOverExpression(SuperSimpleTemplateParserState state) { var each = SyntaxTree.Iterate( state.ParseCurrentTokenExpression(), SyntaxTree.Block() ); state.AddNodeToCurrentBlock(each); state.PushNewScope(each.Body, each.ItemType); }
public void Should_use_default_for_a_section_if_not_overridden() { var model = new { }; RegisterTemplate("master", SyntaxTree.Block(SyntaxTree.WriteString("Hello "), SyntaxTree.Override("foo", SyntaxTree.WriteString("World")))); var template = SyntaxTree.Extend("master"); var result = ExecuteTemplate(template, model); Assert.Equal("Hello World", result); }