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