feat(FindRules): Use find rules during parsing

Author: RomanSoloweow

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

@@ -20,7 +20,6 @@
           $var$ = $value1$;
     FindRules:
       - $sign$ In ("is", "==", "!=", "is not")
-      - $value$ In ($value1$, $value2$)
     ReplaceTemplate: |-
       $var$ = $value1$ ?? $value2$;
     ReplaceRules:

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

@@ -19,7 +19,6 @@
           $var$ = $value1$;
     FindRules:
       - $sign$ In ("is", "==", "!=", "is not")
-      - $value$ In ($value1$, $value2$)
     ReplaceTemplate: |-
       $var$ = $value1$ ?? $value2$;
     ReplaceRules:

src/SimpleStateMachine.StructuralSearch.Tests/ExamplesInput/Methods.cs

@@ -0,0 +1,34 @@
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace SimpleStateMachine.StructuralSearch.Tests.Examples;
+
+public class Test
+{
+    public int Method1(int value1, int value2)
+    {
+        return value1 + value2;
+    }
+    
+    public string Method2(int value1, string value2)
+    {
+        // some comments
+        return value2 + value1;
+    }
+    
+    public void Method3()
+    {
+
+    }
+    
+    public Task Method4Async(CancellationToken cancellationToken)
+    {
+        return Task.CompletedTask;
+    }
+    
+    public int Test2(int Test2)
+    {
+        // some comments
+        return Test2;
+    }
+}

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

@@ -1,2 +1 @@
-$sign$ In ("is", "==", "!=", "is not")
-$value$ In ($value1$, $value2$)
+$sign$ In ("is", "==", "!=", "is not")

src/SimpleStateMachine.StructuralSearch.Tests/FindRuleParserTests.cs

@@ -62,7 +62,7 @@ public static void FindRuleExprParsingShouldBeEqualsCustomResult(string ruleStr,
     }
 
     [Theory]
-    [InlineData("FindRule/NullUnionOperator.txt", "$sign$ In \"is\",\"==\",\"!=\",\"is not\"",  "$value$ In $value1$,$value2$")]
+    [InlineData("FindRule/NullUnionOperator.txt", "$sign$ In \"is\",\"==\",\"!=\",\"is not\"")]
     [InlineData("FindRule/AssignmentNullUnionOperator.txt", "$sign$ In \"is\",\"==\",\"!=\",\"is not\"")]
     public static void FindRuleParsingFromFileShouldBeSuccess(string filePath, params string[] customResult)
     {

src/SimpleStateMachine.StructuralSearch.Tests/StructuralSearchTests.cs

@@ -1,5 +1,8 @@
 using System.Collections.Generic;
+using System.IO;
 using System.Linq;
+using SimpleStateMachine.StructuralSearch;
+using SimpleStateMachine.StructuralSearch.Configurations;
 using SimpleStateMachine.StructuralSearch.Extensions;
 using Xunit;
 
@@ -37,4 +40,26 @@ public static void StructuralSearchShouldBeSuccess(string inputText, string temp
             }
         }
     };
+
+
+    [Theory]
+    [InlineData("ExamplesInput/Methods.cs")]
+    public static void StructuralSearchShouldBeSuccess2(string filePath)
+    {
+        var configuration = new Configuration()
+        {
+            FindTemplate = "$Modificator$ $ReturnType$ $MethodName$($params$)",
+            FindRules = new List<string>
+            {
+                "$Modificator$ in (\"public\", \"private\", \"internal\")",
+                "$ReturnType$ is var",
+                "$MethodName$ is var"
+            }
+        };
+
+        var parser = new StructuralSearchParser(configuration);
+        IParsingContext context = new ParsingContext(new FileInput(new FileInfo(filePath)));
+        var results = parser.Parse(ref context).ToList();
+        // parser.ApplyFindRule(results);
+    }
 }

src/SimpleStateMachine.StructuralSearch/EmptyParsingContext.cs

@@ -17,6 +17,9 @@ public bool TryGetPlaceholder(string name, out IPlaceholder value)
         public void AddPlaceholder(IPlaceholder placeholder) 
             => throw new System.NotImplementedException();
 
+        public void RemovePlaceholder(IPlaceholder placeholder)
+            => throw new System.NotImplementedException();
+
         public IPlaceholder GetPlaceholder(string name) 
             => Placeholder.CreateEmpty(this, name, string.Empty);
 

src/SimpleStateMachine.StructuralSearch/Extensions/IRuleParameterExtensions.cs

@@ -0,0 +1,7 @@
+namespace SimpleStateMachine.StructuralSearch.Rules;
+
+internal static class IRuleParameterExtensions
+{
+    public static bool IsApplicableForPlaceholder(this IRuleParameter parameter, string placeholderName)
+        => parameter is IPlaceholderRelatedRuleParameter relatedRuleParameter && relatedRuleParameter.Name == placeholderName;
+}

src/SimpleStateMachine.StructuralSearch/IParsingContext.cs

@@ -8,6 +8,7 @@ public interface IParsingContext
 
         bool TryGetPlaceholder(string name, out IPlaceholder value);
         void AddPlaceholder(IPlaceholder placeholder);
+        void RemovePlaceholder(IPlaceholder placeholder);
         IPlaceholder GetPlaceholder(string name);
 
         void Fill(IReadOnlyDictionary<string, IPlaceholder>placeholders);

src/SimpleStateMachine.StructuralSearch/Parsers/PlaceholderParser.cs

@@ -1,20 +1,25 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using Pidgin;
 using SimpleStateMachine.StructuralSearch.Extensions;
+using SimpleStateMachine.StructuralSearch.Rules;
 
 namespace SimpleStateMachine.StructuralSearch
 {
     public class PlaceholderParser : ParserWithLookahead<char, string>, IContextDependent
     {
         private readonly string _name;
+        private readonly IReadOnlyList<IFindRule> _findRules;
         private IParsingContext? _context;
-        private IParsingContext Context => _context ?? throw new ArgumentNullException(nameof(_context));
 
-        public PlaceholderParser(string name)
+        public PlaceholderParser(string name, IReadOnlyList<IFindRule> findRules)
         {
             _name = name;
+            _findRules = findRules;
         }
+        
+        private IParsingContext Context => _context ?? throw new ArgumentNullException(nameof(_context));
 
         protected override Parser<char, string> BuildParser(Func<Parser<char, string>?> next,
             Func<Parser<char, string>?> nextNext)
@@ -28,7 +33,6 @@ protected override Parser<char, string> BuildParser(Func<Parser<char, string>?>
             Parser<char, Unit> lookahead;
             if (nextNextParser is not null)
             {
-            
                 lookahead = Parser.Lookahead(nextParser.Then(nextNextParser, (s1, s2) =>
                 {
                     OnLookahead = () => new List<LookaheadResult<char, string>>
@@ -90,10 +94,19 @@ public override bool TryParse(ref ParseState<char> state, ref PooledList<Expecte
                 result = match.Value;
                 if (res)
                 {
-                    Context.AddPlaceholder(new Placeholder(
+                    var placeholderObj = new Placeholder
+                    (
                         context: ref _context!,
                         name: _name,
-                        match: match));
+                        match: match
+                    );
+                    
+                    Context.AddPlaceholder(placeholderObj);
+
+                    res = _findRules.All(r => r.Execute(ref _context));
+                    
+                    if (!res)
+                        Context.RemovePlaceholder(placeholderObj);
                 }
             }