Simplify interfaces

Author: RomanSoloweow

src/SimpleStateMachine.StructuralSearch.Sandbox/Program.cs

@@ -9,28 +9,18 @@ internal static class Program
 {
     static void Main(string[] args)
     {
-            
-        var pr = Parser.String("var").Trim();
-        var str = pr.ParseOrThrow("var");
-        str = pr.ParseOrThrow(" var");
-        str = pr.ParseOrThrow("var ");
-        str = pr.ParseOrThrow(" var ");
-        var source = "test;;;test;;;.";
-        var parser = Parser.OneOf(Parser<char>.Any.ThenReturn(Unit.Value), Parser<char>.End);
-            
-            
-        var t = Parser<char>.Any.AtLeastOnceAsStringUntil(Lookahead(String(";").Then(Not(String(";"))).Try())).ParseOrThrow(source);
+        //StructuralSearch.ParseFindTemplate()
 
 
         var path = "Test.txt";
         var oldText = "0123456789";
         var text = "test";
         File.WriteAllText(path, oldText);
 
-        using var stringReader = text.AsStream();
-        using var streamWriter = File.OpenWrite(path);
-            
-        stringReader.CopyPartTo(streamWriter, 0, 7);
+        // using var stringReader = text.AsStream();
+        // using var streamWriter = File.OpenWrite(path);
+        //     
+        // stringReader.CopyPartTo(streamWriter, 0, 7);
 
         // var config = YmlHelper.Parse(
         //     @"C:\Users\roman\GitHub\SimpleStateMachine.StructuralSearch\src\SimpleStateMachine.StructuralSearch.Tests\ConfigurationFile\FullConfig.yml");

src/SimpleStateMachine.StructuralSearch.Tests/FindTemplateParserTests.cs

@@ -29,10 +29,9 @@ public static void SourceParsingBeFindTemplateShouldBeSuccess(string templatePat
     {
         var findTemplate = File.ReadAllText(templatePath);
         var source = File.ReadAllText(sourcePath);
-        var input = Input.String(source);
+        var input = Input.Input.String(source);
         var findParser = StructuralSearch.ParseFindTemplate(findTemplate);
-        IParsingContext parsingContext = new ParsingContext(input);
-        var matches = findParser.Parse(ref parsingContext);
+        var matches = findParser.Parse(input);
         Assert.Single(matches);
 
         var match = matches.First();

src/SimpleStateMachine.StructuralSearch.Tests/PlaceholderParserTests.cs

@@ -12,10 +12,9 @@ public static class PlaceholderParserTests
     [InlineData("($test$)", "(value (test) )", "value (test) ")]
     public static void TemplateParsingShouldBeSuccess(string template, string source, string result)
     {
-        var input = Input.String(source);
-        IParsingContext parsingContext = new ParsingContext(input);
+        var input = Input.Input.String(source);
         var templateParser = StructuralSearch.ParseFindTemplate(template);
-        var matches = templateParser.Parse(ref parsingContext);
+        var matches = templateParser.Parse(input);
 
         Assert.Single(matches);
         var match = matches.First();
@@ -30,10 +29,9 @@ public static void TemplateParsingShouldBeSuccess(string template, string source
     [InlineData("$var$;.", "test;;;.", "test;;")]
     public static void TemplateParsingShouldBeSuccess2(string template, string source, params string[] values)
     {
-        var input = Input.String(source);
-        IParsingContext parsingContext = new ParsingContext(input);
+        var input = Input.Input.String(source);
         var templateParser = StructuralSearch.ParseFindTemplate(template);
-        var matches = templateParser.Parse(ref parsingContext);
+        var matches = templateParser.Parse(input);
         Assert.Single(matches);
         var match = matches.First();
         Assert.Equal(match.Placeholders.Count, values.Length);

src/SimpleStateMachine.StructuralSearch.Tests/ReplaceTemplateTests.cs

@@ -1,6 +1,7 @@
 using System.IO;
 using System.Linq;
 using Pidgin;
+using SimpleStateMachine.StructuralSearch.ReplaceTemplate;
 using Xunit;
 
 namespace SimpleStateMachine.StructuralSearch.Tests;
@@ -15,11 +16,9 @@ public static void ReplaceTemplateParsingShouldHaveStepCount(string templatePath
     {
         var replaceTemplate = File.ReadAllText(templatePath);
         var replaceBuilder = StructuralSearch.ParseReplaceTemplate(replaceTemplate);
-        IParsingContext context = ParsingContext.Empty;
-        var result = replaceBuilder.Build(ref context);
 
         Assert.NotNull(replaceTemplate);
-        Assert.Equal(replaceBuilder.Steps.Count(), stepsCount);
+        Assert.Equal(((ReplaceBuilder)replaceBuilder).Steps.Count(), stepsCount);
     }
 
     [Theory]
@@ -38,12 +37,12 @@ public static void ReplaceBuildShouldBeSuccess(string templatePath, string resul
         var replaceResult = File.ReadAllText(resultPath);
         var replaceBuilder = StructuralSearch.ParseReplaceTemplate(replaceTemplate);
 
-        IParsingContext parsingContext = new ParsingContext(Input.Empty);
+        IParsingContext parsingContext = new ParsingContext(Input.Input.Empty);
         for (int i = 0; i < keys.Length; i++)
         {
-            parsingContext.AddPlaceholder(Placeholder.CreateEmpty(parsingContext, keys[i], values[i]));
+            parsingContext[keys[i]] = Placeholder.CreateEmpty(parsingContext, keys[i], values[i]);
         }
-            
+
         var result = replaceBuilder.Build(ref parsingContext);
 
         Assert.NotNull(replaceTemplate);

src/SimpleStateMachine.StructuralSearch.Tests/StructurSearchParserTests.cs

@@ -16,7 +16,7 @@ public static void StructuralSearchShouldBeSuccess(string exampleName, string ex
         var parser = new StructuralSearchParser(config);
 
         var fileInfo = new FileInfo(exampleFilePath);
-        var input = Input.File(fileInfo);
+        var input = Input.Input.File(fileInfo);
         var matches = parser.Parse(input);
         Assert.Equal(matches.Count(), matchesCount);
     }

src/SimpleStateMachine.StructuralSearch.Tests/StructuralSearchTests.cs

@@ -4,6 +4,7 @@
 using SimpleStateMachine.StructuralSearch;
 using SimpleStateMachine.StructuralSearch.Configurations;
 using SimpleStateMachine.StructuralSearch.Extensions;
+using SimpleStateMachine.StructuralSearch.Input;
 using Xunit;
 
 namespace SimpleStateMachine.StructuralSearch.Tests;

src/SimpleStateMachine.StructuralSearch/Empty.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using SimpleStateMachine.StructuralSearch.Input;
 
 namespace SimpleStateMachine.StructuralSearch;
 

src/SimpleStateMachine.StructuralSearch/Extensions/IRuleParameterExtensions.cs

@@ -3,5 +3,5 @@
 internal static class IRuleParameterExtensions
 {
     public static bool IsApplicableForPlaceholder(this IRuleParameter parameter, string placeholderName)
-        => parameter is IPlaceholderRelatedRuleParameter relatedRuleParameter && relatedRuleParameter.Name == placeholderName;
+        => parameter is IPlaceholderRelatedRuleParameter relatedRuleParameter && relatedRuleParameter.PlaceholderName == placeholderName;
 }

src/SimpleStateMachine.StructuralSearch/FindParser.cs

@@ -3,47 +3,49 @@
 using System.Text;
 using Pidgin;
 using SimpleStateMachine.StructuralSearch.Extensions;
+using SimpleStateMachine.StructuralSearch.Input;
 
 namespace SimpleStateMachine.StructuralSearch;
 
-public class FindParser : IFindParser
+internal class FindParser : IFindParser
 {
-    public static readonly EmptyFindParser Empty = new ();
-        
     private SeriesParser Parser { get; }
+
     public FindParser(SeriesParser parser)    
     {
         Parser = parser;
     }
 
-    public IEnumerable<FindParserResult> Parse(ref IParsingContext context)
+    public List<FindParserResult> Parse(IInput input)
     {
         List<FindParserResult> matches = new();
         StringBuilder res = new();
 
+        IParsingContext context = new ParsingContext(input);
         Parser.SetContext(ref context);
-            
+
         var parsingContext = context;
         var parser = Parser.Select(x => string.Join(string.Empty, x))
             .Match()
             .ThenInvoke(match =>
             {
-                var placeholders = parsingContext.Clear();
+                var placeholders = context.ToDictionary();
+                context.Clear();
                 matches.Add(new FindParserResult(match, placeholders));
             })
             .ThenReturn(Unit.Value)
             .Try();
-            
+
         var empty = Parser<char>.Any
             .ThenInvoke(x =>
             {
                 res.Append(x);
                 parsingContext.Clear();
             })
             .ThenReturn(Unit.Value);
-            
-        context.Input.ParseBy(Pidgin.Parser.OneOf(parser, empty).Many());
-            
-        return matches.OrderBy(x=> x.Match.Offset.Start);
+
+        using var textReader = context.Input.ReadData();
+        Pidgin.Parser.OneOf(parser, empty).Many().Parse(textReader);
+        return matches.OrderBy(x=> x.Match.Offset.Start).ToList();
     }
 }

src/SimpleStateMachine.StructuralSearch/IFindParser.cs

@@ -1,15 +1,9 @@
-using System;
-using System.Collections.Generic;
+using System.Collections.Generic;
+using SimpleStateMachine.StructuralSearch.Input;
 
 namespace SimpleStateMachine.StructuralSearch;
 
 public interface IFindParser
 {
-    IEnumerable<FindParserResult> Parse(ref IParsingContext context);
-}
-    
-public class EmptyFindParser: IFindParser
-{
-    public IEnumerable<FindParserResult> Parse(ref IParsingContext context) 
-        => Array.Empty<FindParserResult>();
+    List<FindParserResult> Parse(IInput input);
 }