refact, some fix and placeholder parameter in rule

Author: RomanSoloweow

src/SimpleStateMachine.StructuralSearch.Sandbox/Program.cs

@@ -1,34 +1,29 @@
 using System.Text.RegularExpressions;
 using Pidgin;
+using SimpleStateMachine.StructuralSearch.Extensions;
+using SimpleStateMachine.StructuralSearch.Rules;
 using static Pidgin.Parser;
+using String = System.String;
 
 namespace SimpleStateMachine.StructuralSearch.Sandbox
 {
     internal static class Program
     {
         static void Main(string[] args)
         {
-            
-            
-            
-            var rule = StructuralSearch.ParseFindRule("$var$ Not (Is int or equals \"test\") and match \"^[0-9]+.[0-9]+$\"");
+            var tr = SubRuleParser.UnarySubRule.ParseOrThrow("equals $var$.Lenght");
+            var rule = StructuralSearch.ParseFindRule("$var$ equals $var$ .Lenght");
             var result1 = rule.Execute("test");
-            var result2 = rule.Execute("125");
+            var result2 = rule.Execute("10");
             var result3 = rule.Execute("5.3");
 
-            
-            
-            
             var t = ExprParser.ParseOrThrow("2 + 2 + 2");
             var resw = t.Invoke();
             var test = String("return ")
                 .Then(AnyCharExcept(';').ManyString())
                 .Then(Char(';').AtLeastOnceString())
                 .Before(Char(';'));
 
-            
-            
-            
             // var template = StructuralSearch.ParseTemplate("");
             // var test = Parser.OneOf(String("Test"), CommonParser.Empty);
             var res = test.ParseOrThrow("return 125;;;;");

src/SimpleStateMachine.StructuralSearch/Constant.cs

@@ -77,6 +77,11 @@ public static partial class Constant
         /// </summary>
         public static readonly char DoubleQuotes = '\"';
 
+        /// <summary>
+        /// Char: '.'
+        /// </summary>
+        public static readonly char Dote = '.';
+        
         /// <summary>
         /// Parenthesis chars: '(' and ')'
         /// </summary>

src/SimpleStateMachine.StructuralSearch/Extensions/ParserExtensions.cs

@@ -11,8 +11,7 @@ public static Parser<TToken, T> Try<TToken, T>(this Parser<TToken, T> parser)
         {
             return Parser.Try(parser);
         }
-
-
+        
         public static Parser<TToken, IEnumerable<T>> AsMany<TToken, T>(this Parser<TToken, T> parser)
         {
             return parser.Select(x => (IEnumerable<T>)new List<T> { x });
@@ -26,7 +25,6 @@ public static Parser<TToken, IEnumerable<T>> AtLeastOnceUntilNot<TToken, T, U>(t
                 : throw new ArgumentNullException(nameof(parser));
         }
 
-        
         public static Parser<TToken, IEnumerable<T>> UntilNot<TToken, T, U>(this Parser<TToken, T> parser,
             Parser<TToken, U> terminator)
         {
@@ -39,10 +37,10 @@ public static bool TryParse(this Parser<char, string> parser, string value, out
         {
             if(parser is null)
                 throw new ArgumentNullException(nameof(parser));
-
-            var res = parser.Try().Optional().ParseOrThrow(value, null);
-            result = res.HasValue ? res.Value : default;
-            return res.HasValue;
+            
+            var res = parser.Parse(value);
+            result = res.Success ? res.Value : default;
+            return res.Success;
         }
         public static Parser<TToken, bool> Contains<TToken, T>(this Parser<TToken, T> parser)
         {
@@ -112,6 +110,11 @@ public static Parser<TToken, R> As<TToken, T, R>(this Parser<TToken, T> parser)
         {
             return parser.Select(x => (R)x);
         }
+        
+        public static Parser<TToken, T> After<TToken, T, U>(this Parser<TToken, T> parser, Parser<TToken, U> parserAfter)
+        {
+            return parserAfter.Then(parser, (u, t) => t);
+        }
 
         // public static Parser<TToken, T> BetweenAsThen<TToken, T, U, V>(this Parser<TToken, T> parser, Parser<TToken, U> parser1, Parser<TToken, V> parser2, Func<U, T, V, T> func)
         // {

src/SimpleStateMachine.StructuralSearch/Extensions/StringParserExtensions.cs

@@ -57,11 +57,21 @@ public static Parser<TToken, SourceMatch> AsMatch<TToken>(this Parser<TToken, st
             return parser.Then(Parser<TToken>.CurrentOffset, (s, offset) => new SourceMatch(s, offset - s.Length, offset));
         }
 
-        public static Parser<char, T> Trim<T>(this Parser<char, T> parser)
+        public static Parser<char, T> TrimEnd<T>(this Parser<char, T> parser)
         {
             return parser.Before(SkipWhitespaces);
         }
 
+        public static Parser<char, T> TrimStart<T>(this Parser<char, T> parser)
+        {
+            return parser.After(SkipWhitespaces);
+        }
+        
+        public static Parser<char, T> Trim<T>(this Parser<char, T> parser)
+        {
+            return parser.Between(SkipWhitespaces);
+        }
+        
         public static Parser<char, TEnum> AsEnum<TEnum>(this Parser<char, string> parser, bool ignoreCase)
             where TEnum: struct, Enum
         {

src/SimpleStateMachine.StructuralSearch/Parsers/Parsers.cs

@@ -17,6 +17,12 @@ public static Parser<char, string> String(string value, bool ignoreCase)
             return ignoreCase ? Parser.CIString(value): Parser.String(value);
         }
 
+        public static Parser<char, TEnum> After<TEnum>(TEnum value, bool ignoreCase = false)
+            where TEnum : struct, Enum
+        {
+            return Parsers.String(value.ToString(), ignoreCase).AsEnum<TEnum>(ignoreCase);
+        }
+
         // public static Parser<char, string> EnumValue<TEnum>(TEnum value, bool ignoreCase = false)
         //     where TEnum : struct, Enum
         // {

…ine.StructuralSearch/Rules/BinaryRule.cs …cturalSearch/Rule/FindRule/BinaryRule.cssrc/SimpleStateMachine.StructuralSearch/Rules/BinaryRule.cs renamed to src/SimpleStateMachine.StructuralSearch/Rule/FindRule/BinaryRule.cs src/SimpleStateMachine.StructuralSearch/Rules/BinaryRule.cs renamed to src/SimpleStateMachine.StructuralSearch/Rule/FindRule/BinaryRule.cs

@@ -2,7 +2,8 @@
 {
     public enum BinaryRuleType
     {
-        And = 0,
+        NotCorrect = 0,
+        And,
         Or,
         NAND,
         NOR,