Merge pull request #4 from SimpleStateMachine/dev

Dev

Author: RomanSoloweow

src/SimpleStateMachine.StructuralSearch.Sandbox/Program.cs

@@ -13,12 +13,14 @@ internal static class Program
     {
         static void Main(string[] args)
         {
-            var tesds = ParametersParser.StringFormatParameter.ParseOrThrow("\"tfasdfa\\\"sd$var$.Lenght\"");
-            var rule = StructuralSearch.ParseFindRule("$var$ equals $var$.Lenght and Not StartsWith \"123\"");
+            //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\"");
-            var result1 = rule.Execute("test");
-            var result2 = rule.Execute("10");
-            var result3 = rule.Execute("5.3");
+            // var result1 = rule.Execute("test");
+            // var result2 = rule.Execute("10");
+            // var result3 = rule.Execute("5.3");
 
             var t = ExprParser.ParseOrThrow("2 + 2 + 2");
             var resw = t.Invoke();

src/SimpleStateMachine.StructuralSearch.Tests/FindRuleParserTests.cs

@@ -0,0 +1,24 @@
+using System.Linq;
+using Pidgin;
+using Xunit;
+
+namespace SimpleStateMachine.StructuralSearch.Tests
+{
+    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\"")]
+        [InlineData("equals $var$.Lenght and Not StartsWith \"\\\"Test\"")]
+        public void FindRuleParsingShouldBeSuccess(string ruleStr)
+        {
+            var rule = FindRuleParser.Expr.ParseOrThrow(ruleStr);
+            var _ruleStr = rule.ToString()?.ToLower();
+            Assert.NotNull(rule);
+            Assert.Equal(_ruleStr, ruleStr.ToLower());
+        }
+    }
+}

src/SimpleStateMachine.StructuralSearch.Tests/ReplaceRuleParserTests.cs

@@ -0,0 +1,26 @@
+using System.Linq;
+using Pidgin;
+using Xunit;
+
+namespace SimpleStateMachine.StructuralSearch.Tests
+{
+    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)
+        {
+            var placeholder = "$var$";
+            var 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.Tests/RuleParserTests.cs

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

src/SimpleStateMachine.StructuralSearch/Constant.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)));
+        }
+    }
+}