public void Should_preference_late_binding_over_Has_prefix() { var model = new { HasItems = true, Items = new string[0] }; var result = SuperSimpleExpressionParser.Parse(CreateScopes(typeof(object)), "Model.HasItems"); result.ShouldDeepEqual(SyntaxTreeExpression.LateBound("HasItems", true, ExpressionScope.RootModel)); }
public void Should_handle_late_binding <T>(T model) { var template = SyntaxTree.Block( SyntaxTree.WriteExpression(SyntaxTreeExpression.LateBound("Name")) ); var result = ExecuteTemplate(template, model); Assert.That(result, Is.EqualTo("Joe")); }
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_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_be_able_to_iterate_items_from_an_untyped_model() { var model = new Dictionary <string, object>(); model.Add("Items", new string[] { "1", "2" }); var template = SyntaxTree.Block(SyntaxTree.Iterate( SyntaxTreeExpression.LateBound("Items"), SyntaxTree.Block( SyntaxTree.WriteExpression(SyntaxTreeExpression.Self(typeof(object))) ) )); var result = ExecuteTemplate(template, model); Assert.Equal("12", result); }
public void Should_not_get_mixed_up_by_caching_of_late_bindings() { var model = new Dictionary <string, object>(); model.Add("Name", "D1"); model.Add("User", new { Name = "U" }); model.Add("Department", new Dictionary <string, object> { { "Name", "D2" } }); var template = SyntaxTree.Block( SyntaxTree.WriteExpression(SyntaxTreeExpression.LateBound("Name")), SyntaxTree.WriteExpression(SyntaxTreeExpression.SubModel(SyntaxTreeExpression.LateBound("User"), SyntaxTreeExpression.LateBound("Name"))), SyntaxTree.WriteExpression(SyntaxTreeExpression.SubModel(SyntaxTreeExpression.LateBound("Department"), SyntaxTreeExpression.LateBound("Name"))) ); var result = ExecuteTemplate(template, model); Assert.That(result, Is.EqualTo("D1UD2")); }
public void Should_render_include_with_untyped_model() { var model = new Dictionary <string, object>(); model.Add("Name", "Joe"); RegisterTemplate("person", SyntaxTree.Block( SyntaxTree.WriteExpression(SyntaxTreeExpression.LateBound("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")); }
public void Should_render_include_with_untyped_sub_model() { var model = new Dictionary <string, object>(); model.Add("Person", new { Name = "Joe" }); RegisterTemplate("person", SyntaxTree.Block( SyntaxTree.WriteExpression(SyntaxTreeExpression.LateBound("Name")) )); var template = SyntaxTree.Block( SyntaxTree.WriteString("Hello "), SyntaxTree.Include("person", SyntaxTreeExpression.LateBound("Person")) ); var result = ExecuteTemplate(template, model); Assert.Equal("Hello Joe", result); }
private static ExpressionNode ParseAgainstModel(Type modelType, string expression, ExpressionScope expressionScope, int recursionLevel, IMemberLocator memberLocator, SourceLocation location) { var dotIndex = expression.IndexOf('.'); if (dotIndex >= 0) { var subModel = ParseAgainstModel(modelType, expression.Substring(0, dotIndex), expressionScope, recursionLevel, memberLocator, location.SetLength(dotIndex)); return(SyntaxTreeExpression.SubModel( subModel, ParseAgainstModel(subModel.ResultType, expression.Substring(dotIndex + 1), ExpressionScope.CurrentModelOnStack, 0, memberLocator, location.MoveIndex(dotIndex + 1)), location )); } if (expression.EndsWith("()")) { var func = memberLocator.FindMember(modelType, expression.Substring(0, expression.Length - 2), MemberTypes.Method); if (func != null) { return(SyntaxTreeExpression.Function(modelType, func.Name, location, expressionScope)); } } var prop = memberLocator.FindMember(modelType, expression, MemberTypes.Property | MemberTypes.Field); if (prop != null) { switch (prop.MemberType) { case MemberTypes.Property: return(SyntaxTreeExpression.Property(modelType, prop.Name, location, expressionScope, recursionLevel)); case MemberTypes.Field: return(SyntaxTreeExpression.Field(modelType, prop.Name, location, expressionScope, recursionLevel)); } } if (IsLateBoundAcceptingType(modelType)) { return(SyntaxTreeExpression.LateBound(expression, location, memberLocator, false, expressionScope, recursionLevel)); } throw new VeilParserException(String.Format("Unable to parse model expression '{0}' againt model '{1}'", expression, modelType.Name), location); }
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)); }
private static ExpressionNode ParseAgainstModel(Type modelType, string expression, ExpressionScope expressionScope) { var dotIndex = expression.IndexOf('.'); if (dotIndex >= 0) { var subModel = HandlebarsExpressionParser.ParseAgainstModel(modelType, expression.Substring(0, dotIndex), expressionScope); return(SyntaxTreeExpression.SubModel( subModel, HandlebarsExpressionParser.ParseAgainstModel(subModel.ResultType, expression.Substring(dotIndex + 1), ExpressionScope.CurrentModelOnStack) )); } if (expression.EndsWith("()")) { var func = FindMember(modelType, expression.Substring(0, expression.Length - 2), MemberTypes.Method); if (func != null) { return(SyntaxTreeExpression.Function(modelType, func.Name, expressionScope)); } } var prop = FindMember(modelType, expression, MemberTypes.Property | MemberTypes.Field); if (prop != null) { switch (prop.MemberType) { case MemberTypes.Property: return(SyntaxTreeExpression.Property(modelType, prop.Name, expressionScope)); case MemberTypes.Field: return(SyntaxTreeExpression.Field(modelType, prop.Name, expressionScope)); } } if (IsLateBoundAcceptingType(modelType)) { return(SyntaxTreeExpression.LateBound(expression, false, expressionScope)); } throw new VeilParserException(String.Format("Unable to parse model expression '{0}' against model '{1}'", expression, modelType.Name)); }
public void Should_parse_as_late_bound_when_model_type_is_not_known <T>(T model) { var result = HandlebarsExpressionParser.Parse(CreateScopes(typeof(T)), "Name"); result.ShouldDeepEqual(SyntaxTreeExpression.LateBound("Name", false, ExpressionScope.CurrentModelOnStack)); }
public void Should_parse_as_late_bound_when_model_type_is_not_known <T>(T model) { var result = SuperSimpleExpressionParser.Parse(CreateScopes(typeof(T)), "Model.Name"); result.ShouldDeepEqual(SyntaxTreeExpression.LateBound("Name", true, ExpressionScope.RootModel)); }