private static void HandleEachOverSelf(SuperSimpleTemplateParserState state)
{
var each = SyntaxTree.Iterate(
SyntaxTreeExpression.Self(state.CurrentTypeInScope()),
SyntaxTree.Block()
);
state.AddNodeToCurrentBlock(each);
state.PushNewScope(each.Body, each.ItemType);
}
public void Should_parse_sub_model_expression_from_root_model()
{
var model = new { User = new { Name = "Bob" } };
var result = SuperSimpleExpressionParser.Parse(CreateScopes(model.GetType()), "Model.User.Name");
result.ShouldDeepEqual(SyntaxTreeExpression.SubModel(
SyntaxTreeExpression.Property(model.GetType(), "User", ExpressionScope.RootModel),
SyntaxTreeExpression.Property(model.User.GetType(), "Name")
));
}
public void Should_trim_whitespace_from_next_literal()
{
var template = Parse("Hello {{this~}}\r\n!", typeof(string));
AssertSyntaxTree(
template,
SyntaxTree.WriteString("Hello "),
SyntaxTree.WriteExpression(SyntaxTreeExpression.Self(typeof(string)), true),
SyntaxTree.WriteString("!")
);
}
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_parse_partial_syntax()
{
var model = new { };
var template = Parse("Hello {{> person }}", model.GetType());
AssertSyntaxTree(
template,
SyntaxTree.WriteString("Hello "),
SyntaxTree.Include("person", SyntaxTreeExpression.Self(model.GetType()))
);
}
public void Should_replace_primitive_model_with_value()
{
var input = @"<html><head></head><body>Hello there @Model;</body></html>";
var output = Parse(input, typeof(string));
AssertSyntaxTree(output,
SyntaxTree.WriteString("<html><head></head><body>Hello there "),
SyntaxTree.WriteExpression(SyntaxTreeExpression.Self(typeof(string), ExpressionScope.RootModel)),
SyntaxTree.WriteString("</body></html>")
);
}
private static void HandlePartial(SuperSimpleTemplateParserState state)
{
var details = state.ParseCurrentTokenNameAndModelExpression();
ExpressionNode expression = SyntaxTreeExpression.Self(state.CurrentTypeInScope());
if (!String.IsNullOrEmpty(details.Model))
{
expression = state.ParseExpression(details.Model);
}
state.AddNodeToCurrentBlock(SyntaxTree.Include(details.Name, expression));
}
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_be_able_to_write_item_from_dictionary()
{
var model = new Dictionary <string, object>();
model.Add("Name", "Joe");
var template = SyntaxTree.Block(
SyntaxTree.WriteExpression(SyntaxTreeExpression.LateBound("Name"))
);
var result = ExecuteTemplate(template, model);
Assert.That(result, Is.EqualTo("Joe"));
}
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_basic_partials()
{
var input = @"<html><head></head><body>@Partial['testing'];</body></html>";
var result = Parse(input, typeof(object));
AssertSyntaxTree(
result,
SyntaxTree.WriteString("<html><head></head><body>"),
SyntaxTree.Include("testing", SyntaxTreeExpression.Self(typeof(object))),
SyntaxTree.WriteString("</body></html>")
);
}
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_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_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_throw_if_unable_to_load_template()
{
var model = new { Name = "Joe" };
var template = SyntaxTree.Block(
SyntaxTree.WriteString("Hello "),
SyntaxTree.Include("person", SyntaxTreeExpression.Self(model.GetType()))
);
Assert.Throws <VeilCompilerException>(() =>
{
ExecuteTemplate(template, model);
});
}
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_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 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_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 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_be_able_to_output_value_types_from_collections()
{
var model = new { Items = new[] { "1", "2", "3", "4" } };
var template = SyntaxTree.Block(SyntaxTree.Iterate(
SyntaxTreeExpression.Property(model.GetType(), "Items"),
SyntaxTree.Block(
SyntaxTree.WriteExpression(SyntaxTreeExpression.Self(typeof(string)))
)
));
var result = ExecuteTemplate(template, model);
Assert.Equal("1234", result);
}
public void Should_be_able_to_reference_parent_scope_from_within_each_block()
{
var result = Parse("{{#each Items }}{{ ../Prefix }}{{ this }}{{/each}}", typeof(TestModel));
AssertSyntaxTree(result,
SyntaxTree.Iterate(
SyntaxTreeExpression.Property(typeof(TestModel), "Items"),
SyntaxTree.Block(
SyntaxTree.WriteExpression(SyntaxTreeExpression.Property(typeof(TestModel), "Prefix", ExpressionScope.ModelOfParentScope), true),
SyntaxTree.WriteExpression(SyntaxTreeExpression.Self(typeof(string)), true)
)
)
);
}
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>")
);
}
public static ExpressionNode Parse(HandlebarsBlockStack blockStack, string expression)
{
expression = expression.Trim();
if (expression == "this")
{
return(SyntaxTreeExpression.Self(blockStack.GetCurrentModelType(), ExpressionScope.CurrentModelOnStack));
}
if (expression.StartsWith("../"))
{
return(ParseAgainstModel(blockStack.GetParentModelType(), expression.Substring(3), ExpressionScope.ModelOfParentScope));
}
return(ParseAgainstModel(blockStack.GetCurrentModelType(), expression, ExpressionScope.CurrentModelOnStack));
}
public void Should_include_block_with_ifnull_if_value_null()
{
var input = @"<html><head></head><body>@IfNull.Name;No users found@EndIf;</body></html>";
var output = Parse(input, typeof(User));
AssertSyntaxTree(
output,
SyntaxTree.WriteString("<html><head></head><body>"),
SyntaxTree.Conditional(SyntaxTreeExpression.Property(typeof(User), "Name"),
SyntaxTree.Block(),
SyntaxTree.Block(SyntaxTree.WriteString("No users found"))
),
SyntaxTree.WriteString("</body></html>")
);
}
public void Should_throw_with_empty_blocks(BlockNode emptyBlock)
{
var model = new { X = true };
var template = SyntaxTree.Block(
SyntaxTree.Conditional(
SyntaxTreeExpression.Property(model.GetType(), "X"),
emptyBlock,
emptyBlock
));
Assert.Throws <VeilCompilerException>(() =>
{
this.ExecuteTemplate(template, model);
});
}
public void Should_support_this_inside_with_block()
{
var model = new { User = "" };
var template = Parse("Hello {{#with User}}{{this}}{{/with}}", model.GetType());
AssertSyntaxTree(
template,
SyntaxTree.WriteString("Hello "),
SyntaxTree.ScopeNode(
SyntaxTreeExpression.Property(model.GetType(), "User"),
SyntaxTree.Block(
SyntaxTree.WriteExpression(SyntaxTreeExpression.Self(model.User.GetType()), true)
)
)
);
}
public void Should_handle_conditional_on_dictionary_item <T>(T testModel, string expectedResult)
{
var model = new Dictionary <string, object>();
model.Add("Bool", testModel.GetType().GetProperty("Condition").GetValue(testModel));
var template = SyntaxTree.Block(
SyntaxTree.Conditional(
SyntaxTreeExpression.LateBound("Bool"),
SyntaxTree.Block(SyntaxTree.WriteString("True")),
SyntaxTree.Block(SyntaxTree.WriteString("False"))
)
);
var result = ExecuteTemplate(template, model);
Assert.Equal(expectedResult, result);
}
public void Should_render_include_with_same_model()
{
var model = new { Name = "Joe" };
RegisterTemplate("person", SyntaxTree.Block(
SyntaxTree.WriteExpression(SyntaxTreeExpression.Property(model.GetType(), "Name"))
));
var template = SyntaxTree.Block(
SyntaxTree.WriteString("Hello "),
SyntaxTree.Include("person", SyntaxTreeExpression.Self(model.GetType()))
);
var result = ExecuteTemplate(template, model);
Assert.That(result, Is.EqualTo("Hello Joe"));
}
