new replace rule with new find rule, replace sub rules

Author: RomanSoloweow

src/SimpleStateMachine.StructuralSearch.Tests/ConfigurationFile/FullConfig.yml

@@ -27,6 +27,7 @@
     ReplaceTemplate: |-
       $var$ = $value1$ ?? $value2$;
     ReplaceRules:  
+      - $sign$ In ("!=", "is not") then $var2$ => $var1$, $var1$ => $var2$
 
 #  TernaryOperator 
 

src/SimpleStateMachine.StructuralSearch.Tests/ConfigurationFile/ShortConfig.yml

@@ -25,7 +25,8 @@
       - $sign$ In ("Is", "==", "!=", "is not")
     ReplaceTemplate: |-
       $var$ = $value1$ ?? $value2$;
-      
+    ReplaceRules:  
+     - $sign$ In ("!=", "is not") then $var2$ => $var1$, $var1$ => $var2$
 #  TernaryOperator   
 
   - FindTemplate: |-

src/SimpleStateMachine.StructuralSearch.Tests/Mock/Configuration.cs

@@ -13,9 +13,8 @@ public static Configuration GetConfigurationFromFiles(string name)
             var fileRule = FileOrNull("FindRule", fileName) ;
             var replaceTemplate = FileOrNull("ReplaceTemplate", fileName);
             var replaceRule = FileOrNull("ReplaceRule", fileName);
-
-            var fileRules = fileRule is null ? null : new List<string>{ fileRule };
-            var replaceRules = replaceRule is null ? null : new List<string>{ replaceRule };
+            var fileRules = fileRule is null ? null : new List<string>(fileRule.Split(Constant.LineFeed.ToString()));
+            var replaceRules = replaceRule is null ? null : new List<string>(replaceRule.Split(Constant.LineFeed.ToString()));
             var config = new Configuration
             {
                 FindTemplate = findTemplate,

src/SimpleStateMachine.StructuralSearch.Tests/ReplaceRule/NullUnionOperator.txt

@@ -1 +1 @@
-$sign$ Is ("Is", "==", "!=", "is not")
+$sign$ In ("!=", "is not") then $var2$ => $var1$, $var1$ => $var2$

src/SimpleStateMachine.StructuralSearch.Tests/ReplaceRuleParserTests.cs

@@ -7,28 +7,13 @@ namespace SimpleStateMachine.StructuralSearch.Tests
     public class ReplaceRuleParserTests
     {
         [Theory]
-        [InlineData("$var$", "equals $var$", "$var$")]
-        [InlineData("$var$", "equals \"\\$\"", "\"\\$\"")]
-        [InlineData("$var$", "Not equals $var$.Lenght", "$var$.Lenght")]
-        [InlineData("$var$", "Not equals $var$.offset.Start", "$var$.offset.Start")]
-        [InlineData("$var$", "equals $var$.Lenght and Not StartsWith \"123\"", "$var$.offset.Start.Trim")]
-        [InlineData("$var$", "equals $var$.Lenght and Not StartsWith \"\\\"Test\"", "$var$.offset.Start.ToUpper")]
-        public void ReplaceRulePartsParsingShouldBeSuccess(string placeholder, string findRule, string replaceRule)
-        {
-            var replaceRuleStr = $"{placeholder} {findRule} => {replaceRule}";
-            var rule = StructuralSearch.ParseReplaceRule(replaceRuleStr);
-            var ruleStr = rule.ToString().ToLower();
-            Assert.NotNull(rule);
-            Assert.Equal(ruleStr, replaceRuleStr.ToLower());
-        }
-        
-        [Theory]
-        [InlineData("$var1$ equals $var$ => $var2$")]
-        [InlineData("$var1$ equals \"\\$\" => \"\\$\"")]
-        [InlineData("$var1$ Not equals $var$.Lenght => $var$.Lenght")]
-        [InlineData("$var1$ Not equals $var$.offset.Start => $var$.offset.Start")]
-        [InlineData("$var1$ equals $var$.Lenght and Not StartsWith \"123\" => $var$.offset.Start.Trim")]
-        [InlineData("$var1$ equals $var$.Lenght and Not StartsWith \"\\\"Test\" => $var$.offset.Start.ToUpper")]
+        [InlineData("$var1$ equals $var2$ then $var1$ => $var3$")]
+        [InlineData("$var1$ equals \"\\$\" then $var1$ => \"\\$\",$var2$ => \"132\"")]
+        [InlineData("Not $var1$ equals $var$.Lenght then $var1$ => $var$.Lenght")]
+        [InlineData("Not $var1$ equals $var$.offset.Start then $var1$ => $var$.offset.Start")]
+        [InlineData("$var1$ equals $var$.Lenght and Not $var1$ StartsWith \"123\" then $var1$ => $var$.offset.Start.Trim")]
+        [InlineData("$var1$ equals $var$.Lenght and Not $var1$ StartsWith \"123\" then $var1$ => $var$.offset.Start.Trim,$var2$ => $var$.offset.Start.Trim")]
+        [InlineData("$var1$ equals $var$.Lenght and Not $var1$ StartsWith \"\\\"Test\" then $var1$ => $var$.offset.Start.ToUpper")]
         public void ReplaceRuleParsingShouldBeSuccess(string replaceRule)
         {
             var rule = StructuralSearch.ParseReplaceRule(replaceRule);

src/SimpleStateMachine.StructuralSearch/Constant.cs

@@ -12,6 +12,11 @@ public static partial class Constant
         /// </summary>
         public static readonly string Not ="Not";
 
+        /// <summary>
+        /// String: "Then"
+        /// </summary>
+        public static readonly string Then ="Then";
+        
         /// <summary>
         /// Parenthesis char: '('
         /// </summary>
@@ -97,6 +102,11 @@ public static partial class Constant
         /// </summary>
         public static readonly char More = '>';
 
+        /// <summary>
+        /// Char: ':'
+        /// </summary>
+        public static readonly char Colon = ':';
+        
         /// <summary>
         /// String: "=>"
         /// </summary>

src/SimpleStateMachine.StructuralSearch/Rules/ReplaceRule/ReplaceRule.cs

@@ -1,4 +1,6 @@
-using Pidgin;
+using System.Collections.Generic;
+using System.Reflection.Metadata;
+using Pidgin;
 using SimpleStateMachine.StructuralSearch.Extensions;
 using SimpleStateMachine.StructuralSearch.Rules;
 
@@ -7,19 +9,18 @@ namespace SimpleStateMachine.StructuralSearch
     public class ReplaceRule
     {
         public IRule FindRule { get; }
-        public PlaceholderParameter Placeholder { get; }
-        public IRuleParameter Parameter { get; }
 
-        public ReplaceRule(IRule findRule, PlaceholderParameter placeholder, IRuleParameter parameter)
+        public IEnumerable<ReplaceSubRule> Rules { get; }
+        
+        public ReplaceRule(IRule findRule, IEnumerable<ReplaceSubRule> rules)
         {
             FindRule = findRule;
-            Placeholder = placeholder;
-            Parameter = parameter;
+            Rules = rules;
         }
 
         public override string ToString()
         {
-            return $"{FindRule}{Constant.Space}{Constant.Should}{Constant.Space}{Parameter}";
+            return $"{FindRule}{Constant.Space}{Constant.Then}{Constant.Space}{string.Join(Constant.Comma, Rules)}";
         } 
     }
 }

src/SimpleStateMachine.StructuralSearch/Rules/ReplaceRule/ReplaceSubRule.cs

@@ -0,0 +1,20 @@
+using SimpleStateMachine.StructuralSearch.Rules;
+
+namespace SimpleStateMachine.StructuralSearch;
+
+public class ReplaceSubRule
+{
+    public PlaceholderParameter Placeholder { get; }
+    public IRuleParameter Parameter { get; }
+    
+    public ReplaceSubRule(PlaceholderParameter placeholder, IRuleParameter parameter)
+    {
+        Placeholder = placeholder;
+        Parameter = parameter;
+    }
+        
+    public override string ToString()
+    {
+        return $"{Placeholder}{Constant.Space}{Constant.Should}{Constant.Space}{Parameter}";
+    } 
+}

src/SimpleStateMachine.StructuralSearch/StructuralSearch/CommonParser.cs

@@ -34,6 +34,9 @@ internal static readonly Parser<char, string> Identifier
         internal static readonly Parser<char, char> Comma
             = Char(Constant.Comma);
 
+        internal static readonly Parser<char, char> Colon
+            = Char(Constant.Colon);
+        
         internal static readonly Parser<char, char> DoubleQuotes
             = Char(Constant.DoubleQuotes);
 

src/SimpleStateMachine.StructuralSearch/StructuralSearch/ReplaceRuleParser.cs

@@ -13,14 +13,26 @@ public static class ReplaceRuleParser
                 .As<char, ChangeParameter, IRuleParameter>()
                 .Try()
                 .TrimStart();
+    
+        internal static readonly Parser<char, string> Then =
+            Parser.CIString(Constant.Then)
+                .Try()
+                .TrimStart();
 
-        internal static readonly Parser<char, ReplaceRule> ReplaceRule =
-            Parser.Map((rule, parameter) => new ReplaceRule(rule, parameter),
-                    FindRuleParser.Expr.Before(CommonTemplateParser.Should.TrimStart()),
+        internal static readonly Parser<char, ReplaceSubRule> ReplaceSubRule =
+            Parser.Map((placeholder, parameter) => new ReplaceSubRule(placeholder, parameter),
+                    ParametersParser.PlaceholderParameter.Before(CommonTemplateParser.Should.TrimStart()),
                     Parser.OneOf(ChangeParameter.Try(), ParametersParser.Parameter.Try()))
                 .Try()
                 .TrimStart();
 
+        internal static readonly Parser<char, ReplaceRule> ReplaceRule =
+            Parser.Map((rule, subRules) => new ReplaceRule(rule, subRules),
+                    FindRuleParser.Expr,
+                    Then.Then(ReplaceSubRule.SeparatedAtLeastOnce(CommonParser.Comma)))
+                .Try()
+                .TrimStart();
+        
         internal static ReplaceRule ParseTemplate(string str)
         {
             return ReplaceRule.ParseOrThrow(str);