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_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>(() =>
{
SyntaxTreeExpression.HasItems(SyntaxTreeExpression.Property(model.GetType(), "Items"));
});
}
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_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);
}
private static ExpressionNode ParseAgainstModel(string originalExpression, string expression, SuperSimpleTemplateParserScope scope, ExpressionScope expressionScope)
{
var subModelIndex = expression.IndexOf('.');
if (subModelIndex >= 0)
{
var subModel = ParseAgainstModel(originalExpression, expression.Substring(0, subModelIndex), scope, expressionScope);
return(SyntaxTreeExpression.SubModel(
subModel,
ParseAgainstModel(originalExpression, expression.Substring(subModelIndex + 1), new SuperSimpleTemplateParserScope {
Block = scope.Block, ModelType = subModel.ResultType
}, ExpressionScope.CurrentModelOnStack)
));
}
var propertyInfo = scope.ModelType.GetProperty(expression);
if (propertyInfo != null)
{
return(SyntaxTreeExpression.Property(scope.ModelType, expression, expressionScope));
}
var fieldInfo = scope.ModelType.GetField(expression);
if (fieldInfo != null)
{
return(SyntaxTreeExpression.Field(scope.ModelType, expression, expressionScope));
}
if (IsLateBoundAcceptingType(scope.ModelType))
{
return(SyntaxTreeExpression.LateBound(expression, true, expressionScope));
}
if (expression.StartsWith("Has"))
{
var collectionExpression = ParseAgainstModel(originalExpression, expression.Substring(3), scope, expressionScope);
return(SyntaxTreeExpression.HasItems(collectionExpression));
}
throw new VeilParserException(String.Format("Unable to parse model expression '{0}'", originalExpression));
}