push

Author: RomanSoloweow

src/SimpleStateMachine.StructuralSearch.Tests/PlaceholderParserTests.cs

@@ -12,6 +12,7 @@ public static class PlaceholderParserTests
     [InlineData("($test$)", "(value (test) )", "value (test) ")]
     [InlineData("$var$;", "test;;",  "test")]
     [InlineData("$var$;.", "test;;;.", "test;;")]
+    [InlineData("$value2$(123)", "temp1(123)", "temp1")]
     [InlineData("$value2$", "temp1 ?? temp2", "temp1 ?? temp2")]
     [InlineData("$value2$;", "temp1 ?? temp2;", "temp1 ?? temp2")]
     public static void PlaceholderParsingShouldBeSuccess(string template, string source, string expectedResult)

src/SimpleStateMachine.StructuralSearch.Tests/Tests.cs

@@ -0,0 +1,35 @@
+using Pidgin;
+using SimpleStateMachine.StructuralSearch.CustomParsers;
+using SimpleStateMachine.StructuralSearch.Extensions;
+using Xunit;
+
+namespace SimpleStateMachine.StructuralSearch.Tests;
+
+public static class Tests
+{
+    [Theory]
+    [InlineData("temp1 ?? temp2;", ";", "temp1 ?? temp2")]
+    [InlineData("(value )", null, "value ")]
+    [InlineData("(value )", null, "value")]
+    [InlineData("(value (test))", null, "value (test)")]
+    [InlineData("(value (test) )", null, "value (test) ")]
+    [InlineData("test;;",  ";", "test;")]
+    [InlineData("test;;;.", ".", "test;;")]
+    [InlineData( "temp1(123)", null,"temp1")]
+    [InlineData("temp1 ?? temp2", null, "temp1 ?? temp2")]
+    public static void PlaceholderParsingShouldBeSuccess(string input, string? terminator, string expectedResult)
+    {
+        var terminatorParser = terminator is null ? Parser.EndOfLine : Parser.String(terminator);
+        var result = Parser.AnyCharExcept().AtLeastOnceAsStringUntil(terminatorParser).ParseOrThrow(expectedResult);
+        Assert.Equal(expectedResult, result);
+    }
+    
+    [Theory]
+    [InlineData("temp1;", ";", "temp1 ?? temp2")]
+    public static void PlaceholderParsingShouldBeSuccess2(string input, string terminator, string expectedResult)
+    {
+        var terminatorParser = Parser.String(terminator).Try().Select(x => Unit.Value);
+        var result = PlaceholderParser.CreateParser(terminatorParser).ParseToEnd(input);
+        Assert.Equal(expectedResult, result);
+    }
+}

src/SimpleStateMachine.StructuralSearch/CustomParsers/FindTemplateParser.cs

@@ -5,7 +5,7 @@
 
 namespace SimpleStateMachine.StructuralSearch.CustomParsers;
 
-internal class FindTemplateParser : Parser<char, IEnumerable<string>>, IContextDependent
+internal class FindTemplateParser : Parser<char, List<string>>, IContextDependent
 {
     private readonly List<Parser<char, string>> _parsers;
 
@@ -31,7 +31,7 @@ private void InitializeLookaheadParsers()
         }
     }
 
-    public override bool TryParse(ref ParseState<char> state, ref PooledList<Expected<char>> expected, out IEnumerable<string> result)
+    public override bool TryParse(ref ParseState<char> state, ref PooledList<Expected<char>> expected, out List<string> result)
     {
         var results = new List<string>();
         var count = _parsers.Count;

src/SimpleStateMachine.StructuralSearch/CustomParsers/PlaceholderParser.cs

@@ -10,14 +10,14 @@ namespace SimpleStateMachine.StructuralSearch.CustomParsers;
 
 internal class PlaceholderParser : ParserWithLookahead<char, string>, IContextDependent
 {
-    private static readonly IReadOnlySet<char> InvalidStringLiteralChars = new HashSet<char>(Constant.AllParenthesis)
+    internal static readonly IReadOnlySet<char> InvalidStringLiteralChars = new HashSet<char>(Constant.AllParenthesis)
     {
         Constant.CarriageReturn,
         Constant.LineFeed,
         Constant.Space
     };
 
-    private static readonly Parser<char, char> StringLiteralChar = Parser.AnyCharExcept(InvalidStringLiteralChars);
+    internal static readonly Parser<char, char> StringLiteralChar = Parser.AnyCharExcept(InvalidStringLiteralChars);
 
     private readonly string _name;
     private IParsingContext? _context;
@@ -62,13 +62,46 @@ protected override Parser<char, string> BuildParser(Func<Parser<char, string>?>
             }).Try());
         }
 
-        var anyString = StringLiteralChar.AtLeastOnceAsStringUntil(lookahead);
-        var simpleString = StringLiteralChar.AtLeastOnceString();
+        return CreateParser(lookahead);
+
+
+        //parenthesised and tokens and whiteSpaces
+        // var prdsAndTokens = Parser.OneOf(parenthesised, token)
+        //     .AtLeastOnceUntil(lookahead)
+        //     .JoinToString()
+        //     .Try();
+
+        // var parser = prdsAndTokens.Or(anyString);
+    }
+
+    // internal static Parser<char, string> CreateParser(Parser<char, Unit> terminator)
+    // {
+    //     var simpleString = StringLiteralChar.AtLeastOnceAsStringUntil(terminator).Select(x => x);
+    //     var whitespaces = Parser.OneOf(Constant.WhitespaceChars).AtLeastOnceAsStringUntil(terminator).Select(x => x);
+    //     var token = Parser.OneOf(simpleString.Try(), whitespaces).Select(x => x);
+    //
+    //     Parser<char, string>? parser = null;
+    //
+    //     // var parserBetweenParentheses = Parser.Rec(() => parser ?? throw new ArgumentNullException(nameof(parser)))
+    //     //     .BetweenAnyParentheses((c1, s, c2) => $"{c1}{s}{c2}");
+    //
+    //     // parser = Parser.OneOf(token, parserBetweenParentheses).AtLeastOnceUntil(terminator).JoinToString();
+    //     parser = token.Try().Many().JoinToString();
+    //     return parser;
+    // }
+    
+    internal static Parser<char, string> CreateParser(Parser<char, Unit> terminator)
+    {
+        var anyString = InvalidStringLiteralChars.AnyCharWithPlshd
+            .AtLeastOnceAsStringUntil(lookahead);
+
+        var simpleString = CommonTemplateParser.StringWithPlshd;
         var token = Parser.OneOf(simpleString, Grammar.WhiteSpaces).Try();
         Parser<char, string>? term = null;
 
-        var parenthesised = Parser.Rec(() => term ?? throw new ArgumentNullException(nameof(term)))
-            .BetweenAnyParentheses((c1, s, c2) => $"{c1}{s}{c2}");
+        var parenthesised = Parsers.BetweenOneOfChars(x => Parser.Char(x).AsString(),
+            expr: Parser.Rec(() => term ?? throw new ArgumentNullException(nameof(term))),
+            Constant.AllParenthesised).JoinToString();
 
         term = Parser.OneOf(parenthesised, token).Many().JoinToString();
 
@@ -81,7 +114,7 @@ protected override Parser<char, string> BuildParser(Func<Parser<char, string>?>
         var parser = prdsAndTokens.Or(anyString);
         return parser;
     }
-
+    
     public override bool TryParse(ref ParseState<char> state, ref PooledList<Expected<char>> expected,
         out string result)
     {

src/SimpleStateMachine.StructuralSearch/StructuralSearch/StructuralSearch.cs

@@ -1,5 +1,4 @@
 using System.Linq;
-using Pidgin;
 using SimpleStateMachine.StructuralSearch.CustomParsers;
 using SimpleStateMachine.StructuralSearch.Extensions;
 using SimpleStateMachine.StructuralSearch.Operator.Logical;