From b39591eac1f103cb418908393548f38fa09ccddf Mon Sep 17 00:00:00 2001
From: Abbas Cyclewala <abcy@microsoft.com>
Date: Fri, 11 Dec 2020 14:48:52 +0530
Subject: [PATCH] Added support for unlimited inputs (#76)

* Added support for unlimited inputs
---
 .../RulesEngineBenchmark.csproj                    |  1 +
 .../ExpressionBuilders/RuleExpressionParser.cs     | 14 ++++----
 src/RulesEngine/RulesEngine.csproj                 |  2 +-
 .../RulesEngine.UnitTest/BusinessRuleEngineTest.cs | 38 ++++++++++++++++++++++
 4 files changed, 48 insertions(+), 7 deletions(-)

diff --git a/benchmark/RulesEngineBenchmark/RulesEngineBenchmark.csproj b/benchmark/RulesEngineBenchmark/RulesEngineBenchmark.csproj
index fa35dcd..07c60a3 100644
--- a/benchmark/RulesEngineBenchmark/RulesEngineBenchmark.csproj
+++ b/benchmark/RulesEngineBenchmark/RulesEngineBenchmark.csproj
@@ -7,6 +7,7 @@
 
   <ItemGroup>
     <PackageReference Include="BenchmarkDotNet" Version="0.12.1" />
+	  <!--<PackageReference Include="RulesEngine" Version="3.0.0-preview.2" />-->
   </ItemGroup>
 
   <ItemGroup>
diff --git a/src/RulesEngine/ExpressionBuilders/RuleExpressionParser.cs b/src/RulesEngine/ExpressionBuilders/RuleExpressionParser.cs
index d089c75..04bf936 100644
--- a/src/RulesEngine/ExpressionBuilders/RuleExpressionParser.cs
+++ b/src/RulesEngine/ExpressionBuilders/RuleExpressionParser.cs
@@ -36,16 +36,18 @@ namespace RulesEngine.ExpressionBuilders
             
         }
 
-        private Expression<Func<object[],T>> WrapExpression<T>(Expression expression, ParameterExpression[] parameters){
+        private Expression<Func<object[],T>> WrapExpression<T>(LambdaExpression expression, ParameterExpression[] parameters){
             var argExp = Expression.Parameter(typeof(object[]),"args");
-            var paramExps = parameters.Select((c,i) => {
-                var arg = Expression.ArrayAccess(argExp,Expression.Constant(i));
-                return Expression.Convert(arg,c.Type);
+            IEnumerable<Expression> paramExps = parameters.Select((c, i) => {
+                var arg = Expression.ArrayAccess(argExp, Expression.Constant(i));
+                return (Expression)Expression.Assign(c, Expression.Convert(arg, c.Type));
             });
-            var invokeExp = Expression.Invoke(expression,paramExps);
-            return Expression.Lambda<Func<object[],T>>(invokeExp, argExp);
+            var blockExpSteps = paramExps.Concat(new List<Expression> { expression.Body });
+            var blockExp = Expression.Block(parameters, blockExpSteps);
+            return Expression.Lambda<Func<object[],T>>(blockExp, argExp);
         }
 
+
         public T Evaluate<T>(string expression, RuleParameter[] ruleParams)
         {
             var func = Compile<T>(expression, ruleParams);
diff --git a/src/RulesEngine/RulesEngine.csproj b/src/RulesEngine/RulesEngine.csproj
index 9e7e0e7..43bfe8b 100644
--- a/src/RulesEngine/RulesEngine.csproj
+++ b/src/RulesEngine/RulesEngine.csproj
@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <TargetFramework>netstandard2.0</TargetFramework>
-    <Version>3.0.0-preview.2</Version>
+    <Version>3.0.0-preview.3</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
index 75b0b89..481900a 100644
--- a/test/RulesEngine.UnitTest/BusinessRuleEngineTest.cs
+++ b/test/RulesEngine.UnitTest/BusinessRuleEngineTest.cs
@@ -62,6 +62,44 @@ namespace RulesEngine.UnitTest
             Assert.Contains(result,c => c.IsSuccess);
         }
 
+        [Theory]
+        [InlineData("rules2.json")]
+        public async Task ExecuteRule_ManyInputs_ReturnsListOfRuleResultTree(string ruleFileName)
+        {
+            var re = GetRulesEngine(ruleFileName);
+
+            dynamic input1 = GetInput1();
+            dynamic input2 = GetInput2();
+            dynamic input3 = GetInput3();
+
+            dynamic input4 = GetInput1();
+            dynamic input5 = GetInput2();
+            dynamic input6 = GetInput3();
+
+            dynamic input7 = GetInput1();
+            dynamic input8 = GetInput2();
+            dynamic input9 = GetInput3();
+            
+            dynamic input10 = GetInput1();
+            dynamic input11 = GetInput2();
+            dynamic input12 = GetInput3();
+
+            dynamic input13 = GetInput1();
+            dynamic input14 = GetInput2();
+            dynamic input15 = GetInput3();
+
+
+            dynamic input16 = GetInput1();
+            dynamic input17 = GetInput2();
+            dynamic input18 = GetInput3();
+
+            List<RuleResultTree> result = await re.ExecuteAllRulesAsync("inputWorkflow", input1, input2, input3,input4, input5, input6, input7, input8, input9, input10, input11, input12, input13, input14, input15, input16, input17, input18);
+            Assert.NotNull(result);
+            Assert.IsType<List<RuleResultTree>>(result);
+            Assert.Contains(result, c => c.IsSuccess);
+        }
+
+
         [Theory]
         [InlineData("rules2.json")]
         public async Task ExecuteRule_CalledMultipleTimes_ReturnsSameResult(string ruleFileName)