new find rules

Author: RomanSoloweow

src/SimpleStateMachine.StructuralSearch.Tests/FindRuleParserTests.cs

@@ -10,36 +10,41 @@ namespace SimpleStateMachine.StructuralSearch.Tests
     public class FindRuleParserTests
     {
         [Theory]
-        [InlineData("equals $var$")]
-        [InlineData("equals \"\\$\"")]
-        [InlineData("Not equals $var$.Lenght")]
-        [InlineData("Not equals $var$.offset.Start")]
-        [InlineData("equals $var$.Lenght and Not StartsWith \"123\"")]
-        [InlineData("equals $var$.Lenght and Not StartsWith \"\\\"Test\"")]
-        [InlineData("Contains $var$.Lenght")]
-        [InlineData("Contains \"123\"")]
-        [InlineData("StartsWith $var$.Lenght")]
-        [InlineData("StartsWith \"123\"")]
-        [InlineData("EndsWith $var$.Lenght")]
-        [InlineData("EndsWith \"123\"")]
-        [InlineData("Match $var$.Lenght")]
-        [InlineData("Is Int")]
-        [InlineData("Is DateTime")]
+        [InlineData("$var$ equals $var$")]
+        [InlineData("$var$ equals \"\\$\"")]
+        [InlineData("Not $var$ equals $var$.Lenght")]
+        [InlineData("Not $var$ equals $var$.offset.Start")]
+        [InlineData("$var$ equals $var$.Lenght and Not $var$ StartsWith \"123\"")]
+        [InlineData("Not $var$ equals $var$.Lenght and $var$ StartsWith \"123\"")]
+        [InlineData("$var$ equals $var$.Lenght and Not $var$ StartsWith \"\\\"Test\"")]
+        [InlineData("$var$ Contains $var$.Lenght")]
+        [InlineData("$var1$.Lenght Contains $var2$.Lenght")]
+        [InlineData("$var$ Contains \"123\"")]
+        [InlineData("$var$ StartsWith $var$.Lenght")]
+        [InlineData("$var$.Lenght Equals $var$.Lenght")]
+        [InlineData("$var$ StartsWith \"123\"")]
+        [InlineData("$var$ EndsWith $var$.Lenght")]
+        [InlineData("$var$ EndsWith \"123\"")]
+        [InlineData("$var$ Match $var$.Lenght")]
+        [InlineData("$var$ Is Int")]
+        [InlineData("$var$ Is DateTime")]
 
         public void FindRuleExprParsingShouldBeSuccess(string ruleStr)
         {
-            var rule = RuleParser.Expr.ParseOrThrow(ruleStr);
+            var rule = FindRuleParser.Expr.ParseOrThrow(ruleStr);
             var _ruleStr = rule.ToString()?.ToLower();
             Assert.NotNull(rule);
             Assert.Equal(_ruleStr, ruleStr.ToLower());
         }
 
         [Theory]
-        [InlineData("In \"Is\", \"==\", \"!=\", \"is not\"", "In \"Is\",\"==\",\"!=\",\"is not\"")]
-        [InlineData("In (\"Is\", \"==\", \"!=\", \"is not\")", "In \"Is\",\"==\",\"!=\",\"is not\"")]
+        [InlineData("$var$ In \"Is\", \"==\", \"!=\", \"is not\"", "$var$ In \"Is\",\"==\",\"!=\",\"is not\"")]
+        [InlineData("$var$ In (\"Is\", \"==\", \"!=\", \"is not\")", "$var$ In \"Is\",\"==\",\"!=\",\"is not\"")]
+        [InlineData("Not ($var$ equals $var$.Lenght and $var$ StartsWith \"123\")", "Not $var$ equals $var$.Lenght and $var$ StartsWith \"123\"")]
+        [InlineData("Not ($var$ equals $var$.Lenght)", "Not $var$ equals $var$.Lenght")]
         public void FindRuleExprParsingShouldBeEqualsCustomResult(string ruleStr, string customResult)
         {
-            var rule = RuleParser.Expr.ParseOrThrow(ruleStr);
+            var rule = FindRuleParser.Expr.ParseOrThrow(ruleStr);
             var _ruleStr = rule.ToString()?.ToLower();
             Assert.NotNull(rule);
             Assert.Equal(_ruleStr, customResult.ToLower());

src/SimpleStateMachine.StructuralSearch/Rules/FindRule/BinaryRule.cs

@@ -17,10 +17,10 @@ public BinaryRule(BinaryRuleType type, IRule left, IRule right)
             Right = right;
         }
 
-        public bool Execute(string value)
+        public bool Execute()
         {
-            var left = Left.Execute(value);
-            var right = Right.Execute(value);
+            var left = Left.Execute();
+            var right = Right.Execute();
 
             return LogicalHelper.Calculate(Type, left, right);
         }

src/SimpleStateMachine.StructuralSearch/Rules/FindRule/ILogicalRule.cs

@@ -2,6 +2,6 @@
 {
     public interface IRule
     {
-        bool Execute(string value);
+        bool Execute();
     }
 }

src/SimpleStateMachine.StructuralSearch/Rules/FindRule/IRule.cs

@@ -0,0 +1,30 @@
+using System.Collections.Generic;
+using System.Linq;
+
+namespace SimpleStateMachine.StructuralSearch.Rules
+{
+    public class InSubRule : IRule
+    {
+        public IRuleParameter Parameter { get; }
+        
+        public IEnumerable<IRuleParameter> Arguments { get; }
+        
+        public InSubRule(IRuleParameter parameter, IEnumerable<IRuleParameter> arguments)
+        {
+            Parameter = parameter;
+            
+            Arguments = arguments;
+        }
+
+        public bool Execute()
+        {
+            var value = Parameter.GetValue();
+            return Arguments.Any(parameter => Equals(value, parameter.GetValue()));
+        }
+        
+        public override string ToString()
+        {
+            return $"{Parameter}{Constant.Space}{SubRuleType.In}{Constant.Space}{string.Join(Constant.Comma, Arguments.Select(x=>x.ToString()))}";
+        }  
+    }
+}

src/SimpleStateMachine.StructuralSearch/Rules/FindRule/InRule.cs

@@ -3,21 +3,23 @@
 
 namespace SimpleStateMachine.StructuralSearch.Rules
 {
-    public class IsRule : IRule
+    public class IsSubRule : IRule
     {
-        public SubRuleType Type { get; }
+        public PlaceholderType Argument { get; }
 
-        public PlaceholderType PlaceholderType { get; }
+        public IRuleParameter Parameter { get; }
 
-        public IsRule(SubRuleType type, PlaceholderType placeholderType)
+        public IsSubRule(IRuleParameter parameter, PlaceholderType argument)
         {
-            Type = type;
-            PlaceholderType = placeholderType;
+            Parameter = parameter;
+            Argument = argument;
         }
 
-        public bool Execute(string value)
+        public bool Execute()
         {
-            return PlaceholderType switch
+            var value = Parameter.GetValue();
+            
+            return Argument switch
             {
                 PlaceholderType.Var => CommonParser.Identifier.TryParse(value, out _),
                 PlaceholderType.Int => int.TryParse(value, out _),
@@ -30,7 +32,7 @@ public bool Execute(string value)
 
         public override string ToString()
         {
-            return $"{Type}{Constant.Space}{PlaceholderType}";
+            return $"{Parameter}{Constant.Space}{SubRuleType.Is}{Constant.Space}{Argument}";
         }  
     }
 }