ReplaceTemplate

Author: RomanSoloweow

src/SimpleStateMachine.StructuralSearch.Sandbox/Program.cs

@@ -10,9 +10,18 @@ internal static class Program
     {
         static void Main(string[] args)
         {
-            var template = StructuralSearch.ParseTemplate("");
-            var test = Parser.OneOf(String("Test"), CommonParser.Empty);
-            var res = test.ParseOrThrow("");
+
+            var test = String("return ")
+                .Then(AnyCharExcept(';').ManyString())
+                .Then(Char(';').AtLeastOnceString())
+                .Before(Char(';'));
+            
+            
+            // var template = StructuralSearch.ParseTemplate("");
+            // var test = Parser.OneOf(String("Test"), CommonParser.Empty);
+            var res = test.ParseOrThrow("return 125;;;;");
+            
+            
             // var lookahead = Parser.Lookahead(Char(';').Then(End).Try());
             // var t = Parser.String("return ").Then(Any.AtLeastOnceAsStringUntilNot(lookahead));
             // var res = t.ParseOrThrow("return 124;;");

src/SimpleStateMachine.StructuralSearch/ReplaceTemplate/IReplaceBuilder.cs

@@ -0,0 +1,10 @@
+using System.Collections.Generic;
+
+namespace SimpleStateMachine.StructuralSearch.ReplaceTemplate
+{
+    public interface IReplaceBuilder
+    {
+        IEnumerable<IReplaceStep> Steps { get; }
+        string Build();
+    }
+}

src/SimpleStateMachine.StructuralSearch/ReplaceTemplate/IReplaceStep.cs

@@ -0,0 +1,7 @@
+namespace SimpleStateMachine.StructuralSearch.ReplaceTemplate
+{
+    public interface IReplaceStep
+    {
+        string GetValue();
+    }
+}

src/SimpleStateMachine.StructuralSearch/ReplaceTemplate/ParserToReplace.cs

@@ -0,0 +1,21 @@
+using Pidgin;
+using SimpleStateMachine.StructuralSearch.Extensions;
+
+namespace SimpleStateMachine.StructuralSearch.ReplaceTemplate
+{
+    public static class ParserToReplace
+    {
+        public static Parser<char, IReplaceStep> ResultAsReplace(Parser<char, string> parser)
+        {
+            return parser.Select(result => new TokenReplace(result))
+                .As<char, TokenReplace, IReplaceStep>();
+        }
+        
+        public static Parser<char, IReplaceStep> Stringc(char token)
+        {
+            var _token = token.ToString();
+            
+            return ResultAsReplace(Parser.String(_token));
+        }
+    }
+}

src/SimpleStateMachine.StructuralSearch/ReplaceTemplate/PlaceholderReplace.cs

@@ -0,0 +1,17 @@
+namespace SimpleStateMachine.StructuralSearch.ReplaceTemplate
+{
+    public class PlaceholderReplace:IReplaceStep
+    {
+        public string Name { get; }
+        
+        public PlaceholderReplace(string name)
+        {
+            Name = name;
+        }
+        
+        public string GetValue()
+        {
+            return Name;
+        }
+    }
+}

src/SimpleStateMachine.StructuralSearch/ReplaceTemplate/ReplaceBuilder.cs

@@ -0,0 +1,29 @@
+using System.Collections.Generic;
+using System.Text;
+using Pidgin;
+
+namespace SimpleStateMachine.StructuralSearch.ReplaceTemplate
+{
+    public class ReplaceBuilder : IReplaceBuilder
+    {
+        public IEnumerable<IReplaceStep> Steps { get; }
+
+        public ReplaceBuilder(IEnumerable<IReplaceStep> steps)
+        {
+            Steps = steps;
+        }
+
+        public string Build()
+        {
+            StringBuilder stringBuilder = new StringBuilder();
+
+            foreach (var step in Steps)
+            {
+                stringBuilder.Append(step.GetValue());
+            }
+
+            var result = stringBuilder.ToString();
+            return result;
+        }
+    }
+}

src/SimpleStateMachine.StructuralSearch/ReplaceTemplate/TokenReplace.cs

@@ -0,0 +1,16 @@
+namespace SimpleStateMachine.StructuralSearch.ReplaceTemplate
+{
+    public class TokenReplace : IReplaceStep
+    {
+        public string Token { get; }
+        public TokenReplace(string token)
+        {
+            Token = token;
+        }
+
+        public string GetValue()
+        {
+            return Token;
+        }
+    }
+}

src/SimpleStateMachine.StructuralSearch/StructuralSearch/ReplaceTemplateParser.cs

@@ -0,0 +1,59 @@
+using System.Collections.Generic;
+using System.Linq;
+using Pidgin;
+using SimpleStateMachine.StructuralSearch.Extensions;
+using SimpleStateMachine.StructuralSearch.ReplaceTemplate;
+
+namespace SimpleStateMachine.StructuralSearch
+{
+    public class ReplaceTemplateParser
+    {
+        static ReplaceTemplateParser()
+        {
+            Parenthesised = Parsers.BetweenOneOfChars(ParserToReplace.Stringc,
+                Parser.Rec(() => Term),
+                Constant.AllParenthesised);
+
+            Term = Parser.OneOf(Parenthesised, Token)
+                .Many()
+                .MergerMany();
+
+            TemplateParser = Parser.OneOf(Parenthesised, Token)
+                .AtLeastOnce()
+                .MergerMany();
+        }
+
+        public static readonly Parser<char, IReplaceStep> Empty = 
+            ParserToReplace.ResultAsReplace(CommonParser.Empty);
+
+        public static readonly Parser<char, IReplaceStep> AnyString = 
+            ParserToReplace.ResultAsReplace(CommonParser.AnyString)
+                .Try();
+
+        public static readonly Parser<char, IReplaceStep> WhiteSpaces =
+            ParserToReplace.ResultAsReplace(CommonParser.WhiteSpaces)
+                .Try();
+
+        public static readonly Parser<char, IReplaceStep> Placeholder =
+            CommonTemplateParser.Placeholder.Select(name=> new PlaceholderReplace(name))
+                .As<char, PlaceholderReplace, IReplaceStep>()
+                .Try();
+
+        public static readonly Parser<char, IEnumerable<IReplaceStep>> Token =
+            Parser.OneOf(AnyString, Placeholder, WhiteSpaces)
+                .AsMany();
+
+        public static readonly Parser<char, IEnumerable<IReplaceStep>> Term;
+
+        public static readonly Parser<char, IEnumerable<IReplaceStep>> Parenthesised;
+
+        private static readonly Parser<char, IEnumerable<IReplaceStep>> TemplateParser;
+
+        internal static IReplaceBuilder ParseTemplate(string str)
+        {
+            return TemplateParser
+                .Select(steps => new ReplaceBuilder(steps))
+                .ParseOrThrow(str);
+        }
+    }
+}