Replace result tests, ParsingContext interface

RomanSoloweow · RomanSoloweow · commit 31b8c81bf96b · 2022-04-03T03:59:52.000+03:00
diff --git a/src/SimpleStateMachine.StructuralSearch.Tests/Mock/EmptyParsingContext.cs b/src/SimpleStateMachine.StructuralSearch.Tests/Mock/EmptyParsingContext.cs
@@ -0,0 +1,20 @@
+﻿namespace SimpleStateMachine.StructuralSearch.Tests.Mock
+{
+    public class EmptyParsingContext : IParsingContext
+    {
+        public bool TryGetPlaceholder(string name, out string value)
+        {
+            throw new System.NotImplementedException();
+        }
+
+        public void AddPlaceholder(string name, string value)
+        {
+            throw new System.NotImplementedException();
+        }
+
+        public string GetPlaceholder(string name)
+        {
+            return name;
+        }
+    }
+}
diff --git a/src/SimpleStateMachine.StructuralSearch.Tests/ReplaceTemplate/IfElseReplaceTemplate.txt b/src/SimpleStateMachine.StructuralSearch.Tests/ReplaceTemplate/IfElseReplaceTemplate.txt
@@ -1 +1 @@
-﻿$var1$ $sign$ $value1$ ? $value1$ : $value2$;
+﻿$var1$ $sign$ $value1$ ? $value2$ : $value3$;
diff --git a/src/SimpleStateMachine.StructuralSearch.Tests/ReplaceTemplateTests.cs b/src/SimpleStateMachine.StructuralSearch.Tests/ReplaceTemplateTests.cs
@@ -1,5 +1,7 @@
-﻿using System.IO;
+﻿using System.Collections.Generic;
+using System.IO;
 using System.Linq;
+using SimpleStateMachine.StructuralSearch.Tests.Mock;
 using Xunit;
 
 namespace SimpleStateMachine.StructuralSearch.Tests
@@ -13,23 +15,34 @@ public class ReplaceTemplateTests
         public void TemplateParsingShouldHaveStepCount(string templatePath, int stepsCount)
         {
             var replaceTemplate = File.ReadAllText(templatePath);
-            var replaceBuilder = StructuralSearch.ParseReplaceTemplate(replaceTemplate, new ParsingContext());
-            var result = replaceBuilder.Build();
-            
+            var replaceBuilder = StructuralSearch.ParseReplaceTemplate(replaceTemplate);
+            var result = replaceBuilder.Build(new EmptyParsingContext());
+
             Assert.NotNull(replaceTemplate);
             Assert.Equal(replaceBuilder.Steps.Count(), stepsCount);
         }
-        
-        // [Theory]
-        // [InlineData("Source/IfElseSource.txt", "ReplaceTemplate/IfElseReplaceTemplate.txt")]
-        // public void ReplaceByTemplateShouldBeSuccess(string sourcePath, string templatePath)
-        // {
-        //     var replaceTemplate = File.ReadAllText(templatePath);
-        //     var replaceBuilder = StructuralSearch.ParseReplaceTemplate(replaceTemplate, new ParsingContext());
-        //     var result = replaceBuilder.Build();
-        //     
-        //     Assert.NotNull(replaceTemplate);
-        //     Assert.Equal(replaceBuilder.Steps.Count(), stepsCount);
-        // }
+
+        [Theory]
+        [InlineData("ReplaceTemplate/IfElseReplaceTemplate.txt", "ReplaceResult/IfElseReplaceResult.txt", new[] { "var1", "sign", "value1", "value2", "value3" }, new[] { "temp", "==", "125", "12", "15" })]
+        [InlineData("ReplaceTemplate/IfValueIsNullReplaceTemplate.txt", "ReplaceResult/IfValueIsNullReplaceResult.txt", new[] { "var", "value"  }, new[] { "temp", "12" })]
+        [InlineData("ReplaceTemplate/TernaryOperatorReplaceTemplate.txt", "ReplaceResult/TernaryOperatorReplaceResult.txt", new[] { "condition", "value1", "value2" }, new[] { "temp == 125", "12", "15" })]
+        public void ReplaceByTemplateShouldBeSuccess(string templatePath, string resultPath, string[] keys, string[] values)
+        {
+            var replaceTemplate = File.ReadAllText(templatePath);
+            var replaceResult = File.ReadAllText(resultPath);
+            var replaceBuilder = StructuralSearch.ParseReplaceTemplate(replaceTemplate);
+            
+            var parsingContext = new ParsingContext();
+            for (int i = 0; i < keys.Length; i++)
+            {
+                parsingContext.AddPlaceholder(keys[i], values[i]);
+            }
+            
+            var result = replaceBuilder.Build(parsingContext);
+
+            Assert.NotNull(replaceTemplate);
+            Assert.NotNull(replaceResult);
+            Assert.Equal(replaceResult, result);
+        }
     }
 }
diff --git a/src/SimpleStateMachine.StructuralSearch.Tests/SimpleStateMachine.StructuralSearch.Tests.csproj b/src/SimpleStateMachine.StructuralSearch.Tests/SimpleStateMachine.StructuralSearch.Tests.csproj
@@ -35,6 +35,9 @@
         <Content Include="ReplaceTemplate\*.txt">
             <CopyToOutputDirectory>Always</CopyToOutputDirectory>
         </Content>
+        <Content Include="ReplaceResult\*.txt">
+            <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+        </Content>
         <Content Include="ConfigurationFile\*">
             <CopyToOutputDirectory>Always</CopyToOutputDirectory>
         </Content>
diff --git a/src/SimpleStateMachine.StructuralSearch/Extensions/SourceMatchManyParserExtensions.cs b/src/SimpleStateMachine.StructuralSearch/Extensions/SourceMatchManyParserExtensions.cs
@@ -9,11 +9,11 @@ public static class SourceMatchParserExtensions
         // {
         //     return parsers.Select(x => Parsers.Series(x, getResult));
         // }
-        public static Parser<char, Parser<char, string>> JoinResults(this Parser<char, IEnumerable<Parser<char, string>>> parsers, ParsingContext context)
+        public static Parser<char, Parser<char, string>> JoinResults(this Parser<char, IEnumerable<Parser<char, string>>> parsers, IParsingContext context)
         {
             return parsers.Select(x => Parsers.Series(context, x, y => string.Join(string.Empty, y)));
         }
-        public static Parser<char, Parser<char, SourceMatch>> JoinResults(this Parser<char, IEnumerable<Parser<char, SourceMatch>>> parsers, ParsingContext context)
+        public static Parser<char, Parser<char, SourceMatch>> JoinResults(this Parser<char, IEnumerable<Parser<char, SourceMatch>>> parsers, IParsingContext context)
         {
             return parsers.Select(x => Parsers.Series(context, x, y => y.Concatenate()));
         }
diff --git a/src/SimpleStateMachine.StructuralSearch/IParsingContext.cs b/src/SimpleStateMachine.StructuralSearch/IParsingContext.cs
@@ -0,0 +1,11 @@
+﻿namespace SimpleStateMachine.StructuralSearch
+{
+    public interface IParsingContext
+    {
+        bool TryGetPlaceholder(string name, out string value);
+
+        void AddPlaceholder(string name, string value);
+
+        string GetPlaceholder(string name);
+    }
+}
diff --git a/src/SimpleStateMachine.StructuralSearch/Parsers/IContextDependent.cs b/src/SimpleStateMachine.StructuralSearch/Parsers/IContextDependent.cs
@@ -2,6 +2,6 @@
 {
     public interface IContextDependent
     {
-        void SetContext(ParsingContext context);
+        void SetContext(IParsingContext context);
     }
 }
diff --git a/src/SimpleStateMachine.StructuralSearch/Parsers/Parsers.cs b/src/SimpleStateMachine.StructuralSearch/Parsers/Parsers.cs
@@ -78,7 +78,7 @@ public static Parser<TToken, IEnumerable<T>> MapToMany<TToken, T>(Parser<TToken,
         }
 
 
-        public static Parser<TToken, R> Series<TToken, T, R>(ParsingContext context, IEnumerable<Parser<TToken, T>> parsers,
+        public static Parser<TToken, R> Series<TToken, T, R>(IParsingContext context, IEnumerable<Parser<TToken, T>> parsers,
             Func<IEnumerable<T>, R> func)
         {
             if (parsers == null)
diff --git a/src/SimpleStateMachine.StructuralSearch/Parsers/PlaceholderParser.cs b/src/SimpleStateMachine.StructuralSearch/Parsers/PlaceholderParser.cs
@@ -7,7 +7,7 @@ namespace SimpleStateMachine.StructuralSearch
 {
     public class PlaceholderParser : ParserWithLookahead<char, string>, IContextDependent
     {
-        private ParsingContext _context;
+        private IParsingContext _context;
 
         public PlaceholderParser(string name)
         {
@@ -60,7 +60,7 @@ public override bool TryParse(ref ParseState<char> state, ref PooledList<Expecte
             bool res;
             
             // No use look-ahead if placeholder is already defined
-            if (_context.TryGet(Name, out var value))
+            if (_context.TryGetPlaceholder(Name, out var value))
             {
                 res = Parser.String(value).TryParse(ref state, ref expected, out result);
             }
@@ -102,7 +102,7 @@ public override bool TryParse(ref ParseState<char> state, ref PooledList<Expecte
         //     var parser = term.JoinToString().AsMatch();
         //     return parser;
         // }
-        public void SetContext(ParsingContext context)
+        public void SetContext(IParsingContext context)
         {
             _context = context;
         }
diff --git a/src/SimpleStateMachine.StructuralSearch/Parsers/SeriesParser.cs b/src/SimpleStateMachine.StructuralSearch/Parsers/SeriesParser.cs
@@ -9,9 +9,9 @@ public class SeriesParser<TToken, T, R>: Parser<TToken, R>
     {
         private readonly Func<IEnumerable<T>, R> _getResult;
         private readonly IEnumerable<Parser<TToken, T>> _parsers;
-        private readonly ParsingContext _context;
+        private readonly IParsingContext _context;
         private bool _initialized = false;
-        public SeriesParser(ParsingContext context, IEnumerable<Parser<TToken, T>> parsers, Func<IEnumerable<T>, R> getResult)
+        public SeriesParser(IParsingContext context, IEnumerable<Parser<TToken, T>> parsers, Func<IEnumerable<T>, R> getResult)
         {
             _getResult = getResult;
             _parsers = parsers;
diff --git a/src/SimpleStateMachine.StructuralSearch/ParsingContext.cs b/src/SimpleStateMachine.StructuralSearch/ParsingContext.cs
@@ -2,20 +2,20 @@
 
 namespace SimpleStateMachine.StructuralSearch
 {
-    public class ParsingContext
+    public class ParsingContext : IParsingContext
     {
         public Dictionary<string, string> Placeholders { get; } = new();
 
-        public bool TryGet(string name, out string value)
+        public bool TryGetPlaceholder(string name, out string value)
         {
             return Placeholders.TryGetValue(name, out value);
         }
-        
+
         public void AddPlaceholder(string name, string value)
         {
-           Placeholders[name] = value;
+            Placeholders[name] = value;
         }
-        
+
         public string GetPlaceholder(string name)
         {
             return Placeholders[name];
diff --git a/src/SimpleStateMachine.StructuralSearch/Rules/Parameters/PlaceholderParameter.cs b/src/SimpleStateMachine.StructuralSearch/Rules/Parameters/PlaceholderParameter.cs
@@ -2,7 +2,7 @@
 {
     public class PlaceholderParameter : IRuleParameter, IContextDependent
     {
-        private ParsingContext _context;
+        private IParsingContext _context;
         
         public PlaceholderParameter(string name)
         {
@@ -13,15 +13,15 @@ public PlaceholderParameter(string name)
         
         public string GetValue()
         {
-            throw new System.NotImplementedException();
+            return _context.GetPlaceholder(Name);
         }
         
         public override string ToString()
         {
             return $"{Constant.PlaceholderSeparator}{Name}{Constant.PlaceholderSeparator}";
         }
 
-        public void SetContext(ParsingContext context)
+        public void SetContext(IParsingContext context)
         {
             _context = context;
         }
diff --git a/src/SimpleStateMachine.StructuralSearch/StructuralSearch/FindTemplateParser.cs b/src/SimpleStateMachine.StructuralSearch/StructuralSearch/FindTemplateParser.cs
@@ -48,7 +48,7 @@ static FindTemplateParser()
         
         private static readonly Parser<char, IEnumerable<Parser<char, string>>> TemplateParser;
         
-        internal static Parser<char, SourceMatch> ParseTemplate(string str, ParsingContext context)
+        internal static Parser<char, SourceMatch> ParseTemplate(string str, IParsingContext context)
         {
             return TemplateParser.JoinResults(context).ParseOrThrow(str).AsMatch();
         }
diff --git a/src/SimpleStateMachine.StructuralSearch/StructuralSearch/ReplaceTemplateParser.cs b/src/SimpleStateMachine.StructuralSearch/StructuralSearch/ReplaceTemplateParser.cs
@@ -48,10 +48,10 @@ static ReplaceTemplateParser()
 
         private static readonly Parser<char, IEnumerable<IReplaceStep>> TemplateParser;
 
-        internal static IReplaceBuilder ParseTemplate(string str, ParsingContext context)
+        internal static IReplaceBuilder ParseTemplate(string str)
         {
             return TemplateParser
-                .Select(steps => new ReplaceBuilder(context, steps))
+                .Select(steps => new ReplaceBuilder(steps))
                 .ParseOrThrow(str);
         }
     }
diff --git a/src/SimpleStateMachine.StructuralSearch/StructuralSearch/StructuralSearch.cs b/src/SimpleStateMachine.StructuralSearch/StructuralSearch/StructuralSearch.cs
@@ -6,11 +6,11 @@ namespace SimpleStateMachine.StructuralSearch
 {
     public static class StructuralSearch
     {
-        public static Parser<char, SourceMatch> ParseFindTemplate(string template, ParsingContext context) 
+        public static Parser<char, SourceMatch> ParseFindTemplate(string template, IParsingContext context) 
             => FindTemplateParser.ParseTemplate(template, context);
         
-        public static IReplaceBuilder ParseReplaceTemplate(string template, ParsingContext context) 
-            => ReplaceTemplateParser.ParseTemplate(template, context);
+        public static IReplaceBuilder ParseReplaceTemplate(string template) 
+            => ReplaceTemplateParser.ParseTemplate(template);
         
         public static FindRule ParseFindRule(string template) 
             => FindRuleParser.ParseTemplate(template);
diff --git a/src/SimpleStateMachine.StructuralSearch/Templates/ReplaceTemplate/IReplaceBuilder.cs b/src/SimpleStateMachine.StructuralSearch/Templates/ReplaceTemplate/IReplaceBuilder.cs
@@ -5,6 +5,6 @@ namespace SimpleStateMachine.StructuralSearch.ReplaceTemplate
     public interface IReplaceBuilder
     {
         IEnumerable<IReplaceStep> Steps { get; }
-        string Build();
+        string Build(IParsingContext context);
     }
 }
diff --git a/src/SimpleStateMachine.StructuralSearch/Templates/ReplaceTemplate/PlaceholderReplace.cs b/src/SimpleStateMachine.StructuralSearch/Templates/ReplaceTemplate/PlaceholderReplace.cs
@@ -1,17 +1,24 @@
 ﻿namespace SimpleStateMachine.StructuralSearch.ReplaceTemplate
 {
-    public class PlaceholderReplace:IReplaceStep
+    public class PlaceholderReplace : IReplaceStep, IContextDependent
     {
-        public string Name { get; }
+        private IParsingContext _context;
         
+        public string Name { get; }
+
         public PlaceholderReplace(string name)
         {
             Name = name;
         }
-        
+
         public string GetValue()
         {
-            return Name;
+            return _context.GetPlaceholder(Name);
+        }
+
+        public void SetContext(IParsingContext context)
+        {
+            _context = context;
         }
     }
 }
diff --git a/src/SimpleStateMachine.StructuralSearch/Templates/ReplaceTemplate/ReplaceBuilder.cs b/src/SimpleStateMachine.StructuralSearch/Templates/ReplaceTemplate/ReplaceBuilder.cs
@@ -5,24 +5,22 @@ namespace SimpleStateMachine.StructuralSearch.ReplaceTemplate
 {
     public class ReplaceBuilder : IReplaceBuilder
     {
-        private ParsingContext _context;
         public IEnumerable<IReplaceStep> Steps { get; }
 
-        public ReplaceBuilder(ParsingContext context, IEnumerable<IReplaceStep> steps)
+        public ReplaceBuilder(IEnumerable<IReplaceStep> steps)
         {
             Steps = steps;
-            _context = context;
         }
 
-        public string Build()
+        public string Build(IParsingContext context)
         {
             StringBuilder stringBuilder = new StringBuilder();
             
             foreach (var step in Steps)
             {
                 if (step is IContextDependent contextDependentStep)
                 {
-                    contextDependentStep.SetContext(_context);
+                    contextDependentStep.SetContext(context);
                 }
                 
                 stringBuilder.Append(step.GetValue());

Original file line number	Diff line number	Diff line change
`@@ -1 +1 @@`
`1`		`-$var1$ $sign$ $value1$ ? $value1$ : $value2$;`
	`1`	`+$var1$ $sign$ $value1$ ? $value2$ : $value3$;`
Original file line number	Diff line number	Diff line change
`@@ -9,11 +9,11 @@ public static class SourceMatchParserExtensions`
`9`	`9`	`// {`
`10`	`10`	`// return parsers.Select(x => Parsers.Series(x, getResult));`
`11`	`11`	`// }`
`12`		`- public static Parser<char, Parser<char, string>> JoinResults(this Parser<char, IEnumerable<Parser<char, string>>> parsers, ParsingContext context)`
	`12`	`+ public static Parser<char, Parser<char, string>> JoinResults(this Parser<char, IEnumerable<Parser<char, string>>> parsers, IParsingContext context)`
`13`	`13`	`{`
`14`	`14`	`return parsers.Select(x => Parsers.Series(context, x, y => string.Join(string.Empty, y)));`
`15`	`15`	`}`
`16`		`- public static Parser<char, Parser<char, SourceMatch>> JoinResults(this Parser<char, IEnumerable<Parser<char, SourceMatch>>> parsers, ParsingContext context)`
	`16`	`+ public static Parser<char, Parser<char, SourceMatch>> JoinResults(this Parser<char, IEnumerable<Parser<char, SourceMatch>>> parsers, IParsingContext context)`
`17`	`17`	`{`
`18`	`18`	`return parsers.Select(x => Parsers.Series(context, x, y => y.Concatenate()));`
`19`	`19`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2,6 +2,6 @@`
`2`	`2`	`{`
`3`	`3`	`public interface IContextDependent`
`4`	`4`	`{`
`5`		`- void SetContext(ParsingContext context);`
	`5`	`+ void SetContext(IParsingContext context);`
`6`	`6`	`}`
`7`	`7`	`}`
Original file line number	Diff line number	Diff line change
`@@ -78,7 +78,7 @@ public static Parser<TToken, IEnumerable<T>> MapToMany<TToken, T>(Parser<TToken,`
`78`	`78`	`}`
`79`	`79`
`80`	`80`
`81`		`- public static Parser<TToken, R> Series<TToken, T, R>(ParsingContext context, IEnumerable<Parser<TToken, T>> parsers,`
	`81`	`+ public static Parser<TToken, R> Series<TToken, T, R>(IParsingContext context, IEnumerable<Parser<TToken, T>> parsers,`
`82`	`82`	`Func<IEnumerable<T>, R> func)`
`83`	`83`	`{`
`84`	`84`	`if (parsers == null)`
Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,7 @@ namespace SimpleStateMachine.StructuralSearch`
`7`	`7`	`{`
`8`	`8`	`public class PlaceholderParser : ParserWithLookahead<char, string>, IContextDependent`
`9`	`9`	`{`
`10`		`- private ParsingContext _context;`
	`10`	`+ private IParsingContext _context;`
`11`	`11`
`12`	`12`	`public PlaceholderParser(string name)`
`13`	`13`	`{`
`@@ -60,7 +60,7 @@ public override bool TryParse(ref ParseState<char> state, ref PooledList<Expecte`
`60`	`60`	`bool res;`
`61`	`61`
`62`	`62`	`// No use look-ahead if placeholder is already defined`
`63`		`- if (_context.TryGet(Name, out var value))`
	`63`	`+ if (_context.TryGetPlaceholder(Name, out var value))`
`64`	`64`	`{`
`65`	`65`	`res = Parser.String(value).TryParse(ref state, ref expected, out result);`
`66`	`66`	`}`
`@@ -102,7 +102,7 @@ public override bool TryParse(ref ParseState<char> state, ref PooledList<Expecte`
`102`	`102`	`// var parser = term.JoinToString().AsMatch();`
`103`	`103`	`// return parser;`
`104`	`104`	`// }`
`105`		`- public void SetContext(ParsingContext context)`
	`105`	`+ public void SetContext(IParsingContext context)`
`106`	`106`	`{`
`107`	`107`	`_context = context;`
`108`	`108`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,9 +9,9 @@ public class SeriesParser<TToken, T, R>: Parser<TToken, R>`
`9`	`9`	`{`
`10`	`10`	`private readonly Func<IEnumerable<T>, R> _getResult;`
`11`	`11`	`private readonly IEnumerable<Parser<TToken, T>> _parsers;`
`12`		`- private readonly ParsingContext _context;`
	`12`	`+ private readonly IParsingContext _context;`
`13`	`13`	`private bool _initialized = false;`
`14`		`- public SeriesParser(ParsingContext context, IEnumerable<Parser<TToken, T>> parsers, Func<IEnumerable<T>, R> getResult)`
	`14`	`+ public SeriesParser(IParsingContext context, IEnumerable<Parser<TToken, T>> parsers, Func<IEnumerable<T>, R> getResult)`
`15`	`15`	`{`
`16`	`16`	`_getResult = getResult;`
`17`	`17`	`_parsers = parsers;`