Parsing context as ref, dictionary for rules in StructuralSearchParser

RomanSoloweow · RomanSoloweow · commit a5e51af816d0 · 2022-04-16T03:24:39.000+03:00
diff --git a/src/SimpleStateMachine.StructuralSearch.Tests/FindTemplateTests.cs b/src/SimpleStateMachine.StructuralSearch.Tests/FindTemplateTests.cs
@@ -29,11 +29,10 @@ public void SourceParsingBeFindTemplateShouldBeSuccess(string templatePath, stri
             var findTemplate = File.ReadAllText(templatePath);
             var source = File.ReadAllText(sourcePath);
             var findParser = StructuralSearch.ParseFindTemplate(findTemplate);
-            var parsingContext = new ParsingContext();
-            var result = findParser.Parse(parsingContext, source);
+            IParsingContext parsingContext = new ParsingContext();
+            var result = findParser.Parse(ref parsingContext, source);
             
             Assert.NotNull(findParser);
-            Assert.NotNull(result);
             Assert.NotNull(result.Value);
             Assert.Equal(result.Lenght, source.Length);
         }
diff --git a/src/SimpleStateMachine.StructuralSearch.Tests/Mock/EmptyParsingContext.cs b/src/SimpleStateMachine.StructuralSearch.Tests/Mock/EmptyParsingContext.cs
@@ -2,6 +2,8 @@
 {
     public class EmptyParsingContext : IParsingContext
     {
+        public FileProperty File { get; } = new FileProperty();
+
         public bool TryGetPlaceholder(string name, out Placeholder value)
         {
             throw new System.NotImplementedException();
diff --git a/src/SimpleStateMachine.StructuralSearch.Tests/PlaceholderParserTests.cs b/src/SimpleStateMachine.StructuralSearch.Tests/PlaceholderParserTests.cs
@@ -18,9 +18,9 @@ public void FindTemplateShouldBeNotEmpty()
         [InlineData("($test$)", "(value (test) )", "value (test) ")]
         public void TemplateParsingShouldBeSuccess(string template, string source, string result)
         {
-            var parsingContext = new ParsingContext();
+            IParsingContext parsingContext = new ParsingContext();
             var templateParser = StructuralSearch.ParseFindTemplate(template);
-            var res = templateParser.Parse(parsingContext, source);
+            var res = templateParser.Parse(ref parsingContext, source);
             var placeholder = parsingContext.GetPlaceholder("test");
             
             Assert.Equal(placeholder.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 parsingContext = new ParsingContext();
+            IParsingContext parsingContext = new ParsingContext();
             var templateParser = StructuralSearch.ParseFindTemplate(template);
-            var res = templateParser.Parse(parsingContext, source);
+            templateParser.Parse(ref parsingContext, source);
              
             
             // var templateStr = File.ReadAllText(templatePath);
diff --git a/src/SimpleStateMachine.StructuralSearch.Tests/ReplaceRuleParserTests.cs b/src/SimpleStateMachine.StructuralSearch.Tests/ReplaceRuleParserTests.cs
@@ -7,20 +7,34 @@ namespace SimpleStateMachine.StructuralSearch.Tests
     public class ReplaceRuleParserTests
     {
         [Theory]
-        [InlineData("equals $var$", "$var$")]
-        [InlineData("equals \"\\$\"", "\"\\$\"")]
-        [InlineData("Not equals $var$.Lenght", "$var$.Lenght")]
-        [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 ReplaceRuleParsingShouldBeSuccess(string findRule, string replaceRule)
+        [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 placeholder = "$var$";
             var replaceRuleStr = $"{placeholder} {findRule} => {replaceRule}";
             var rule = StructuralSearch.ParseReplaceRule(replaceRuleStr);
-            var _ruleStr = rule.ToString().ToLower();
+            var ruleStr = rule.ToString().ToLower();
             Assert.NotNull(rule);
-            Assert.Equal(_ruleStr, replaceRuleStr.ToLower());
+            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")]
+        public void ReplaceRuleParsingShouldBeSuccess(string replaceRule)
+        {
+            var rule = StructuralSearch.ParseReplaceRule(replaceRule);
+            var ruleStr = rule.ToString().ToLower();
+            Assert.NotNull(rule);
+            Assert.Equal(ruleStr, replaceRule.ToLower());
         }
     }
 }
diff --git a/src/SimpleStateMachine.StructuralSearch/Extensions/IEnumerableExtensions.cs b/src/SimpleStateMachine.StructuralSearch/Extensions/IEnumerableExtensions.cs
@@ -0,0 +1,13 @@
+﻿using System.Collections.Generic;
+using System.Linq;
+
+namespace SimpleStateMachine.StructuralSearch.Extensions
+{
+    public static class IEnumerableExtensions
+    {
+        public static IEnumerable<T> EmptyIfNull<T>(this IEnumerable<T>? enumerable)
+        {
+            return enumerable ?? Enumerable.Empty<T>();
+        }
+    }
+}
diff --git a/src/SimpleStateMachine.StructuralSearch/FindParser.cs b/src/SimpleStateMachine.StructuralSearch/FindParser.cs
@@ -12,9 +12,9 @@ public FindParser(SeriesParser parser)
             Parser = parser;
         }
 
-        public SourceMatch Parse(IParsingContext context, string input)
+        public SourceMatch Parse(ref IParsingContext context, string input)
         {
-            Parser.SetContext(context);
+            Parser.SetContext(ref context);
             var result = Parser.Select(x => string.Join(string.Empty, x)).AsMatch().Parse(input);
             
             return result.Success ? result.Value : SourceMatch.Empty;
diff --git a/src/SimpleStateMachine.StructuralSearch/IFindParser.cs b/src/SimpleStateMachine.StructuralSearch/IFindParser.cs
@@ -6,6 +6,6 @@ namespace SimpleStateMachine.StructuralSearch
 {
     public interface IFindParser
     {
-        SourceMatch Parse(IParsingContext context, string input);
+        SourceMatch Parse(ref IParsingContext context, string input);
     }
 }
diff --git a/src/SimpleStateMachine.StructuralSearch/IParsingContext.cs b/src/SimpleStateMachine.StructuralSearch/IParsingContext.cs
@@ -2,6 +2,7 @@
 {
     public interface IParsingContext
     {
+        FileProperty File { get; }
         bool TryGetPlaceholder(string name, out Placeholder value);
 
         void AddPlaceholder(Placeholder placeholder);
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(IParsingContext context);
+        void SetContext(ref IParsingContext context);
     }
 }
diff --git a/src/SimpleStateMachine.StructuralSearch/Parsers/PlaceholderParser.cs b/src/SimpleStateMachine.StructuralSearch/Parsers/PlaceholderParser.cs
@@ -79,7 +79,6 @@ public override bool TryParse(ref ParseState<char> state, ref PooledList<Expecte
                         context: _context,
                         name: Name,
                         value: result,
-                        file: null,
                         line: new LineProperty(oldPos.Line, oldPos.Line + posDelta.Lines),
                         column: new ColumnProperty(oldPos.Col, oldPos.Col + posDelta.Cols),
                         offset: new OffsetProperty(oldOffset, newOffset)));
@@ -117,7 +116,7 @@ public override bool TryParse(ref ParseState<char> state, ref PooledList<Expecte
         //     var parser = term.JoinToString().AsMatch();
         //     return parser;
         // }
-        public void SetContext(IParsingContext context)
+        public void SetContext(ref IParsingContext context)
         {
             _context = context;
         }
diff --git a/src/SimpleStateMachine.StructuralSearch/ParsingContext.cs b/src/SimpleStateMachine.StructuralSearch/ParsingContext.cs
@@ -6,6 +6,8 @@ public class ParsingContext : IParsingContext
     {
         public Dictionary<string, Placeholder> Placeholders { get; } = new();
 
+        public FileProperty File { get; }
+
         public bool TryGetPlaceholder(string name, out Placeholder value)
         {
             return Placeholders.TryGetValue(name, out value);
diff --git a/src/SimpleStateMachine.StructuralSearch/Placeholder/Placeholder.cs b/src/SimpleStateMachine.StructuralSearch/Placeholder/Placeholder.cs
@@ -3,13 +3,12 @@
     public class Placeholder
     {
         private IParsingContext _context;
-        public Placeholder(IParsingContext context, string name, string value, FileProperty file, LineProperty line, ColumnProperty column, OffsetProperty offset)
+        public Placeholder(IParsingContext context, string name, string value, LineProperty line, ColumnProperty column, OffsetProperty offset)
         {
             _context = context;
             Name = name;
             Lenght = value.Length;
             Value = value;
-            File = file;
             Line = line;
             Column = column;
             Offset = offset;
@@ -18,7 +17,7 @@ public Placeholder(IParsingContext context, string name, string value, FilePrope
         public readonly string Name;
         public readonly string Value;
         public readonly int Lenght;
-        public readonly FileProperty File;
+        public FileProperty File => _context.File;
         public readonly LineProperty Line;
         public readonly ColumnProperty Column;
         public readonly OffsetProperty Offset;
@@ -30,7 +29,6 @@ public static Placeholder CreateEmpty(IParsingContext context, string name, stri
                 context: context,
                 name: name,
                 value: value,
-                file: null,
                 line: null,
                 column: null,
                 offset: null);
diff --git a/src/SimpleStateMachine.StructuralSearch/Rules/FindRule/FindRule.cs b/src/SimpleStateMachine.StructuralSearch/Rules/FindRule/FindRule.cs
@@ -2,11 +2,11 @@
 {
     public class FindRule
     {
-        public IRuleParameter Placeholder { get; }
+        public PlaceholderParameter Placeholder { get; }
         
         private IRule _rule { get; }
 
-        public FindRule(IRuleParameter placeholder, IRule rule)
+        public FindRule(PlaceholderParameter placeholder, IRule rule)
         {
             Placeholder = placeholder;
             _rule = rule;
diff --git a/src/SimpleStateMachine.StructuralSearch/Rules/Parameters/ParametersParser.cs b/src/SimpleStateMachine.StructuralSearch/Rules/Parameters/ParametersParser.cs
@@ -7,13 +7,16 @@ namespace SimpleStateMachine.StructuralSearch
 {
     public static class ParametersParser
     {
-        public static readonly Parser<char, IRuleParameter> PlaceholderParameter =
+        public static readonly Parser<char, PlaceholderParameter> PlaceholderParameter =
             CommonTemplateParser.Placeholder
                 .Select(x => new PlaceholderParameter(x))
-                .As<char, PlaceholderParameter, IRuleParameter>()
                 .TrimStart()
                 .Try();
-        
+
+        public static readonly Parser<char, IRuleParameter> PlaceholderRuleParameter =
+            PlaceholderParameter
+                .As<char, PlaceholderParameter, IRuleParameter>();
+
         public static readonly Parser<char, IRuleParameter> StringParameter =
             CommonParser.Escaped(Constant.DoubleQuotes, Constant.PlaceholderSeparator)
                 .Or(Parser.AnyCharExcept(Constant.DoubleQuotes, Constant.PlaceholderSeparator))
@@ -24,7 +27,7 @@ public static class ParametersParser
                 .Try();
         
         public static readonly Parser<char, IRuleParameter> StringFormatParameter =
-            Parser.OneOf(StringParameter, PlaceholderPropertyParser.PlaceholderPropertyParameter, PlaceholderParameter)
+            Parser.OneOf(StringParameter, PlaceholderPropertyParser.PlaceholderPropertyParameter, PlaceholderRuleParameter)
                 .AtLeastOnce()
                 .Between(CommonParser.DoubleQuotes)
                 .Select(parameters => new StringFormatParameter(parameters))
@@ -33,7 +36,7 @@ public static class ParametersParser
                 .Try();
         
         public static readonly Parser<char, IRuleParameter> Parameter =
-            Parser.OneOf(PlaceholderPropertyParser.PlaceholderPropertyParameter, PlaceholderParameter, StringFormatParameter)
+            Parser.OneOf(PlaceholderPropertyParser.PlaceholderPropertyParameter, PlaceholderRuleParameter, StringFormatParameter)
                 .TrimStart()
                 .Try();
 
diff --git a/src/SimpleStateMachine.StructuralSearch/Rules/Parameters/PlaceholderParameter.cs b/src/SimpleStateMachine.StructuralSearch/Rules/Parameters/PlaceholderParameter.cs
@@ -26,7 +26,7 @@ public override string ToString()
             return $"{Constant.PlaceholderSeparator}{Name}{Constant.PlaceholderSeparator}";
         }
 
-        public void SetContext(IParsingContext context)
+        public void SetContext(ref IParsingContext context)
         {
             _context = context;
         }
diff --git a/src/SimpleStateMachine.StructuralSearch/SeriesParser.cs b/src/SimpleStateMachine.StructuralSearch/SeriesParser.cs
@@ -62,13 +62,13 @@ void SkipLookedParsers(Parser<char, string> parser, ref ParseState<char> state)
             return true;
         }
         
-        public void SetContext(IParsingContext parsingContext)
+        public void SetContext(ref IParsingContext parsingContext)
         {
             foreach (var parser in Parsers)
             {
                 if (parser is IContextDependent element)
                 {
-                    element.SetContext(parsingContext);
+                    element.SetContext(ref parsingContext);
                 }
             }
         }
diff --git a/src/SimpleStateMachine.StructuralSearch/StructuralSearchParser.cs b/src/SimpleStateMachine.StructuralSearch/StructuralSearchParser.cs
@@ -1,6 +1,8 @@
 ﻿
 using System.Collections.Generic;
+using System.Linq;
 using SimpleStateMachine.StructuralSearch.Configurations;
+using SimpleStateMachine.StructuralSearch.Extensions;
 using SimpleStateMachine.StructuralSearch.ReplaceTemplate;
 using SimpleStateMachine.StructuralSearch.Rules;
 
@@ -10,15 +12,38 @@ public class StructuralSearchParser
     {
         public IFindParser FindParser { get; set; }
 
-        public List<FindRule> FindRules { get; set; }
+        public Dictionary<string, FindRule> FindRules { get; set; }
 
         public IReplaceBuilder ReplaceBuilder { get; set; }
 
-        public List<ReplaceRule> ReplaceRules { get; set; }
+        public Dictionary<string, ReplaceRule> ReplaceRules { get; set; }
         
         public StructuralSearchParser(Configuration configuration)
         {
+            FindParser = StructuralSearch.ParseFindTemplate(configuration.FindTemplate);
             
+            FindRules = configuration.FindRules
+                .EmptyIfNull()
+                .Select(StructuralSearch.ParseFindRule)
+                .ToDictionary(x => x.Placeholder.Name, x => x);
+            
+            ReplaceBuilder = StructuralSearch.ParseReplaceTemplate(configuration.ReplaceTemplate);
+            
+            ReplaceRules = configuration.ReplaceRules
+                .EmptyIfNull()
+                .Select(StructuralSearch.ParseReplaceRule)
+                .ToDictionary(x => x.FindRule.Placeholder.Name, x => x);
+        }
+
+        public void Parse(ref IParsingContext context)
+        {
+            FindParser.Parse(ref context, context.File.Data);
+        }
+        
+        public void Replace(ref IParsingContext context)
+        {
+            ReplaceBuilder.Build(context);
+            //FindParser.Parse(context, context.File.Data);
         }
     }
 }
diff --git a/src/SimpleStateMachine.StructuralSearch/Templates/ReplaceTemplate/PlaceholderReplace.cs b/src/SimpleStateMachine.StructuralSearch/Templates/ReplaceTemplate/PlaceholderReplace.cs
@@ -16,7 +16,7 @@ public string GetValue()
             return _context.GetPlaceholder(Name).Value;
         }
 
-        public void SetContext(IParsingContext context)
+        public void SetContext(ref IParsingContext context)
         {
             _context = context;
         }
diff --git a/src/SimpleStateMachine.StructuralSearch/Templates/ReplaceTemplate/ReplaceBuilder.cs b/src/SimpleStateMachine.StructuralSearch/Templates/ReplaceTemplate/ReplaceBuilder.cs
@@ -20,7 +20,7 @@ public string Build(IParsingContext context)
             {
                 if (step is IContextDependent contextDependentStep)
                 {
-                    contextDependentStep.SetContext(context);
+                    contextDependentStep.SetContext(ref context);
                 }
                 
                 stringBuilder.Append(step.GetValue());

Original file line number	Diff line number	Diff line change
`@@ -2,6 +2,8 @@`
`2`	`2`	`{`
`3`	`3`	`public class EmptyParsingContext : IParsingContext`
`4`	`4`	`{`
	`5`	`+ public FileProperty File { get; } = new FileProperty();`
	`6`	`+`
`5`	`7`	`public bool TryGetPlaceholder(string name, out Placeholder value)`
`6`	`8`	`{`
`7`	`9`	`throw new System.NotImplementedException();`
Original file line number	Diff line number	Diff line change
`@@ -12,9 +12,9 @@ public FindParser(SeriesParser parser)`
`12`	`12`	`Parser = parser;`
`13`	`13`	`}`
`14`	`14`
`15`		`- public SourceMatch Parse(IParsingContext context, string input)`
	`15`	`+ public SourceMatch Parse(ref IParsingContext context, string input)`
`16`	`16`	`{`
`17`		`- Parser.SetContext(context);`
	`17`	`+ Parser.SetContext(ref context);`
`18`	`18`	`var result = Parser.Select(x => string.Join(string.Empty, x)).AsMatch().Parse(input);`
`19`	`19`
`20`	`20`	`return result.Success ? result.Value : SourceMatch.Empty;`
Original file line number	Diff line number	Diff line change
`@@ -6,6 +6,6 @@ namespace SimpleStateMachine.StructuralSearch`
`6`	`6`	`{`
`7`	`7`	`public interface IFindParser`
`8`	`8`	`{`
`9`		`- SourceMatch Parse(IParsingContext context, string input);`
	`9`	`+ SourceMatch Parse(ref IParsingContext context, string input);`
`10`	`10`	`}`
`11`	`11`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2,6 +2,7 @@`
`2`	`2`	`{`
`3`	`3`	`public interface IParsingContext`
`4`	`4`	`{`
	`5`	`+ FileProperty File { get; }`
`5`	`6`	`bool TryGetPlaceholder(string name, out Placeholder value);`
`6`	`7`
`7`	`8`	`void AddPlaceholder(Placeholder placeholder);`
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(IParsingContext context);`
	`5`	`+ void SetContext(ref IParsingContext context);`
`6`	`6`	`}`
`7`	`7`	`}`