public object Any(EvalExpression request)
{
if (string.IsNullOrWhiteSpace(request.Expression))
{
return(new EvalExpressionResponse());
}
var args = new Dictionary <string, object>();
foreach (String name in Request.QueryString.AllKeys)
{
if (name.EqualsIgnoreCase("expression"))
{
continue;
}
var argExpr = Request.QueryString[name];
var argValue = JS.eval(argExpr);
args[name] = argValue;
}
var scope = JS.CreateScope(args: args);
var expr = JS.expression(request.Expression.Trim());
var response = new EvalExpressionResponse {
Result = ScriptLanguage.UnwrapValue(expr.Evaluate(scope)),
Tree = expr.ToJsAstString(),
};
return(response);
}
public void Can_Invoke_Arrow_Expressions()
{
var context = new TemplateContext().Init();
var expr = JS.expression("pow(2,2) + pow(4,2)");
Assert.That(expr.Evaluate(), Is.EqualTo(20));
Assert.That(JS.eval("pow(2,2) + pow(4,2)"), Is.EqualTo(20));
var scope = JS.CreateScope(args: new Dictionary <string, object> {
["a"] = 2,
["b"] = 4,
});
Assert.That(JS.eval("pow(a,2) + pow(b,2)", scope), Is.EqualTo(20));
var customPow = JS.CreateScope(functions: new MyFilters());
Assert.That(JS.eval("pow(2,2) + pow(4,2)", customPow), Is.EqualTo(3));
var arrowExpr = (JsArrowFunctionExpression)JS.expression("(a,b) => pow(a,2) + pow(b,2)");
Assert.That(arrowExpr.Invoke(2, 4), Is.EqualTo(20));
Assert.That(arrowExpr.Invoke(customPow, 2, 4), Is.EqualTo(3));
}
public void Can_eval_js()
{
var scope = JS.CreateScope(
args: new Dictionary <string, object>
{
{ "arg", "value" }
},
functions: new CustomFilter());
Assert.That(JS.eval("arg", scope), Is.EqualTo("value"));
Assert.That(JS.eval("reverse(arg)", scope), Is.EqualTo("eulav"));
Assert.That(JS.eval("itemsOf(3, padRight(reverse(arg), 8, '_'))", scope), Is.EqualTo(new List <object> {
"eulav___", "eulav___", "eulav___"
}));
Assert.That(JS.eval("{a: itemsOf(3, padRight(reverse(arg), 8, '_')) }", scope), Is.EqualTo(new Dictionary <string, object>
{
{ "a", new List <object> {
"eulav___", "eulav___", "eulav___"
} }
}));
Assert.That(JS.eval("3.itemsOf(arg.reverse().padRight(8, '_'))", scope), Is.EqualTo(new List <object> {
"eulav___", "eulav___", "eulav___"
}));
}
public void Can_customize_and_evaluate_custom_AST_expressions()
{
JsToken expr;
var expected = new JsLogicalExpression(
new JsBinaryExpression(new JsIdentifier("a"), JsGreaterThan.Operator, new JsLiteral(1)),
JsAnd.Operator,
new JsBinaryExpression(new JsIdentifier("b"), JsLessThan.Operator, new JsLiteral(2))
);
expr = JS.expression("a > 1 && b < 2");
Assert.That(expr, Is.EqualTo(expected));
Assert.That(expr.Equals(expected));
Assert.That(new JsLogicalExpression(
JS.expression("a > 1"),
JsAnd.Operator,
JS.expression("b < 2")),
Is.EqualTo(expected));
Assert.That((bool)expr.Evaluate(JS.CreateScope(args: new Dictionary <string, object> {
["a"] = 2,
["b"] = 1
})));
Assert.That((bool)expr.Evaluate(JS.CreateScope(args: new Dictionary <string, object> {
["a"] = 1,
["b"] = 2
})), Is.False);
}
public void Can_Invoke_Arrow_Expressions()
{
var context = new TemplateContext().Init();
"(a,b) => pow(a,2) + pow(b,2)".ParseJsExpression(out var token);
var arrowExpr = (JsArrowFunctionExpression)token;
Assert.That(arrowExpr.Invoke(2, 4), Is.EqualTo(20));
Assert.That(arrowExpr.Invoke(JS.CreateScope(functions: new MyFilter()), 2, 4), Is.EqualTo(3));
}
/// <summary> /// Invokes the specified parameters. /// </summary> /// <param name="params">The parameters.</param> /// <returns>System.Object.</returns> public object Invoke(params object[] @params) => Invoke(JS.CreateScope(), @params);
/// <summary>
/// Parses the specified json.
/// </summary>
/// <param name="json">The json.</param>
/// <returns>System.Object.</returns>
public static object parse(string json)
{
json.AsSpan().ParseJsToken(out var token);
return(token?.Evaluate(JS.CreateScope()));
}