refact, escape string parameter, tests with escaped chars

Author: RomanSoloweow

src/SimpleStateMachine.StructuralSearch.Tests/FindRuleParserTests.cs

@@ -8,6 +8,7 @@ public class FindRuleParserTests
     {
         [Theory]
         [InlineData("equals $var$")]
+        [InlineData("equals \"\\$\"")]
         [InlineData("Not equals $var$.Lenght")]
         [InlineData("Not equals $var$.offset.Start")]
         [InlineData("equals $var$.Lenght and Not StartsWith \"123\"")]

src/SimpleStateMachine.StructuralSearch.Tests/ReplaceRuleParserTests.cs

@@ -8,16 +8,17 @@ public class ReplaceRuleParserTests
     {
         [Theory]
         [InlineData("equals $var$", "$var$")]
+        [InlineData("equals \"\\$\"", "\"\\$\"")]
         [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 placeholder = "$var$";
+            var replaceRuleStr = $"{placeholder} {findRule} => {replaceRule}";
             var rule = StructuralSearch.ParseReplaceRule(replaceRuleStr);
-            var _ruleStr = rule.ToString()?.ToLower();
+            var _ruleStr = rule.ToString().ToLower();
             Assert.NotNull(rule);
             Assert.Equal(_ruleStr, replaceRuleStr.ToLower());
         }

src/SimpleStateMachine.StructuralSearch/Helper/CharHelper.cs

@@ -0,0 +1,38 @@
+using System;
+using System.Linq;
+
+namespace SimpleStateMachine.StructuralSearch.Helper
+{
+    public static class EscapeHelper
+    {
+        public static string Escape(string str, Func<char, char> replaceRule)
+        {
+            return new string(str.Select(replaceRule).ToArray());
+        }
+
+        public static string EscapeChars(string str, Func<char, char> replaceRule, params char[] filter)
+        {
+            return new string(str.Select(c => filter.Contains(c) ? replaceRule(c) : c).ToArray());
+        }
+
+        public static string EscapeExclude(string str, Func<char, char> replaceRule, params char[] excluded)
+        {
+            return new string(str.Select(c => excluded.Contains(c) ? c : replaceRule(c)).ToArray());
+        }
+
+        public static string Escape(string str, Func<char, string> replaceRule)
+        {
+            return string.Join(string.Empty, str.Select(replaceRule));
+        }
+
+        public static string EscapeChars(string str, Func<char, string> replaceRule, params char[] filter)
+        {
+            return string.Join(string.Empty, str.Select(c => filter.Contains(c) ? replaceRule(c) : c.ToString()));
+        }
+
+        public static string EscapeExclude(string str, Func<char, string> replaceRule, params char[] excluded)
+        {
+            return string.Join(string.Empty, str.Select(c => excluded.Contains(c) ? c.ToString() : replaceRule(c)));
+        }
+    }
+}