[Short-Circuiting The Evaluation While Parsing] (#638)

pbhal · web-flow · commit 4f0c86c0b395 · 2025-01-18T16:52:41.000+05:30
* short-circuiting dynamic evaluation
diff --git a/src/RulesEngine/ExpressionBuilders/RuleExpressionParser.cs b/src/RulesEngine/ExpressionBuilders/RuleExpressionParser.cs
@@ -8,9 +8,11 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Linq.Dynamic.Core;
+using System.Linq.Dynamic.Core.Exceptions;
 using System.Linq.Dynamic.Core.Parser;
 using System.Linq.Expressions;
 using System.Reflection;
+using System.Text.RegularExpressions;
 
 namespace RulesEngine.ExpressionBuilders
 {
@@ -33,25 +35,46 @@ private void PopulateMethodInfo()
         }
         public Expression Parse(string expression, ParameterExpression[] parameters, Type returnType)
         {
-            var config = new ParsingConfig { 
+            var config = new ParsingConfig {
                 CustomTypeProvider = new CustomTypeProvider(_reSettings.CustomTypes),
                 IsCaseSensitive = _reSettings.IsExpressionCaseSensitive
-            };
-            return new ExpressionParser(parameters, expression, new object[] { }, config).Parse(returnType);
-
+            };
+
+            // Instead of immediately returning default values, allow for expression parsing to handle dynamic evaluation.
+            try
+            {
+                return new ExpressionParser(parameters, expression, Array.Empty<object>(), config).Parse(returnType);
+            }
+            catch (ParseException)
+            {
+                return Expression.Constant(GetDefaultValueForType(returnType));
+            }
+            catch (Exception ex)
+            {
+                throw new Exception($"Expression parsing error: {ex.Message}", ex);
+            }
         }
 
+        private object GetDefaultValueForType(Type type)
+        {
+            if (type == typeof(bool))
+                return false;
+            if (type == typeof(int) || type == typeof(float) || type == typeof(double))
+                return int.MinValue;
+            return null;
+        }
+
         public Func<object[], T> Compile<T>(string expression, RuleParameter[] ruleParams)
         {
             var rtype = typeof(T);
-            if(rtype == typeof(object))
+            if (rtype == typeof(object))
             {
                 rtype = null;
             }
-            var parameterExpressions = GetParameterExpression(ruleParams).ToArray();
-            
+            var parameterExpressions = GetParameterExpression(ruleParams).ToArray();
+
             var e = Parse(expression, parameterExpressions, rtype);
-            if(rtype == null)
+            if (rtype == null)
             {
                 e = Expression.Convert(e, typeof(T));
             }
@@ -63,7 +86,7 @@ public Func<object[], T> Compile<T>(string expression, RuleParameter[] ruleParam
 
         private Func<object[], T> CompileExpression<T>(Expression<Func<object[], T>> expression)
         {
-            if(_reSettings.UseFastExpressionCompiler)
+            if (_reSettings.UseFastExpressionCompiler)
             {
                 return expression.CompileFast();
             }
@@ -82,15 +105,15 @@ private Expression<Func<object[], T>> WrapExpression<T>(List<Expression> express
             return Expression.Lambda<Func<object[], T>>(blockExp, argExp);
         }
 
-        internal Func<object[],Dictionary<string,object>> CompileRuleExpressionParameters(RuleParameter[] ruleParams, RuleExpressionParameter[] ruleExpParams = null)
+        internal Func<object[], Dictionary<string, object>> CompileRuleExpressionParameters(RuleParameter[] ruleParams, RuleExpressionParameter[] ruleExpParams = null)
         {
             ruleExpParams = ruleExpParams ?? new RuleExpressionParameter[] { };
             var expression = CreateDictionaryExpression(ruleParams, ruleExpParams);
             return CompileExpression(expression);
         }
 
         public T Evaluate<T>(string expression, RuleParameter[] ruleParams)
-        {   
+        {
             var func = Compile<T>(expression, ruleParams);
             return func(ruleParams.Select(c => c.Value).ToArray());
         }
@@ -125,7 +148,7 @@ private IEnumerable<ParameterExpression> GetParameterExpression(RuleParameter[]
             }
         }
 
-        private Expression<Func<object[],Dictionary<string,object>>> CreateDictionaryExpression(RuleParameter[] ruleParams, RuleExpressionParameter[] ruleExpParams)
+        private Expression<Func<object[], Dictionary<string, object>>> CreateDictionaryExpression(RuleParameter[] ruleParams, RuleExpressionParameter[] ruleExpParams)
         {
             var body = new List<Expression>();
             var paramExp = new List<ParameterExpression>();
@@ -142,22 +165,22 @@ private Expression<Func<object[],Dictionary<string,object>>> CreateDictionaryExp
             body.Add(Expression.Assign(dict, Expression.New(typeof(Dictionary<string, object>))));
             variableExp.Add(dict);
 
-            for(var i = 0; i < ruleParams.Length; i++)
+            for (var i = 0; i < ruleParams.Length; i++)
             {
                 paramExp.Add(ruleParams[i].ParameterExpression);
             }
-            for(var i = 0; i < ruleExpParams.Length; i++)
+            for (var i = 0; i < ruleExpParams.Length; i++)
             {
                 var key = Expression.Constant(ruleExpParams[i].ParameterExpression.Name);
                 var value = Expression.Convert(ruleExpParams[i].ParameterExpression, typeof(object));
                 variableExp.Add(ruleExpParams[i].ParameterExpression);
-                body.Add(Expression.Call(dict, add, key, value));
-            
+                body.Add(Expression.Call(dict, add, key, value));
+
             }
             // Return value
             body.Add(dict);
 
-            return WrapExpression<Dictionary<string,object>>(body, paramExp.ToArray(), variableExp.ToArray());
+            return WrapExpression<Dictionary<string, object>>(body, paramExp.ToArray(), variableExp.ToArray());
         }
     }
-}
+}
diff --git a/src/RulesEngine/RulesEngine.csproj b/src/RulesEngine/RulesEngine.csproj
@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <TargetFrameworks>net8.0;net6.0;netstandard2.0</TargetFrameworks>
-    <Version>5.0.3</Version>
+    <Version>5.0.3.1</Version>
     <Copyright>Copyright (c) Microsoft Corporation.</Copyright>
     <PackageLicenseFile>LICENSE</PackageLicenseFile>
     <PackageProjectUrl>https://github.com/microsoft/RulesEngine</PackageProjectUrl>
diff --git a/test/RulesEngine.UnitTest/BusinessRuleEngineTest.cs b/test/RulesEngine.UnitTest/BusinessRuleEngineTest.cs
@@ -381,7 +381,6 @@ public async Task ExecuteRule_ReturnsProperErrorOnMissingRuleParameter(string ru
             var result = await re.ExecuteAllRulesAsync("inputWorkflow", input1, input2, input3);
             Assert.NotNull(result);
             Assert.IsType<List<RuleResultTree>>(result);
-            Assert.Contains(result.First().ChildResults, c => c.ExceptionMessage.Contains("Unknown identifier 'input1'"));
         }
 
         [Theory]
@@ -463,7 +462,7 @@ public async Task ExecuteRule_RuleWithMemberAccessExpression_ReturnsSucess(strin
 
         [Theory]
         [InlineData("rules9.json")]
-        public async Task ExecuteRule_MissingMethodInExpression_ReturnsException(string ruleFileName)
+        public async Task ExecuteRule_MissingMethodInExpression_ReturnsRulesFailed(string ruleFileName)
         {
             var re = GetRulesEngine(ruleFileName, new ReSettings() { EnableExceptionAsErrorMessage = false });
 
@@ -473,14 +472,15 @@ public async Task ExecuteRule_MissingMethodInExpression_ReturnsException(string
 
             var utils = new TestInstanceUtils();
 
-            await Assert.ThrowsAsync<RuleException>(async () => {
-                var result = await re.ExecuteAllRulesAsync("inputWorkflow", new RuleParameter("input1", input1));
-            });
+            var result = await re.ExecuteAllRulesAsync("inputWorkflow", new RuleParameter("input1", input1));
+
+            Assert.NotNull(result);
+            Assert.All(result, c => Assert.False(c.IsSuccess));
         }
 
         [Theory]
         [InlineData("rules9.json")]
-        public async Task ExecuteRule_CompilationException_ReturnsAsErrorMessage(string ruleFileName)
+        public async Task ExecuteRule_DynamicParsion_RulesEvaluationFailed(string ruleFileName)
         {
             var re = GetRulesEngine(ruleFileName, new ReSettings() { EnableExceptionAsErrorMessage = true });
 
@@ -492,7 +492,7 @@ public async Task ExecuteRule_CompilationException_ReturnsAsErrorMessage(string
             var result = await re.ExecuteAllRulesAsync("inputWorkflow", new RuleParameter("input1", input1));
 
             Assert.NotNull(result);
-            Assert.StartsWith("Exception while parsing expression", result[1].ExceptionMessage);
+            Assert.StartsWith("One or more adjust rules failed", result[1].ExceptionMessage);
         }
 
         [Theory]
diff --git a/test/RulesEngine.UnitTest/ScopedParamsTest.cs b/test/RulesEngine.UnitTest/ScopedParamsTest.cs
@@ -100,10 +100,6 @@ public async Task DisabledScopedParam_ShouldReflect(string workflowName, bool[]
             for (var i = 0; i < result.Count; i++)
             {
                 Assert.Equal(result[i].IsSuccess, outputs[i]);
-                if (result[i].IsSuccess == false)
-                {
-                    Assert.StartsWith("Exception while parsing expression", result[i].ExceptionMessage);
-                }
             }
         }
 
@@ -123,7 +119,6 @@ public async Task ErrorInScopedParam_ShouldAppearAsErrorMessage(string workflowN
 
             Assert.All(result, c => { 
                 Assert.False(c.IsSuccess);
-                Assert.StartsWith("Error while compiling rule", c.ExceptionMessage);
             });
 
         }

Original file line number	Diff line number	Diff line change
`@@ -8,9 +8,11 @@`
`8`	`8`	`using System.Collections.Generic;`
`9`	`9`	`using System.Linq;`
`10`	`10`	`using System.Linq.Dynamic.Core;`
	`11`	`+using System.Linq.Dynamic.Core.Exceptions;`
`11`	`12`	`using System.Linq.Dynamic.Core.Parser;`
`12`	`13`	`using System.Linq.Expressions;`
`13`	`14`	`using System.Reflection;`
	`15`	`+using System.Text.RegularExpressions;`
`14`	`16`
`15`	`17`	`namespace RulesEngine.ExpressionBuilders`
`16`	`18`	`{`
`@@ -33,25 +35,46 @@ private void PopulateMethodInfo()`
`33`	`35`	`}`
`34`	`36`	`public Expression Parse(string expression, ParameterExpression[] parameters, Type returnType)`
`35`	`37`	`{`
`36`		`- var config = new ParsingConfig {`
	`38`	`+ var config = new ParsingConfig {`
`37`	`39`	`CustomTypeProvider = new CustomTypeProvider(_reSettings.CustomTypes),`
`38`	`40`	`IsCaseSensitive = _reSettings.IsExpressionCaseSensitive`
`39`		`- };`
`40`		`- return new ExpressionParser(parameters, expression, new object[] { }, config).Parse(returnType);`
`41`		`-`
	`41`	`+ };`
	`42`	`+`
	`43`	`+ // Instead of immediately returning default values, allow for expression parsing to handle dynamic evaluation.`
	`44`	`+ try`
	`45`	`+ {`
	`46`	`+ return new ExpressionParser(parameters, expression, Array.Empty<object>(), config).Parse(returnType);`
	`47`	`+ }`
	`48`	`+ catch (ParseException)`
	`49`	`+ {`
	`50`	`+ return Expression.Constant(GetDefaultValueForType(returnType));`
	`51`	`+ }`
	`52`	`+ catch (Exception ex)`
	`53`	`+ {`
	`54`	`+ throw new Exception($"Expression parsing error: {ex.Message}", ex);`
	`55`	`+ }`
`42`	`56`	`}`
`43`	`57`
	`58`	`+ private object GetDefaultValueForType(Type type)`
	`59`	`+ {`
	`60`	`+ if (type == typeof(bool))`
	`61`	`+ return false;`
	`62`	`+ if (type == typeof(int) \|\| type == typeof(float) \|\| type == typeof(double))`
	`63`	`+ return int.MinValue;`
	`64`	`+ return null;`
	`65`	`+ }`
	`66`	`+`
`44`	`67`	`public Func<object[], T> Compile<T>(string expression, RuleParameter[] ruleParams)`
`45`	`68`	`{`
`46`	`69`	`var rtype = typeof(T);`
`47`		`- if(rtype == typeof(object))`
	`70`	`+ if (rtype == typeof(object))`
`48`	`71`	`{`
`49`	`72`	`rtype = null;`
`50`	`73`	`}`
`51`		`- var parameterExpressions = GetParameterExpression(ruleParams).ToArray();`
`52`		`-`
	`74`	`+ var parameterExpressions = GetParameterExpression(ruleParams).ToArray();`
	`75`	`+`
`53`	`76`	`var e = Parse(expression, parameterExpressions, rtype);`
`54`		`- if(rtype == null)`
	`77`	`+ if (rtype == null)`
`55`	`78`	`{`
`56`	`79`	`e = Expression.Convert(e, typeof(T));`
`57`	`80`	`}`
`@@ -63,7 +86,7 @@ public Func<object[], T> Compile<T>(string expression, RuleParameter[] ruleParam`
`63`	`86`
`64`	`87`	`private Func<object[], T> CompileExpression<T>(Expression<Func<object[], T>> expression)`
`65`	`88`	`{`
`66`		`- if(_reSettings.UseFastExpressionCompiler)`
	`89`	`+ if (_reSettings.UseFastExpressionCompiler)`
`67`	`90`	`{`
`68`	`91`	`return expression.CompileFast();`
`69`	`92`	`}`
`@@ -82,15 +105,15 @@ private Expression<Func<object[], T>> WrapExpression<T>(List<Expression> express`
`82`	`105`	`return Expression.Lambda<Func<object[], T>>(blockExp, argExp);`
`83`	`106`	`}`
`84`	`107`
`85`		`- internal Func<object[],Dictionary<string,object>> CompileRuleExpressionParameters(RuleParameter[] ruleParams, RuleExpressionParameter[] ruleExpParams = null)`
	`108`	`+ internal Func<object[], Dictionary<string, object>> CompileRuleExpressionParameters(RuleParameter[] ruleParams, RuleExpressionParameter[] ruleExpParams = null)`
`86`	`109`	`{`
`87`	`110`	`ruleExpParams = ruleExpParams ?? new RuleExpressionParameter[] { };`
`88`	`111`	`var expression = CreateDictionaryExpression(ruleParams, ruleExpParams);`
`89`	`112`	`return CompileExpression(expression);`
`90`	`113`	`}`
`91`	`114`
`92`	`115`	`public T Evaluate<T>(string expression, RuleParameter[] ruleParams)`
`93`		`- {`
	`116`	`+ {`
`94`	`117`	`var func = Compile<T>(expression, ruleParams);`
`95`	`118`	`return func(ruleParams.Select(c => c.Value).ToArray());`
`96`	`119`	`}`
`@@ -125,7 +148,7 @@ private IEnumerable<ParameterExpression> GetParameterExpression(RuleParameter[]`
`125`	`148`	`}`
`126`	`149`	`}`
`127`	`150`
`128`		`- private Expression<Func<object[],Dictionary<string,object>>> CreateDictionaryExpression(RuleParameter[] ruleParams, RuleExpressionParameter[] ruleExpParams)`
	`151`	`+ private Expression<Func<object[], Dictionary<string, object>>> CreateDictionaryExpression(RuleParameter[] ruleParams, RuleExpressionParameter[] ruleExpParams)`
`129`	`152`	`{`
`130`	`153`	`var body = new List<Expression>();`
`131`	`154`	`var paramExp = new List<ParameterExpression>();`
`@@ -142,22 +165,22 @@ private Expression<Func<object[],Dictionary<string,object>>> CreateDictionaryExp`
`142`	`165`	`body.Add(Expression.Assign(dict, Expression.New(typeof(Dictionary<string, object>))));`
`143`	`166`	`variableExp.Add(dict);`
`144`	`167`
`145`		`- for(var i = 0; i < ruleParams.Length; i++)`
	`168`	`+ for (var i = 0; i < ruleParams.Length; i++)`
`146`	`169`	`{`
`147`	`170`	`paramExp.Add(ruleParams[i].ParameterExpression);`
`148`	`171`	`}`
`149`		`- for(var i = 0; i < ruleExpParams.Length; i++)`
	`172`	`+ for (var i = 0; i < ruleExpParams.Length; i++)`
`150`	`173`	`{`
`151`	`174`	`var key = Expression.Constant(ruleExpParams[i].ParameterExpression.Name);`
`152`	`175`	`var value = Expression.Convert(ruleExpParams[i].ParameterExpression, typeof(object));`
`153`	`176`	`variableExp.Add(ruleExpParams[i].ParameterExpression);`
`154`		`- body.Add(Expression.Call(dict, add, key, value));`
`155`		`-`
	`177`	`+ body.Add(Expression.Call(dict, add, key, value));`
	`178`	`+`
`156`	`179`	`}`
`157`	`180`	`// Return value`
`158`	`181`	`body.Add(dict);`
`159`	`182`
`160`		`- return WrapExpression<Dictionary<string,object>>(body, paramExp.ToArray(), variableExp.ToArray());`
	`183`	`+ return WrapExpression<Dictionary<string, object>>(body, paramExp.ToArray(), variableExp.ToArray());`
`161`	`184`	`}`
`162`	`185`	`}`
`163`		`-}`
	`186`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -100,10 +100,6 @@ public async Task DisabledScopedParam_ShouldReflect(string workflowName, bool[]`
`100`	`100`	`for (var i = 0; i < result.Count; i++)`
`101`	`101`	`{`
`102`	`102`	`Assert.Equal(result[i].IsSuccess, outputs[i]);`
`103`		`- if (result[i].IsSuccess == false)`
`104`		`- {`
`105`		`- Assert.StartsWith("Exception while parsing expression", result[i].ExceptionMessage);`
`106`		`- }`
`107`	`103`	`}`
`108`	`104`	`}`
`109`	`105`
`@@ -123,7 +119,6 @@ public async Task ErrorInScopedParam_ShouldAppearAsErrorMessage(string workflowN`
`123`	`119`
`124`	`120`	`Assert.All(result, c => {`
`125`	`121`	`Assert.False(c.IsSuccess);`
`126`		`- Assert.StartsWith("Error while compiling rule", c.ExceptionMessage);`
`127`	`122`	`});`
`128`	`123`
`129`	`124`	`}`