Output interface, All rules and parameters is IContextDependent

RomanSoloweow · RomanSoloweow · commit 2a714a6aa739 · 2022-05-25T03:20:55.000+03:00
diff --git a/src/SimpleStateMachine.StructuralSearch.Tests/FindRuleParserTests.cs b/src/SimpleStateMachine.StructuralSearch.Tests/FindRuleParserTests.cs
@@ -62,8 +62,8 @@ public void FindRuleExprParsingShouldBeEqualsCustomResult(int number, string rul
             Assert.Equal(_ruleStr, customResult.ToLower());
         }
         [Theory]
-        [InlineData("FindRule/NullUnionOperator.txt", "$sign$ In \"Is\",\"==\",\"!=\",\"is not\"",  "$value$ In $value1$,\"$value1$\\.Value\",$value2$,\"$value2$\\.Value\"")]
-        [InlineData("FindRule/AssignmentNullUnionOperator.txt", "$sign$ In \"Is\",\"==\",\"!=\",\"is not\"")]
+        [InlineData("FindRule/NullUnionOperator.txt", "$sign$ In \"is\",\"==\",\"!=\",\"is not\"",  "$value$ In $value1$,\"$value1$\\.Value\",$value2$,\"$value2$\\.Value\"")]
+        [InlineData("FindRule/AssignmentNullUnionOperator.txt", "$sign$ In \"is\",\"==\",\"!=\",\"is not\"")]
         public void FindRuleParsingFromFileShouldBeSuccess(string filePath, params string[] customResult)
         {
             var ruleStr = File.ReadAllText(filePath);
diff --git a/src/SimpleStateMachine.StructuralSearch.Tests/StructurSearchParserTests.cs b/src/SimpleStateMachine.StructuralSearch.Tests/StructurSearchParserTests.cs
@@ -26,21 +26,26 @@ public static void StructuralSearchShouldBeSuccess(string exampleName, string ex
         
         [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)
+        [InlineData("NullUnionOperator", "Examples/NullUnionOperator.cs", "Examples/Test.cs", 2)]
+        [InlineData("TernaryOperator", "Examples/TernaryOperator.cs", "", 3)]
+        public static void StructuralSearchShouldBe(string exampleName, string inputFilePath, string outputFilePath, int matchesCount)
         {
+            // TODO fix NullUnion example
+            
             var config = ConfigurationMock.GetConfigurationFromFiles(exampleName);
             var parser = new StructuralSearchParser(config);
 
-            var fileInfo = new FileInfo(exampleFilePath);
-            var input = Input.File(fileInfo);
+            var inputFileInfo = new FileInfo(inputFilePath);
+            var input = Input.File(inputFileInfo);
             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);
+            var replaceMatches = parser.GetReplaceMatches(ref context, matches);
             
+            var outputFileInfo = new FileInfo(outputFilePath);
+            var output = Output.File(outputFileInfo);
+            output.Replace(input, replaceMatches);
             Assert.Equal(matches.Count(), matchesCount);
         }
     }
diff --git a/src/SimpleStateMachine.StructuralSearch/EmptyParsingContext.cs b/src/SimpleStateMachine.StructuralSearch/EmptyParsingContext.cs
@@ -1,6 +1,6 @@
 ﻿using System.Collections.Generic;
 
-namespace SimpleStateMachine.StructuralSearch.Tests.Mock
+namespace SimpleStateMachine.StructuralSearch
 {
     public class EmptyParsingContext : IParsingContext
     {
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 ReplaceAsync(Match<string> match, string value)
+        public void Replace(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,7 +19,7 @@ public Result<char, T> ParseBy<T>(Parser<char, T> parser)
             return parser.Parse(FileInfo.OpenText());
         }
 
-        public void ReplaceAsync(Match<string> match, string value)
+        public void Replace(Match<string> match, string value)
         {
             var text = File.ReadAllText(Path);
             text = text.Replace(match.Value, value);
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 ReplaceAsync(Match<string> match, string value);
+        void Replace(Match<string> match, string value);
         
         string Extension { get; }
         string Path { get; }
diff --git a/src/SimpleStateMachine.StructuralSearch/Input/Input.cs b/src/SimpleStateMachine.StructuralSearch/Input/Input.cs
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 ReplaceAsync(Match<string> match, string value)
+        public void Replace(Match<string> match, string value)
         {
             throw new System.NotImplementedException();
         }
diff --git a/src/SimpleStateMachine.StructuralSearch/Output/FileOutput.cs b/src/SimpleStateMachine.StructuralSearch/Output/FileOutput.cs
@@ -0,0 +1,28 @@
+﻿using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+
+namespace SimpleStateMachine.StructuralSearch;
+
+public class FileOutput : IOutput
+{
+    public readonly FileInfo FileInfo;
+    
+    public FileOutput(FileInfo fileInfo)
+    {
+        FileInfo = fileInfo;
+    }
+    
+    public void Replace(IInput input, IEnumerable<ReplaceMatch> replaceMatches)
+    {
+        var text = replaceMatches
+            .Aggregate(input.Data, (current, replaceMatch) => 
+                current.Replace(replaceMatch.Match.Value, replaceMatch.Value));
+        
+        File.WriteAllText(Path, text);
+    }
+    
+    public string Extension => FileInfo.Extension;
+    public string Path => System.IO.Path.GetFullPath(FileInfo.FullName);
+    public string Name => System.IO.Path.GetFileNameWithoutExtension(FileInfo.Name);
+}
diff --git a/src/SimpleStateMachine.StructuralSearch/Output/IOutput.cs b/src/SimpleStateMachine.StructuralSearch/Output/IOutput.cs
@@ -0,0 +1,8 @@
+﻿using System.Collections.Generic;
+
+namespace SimpleStateMachine.StructuralSearch;
+
+public interface IOutput
+{
+    void Replace(IInput input, IEnumerable<ReplaceMatch> replaceMatches);
+}
diff --git a/src/SimpleStateMachine.StructuralSearch/Output/Output.cs b/src/SimpleStateMachine.StructuralSearch/Output/Output.cs
@@ -0,0 +1,8 @@
+﻿using System.IO;
+
+namespace SimpleStateMachine.StructuralSearch;
+
+public static class Output
+{
+    public static IOutput File(FileInfo fileInfo) => new FileOutput(fileInfo);
+}
diff --git a/src/SimpleStateMachine.StructuralSearch/ParsingContext.cs b/src/SimpleStateMachine.StructuralSearch/ParsingContext.cs
@@ -5,6 +5,8 @@ namespace SimpleStateMachine.StructuralSearch
 {
     public class ParsingContext : IParsingContext
     {
+        public static IParsingContext Empty = new EmptyParsingContext();
+        
         public ParsingContext(IInput input)
         {
             Input = input;
diff --git a/src/SimpleStateMachine.StructuralSearch/RepalceMatch.cs b/src/SimpleStateMachine.StructuralSearch/RepalceMatch.cs
@@ -0,0 +1,3 @@
+﻿namespace SimpleStateMachine.StructuralSearch;
+
+public readonly record struct ReplaceMatch(Match<string> Match, string Value);
diff --git a/src/SimpleStateMachine.StructuralSearch/Rules/FindRule/BinaryRule.cs b/src/SimpleStateMachine.StructuralSearch/Rules/FindRule/BinaryRule.cs
@@ -28,6 +28,12 @@ public bool Execute()
         public override string ToString()
         {
             return $"{Left}{Constant.Space}{Type}{Constant.Space}{Right}";
-        } 
+        }
+
+        public void SetContext(ref IParsingContext context)
+        {
+            Left.SetContext(ref context);
+            Right.SetContext(ref context);
+        }
     }
 }
diff --git a/src/SimpleStateMachine.StructuralSearch/Rules/FindRule/BinarySubRule.cs b/src/SimpleStateMachine.StructuralSearch/Rules/FindRule/BinarySubRule.cs
@@ -37,6 +37,12 @@ public bool Execute()
         public override string ToString()
         {
             return $"{Left}{Constant.Space}{Type}{Constant.Space}{Right}";
-        } 
+        }
+
+        public void SetContext(ref IParsingContext context)
+        {
+            Left.SetContext(ref context);
+            Right.SetContext(ref context);
+        }
     }
 }
diff --git a/src/SimpleStateMachine.StructuralSearch/Rules/FindRule/EmptySubRule.cs b/src/SimpleStateMachine.StructuralSearch/Rules/FindRule/EmptySubRule.cs
@@ -10,5 +10,10 @@ public bool Execute()
     public override string ToString()
     {
         return $"{Constant.Underscore}";
-    }  
+    }
+
+    public void SetContext(ref IParsingContext context)
+    {
+        
+    }
 }
diff --git a/src/SimpleStateMachine.StructuralSearch/Rules/FindRule/IRule.cs b/src/SimpleStateMachine.StructuralSearch/Rules/FindRule/IRule.cs
@@ -1,6 +1,6 @@
 ﻿namespace SimpleStateMachine.StructuralSearch.Rules
 {
-    public interface IRule
+    public interface IRule : IContextDependent
     {
         bool Execute();
     }
diff --git a/src/SimpleStateMachine.StructuralSearch/Rules/FindRule/InSubRule.cs b/src/SimpleStateMachine.StructuralSearch/Rules/FindRule/InSubRule.cs
@@ -19,12 +19,28 @@ public InSubRule(IRuleParameter parameter, IEnumerable<IRuleParameter> arguments
         public bool Execute()
         {
             var value = Parameter.GetValue();
-            return Arguments.Any(parameter => Equals(value, parameter.GetValue()));
+            var result = Arguments.Any(parameter =>
+            {
+                var value_ = parameter.GetValue();
+                var equal = Equals(value, value_);
+                return equal;
+            });
+            return result;
         }
         
         public override string ToString()
         {
             return $"{Parameter}{Constant.Space}{SubRuleType.In}{Constant.Space}{string.Join(Constant.Comma, Arguments.Select(x=>x.ToString()))}";
-        }  
+        }
+
+        public void SetContext(ref IParsingContext context)
+        {
+            Parameter.SetContext(ref context);
+
+            foreach (var argument in Arguments)
+            {
+                argument.SetContext(ref context);
+            }
+        }
     }
 }
diff --git a/src/SimpleStateMachine.StructuralSearch/Rules/FindRule/IsSubRule.cs b/src/SimpleStateMachine.StructuralSearch/Rules/FindRule/IsSubRule.cs
@@ -33,6 +33,11 @@ public bool Execute()
         public override string ToString()
         {
             return $"{Parameter}{Constant.Space}{SubRuleType.Is}{Constant.Space}{Argument}";
-        }  
+        }
+
+        public void SetContext(ref IParsingContext context)
+        {
+            Parameter.SetContext(ref context);
+        }
     }
 }
diff --git a/src/SimpleStateMachine.StructuralSearch/Rules/FindRule/UnaryRule.cs b/src/SimpleStateMachine.StructuralSearch/Rules/FindRule/UnaryRule.cs
@@ -28,6 +28,11 @@ public bool Execute()
         public override string ToString()
         {
             return $"{Type}{Constant.Space}{Parameter}";
-        } 
+        }
+
+        public void SetContext(ref IParsingContext context)
+        {
+            Parameter.SetContext(ref context);
+        }
     }
 }
diff --git a/src/SimpleStateMachine.StructuralSearch/Rules/Parameters/IRuleParameter.cs b/src/SimpleStateMachine.StructuralSearch/Rules/Parameters/IRuleParameter.cs
@@ -1,6 +1,6 @@
 ﻿namespace SimpleStateMachine.StructuralSearch.Rules
 {
-    public interface IRuleParameter
+    public interface IRuleParameter : IContextDependent
     {
         string GetValue();
     }
diff --git a/src/SimpleStateMachine.StructuralSearch/Rules/Parameters/ParenthesisedParameter.cs b/src/SimpleStateMachine.StructuralSearch/Rules/Parameters/ParenthesisedParameter.cs
@@ -26,6 +26,14 @@ public override string ToString()
         return string.Format(Template, string.Join(string.Empty, Parameters.Select(x=> x.ToString())));
     }
 
+    public void SetContext(ref IParsingContext context)
+    {
+        foreach (var parameter in Parameters)
+        {
+            parameter.SetContext(ref context);
+        }
+    }
+
     private static string GetTemplate(ParenthesisType parenthesisType)
     {
         return parenthesisType switch
diff --git a/src/SimpleStateMachine.StructuralSearch/Rules/Parameters/PlaceholderColumnParameter.cs b/src/SimpleStateMachine.StructuralSearch/Rules/Parameters/PlaceholderColumnParameter.cs
@@ -30,6 +30,11 @@ public string GetValue()
         public override string ToString()
         {
             return $"{PlaceholderParameter}{Constant.Dote}{PlaceholderProperty.Column}{Constant.Dote}{Property}";
-        } 
+        }
+
+        public void SetContext(ref IParsingContext context)
+        {
+            PlaceholderParameter.SetContext(ref context);
+        }
     }
 }
diff --git a/src/SimpleStateMachine.StructuralSearch/Rules/Parameters/PlaceholderFileParameter.cs b/src/SimpleStateMachine.StructuralSearch/Rules/Parameters/PlaceholderFileParameter.cs
@@ -30,6 +30,11 @@ public string GetValue()
         public override string ToString()
         {
             return $"{PlaceholderParameter}{Constant.Dote}{PlaceholderProperty.File}{Constant.Dote}{Property}";
-        } 
+        }
+
+        public void SetContext(ref IParsingContext context)
+        {
+            PlaceholderParameter.SetContext(ref context);
+        }
     }
 }
diff --git a/src/SimpleStateMachine.StructuralSearch/Rules/Parameters/PlaceholderLenghtParameter.cs b/src/SimpleStateMachine.StructuralSearch/Rules/Parameters/PlaceholderLenghtParameter.cs
@@ -21,6 +21,11 @@ public string GetValue()
         public override string ToString()
         {
             return $"{PlaceholderParameter}{Constant.Dote}{Property}";
-        } 
+        }
+
+        public void SetContext(ref IParsingContext context)
+        {
+            PlaceholderParameter.SetContext(ref context);
+        }
     }
 }
diff --git a/src/SimpleStateMachine.StructuralSearch/Rules/Parameters/PlaceholderLineParameter.cs b/src/SimpleStateMachine.StructuralSearch/Rules/Parameters/PlaceholderLineParameter.cs
@@ -30,6 +30,11 @@ public string GetValue()
         public override string ToString()
         {
             return $"{PlaceholderParameter}{Constant.Dote}{PlaceholderProperty.Line}{Constant.Dote}{Property}";
-        } 
+        }
+
+        public void SetContext(ref IParsingContext context)
+        {
+            PlaceholderParameter.SetContext(ref context);
+        }
     }
 }
diff --git a/src/SimpleStateMachine.StructuralSearch/Rules/Parameters/PlaceholderOffsetParameter.cs b/src/SimpleStateMachine.StructuralSearch/Rules/Parameters/PlaceholderOffsetParameter.cs
@@ -29,6 +29,11 @@ public string GetValue()
         public override string ToString()
         {
             return $"{PlaceholderParameter}{Constant.Dote}{PlaceholderProperty.Offset}{Constant.Dote}{Property}";
-        } 
+        }
+
+        public void SetContext(ref IParsingContext context)
+        {
+            PlaceholderParameter.SetContext(ref context);
+        }
     }
 }
diff --git a/src/SimpleStateMachine.StructuralSearch/Rules/Parameters/PlaceholderParameter.cs b/src/SimpleStateMachine.StructuralSearch/Rules/Parameters/PlaceholderParameter.cs
@@ -1,6 +1,6 @@
 ﻿namespace SimpleStateMachine.StructuralSearch.Rules
 {
-    public class PlaceholderParameter : IRuleParameter, IContextDependent
+    public class PlaceholderParameter : IRuleParameter
     {
         private IParsingContext _context;
         
diff --git a/src/SimpleStateMachine.StructuralSearch/Rules/Parameters/StringFormatParameter.cs b/src/SimpleStateMachine.StructuralSearch/Rules/Parameters/StringFormatParameter.cs
@@ -20,6 +20,14 @@ public string GetValue()
         public override string ToString()
         {
             return $"{Constant.DoubleQuotes}{string.Join(string.Empty, Parameters.Select(x=> x.ToString()))}{Constant.DoubleQuotes}";
-        } 
+        }
+
+        public void SetContext(ref IParsingContext context)
+        {
+            foreach (var parameter in Parameters)
+            {
+                parameter.SetContext(ref context);
+            }
+        }
     }
 }
diff --git a/src/SimpleStateMachine.StructuralSearch/Rules/Parameters/StringParameter.cs b/src/SimpleStateMachine.StructuralSearch/Rules/Parameters/StringParameter.cs
@@ -19,6 +19,11 @@ public override string ToString()
             var value = EscapeHelper.EscapeChars(Value, c => $"{Constant.BackSlash}{c}", Constant.Parameter.Escape);
             
             return $"{value}";
-        } 
+        }
+
+        public void SetContext(ref IParsingContext context)
+        {
+            
+        }
     }
 }
diff --git a/src/SimpleStateMachine.StructuralSearch/Rules/ReplaceRule/ChangeParameter.cs b/src/SimpleStateMachine.StructuralSearch/Rules/ReplaceRule/ChangeParameter.cs
diff --git a/src/SimpleStateMachine.StructuralSearch/Rules/ReplaceRule/ReplaceRule.cs b/src/SimpleStateMachine.StructuralSearch/Rules/ReplaceRule/ReplaceRule.cs
diff --git a/src/SimpleStateMachine.StructuralSearch/Rules/ReplaceRule/ReplaceSubRule.cs b/src/SimpleStateMachine.StructuralSearch/Rules/ReplaceRule/ReplaceSubRule.cs
diff --git a/src/SimpleStateMachine.StructuralSearch/StructuralSearchParser.cs b/src/SimpleStateMachine.StructuralSearch/StructuralSearchParser.cs

Original file line number	Diff line number	Diff line change
`@@ -62,8 +62,8 @@ public void FindRuleExprParsingShouldBeEqualsCustomResult(int number, string rul`
`62`	`62`	`Assert.Equal(_ruleStr, customResult.ToLower());`
`63`	`63`	`}`
`64`	`64`	`[Theory]`
`65`		`- [InlineData("FindRule/NullUnionOperator.txt", "$sign$ In \"Is\",\"==\",\"!=\",\"is not\"", "$value$ In $value1$,\"$value1$\\.Value\",$value2$,\"$value2$\\.Value\"")]`
`66`		`- [InlineData("FindRule/AssignmentNullUnionOperator.txt", "$sign$ In \"Is\",\"==\",\"!=\",\"is not\"")]`
	`65`	`+ [InlineData("FindRule/NullUnionOperator.txt", "$sign$ In \"is\",\"==\",\"!=\",\"is not\"", "$value$ In $value1$,\"$value1$\\.Value\",$value2$,\"$value2$\\.Value\"")]`
	`66`	`+ [InlineData("FindRule/AssignmentNullUnionOperator.txt", "$sign$ In \"is\",\"==\",\"!=\",\"is not\"")]`
`67`	`67`	`public void FindRuleParsingFromFileShouldBeSuccess(string filePath, params string[] customResult)`
`68`	`68`	`{`
`69`	`69`	`var ruleStr = File.ReadAllText(filePath);`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`using System.Collections.Generic;`
`2`	`2`
`3`		`-namespace SimpleStateMachine.StructuralSearch.Tests.Mock`
	`3`	`+namespace SimpleStateMachine.StructuralSearch`
`4`	`4`	`{`
`5`	`5`	`public class EmptyParsingContext : IParsingContext`
`6`	`6`	`{`
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 ReplaceAsync(Match<string> match, string value)`
	`12`	`+ public void Replace(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
`@@ -19,7 +19,7 @@ public Result<char, T> ParseBy<T>(Parser<char, T> parser)`
`19`	`19`	`return parser.Parse(FileInfo.OpenText());`
`20`	`20`	`}`
`21`	`21`
`22`		`- public void ReplaceAsync(Match<string> match, string value)`
	`22`	`+ public void Replace(Match<string> match, string value)`
`23`	`23`	`{`
`24`	`24`	`var text = File.ReadAllText(Path);`
`25`	`25`	`text = text.Replace(match.Value, value);`
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 ReplaceAsync(Match<string> match, string value);`
	`8`	`+ void Replace(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 ReplaceAsync(Match<string> match, string value)`
	`19`	`+ public void Replace(Match<string> match, string value)`
`20`	`20`	`{`
`21`	`21`	`throw new System.NotImplementedException();`
`22`	`22`	`}`