Some for StructuralSearchParser

RomanSoloweow · RomanSoloweow · commit bff4e31f3eec · 2022-05-08T15:39:43.000+03:00
diff --git a/src/SimpleStateMachine.StructuralSearch.Sandbox/Program.cs b/src/SimpleStateMachine.StructuralSearch.Sandbox/Program.cs
@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Text;
 using System.Text.Json;
 using System.Text.RegularExpressions;
 using Pidgin;
@@ -20,6 +21,24 @@ internal static class Program
     {
         static void Main(string[] args)
         {
+
+            var source = "test;;;test;;;.";
+            var parser = Parser.OneOf(Parser<char>.Any.ThenReturn(Unit.Value), Parser<char>.End);
+            
+            
+            var t = Parser<char>.Any.AtLeastOnceAsStringUntil(Lookahead(String(";").Then(Not(String(";"))).Try())).ParseOrThrow(source);
+
+
+            var path = "Test.txt";
+            var oldText = "0123456789";
+            var text = "test";
+            File.WriteAllText(path, oldText);
+
+            using var stringReader = text.AsStream();
+            using var streamWriter = File.OpenWrite(path);
+            
+            stringReader.CopyPartTo(streamWriter, 0, 7);
+            
             // var config = YmlHelper.Parse(
             //     @"C:\Users\roman\GitHub\SimpleStateMachine.StructuralSearch\src\SimpleStateMachine.StructuralSearch.Tests\ConfigurationFile\FullConfig.yml");
             //
diff --git a/src/SimpleStateMachine.StructuralSearch.Tests/Mock/EmptyParsingContext.cs b/src/SimpleStateMachine.StructuralSearch.Tests/Mock/EmptyParsingContext.cs
@@ -21,7 +21,17 @@ public Placeholder GetPlaceholder(string name)
             return Placeholder.CreateEmpty(this, name, string.Empty);
         }
 
-        public IReadOnlyDictionary<string, Placeholder> Switch()
+        public IReadOnlyDictionary<string, Placeholder> SwitchOnNew()
+        {
+            throw new System.NotImplementedException();
+        }
+
+        public void Set(IReadOnlyDictionary<string, Placeholder> placeholders)
+        {
+            throw new System.NotImplementedException();
+        }
+
+        public void Clear()
         {
             throw new System.NotImplementedException();
         }
diff --git a/src/SimpleStateMachine.StructuralSearch.Tests/PlaceholderParserTests.cs b/src/SimpleStateMachine.StructuralSearch.Tests/PlaceholderParserTests.cs
@@ -35,9 +35,8 @@ public void TemplateParsingShouldBeSuccess(string template, string source, strin
         }
         
         [Theory]
-        [InlineData("$var$;", "test;;;",  "test;;")]
+        [InlineData("$var$;", "test;;",  "test")]
         [InlineData("$var$;.", "test;;;.", "test;;")]
-        [InlineData("$var$;$var2$;", "test;;;test;;;", "test",";;test;;")]
         public void TemplateParsingShouldBeSuccess2(string template, string source, params string[] values)
         {
             var input = Input.String(source);
diff --git a/src/SimpleStateMachine.StructuralSearch.Tests/StructurSearchParserTests.cs b/src/SimpleStateMachine.StructuralSearch.Tests/StructurSearchParserTests.cs
@@ -1,4 +1,5 @@
 ﻿using System.IO;
+using System.Linq;
 using SimpleStateMachine.StructuralSearch.Tests.Mock;
 using Xunit;
 
@@ -9,8 +10,8 @@ public class StructuralSearchParserTests
         [Theory]
         // [InlineData("AssignmentNullUnionOperator")]
         // [InlineData("NullUnionOperator")]
-        [InlineData("TernaryOperator", "Examples/TernaryOperator.cs")]
-        public static void StructuralSearchShouldBeSuccess(string exampleName, string exampleFilePath)
+        [InlineData("TernaryOperator", "Examples/TernaryOperator.cs", 3)]
+        public static void StructuralSearchShouldBeSuccess(string exampleName, string exampleFilePath, int matchesCount)
         {
             var config = ConfigurationMock.GetConfigurationFromFiles(exampleName);
             var parser = new StructuralSearchParser(config);
@@ -19,7 +20,13 @@ public static void StructuralSearchShouldBeSuccess(string exampleName, string ex
             var input = Input.File(fileInfo);
             IParsingContext context = new ParsingContext(input);
            
-            parser.Parse(ref context);
+            var matches = parser.Parse(ref context);
+            Assert.Equal(matches.Count(), matchesCount);
+            // foreach (var match in matches)
+            // {
+            //     input.Replace(match.Match);
+            // }
+            
         }
     }
 }
diff --git a/src/SimpleStateMachine.StructuralSearch/Configurations/Configuration.cs b/src/SimpleStateMachine.StructuralSearch/Configurations/Configuration.cs
@@ -7,13 +7,13 @@ namespace SimpleStateMachine.StructuralSearch.Configurations
 {
     public class Configuration : IEquatable<Configuration>
     {
-        public string FindTemplate { get; set; }
+        public string FindTemplate { get; init; }
 
-        public List<string>? FindRules { get; set; }
+        public List<string>? FindRules { get; init; }
 
-        public string ReplaceTemplate { get; set; }
+        public string ReplaceTemplate { get; init; }
 
-        public List<string>? ReplaceRules { get; set; }
+        public List<string>? ReplaceRules { get; init; }
 
         public bool Equals(Configuration? other)
         {
diff --git a/src/SimpleStateMachine.StructuralSearch/Custom/StreamReplacer.cs b/src/SimpleStateMachine.StructuralSearch/Custom/StreamReplacer.cs
@@ -0,0 +1,53 @@
+﻿using System.IO;
+using System.Threading.Tasks;
+
+namespace SimpleStateMachine.StructuralSearch.Custom;
+
+// public class StreamReplacer : Stream
+// {
+//     
+//     private readonly Stream _baseStream;
+//     
+//     public StreamReplacer(Stream baseStream)
+//     {
+//         _baseStream = baseStream;
+//     }
+//     
+//     public Task Replace(Stream stream, int fromStart, int fromEnd, int toStart, int toEnd)
+//     {
+//         stream.SetLength();
+//         stream.Position = fromStart;
+//         stream.
+//     }
+//     
+//     public override void Flush()
+//     {
+//         throw new System.NotImplementedException();
+//     }
+//
+//     public override int Read(byte[] buffer, int offset, int count)
+//     {
+//         throw new System.NotImplementedException();
+//     }
+//
+//     public override long Seek(long offset, SeekOrigin origin)
+//     {
+//         throw new System.NotImplementedException();
+//     }
+//
+//     public override void SetLength(long value)
+//     {
+//         throw new System.NotImplementedException();
+//     }
+//
+//     public override void Write(byte[] buffer, int offset, int count)
+//     {
+//         throw new System.NotImplementedException();
+//     }
+//
+//     public override bool CanRead { get; }
+//     public override bool CanSeek { get; }
+//     public override bool CanWrite { get; }
+//     public override long Length { get; }
+//     public override long Position { get; set; }
+// }
diff --git a/src/SimpleStateMachine.StructuralSearch/EmptyInput.cs b/src/SimpleStateMachine.StructuralSearch/EmptyInput.cs
@@ -9,6 +9,11 @@ public Result<char, T> ParseBy<T>(Parser<char, T> parser)
             throw new System.NotImplementedException();
         }
 
+        public void Replace(Match<string> match, string value)
+        {
+            throw new System.NotImplementedException();
+        }
+
         public string Extension => string.Empty;
         public string Path => string.Empty;
         public string Name => string.Empty;
diff --git a/src/SimpleStateMachine.StructuralSearch/Extensions/StringExtensions.cs b/src/SimpleStateMachine.StructuralSearch/Extensions/StringExtensions.cs
@@ -0,0 +1,12 @@
+﻿using System.IO;
+using System.Text;
+
+namespace SimpleStateMachine.StructuralSearch.Extensions;
+
+public static class StringExtensions
+{
+    public static MemoryStream AsStream(this string str)
+    {
+        return new MemoryStream(Encoding.UTF8.GetBytes(str));
+    }
+}
diff --git a/src/SimpleStateMachine.StructuralSearch/FileInput.cs b/src/SimpleStateMachine.StructuralSearch/FileInput.cs
@@ -1,22 +1,35 @@
 ﻿using System.IO;
+using System.Threading;
 using Pidgin;
+using SimpleStateMachine.StructuralSearch.Helper;
 
 namespace SimpleStateMachine.StructuralSearch
 {
     public class FileInput : IInput
     {
+        public readonly FileInfo FileInfo;
+        
         public FileInput(FileInfo fileInfo)
         {
             FileInfo = fileInfo;
         }
-        
-        public readonly FileInfo FileInfo;
-        
+
         public Result<char, T> ParseBy<T>(Parser<char, T> parser)
         {
             return parser.Parse(FileInfo.OpenText());
         }
 
+        public void Replace(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);
+            
+            //return (emptyStart, emptyEnd);
+        }
+
         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/FindParser.cs b/src/SimpleStateMachine.StructuralSearch/FindParser.cs
@@ -28,7 +28,7 @@ public IEnumerable<FindParserMatch> Parse(ref IParsingContext context)
                 .Match()
                 .ThenInvoke(match =>
                 {
-                    var placeholders= parsingContext.Switch();
+                    var placeholders= parsingContext.SwitchOnNew();
                     matches.Add(new FindParserMatch(match, placeholders));
                 })
                 .ThenReturn(Unit.Value)
@@ -38,7 +38,7 @@ public IEnumerable<FindParserMatch> Parse(ref IParsingContext context)
                 .ThenInvoke(x =>
                 {
                     res.Append(x);
-                    parsingContext.Switch();
+                    parsingContext.SwitchOnNew();
                 })
                 .ThenReturn(Unit.Value);
             
diff --git a/src/SimpleStateMachine.StructuralSearch/Helper/StreamExtensions.cs b/src/SimpleStateMachine.StructuralSearch/Helper/StreamExtensions.cs
@@ -0,0 +1,46 @@
+﻿using System;
+using System.Diagnostics.Contracts;
+using System.IO;
+
+namespace SimpleStateMachine.StructuralSearch.Helper;
+
+public static class StreamExtensions
+    {
+        /// <summary>
+        /// Copies a specific number of bytes from the current position of the
+        /// source stream to the current position of the destination stream.
+        /// </summary>
+        /// <param name="source">The source stream.</param>
+        /// <param name="destination">The destination stream.</param>
+        /// <param name="count">The number of bytes to copy.</param>
+        /// <param name="bufferSize">The size of the buffer to use.
+        /// The default is 4096.</param>
+        public static void CopyPartTo(this Stream source, Stream destination, int offset, int count, int bufferSize)
+        {
+            if (source == null) throw new ArgumentNullException(nameof(source));
+            if (destination == null) throw new ArgumentNullException(nameof(destination));
+
+            byte[] buffer = new byte[bufferSize];
+            int read;
+            while (count > 0 && (read = source.Read(buffer, 0, Math.Min(buffer.Length, count))) > 0)
+            {
+                count -= read;
+                destination.Write(buffer, offset, read);
+            }
+        }
+
+        /// <summary>
+        /// Copies a specific number of bytes from the current position of the
+        /// source stream to the current position of the destination stream.
+        /// </summary>
+        /// <param name="source">The source stream.</param>
+        /// <param name="destination">The destination stream.</param>
+        /// <param name="count">The number of bytes to copy.</param>
+        public static void CopyPartTo(this Stream source, Stream destination, int offset, int count)
+        {
+            if (source == null) throw new ArgumentNullException(nameof(source));
+            if (destination == null) throw new ArgumentNullException(nameof(destination));
+            
+            CopyPartTo(source, destination, offset, count, 0x1000);
+        }
+    }
diff --git a/src/SimpleStateMachine.StructuralSearch/Helper/TextReaderExtensions.cs b/src/SimpleStateMachine.StructuralSearch/Helper/TextReaderExtensions.cs
@@ -0,0 +1,46 @@
+﻿using System;
+using System.IO;
+
+namespace SimpleStateMachine.StructuralSearch.Helper;
+
+public static class TextReaderExtensions
+{
+    /// <summary>
+    /// Copies a specific number of bytes from the current position of the
+    /// source stream to the current position of the destination stream.
+    /// </summary>
+    /// <param name="source">The source stream.</param>
+    /// <param name="destination">The destination stream.</param>
+    /// <param name="count">The number of bytes to copy.</param>
+    /// <param name="bufferSize">The size of the buffer to use.
+    /// The default is 4096.</param>
+    public static void CopyPartTo(this TextReader source, TextWriter destination, int offset, int count, int bufferSize)
+    {
+        if (source == null) throw new ArgumentNullException(nameof(source));
+        if (destination == null) throw new ArgumentNullException(nameof(destination));
+
+        char[] buffer = new char[bufferSize];
+        int read;
+        
+        while (count > 0 && (read = source.ReadBlock(buffer)) > 0)
+        {
+            count -= read;
+            destination.Write(buffer, offset, read);
+        }
+    }
+
+    /// <summary>
+    /// Copies a specific number of bytes from the current position of the
+    /// source stream to the current position of the destination stream.
+    /// </summary>
+    /// <param name="source">The source stream.</param>
+    /// <param name="destination">The destination stream.</param>
+    /// <param name="count">The number of bytes to copy.</param>
+    public static void CopyPartTo(this TextReader source, TextWriter destination, int offset, int count)
+    {
+        if (source == null) throw new ArgumentNullException(nameof(source));
+        if (destination == null) throw new ArgumentNullException(nameof(destination));
+            
+        CopyPartTo(source, destination, offset, count, 4096);
+    }
+}
diff --git a/src/SimpleStateMachine.StructuralSearch/IInput.cs b/src/SimpleStateMachine.StructuralSearch/IInput.cs
@@ -5,6 +5,7 @@ namespace SimpleStateMachine.StructuralSearch
     public interface IInput
     {
         Result<char, T> ParseBy<T>(Parser<char, T> parser);
+        void Replace(Match<string> match, string value);
         
         string Extension { get; }
         string Path { get; }
diff --git a/src/SimpleStateMachine.StructuralSearch/IParsingContext.cs b/src/SimpleStateMachine.StructuralSearch/IParsingContext.cs
@@ -12,6 +12,8 @@ public interface IParsingContext
 
         Placeholder GetPlaceholder(string name);
         
-        IReadOnlyDictionary<string, Placeholder> Switch();
+        IReadOnlyDictionary<string, Placeholder> SwitchOnNew();
+        void Set(IReadOnlyDictionary<string, Placeholder>placeholders);
+        void Clear();
     }
 }
diff --git a/src/SimpleStateMachine.StructuralSearch/Parsers/PlaceholderParser.cs b/src/SimpleStateMachine.StructuralSearch/Parsers/PlaceholderParser.cs
diff --git a/src/SimpleStateMachine.StructuralSearch/ParsingContext.cs b/src/SimpleStateMachine.StructuralSearch/ParsingContext.cs
diff --git a/src/SimpleStateMachine.StructuralSearch/Rules/FindRule/FindRule.cs b/src/SimpleStateMachine.StructuralSearch/Rules/FindRule/FindRule.cs
diff --git a/src/SimpleStateMachine.StructuralSearch/StringInput.cs b/src/SimpleStateMachine.StructuralSearch/StringInput.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
`@@ -21,7 +21,17 @@ public Placeholder GetPlaceholder(string name)`
`21`	`21`	`return Placeholder.CreateEmpty(this, name, string.Empty);`
`22`	`22`	`}`
`23`	`23`
`24`		`- public IReadOnlyDictionary<string, Placeholder> Switch()`
	`24`	`+ public IReadOnlyDictionary<string, Placeholder> SwitchOnNew()`
	`25`	`+ {`
	`26`	`+ throw new System.NotImplementedException();`
	`27`	`+ }`
	`28`	`+`
	`29`	`+ public void Set(IReadOnlyDictionary<string, Placeholder> placeholders)`
	`30`	`+ {`
	`31`	`+ throw new System.NotImplementedException();`
	`32`	`+ }`
	`33`	`+`
	`34`	`+ public void Clear()`
`25`	`35`	`{`
`26`	`36`	`throw new System.NotImplementedException();`
`27`	`37`	`}`
Original file line number	Diff line number	Diff line change
`@@ -35,9 +35,8 @@ public void TemplateParsingShouldBeSuccess(string template, string source, strin`
`35`	`35`	`}`
`36`	`36`
`37`	`37`	`[Theory]`
`38`		`- [InlineData("$var$;", "test;;;", "test;;")]`
	`38`	`+ [InlineData("$var$;", "test;;", "test")]`
`39`	`39`	`[InlineData("$var$;.", "test;;;.", "test;;")]`
`40`		`- [InlineData("$var$;$var2$;", "test;;;test;;;", "test",";;test;;")]`
`41`	`40`	`public void TemplateParsingShouldBeSuccess2(string template, string source, params string[] values)`
`42`	`41`	`{`
`43`	`42`	`var input = Input.String(source);`
Original file line number	Diff line number	Diff line change
`@@ -7,13 +7,13 @@ namespace SimpleStateMachine.StructuralSearch.Configurations`
`7`	`7`	`{`
`8`	`8`	`public class Configuration : IEquatable<Configuration>`
`9`	`9`	`{`
`10`		`- public string FindTemplate { get; set; }`
	`10`	`+ public string FindTemplate { get; init; }`
`11`	`11`
`12`		`- public List<string>? FindRules { get; set; }`
	`12`	`+ public List<string>? FindRules { get; init; }`
`13`	`13`
`14`		`- public string ReplaceTemplate { get; set; }`
	`14`	`+ public string ReplaceTemplate { get; init; }`
`15`	`15`
`16`		`- public List<string>? ReplaceRules { get; set; }`
	`16`	`+ public List<string>? ReplaceRules { get; init; }`
`17`	`17`
`18`	`18`	`public bool Equals(Configuration? other)`
`19`	`19`	`{`