use parsing context

Author: RomanSoloweow

src/SimpleStateMachine.StructuralSearch.Tests/ConfigurationFileTests.cs

@@ -21,16 +21,16 @@ public void ConfigurationFileParsingShouldBeSuccess(string filePath)
                 .WithNamingConvention(PascalCaseNamingConvention.Instance)
                 .Build();
 
-            var cfg = deserializer.Deserialize<ConfigurationsFile>(yml);
+            var cfg = deserializer.Deserialize<ConfigurationFile>(yml);
             var mock = Mock();
             Assert.Equal(mock, cfg);
         }
 
-        private ConfigurationsFile Mock()
+        private ConfigurationFile Mock()
         {
             var names = new[] { "AssignmentNullUnionOperator", "NullUnionOperator", "TernaryOperator"};
 
-            var configurationFile = new ConfigurationsFile
+            var configurationFile = new ConfigurationFile
             {
                 Configurations = new List<Configuration>()
             };

src/SimpleStateMachine.StructuralSearch.Tests/FindTemplateTests.cs

@@ -14,7 +14,7 @@ public class FindTemplateTests
         public void TemplateParsingShouldBeSuccess(string templatePath)
         {
            var findTemplate = File.ReadAllText(templatePath);
-           var template = StructuralSearch.ParseFindTemplate(findTemplate, new ParsingContext());
+           var template = StructuralSearch.ParseFindTemplate(findTemplate);
 
            Assert.NotNull(template);
         }
@@ -28,12 +28,11 @@ public void SourceParsingBeFindTemplateShouldBeSuccess(string templatePath, stri
         {
             var findTemplate = File.ReadAllText(templatePath);
             var source = File.ReadAllText(sourcePath);
-
-            var context = new ParsingContext();
-            var template = StructuralSearch.ParseFindTemplate(findTemplate, context);
-            var result = template.ParseOrThrow(source);
+            var findParser = StructuralSearch.ParseFindTemplate(findTemplate);
+            var parsingContext = new ParsingContext();
+            var result = findParser.Parse(parsingContext, source);
 
-            Assert.NotNull(template);
+            Assert.NotNull(findParser);
             Assert.NotNull(result);
             Assert.NotNull(result.Value);
             Assert.Equal(result.Lenght, source.Length);

src/SimpleStateMachine.StructuralSearch.Tests/PlaceholderParserTests.cs

@@ -8,7 +8,7 @@ public class PlaceholderParserTests
         [Fact]
         public void FindTemplateShouldBeNotEmpty()
         {
-            Assert.Throws<ParseException>(() => StructuralSearch.ParseFindTemplate(string.Empty, new ParsingContext()));
+            Assert.Throws<ParseException>(() => StructuralSearch.ParseFindTemplate(string.Empty));
         }
 
         [Theory]
@@ -18,10 +18,10 @@ public void FindTemplateShouldBeNotEmpty()
         [InlineData("($test$)", "(value (test) )", "value (test) ")]
         public void TemplateParsingShouldBeSuccess(string template, string source, string result)
         {
-            var context = new ParsingContext();
-            var templateParser = StructuralSearch.ParseFindTemplate(template, context);
-            var res = templateParser.ParseOrThrow(source);
-            var value = context.GetPlaceholder("test");
+            var parsingContext = new ParsingContext();
+            var templateParser = StructuralSearch.ParseFindTemplate(template);
+            var res = templateParser.Parse(parsingContext, source);
+            var value = parsingContext.GetPlaceholder("test");
 
             Assert.Equal(value, result);
         }
@@ -30,9 +30,9 @@ public void TemplateParsingShouldBeSuccess(string template, string source, strin
         [InlineData("$var$;$var2$;", "test;;;test;;;",  "value ")]
         public void TemplateParsingShouldBeSuccess2(string template, string source, string result)
         {
-            var context = new ParsingContext();
-            var templateParser = StructuralSearch.ParseFindTemplate(template, context);
-            var res = templateParser.ParseOrThrow(source);
+            var parsingContext = new ParsingContext();
+            var templateParser = StructuralSearch.ParseFindTemplate(template);
+            var res = templateParser.Parse(parsingContext, source);
 
 
             // var templateStr = File.ReadAllText(templatePath);

src/SimpleStateMachine.StructuralSearch.Tests/ReplaceRuleParserTests.cs

@@ -13,7 +13,7 @@ public class ReplaceRuleParserTests
         [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)
+        public void ReplaceRuleParsingShouldBeSuccess(string findRule, string replaceRule)
         {
             var placeholder = "$var$";
             var replaceRuleStr = $"{placeholder} {findRule} => {replaceRule}";

…rch/Configurations/ConfigurationsFile.cs …arch/Configurations/ConfigurationFile.cssrc/SimpleStateMachine.StructuralSearch/Configurations/ConfigurationsFile.cs renamed to src/SimpleStateMachine.StructuralSearch/Configurations/ConfigurationFile.cs src/SimpleStateMachine.StructuralSearch/Configurations/ConfigurationsFile.cs renamed to src/SimpleStateMachine.StructuralSearch/Configurations/ConfigurationFile.cs

@@ -4,19 +4,19 @@
 
 namespace SimpleStateMachine.StructuralSearch.Configurations
 {
-    public class ConfigurationsFile: IEquatable<ConfigurationsFile>
+    public class ConfigurationFile: IEquatable<ConfigurationFile>
     {
         public List<Configuration> Configurations { get; set; }
 
-        public bool Equals(ConfigurationsFile? other)
+        public bool Equals(ConfigurationFile? other)
         {
             return Configurations.SequenceEqual(other.Configurations);
         }
 
         public override bool Equals(object? obj)
         {
             if (obj.GetType() != this.GetType()) return false;
-            return Equals((ConfigurationsFile)obj);
+            return Equals((ConfigurationFile)obj);
         }
 
         public override int GetHashCode()

src/SimpleStateMachine.StructuralSearch/Extensions/SourceMatchManyParserExtensions.cs

@@ -0,0 +1,23 @@
+using System.Collections.Generic;
+using Pidgin;
+using SimpleStateMachine.StructuralSearch.Extensions;
+
+namespace SimpleStateMachine.StructuralSearch
+{
+    public class FindParser : IFindParser
+    {
+        private SeriesParser Parser { get; }
+        public FindParser(SeriesParser parser)
+        {
+            Parser = parser;
+        }
+
+        public SourceMatch Parse(IParsingContext context, string input)
+        {
+            Parser.SetContext(context);
+            var result = Parser.Select(x => string.Join(string.Empty, x)).AsMatch().Parse(input);
+            
+            return result.Success ? result.Value : SourceMatch.Empty;
+        }
+    }
+}

src/SimpleStateMachine.StructuralSearch/FindParser.cs

@@ -0,0 +1,11 @@
+using System.Collections.Generic;
+using Pidgin;
+using SimpleStateMachine.StructuralSearch.ReplaceTemplate;
+
+namespace SimpleStateMachine.StructuralSearch
+{
+    public interface IFindParser
+    {
+        SourceMatch Parse(IParsingContext context, string input);
+    }
+}

src/SimpleStateMachine.StructuralSearch/IFindParser.cs

@@ -77,18 +77,6 @@ public static Parser<TToken, IEnumerable<T>> MapToMany<TToken, T>(Parser<TToken,
             }, parser1, parser2);
         }
 
-
-        public static Parser<TToken, R> Series<TToken, T, R>(IParsingContext context, IEnumerable<Parser<TToken, T>> parsers,
-            Func<IEnumerable<T>, R> func)
-        {
-            if (parsers == null)
-                throw new ArgumentNullException(nameof(parsers));
-            if (func == null)
-                throw new ArgumentNullException(nameof(func));
-
-            return new SeriesParser<TToken, T, R>(context, parsers, func);
-        }
-
         public static Parser<char, IEnumerable<T>> BetweenChars<T>(char left, char right,
             Func<char, Parser<char, T>> leftRight,
             Parser<char, IEnumerable<T>> expr)