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