Skip to content

Commit 2bc4bfe

Browse files
RomanSoloweowRomanSoloweow
committed
Push
1 parent 14bf1d0 commit 2bc4bfe

35 files changed

+301
-464
lines changed

‎src/SimpleStateMachine.StructuralSearch.Tests/FindTemplateParserTests.cs‎

Lines changed: 38 additions & 43 deletions
Original file line numberDiff line numberDiff line change
@@ -1,61 +1,56 @@
11
using System.IO;
2-
using System.Linq;
32
using Pidgin;
3+
using SimpleStateMachine.StructuralSearch.StructuralSearch;
44
using Xunit;
55

66
namespace SimpleStateMachine.StructuralSearch.Tests;
77

8-
public static class FindTemplateTests
8+
public static class FindTemplateParserTests
99
{
1010
[Theory]
11-
[InlineData("FindTemplate/NullUnionOperator.txt")]
12-
[InlineData("FindTemplate/AssignmentNullUnionOperator.txt")]
13-
[InlineData("FindTemplate/NestedParenthesised.txt")]
14-
[InlineData("FindTemplate/TernaryOperator.txt")]
15-
public static void FindTemplateFromFileParsingShouldBeSuccess(string templatePath)
16-
{
17-
var findTemplate = File.ReadAllText(templatePath);
18-
var template = StructuralSearch.StructuralSearch.ParseFindTemplate(findTemplate);
19-
20-
Assert.NotNull(template);
21-
}
22-
23-
[Theory]
24-
[InlineData("FindTemplate/NullUnionOperator.txt", "Source/NullUnionOperator.txt")]
25-
[InlineData("FindTemplate/AssignmentNullUnionOperator.txt", "Source/AssignmentNullUnionOperator.txt")]
26-
[InlineData("FindTemplate/NestedParenthesised.txt", "Source/NestedParenthesised.txt")]
27-
[InlineData("FindTemplate/TernaryOperator.txt", "Source/TernaryOperator.txt")]
28-
public static void SourceParsingBeFindTemplateShouldBeSuccess(string templatePath, string sourcePath)
29-
{
30-
var findTemplate = File.ReadAllText(templatePath);
31-
var source = File.ReadAllText(sourcePath);
32-
var input = Input.Input.String(source);
33-
var findParser = StructuralSearch.StructuralSearch.ParseFindTemplate(findTemplate);
34-
var matches = findParser.Parse(input);
35-
Assert.Single(matches);
36-
37-
var match = matches.First();
38-
39-
Assert.NotNull(findParser);
40-
Assert.Equal(match.Match.Length, source.Length);
41-
}
42-
43-
[Theory]
44-
[InlineData("( $var$")]
45-
public static void FindTemplateParsingShouldBeFail(string templateStr)
46-
{
47-
Assert.Throws<ParseException<char>>(() => StructuralSearch.StructuralSearch.ParseFindTemplate(templateStr));
48-
}
49-
50-
[Theory]
11+
[InlineData("()")]
12+
[InlineData("(123)")]
5113
[InlineData("($var$)")]
5214
[InlineData("($var$)(123)")]
5315
[InlineData("($var$)( )")]
5416
[InlineData("($var$) ( )")]
5517
[InlineData("( $var$ )")]
5618
[InlineData("(123$var$)")]
19+
[InlineData("if ($value$ $sign$ null)")]
5720
public static void FindTemplateParsingShouldBeSuccess(string templateStr)
5821
{
59-
var template = StructuralSearch.StructuralSearch.ParseFindTemplate(templateStr);
22+
var template = FindTemplateParser.Template.Before(CommonParser.Eof).ParseOrThrow(templateStr);
23+
}
24+
25+
[Theory]
26+
[InlineData("FindTemplate/NullUnionOperator.txt")]
27+
[InlineData("FindTemplate/AssignmentNullUnionOperator.txt")]
28+
[InlineData("FindTemplate/NestedParenthesised.txt")]
29+
[InlineData("FindTemplate/TernaryOperator.txt")]
30+
public static void FindTemplateFileParsingShouldBeSuccess(string templatePath)
31+
{
32+
var templateStr = File.ReadAllText(templatePath);
33+
var parsers = FindTemplateParser.Template.Before(CommonParser.Eof).ParseOrThrow(templateStr);
34+
Assert.NotEmpty(parsers);
6035
}
36+
37+
// [Theory]
38+
// [InlineData("FindTemplate/NullUnionOperator.txt", "Source/NullUnionOperator.txt")]
39+
// [InlineData("FindTemplate/AssignmentNullUnionOperator.txt", "Source/AssignmentNullUnionOperator.txt")]
40+
// [InlineData("FindTemplate/NestedParenthesised.txt", "Source/NestedParenthesised.txt")]
41+
// [InlineData("FindTemplate/TernaryOperator.txt", "Source/TernaryOperator.txt")]
42+
// public static void SourceParsingBeFindTemplateShouldBeSuccess(string templatePath, string sourcePath)
43+
// {
44+
// var findTemplate = File.ReadAllText(templatePath);
45+
// var source = File.ReadAllText(sourcePath);
46+
// var input = Input.Input.String(source);
47+
// var findParser = StructuralSearch.StructuralSearch.ParseFindTemplate(findTemplate);
48+
// var matches = findParser.Parse(input);
49+
// Assert.Single(matches);
50+
//
51+
// var match = matches.First();
52+
//
53+
// Assert.NotNull(findParser);
54+
// Assert.Equal(match.Match.Length, source.Length);
55+
// }
6156
}

‎src/SimpleStateMachine.StructuralSearch.Tests/LogicalExpressionParserTests.cs‎

Lines changed: 0 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1,8 +1,6 @@
11
using System;
22
using System.Collections.Generic;
3-
using System.Linq;
43
using Pidgin;
5-
using SimpleStateMachine.StructuralSearch.Extensions;
64
using SimpleStateMachine.StructuralSearch.Operator.Logical.Type;
75
using SimpleStateMachine.StructuralSearch.StructuralSearch;
86
using Xunit;

‎src/SimpleStateMachine.StructuralSearch.Tests/PlaceholderParserTests.cs‎

Lines changed: 41 additions & 41 deletions
Original file line numberDiff line numberDiff line change
@@ -1,41 +1,41 @@
1-
using System.Linq;
2-
using Xunit;
3-
4-
namespace SimpleStateMachine.StructuralSearch.Tests;
5-
6-
public static class PlaceholderParserTests
7-
{
8-
[Theory]
9-
[InlineData("($test$)", "(value )", "value ")]
10-
[InlineData("($test$ )", "(value )", "value")]
11-
[InlineData("($test$123)", "(value123)", "value")]
12-
[InlineData("($test$)", "(value (test))", "value (test)")]
13-
[InlineData("($test$)", "(value (test) )", "value (test) ")]
14-
public static void TemplateParsingShouldBeSuccess(string template, string source, string result)
15-
{
16-
var input = Input.Input.String(source);
17-
var templateParser = StructuralSearch.StructuralSearch.ParseFindTemplate(template);
18-
var matches = templateParser.Parse(input);
19-
20-
Assert.Single(matches);
21-
var match = matches.First();
22-
Assert.Single(match.Placeholders);
23-
var placeholder = match.Placeholders.First();
24-
25-
Assert.Equal(placeholder.Value.Value, result);
26-
}
27-
28-
[Theory]
29-
[InlineData("$var$;", "test;;", "test")]
30-
[InlineData("$var$;.", "test;;;.", "test;;")]
31-
public static void TemplateParsingShouldBeSuccess2(string template, string source, params string[] values)
32-
{
33-
var input = Input.Input.String(source);
34-
var templateParser = StructuralSearch.StructuralSearch.ParseFindTemplate(template);
35-
var matches = templateParser.Parse(input);
36-
Assert.Single(matches);
37-
var match = matches.First();
38-
Assert.Equal(match.Placeholders.Count, values.Length);
39-
Assert.Equal(match.Placeholders.Select(x=> x.Value.Value), values);
40-
}
41-
}
1+
// using System.Linq;
2+
// using Xunit;
3+
//
4+
// namespace SimpleStateMachine.StructuralSearch.Tests;
5+
//
6+
// public static class PlaceholderParserTests
7+
// {
8+
// [Theory]
9+
// [InlineData("($test$)", "(value )", "value ")]
10+
// [InlineData("($test$ )", "(value )", "value")]
11+
// [InlineData("($test$123)", "(value123)", "value")]
12+
// [InlineData("($test$)", "(value (test))", "value (test)")]
13+
// [InlineData("($test$)", "(value (test) )", "value (test) ")]
14+
// public static void TemplateParsingShouldBeSuccess(string template, string source, string result)
15+
// {
16+
// var input = Input.Input.String(source);
17+
// var templateParser = StructuralSearch.StructuralSearch.ParseFindTemplate(template);
18+
// var matches = templateParser.Parse(input);
19+
//
20+
// Assert.Single(matches);
21+
// var match = matches.First();
22+
// Assert.Single(match.Placeholders);
23+
// var placeholder = match.Placeholders.First();
24+
//
25+
// Assert.Equal(placeholder.Value.Value, result);
26+
// }
27+
//
28+
// [Theory]
29+
// [InlineData("$var$;", "test;;", "test")]
30+
// [InlineData("$var$;.", "test;;;.", "test;;")]
31+
// public static void TemplateParsingShouldBeSuccess2(string template, string source, params string[] values)
32+
// {
33+
// var input = Input.Input.String(source);
34+
// var templateParser = StructuralSearch.StructuralSearch.ParseFindTemplate(template);
35+
// var matches = templateParser.Parse(input);
36+
// Assert.Single(matches);
37+
// var match = matches.First();
38+
// Assert.Equal(match.Placeholders.Count, values.Length);
39+
// Assert.Equal(match.Placeholders.Select(x=> x.Value.Value), values);
40+
// }
41+
// }

‎src/SimpleStateMachine.StructuralSearch.Tests/ReplaceRuleParserTests.cs‎

Lines changed: 22 additions & 31 deletions
Original file line numberDiff line numberDiff line change
@@ -8,52 +8,43 @@ public static class ReplaceRuleParserTests
88
{
99
[Theory]
1010
[InlineData("if $var1$ equals $var2$ then")]
11+
[InlineData("if $var1$ equals \"123\" then")]
1112
[InlineData("if Not $var1$ equals $var$.Length then")]
1213
[InlineData("if Not $var1$ equals $var$.offset.Start then")]
1314
[InlineData("if $var1$ equals $var$.Length and Not $var1$ StartsWith \"123\" then")]
1415
[InlineData("if $var1$ equals $var$.Length and Not $var1$ StartsWith \"Test\" then")]
15-
public static void ReplaceConditionParsingShouldBeSuccess(string replaceRule)
16+
public static void ReplaceRuleConditionParsingShouldBeSuccess(string condition)
1617
{
17-
var rule = ReplaceRuleParser.ReplaceRule.Before(CommonParser.Eof).ParseOrThrow(replaceRule);
18-
var ruleStr = rule.ToString().ToLower();
19-
Assert.NotNull(rule);
20-
Assert.Equal(replaceRule.ToLower(), ruleStr);
18+
var logicalOperation = ReplaceRuleParser.ReplaceRuleCondition.Before(CommonParser.Eof).ParseOrThrow(condition);
19+
var result = logicalOperation.ToString()!;
20+
Assert.Equal(condition.ToLower(), result.ToLower());
2121
}
22-
22+
23+
[Theory]
24+
[InlineData("$var1$ => \"132\"")]
25+
[InlineData("$var1$ => $var3$")]
26+
[InlineData("$var1$ => $var3$.Length")]
27+
public static void AssignmentParsingShouldBeSuccess(string assignmentStr)
28+
{
29+
var assignment = ReplaceRuleParser.Assignment.Before(CommonParser.Eof).ParseOrThrow(assignmentStr);
30+
var result = assignment.ToString().ToLower();
31+
Assert.Equal(assignmentStr.ToLower(), result.ToLower());
32+
}
33+
2334
[Theory]
2435
[InlineData("if $var1$ equals $var2$ then $var1$ => \"test $var3$\"")]
25-
[InlineData("if $var1$ equals \"\\$\" then $var1$ => \"\\$\",$var2$ => \"132\"")]
36+
[InlineData("if $var1$ equals \"$\" then $var1$ => \"$\",$var2$ => \"132\"")]
2637
[InlineData("$var1$ => \"test $var3$.Length\"")]
2738
[InlineData("$var1$ => \"$\",$var2$ => \"132\"")]
2839
[InlineData("if Not $var1$ equals $var$.Length then $var1$ => $var$.Length")]
2940
[InlineData("if Not $var1$ equals $var$.offset.Start then $var1$ => $var$.offset.Start")]
3041
[InlineData("if $var1$ equals $var$.Length and Not $var1$ StartsWith \"123\" then $var1$ => $var$.offset.Start")]
3142
[InlineData("if $var1$ equals $var$.Length and Not $var1$ StartsWith \"123\" then $var1$ => $var$.offset.Start,$var2$ => $var$.offset.Start")]
3243
[InlineData("if $var1$ equals $var$.Length and Not $var1$ StartsWith \"Test\" then $var1$ => $var$.offset.Start")]
33-
public static void ReplaceRuleParsingShouldBeSuccess(string replaceRule)
34-
{
35-
var rule = StructuralSearch.StructuralSearch.ParseReplaceRule(replaceRule);
36-
var ruleStr = rule.ToString()?.ToLower();
37-
Assert.NotNull(rule);
38-
Assert.Equal(ruleStr, replaceRule.ToLower());
39-
}
40-
41-
[Theory]
42-
[InlineData("($var1$ equals $var2$) then $var1$ => \"test $var3$\"", "$var1$ equals $var2$ then $var1$ => \"test $var3$\"")]
43-
public static void ReplaceRuleShouldBeEqualsString(string replaceRule, string customResult)
44-
{
45-
var rule = StructuralSearch.StructuralSearch.ParseReplaceRule(replaceRule);
46-
var ruleStr = rule.ToString()?.ToLower();
47-
Assert.NotNull(rule);
48-
Assert.Equal(ruleStr, customResult.ToLower());
49-
}
50-
51-
[Theory]
52-
[InlineData("$var1$ equals $var2$ then $var1$ => (\"test $var3$\"")]
53-
[InlineData("($var1$ equals $var2$ then $var1$ => \"test $var3$\"")]
54-
[InlineData("$var1$ equals $var2$ then ($var1$) => \"test $var3$\"")]
55-
public static void ReplaceRuleParsingShouldBeFail(string replaceRuleStr)
44+
public static void ReplaceRuleParsingShouldBeSuccess(string replaceRuleStr)
5645
{
57-
Assert.Throws<ParseException<char>>(() => StructuralSearch.StructuralSearch.ParseReplaceRule(replaceRuleStr));
46+
var rule = ReplaceRuleParser.ReplaceRule.Before(CommonParser.Eof).ParseOrThrow(replaceRuleStr);
47+
var result = rule.ToString().ToLower();
48+
Assert.Equal(replaceRuleStr.ToLower(), result);
5849
}
5950
}

‎src/SimpleStateMachine.StructuralSearch.Tests/ReplaceTemplateTests.cs‎

Lines changed: 2 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,7 @@
11
using System.IO;
22
using Pidgin;
33
using SimpleStateMachine.StructuralSearch.Context;
4+
using SimpleStateMachine.StructuralSearch.StructuralSearch;
45
using Xunit;
56

67
namespace SimpleStateMachine.StructuralSearch.Tests;
@@ -64,19 +65,8 @@ public static void ReplaceBuildShouldBeSuccess(string templatePath, string resul
6465
[InlineData("(test ($var1$.Length) test2)")]
6566
public static void ReplaceTemplateParsingShouldBeSuccess(string templateStr)
6667
{
67-
var replaceBuilder = StructuralSearch.StructuralSearch.ParseReplaceTemplate(templateStr);
68+
var replaceBuilder = ReplaceTemplateParser.ReplaceTemplate.Before(CommonParser.Eof).ParseOrThrow(templateStr);
6869
var replaceStr = replaceBuilder.ToString()?.ToLower();
6970
Assert.Equal(replaceStr, templateStr.ToLower());
7071
}
71-
72-
[Theory]
73-
[InlineData("(test $var1$.Length")]
74-
[InlineData("test ($var1$.Length")]
75-
[InlineData("test $var1$.Length)")]
76-
[InlineData(" ( ")]
77-
[InlineData("test ( ")]
78-
public static void ReplaceTemplateParsingShouldBeFail(string templateStr)
79-
{
80-
Assert.Throws<ParseException<char>>(() => StructuralSearch.StructuralSearch.ParseReplaceTemplate(templateStr));
81-
}
8272
}

‎src/SimpleStateMachine.StructuralSearch/Constant.cs‎

Lines changed: 6 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -118,7 +118,7 @@ internal static class Constant
118118
/// <summary>
119119
/// Char: '='
120120
/// </summary>
121-
private new const char Equals = '=';
121+
public new const char Equals = '=';
122122

123123
/// <summary>
124124
/// Char: '>'
@@ -147,27 +147,20 @@ internal static class Constant
147147
LeftCurlyParenthesis,
148148
RightCurlyParenthesis
149149
};
150-
150+
151151
public static readonly IReadOnlySet<char> StringLiteralCharsToEscape = new HashSet<char>()
152152
{
153153
BackSlash,
154154
DoubleQuotes
155155
};
156-
157-
public static readonly IReadOnlySet<char> InvalidStringLiteralChars = new HashSet<char>(AllParenthesis)
156+
157+
public static readonly IReadOnlySet<char> WhitespaceChars = new HashSet<char>
158158
{
159159
CarriageReturn,
160160
LineFeed,
161161
Space
162162
};
163163

164-
public static readonly IReadOnlySet<char> CharsToEscape = new HashSet<char>
165-
{
166-
DoubleQuotes,
167-
BackSlash,
168-
PlaceholderSeparator,
169-
Dote
170-
};
171-
172-
public static readonly IReadOnlySet<char> LanguageSyntaxChars = AllParenthesis.Union(CharsToEscape).ToHashSet();
164+
public static readonly IReadOnlySet<char> InvalidStringLiteralChars =
165+
AllParenthesis.Union(WhitespaceChars).Union([PlaceholderSeparator]).ToHashSet();
173166
}

‎src/SimpleStateMachine.StructuralSearch/CustomParsers/FindParser.cs‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -11,9 +11,9 @@ namespace SimpleStateMachine.StructuralSearch.CustomParsers;
1111

1212
internal class FindParser : IFindParser
1313
{
14-
private TemplateParser Parser { get; }
14+
private FindTemplateParser Parser { get; }
1515

16-
public FindParser(TemplateParser parser)
16+
public FindParser(FindTemplateParser parser)
1717
{
1818
Parser = parser;
1919
}

src/SimpleStateMachine.StructuralSearch/CustomParsers/TemplateParser.cs renamed to src/SimpleStateMachine.StructuralSearch/CustomParsers/FindTemplateParser.cs

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -5,11 +5,11 @@
55

66
namespace SimpleStateMachine.StructuralSearch.CustomParsers;
77

8-
internal class TemplateParser : Parser<char, IEnumerable<string>>, IContextDependent
8+
internal class FindTemplateParser : Parser<char, IEnumerable<string>>, IContextDependent
99
{
1010
private readonly List<Parser<char, string>> _parsers;
1111

12-
public TemplateParser(List<Parser<char, string>> parsers)
12+
public FindTemplateParser(List<Parser<char, string>> parsers)
1313
{
1414
_parsers = parsers;
1515

‎src/SimpleStateMachine.StructuralSearch/CustomParsers/PlaceholderParser.cs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -53,7 +53,7 @@ protected override Parser<char, string> BuildParser(Func<Parser<char, string>?>
5353
}).Try());
5454
}
5555

56-
var anyString = Grammar.StringLiteralChar
56+
var anyString = Parser.AnyCharExcept(Constant.InvalidStringLiteralChars)
5757
.AtLeastOnceAsStringUntil(lookahead);
5858

5959
var simpleString = Grammar.StringLiteral;

‎src/SimpleStateMachine.StructuralSearch/Extensions/CharParserExtensions.cs‎

Lines changed: 2 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,5 @@
11
using System;
2+
using System.Linq;
23
using Pidgin;
34

45
namespace SimpleStateMachine.StructuralSearch.Extensions;
@@ -9,8 +10,5 @@ public static Parser<TToken, string> AsString<TToken>(this Parser<TToken, char>
910
=> parser.Select(x => x.ToString());
1011

1112
public static Parser<TToken, string> AtLeastOnceAsStringUntil<TToken, U>(this Parser<TToken, char> parser, Parser<TToken, U> terminator)
12-
=> parser != null ? parser.AtLeastOnceUntil(terminator).AsString() : throw new ArgumentNullException(nameof (parser));
13-
14-
public static Parser<TToken, string> AtLeastOnceAsStringUntilNot<TToken, U>(this Parser<TToken, char> parser, Parser<TToken, U> terminator)
15-
=> parser != null ? parser.AtLeastOnceUntilNot(terminator).AsString() : throw new ArgumentNullException(nameof (parser));
13+
=> parser != null ? parser.AtLeastOnceUntil(terminator).Select(x => new string(x.ToArray())) : throw new ArgumentNullException(nameof (parser));
1614
}

0 commit comments

Comments
 (0)