Apply replace rules and replace for files

RomanSoloweow · RomanSoloweow · commit 7406eebb2743 · 2022-05-25T01:11:19.000+03:00
diff --git a/src/SimpleStateMachine.StructuralSearch.Tests/Mock/EmptyParsingContext.cs b/src/SimpleStateMachine.StructuralSearch.Tests/Mock/EmptyParsingContext.cs
@@ -26,7 +26,7 @@ public IReadOnlyDictionary<string, IPlaceholder> SwitchOnNew()
             throw new System.NotImplementedException();
         }
 
-        public void Set(IReadOnlyDictionary<string, IPlaceholder> placeholders)
+        public void Fill(IReadOnlyDictionary<string, IPlaceholder> placeholders)
         {
             throw new System.NotImplementedException();
         }
diff --git a/src/SimpleStateMachine.StructuralSearch.Tests/StructurSearchParserTests.cs b/src/SimpleStateMachine.StructuralSearch.Tests/StructurSearchParserTests.cs
@@ -23,5 +23,25 @@ public static void StructuralSearchShouldBeSuccess(string exampleName, string ex
             var matches = parser.Parse(ref context);
             Assert.Equal(matches.Count(), matchesCount);
         }
+        
+        [Theory]
+        // [InlineData("AssignmentNullUnionOperator")]
+        [InlineData("NullUnionOperator", "Examples/NullUnionOperator.cs", 2)]
+        [InlineData("TernaryOperator", "Examples/TernaryOperator.cs", 3)]
+        public static void StructuralSearchShouldBe(string exampleName, string exampleFilePath, int matchesCount)
+        {
+            var config = ConfigurationMock.GetConfigurationFromFiles(exampleName);
+            var parser = new StructuralSearchParser(config);
+
+            var fileInfo = new FileInfo(exampleFilePath);
+            var input = Input.File(fileInfo);
+            IParsingContext context = new ParsingContext(input);
+            var matches = parser.Parse(ref context);
+            matches = parser.ApplyFindRule(ref context, matches);
+            matches = parser.ApplyReplaceRule(ref context, matches);
+            parser.Replace(ref context, matches);
+            
+            Assert.Equal(matches.Count(), matchesCount);
+        }
     }
 }
diff --git a/src/SimpleStateMachine.StructuralSearch/FindParser.cs b/src/SimpleStateMachine.StructuralSearch/FindParser.cs
@@ -17,9 +17,9 @@ public FindParser(SeriesParser parser)
             Parser = parser;
         }
 
-        public IEnumerable<FindParserMatch> Parse(ref IParsingContext context)
+        public IEnumerable<FindParserResult> Parse(ref IParsingContext context)
         {
-            List<FindParserMatch> matches = new();
+            List<FindParserResult> matches = new();
             StringBuilder res = new();
             Parser.SetContext(ref context);
             
@@ -29,7 +29,7 @@ public IEnumerable<FindParserMatch> Parse(ref IParsingContext context)
                 .ThenInvoke(match =>
                 {
                     var placeholders= parsingContext.SwitchOnNew();
-                    matches.Add(new FindParserMatch(match, placeholders));
+                    matches.Add(new FindParserResult(match, placeholders));
                 })
                 .ThenReturn(Unit.Value)
                 .Try();
diff --git a/src/SimpleStateMachine.StructuralSearch/FindParserResult.cs b/src/SimpleStateMachine.StructuralSearch/FindParserResult.cs
@@ -2,4 +2,4 @@
 
 namespace SimpleStateMachine.StructuralSearch;
 
-public readonly record struct FindParserMatch(Match<string> Match, IReadOnlyDictionary<string, IPlaceholder> Placeholders);
+public readonly record struct FindParserResult(Match<string> Match, IReadOnlyDictionary<string, IPlaceholder> Placeholders);
diff --git a/src/SimpleStateMachine.StructuralSearch/IFindParser.cs b/src/SimpleStateMachine.StructuralSearch/IFindParser.cs
@@ -7,6 +7,6 @@ namespace SimpleStateMachine.StructuralSearch
 {
     public interface IFindParser
     {
-        IEnumerable<FindParserMatch> Parse(ref IParsingContext context);
+        IEnumerable<FindParserResult> Parse(ref IParsingContext context);
     }
 }
diff --git a/src/SimpleStateMachine.StructuralSearch/IParsingContext.cs b/src/SimpleStateMachine.StructuralSearch/IParsingContext.cs
@@ -13,7 +13,7 @@ public interface IParsingContext
         IPlaceholder GetPlaceholder(string name);
         
         IReadOnlyDictionary<string, IPlaceholder> SwitchOnNew();
-        void Set(IReadOnlyDictionary<string, IPlaceholder>placeholders);
+        void Fill(IReadOnlyDictionary<string, IPlaceholder>placeholders);
         void Clear();
     }
 }
diff --git a/src/SimpleStateMachine.StructuralSearch/Input/EmptyInput.cs b/src/SimpleStateMachine.StructuralSearch/Input/EmptyInput.cs
@@ -9,7 +9,7 @@ public Result<char, T> ParseBy<T>(Parser<char, T> parser)
             throw new System.NotImplementedException();
         }
 
-        public void Replace(Match<string> match, string value)
+        public void ReplaceAsync(Match<string> match, string value)
         {
             throw new System.NotImplementedException();
         }
diff --git a/src/SimpleStateMachine.StructuralSearch/Input/FileInput.cs b/src/SimpleStateMachine.StructuralSearch/Input/FileInput.cs
@@ -19,14 +19,18 @@ public Result<char, T> ParseBy<T>(Parser<char, T> parser)
             return parser.Parse(FileInfo.OpenText());
         }
 
-        public void Replace(Match<string> match, string value)
+        public void ReplaceAsync(Match<string> match, string value)
         {
-            using var valueReader = new StringReader(value);
-            using var streamWriter = new StreamWriter(FileInfo.FullName);
-            var emptyStart = match.Offset.Start + match.Lenght;
-            var emptyEnd = match.Offset.End;
-            valueReader.CopyPartTo(streamWriter, match.Offset.Start, match.Lenght);
-            
+            var text = File.ReadAllText(Path);
+            text = text.Replace(match.Value, value);
+            File.WriteAllText(Path, text);
+
+            // using var valueReader = new StringReader(value);
+            // using var streamWriter = new StreamWriter(FileInfo.FullName);
+            // var emptyStart = match.Offset.Start + match.Lenght;
+            // var emptyEnd = match.Offset.End;
+            // valueReader.CopyPartTo(streamWriter, match.Offset.Start, match.Lenght);
+
             //return (emptyStart, emptyEnd);
         }
 
diff --git a/src/SimpleStateMachine.StructuralSearch/Input/IInput.cs b/src/SimpleStateMachine.StructuralSearch/Input/IInput.cs
@@ -5,7 +5,7 @@ namespace SimpleStateMachine.StructuralSearch
     public interface IInput
     {
         Result<char, T> ParseBy<T>(Parser<char, T> parser);
-        void Replace(Match<string> match, string value);
+        void ReplaceAsync(Match<string> match, string value);
         
         string Extension { get; }
         string Path { get; }
diff --git a/src/SimpleStateMachine.StructuralSearch/Input/StringInput.cs b/src/SimpleStateMachine.StructuralSearch/Input/StringInput.cs
@@ -16,7 +16,7 @@ public Result<char, T> ParseBy<T>(Parser<char, T> parser)
             return parser.Parse(Input);
         }
 
-        public void Replace(Match<string> match, string value)
+        public void ReplaceAsync(Match<string> match, string value)
         {
             throw new System.NotImplementedException();
         }
diff --git a/src/SimpleStateMachine.StructuralSearch/ParsingContext.cs b/src/SimpleStateMachine.StructuralSearch/ParsingContext.cs
@@ -37,7 +37,7 @@ public IReadOnlyDictionary<string, IPlaceholder> SwitchOnNew()
             return placeholders;
         }
 
-        public void Set(IReadOnlyDictionary<string, IPlaceholder> placeholders)
+        public void Fill(IReadOnlyDictionary<string, IPlaceholder> placeholders)
         {
             Clear();
             
diff --git a/src/SimpleStateMachine.StructuralSearch/Placeholder/ReplacedPlaceholder.cs b/src/SimpleStateMachine.StructuralSearch/Placeholder/ReplacedPlaceholder.cs
@@ -0,0 +1,23 @@
+﻿namespace SimpleStateMachine.StructuralSearch;
+
+public class ReplacedPlaceholder : IPlaceholder
+{
+    public ReplacedPlaceholder(IPlaceholder placeholder, string value)
+    {
+        Name = placeholder.Name;
+        Value = value;
+        Lenght = value.Length;
+        Line = placeholder.Line;
+        Column = placeholder.Column;
+        Offset = placeholder.Offset;
+        Input = placeholder.Input;
+    }
+    
+    public string Name { get; }
+    public string Value { get; }
+    public int Lenght { get; }
+    public LinePosition Line { get; }
+    public ColumnPosition Column { get; }
+    public OffsetPosition Offset { get; }
+    public IInput Input { get; }
+}
diff --git a/src/SimpleStateMachine.StructuralSearch/Rules/ReplaceRule/ReplaceRule.cs b/src/SimpleStateMachine.StructuralSearch/Rules/ReplaceRule/ReplaceRule.cs
@@ -8,19 +8,19 @@ namespace SimpleStateMachine.StructuralSearch
 {
     public class ReplaceRule
     {
-        public IRule FindRule { get; }
+        public IRule ConditionRule { get; }
         
         public IEnumerable<ReplaceSubRule> Rules { get; }
         
-        public ReplaceRule(IRule findRule, IEnumerable<ReplaceSubRule> rules)
+        public ReplaceRule(IRule conditionRule, IEnumerable<ReplaceSubRule> rules)
         {
-            FindRule = findRule;
+            ConditionRule = conditionRule;
             Rules = rules;
         }
         
         public override string ToString()
         {
-            return $"{FindRule}{Constant.Space}{Constant.Then}{Constant.Space}{string.Join(Constant.Comma, Rules)}";
+            return $"{ConditionRule}{Constant.Space}{Constant.Then}{Constant.Space}{string.Join(Constant.Comma, Rules)}";
         } 
     }
 }
diff --git a/src/SimpleStateMachine.StructuralSearch/StructuralSearchParser.cs b/src/SimpleStateMachine.StructuralSearch/StructuralSearchParser.cs
@@ -34,18 +34,18 @@ public StructuralSearchParser(Configuration configuration)
                 .Select(StructuralSearch.ParseReplaceRule);
         }
 
-        public IEnumerable<FindParserMatch> Parse(ref IParsingContext context)
+        public IEnumerable<FindParserResult> Parse(ref IParsingContext context)
         {
             var matches = FindParser.Parse(ref context);
             return matches;
         }
 
-        public IEnumerable<FindParserMatch> ApplyFindRule(ref IParsingContext context, IEnumerable<FindParserMatch> matches)
+        public IEnumerable<FindParserResult> ApplyFindRule(ref IParsingContext context, IEnumerable<FindParserResult> matches)
         {
-            var result = new List<FindParserMatch>();
+            var result = new List<FindParserResult>();
             foreach (var match in matches)
             {
-                context.Set(match.Placeholders);
+                context.Fill(match.Placeholders);
                 var all = FindRules.All(x => x.Execute());
                 if (all)
                 {
@@ -55,34 +55,54 @@ public IEnumerable<FindParserMatch> ApplyFindRule(ref IParsingContext context, I
             
             return result;
         }
-        public void ApplyReplaceRule(ref IParsingContext context, IEnumerable<FindParserMatch> matches)
+        public IEnumerable<FindParserResult> ApplyReplaceRule(ref IParsingContext context, IEnumerable<FindParserResult> matches)
         {
-            // var result = new List<FindParserMatch>();
-            // foreach (var match in matches)
-            // {
-            //     context.Set(match.Placeholders);
-            //     
-            //     var rules = ReplaceRules
-            //         .Where(x => x.FindRule.Execute())
-            //         .SelectMany(x => x.Rules);
-            //     
-            //     var placeHolder = match.Placeholders
-            //         .ToDictionary(x=> x.Key, x=> x.Value);
-            //  
-            //     foreach (var rule in rules)
-            //     {
-            //         placeHolder[rule.Placeholder.Name].Value 
-            //     }
-            // }
-            //
-            // return result;
+            var result = new List<FindParserResult>();
+            
+            foreach (var match in matches)
+            {
+                var placeholders = match.Placeholders
+                    .ToDictionary(x => x.Key, 
+                    x => x.Value);
+                
+                context.Fill(match.Placeholders);
+                
+                var rules = ReplaceRules
+                    .Where(x => x.ConditionRule.Execute())
+                    .SelectMany(x => x.Rules);
+
+                foreach (var rule in rules)
+                {
+                    var name = rule.Placeholder.Name;
+                    var placeholder = placeholders[name];
+                    var value = rule.Parameter.GetValue();
+                    placeholders[name] = new ReplacedPlaceholder(placeholder, value);
+                }
+                
+                result.Add(match with { Placeholders = placeholders });
+            }
+            
+            return result;
         }
-        public void Replace(FindParserMatch context)
+        public void Replace(ref IParsingContext context, FindParserResult parserResult)
         {
+            context.Fill(parserResult.Placeholders);
+            var replaceText = ReplaceBuilder.Build(context);
+            context.Input.ReplaceAsync(parserResult.Match, replaceText);
+            //ReplaceBuilder.Build(context);
+            // context.
+            //FindParser.Parse(context, context.File.Data);
+        }
+        public void Replace(ref IParsingContext context, IEnumerable<FindParserResult> parserResults)
+        {
+            foreach (var parserResult in parserResults)
+            {
+                Replace(ref context, parserResult);
+            }
+            
             //ReplaceBuilder.Build(context);
             // context.
             //FindParser.Parse(context, context.File.Data);
         }
-        
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,7 @@ public IReadOnlyDictionary<string, IPlaceholder> SwitchOnNew()`
`26`	`26`	`throw new System.NotImplementedException();`
`27`	`27`	`}`
`28`	`28`
`29`		`- public void Set(IReadOnlyDictionary<string, IPlaceholder> placeholders)`
	`29`	`+ public void Fill(IReadOnlyDictionary<string, IPlaceholder> placeholders)`
`30`	`30`	`{`
`31`	`31`	`throw new System.NotImplementedException();`
`32`	`32`	`}`
Original file line number	Diff line number	Diff line change
`@@ -17,9 +17,9 @@ public FindParser(SeriesParser parser)`
`17`	`17`	`Parser = parser;`
`18`	`18`	`}`
`19`	`19`
`20`		`- public IEnumerable<FindParserMatch> Parse(ref IParsingContext context)`
	`20`	`+ public IEnumerable<FindParserResult> Parse(ref IParsingContext context)`
`21`	`21`	`{`
`22`		`- List<FindParserMatch> matches = new();`
	`22`	`+ List<FindParserResult> matches = new();`
`23`	`23`	`StringBuilder res = new();`
`24`	`24`	`Parser.SetContext(ref context);`
`25`	`25`
`@@ -29,7 +29,7 @@ public IEnumerable<FindParserMatch> Parse(ref IParsingContext context)`
`29`	`29`	`.ThenInvoke(match =>`
`30`	`30`	`{`
`31`	`31`	`var placeholders= parsingContext.SwitchOnNew();`
`32`		`- matches.Add(new FindParserMatch(match, placeholders));`
	`32`	`+ matches.Add(new FindParserResult(match, placeholders));`
`33`	`33`	`})`
`34`	`34`	`.ThenReturn(Unit.Value)`
`35`	`35`	`.Try();`
Original file line number	Diff line number	Diff line change
`@@ -2,4 +2,4 @@`
`2`	`2`
`3`	`3`	`namespace SimpleStateMachine.StructuralSearch;`
`4`	`4`
`5`		`-public readonly record struct FindParserMatch(Match<string> Match, IReadOnlyDictionary<string, IPlaceholder> Placeholders);`
	`5`	`+public readonly record struct FindParserResult(Match<string> Match, IReadOnlyDictionary<string, IPlaceholder> Placeholders);`
Original file line number	Diff line number	Diff line change
`@@ -7,6 +7,6 @@ namespace SimpleStateMachine.StructuralSearch`
`7`	`7`	`{`
`8`	`8`	`public interface IFindParser`
`9`	`9`	`{`
`10`		`- IEnumerable<FindParserMatch> Parse(ref IParsingContext context);`
	`10`	`+ IEnumerable<FindParserResult> Parse(ref IParsingContext context);`
`11`	`11`	`}`
`12`	`12`	`}`
Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,7 @@ public interface IParsingContext`
`13`	`13`	`IPlaceholder GetPlaceholder(string name);`
`14`	`14`
`15`	`15`	`IReadOnlyDictionary<string, IPlaceholder> SwitchOnNew();`
`16`		`- void Set(IReadOnlyDictionary<string, IPlaceholder>placeholders);`
	`16`	`+ void Fill(IReadOnlyDictionary<string, IPlaceholder>placeholders);`
`17`	`17`	`void Clear();`
`18`	`18`	`}`
`19`	`19`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@ public Result<char, T> ParseBy<T>(Parser<char, T> parser)`
`9`	`9`	`throw new System.NotImplementedException();`
`10`	`10`	`}`
`11`	`11`
`12`		`- public void Replace(Match<string> match, string value)`
	`12`	`+ public void ReplaceAsync(Match<string> match, string value)`
`13`	`13`	`{`
`14`	`14`	`throw new System.NotImplementedException();`
`15`	`15`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@ namespace SimpleStateMachine.StructuralSearch`
`5`	`5`	`public interface IInput`
`6`	`6`	`{`
`7`	`7`	`Result<char, T> ParseBy<T>(Parser<char, T> parser);`
`8`		`- void Replace(Match<string> match, string value);`
	`8`	`+ void ReplaceAsync(Match<string> match, string value);`
`9`	`9`
`10`	`10`	`string Extension { get; }`
`11`	`11`	`string Path { get; }`
Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@ public Result<char, T> ParseBy<T>(Parser<char, T> parser)`
`16`	`16`	`return parser.Parse(Input);`
`17`	`17`	`}`
`18`	`18`
`19`		`- public void Replace(Match<string> match, string value)`
	`19`	`+ public void ReplaceAsync(Match<string> match, string value)`
`20`	`20`	`{`
`21`	`21`	`throw new System.NotImplementedException();`
`22`	`22`	`}`