Input abstraction

RomanSoloweow · RomanSoloweow · commit 0e47475b0a62 · 2022-04-17T04:31:00.000+03:00
diff --git a/src/SimpleStateMachine.StructuralSearch.Tests/Examples/TernaryOperator.cs b/src/SimpleStateMachine.StructuralSearch.Tests/Examples/TernaryOperator.cs
@@ -0,0 +1,54 @@
+﻿using System;
+
+namespace SimpleStateMachine.StructuralSearch.Tests.Examples
+{
+    public class TernaryOperator
+    {
+        public int Test1()
+        {
+            var temp = 150;
+            
+            if(temp == 125)
+                return 12;
+            else
+                return 15;
+        }
+        
+        public int Test2()
+        {
+            var temp = 150;
+            
+            if(temp == 125)
+                return 12;
+            else
+                return 15;
+        }
+        
+        public int Test3()
+        {
+            var temp2 = 150;
+            
+            if(temp2 == 125)
+                return 12;
+            else
+                return 15; 
+        }
+        
+        public int Test4()
+        {
+            var temp3 = 150;
+            
+            if(temp3 == 125)
+                return 12;
+            else if (temp3 == 135)
+                return 15;
+            else
+                return 0;
+        }
+        
+        public void Test5()
+        {
+            
+        }
+    }
+}
diff --git a/src/SimpleStateMachine.StructuralSearch.Tests/FindTemplateTests.cs b/src/SimpleStateMachine.StructuralSearch.Tests/FindTemplateTests.cs
@@ -28,9 +28,10 @@ public void SourceParsingBeFindTemplateShouldBeSuccess(string templatePath, stri
         {
             var findTemplate = File.ReadAllText(templatePath);
             var source = File.ReadAllText(sourcePath);
+            var input = Input.String(source);
             var findParser = StructuralSearch.ParseFindTemplate(findTemplate);
-            IParsingContext parsingContext = new ParsingContext();
-            var result = findParser.Parse(ref parsingContext, source);
+            IParsingContext parsingContext = new ParsingContext(input);
+            var result = findParser.Parse(ref parsingContext, input);
             
             Assert.NotNull(findParser);
             Assert.NotNull(result.Value);
diff --git a/src/SimpleStateMachine.StructuralSearch.Tests/Mock/EmptyParsingContext.cs b/src/SimpleStateMachine.StructuralSearch.Tests/Mock/EmptyParsingContext.cs
@@ -2,7 +2,7 @@
 {
     public class EmptyParsingContext : IParsingContext
     {
-        public FileProperty File { get; } = new FileProperty();
+        public IInput Input { get; }
 
         public bool TryGetPlaceholder(string name, out Placeholder value)
         {
diff --git a/src/SimpleStateMachine.StructuralSearch.Tests/PlaceholderParserTests.cs b/src/SimpleStateMachine.StructuralSearch.Tests/PlaceholderParserTests.cs
@@ -18,9 +18,10 @@ public void FindTemplateShouldBeNotEmpty()
         [InlineData("($test$)", "(value (test) )", "value (test) ")]
         public void TemplateParsingShouldBeSuccess(string template, string source, string result)
         {
-            IParsingContext parsingContext = new ParsingContext();
+            var input = Input.String(source);
+            IParsingContext parsingContext = new ParsingContext(input);
             var templateParser = StructuralSearch.ParseFindTemplate(template);
-            var res = templateParser.Parse(ref parsingContext, source);
+            var res = templateParser.Parse(ref parsingContext, input);
             var placeholder = parsingContext.GetPlaceholder("test");
             
             Assert.Equal(placeholder.Value, result);
@@ -30,9 +31,10 @@ public void TemplateParsingShouldBeSuccess(string template, string source, strin
         [InlineData("$var$;$var2$;", "test;;;test;;;",  "value ")]
         public void TemplateParsingShouldBeSuccess2(string template, string source, string result)
         {
-            IParsingContext parsingContext = new ParsingContext();
+            var input = Input.String(source);
+            IParsingContext parsingContext = new ParsingContext(input);
             var templateParser = StructuralSearch.ParseFindTemplate(template);
-            templateParser.Parse(ref parsingContext, source);
+            templateParser.Parse(ref parsingContext, input);
              
             
             // var templateStr = File.ReadAllText(templatePath);
diff --git a/src/SimpleStateMachine.StructuralSearch.Tests/ReplaceTemplateTests.cs b/src/SimpleStateMachine.StructuralSearch.Tests/ReplaceTemplateTests.cs
@@ -38,7 +38,7 @@ public void ReplaceBuildShouldBeSuccess(string templatePath, string resultPath,
             var replaceResult = File.ReadAllText(resultPath);
             var replaceBuilder = StructuralSearch.ParseReplaceTemplate(replaceTemplate);
             
-            var parsingContext = new ParsingContext();
+            var parsingContext = new ParsingContext(Input.Empty);
             for (int i = 0; i < keys.Length; i++)
             {
                 parsingContext.AddPlaceholder(Placeholder.CreateEmpty(parsingContext, keys[i], values[i]));
diff --git a/src/SimpleStateMachine.StructuralSearch.Tests/SimpleStateMachine.StructuralSearch.Tests.csproj b/src/SimpleStateMachine.StructuralSearch.Tests/SimpleStateMachine.StructuralSearch.Tests.csproj
@@ -25,6 +25,9 @@
     </ItemGroup>
 
     <ItemGroup Condition="'$(Configuration)' == 'Debug'">
+        <Content Include="Examples\*.cs">
+            <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+        </Content>
         <Content Include="FindTemplate\*.txt">
             <CopyToOutputDirectory>Always</CopyToOutputDirectory>
         </Content>
diff --git a/src/SimpleStateMachine.StructuralSearch.Tests/StructurSearchParserTests.cs b/src/SimpleStateMachine.StructuralSearch.Tests/StructurSearchParserTests.cs
@@ -1,19 +1,25 @@
-﻿using SimpleStateMachine.StructuralSearch.Tests.Mock;
+﻿using System.IO;
+using SimpleStateMachine.StructuralSearch.Tests.Mock;
 using Xunit;
 
 namespace SimpleStateMachine.StructuralSearch.Tests
 {
     public class StructuralSearchParserTests
     {
         [Theory]
-        [InlineData("AssignmentNullUnionOperator")]
-        [InlineData("NullUnionOperator")]
-        [InlineData("TernaryOperator")]
-        public static void StructuralSearchShouldBeSuccess(string exampleName)
+        // [InlineData("AssignmentNullUnionOperator")]
+        // [InlineData("NullUnionOperator")]
+        [InlineData("TernaryOperator", "Examples/TernaryOperator.cs")]
+        public static void StructuralSearchShouldBeSuccess(string exampleName, string exampleFilePath)
         {
             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);
+           
+            parser.Parse(ref context);
         }
     }
 }
diff --git a/src/SimpleStateMachine.StructuralSearch/EmptyInput.cs b/src/SimpleStateMachine.StructuralSearch/EmptyInput.cs
@@ -0,0 +1,12 @@
+﻿using Pidgin;
+
+namespace SimpleStateMachine.StructuralSearch
+{
+    public class EmptyInput : IInput
+    {
+        public Result<char, T> Parse<T>(Parser<char, T> parser)
+        {
+            throw new System.NotImplementedException();
+        }
+    }
+}
diff --git a/src/SimpleStateMachine.StructuralSearch/FileInput.cs b/src/SimpleStateMachine.StructuralSearch/FileInput.cs
@@ -0,0 +1,20 @@
+﻿using System.IO;
+using Pidgin;
+
+namespace SimpleStateMachine.StructuralSearch
+{
+    public class FileInput : IInput
+    {
+        public FileInput(FileInfo fileInfo)
+        {
+            FileInfo = fileInfo;
+        }
+        
+        public readonly FileInfo FileInfo;
+        
+        public Result<char, T> Parse<T>(Parser<char, T> parser)
+        {
+            return parser.Parse(FileInfo.OpenText());
+        }
+    }
+}
diff --git a/src/SimpleStateMachine.StructuralSearch/FindParser.cs b/src/SimpleStateMachine.StructuralSearch/FindParser.cs
@@ -1,6 +1,8 @@
 ﻿using System.Collections.Generic;
+using System.IO;
 using Pidgin;
 using SimpleStateMachine.StructuralSearch.Extensions;
+using YamlDotNet.Core.Events;
 
 namespace SimpleStateMachine.StructuralSearch
 {
@@ -12,13 +14,13 @@ public FindParser(SeriesParser parser)
             Parser = parser;
         }
 
-        public SourceMatch Parse(ref IParsingContext context, string input)
+        public SourceMatch Parse(ref IParsingContext context, IInput input)
         {
             Parser.SetContext(ref context);
-            var result = Parser.Select(x => string.Join(string.Empty, x))
-                .AsMatch()
-                .Parse(input);
             
+            var result = input.Parse(Parser.Select(x => string.Join(string.Empty, x))
+                .AsMatch());
+
             return result.Success ? result.Value : SourceMatch.Empty;
         }
     }
diff --git a/src/SimpleStateMachine.StructuralSearch/IFindParser.cs b/src/SimpleStateMachine.StructuralSearch/IFindParser.cs
@@ -1,11 +1,12 @@
 ﻿using System.Collections.Generic;
+using System.IO;
 using Pidgin;
 using SimpleStateMachine.StructuralSearch.ReplaceTemplate;
 
 namespace SimpleStateMachine.StructuralSearch
 {
     public interface IFindParser
     {
-        SourceMatch Parse(ref IParsingContext context, string input);
+        SourceMatch Parse(ref IParsingContext context, IInput input);
     }
 }
diff --git a/src/SimpleStateMachine.StructuralSearch/IParsingContext.cs b/src/SimpleStateMachine.StructuralSearch/IParsingContext.cs
@@ -2,7 +2,8 @@
 {
     public interface IParsingContext
     {
-        FileProperty File { get; }
+        IInput Input { get; }
+        
         bool TryGetPlaceholder(string name, out Placeholder value);
 
         void AddPlaceholder(Placeholder placeholder);
diff --git a/src/SimpleStateMachine.StructuralSearch/ISource.cs b/src/SimpleStateMachine.StructuralSearch/ISource.cs
@@ -0,0 +1,9 @@
+﻿using Pidgin;
+
+namespace SimpleStateMachine.StructuralSearch
+{
+    public interface IInput
+    {
+        Result<char, T> Parse<T>(Parser<char, T> parser);
+    }
+}
diff --git a/src/SimpleStateMachine.StructuralSearch/Input.cs b/src/SimpleStateMachine.StructuralSearch/Input.cs
@@ -0,0 +1,13 @@
+﻿using System.IO;
+
+namespace SimpleStateMachine.StructuralSearch
+{
+    public static class Input
+    {
+        public static readonly IInput Empty = new EmptyInput();
+        
+        public static IInput String(string input) => new StringInput(input);
+        
+        public static IInput File(FileInfo fileInfo) => new FileInput(fileInfo);
+    }
+}
diff --git a/src/SimpleStateMachine.StructuralSearch/ParsingContext.cs b/src/SimpleStateMachine.StructuralSearch/ParsingContext.cs
@@ -4,10 +4,16 @@ namespace SimpleStateMachine.StructuralSearch
 {
     public class ParsingContext : IParsingContext
     {
+        public ParsingContext(IInput input)
+        {
+            Input = input;
+        }
         public Dictionary<string, Placeholder> Placeholders { get; } = new();
 
         public FileProperty File { get; }
 
+        public IInput Input { get; }
+
         public bool TryGetPlaceholder(string name, out Placeholder value)
         {
             return Placeholders.TryGetValue(name, out value);
diff --git a/src/SimpleStateMachine.StructuralSearch/Placeholder/FileProperty.cs b/src/SimpleStateMachine.StructuralSearch/Placeholder/FileProperty.cs
@@ -1,11 +1,28 @@
-﻿namespace SimpleStateMachine.StructuralSearch
+﻿using System.IO;
+
+namespace SimpleStateMachine.StructuralSearch
 {
     public class FileProperty
     {
+        public FileProperty(FileInfo fileInfo)
+        {
+            FileInfo = fileInfo;
+            StreamReader = new StreamReader(fileInfo.OpenRead());
+        }
+
+        public readonly FileInfo FileInfo;
         public readonly string Path;
         public readonly string Data;
-        public readonly string Name;
-        public readonly string Directory;
-        public readonly int Lenght;
+        public readonly StreamReader StreamReader;
+        public string Name => FileInfo.Name;
+        public string Directory => FileInfo.FullName;
+        public long Lenght => FileInfo.Length;
+
+        public static FileProperty FromFile(string path)
+        {
+            return new FileProperty(new FileInfo(path));
+        }
+
+        public static readonly FileProperty Empty = new FileProperty(null);
     }
 }
diff --git a/src/SimpleStateMachine.StructuralSearch/Placeholder/Placeholder.cs b/src/SimpleStateMachine.StructuralSearch/Placeholder/Placeholder.cs
@@ -17,7 +17,6 @@ public Placeholder(IParsingContext context, string name, string value, LinePrope
         public readonly string Name;
         public readonly string Value;
         public readonly int Lenght;
-        public FileProperty File => _context.File;
         public readonly LineProperty Line;
         public readonly ColumnProperty Column;
         public readonly OffsetProperty Offset;
diff --git a/src/SimpleStateMachine.StructuralSearch/Rules/Parameters/PlaceholderFileParameter.cs b/src/SimpleStateMachine.StructuralSearch/Rules/Parameters/PlaceholderFileParameter.cs
@@ -15,16 +15,19 @@ public PlaceholderFileParameter(PlaceholderParameter parameter, FileProperty pro
 
         public string GetValue()
         {
-            var file = PlaceholderParameter.GetPlaceholder().File;
-            return Property switch
-            {
-                FileProperty.Path => file.Path,
-                FileProperty.Data => file.Data,
-                FileProperty.Name => file.Name,
-                FileProperty.Directory => file.Directory,
-                FileProperty.Lenght => file.Lenght.ToString(),
-                _ => throw new ArgumentOutOfRangeException()
-            };
+            // TODO
+            // var file = PlaceholderParameter.GetPlaceholder().File;
+            // return Property switch
+            // {
+            //     FileProperty.Path => file.Path,
+            //     FileProperty.Data => file.Data,
+            //     FileProperty.Name => file.Name,
+            //     FileProperty.Directory => file.Directory,
+            //     FileProperty.Lenght => file.Lenght.ToString(),
+            //     _ => throw new ArgumentOutOfRangeException()
+            // };
+
+            return null;
         }
         
         public override string ToString()
diff --git a/src/SimpleStateMachine.StructuralSearch/StringInput.cs b/src/SimpleStateMachine.StructuralSearch/StringInput.cs
@@ -0,0 +1,19 @@
+﻿using Pidgin;
+
+namespace SimpleStateMachine.StructuralSearch
+{
+    public class StringInput : IInput
+    {
+        public StringInput(string input)
+        {
+            Input = input;
+        }
+        
+        public readonly string Input;
+        
+        public Result<char, T> Parse<T>(Parser<char, T> parser)
+        {
+            return parser.Parse(Input);
+        }
+    }
+}
diff --git a/src/SimpleStateMachine.StructuralSearch/StructuralSearchParser.cs b/src/SimpleStateMachine.StructuralSearch/StructuralSearchParser.cs
@@ -1,5 +1,6 @@
 ﻿
 using System.Collections.Generic;
+using System.IO;
 using System.Linq;
 using SimpleStateMachine.StructuralSearch.Configurations;
 using SimpleStateMachine.StructuralSearch.Extensions;
@@ -37,7 +38,7 @@ public StructuralSearchParser(Configuration configuration)
 
         public void Parse(ref IParsingContext context)
         {
-            FindParser.Parse(ref context, context.File.Data);
+            var result = FindParser.Parse(ref context, context.Input);
         }
         
         public void Replace(ref IParsingContext context)

Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,7 @@`
`2`	`2`	`{`
`3`	`3`	`public class EmptyParsingContext : IParsingContext`
`4`	`4`	`{`
`5`		`- public FileProperty File { get; } = new FileProperty();`
	`5`	`+ public IInput Input { get; }`
`6`	`6`
`7`	`7`	`public bool TryGetPlaceholder(string name, out Placeholder value)`
`8`	`8`	`{`
Original file line number	Diff line number	Diff line change
`@@ -38,7 +38,7 @@ public void ReplaceBuildShouldBeSuccess(string templatePath, string resultPath,`
`38`	`38`	`var replaceResult = File.ReadAllText(resultPath);`
`39`	`39`	`var replaceBuilder = StructuralSearch.ParseReplaceTemplate(replaceTemplate);`
`40`	`40`
`41`		`- var parsingContext = new ParsingContext();`
	`41`	`+ var parsingContext = new ParsingContext(Input.Empty);`
`42`	`42`	`for (int i = 0; i < keys.Length; i++)`
`43`	`43`	`{`
`44`	`44`	`parsingContext.AddPlaceholder(Placeholder.CreateEmpty(parsingContext, keys[i], values[i]));`
Original file line number	Diff line number	Diff line change
`@@ -1,19 +1,25 @@`
`1`		`-using SimpleStateMachine.StructuralSearch.Tests.Mock;`
	`1`	`+using System.IO;`
	`2`	`+using SimpleStateMachine.StructuralSearch.Tests.Mock;`
`2`	`3`	`using Xunit;`
`3`	`4`
`4`	`5`	`namespace SimpleStateMachine.StructuralSearch.Tests`
`5`	`6`	`{`
`6`	`7`	`public class StructuralSearchParserTests`
`7`	`8`	`{`
`8`	`9`	`[Theory]`
`9`		`- [InlineData("AssignmentNullUnionOperator")]`
`10`		`- [InlineData("NullUnionOperator")]`
`11`		`- [InlineData("TernaryOperator")]`
`12`		`- public static void StructuralSearchShouldBeSuccess(string exampleName)`
	`10`	`+ // [InlineData("AssignmentNullUnionOperator")]`
	`11`	`+ // [InlineData("NullUnionOperator")]`
	`12`	`+ [InlineData("TernaryOperator", "Examples/TernaryOperator.cs")]`
	`13`	`+ public static void StructuralSearchShouldBeSuccess(string exampleName, string exampleFilePath)`
`13`	`14`	`{`
`14`	`15`	`var config = ConfigurationMock.GetConfigurationFromFiles(exampleName);`
`15`	`16`	`var parser = new StructuralSearchParser(config);`
`16`		`-`
	`17`	`+`
	`18`	`+ var fileInfo = new FileInfo(exampleFilePath);`
	`19`	`+ var input = Input.File(fileInfo);`
	`20`	`+ IParsingContext context = new ParsingContext(input);`
	`21`	`+`
	`22`	`+ parser.Parse(ref context);`
`17`	`23`	`}`
`18`	`24`	`}`
`19`	`25`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,8 @@`
`1`	`1`	`using System.Collections.Generic;`
	`2`	`+using System.IO;`
`2`	`3`	`using Pidgin;`
`3`	`4`	`using SimpleStateMachine.StructuralSearch.Extensions;`
	`5`	`+using YamlDotNet.Core.Events;`
`4`	`6`
`5`	`7`	`namespace SimpleStateMachine.StructuralSearch`
`6`	`8`	`{`
`@@ -12,13 +14,13 @@ public FindParser(SeriesParser parser)`
`12`	`14`	`Parser = parser;`
`13`	`15`	`}`
`14`	`16`
`15`		`- public SourceMatch Parse(ref IParsingContext context, string input)`
	`17`	`+ public SourceMatch Parse(ref IParsingContext context, IInput input)`
`16`	`18`	`{`
`17`	`19`	`Parser.SetContext(ref context);`
`18`		`- var result = Parser.Select(x => string.Join(string.Empty, x))`
`19`		`- .AsMatch()`
`20`		`- .Parse(input);`
`21`	`20`
	`21`	`+ var result = input.Parse(Parser.Select(x => string.Join(string.Empty, x))`
	`22`	`+ .AsMatch());`
	`23`	`+`
`22`	`24`	`return result.Success ? result.Value : SourceMatch.Empty;`
`23`	`25`	`}`
`24`	`26`	`}`