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