fix enum parser, try parse for string, isRule implementation

Author: RomanSoloweow

src/SimpleStateMachine.StructuralSearch.Sandbox/Program.cs

@@ -10,7 +10,9 @@ internal static class Program
     {
         static void Main(string[] args)
         {
-            var result = FindRuleParser.ParseTemplate("$var$ Equals \"125\"");
+            var result = FindRuleParser.ParseTemplate("$var$ Is int");
+            var result1 = result.Execute("125");
+            
 
             var t = ExprParser.ParseOrThrow("( 2 + 2 ) * 2");
             var resw = t.Invoke();

src/SimpleStateMachine.StructuralSearch/Extensions/ParserExtensions.cs

@@ -43,7 +43,22 @@ public static Parser<TToken, IEnumerable<T>> UntilNot<TToken, T, U>(this Parser<
                 ? parser.Until(Not(terminator))
                 : throw new ArgumentNullException(nameof(parser));
         }
+        
+        public static bool TryParse(this Parser<char, string> parser, string value, out string? result)
+        {
+            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;
+        }
+        public static Parser<TToken, bool> Contains<TToken, T>(this Parser<TToken, T> parser)
+        {
+            return parser != null
+                ? parser.Optional().Select(x => x.HasValue)
+                : throw new ArgumentNullException(nameof(parser));
+        }
 
         // public static Parser<TToken, TOut> WithResult<TToken, TOut>(this Parser<TToken, TOut> parser, Func<TToken, SourcePos, TOut> transformResult)
         // {

src/SimpleStateMachine.StructuralSearch/Extensions/StringParserExtensions.cs

@@ -63,10 +63,10 @@ public static Parser<char, T> Trim<T>(this Parser<char, T> parser)
             return parser.Before(SkipWhitespaces);
         }
 
-        public static Parser<char, TEnum> AsEnum<TEnum>(this Parser<char, string> parser)
+        public static Parser<char, TEnum> AsEnum<TEnum>(this Parser<char, string> parser, bool ignoreCase)
             where TEnum: struct, Enum
         {
-            return parser.Select(Enum.Parse<TEnum>);
+            return parser.Select(value => Enum.Parse<TEnum>(value, ignoreCase));
         }
     }
 }

src/SimpleStateMachine.StructuralSearch/Parsers/EnumParser.cs

@@ -16,7 +16,7 @@ public EnumParser(bool ignoreCase, params TEnum [] excluded)
             _parser = Parser.OneOf(EnumHelper.GetNamesExcept(excluded)
                 .Select(value => Parsers.String(value, ignoreCase))
                 .Select(Parser.Try))
-                .AsEnum<TEnum>();
+                .AsEnum<TEnum>(ignoreCase);
         }
 
         public override bool TryParse(ref ParseState<char> state, ref PooledList<Expected<char>> expecteds,

src/SimpleStateMachine.StructuralSearch/Parsers/Parsers.cs

@@ -16,14 +16,9 @@ public static Parser<char, string> Stringc(char character, bool ignoreCase = fal
 
         public static Parser<char, string> String(string value, bool ignoreCase)
         {
-            return ignoreCase ? Parser.String(value) : Parser.CIString(value);
+            return ignoreCase ? Parser.CIString(value): Parser.String(value);
         }
 
-        public static Parser<char, bool> Contains(string value, bool ignoreCase = false)
-        {
-            return String(value, ignoreCase).Optional().Select(x => x.HasValue);
-        }
-        
         // public static Parser<char, string> EnumValue<TEnum>(TEnum value, bool ignoreCase = false)
         //     where TEnum : struct, Enum
         // {
@@ -133,7 +128,7 @@ public static Parser<char, TEnum> EnumExcept<TEnum>(bool ignoreCase = false, par
         public static Parser<char, TEnum> EnumValue<TEnum>(TEnum value, bool ignoreCase = false)
             where TEnum : struct, Enum
         {
-            return Parsers.String(value.ToString(), ignoreCase).AsEnum<TEnum>();
+            return Parsers.String(value.ToString(), ignoreCase).AsEnum<TEnum>(ignoreCase);
         }
     }
 }

src/SimpleStateMachine.StructuralSearch/Rules/IsRule.cs

@@ -1,4 +1,8 @@
-namespace SimpleStateMachine.StructuralSearch.Rules
+using System;
+using Pidgin;
+using SimpleStateMachine.StructuralSearch.Extensions;
+
+namespace SimpleStateMachine.StructuralSearch.Rules
 {
     public class IsRule : IRule
     {
@@ -14,7 +18,15 @@ public IsRule(SubRuleType type, PlaceholderType placeholderType)
 
         public bool Execute(string value)
         {
-            throw new System.NotImplementedException();
+            return PlaceholderType switch
+            {
+                PlaceholderType.Var => CommonParser.Identifier.TryParse(value, out _),
+                PlaceholderType.Int => int.TryParse(value, out _),
+                PlaceholderType.Double => double.TryParse(value, out _),
+                PlaceholderType.DateTime => DateTime.TryParse(value, out _),
+                PlaceholderType.Guid => Guid.TryParse(value, out _),
+                _ => throw new ArgumentOutOfRangeException()
+            };
         }
     }
 }

src/SimpleStateMachine.StructuralSearch/StructuralSearch/RulesParser.cs

@@ -66,13 +66,15 @@ static FindRuleParser()
 
         public static readonly Parser<char, IRule> IsSubRule =
             Parser.Map((type, param) => new IsRule(type, param),
-                    Parsers.EnumValue(Rules.SubRuleType.Is), PlaceholderType)
+                    Parsers.EnumValue(Rules.SubRuleType.Is, true)
+                        .Trim(), 
+                    PlaceholderType)
                 .As<char, IsRule, IRule>()
                 .Try();
 
         public static readonly Parser<char, IRule> InSubRule =
             Parser.Map((type, param) => new InRule(type, param),
-                    Parsers.EnumValue(Rules.SubRuleType.In), Parameters)
+                    Parsers.EnumValue(Rules.SubRuleType.In, true), Parameters)
                 .As<char, InRule, IRule>()
                 .Try();