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>")
);
}