Fix parsers, check on EOF

Author: RomanSoloweow

src/SimpleStateMachine.StructuralSearch.Tests/FindRuleParserTests.cs

@@ -49,17 +49,17 @@ public void FindRuleExprParsingShouldBeEqualsCustomResult(string ruleStr, string
             Assert.NotNull(rule);
             Assert.Equal(_ruleStr, customResult.ToLower());
         }
-        
         [Theory]
-        [InlineData("FindRule/NullUnionOperator.txt", "$sign$ In \"Is\",\"==\",\"!=\",\"is not\"")]
+        [InlineData("FindRule/NullUnionOperator.txt", "$sign$ In \"Is\",\"==\",\"!=\",\"is not\"",  "$value$ In $value1$,\"$value1$.Value\",$value2$,\"$value2$.Value\"")]
         [InlineData("FindRule/AssignmentNullUnionOperator.txt", "$sign$ In \"Is\",\"==\",\"!=\",\"is not\"")]
-        public void FindRuleParsingFromFileShouldBeSuccess(string filePath, string customResult)
+        public void FindRuleParsingFromFileShouldBeSuccess(string filePath, params string[] customResult)
         {
             var ruleStr = File.ReadAllText(filePath);
-            var rule = StructuralSearch.ParseFindRule(ruleStr);
-            var _ruleStr = rule.ToString()?.ToLower();
-            Assert.NotNull(rule);
-            Assert.Equal(_ruleStr, customResult.ToLower());
+            var rules = ruleStr.Split(Constant.LineFeed)
+                .Select(StructuralSearch.ParseFindRule);
+            var rulesAsStr = rules.Select(x => x.ToString()).ToArray();
+            
+            Assert.True(customResult.SequenceEqual(rulesAsStr));
         }
     }
 }

src/SimpleStateMachine.StructuralSearch.Tests/FindTemplateParserTests.cs

@@ -12,7 +12,7 @@ public class FindTemplateTests
         [InlineData("FindTemplate/AssignmentNullUnionOperator.txt")]
         [InlineData("FindTemplate/NestedParenthesised.txt")]
         [InlineData("FindTemplate/TernaryOperator.txt")]
-        public void TemplateParsingShouldBeSuccess(string templatePath)
+        public void FindTemplateParsingShouldBeSuccess(string templatePath)
         {
            var findTemplate = File.ReadAllText(templatePath);
            var template = StructuralSearch.ParseFindTemplate(findTemplate);
@@ -40,5 +40,12 @@ public void SourceParsingBeFindTemplateShouldBeSuccess(string templatePath, stri
             Assert.NotNull(findParser);
             Assert.Equal(match.Match.Lenght, source.Length);
         }
+        
+        [Theory]
+        [InlineData("( $var$")]
+        public void FindTemplateParsingShouldBeFail(string templateStr)
+        {
+            Assert.Throws<ParseException>(() => StructuralSearch.ParseFindTemplate(templateStr));
+        }
     }
 }

src/SimpleStateMachine.StructuralSearch.Tests/ReplaceRuleParserTests.cs

@@ -24,5 +24,24 @@ public void ReplaceRuleParsingShouldBeSuccess(string replaceRule)
             Assert.Equal(ruleStr, replaceRule.ToLower());
         }
 
+        [Theory]
+        [InlineData("($var1$ equals $var2$) then $var1$ => \"test $var3$\"", "$var1$ equals $var2$ then $var1$ => \"test $var3$\"")]
+        public void ReplaceRuleShouldBeEqualsString(string replaceRule, string customResult)
+        {
+            var rule = StructuralSearch.ParseReplaceRule(replaceRule);
+            var ruleStr = rule.ToString().ToLower();
+             Assert.NotNull(rule);
+            Assert.Equal(ruleStr, customResult.ToLower());
+        }
+        
+        [Theory]
+        [InlineData("$var1$ equals $var2$ then $var1$ => (\"test $var3$\"")]
+        [InlineData("($var1$ equals $var2$ then $var1$ => \"test $var3$\"")]
+        [InlineData("$var1$ equals $var2$ then ($var1$) => \"test $var3$\"")]
+        public void ReplaceRuleParsingShouldBeFail(string replaceRuleStr)
+        {
+            Assert.Throws<ParseException>(() => StructuralSearch.ParseReplaceRule(replaceRuleStr));
+        }
+        
     }
 }

src/SimpleStateMachine.StructuralSearch.Tests/ReplaceTemplateTests.cs

@@ -1,6 +1,7 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using Pidgin;
 using SimpleStateMachine.StructuralSearch.Tests.Mock;
 using Xunit;
 
@@ -53,11 +54,22 @@ public void ReplaceBuildShouldBeSuccess(string templatePath, string resultPath,
 
         [Theory]
         [InlineData("test $var1$.Lenght")]
+        [InlineData("(test $var1$.Lenght)")]
+        [InlineData("test ($var1$.Lenght)")]
         public void ReplaceTemplateParsingShouldBeSuccess(string templateStr)
         {
             var replaceBuilder = StructuralSearch.ParseReplaceTemplate(templateStr);
             var replaceStr = replaceBuilder.ToString().ToLower();
             Assert.Equal(replaceStr, templateStr.ToLower());
         }
+        
+        [Theory]
+        [InlineData("(test $var1$.Lenght")]
+        [InlineData("test ($var1$.Lenght")]
+        [InlineData("test $var1$.Lenght)")]
+        public void ReplaceTemplateParsingShouldBeFail(string templateStr)
+        {
+            Assert.Throws<ParseException>(() => StructuralSearch.ParseReplaceTemplate(templateStr));
+        }
     }
 }

src/SimpleStateMachine.StructuralSearch/StructuralSearch/CommonParser.cs

@@ -15,6 +15,9 @@ internal static readonly Parser<char, char> AnyChar
         internal static readonly Parser<char, char> Space
             = Char(Constant.Space);
 
+        internal static readonly Parser<char, Unit> EOF
+            = Parser<char>.End;
+        
         internal static readonly Parser<char, string> AnyString
             = AnyChar.AtLeastOnceString();
 

src/SimpleStateMachine.StructuralSearch/StructuralSearch/FindRulesParser.cs

@@ -71,7 +71,7 @@ internal static readonly Parser<char, Func<IRule, IRule>> Not
 
         internal static IRule ParseTemplate(string str)
         {
-            return Expr.ParseOrThrow(str);
+            return Expr.Before(CommonParser.EOF).ParseOrThrow(str);
         }
     }
 }

src/SimpleStateMachine.StructuralSearch/StructuralSearch/FindTemplateParser.cs

@@ -17,7 +17,7 @@ static FindTemplateParser()
                 .MergerMany();
 
             TemplateParser = Parser.OneOf(Parenthesised, Token)
-                .AtLeastOnce()
+                .AtLeastOnceUntil(CommonParser.EOF)
                 .MergerMany();
 
             SeriesParser = TemplateParser.Select(parsers => new SeriesParser(parsers));

src/SimpleStateMachine.StructuralSearch/StructuralSearch/ReplaceRuleParser.cs

@@ -42,7 +42,7 @@ public static class ReplaceRuleParser
 
         internal static ReplaceRule ParseTemplate(string str)
         {
-            return ReplaceRule.ParseOrThrow(str);
+            return ReplaceRule.Before(CommonParser.EOF).ParseOrThrow(str);
         }
     }
 }

src/SimpleStateMachine.StructuralSearch/StructuralSearch/ReplaceTemplateParser.cs

@@ -18,7 +18,7 @@ static ReplaceTemplateParser()
                 .MergerMany();
 
             TemplateParser = Parser.OneOf(Parenthesised, Token)
-                .AtLeastOnce()
+                .AtLeastOnceUntil(CommonParser.EOF)
                 .MergerMany();
         }