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_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_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_throw_when_collection_expression_is_a_suitable_type <T>(T model) { Assert.DoesNotThrow(() => { SyntaxTreeExpression.HasItems(SyntaxTreeExpression.Property(model.GetType(), "Items")); }); }
public void Should_throw_when_collection_expression_not_suitable <T>(T model) { Assert.Throws <VeilParserException>(() => { SyntaxTree.Iterate(SyntaxTreeExpression.Property(model.GetType(), "Items"), SyntaxTree.Block()); }); }
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_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>") ); }
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_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.That(result, Is.EqualTo(expectedResult)); }
public void Should_not_throw_when_conditional_expression_is_a_suitable_type <T>(T model) { Assert.DoesNotThrow(() => { SyntaxTree.Conditional(SyntaxTreeExpression.Property(model.GetType(), "Items"), SyntaxTree.Block(), SyntaxTree.Block()); }); }
public void Should_give_precedence_to_property_over_hasitems() { var model = new { Items = new[] { 1, 2, 3 }, HasItems = true }; var result = SuperSimpleExpressionParser.Parse(CreateScopes(model.GetType()), "HasItems"); result.ShouldDeepEqual(SyntaxTreeExpression.Property(model.GetType(), "HasItems")); }
public void Should_parse_hasitems_expression() { var model = new { Items = new[] { 1, 2, 3 } }; var result = SuperSimpleExpressionParser.Parse(CreateScopes(model.GetType()), "HasItems"); result.ShouldDeepEqual(SyntaxTreeExpression.HasItems(SyntaxTreeExpression.Property(model.GetType(), "Items"))); }
public void Should_parse_model_dot_property_as_proeprty_expression() { var model = new { Name = "foo" }; var result = SuperSimpleExpressionParser.Parse(CreateScopes(model.GetType()), "Model.Name"); result.ShouldDeepEqual(SyntaxTreeExpression.Property(model.GetType(), "Name", ExpressionScope.RootModel)); }
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.Equal(expectedResult, result); }
public void Should_parse_sub_model_expression_from_current_model() { var model = new { User = new { Name = "Bob" } }; var result = SuperSimpleExpressionParser.Parse(CreateScopes(model.GetType()), "Current.User.Name"); result.ShouldDeepEqual(SyntaxTreeExpression.SubModel( SyntaxTreeExpression.Property(model.GetType(), "User"), SyntaxTreeExpression.Property(model.User.GetType(), "Name") )); }
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_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_parse_if_statement() { var template = Parse("Hello {{#if Conditional }} John{{/if}}", typeof(TestModel)); AssertSyntaxTree(template, new SyntaxTreeNode[] { SyntaxTree.WriteString("Hello "), SyntaxTree.Conditional(SyntaxTreeExpression.Property(typeof(TestModel), "Conditional"), SyntaxTree.Block(SyntaxTree.WriteString(" John")) ) }); }
public void Should_be_able_to_reference_parent_scopes_model() { var current = new { }; var parent = new { Name = "" }; var root = new { }; var scopes = CreateScopes(root.GetType(), parent.GetType(), current.GetType()); var result = HandlebarsExpressionParser.Parse(scopes, "../Name"); result.ShouldDeepEqual(SyntaxTreeExpression.Property(parent.GetType(), "Name", ExpressionScope.ModelOfParentScope)); }
public void Should_emit_all_nodes_in_block() { var model = new { Name = "World" }; var template = SyntaxTree.Block( SyntaxTree.WriteString("Hello "), SyntaxTree.WriteExpression(SyntaxTreeExpression.Property(model.GetType(), "Name")), SyntaxTree.WriteString("!") ); var result = ExecuteTemplate(template, model); Assert.That(result, Is.EqualTo("Hello World!")); }
public void Should_replaces_valid_property() { var input = @"<html><head></head><body>Hello there @Model.Name;</body></html>"; var model = new { Name = "bob" }; var output = Parse(input, model.GetType()); AssertSyntaxTree(output, SyntaxTree.WriteString("<html><head></head><body>Hello there "), SyntaxTree.WriteExpression(SyntaxTreeExpression.Property(model.GetType(), "Name", ExpressionScope.RootModel)), SyntaxTree.WriteString("</body></html>") ); }
public void Should_parse_field_from_subsubmodel() { var result = HandlebarsExpressionParser.Parse(CreateScopes(typeof(Model)), "SubModel.SubSubModel.SubSubField"); result.ShouldDeepEqual(SyntaxTreeExpression.SubModel( SyntaxTreeExpression.Property(typeof(Model), "SubModel"), SyntaxTreeExpression.SubModel( SyntaxTreeExpression.Field(typeof(SubModel), "SubSubModel"), SyntaxTreeExpression.Field(typeof(SubSubModel), "SubSubField")) ) ); }
public void Should_allow_model_statement_to_be_followed_by_a_newline() { var input = "<html><head></head><body>Hello there @Model.Name;\n</body></html>"; var model = new { Name = "Bob" }; var output = Parse(input, model.GetType()); AssertSyntaxTree(output, SyntaxTree.WriteString("<html><head></head><body>Hello there "), SyntaxTree.WriteExpression(SyntaxTreeExpression.Property(model.GetType(), "Name", ExpressionScope.RootModel)), SyntaxTree.WriteString("\n</body></html>") ); }
public void Should_handle_empty_false_block(BlockNode falseBlock) { var model = new { X = true }; var template = SyntaxTree.Block( SyntaxTree.Conditional( SyntaxTreeExpression.Property(model.GetType(), "X"), SyntaxTree.Block(SyntaxTree.WriteString("Hello")), falseBlock) ); var result = this.ExecuteTemplate(template, model); Assert.Equal("Hello", result); }
public static object[] CaseInsensitiveTests() { return(new object[] { new object[] { "UserName", SyntaxTreeExpression.Property(typeof(CaseTestModel), "UserName") }, new object[] { "userName", SyntaxTreeExpression.Field(typeof(CaseTestModel), "userName") }, new object[] { "username", SyntaxTreeExpression.Property(typeof(CaseTestModel), "UserName") }, new object[] { "USERNAME", SyntaxTreeExpression.Property(typeof(CaseTestModel), "UserName") }, new object[] { "FOO", SyntaxTreeExpression.Field(typeof(CaseTestModel), "foo") }, new object[] { "function()", SyntaxTreeExpression.Function(typeof(CaseTestModel), "Function") }, new object[] { "submodel.subproperty", SyntaxTreeExpression.SubModel(SyntaxTreeExpression.Property(typeof(CaseTestModel), "SubModel"), SyntaxTreeExpression.Property(typeof(SubModel), "SubProperty")) }, new object[] { "submodel.subsubmodel.subsubfield", SyntaxTreeExpression.SubModel(SyntaxTreeExpression.Property(typeof(CaseTestModel), "SubModel"), SyntaxTreeExpression.SubModel(SyntaxTreeExpression.Field(typeof(SubModel), "SubSubModel"), SyntaxTreeExpression.Field(typeof(SubSubModel), "SubSubField"))) } }); }
public void Should_parse_partial_with_specified_model_property() { var input = @"<html><head></head><body>@Partial['testing', Model.User];</body></html>"; var model = new { Name = "Jim", User = new { Name = "Bob" } }; var result = Parse(input, model.GetType()); AssertSyntaxTree( result, SyntaxTree.WriteString("<html><head></head><body>"), SyntaxTree.Include("testing", SyntaxTreeExpression.Property(model.GetType(), "User", ExpressionScope.RootModel)), SyntaxTree.WriteString("</body></html>") ); }
public void Model_with_exclaimation_should_html_encode() { var input = @"<html><head></head><body>Hello there @!Model.Name;</body></html>"; var model = new { Name = "<b>Bob</b>" }; var output = Parse(input, model.GetType()); AssertSyntaxTree( output, SyntaxTree.WriteString("<html><head></head><body>Hello there "), SyntaxTree.WriteExpression(SyntaxTreeExpression.Property(model.GetType(), "Name", ExpressionScope.RootModel), true), SyntaxTree.WriteString("</body></html>") ); }
public void Should_parse_each_block() { var result = Parse("{{#each Items }}{{ this }}{{/each}}", typeof(TestModel)); AssertSyntaxTree(result, SyntaxTree.Iterate( SyntaxTreeExpression.Property(typeof(TestModel), "Items"), SyntaxTree.Block( SyntaxTree.WriteExpression(SyntaxTreeExpression.Self(typeof(string)), true) ) ) ); }
public void Should_handle_has_items_expression <T>(T model, string expectedResult) { var template = SyntaxTree.Block( SyntaxTree.Conditional( SyntaxTreeExpression.HasItems(SyntaxTreeExpression.Property(model.GetType(), "Items")), SyntaxTree.Block(SyntaxTree.WriteString("HasItems")), SyntaxTree.Block(SyntaxTree.WriteString("HasNoItems")) ) ); var result = this.ExecuteTemplate(template, model); Assert.Equal(expectedResult, result); }
public void Should_replace_multiple_properties_with_the_same_name() { const string input = @"<html><head></head><body>Hello there @Model.Name;, nice to see you @Model.Name;</body></html>"; var model = new { Name = "bob" }; var output = Parse(input, model.GetType()); AssertSyntaxTree(output, SyntaxTree.WriteString("<html><head></head><body>Hello there "), SyntaxTree.WriteExpression(SyntaxTreeExpression.Property(model.GetType(), "Name", ExpressionScope.RootModel)), SyntaxTree.WriteString(", nice to see you "), SyntaxTree.WriteExpression(SyntaxTreeExpression.Property(model.GetType(), "Name", ExpressionScope.RootModel)), SyntaxTree.WriteString("</body></html>") ); }