replace rule

Author: RomanSoloweow

src/SimpleStateMachine.StructuralSearch.Sandbox/Program.cs

@@ -14,13 +14,13 @@ 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 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/RuleParserTests.cs

@@ -12,7 +12,7 @@ public class RuleParserTests
         [InlineData("Not equals $var$.offset.Start")]
         [InlineData("equals $var$.Lenght and Not StartsWith \"123\"")]
         [InlineData("equals $var$.Lenght and Not StartsWith \"\\\"Test\"")]
-        public void TemplateParsingShouldBeSuccess(string ruleStr)
+        public void FindRuleParsingShouldBeSuccess(string ruleStr)
         {
             var rule = FindRuleParser.Expr.ParseOrThrow(ruleStr);
             var _ruleStr = rule.ToString()?.ToLower();

src/SimpleStateMachine.StructuralSearch/Constant.cs

@@ -87,6 +87,16 @@ 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>
         /// Parenthesis chars: '(' and ')'
         /// </summary>

…e.StructuralSearch/Rule/FindRule/Rule.cs …ructuralSearch/Rule/FindRule/FindRule.cssrc/SimpleStateMachine.StructuralSearch/Rule/FindRule/Rule.cs renamed to src/SimpleStateMachine.StructuralSearch/Rule/FindRule/FindRule.cs src/SimpleStateMachine.StructuralSearch/Rule/FindRule/Rule.cs renamed to src/SimpleStateMachine.StructuralSearch/Rule/FindRule/FindRule.cs

@@ -1,21 +1,16 @@
 namespace SimpleStateMachine.StructuralSearch.Rules
 {
-    public class Rule:IRule
+    public class FindRule
     {
         public string Placeholder { get; }
 
         private IRule _rule { get; }
 
-        public Rule(string placeholder, IRule rule)
+        public FindRule(string placeholder, IRule rule)
         {
             Placeholder = placeholder;
             _rule = rule;
         }
-
-        public bool Execute(string value)
-        {
-            return _rule.Execute(value);
-        }
 
         public override string ToString()
         {

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

@@ -0,0 +1,21 @@
+using SimpleStateMachine.StructuralSearch.Rules;
+
+namespace SimpleStateMachine.StructuralSearch
+{
+    public class ChangeParameter : IRuleParameter
+    {
+        public IRuleParameter Parameter { get; }
+        public ChangeType Type { get; }
+
+        public ChangeParameter(IRuleParameter parameter, ChangeType type)
+        {
+            Parameter = parameter;
+            Type = type;
+        }
+
+        public string GetValue()
+        {
+            throw new System.NotImplementedException();
+        }
+    }
+}

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

@@ -2,8 +2,7 @@
 {
     public enum ChangeType
     {
-        NotCorrect = 0,
-        Trim,
+        Trim = 0,
         TrimEnd,
         TrimStart,
         ToUpper,

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

@@ -0,0 +1,24 @@
+using Pidgin;
+using SimpleStateMachine.StructuralSearch.Extensions;
+using SimpleStateMachine.StructuralSearch.Rules;
+
+namespace SimpleStateMachine.StructuralSearch
+{
+    public class ReplaceRule
+    {
+        public FindRule FindRule { get; }
+
+        public IRuleParameter Parameter { get; }
+
+        public ReplaceRule(FindRule findRule, IRuleParameter parameter)
+        {
+            FindRule = findRule;
+            Parameter = parameter;
+        }
+        
+        public override string ToString()
+        {
+            return $"{FindRule}{Constant.Space}{Parameter}";
+        } 
+    }
+}

src/SimpleStateMachine.StructuralSearch/StructuralSearch/CommonTemplateParser.cs

@@ -16,6 +16,10 @@ internal static readonly Parser<char, string> Placeholder
         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);
+        
         //can be contains one $
         internal static readonly Parser<char, string> StringWithoutPlaceholder
             = Any.AtLeastOnceAsStringUntilNot(Placeholder);

src/SimpleStateMachine.StructuralSearch/StructuralSearch/FindRulesParser.cs

@@ -57,13 +57,12 @@ internal static readonly Parser<char, Func<IRule, IRule>> Not
             )
         );
 
-        internal static readonly Parser<char, IRule> Rule =
-            Parser.Map((name, rule) => new Rule(name, rule),
+        internal static readonly Parser<char, FindRule> Rule =
+            Parser.Map((name, rule) => new FindRule(name, rule),
                     CommonTemplateParser.Placeholder.TrimStart(),
-                    Expr.TrimStart())
-                .As<char, Rule, IRule>();
+                    Expr.TrimStart());
 
-        internal static IRule ParseTemplate(string str)
+        internal static FindRule ParseTemplate(string str)
         {
             return Rule.ParseOrThrow(str);
         }

src/SimpleStateMachine.StructuralSearch/StructuralSearch/ReplaceRuleParser.cs

@@ -1,7 +1,27 @@
-namespace SimpleStateMachine.StructuralSearch
+using Pidgin;
+using SimpleStateMachine.StructuralSearch.Extensions;
+using SimpleStateMachine.StructuralSearch.Rules;
+
+namespace SimpleStateMachine.StructuralSearch
 {
-    public class ReplaceRuleParser
+    public static class ReplaceRuleParser
     {
+        internal static readonly Parser<char, IRuleParameter> ChangeParameter =
+            Parser.Map((parameter, changeType) => new ChangeParameter(parameter, changeType),
+                ParametersParser.Parameter.Before(CommonParser.Dote),
+                Parsers.Enum<ChangeType>(true))
+                .As<char, ChangeParameter, IRuleParameter>()
+                .Try()
+                .TrimStart();
 
+        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));
+        
+        internal static ReplaceRule ParseTemplate(string str)
+        {
+            return ReplaceRule.ParseOrThrow(str);
+        }
     }
 }