public string Evaluate(TagModel model)
{
var id = GetAutoValueAsString(nameof(Name), model);
if (id == null)
{
throw ExpressionParseException.UnexpectedNullValue(nameof(Name)).Decorate(Name.Context);
}
id = LanguageHelper.CamelCaseAttribute(id);
var raw = model.TryGet(id);
if (raw == null)
{
throw MacroException.NotFound(id).Decorate(Name.Context);
}
var macro = raw as DefineMacroTag.MarcoDefinition;
var function = raw as DefineFunctionTag.FunctionDefinition;
if (macro == null && function == null)
{
throw MacroException.NoMacroOrFunction(id).Decorate(Name.Context);
}
if (macro != null)
{
return(ExecuteMacro(model, id, macro));
}
return(ExecuteFunction(model, function));
}
private string ExecuteMacro(TagModel model, string id, DefineMacroTag.MarcoDefinition macro)
{
if (FreeAttribs.Count > 0)
{
throw MacroException.AgrumentsNotAllowed(id).Decorate(Context);
}
return(macro.Evaluate(model));
}
public void Should_Fail_On_Unknown_Macro()
{
var model = new TagModel(this);
CreateFactory().Parse("<macro:define name='testA'>aa</macro:define>").Evaluate(model);
try
{
CreateFactory().Parse("<macro:call name='testC'/>").Evaluate(model);
}
catch (MacroException Te)
{
Assert.That(Te.MessageWithOutContext, Is.EqualTo(MacroException.NotFound("TestC").Message));
}
}
public void Should_Report_Missing_Argument_Function()
{
var model = new TagModel(this);
CreateFactory().Parse("<macro:function name='testA' argument-1='firstName' argument-2='lastName'>Hi ${firstName} ${lastName}</macro:function>").Evaluate(model);
CreateFactory().Parse("<macro:function name='testB' argument-1='firstName' argument-2='lastName'>Bye ${firstName} ${lastName}</macro:function>").Evaluate(model);
try
{
CreateFactory().Parse("<macro:call name='testA' firstName='John'/>").Evaluate(model);
}
catch (MacroException Me)
{
Assert.That(Me.MessageWithOutContext, Is.EqualTo(MacroException.NullNotAllowed("lastName").Message));
}
}
public void Should_Fail_On_Neither_Macro_Or_Function()
{
var model = new TagModel(this);
model.Page["TestC"] = "X";
CreateFactory().Parse("<macro:define name='testA'>aa</macro:define>").Evaluate(model);
try
{
CreateFactory().Parse("<macro:call name='testC'/>").Evaluate(model);
}
catch (MacroException Te)
{
Assert.That(Te.MessageWithOutContext, Is.EqualTo(MacroException.NoMacroOrFunction("TestC").Message));
}
}
public object Evaluate(params object[] parameters)
{
var def = parameters.Cast <DefineFunctionTag.FunctionDefinition>().First();
var args = parameters.Skip(1).ToArray();
if (args.Length != def.Arguments.Length)
{
throw MacroException.ArgumentIndexOutOfBounds(args.Length, def.Arguments.Length);
}
var model = new Dictionary <string, object>();
for (var i = 0; i < def.Arguments.Length; i++)
{
var argument = def.Arguments[i];
if (argument.Contains("("))
{
argument = argument.Substring(0, argument.IndexOf("(", StringComparison.InvariantCulture));
}
model[argument] = args[i];
}
return(def.Evaluate(new TagModel(model)));
}
public ITagAttribute this[string property]
{
get
{
if (nameof(Result).Equals(property))
{
return(Result);
}
var argumentIndex = ParseArgumentsProperty(property);
if (!argumentIndex.HasValue)
{
return(base.AttributeSetter[property]);
}
if (argumentIndex >= Arguments.Count)
{
return(null);
}
return(Arguments[argumentIndex.Value - 1]);
}
set {
if (nameof(Result).Equals(property))
{
Result = value;
return;
}
var argumentIndex = ParseArgumentsProperty(property);
if (!argumentIndex.HasValue)
{
base.AttributeSetter[property] = value;
return;
}
if (argumentIndex != Arguments.Count + 1)
{
throw MacroException.ExcpectedArgumentIndex(argumentIndex.Value, Arguments.Count).Decorate(value.Context);
}
Arguments.Add(value);
}
}
private string ExecuteFunction(TagModel model, DefineFunctionTag.FunctionDefinition function)
{
var callArguments = new Dictionary <string, object>();
var freeFields = FreeFields(model);
foreach (var argumentWithDefault in function.Arguments)
{
var argument = argumentWithDefault;
var defaultPath = null as string;
if (argumentWithDefault.Contains("(") && argumentWithDefault.EndsWith(")"))
{
var split = argumentWithDefault.IndexOf("(", StringComparison.InvariantCulture);
argument = argumentWithDefault.Substring(0, split);
defaultPath = argumentWithDefault.Substring(split + 1, argumentWithDefault.Length - split - 2);
// Console.WriteLine(defaultPath);
}
var value = CollectionUtils.SafeGet(freeFields, argument) ?? CollectionUtils.SafeGet(freeFields, LanguageHelper.CamelCaseProperty(argument));
if (!string.IsNullOrEmpty(defaultPath) && value == null)
{
value = model.TryGet(defaultPath);
}
if (function.IsStrict && value == null)
{
throw MacroException.NullNotAllowed(argument).Decorate(Name.Context);
}
callArguments[argument] = value;
// model.Tag[argument] = value;
}
model.PushTagStack();
foreach (var argument in callArguments)
{
model.Tag[argument.Key] = argument.Value;
}
var result = function.Evaluate(model);
model.PopTagStack();
return(TypeConverter.To <string>(result));
}
