push

RomanSoloweow · RomanSoloweow · commit 1a7d7b23e93b · 2025-03-24T14:44:49.000Z
diff --git a/src/SimpleStateMachine.StructuralSearch.Tests/ReplaceTemplateTests.cs b/src/SimpleStateMachine.StructuralSearch.Tests/ReplaceTemplateTests.cs
@@ -1,27 +1,12 @@
 ﻿using System.IO;
-using System.Linq;
 using Pidgin;
 using SimpleStateMachine.StructuralSearch.Context;
-using SimpleStateMachine.StructuralSearch.Templates.ReplaceTemplate;
 using Xunit;
 
 namespace SimpleStateMachine.StructuralSearch.Tests;
 
 public static class ReplaceTemplateTests
 {
-    [Theory]
-    [InlineData("ReplaceTemplate/NullUnionOperator.txt", 6)]
-    [InlineData("ReplaceTemplate/AssignmentNullUnionOperator.txt", 4)]
-    [InlineData("ReplaceTemplate/TernaryOperator.txt", 7)]
-    public static void ReplaceTemplateParsingShouldHaveStepCount(string templatePath, int stepsCount)
-    {
-        var replaceTemplate = File.ReadAllText(templatePath);
-        var replaceBuilder = StructuralSearch.StructuralSearch.ParseReplaceTemplate(replaceTemplate);
-
-        Assert.NotNull(replaceTemplate);
-        Assert.Equal(((ReplaceBuilder)replaceBuilder).Steps.Count(), stepsCount);
-    }
-
     [Theory]
     [InlineData("ReplaceTemplate/NullUnionOperator.txt", "ReplaceResult/NullUnionOperator.txt", 
         new[] { "var", "sign", "value1", "value2"}, 
@@ -54,21 +39,28 @@ public static void ReplaceBuildShouldBeSuccess(string templatePath, string resul
     // TODO validation parenthesis for parameters
         
     [Theory]
+    [InlineData("test")]
+    [InlineData("()")]
+    [InlineData("$var1$")]
+    [InlineData("test () test")]  
+    [InlineData("test $var1$ test")]
+    [InlineData("($var1$)")]
+    [InlineData("($var1$ test)")]
+    [InlineData("test (test)")]
+    [InlineData("test ($var1$)")]
+    [InlineData("test ($var1$) test")]
+
     [InlineData("test $var1$.Lenght")]
     [InlineData("(test) $var1$.Lenght")]
     [InlineData("test ($var1$.Lenght)")]
     [InlineData("(test $var1$.Lenght)")]
-    [InlineData("test ")]
     [InlineData("($var1$.Lenght)")]
     [InlineData(" ($var1$.Lenght)")]
-    [InlineData(" ( )")]  
-    [InlineData("test ( )")]
     [InlineData(" (test $var1$.Lenght)")]
     [InlineData("(test) ($var1$.Lenght)")]
     [InlineData("((test) $var1$.Lenght)")]
     [InlineData("(test ($var1$.Lenght))")]
     [InlineData("((test) ($var1$.Lenght))")]
-    [InlineData("()")]
     [InlineData("(test ($var1$.Lenght) test2)")]
     public static void ReplaceTemplateParsingShouldBeSuccess(string templateStr)
     {
diff --git a/src/SimpleStateMachine.StructuralSearch/Helper/EscapeHelper.cs b/src/SimpleStateMachine.StructuralSearch/Helper/EscapeHelper.cs
@@ -1,6 +1,5 @@
 ﻿using System;
 using System.Collections.Generic;
-using System.Linq;
 
 namespace SimpleStateMachine.StructuralSearch.Helper;
 
diff --git a/src/SimpleStateMachine.StructuralSearch/Parsers/FindTemplateParser.cs b/src/SimpleStateMachine.StructuralSearch/Parsers/FindTemplateParser.cs
@@ -7,9 +7,9 @@ namespace SimpleStateMachine.StructuralSearch.Parsers;
 
 internal class FindTemplateParser : Parser<char, IEnumerable<string>>, IContextDependent
 {
-    private readonly IEnumerable<Parser<char, string>> _parsers;
+    private readonly List<Parser<char, string>> _parsers;
 
-    public FindTemplateParser(IEnumerable<Parser<char, string>> parsers)
+    public FindTemplateParser(List<Parser<char, string>> parsers)
     {
         _parsers = parsers;
             
@@ -18,7 +18,7 @@ public FindTemplateParser(IEnumerable<Parser<char, string>> parsers)
 
     private void InitializeLookaheadParsers()
     {
-        var count = _parsers.Count();
+        var count = _parsers.Count;
             
         for (var i = count-1; i >= 0 ; i--)
         {
@@ -34,7 +34,7 @@ private void InitializeLookaheadParsers()
     public override bool TryParse(ref ParseState<char> state, ref PooledList<Expected<char>> expected, out IEnumerable<string> result)
     {
         var results = new List<string>();
-        var count = _parsers.Count();
+        var count = _parsers.Count;
 
         for (int i = 0; i < count; i++)
         {
diff --git a/src/SimpleStateMachine.StructuralSearch/Parsers/Parsers.cs b/src/SimpleStateMachine.StructuralSearch/Parsers/Parsers.cs
@@ -1,5 +1,4 @@
 ﻿using System;
-using System.Collections.Generic;
 using System.Linq;
 using Pidgin;
 using SimpleStateMachine.StructuralSearch.Extensions;
diff --git a/src/SimpleStateMachine.StructuralSearch/Parsers/PlaceholderParser.cs b/src/SimpleStateMachine.StructuralSearch/Parsers/PlaceholderParser.cs
@@ -53,8 +53,7 @@ protected override Parser<char, string> BuildParser(Func<Parser<char, string>?>
             }).Try());
         }
 
-        // Was changed from StringLiteralChar
-        var anyString = Grammar.NonLanguageSyntaxChar
+        var anyString = Grammar.StringLiteralChar
             .AtLeastOnceAsStringUntil(lookahead);
 
         var simpleString = Grammar.StringLiteral;
@@ -101,7 +100,7 @@ public override bool TryParse(ref ParseState<char> state, ref PooledList<Expecte
                     match: match
                 );
 
-                Context.Add(_name, placeholderObj);
+                Context[_name] = placeholderObj;
 
                 res = Context.FindRules
                     .Where(r => r.IsApplicableForPlaceholder(_name))
diff --git a/src/SimpleStateMachine.StructuralSearch/Rules/Parameters/StringFormatParameter.cs b/src/SimpleStateMachine.StructuralSearch/Rules/Parameters/StringFormatParameter.cs
@@ -6,22 +6,17 @@ namespace SimpleStateMachine.StructuralSearch.Rules.Parameters;
 
 internal class StringFormatParameter : IRuleParameter
 {
-    private readonly IEnumerable<IRuleParameter> _parameters;
+    private readonly List<IRuleParameter> _parameters;
 
-    public StringFormatParameter(IEnumerable<IRuleParameter> parameters)
+    public StringFormatParameter(List<IRuleParameter> parameters)
     {
         _parameters = parameters;
     }
 
     public string GetValue(ref IParsingContext context)
     {
-        var values = new List<string>();
-        foreach (var parameter in _parameters)
-        {
-            values.Add(parameter.GetValue(ref context));
-        }
-        
-        return string.Join(string.Empty, values);
+        var localContext = context;
+        return string.Join(string.Empty, _parameters.Select(parameter => parameter.GetValue(ref localContext)));
     }
         
     public override string ToString() 
diff --git a/src/SimpleStateMachine.StructuralSearch/Rules/Parameters/StringJoinParameter.cs b/src/SimpleStateMachine.StructuralSearch/Rules/Parameters/StringJoinParameter.cs
@@ -0,0 +1,25 @@
+﻿using System.Collections.Generic;
+using System.Linq;
+using SimpleStateMachine.StructuralSearch.Context;
+
+namespace SimpleStateMachine.StructuralSearch.Rules.Parameters;
+
+internal class StringJoinParameter : IRuleParameter
+{
+    private readonly List<IRuleParameter> _parameters;
+
+    public StringJoinParameter(List<IRuleParameter> parameters)
+    {
+        _parameters = parameters;
+    }
+
+    public string GetValue(ref IParsingContext context)
+    {
+        var localContext = context;
+        var values = _parameters.Select(parameter => parameter.GetValue(ref localContext)).ToList();
+        return string.Join(string.Empty, values);
+    }
+
+    public override string ToString()
+        => string.Join(string.Empty, _parameters.Select(x => x.ToString()));
+}
diff --git a/src/SimpleStateMachine.StructuralSearch/StructuralSearch/FindRulesParser.cs b/src/SimpleStateMachine.StructuralSearch/StructuralSearch/FindRulesParser.cs
@@ -23,7 +23,7 @@ internal static class FindRuleParser
         (
             Parser.OneOf
             (
-                SubRuleParser.OneOfSubRule,
+                FindSubRuleParser.OneOfSubRule,
                 CommonParser.Parenthesised(rule, x => Parser.Char(x).Trim())
             ),
             [
diff --git a/src/SimpleStateMachine.StructuralSearch/StructuralSearch/FindSubRuleParser.cs b/src/SimpleStateMachine.StructuralSearch/StructuralSearch/FindSubRuleParser.cs
@@ -6,10 +6,12 @@
 
 namespace SimpleStateMachine.StructuralSearch.StructuralSearch;
 
-internal static class SubRuleParser
+internal static class FindSubRuleParser
 {
     private static readonly Parser<char, SubRuleType> SubRuleType = Parser.CIEnum<SubRuleType>().Trim();
-    private static readonly Parser<char, PlaceholderType> PlaceholderType = Parser.CIEnum<PlaceholderType>().TrimStart();
+
+    private static readonly Parser<char, PlaceholderType>
+        PlaceholderType = Parser.CIEnum<PlaceholderType>().TrimStart();
 
     private static Parser<char, IFindRule> BinarySubRule(IRuleParameter left, SubRuleType ruleType) =>
         ParametersParser.Parameter
@@ -18,30 +20,30 @@ private static Parser<char, IFindRule> BinarySubRule(IRuleParameter left, SubRul
             .As<char, BinarySubRule, IFindRule>()
             .Try();
 
-    private static Parser<char, IFindRule> IsSubRule(IRuleParameter left, SubRuleType ruleType) =>
+    private static Parser<char, IFindRule> IsSubRule(IRuleParameter left) =>
         PlaceholderType.Select(arg => new IsSubRule(left, arg))
             .As<char, IsSubRule, IFindRule>()
             .Try();
 
-    private static Parser<char, IFindRule> InSubRule(IRuleParameter left, SubRuleType ruleType) =>
+    private static Parser<char, IFindRule> InSubRule(IRuleParameter left) =>
         ParametersParser.Parameters
             .ParenthesisedOptional(x => Parser.Char(x).Trim())
             .TrimStart()
             .Select(args => new InSubRule(left, args))
             .As<char, InSubRule, IFindRule>()
             .Try();
 
-    public static readonly Parser<char, IFindRule> OneOfSubRule =
+    internal static readonly Parser<char, IFindRule> OneOfSubRule =
         Parser.Map
             (
-                func: (left, ruleType) => (left, ruleType),
+                func: (left, ruleType) => (value: left, type: ruleType),
                 parser1: ParametersParser.Parameter.Trim(),
                 parser2: SubRuleType
             )
-            .Then(x => x.ruleType switch
+            .Then(x => x.type switch
             {
-                Rules.FindRules.Types.SubRuleType.In => InSubRule(x.left, x.ruleType),
-                Rules.FindRules.Types.SubRuleType.Is => IsSubRule(x.left, x.ruleType),
-                _ => BinarySubRule(x.left, x.ruleType)
+                Rules.FindRules.Types.SubRuleType.In => InSubRule(x.value),
+                Rules.FindRules.Types.SubRuleType.Is => IsSubRule(x.value),
+                _ => BinarySubRule(x.value, x.type)
             });
 }
diff --git a/src/SimpleStateMachine.StructuralSearch/StructuralSearch/FindTemplateParser.cs b/src/SimpleStateMachine.StructuralSearch/StructuralSearch/FindTemplateParser.cs
@@ -43,7 +43,7 @@ internal static class FindTemplateParser
         Parser.OneOf(TokenInParentheses, Token.AsMany())
             .AtLeastOnceUntil(CommonParser.Eof)
             .Select(x => x.SelectMany(y => y))
-            .Select(parsers => new Parsers.FindTemplateParser(parsers));
+            .Select(parsers => new Parsers.FindTemplateParser(parsers.ToList()));
 
     internal static IFindParser ParseTemplate(string? str) =>
         string.IsNullOrEmpty(str)
diff --git a/src/SimpleStateMachine.StructuralSearch/StructuralSearch/Grammar.cs b/src/SimpleStateMachine.StructuralSearch/StructuralSearch/Grammar.cs
@@ -6,23 +6,13 @@ namespace SimpleStateMachine.StructuralSearch.StructuralSearch;
 
 internal static class Grammar
 {
-    internal static readonly Parser<char, char> NonLanguageSyntaxChar =
-        Parser.AnyCharExcept(Constant.LanguageSyntaxChars);
-
-    internal static readonly Parser<char, string> WhiteSpaces =
-        Parser.OneOf(CommonParser.Spaces, CommonParser.LineEnds, CommonParser.LineEnds).AtLeastOnceString();
-
-    // internal static readonly Parser<char, char> StringLiteralChar =
-    //     Parser.AnyCharExcept(Constant.LanguageSyntaxChars);
-
-    internal static readonly Parser<char, string> StringLiteral = 
-        NonLanguageSyntaxChar.AtLeastOnceString();
-
-    internal static readonly Parser<char, string> Identifier =
-        Parser.Letter.Then(Parser.OneOf(Parser.Letter, Parser.Digit, CommonParser.Underscore).AtLeastOnce(), BuildString);
-
-    internal static readonly Parser<char, string> Placeholder =
-        Identifier.Between(Parser.Char(Constant.PlaceholderSeparator));
+    internal static readonly Parser<char, char> NonLanguageSyntaxChar = Parser.AnyCharExcept(Constant.LanguageSyntaxChars);
+    internal static readonly Parser<char, char> StringLiteralChar = Parser.AnyCharExcept(Constant.InvalidStringLiteralChars);
+    internal static readonly Parser<char, string> WhiteSpaces = Parser.OneOf(CommonParser.Spaces, CommonParser.LineEnds, CommonParser.LineEnds).AtLeastOnceString();
+    internal static readonly Parser<char, string> StringNonLanguageSyntaxChar = NonLanguageSyntaxChar.AtLeastOnceString();
+    internal static readonly Parser<char, string> StringLiteral = StringLiteralChar.AtLeastOnceString();
+    internal static readonly Parser<char, string> Identifier = Parser.Letter.Then(Parser.OneOf(Parser.Letter, Parser.Digit, CommonParser.Underscore).AtLeastOnce(), BuildString);
+    internal static readonly Parser<char, string> Placeholder = Identifier.Between(Parser.Char(Constant.PlaceholderSeparator));
 
     private static string BuildString(char c, IEnumerable<char> chars)
     {
diff --git a/src/SimpleStateMachine.StructuralSearch/StructuralSearch/ParametersParser.cs b/src/SimpleStateMachine.StructuralSearch/StructuralSearch/ParametersParser.cs
@@ -15,15 +15,17 @@ internal static class ParametersParser
     internal static readonly Parser<char, string> String =
         Parser.OneOf(CommonParser.EscapedChar, Grammar.NonLanguageSyntaxChar).AtLeastOnceString();
 
+    internal static readonly Parser<char, string> StringOptional =
+        String.Optional().Select(x => x.GetValueOrDefault(string.Empty));
+
     internal static readonly Parser<char, string> StringInParentheses =
         Parsers.Parsers.BetweenParentheses
         (
             expr: Parser.OneOf
             (
                 // Recursive
                 Parser.Rec(() => StringInParentheses ?? throw new ArgumentNullException(nameof(StringInParentheses))),
-                // Optional string
-                String.Optional().Select(x => x.GetValueOrDefault())
+                StringOptional
             ),
             mapFunc: (left, result, right) => $"{left}{result}{right}"
         );
@@ -61,22 +63,22 @@ internal static class ParametersParser
             .Then(PlaceholderPropertyParser.PlaceholderPropertyParameter, (placeholder, func) => func(placeholder))
             .Then(Change, (parameter, func) => func(parameter));
 
-    public static readonly Parser<char, IRuleParameter> StringFormatParameter =
+    internal static readonly Parser<char, IRuleParameter> StringFormatParameter =
         Parser.OneOf
             (
                 Parser.Rec(() => PlaceholderOrPropertyRuleParameter ?? throw new ArgumentNullException()).Try(), 
                 StringParameter
             )
             .AtLeastOnce()
             .Between(CommonParser.DoubleQuotes)
-            .Select(IRuleParameter (parameters)=> new StringFormatParameter(parameters));
+            .Select(IRuleParameter (parameters)=> new StringFormatParameter(parameters.ToList()));
 
-    public static readonly Parser<char, IRuleParameter> Parameter = Parameter = Parser.OneOf
+    internal static readonly Parser<char, IRuleParameter> Parameter = Parameter = Parser.OneOf
     (
         StringFormatParameter.Try(),
         Parser.Rec(() => PlaceholderOrPropertyRuleParameter ?? throw new ArgumentNullException())
     );
 
-    public static readonly Parser<char, IEnumerable<IRuleParameter>> Parameters =
+    internal static readonly Parser<char, IEnumerable<IRuleParameter>> Parameters =
         Parameter.Try().Trim().SeparatedAtLeastOnce(CommonParser.Comma.Trim());
 }
diff --git a/src/SimpleStateMachine.StructuralSearch/StructuralSearch/PlaceholderPropertyParser.cs b/src/SimpleStateMachine.StructuralSearch/StructuralSearch/PlaceholderPropertyParser.cs
@@ -2,10 +2,10 @@
 using Pidgin;
 using SimpleStateMachine.StructuralSearch.Extensions;
 using SimpleStateMachine.StructuralSearch.Rules.FindRules.Types;
+using SimpleStateMachine.StructuralSearch.Rules.Parameters;
 using SimpleStateMachine.StructuralSearch.Rules.Parameters.Types;
-using SimpleStateMachine.StructuralSearch.StructuralSearch;
 
-namespace SimpleStateMachine.StructuralSearch.Rules.Parameters;
+namespace SimpleStateMachine.StructuralSearch.StructuralSearch;
 
 internal static class PlaceholderPropertyParser
 {
diff --git a/src/SimpleStateMachine.StructuralSearch/StructuralSearch/ReplaceTemplateParser.cs b/src/SimpleStateMachine.StructuralSearch/StructuralSearch/ReplaceTemplateParser.cs
diff --git a/src/SimpleStateMachine.StructuralSearch/Templates/ReplaceTemplate/IReplaceBuilder.cs b/src/SimpleStateMachine.StructuralSearch/Templates/ReplaceTemplate/IReplaceBuilder.cs
diff --git a/src/SimpleStateMachine.StructuralSearch/Templates/ReplaceTemplate/ReplaceBuilder.cs b/src/SimpleStateMachine.StructuralSearch/Templates/ReplaceTemplate/ReplaceBuilder.cs

Original file line number	Diff line number	Diff line change
`@@ -7,9 +7,9 @@ namespace SimpleStateMachine.StructuralSearch.Parsers;`
`7`	`7`
`8`	`8`	`internal class FindTemplateParser : Parser<char, IEnumerable<string>>, IContextDependent`
`9`	`9`	`{`
`10`		`- private readonly IEnumerable<Parser<char, string>> _parsers;`
	`10`	`+ private readonly List<Parser<char, string>> _parsers;`
`11`	`11`
`12`		`- public FindTemplateParser(IEnumerable<Parser<char, string>> parsers)`
	`12`	`+ public FindTemplateParser(List<Parser<char, string>> parsers)`
`13`	`13`	`{`
`14`	`14`	`_parsers = parsers;`
`15`	`15`
`@@ -18,7 +18,7 @@ public FindTemplateParser(IEnumerable<Parser<char, string>> parsers)`
`18`	`18`
`19`	`19`	`private void InitializeLookaheadParsers()`
`20`	`20`	`{`
`21`		`- var count = _parsers.Count();`
	`21`	`+ var count = _parsers.Count;`
`22`	`22`
`23`	`23`	`for (var i = count-1; i >= 0 ; i--)`
`24`	`24`	`{`
`@@ -34,7 +34,7 @@ private void InitializeLookaheadParsers()`
`34`	`34`	`public override bool TryParse(ref ParseState<char> state, ref PooledList<Expected<char>> expected, out IEnumerable<string> result)`
`35`	`35`	`{`
`36`	`36`	`var results = new List<string>();`
`37`		`- var count = _parsers.Count();`
	`37`	`+ var count = _parsers.Count;`
`38`	`38`
`39`	`39`	`for (int i = 0; i < count; i++)`
`40`	`40`	`{`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,4 @@`
`1`	`1`	`using System;`
`2`		`-using System.Collections.Generic;`
`3`	`2`	`using System.Linq;`
`4`	`3`	`using Pidgin;`
`5`	`4`	`using SimpleStateMachine.StructuralSearch.Extensions;`
Original file line number	Diff line number	Diff line change
`@@ -6,22 +6,17 @@ namespace SimpleStateMachine.StructuralSearch.Rules.Parameters;`
`6`	`6`
`7`	`7`	`internal class StringFormatParameter : IRuleParameter`
`8`	`8`	`{`
`9`		`- private readonly IEnumerable<IRuleParameter> _parameters;`
	`9`	`+ private readonly List<IRuleParameter> _parameters;`
`10`	`10`
`11`		`- public StringFormatParameter(IEnumerable<IRuleParameter> parameters)`
	`11`	`+ public StringFormatParameter(List<IRuleParameter> parameters)`
`12`	`12`	`{`
`13`	`13`	`_parameters = parameters;`
`14`	`14`	`}`
`15`	`15`
`16`	`16`	`public string GetValue(ref IParsingContext context)`
`17`	`17`	`{`
`18`		`- var values = new List<string>();`
`19`		`- foreach (var parameter in _parameters)`
`20`		`- {`
`21`		`- values.Add(parameter.GetValue(ref context));`
`22`		`- }`
`23`		`-`
`24`		`- return string.Join(string.Empty, values);`
	`18`	`+ var localContext = context;`
	`19`	`+ return string.Join(string.Empty, _parameters.Select(parameter => parameter.GetValue(ref localContext)));`
`25`	`20`	`}`
`26`	`21`
`27`	`22`	`public override string ToString()`
Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,7 @@ internal static class FindRuleParser`
`23`	`23`	`(`
`24`	`24`	`Parser.OneOf`
`25`	`25`	`(`
`26`		`- SubRuleParser.OneOfSubRule,`
	`26`	`+ FindSubRuleParser.OneOfSubRule,`
`27`	`27`	`CommonParser.Parenthesised(rule, x => Parser.Char(x).Trim())`
`28`	`28`	`),`
`29`	`29`	`[`