UnarySubRule, fix rules parser

Author: RomanSoloweow

src/SimpleStateMachine.StructuralSearch.Sandbox/Program.cs

@@ -1,4 +1,5 @@
-using Pidgin;
+using System.Text.RegularExpressions;
+using Pidgin;
 using static Pidgin.Parser;
 
 namespace SimpleStateMachine.StructuralSearch.Sandbox
@@ -7,11 +8,18 @@ internal static class Program
     {
         static void Main(string[] args)
         {
-            var result = StructuralSearch.ParseFindRule("$var$ Is int or equals \"test\"");
-            var result1 = result.Execute("test");
 
 
-            var t = ExprParser.ParseOrThrow("( 2 + 2 ) * 2");
+            
+            var rule = StructuralSearch.ParseFindRule("$var$ Not (Is int or equals \"test\") and match \"^[0-9]+.[0-9]+$\"");
+            var result1 = rule.Execute("test");
+            var result2 = rule.Execute("125");
+            var result3 = rule.Execute("5.3");
+            
+            
+            
+            
+            var t = ExprParser.ParseOrThrow("2 + 2 + 2");
             var resw = t.Invoke();
             var test = String("return ")
                 .Then(AnyCharExcept(';').ManyString())

src/SimpleStateMachine.StructuralSearch/Rules/UnarySubRule.cs

@@ -1,4 +1,7 @@
-namespace SimpleStateMachine.StructuralSearch.Rules
+using System;
+using System.Text.RegularExpressions;
+
+namespace SimpleStateMachine.StructuralSearch.Rules
 {
     public class UnarySubRule : IRule
     {
@@ -14,7 +17,17 @@ public UnarySubRule(SubRuleType type, IRuleParameter parameter)
 
         public bool Execute(string value)
         {
-            throw new System.NotImplementedException();
+            var param = Parameter.GetValue();
+            
+            return Type switch
+            {
+                SubRuleType.Equals => value.Equals(param),
+                SubRuleType.Contains => value.Contains(param),
+                SubRuleType.StartsWith => value.StartsWith(param),
+                SubRuleType.EndsWith => value.EndsWith(param),
+                SubRuleType.Match => Regex.IsMatch(value, param),
+                _ => throw new ArgumentOutOfRangeException()
+            };
         }
     }
 }

src/SimpleStateMachine.StructuralSearch/StructuralSearch/RulesParser.cs

@@ -17,25 +17,25 @@ internal static Parser<char, Func<IRule, IRule>> Unary(Parser<char, UnaryRuleTyp
 
 
         internal static readonly Parser<char, Func<IRule, IRule, IRule>> And
-            = Binary(Parsers.EnumValue(BinaryRuleType.And).Trim());
+            = Binary(Parsers.EnumValue(BinaryRuleType.And, true).Trim());
 
         internal static readonly Parser<char, Func<IRule, IRule, IRule>> Or
-            = Binary(Parsers.EnumValue(BinaryRuleType.Or).Trim());
+            = Binary(Parsers.EnumValue(BinaryRuleType.Or, true).Trim());
 
         internal static readonly Parser<char, Func<IRule, IRule, IRule>> NOR
-            = Binary(Parsers.EnumValue(BinaryRuleType.NOR).Trim());
+            = Binary(Parsers.EnumValue(BinaryRuleType.NOR, true).Trim());
 
         internal static readonly Parser<char, Func<IRule, IRule, IRule>> XOR
-            = Binary(Parsers.EnumValue(BinaryRuleType.XOR).Trim());
+            = Binary(Parsers.EnumValue(BinaryRuleType.XOR, true).Trim());
 
         internal static readonly Parser<char, Func<IRule, IRule, IRule>> NAND
-            = Binary(Parsers.EnumValue(BinaryRuleType.NAND).Trim());
+            = Binary(Parsers.EnumValue(BinaryRuleType.NAND, true).Trim());
 
         internal static readonly Parser<char, Func<IRule, IRule, IRule>> XNOR
-            = Binary(Parsers.EnumValue(BinaryRuleType.XNOR).Trim());
+            = Binary(Parsers.EnumValue(BinaryRuleType.XNOR, true).Trim());
 
         internal static readonly Parser<char, Func<IRule, IRule>> Not
-            = Unary(Parsers.EnumValue(UnaryRuleType.Not).Trim());
+            = Unary(Parsers.EnumValue(UnaryRuleType.Not, true).Trim());
 
         internal static readonly Parser<char, IRule> Expr = ExpressionParser.Build<char, IRule>(
             rule => (