fix replace rule

Author: RomanSoloweow

src/SimpleStateMachine.StructuralSearch.Sandbox/Program.cs

@@ -13,8 +13,8 @@ internal static class Program
     {
         static void Main(string[] args)
         {
-            var tesds = ParametersParser.StringFormatParameter.ParseOrThrow("\"tfasdfa\\\"sd$var$.Lenght\"");
-            var replaceRule = StructuralSearch.ParseReplaceRule("$var$ equals $var$ => $var$");
+            //var tesds = ParametersParser.StringFormatParameter.ParseOrThrow("\"tfasdfa\\\"sd$var$.Lenght\"");
+            var replaceRule = StructuralSearch.ParseReplaceRule("$var$ equals $var$ => $var$.Trim");
 
             var rule = StructuralSearch.ParseFindRule("$var$ equals $var$.Lenght and Not StartsWith \"123\\\" $var$ \\\"\"");
             var rule2 = StructuralSearch.ParseFindRule("$var$ equals $var$.Offset.Start and Not StartsWith \"123\"");

src/SimpleStateMachine.StructuralSearch/Rule/ReplaceRule/ChangeParameter.cs

@@ -1,4 +1,5 @@
-using SimpleStateMachine.StructuralSearch.Rules;
+using System;
+using SimpleStateMachine.StructuralSearch.Rules;
 
 namespace SimpleStateMachine.StructuralSearch
 {
@@ -15,7 +16,21 @@ public ChangeParameter(IRuleParameter parameter, ChangeType type)
 
         public string GetValue()
         {
-            throw new System.NotImplementedException();
+            var value = Parameter.GetValue();
+            return Type switch
+            {
+                ChangeType.Trim => value.Trim(),
+                ChangeType.TrimEnd => value.TrimEnd(),
+                ChangeType.TrimStart => value.TrimStart(),
+                ChangeType.ToUpper => value.ToUpper(),
+                ChangeType.ToLower => value.ToLower(),
+                _ => throw new ArgumentOutOfRangeException()
+            };
         }
+        
+        public override string ToString()
+        {
+            return $"{Parameter}{Constant.Dote}{Type}";
+        } 
     }
 }

src/SimpleStateMachine.StructuralSearch/StructuralSearch/FindRulesParser.cs

@@ -16,25 +16,39 @@ internal static Parser<char, Func<IRule, IRule>> Unary(Parser<char, UnaryRuleTyp
             => op.Select<Func<IRule, IRule>>(type => param => new UnaryRule(type, param));
 
         internal static readonly Parser<char, Func<IRule, IRule, IRule>> And
-            = Binary(Parsers.EnumValue(BinaryRuleType.And, true).TrimStart());
+            = Binary(Parsers.EnumValue(BinaryRuleType.And, true)
+                .TrimStart()
+                .Try());
 
         internal static readonly Parser<char, Func<IRule, IRule, IRule>> Or
-            = Binary(Parsers.EnumValue(BinaryRuleType.Or, true).TrimStart());
+            = Binary(Parsers.EnumValue(BinaryRuleType.Or, true)
+                .TrimStart()
+                .Try());
 
         internal static readonly Parser<char, Func<IRule, IRule, IRule>> NOR
-            = Binary(Parsers.EnumValue(BinaryRuleType.NOR, true).TrimStart());
+            = Binary(Parsers.EnumValue(BinaryRuleType.NOR, true)
+                .TrimStart()
+                .Try());
 
         internal static readonly Parser<char, Func<IRule, IRule, IRule>> XOR
-            = Binary(Parsers.EnumValue(BinaryRuleType.XOR, true).TrimStart());
+            = Binary(Parsers.EnumValue(BinaryRuleType.XOR, true)
+                .TrimStart()
+                .Try());
 
         internal static readonly Parser<char, Func<IRule, IRule, IRule>> NAND
-            = Binary(Parsers.EnumValue(BinaryRuleType.NAND, true).TrimStart());
+            = Binary(Parsers.EnumValue(BinaryRuleType.NAND, true)
+                .TrimStart()
+                .Try());
 
         internal static readonly Parser<char, Func<IRule, IRule, IRule>> XNOR
-            = Binary(Parsers.EnumValue(BinaryRuleType.XNOR, true).TrimStart());
+            = Binary(Parsers.EnumValue(BinaryRuleType.XNOR, true)
+                .TrimStart()
+                .Try());
 
         internal static readonly Parser<char, Func<IRule, IRule>> Not
-            = Unary(Parsers.EnumValue(UnaryRuleType.Not, true).TrimStart());
+            = Unary(Parsers.EnumValue(UnaryRuleType.Not, true)
+                .TrimStart()
+                .Try());
 
         public static readonly Parser<char, IRule> Expr = ExpressionParser.Build<char, IRule>(
             rule => (

src/SimpleStateMachine.StructuralSearch/StructuralSearch/ReplaceRuleParser.cs

@@ -16,8 +16,10 @@ public static class ReplaceRuleParser
 
         internal static readonly Parser<char, ReplaceRule> ReplaceRule =
             Parser.Map((rule, parameter) => new ReplaceRule(rule, parameter),
-                    FindRuleParser.Rule.Before(CommonTemplateParser.Should),
-                    Parser.OneOf(ChangeParameter, ParametersParser.Parameter));
+                    FindRuleParser.Rule.Before(CommonTemplateParser.Should.TrimStart()),
+                    Parser.OneOf(ChangeParameter.Try(), ParametersParser.Parameter.Try()))
+                .Try()
+                .TrimStart();
 
         internal static ReplaceRule ParseTemplate(string str)
         {