some before check

RomanSoloweow · RomanSoloweow · commit a9670f9da824 · 2022-05-08T17:39:25.000+03:00
diff --git a/src/SimpleStateMachine.StructuralSearch.Tests/Examples/NullUnionOperator.cs b/src/SimpleStateMachine.StructuralSearch.Tests/Examples/NullUnionOperator.cs
@@ -0,0 +1,51 @@
+﻿namespace SimpleStateMachine.StructuralSearch.Tests.Examples;
+
+public class NullUnionOperator
+{
+    public int Test1()
+    {
+        int? temp = 1;
+            
+        if(temp is null)
+            return 3;
+        else
+            return 4;
+    }
+        
+    public int Test2()
+    {
+        int? temp = 5;
+            
+        if(temp is null)
+            return 7;
+        else
+            return 8;
+    }
+        
+    public int Test3()
+    {
+        int? temp2 = 1;
+            
+        if(temp2 is null)
+            return 3;
+        else
+            return 4; 
+    }
+        
+    public int Test4()
+    {
+        int? temp3 = 5;
+            
+        if(temp3 is null)
+            return 7;
+        else if (temp3 == 8)
+            return 9;
+        else
+            return 10;
+    }
+        
+    public void Test5()
+    {
+            
+    }
+}
diff --git a/src/SimpleStateMachine.StructuralSearch.Tests/FindRuleParserTests.cs b/src/SimpleStateMachine.StructuralSearch.Tests/FindRuleParserTests.cs
@@ -28,7 +28,7 @@ public class FindRuleParserTests
 
         public void FindRuleExprParsingShouldBeSuccess(string ruleStr)
         {
-            var rule = FindRuleParser.Expr.ParseOrThrow(ruleStr);
+            var rule = RuleParser.Expr.ParseOrThrow(ruleStr);
             var _ruleStr = rule.ToString()?.ToLower();
             Assert.NotNull(rule);
             Assert.Equal(_ruleStr, ruleStr.ToLower());
@@ -39,7 +39,7 @@ public void FindRuleExprParsingShouldBeSuccess(string ruleStr)
         [InlineData("In (\"Is\", \"==\", \"!=\", \"is not\")", "In \"Is\",\"==\",\"!=\",\"is not\"")]
         public void FindRuleExprParsingShouldBeEqualsCustomResult(string ruleStr, string customResult)
         {
-            var rule = FindRuleParser.Expr.ParseOrThrow(ruleStr);
+            var rule = RuleParser.Expr.ParseOrThrow(ruleStr);
             var _ruleStr = rule.ToString()?.ToLower();
             Assert.NotNull(rule);
             Assert.Equal(_ruleStr, customResult.ToLower());
diff --git a/src/SimpleStateMachine.StructuralSearch.Tests/ReplaceRule/NullUnionOperator.txt b/src/SimpleStateMachine.StructuralSearch.Tests/ReplaceRule/NullUnionOperator.txt
@@ -0,0 +1 @@
+﻿$sign$ Is ("Is", "==", "!=", "is not")
diff --git a/src/SimpleStateMachine.StructuralSearch.Tests/SimpleStateMachine.StructuralSearch.Tests.csproj b/src/SimpleStateMachine.StructuralSearch.Tests/SimpleStateMachine.StructuralSearch.Tests.csproj
@@ -50,9 +50,5 @@
             <CopyToOutputDirectory>Always</CopyToOutputDirectory>
         </Content>
     </ItemGroup>
-
-    <ItemGroup>
-      <Folder Include="ReplaceRule" />
-    </ItemGroup>
     
 </Project>
diff --git a/src/SimpleStateMachine.StructuralSearch.Tests/StructurSearchParserTests.cs b/src/SimpleStateMachine.StructuralSearch.Tests/StructurSearchParserTests.cs
@@ -22,11 +22,6 @@ public static void StructuralSearchShouldBeSuccess(string exampleName, string ex
            
             var matches = parser.Parse(ref context);
             Assert.Equal(matches.Count(), matchesCount);
-            // foreach (var match in matches)
-            // {
-            //     input.Replace(match.Match);
-            // }
-            
         }
     }
 }
diff --git a/src/SimpleStateMachine.StructuralSearch/Rules/FindRule/ILogicalRule.cs b/src/SimpleStateMachine.StructuralSearch/Rules/FindRule/ILogicalRule.cs
@@ -0,0 +1,6 @@
+﻿namespace SimpleStateMachine.StructuralSearch.Rules;
+
+public interface ILogicalRule
+{
+    bool Execute();
+}
diff --git a/src/SimpleStateMachine.StructuralSearch/Rules/FindRule/LogicalRule/BinaryLogicalRule.cs b/src/SimpleStateMachine.StructuralSearch/Rules/FindRule/LogicalRule/BinaryLogicalRule.cs
@@ -0,0 +1,32 @@
+﻿using SimpleStateMachine.StructuralSearch.Helper;
+
+namespace SimpleStateMachine.StructuralSearch.Rules;
+
+public class BinaryLogicalRule : ILogicalRule
+{
+    public BinaryRuleType Type { get; }
+
+    public ILogicalRule Left { get; }
+
+    public ILogicalRule Right { get; }
+
+    public BinaryLogicalRule(BinaryRuleType type, ILogicalRule left, ILogicalRule right)
+    {
+        Type = type;
+        Left = left;
+        Right = right;
+    }
+
+    public bool Execute()
+    {
+        var left = Left.Execute();
+        var right = Right.Execute();
+
+        return LogicalHelper.Calculate(Type, left, right);
+    }
+
+    public override string ToString()
+    {
+        return $"{Left}{Constant.Space}{Type}{Constant.Space}{Right}";
+    }
+}
diff --git a/src/SimpleStateMachine.StructuralSearch/Rules/FindRule/LogicalRule/PlaceholderLogicalRule.cs b/src/SimpleStateMachine.StructuralSearch/Rules/FindRule/LogicalRule/PlaceholderLogicalRule.cs
@@ -1,12 +1,12 @@
 ﻿namespace SimpleStateMachine.StructuralSearch.Rules
 {
-    public class FindRule
+    public class PlaceholderLogicalRule : ILogicalRule
     {
         public PlaceholderParameter Placeholder { get; }
         
         private IRule _rule { get; }
 
-        public FindRule(PlaceholderParameter placeholder, IRule rule)
+        public PlaceholderLogicalRule(PlaceholderParameter placeholder, IRule rule)
         {
             Placeholder = placeholder;
             _rule = rule;
@@ -16,7 +16,7 @@ public override string ToString()
         {
             return $"{Placeholder}{Constant.Space}{_rule}";
         }
-
+        
         public bool Execute()
         {
             var value = Placeholder.GetValue();
diff --git a/src/SimpleStateMachine.StructuralSearch/Rules/FindRule/LogicalRule/UnaryLogicalRule.cs b/src/SimpleStateMachine.StructuralSearch/Rules/FindRule/LogicalRule/UnaryLogicalRule.cs
@@ -0,0 +1,32 @@
+﻿using System;
+
+namespace SimpleStateMachine.StructuralSearch.Rules;
+
+public class UnaryLogicalRule : ILogicalRule
+{
+    public UnaryRuleType Type { get; }
+
+    public ILogicalRule Parameter { get; }
+
+    public UnaryLogicalRule(UnaryRuleType type, ILogicalRule parameter)
+    {
+        Type = type;
+        Parameter = parameter;
+    }
+
+    public bool Execute()
+    {
+        var result = Parameter.Execute();
+
+        return Type switch
+        {
+            UnaryRuleType.Not => !result,
+            _ => throw new ArgumentOutOfRangeException()
+        };
+    }
+
+    public override string ToString()
+    {
+        return $"{Type}{Constant.Space}{Parameter}";
+    }
+}
diff --git a/src/SimpleStateMachine.StructuralSearch/Rules/ReplaceRule/ReplaceRule.cs b/src/SimpleStateMachine.StructuralSearch/Rules/ReplaceRule/ReplaceRule.cs
@@ -6,11 +6,11 @@ namespace SimpleStateMachine.StructuralSearch
 {
     public class ReplaceRule
     {
-        public FindRule FindRule { get; }
+        public PlaceholderLogicalRule FindRule { get; }
 
         public IRuleParameter Parameter { get; }
 
-        public ReplaceRule(FindRule findRule, IRuleParameter parameter)
+        public ReplaceRule(PlaceholderLogicalRule findRule, IRuleParameter parameter)
         {
             FindRule = findRule;
             Parameter = parameter;
diff --git a/src/SimpleStateMachine.StructuralSearch/StructuralSearch/FindRulesParser.cs b/src/SimpleStateMachine.StructuralSearch/StructuralSearch/FindRulesParser.cs
@@ -7,7 +7,7 @@
 
 namespace SimpleStateMachine.StructuralSearch
 {
-    public static class FindRuleParser
+    public static class RuleParser
     {
         internal static Parser<char, Func<IRule, IRule, IRule>> Binary(Parser<char, BinaryRuleType> op)
             => op.Select<Func<IRule, IRule, IRule>>(type => (l, r) => new BinaryRule(type, l, r));
@@ -71,14 +71,10 @@ internal static readonly Parser<char, Func<IRule, IRule>> Not
             )
         );
 
-        internal static readonly Parser<char, FindRule> Rule =
-            Parser.Map((parameter, rule) => new FindRule(parameter, rule),
+        internal static readonly Parser<char, ILogicalRule> PlaceholderLogicalRule =
+            Parser.Map((parameter, rule) => new PlaceholderLogicalRule(parameter, rule),
                 ParametersParser.PlaceholderParameter,
-                    Expr.TrimStart());
-
-        internal static FindRule ParseTemplate(string str)
-        {
-            return Rule.ParseOrThrow(str);
-        }
+                    Expr.TrimStart())    
+                .As<char, PlaceholderLogicalRule, ILogicalRule>();
     }
 }
diff --git a/src/SimpleStateMachine.StructuralSearch/StructuralSearch/LogicalRuleParser.cs b/src/SimpleStateMachine.StructuralSearch/StructuralSearch/LogicalRuleParser.cs
@@ -0,0 +1,81 @@
+﻿using System;
+using Pidgin;
+using Pidgin.Expression;
+using SimpleStateMachine.StructuralSearch.Extensions;
+using SimpleStateMachine.StructuralSearch.Rules;
+
+namespace SimpleStateMachine.StructuralSearch;
+
+public static class LogicalRuleParser
+{
+        internal static Parser<char, Func<ILogicalRule, ILogicalRule, ILogicalRule>> BinaryLogical(Parser<char, BinaryRuleType> op)
+        => op.Select<Func<ILogicalRule, ILogicalRule, ILogicalRule>>(type => (l, r) => new BinaryLogicalRule(type, l, r));
+
+        internal static Parser<char, Func<ILogicalRule, ILogicalRule>> UnaryLogical(Parser<char, UnaryRuleType> op)
+            => op.Select<Func<ILogicalRule, ILogicalRule>>(type => param => new UnaryLogicalRule(type, param));
+        
+        internal static readonly Parser<char, Func<ILogicalRule, ILogicalRule, ILogicalRule>> And
+            = BinaryLogical(Parsers.EnumValue(BinaryRuleType.And, true)
+                .TrimStart()
+                .Try());
+
+        internal static readonly Parser<char, Func<ILogicalRule, ILogicalRule, ILogicalRule>> Or
+            = BinaryLogical(Parsers.EnumValue(BinaryRuleType.Or, true)
+                .TrimStart()
+                .Try());
+
+        internal static readonly Parser<char, Func<ILogicalRule, ILogicalRule, ILogicalRule>> NOR
+            = BinaryLogical(Parsers.EnumValue(BinaryRuleType.NOR, true)
+                .TrimStart()
+                .Try());
+
+        internal static readonly Parser<char, Func<ILogicalRule, ILogicalRule, ILogicalRule>> XOR
+            = BinaryLogical(Parsers.EnumValue(BinaryRuleType.XOR, true)
+                .TrimStart()
+                .Try());
+
+        internal static readonly Parser<char, Func<ILogicalRule, ILogicalRule, ILogicalRule>> NAND
+            = BinaryLogical(Parsers.EnumValue(BinaryRuleType.NAND, true)
+                .TrimStart()
+                .Try());
+
+        internal static readonly Parser<char, Func<ILogicalRule, ILogicalRule, ILogicalRule>> XNOR
+            = BinaryLogical(Parsers.EnumValue(BinaryRuleType.XNOR, true)
+                .TrimStart()
+                .Try());
+
+        internal static readonly Parser<char, Func<ILogicalRule, ILogicalRule>> Not
+            = UnaryLogical(Parsers.EnumValue(UnaryRuleType.Not, true)
+                .TrimStart()
+                .Try());
+
+        public static readonly Parser<char, ILogicalRule> Expr = ExpressionParser.Build<char, ILogicalRule>(
+            rule => (
+                Parser.OneOf(
+                RuleParser.PlaceholderLogicalRule,
+                    CommonParser.Parenthesised(rule, x => x.TrimStart())
+                ),
+                new[]
+                {
+                    Operator.Prefix(Not),
+                    Operator.InfixL(And),
+                    Operator.InfixL(NOR),
+                    Operator.InfixL(XOR),
+                    Operator.InfixL(NAND),
+                    Operator.InfixL(XNOR),
+                    Operator.InfixL(Or),
+                }
+            )
+        );
+
+        internal static readonly Parser<char, ILogicalRule> Rule =
+            Parser.Map((parameter, rule) => new PlaceholderLogicalRule(parameter, rule),
+                    ParametersParser.PlaceholderParameter,
+                    Expr.TrimStart())
+                .As<char, PlaceholderLogicalRule, ILogicalRule>();
+
+        internal static ILogicalRule ParseTemplate(string str)
+        {
+            return Rule.ParseOrThrow(str);
+        }
+}
diff --git a/src/SimpleStateMachine.StructuralSearch/StructuralSearch/ReplaceRuleParser.cs b/src/SimpleStateMachine.StructuralSearch/StructuralSearch/ReplaceRuleParser.cs
@@ -16,7 +16,7 @@ public static class ReplaceRuleParser
         
         internal static readonly Parser<char, ReplaceRule> ReplaceRule =
             Parser.Map((rule, parameter) => new ReplaceRule(rule, parameter),
-                    FindRuleParser.Rule.Before(CommonTemplateParser.Should.TrimStart()),
+                    RuleParser.PlaceholderLogicalRule.Before(CommonTemplateParser.Should.TrimStart()),
                     Parser.OneOf(ChangeParameter.Try(), ParametersParser.Parameter.Try()))
                 .Try()
                 .TrimStart();
diff --git a/src/SimpleStateMachine.StructuralSearch/StructuralSearch/StructuralSearch.cs b/src/SimpleStateMachine.StructuralSearch/StructuralSearch/StructuralSearch.cs
@@ -12,8 +12,8 @@ public static IFindParser ParseFindTemplate(string template)
         public static IReplaceBuilder ParseReplaceTemplate(string template) 
             => ReplaceTemplateParser.ParseTemplate(template);
         
-        public static FindRule ParseFindRule(string template) 
-            => FindRuleParser.ParseTemplate(template);
+        public static PlaceholderLogicalRule ParseFindRule(string template) 
+            => RuleParser.ParseTemplate(template);
         
         public static ReplaceRule ParseReplaceRule(string template) 
             => ReplaceRuleParser.ParseTemplate(template);
diff --git a/src/SimpleStateMachine.StructuralSearch/StructuralSearchParser.cs b/src/SimpleStateMachine.StructuralSearch/StructuralSearchParser.cs
@@ -13,7 +13,7 @@ public class StructuralSearchParser
     {
         public IFindParser FindParser { get; set; }
 
-        public Dictionary<string, FindRule> FindRules { get; set; }
+        public Dictionary<string, PlaceholderLogicalRule> FindRules { get; set; }
 
         public IReplaceBuilder ReplaceBuilder { get; set; }
 

Original file line number	Diff line number	Diff line change
`@@ -22,11 +22,6 @@ public static void StructuralSearchShouldBeSuccess(string exampleName, string ex`
`22`	`22`
`23`	`23`	`var matches = parser.Parse(ref context);`
`24`	`24`	`Assert.Equal(matches.Count(), matchesCount);`
`25`		`- // foreach (var match in matches)`
`26`		`- // {`
`27`		`- // input.Replace(match.Match);`
`28`		`- // }`
`29`		`-`
`30`	`25`	`}`
`31`	`26`	`}`
`32`	`27`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,12 +1,12 @@`
`1`	`1`	`namespace SimpleStateMachine.StructuralSearch.Rules`
`2`	`2`	`{`
`3`		`- public class FindRule`
	`3`	`+ public class PlaceholderLogicalRule : ILogicalRule`
`4`	`4`	`{`
`5`	`5`	`public PlaceholderParameter Placeholder { get; }`
`6`	`6`
`7`	`7`	`private IRule _rule { get; }`
`8`	`8`
`9`		`- public FindRule(PlaceholderParameter placeholder, IRule rule)`
	`9`	`+ public PlaceholderLogicalRule(PlaceholderParameter placeholder, IRule rule)`
`10`	`10`	`{`
`11`	`11`	`Placeholder = placeholder;`
`12`	`12`	`_rule = rule;`
`@@ -16,7 +16,7 @@ public override string ToString()`
`16`	`16`	`{`
`17`	`17`	`return $"{Placeholder}{Constant.Space}{_rule}";`
`18`	`18`	`}`
`19`		`-`
	`19`	`+`
`20`	`20`	`public bool Execute()`
`21`	`21`	`{`
`22`	`22`	`var value = Placeholder.GetValue();`
Original file line number	Diff line number	Diff line change
`@@ -6,11 +6,11 @@ namespace SimpleStateMachine.StructuralSearch`
`6`	`6`	`{`
`7`	`7`	`public class ReplaceRule`
`8`	`8`	`{`
`9`		`- public FindRule FindRule { get; }`
	`9`	`+ public PlaceholderLogicalRule FindRule { get; }`
`10`	`10`
`11`	`11`	`public IRuleParameter Parameter { get; }`
`12`	`12`
`13`		`- public ReplaceRule(FindRule findRule, IRuleParameter parameter)`
	`13`	`+ public ReplaceRule(PlaceholderLogicalRule findRule, IRuleParameter parameter)`
`14`	`14`	`{`
`15`	`15`	`FindRule = findRule;`
`16`	`16`	`Parameter = parameter;`