public string Evaluate(IDictionary <string, object> attributes, IFunctionEvaluator evaluator, string content)
{
var from = attributes.GetRequiredAttribute <IEnumerable>("from");
var item = attributes.GetRequiredAttribute <string>("item");
return(EvaluateContent(from, item, evaluator, content));
}
public void Setup()
{
localData = new Dictionary <string, object>();
evaluator = MockRepository.GenerateMock <IFunctionEvaluator>();
evaluator.Stub(x => x.LocalData).Return(localData);
}
public string Evaluate(IDictionary <string, object> attributes, IFunctionEvaluator evaluator, string content)
{
var name = attributes.GetRequiredAttribute <string>("name");
evaluator.LocalData[name] = evaluator.Evaluate(content);
return(null);
}
public string Evaluate(IDictionary <string, object> attributes, IFunctionEvaluator evaluator)
{
var name = attributes.GetRequiredAttribute <string>("var");
var value = attributes.GetRequiredAttribute <object>("value");
evaluator.LocalData[name] = value;
return(null);
}
public Boolean FunctionFind(String functionName, out IFunctionEvaluator functionEvaluator)
{
Boolean Found = FindIdentifier(functionName, out var context, out var Item) && Item.Identifierkind == IdentifierKind.Function;
if (Found)
{
functionEvaluator = Item as IFunctionEvaluator;
}
else
{
functionEvaluator = null;
}
return(Found);
}
public string Evaluate(IDictionary <string, object> attributes, IFunctionEvaluator evaluator)
{
var valuesAttribute = attributes.GetRequiredAttribute <string>("values");
const string name = "default";
var slotName = GetType().FullName + "_" + name;
if (!evaluator.FunctionData.ContainsKey(slotName))
{
var splitAttributes = valuesAttribute.Split(',');
var cycleValue = new CycleValue(splitAttributes);
evaluator.FunctionData[slotName] = cycleValue;
}
return(((CycleValue)evaluator.FunctionData[slotName]).NextValue());
}
public void Setup()
{
var blockFunctions = new IBlockFunction[] { new ForEach(), new Literal(), new Strip(), new Capture() };
var inlineFunctions = new IInlineFunction[] { new LDelim(), new RDelim(), new Assign(), new Cycle() };
var expressionFunctions = new IExpressionFunction[] { new If() };
var variableModifiers = new IVariableModifier[] { new Capitalize(), new Cat(), new CountCharacters(), new CountParagraphs(), new CountSentences(), new CountWords(), new DateFormat(), new Default(), new Lower(), new NewLineToBreak(), new RegexReplace(), new Replace(), new Spacify(), new StringFormat(), new ASmarty.VariableModifiers.Strip(), new StripTags(), new Truncate(), new Upper(), new WordWrap(), new Indent() };
var functions = new Functions(blockFunctions, inlineFunctions, expressionFunctions, variableModifiers);
viewData = new Dictionary <string, object>();
functionData = new Dictionary <string, object>();
var internalEvaluator = new InternalEvaluator(null, null, functions);
evaluator = new ViewEngine.Evaluator(internalEvaluator, 0);
functionEvaluator = new FunctionEvaluator(internalEvaluator, 0, functionData);
}
public void TryEvaluateFunction_LiteralsPassedToFunction_EvaluationReturnsCorrectly()
{
const string expression = @"Sum(10, 10)";
_eval = MathOpsFactory.CreateFunctionEvaluator();
var hasSuceeded = _eval.TryEvaluateFunction(expression, out string result, out string error);
if (hasSuceeded)
{
Assert.AreEqual(result, "20");
}
else
{
Assert.Fail("The Evaluation Manager was unable to resolve evaluation, this is a huge problem");
}
}
public void TryEvaluateFunction_InvalidExpression_ErrorPopulatedAndReturned()
{
const string expression = @"Sum(10, 10,asdasd)";
_eval = MathOpsFactory.CreateFunctionEvaluator();
var hasSuceeded = _eval.TryEvaluateFunction(expression, out string result, out string error);
if (!hasSuceeded)
{
Assert.IsTrue(error.Length > 0);
}
else
{
Assert.Fail("The Function Evaluator did not correctly error on an invalid expression");
}
}
public string Evaluate(IDictionary <string, object> attributes, IFunctionEvaluator evaluator)
{
var file = attributes.GetRequiredAttribute <string>("file");
var assign = attributes.GetOptionalAttribute <string>("assign");
var evaluatedTemplate = evaluator.EvaluateTemplate(file);
if (assign == null)
{
return(evaluatedTemplate);
}
else
{
evaluator.LocalData.Add(assign, evaluatedTemplate);
return(null);
}
}
public void TryEvaluateFunction_InvalidExpression_ErrorPopulatedAndReturned()
{
const string expression = @"Sum(10, 10,asdasd)";
string result;
string error;
_eval = MathOpsFactory.CreateFunctionEvaluator();
bool hasSuceeded = _eval.TryEvaluateFunction(expression, out result, out error);
if(!hasSuceeded)
{
Assert.IsTrue(error.Length > 0);
}
else
{
Assert.Fail("The Function Evaluator did not correctly error on an invalid expression");
}
}
public void TryEvaluateFunction_LiteralsPassedToFunction_EvaluationReturnsCorrectly()
{
const string expression = @"Sum(10, 10)";
string result;
string error;
_eval = MathOpsFactory.CreateFunctionEvaluator();
bool hasSuceeded = _eval.TryEvaluateFunction(expression, out result, out error);
if(hasSuceeded)
{
Assert.AreEqual(result, "20");
}
else
{
Assert.Fail("The Evaluation Manager was unable to resolve evaluation, this is a huge problem");
}
}
public Boolean FunctionFind(String functionName, out IFunctionEvaluator functionEvaluator)
{
IEnvironment context;
INametableItem Item;
Boolean Found = FindIdentifier(functionName, out context, out Item) && Item.Identifierkind == IdentifierKind.Function;
if (Found)
{
functionEvaluator = Item as IFunctionEvaluator;
}
else
{
functionEvaluator = null;
}
return(Found);
}
public string Evaluate(string functionDetails, IFunctionEvaluator evaluator, string content)
{
Match elseIfMatch = null;
Match elseMatch = null;
var depth = 0;
foreach (Match match in Regex.Matches(content, @"{elseif .*}|{else}|{if .*}|{/if}"))
{
if (Regex.IsMatch(match.Value, @"{if .*}"))
{
depth++;
}
else if (Regex.IsMatch(match.Value, @"{/if}"))
{
depth--;
}
else
{
if (depth == 0)
{
if (elseIfMatch == null && Regex.IsMatch(match.Value, @"{elseif .*}"))
{
elseIfMatch = match;
}
else if (elseMatch == null && Regex.IsMatch(match.Value, @"{else}"))
{
elseMatch = match;
}
}
}
}
var result = (bool)evaluator.EvaluateExpression(functionDetails);
if (result)
{
if (elseIfMatch != null)
{
return(evaluator.Evaluate(content.Substring(0, elseIfMatch.Index)));
}
else if (elseMatch != null)
{
return(evaluator.Evaluate(content.Substring(0, elseMatch.Index)));
}
else
{
return(evaluator.Evaluate(content));
}
}
else
{
if (elseIfMatch != null)
{
var newDetails = elseIfMatch.Value.Substring(8, elseIfMatch.Length - 9);
var newContent = content.Substring(elseIfMatch.Index + elseIfMatch.Length);
return(Evaluate(newDetails, evaluator, newContent));
}
else if (elseMatch != null)
{
return(evaluator.Evaluate(content.Substring(elseMatch.Index + elseMatch.Length)));
}
else
{
return(string.Empty);
}
}
}
public string Evaluate(IDictionary <string, object> attributes, IFunctionEvaluator evaluator)
{
return("{");
}
/// <summary>
/// The execute method that is called when the activity is executed at run time and will hold all the logic of the activity
/// </summary>
protected override void OnExecute(NativeActivityContext context)
{
_debugInputs = new List <DebugItem>();
_debugOutputs = new List <DebugItem>();
IDSFDataObject dataObject = context.GetExtension <IDSFDataObject>();
IDataListCompiler compiler = DataListFactory.CreateDataListCompiler();
ErrorResultTO allErrors = new ErrorResultTO();
ErrorResultTO errors = new ErrorResultTO();
Guid executionId = DataListExecutionID.Get(context);
allErrors.MergeErrors(errors);
InitializeDebug(dataObject);
// Process if no errors
try
{
IsSingleValueRule.ApplyIsSingleValueRule(Result, allErrors);
if (dataObject.IsDebugMode())
{
AddDebugInputItem(executionId);
}
IFunctionEvaluator functionEvaluator = MathOpsFactory.CreateFunctionEvaluator();
string input = string.IsNullOrEmpty(Expression) ? Expression : Expression.Replace("\\r", string.Empty).Replace("\\n", string.Empty).Replace(Environment.NewLine, "");
IEvaluationFunction evaluationFunctionTo = MathOpsFactory.CreateEvaluationExpressionTO(input);
string result = functionEvaluator.EvaluateFunction(evaluationFunctionTo, executionId, out errors);
allErrors.MergeErrors(errors);
compiler.Upsert(executionId, Result, result, out errors);
if (dataObject.IsDebugMode() && !allErrors.HasErrors())
{
AddDebugOutputItem(Result, executionId);
}
allErrors.MergeErrors(errors);
}
catch (Exception ex)
{
Dev2Logger.Log.Error("Calculate Exception", ex);
allErrors.AddError(ex.Message);
}
finally
{
// Handle Errors
var hasErrors = allErrors.HasErrors();
if (hasErrors)
{
DisplayAndWriteError("DsfCalculateActivity", allErrors);
compiler.UpsertSystemTag(dataObject.DataListID, enSystemTag.Dev2Error, allErrors.MakeDataListReady(), out errors);
compiler.Upsert(executionId, Result, (string)null, out errors);
}
if (dataObject.IsDebugMode())
{
if (hasErrors)
{
AddDebugOutputItem(Result, executionId);
}
DispatchDebugState(context, StateType.Before);
DispatchDebugState(context, StateType.After);
}
}
}
public string Evaluate(IDictionary <string, object> attributes, IFunctionEvaluator evaluator)
{
//{call object="user" function="load"}
//{call object="user" function="load" param1="" param2="" param3=""}
object _obj = null;
object _fun = null;
attributes.TryGetValue("object", out _obj);
attributes.TryGetValue("function", out _fun);
string obj = _obj as string;
string fun = _fun as string;
if (string.IsNullOrEmpty(obj))
{
throw new RequiredParameterException("tag call not set object attribute");
}
if (string.IsNullOrEmpty(fun))
{
throw new RequiredParameterException("tag call not set function attribute");
}
//
var parameters = new List <object>(attributes.Count);
for (int i = 1; i < int.MaxValue; i++)
{
object p = null;
if (attributes.TryGetValue("param" + i, out p))
{
parameters.Add(p);
}
else
{
break;
}
}
//
object _object = null;
if (evaluator.ViewData.TryGetValue(obj, out _object) == false)
{
throw new RequiredParameterException("tag call " + _object + " noset object in view date ");
}
//
if (_object == null)
{
return(null);
}
//
object methodInfo = null;
string methodName = string.Format("call_{0}_{1}", obj, fun);
if (evaluator.FunctionData.TryGetValue(methodName, out methodInfo) == false)
{
var funMethodInfo = _object.GetType().GetMethod(fun);
if (funMethodInfo == null)
{
throw new RequiredParameterException("tag call " + _object + " not method " + fun);
}
methodInfo = Activator.CreateInstance(typeof(ASmarty.Tools.Accessor <>).MakeGenericType(_object.GetType()), _object.GetType(), fun) as Tools.IAccessor;
evaluator.FunctionData[methodName] = methodInfo;
}
//
var accessor = methodInfo as Tools.IAccessor;
if (accessor != null)
{
accessor.Invoke(_object, parameters.ToArray());
}
//
return(null);
}
public string Evaluate(IDictionary <string, object> attributes, IFunctionEvaluator evaluator, string content)
{
return(regex.Replace(evaluator.Evaluate(content), string.Empty));
}
/// <summary> /// Add a custom function evaluator to the evaluator. /// </summary> /// <param name="evaluator">The <see cref="IFunctionEvaluator"/> responsible for /// implementing the custom function definition.</param> public static void AddFunctionEvaluator(IFunctionEvaluator evaluator) => _functionEvaluators.Add(evaluator);
static Stack <double> EvaluateInternal(IEnumerable <Token> tokens)
{
var result = new Stack <double>();
var operands = new Stack <string>();
var operators = new Stack <Token>();
var lastType = OperatorType.None;
var lastToken = string.Empty;
var nonBase10 = string.Empty;
var iterator = tokens.GetIterator();
Token token;
while ((token = iterator.GetNext()) != null)
{
if (token.Type == TokenType.Operand)
{
if (lastType == OperatorType.Unary && _radixOperators.ContainsKey(lastToken))
{
nonBase10 = token.Name;
}
else if (iterator.PeekNext() != null && iterator.PeekNext().Name == "[")
{
var value = Assembler.SymbolManager.GetNumericVectorElementValue(token, iterator.GetNext());
if (double.IsNegativeInfinity(value))
{
throw new ExpressionException(iterator.Current, "Index is out of range.");
}
result.Push(value);
}
else
{
result.Push(EvaluateAtomic(token));
}
}
else if (token.Type == TokenType.Operator)
{
lastType = token.OperatorType;
lastToken = token.Name; // track for non-base 10 operands that may succeed this operation
if ((token.OperatorType == OperatorType.Open && token.Name.Equals("(")) ||
token.OperatorType == OperatorType.Separator)
{
Stack <double> subResults = EvaluateInternal(token.Children);
foreach (var sr in subResults)
{
result.Push(sr);
}
}
else if (token.OperatorType == OperatorType.Function && !_functions.ContainsKey(token.Name))
{
IFunctionEvaluator fe = _functionEvaluators.FirstOrDefault(fe => fe.EvaluatesFunction(token));
if (fe == null)
{
throw new ExpressionException(token.Position, $"Unknown function \"{token.Name}\".");
}
result.Push(fe.EvaluateFunction(token, iterator.GetNext()));
}
else if (token.OperatorType == OperatorType.Unary)
{
operators.Push(token);
}
else
{
if (operators.Count > 0)
{
if (!_operators.ContainsKey(token) && !_functions.ContainsKey(token.Name))
{
throw new ExpressionException(token.Position, $"Unknown operator \"{token.Name}\".");
}
Token top = operators.Peek();
var opOrder = token.OperatorType == OperatorType.Function ? int.MaxValue : _operators[token].Item2;
while ((top.OperatorType == OperatorType.Function || _operators[top].Item2 >= opOrder) && operators.Count > 0)
{
operators.Pop();
DoOperation(top);
if (operators.Count > 0)
{
top = operators.Peek();
}
}
}
if (token.OperatorType != OperatorType.Function && !_operators.ContainsKey(token))
{
throw new ExpressionException(token.Position, $"Invalid expression \"{token.Name}\".");
}
operators.Push(token);
}
}
else
{
throw new ExpressionException(token.Position, $"Invalid expression \"{token.Name}\".");
}
}
while (operators.Count > 0)
{
DoOperation(operators.Pop());
}
return(result);
void DoOperation(Token op)
{
if (!string.IsNullOrEmpty(nonBase10))
{
try
{
result.Push(_radixOperators[op.Name](nonBase10));
nonBase10 = string.Empty;
}
catch
{
throw new ExpressionException(op.Position, $"\"{op.Name}{nonBase10}\" is not a valid expression.");
}
}
else
{
OperationDef operation;
var parms = new List <double>();
var parmCount = 1;
if (op.OperatorType == OperatorType.Function)
{
operation = _functions[op.Name];
parmCount = operation.Item2;
}
else
{
if (!_operators.ContainsKey(op))
{
throw new ExpressionException(op.Position, $"Invalid expression \"{op.Name}\".");
}
operation = _operators[op];
if (op.OperatorType == OperatorType.Binary)
{
parmCount++;
}
}
while (parmCount-- >= parms.Count)
{
if (result.Count == 0)
{
var opType = op.OperatorType == OperatorType.Function ? "function" : "operator";
throw new ExpressionException(op.Position, $"Missing operand argument for {opType} \"{op.Name}\".");
}
parms.Add(result.Pop());
}
result.Push(operation.Item1(parms));
}
}
}
public string Evaluate(IDictionary <string, object> attributes, IFunctionEvaluator evaluator, string content)
{
return(content);
}
