Replace rule tests, Placeholder parameter in FindRule

Author: RomanSoloweow

src/SimpleStateMachine.StructuralSearch.Tests/RuleParserTests.cs renamed to src/SimpleStateMachine.StructuralSearch.Tests/FindRuleParserTests.cs

@@ -4,7 +4,7 @@
 
 namespace SimpleStateMachine.StructuralSearch.Tests
 {
-    public class RuleParserTests
+    public class FindRuleParserTests
     {
         [Theory]
         [InlineData("equals $var$")]

src/SimpleStateMachine.StructuralSearch.Tests/ReplaceRuleParserTests.cs

@@ -0,0 +1,25 @@
+using System.Linq;
+using Pidgin;
+using Xunit;
+
+namespace SimpleStateMachine.StructuralSearch.Tests
+{
+    public class ReplaceRuleParserTests
+    {
+        [Theory]
+        [InlineData("equals $var$", "$var$")]
+        [InlineData("Not equals $var$.Lenght", "$var$.Lenght")]
+        [InlineData("Not equals $var$.offset.Start", "$var$.offset.Start")]
+        [InlineData("equals $var$.Lenght and Not StartsWith \"123\"", "$var$.offset.Start.Trim")]
+        [InlineData("equals $var$.Lenght and Not StartsWith \"\\\"Test\"", "$var$.offset.Start.ToUpper")]
+        public void FindRuleParsingShouldBeSuccess(string findRule, string replaceRule)
+        {
+            string placeholder = "$var$";
+            string replaceRuleStr = $"{placeholder} {findRule} => {replaceRule}";
+            var rule = StructuralSearch.ParseReplaceRule(replaceRuleStr);
+            var _ruleStr = rule.ToString()?.ToLower();
+            Assert.NotNull(rule);
+            Assert.Equal(_ruleStr, replaceRuleStr.ToLower());
+        }
+    }
+}

src/SimpleStateMachine.StructuralSearch/Constant.cs

@@ -97,6 +97,11 @@ public static partial class Constant
         /// </summary>
         public static readonly char More = '>';
 
+        /// <summary>
+        /// String: "=>"
+        /// </summary>
+        public static readonly string Should = $"{Equals}{More}";
+        
         /// <summary>
         /// Parenthesis chars: '(' and ')'
         /// </summary>

src/SimpleStateMachine.StructuralSearch/Rule/FindRule/FindRule.cs

@@ -2,11 +2,11 @@
 {
     public class FindRule
     {
-        public string Placeholder { get; }
+        public IRuleParameter Placeholder { get; }
 
         private IRule _rule { get; }
 
-        public FindRule(string placeholder, IRule rule)
+        public FindRule(IRuleParameter placeholder, IRule rule)
         {
             Placeholder = placeholder;
             _rule = rule;

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

@@ -18,7 +18,7 @@ public ReplaceRule(FindRule findRule, IRuleParameter parameter)
 
         public override string ToString()
         {
-            return $"{FindRule}{Constant.Space}{Parameter}";
+            return $"{FindRule}{Constant.Space}{Constant.Should}{Constant.Space}{Parameter}";
         } 
     }
 }

src/SimpleStateMachine.StructuralSearch/StructuralSearch/CommonTemplateParser.cs

@@ -17,8 +17,7 @@ internal static readonly Parser<char, string> StringWithPlshd
             = AnyCharWithPlshd.AtLeastOnceString();
 
         internal static readonly Parser<char, string> Should
-            = Parsers.Stringc(Constant.Equals).Then(Parsers.Stringc(Constant.More), 
-                (c1, c2) => c1 + c2);
+            = String(Constant.Should);
 
         //can be contains one $
         internal static readonly Parser<char, string> StringWithoutPlaceholder

src/SimpleStateMachine.StructuralSearch/StructuralSearch/FindRulesParser.cs

@@ -72,8 +72,8 @@ internal static readonly Parser<char, Func<IRule, IRule>> Not
         );
 
         internal static readonly Parser<char, FindRule> Rule =
-            Parser.Map((name, rule) => new FindRule(name, rule),
-                    CommonTemplateParser.Placeholder.TrimStart(),
+            Parser.Map((parameter, rule) => new FindRule(parameter, rule),
+                ParametersParser.PlaceholderParameter,
                     Expr.TrimStart());
 
         internal static FindRule ParseTemplate(string str)