refact parser

RomanSoloweow · RomanSoloweow · commit f5a4c4e67d7e · 2022-03-12T23:50:25.000+03:00
diff --git a/src/SimpleStateMachine.StructuralSearch.Tests/FindTemplateTests.cs b/src/SimpleStateMachine.StructuralSearch.Tests/FindTemplateTests.cs
@@ -13,7 +13,7 @@ public class FindTemplateTests
         public void TemplateParsingShouldBeSuccess(string templatePath)
         {
            var findTemplate = File.ReadAllText(templatePath);
-           var template = StructuralSearch.ParseTemplate(findTemplate);
+           var template = StructuralSearch.ParseFindTemplate(findTemplate);
            
            Assert.NotNull(template);
         }
@@ -27,7 +27,7 @@ public void SourceParsingBeFindTemplateShouldBeSuccess(string templatePath, stri
             var findTemplate = File.ReadAllText(templatePath);
             var source = File.ReadAllText(sourcePath);
 
-            var template = StructuralSearch.ParseTemplate(findTemplate);
+            var template = StructuralSearch.ParseFindTemplate(findTemplate);
             var result = template.ParseOrThrow(source);
             
             Assert.NotNull(template);
diff --git a/src/SimpleStateMachine.StructuralSearch.Tests/PlaceholderParserTests.cs b/src/SimpleStateMachine.StructuralSearch.Tests/PlaceholderParserTests.cs
@@ -9,17 +9,16 @@ public class PlaceholderParserTests
         [Fact]
         public void FindTemplateShouldBeNotEmpty()
         {
-            Assert.Throws<ParseException>(() => StructuralSearch.ParseTemplate(string.Empty));
+            Assert.Throws<ParseException>(() => StructuralSearch.ParseFindTemplate(string.Empty));
         }
         
-        
         [Theory]
         [InlineData("($test$)", "(value )", "value ")]
         [InlineData("($test$ )", "(value )", "value")]
         [InlineData("($test$)", "(value (test))", "value (test)")]
         public void TemplateParsingShouldBeSuccess(string template, string source, string result)
         {
-            var templateParser = StructuralSearch.ParseTemplate(template);
+            var templateParser = StructuralSearch.ParseFindTemplate(template);
             var res = templateParser.ParseOrThrow(source);
             
             // var templateStr = File.ReadAllText(templatePath);
@@ -32,7 +31,7 @@ public void TemplateParsingShouldBeSuccess(string template, string source, strin
         [InlineData("$var$;$var2$;", "test;;;test;;;",  "value ")]
         public void TemplateParsingShouldBeSuccess2(string template, string source, string result)
         {
-            var templateParser = StructuralSearch.ParseTemplate(template);
+            var templateParser = StructuralSearch.ParseFindTemplate(template);
             var res = templateParser.ParseOrThrow(source);
             
             // var templateStr = File.ReadAllText(templatePath);
diff --git a/src/SimpleStateMachine.StructuralSearch.Tests/SimpleStateMachine.StructuralSearch.Tests.csproj b/src/SimpleStateMachine.StructuralSearch.Tests/SimpleStateMachine.StructuralSearch.Tests.csproj
@@ -35,9 +35,5 @@
             <CopyToOutputDirectory>Always</CopyToOutputDirectory>
         </Content>
     </ItemGroup>
-
-    <ItemGroup>
-      <Folder Include="ReplaceTemplate" />
-    </ItemGroup>
     
 </Project>
diff --git a/src/SimpleStateMachine.StructuralSearch/Extensions/ManyParserExtensions.cs b/src/SimpleStateMachine.StructuralSearch/Extensions/ManyParserExtensions.cs
@@ -8,7 +8,7 @@ public static class ManyParserExtensions
     {
         public static Parser<TToken, IEnumerable<T>> ToIEnumerable<TToken, T>(this Parser<TToken, List<T>> parser)
         {
-            return parser.Cast<IEnumerable<T>>();
+            return parser.As<TToken, List<T>, IEnumerable<T>>();
         }
     }
 }
diff --git a/src/SimpleStateMachine.StructuralSearch/Extensions/ParserExtensions.cs b/src/SimpleStateMachine.StructuralSearch/Extensions/ParserExtensions.cs
@@ -100,6 +100,13 @@ public static Parser<TToken, T> BetweenAsThen<TToken, T, U, V>(this Parser<TToke
                 throw new ArgumentNullException(nameof(parser2));
             return Parser.Map<TToken, U, T, V, T>(func, parser1, parser, parser2);
         }
+        
+        public static Parser<TToken, R> As<TToken, T, R>(this Parser<TToken, T> parser)
+            where T: R
+        {
+            return parser.Select(x => (R)x);
+        }
+
         // public static Parser<TToken, T> BetweenAsThen<TToken, T, U, V>(this Parser<TToken, T> parser, Parser<TToken, U> parser1, Parser<TToken, V> parser2, Func<U, T, V, T> func)
         // {
         //     if (parser1 == null)
diff --git a/src/SimpleStateMachine.StructuralSearch/Extensions/SourceMatchManyParserExtensions.cs b/src/SimpleStateMachine.StructuralSearch/Extensions/SourceMatchManyParserExtensions.cs
@@ -11,7 +11,10 @@ public static class SourceMatchParserExtensions
         // {
         //     return parsers.Select(x => Parsers.Series(x, getResult));
         // }
-        
+        public static Parser<char, Parser<char, string>> JoinResults(this Parser<char, IEnumerable<Parser<char, string>>> parsers)
+        {
+            return parsers.Select(x => Parsers.Series(x, y => string.Join(string.Empty, y)));
+        }
         public static Parser<char, Parser<char, SourceMatch>> JoinResults(this Parser<char, IEnumerable<Parser<char, SourceMatch>>> parsers)
         {
             return parsers.Select(x => Parsers.Series(x, y => y.Concatenate()));
diff --git a/src/SimpleStateMachine.StructuralSearch/FindTemplate/ParserToParser.cs b/src/SimpleStateMachine.StructuralSearch/FindTemplate/ParserToParser.cs
diff --git a/src/SimpleStateMachine.StructuralSearch/Parsers/EmptyStringParser.cs b/src/SimpleStateMachine.StructuralSearch/Parsers/EmptyStringParser.cs
diff --git a/src/SimpleStateMachine.StructuralSearch/Parsers/LookaheadParser.cs b/src/SimpleStateMachine.StructuralSearch/Parsers/LookaheadParser.cs
@@ -7,10 +7,10 @@ public abstract class LookaheadParser<TToken, T> : Parser<TToken, T>
     {
         private Parser<TToken, T> _parser { get; set; }
 
-        public abstract Parser<TToken, T> BuildParser<Res1, Res2>(Func<Parser<TToken, Res1>> next,
-            Func<Parser<TToken, Res2>> nextNext);
+        public abstract Parser<TToken, T> BuildParser(Func<Parser<TToken, T>?> next,
+            Func<Parser<TToken, T>?> nextNext);
         
-        public void Lookahead<Res1, Res2>(Func<Parser<TToken, Res1>> next, Func<Parser<TToken, Res2>> nextNext)
+        public void Lookahead(Func<Parser<TToken, T>?> next, Func<Parser<TToken, T>?> nextNext)
         {
             _parser = BuildParser(next, nextNext);
         }
diff --git a/src/SimpleStateMachine.StructuralSearch/Parsers/Parsers.cs b/src/SimpleStateMachine.StructuralSearch/Parsers/Parsers.cs
@@ -43,6 +43,22 @@ public static Parser<TToken, IEnumerable<T>> MapToMany<TToken, T>(Parser<TToken,
                 return (IEnumerable<T>)result;
             }, parser1, parser2, parser3);
         }
+        
+        public static Parser<TToken, IEnumerable<T>> MapToMany<TToken, T>(Parser<TToken, T> parser1,
+            Parser<TToken, T> parser2)
+        {
+            if (parser1 == null)
+                throw new ArgumentNullException(nameof(parser1));
+            if (parser2 == null)
+                throw new ArgumentNullException(nameof(parser2));
+
+            return Map((arg1, arg2) =>
+            {
+                var result = new List<T> { arg1, arg2 };
+                return (IEnumerable<T>)result;
+            }, parser1, parser2);
+        }
+        
 
         public static Parser<TToken, R> Series<TToken, T, R>(IEnumerable<Parser<TToken, T>> parsers,
             Func<IEnumerable<T>, R> func)
diff --git a/src/SimpleStateMachine.StructuralSearch/Parsers/PlaceholderParser.cs b/src/SimpleStateMachine.StructuralSearch/Parsers/PlaceholderParser.cs
@@ -6,7 +6,7 @@
 
 namespace SimpleStateMachine.StructuralSearch
 {
-    public class PlaceholderParser : LookaheadParser<char, SourceMatch>
+    public class PlaceholderParser : LookaheadParser<char, string>
     {
         public string Name { get; }
         
@@ -16,13 +16,14 @@ public PlaceholderParser(string name)
             Name = name;
         }
         
-        public override Parser<char, SourceMatch> BuildParser<Res1, Res2>(Func<Parser<char, Res1>> next,
-            Func<Parser<char, Res2>> nextNext)
+        public override Parser<char, string> BuildParser(Func<Parser<char, string>> next,
+            Func<Parser<char, string>> nextNext)
         {
             var _next = next();
-            var _nextNext = nextNext();
+            var _nextNext = nextNext() ?? Parser<char>.End.ThenReturn(string.Empty);
             var _lookahead = Parser.Lookahead(_next.Then(_nextNext).Try());
-            var lookahead = new DebugParser<char, Res2>(_lookahead);
+            
+            Parser<char, string> lookahead = new DebugParser<char, string>(_lookahead);
             var anyString = CommonTemplateParser.AnyCharWithPlshd
                 .AtLeastOnceAsStringUntil(lookahead);
             
@@ -42,12 +43,12 @@ public override Parser<char, SourceMatch> BuildParser<Res1, Res2>(Func<Parser<ch
                 .JoinToString()
                 .Try();
             
-            var parser = prdsAndTokens.Or(anyString).AsMatch();
+            var parser = prdsAndTokens.Or(anyString);
             return parser;
         }
         
         public override bool TryParse(ref ParseState<char> state, ref PooledList<Expected<char>> expected,
-            out SourceMatch result)
+            out string result)
         {
             var res = base.TryParse(ref state, ref expected, out result);
             return res;
diff --git a/src/SimpleStateMachine.StructuralSearch/Parsers/SeriesParser.cs b/src/SimpleStateMachine.StructuralSearch/Parsers/SeriesParser.cs
@@ -26,18 +26,8 @@ public override bool TryParse(ref ParseState<TToken> state, ref PooledList<Expec
                 if (parsers.ElementAt(i) is LookaheadParser<TToken, T> lookaheadParser)
                 {
                     var number = i;
-                    if (number + 2 <= count - 1)
-                    {
-                        lookaheadParser.Lookahead(() => parsers.ElementAt(number + 1), () =>
-                            parsers.ElementAt(number + 2));
-                    }
-                    else
-                    {
-                        //TODO remove using End (not actual for source files)
-                        lookaheadParser.Lookahead(() => parsers.ElementAt(number + 1), () =>
-                            Parser<TToken>.End);
-                    }
-              
+                    lookaheadParser.Lookahead(() => parsers.ElementAtOrDefault(number + 1), () =>
+                        parsers.ElementAtOrDefault(number + 2));
                 }
             }
             
diff --git a/src/SimpleStateMachine.StructuralSearch/SimpleStateMachine.StructuralSearch.csproj b/src/SimpleStateMachine.StructuralSearch/SimpleStateMachine.StructuralSearch.csproj
@@ -3,6 +3,7 @@
   <PropertyGroup>
     <TargetFramework>net5.0</TargetFramework>
     <LangVersion>9</LangVersion>
+    <Nullable>enable</Nullable>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/src/SimpleStateMachine.StructuralSearch/StructuralSearch/FindTemplateParser.cs b/src/SimpleStateMachine.StructuralSearch/StructuralSearch/FindTemplateParser.cs
@@ -6,10 +6,9 @@ namespace SimpleStateMachine.StructuralSearch
 {
     public static class FindTemplateParser
     {
-        //TODO return string for all parsers exclude  TemplateParser
         static FindTemplateParser()
         {
-            Parenthesised = Parsers.BetweenOneOfChars(ParserToParser.StringcMatch,
+            Parenthesised = Parsers.BetweenOneOfChars(ParserToParser.Stringc,
                 Parser.Rec(() => Term),
                 Constant.AllParenthesised);
 
@@ -23,37 +22,36 @@ static FindTemplateParser()
                 .JoinResults();
         }
         
-        
-        public static readonly Parser<char, IEnumerable<Parser<char, SourceMatch>>> Empty =
-            ParserToParser.ResultAsMatch(CommonParser.Empty)
+        public static readonly Parser<char, IEnumerable<Parser<char, string>>> Empty =
+            ParserToParser.ResultAsParser(CommonParser.Empty)
                 .AsMany();  
         
-        public static readonly Parser<char, Parser<char, SourceMatch>> AnyString =
-            ParserToParser.ResultAsMatch(CommonParser.AnyString)
+        public static readonly Parser<char, Parser<char, string>> AnyString =
+            ParserToParser.ResultAsParser(CommonParser.AnyString)
                 .Try();
             
-        public static readonly Parser<char, Parser<char, SourceMatch>> WhiteSpaces =
-            ParserToParser.ResultAsMatch(CommonParser.WhiteSpaces)
+        public static readonly Parser<char, Parser<char, string>> WhiteSpaces =
+            ParserToParser.ResultAsParser(CommonParser.WhiteSpaces)
                 .Try();  
         
-        public static readonly Parser<char, Parser<char, SourceMatch>> Placeholder = 
+        public static readonly Parser<char, Parser<char, string>> Placeholder = 
             CommonTemplateParser.Placeholder
                 .Select(name => new PlaceholderParser(name))
-                .Cast<Parser<char, SourceMatch>>(); 
+                .As<char, PlaceholderParser, Parser<char, string>>(); 
         
-        public static readonly Parser<char, IEnumerable<Parser<char, SourceMatch>>> Token =
+        public static readonly Parser<char, IEnumerable<Parser<char, string>>> Token =
             Parser.OneOf(AnyString, Placeholder, WhiteSpaces)
                 .AsMany(); 
         
-        public static readonly Parser<char, IEnumerable<Parser<char, SourceMatch>>> Term;
+        public static readonly Parser<char, IEnumerable<Parser<char, string>>> Term;
         
-        public static readonly Parser<char, IEnumerable<Parser<char, SourceMatch>>> Parenthesised;
+        public static readonly Parser<char, IEnumerable<Parser<char, string>>> Parenthesised;
         
-        private static readonly Parser<char, Parser<char, SourceMatch>> TemplateParser;
+        private static readonly Parser<char, Parser<char, string>> TemplateParser;
         
         internal static Parser<char, SourceMatch> ParseTemplate(string str)
         {
-            return TemplateParser.ParseOrThrow(str);
+            return TemplateParser.ParseOrThrow(str).AsMatch();
         }
         
         
diff --git a/src/SimpleStateMachine.StructuralSearch/StructuralSearch/StructuralSearch.cs b/src/SimpleStateMachine.StructuralSearch/StructuralSearch/StructuralSearch.cs
@@ -1,10 +1,14 @@
 ﻿using Pidgin;
+using SimpleStateMachine.StructuralSearch.ReplaceTemplate;
 
 namespace SimpleStateMachine.StructuralSearch
 {
     public static class StructuralSearch
     {
-        public static Parser<char, SourceMatch> ParseTemplate(string str) 
-            => FindTemplateParser.ParseTemplate(str);
+        public static Parser<char, SourceMatch> ParseFindTemplate(string template) 
+            => FindTemplateParser.ParseTemplate(template);
+        
+        public static IReplaceBuilder ParseReplaceTemplate(string template) 
+            => ReplaceTemplateParser.ParseTemplate(template);
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,7 @@ public class FindTemplateTests`
`13`	`13`	`public void TemplateParsingShouldBeSuccess(string templatePath)`
`14`	`14`	`{`
`15`	`15`	`var findTemplate = File.ReadAllText(templatePath);`
`16`		`- var template = StructuralSearch.ParseTemplate(findTemplate);`
	`16`	`+ var template = StructuralSearch.ParseFindTemplate(findTemplate);`
`17`	`17`
`18`	`18`	`Assert.NotNull(template);`
`19`	`19`	`}`
`@@ -27,7 +27,7 @@ public void SourceParsingBeFindTemplateShouldBeSuccess(string templatePath, stri`
`27`	`27`	`var findTemplate = File.ReadAllText(templatePath);`
`28`	`28`	`var source = File.ReadAllText(sourcePath);`
`29`	`29`
`30`		`- var template = StructuralSearch.ParseTemplate(findTemplate);`
	`30`	`+ var template = StructuralSearch.ParseFindTemplate(findTemplate);`
`31`	`31`	`var result = template.ParseOrThrow(source);`
`32`	`32`
`33`	`33`	`Assert.NotNull(template);`
Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,7 @@ public static class ManyParserExtensions`
`8`	`8`	`{`
`9`	`9`	`public static Parser<TToken, IEnumerable<T>> ToIEnumerable<TToken, T>(this Parser<TToken, List<T>> parser)`
`10`	`10`	`{`
`11`		`- return parser.Cast<IEnumerable<T>>();`
	`11`	`+ return parser.As<TToken, List<T>, IEnumerable<T>>();`
`12`	`12`	`}`
`13`	`13`	`}`
`14`	`14`	`}`
Original file line number	Diff line number	Diff line change
`@@ -7,10 +7,10 @@ public abstract class LookaheadParser<TToken, T> : Parser<TToken, T>`
`7`	`7`	`{`
`8`	`8`	`private Parser<TToken, T> _parser { get; set; }`
`9`	`9`
`10`		`- public abstract Parser<TToken, T> BuildParser<Res1, Res2>(Func<Parser<TToken, Res1>> next,`
`11`		`- Func<Parser<TToken, Res2>> nextNext);`
	`10`	`+ public abstract Parser<TToken, T> BuildParser(Func<Parser<TToken, T>?> next,`
	`11`	`+ Func<Parser<TToken, T>?> nextNext);`
`12`	`12`
`13`		`- public void Lookahead<Res1, Res2>(Func<Parser<TToken, Res1>> next, Func<Parser<TToken, Res2>> nextNext)`
	`13`	`+ public void Lookahead(Func<Parser<TToken, T>?> next, Func<Parser<TToken, T>?> nextNext)`
`14`	`14`	`{`
`15`	`15`	`_parser = BuildParser(next, nextNext);`
`16`	`16`	`}`