Update configs

Author: RomanSoloweow

src/SimpleStateMachine.StructuralSearch.Tests/ConfigurationFile/FullConfig.yml

@@ -23,7 +23,7 @@
     ReplaceTemplate: |-
       $var$ = $value1$ ?? $value2$;
     ReplaceRules:
-      - $sign$ In ("!=", "is not") then $value2$ => $value1$, $value1$ => $value2$
+      - if $sign$ In ("!=", "is not") then $value2$ => $value1$, $value1$ => $value2$
 
 #  TernaryOperator 
 

src/SimpleStateMachine.StructuralSearch.Tests/ConfigurationFile/ShortConfig.yml

@@ -22,7 +22,7 @@
     ReplaceTemplate: |-
       $var$ = $value1$ ?? $value2$;
     ReplaceRules:
-      - $sign$ In ("!=", "is not") then $value2$ => $value1$, $value1$ => $value2$
+      - if $sign$ In ("!=", "is not") then $value2$ => $value1$, $value1$ => $value2$
       
 #  TernaryOperator   
 

src/SimpleStateMachine.StructuralSearch.Tests/FindRuleParserTests.cs

@@ -8,6 +8,13 @@ namespace SimpleStateMachine.StructuralSearch.Tests;
 
 public class FindRuleParserTests
 {
+    [Theory]
+    [InlineData("$sign$ In (\"is\", \"==\", \"!=\", \"is not\")")]
+    public static void FindRuleParsingShouldBeSuccess(string ruleStr)
+    {
+        LogicalExpressionParser.LogicalExpression.ParseToEnd(ruleStr);
+    }
+    
     [Theory]
     [FilesData("FindRule")]
     public static void FindRuleFileParsingShouldBeSuccess(string filePath)

src/SimpleStateMachine.StructuralSearch.Tests/ReplaceRule/NullUnionOperator.txt

@@ -1 +1 @@
-$sign$ In ("!=", "is not") then $value2$ => $value1$, $value1$ => $value2$
+if $sign$ In ("!=", "is not") then $value2$ => $value1$, $value1$ => $value2$

src/SimpleStateMachine.StructuralSearch.Tests/ReplaceTemplateTests.cs

@@ -36,9 +36,7 @@ public static void ReplaceBuildShouldBeSuccess(string templatePath, string resul
         Assert.NotNull(replaceResult);
         Assert.Equal(replaceResult, result);
     }
-        
-    // TODO validation parenthesis for parameters
-        
+
     [Theory]
     [InlineData("test")]
     [InlineData("()")]

src/SimpleStateMachine.StructuralSearch.Tests/StructurSearchParserTests.cs

@@ -18,7 +18,7 @@ public static void StructuralSearchShouldBeSuccess(string exampleName, string ex
         var fileInfo = new FileInfo(exampleFilePath);
         var input = Input.Input.File(fileInfo);
         var matches = parser.Parse(input);
-        Assert.Equal(matches.Count(), matchesCount);
+        Assert.Equal(matchesCount, matches.Count());
     }
 
     // [Theory]

src/SimpleStateMachine.StructuralSearch/CustomParsers/PlaceholderParser.cs

@@ -61,7 +61,7 @@ protected override Parser<char, string> BuildParser(Func<Parser<char, string>?>
         Parser<char, string>? term = null;
 
         var parenthesised = Parser.Rec(() => term ?? throw new ArgumentNullException(nameof(term)))
-            .BetweenParentheses((c1, s, c2) => $"{c1}{s}{c2}");
+            .BetweenAnyParentheses((c1, s, c2) => $"{c1}{s}{c2}");
 
         term = Parser.OneOf(parenthesised, token).Many().JoinToString();
 

src/SimpleStateMachine.StructuralSearch/Extensions/ParserExtensions.cs

@@ -74,15 +74,24 @@ public static Parser<char, T> ParenthesisedOptional<T, TResult>(this Parser<char
     public static Parser<TToken, Parser<TToken, T>> SelectToParser<TToken, T>(this Parser<TToken, T> parser,
         Func<T, Parser<TToken, T>, Parser<TToken, T>> selectFunc)
         => parser.Select(value => selectFunc(value, parser));
-    
-    public static Parser<char, TResult> BetweenParentheses<T, TResult>(this Parser<char, T> parser, Func<char, T, char, TResult> mapFunc)
+
+    public static Parser<char, TResult> BetweenAnyParentheses<T, TResult>(this Parser<char, T> parser, Func<char, T, char, TResult> mapFunc)
     {
-        var parentheses= Parser.Map(mapFunc, CommonParser.LeftParenthesis, parser, CommonParser.RightParenthesis);
-        var curlyParentheses= Parser.Map(mapFunc, CommonParser.LeftCurlyParenthesis, parser, CommonParser.RightCurlyParenthesis);
-        var squareParentheses= Parser.Map(mapFunc, CommonParser.LeftSquareParenthesis, parser, CommonParser.RightSquareParenthesis);
+        var parentheses= parser.BetweenParentheses(mapFunc);
+        var curlyParentheses= parser.BetweenCurlyParentheses(mapFunc);
+        var squareParentheses= parser.BetweenSquareParentheses(mapFunc);
         return Parser.OneOf(parentheses, curlyParentheses, squareParentheses);
     }
 
+    public static Parser<char, TResult> BetweenParentheses<T, TResult>(this Parser<char, T> parser, Func<char, T, char, TResult> mapFunc)
+        => Parser.Map(mapFunc, CommonParser.LeftParenthesis, parser, CommonParser.RightParenthesis);
+
+    public static Parser<char, TResult> BetweenCurlyParentheses<T, TResult>(this Parser<char, T> parser, Func<char, T, char, TResult> mapFunc)
+        => Parser.Map(mapFunc, CommonParser.LeftCurlyParenthesis, parser, CommonParser.RightCurlyParenthesis);
+
+    public static Parser<char, TResult> BetweenSquareParentheses<T, TResult>(this Parser<char, T> parser, Func<char, T, char, TResult> mapFunc)
+        => Parser.Map(mapFunc, CommonParser.LeftSquareParenthesis, parser, CommonParser.RightSquareParenthesis);
+
     public static T ParseToEnd<T>(this Parser<char, T> parser, string str)
         => parser.Before(CommonParser.Eof).ParseOrThrow(str);
 }

src/SimpleStateMachine.StructuralSearch/StructuralSearch/FindTemplateParser.cs

@@ -26,7 +26,7 @@ private static readonly Parser<char, IEnumerable<Parser<char, string>>> Template
     // template_between_parentheses = '(' template ')' | '{' template '}' | '[' template ']
     private static readonly Parser<char, IEnumerable<Parser<char, string>>> TemplateBetweenParentheses
         = Parser.Rec(() => Template ?? throw new ArgumentNullException(nameof(Template))).Optional()
-            .BetweenParentheses((left, result, right) =>
+            .BetweenAnyParentheses((left, result, right) =>
             {
                 var leftParser = Parser.Char(left).AsString();
                 var rightParser = Parser.Char(right).AsString();

src/SimpleStateMachine.StructuralSearch/StructuralSearch/LogicalExpressionParser.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using Pidgin;
 using SimpleStateMachine.StructuralSearch.Extensions;
@@ -29,22 +30,27 @@ public static class LogicalExpressionParser
     internal static readonly Parser<char, Func<IParameter, ILogicalOperation>> MatchOperation = 
         CommonParser.Match
             .TrimEnd() // Skip whitespaces
-            .Then(Grammar.StringLiteral) // TODO support regex
+            .Then(Grammar.StringLiteral)
             .Select<Func<IParameter, ILogicalOperation>>(regex => parameter => new MatchOperation(parameter, regex));
 
+    // string_expr { ',' string_expr }
+    internal static readonly Parser<char, IEnumerable<IParameter>> InOperationParameters =
+        ParametersParser.StringExpression.SeparatedAtLeastOnce(CommonParser.Comma.TrimEnd());
+
     // in_operation ='In' [ '(' ] string_expr { ',' string_expr } [ ')' ]
     internal static readonly Parser<char, Func<IParameter, ILogicalOperation>> InOperation = 
         CommonParser.In
             .TrimEnd()// Skip whitespaces
-            .Then(ParametersParser.StringExpression.SeparatedAtLeastOnce(CommonParser.Comma.TrimEnd())) // TODO support Parentheses
+            // .Then(InOperationParameters)
+            .Then(Parser.OneOf(InOperationParameters.BetweenParentheses((_, parameters, _) => parameters), InOperationParameters))
             .Select<Func<IParameter, ILogicalOperation>>(arguments => 
                 parameter => new InOperation(parameter, arguments.ToList()));
 
     // string_logic_operation = string_expr (string_compare_operation | is_operation | match_operation| in_operation )
     private static readonly Parser<char, ILogicalOperation> StringLogicOperation = 
         ParametersParser.StringExpression
             .TrimEnd() // skip whitespaces
-            .Then(Parser.OneOf(StringCompareOperation, IsOperation, MatchOperation, InOperation), 
+            .Then(Parser.OneOf(StringCompareOperation.Try(), IsOperation.Try(), MatchOperation.Try(), InOperation), 
             (parameter, buildOperationFunc) => buildOperationFunc(parameter));
 
     // binary_operation = logic_expr ('And' | 'Or' | 'NAND' | 'NOR' | 'XOR' | 'XNOR') logic_expr