Tests for custom parsing (complex operators)

Author: Sébastien Geiser

CodingSeb.ExpressionEvaluator.Tests/ExpressionEvaluatorTests.cs

@@ -1740,6 +1740,8 @@ void Evaluator_PreEvaluateVariable(object sender, VariablePreEvaluationEventArg
 
                 #region inherits ExpressionEvaluator
 
+                #region Redefine existing operators
+
                 ExpressionEvaluator xExpressionEvaluator1 = new XExpressionEvaluator1();
 
                 yield return new TestCaseData(xExpressionEvaluator1
@@ -1832,6 +1834,10 @@ void Evaluator_PreEvaluateVariable(object sender, VariablePreEvaluationEventArg
                     .SetCategory("inherits ExpressionEvaluator")
                     .SetCategory("Custom operators");
 
+                #endregion
+
+                #region Add your own simple operators
+
                 ExpressionEvaluator xExpressionEvaluator2 = new XExpressionEvaluator2();
 
                 yield return new TestCaseData(xExpressionEvaluator2
@@ -1871,6 +1877,54 @@ void Evaluator_PreEvaluateVariable(object sender, VariablePreEvaluationEventArg
 
                 #endregion
 
+                #region Add a complex operator or change the parsing process
+
+                ExpressionEvaluator xExpressionEvaluator3 = new XExpressionEvaluator3();
+
+                yield return new TestCaseData(xExpressionEvaluator3
+                    , "\"A sentence where a word must be replaced where it is\" ° \"replaced\" @ \"kept\"", null)
+                    .Returns("A sentence where a word must be kept where it is")
+                    .SetCategory("ExpressionEvaluator extend")
+                    .SetCategory("inherits ExpressionEvaluator")
+                    .SetCategory("Custom operators")
+                    .SetCategory("Custom parsing");
+
+                yield return new TestCaseData(xExpressionEvaluator3
+                    , "#1985-09-11.Year", null)
+                    .Returns(1985)
+                    .SetCategory("ExpressionEvaluator extend")
+                    .SetCategory("inherits ExpressionEvaluator")
+                    .SetCategory("Custom syntax")
+                    .SetCategory("Custom parsing");
+
+                yield return new TestCaseData(xExpressionEvaluator3
+                    , "#1985-09-11.Month", null)
+                    .Returns(9)
+                    .SetCategory("ExpressionEvaluator extend")
+                    .SetCategory("inherits ExpressionEvaluator")
+                    .SetCategory("Custom syntax")
+                    .SetCategory("Custom parsing");
+
+                yield return new TestCaseData(xExpressionEvaluator3
+                    , "#1985-09-11.Day", null)
+                    .Returns(11)
+                    .SetCategory("ExpressionEvaluator extend")
+                    .SetCategory("inherits ExpressionEvaluator")
+                    .SetCategory("Custom syntax")
+                    .SetCategory("Custom parsing");
+
+                yield return new TestCaseData(xExpressionEvaluator3
+                    , "#1985-09-11.Equals(new DateTime(1985,9,11))", null)
+                    .Returns(true)
+                    .SetCategory("ExpressionEvaluator extend")
+                    .SetCategory("inherits ExpressionEvaluator")
+                    .SetCategory("Custom syntax")
+                    .SetCategory("Custom parsing");
+
+                #endregion
+
+                #endregion
+
                 #region bug resolution
 
                 yield return new TestCaseData(new ExpressionEvaluator()

CodingSeb.ExpressionEvaluator.Tests/TestsUtils/XExpressionEvaluator3.cs

@@ -0,0 +1,83 @@
+using System;
+using System.Collections.Generic;
+using System.Text.RegularExpressions;
+
+namespace CodingSeb.ExpressionEvaluator.Tests
+{
+    public class XExpressionEvaluator3 : ExpressionEvaluator
+    {
+        protected override void Init()
+        {
+            ParsingMethods.Insert(0, EvaluateDateTimeSyntax);
+            ParsingMethods.Add(EvaluateSpecialTernaryOperator);
+        }
+
+        /// <summary>
+        /// To evaluate DateTimes objects with #year-month-day syntax (#2019-05-28)
+        /// </summary>
+        protected virtual bool EvaluateDateTimeSyntax(string expression, Stack<object> stack, ref int i)
+        {
+            Match match = Regex.Match(expression.Substring(i), @"^\s*#(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})");
+
+            if(match.Success)
+            {
+                int year = int.Parse(match.Groups["year"].Value);
+                int month = int.Parse(match.Groups["month"].Value);
+                int day = int.Parse(match.Groups["day"].Value);
+
+                DateTime dateTime = new DateTime(year,month, day);
+
+                stack.Push(dateTime);
+
+                i += match.Length - 1;
+
+                return true;
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// To evaluate a string replace with custom ternary indicator
+        /// </summary>
+        protected virtual bool EvaluateSpecialTernaryOperator(string expression, Stack<object> stack, ref int i)
+        {
+            if (expression.Substring(i, 1).Equals("°"))
+            {
+                string input = (string)ProcessStack(stack);
+
+                string restOfExpression = expression.Substring(i + 1);
+
+                for (int j = 0; j < restOfExpression.Length; j++)
+                {
+                    string s2 = restOfExpression.Substring(j, 1);
+
+                    Match internalStringMatch = stringBeginningRegex.Match(restOfExpression.Substring(j));
+
+                    if (internalStringMatch.Success)
+                    {
+                        string innerString = internalStringMatch.Value + GetCodeUntilEndOfString(restOfExpression.Substring(j + internalStringMatch.Length), internalStringMatch);
+                        j += innerString.Length - 1;
+                    }
+                    else if (s2.Equals("("))
+                    {
+                        j++;
+                        GetExpressionsBetweenParenthesesOrOtherImbricableBrackets(restOfExpression, ref j, false);
+                    }
+                    else if (s2.Equals("@"))
+                    {
+                        stack.Clear();
+
+                        stack.Push(input.Replace((string)Evaluate(restOfExpression.Substring(1, j - 1)), (string)Evaluate(restOfExpression.Substring(j + 1))));
+
+                        i = expression.Length;
+
+                        return true;
+                    }
+                }
+            }
+
+            return false;
+        }
+    }
+}

CodingSeb.ExpressionEvaluator/ExpressionEvaluator.cs

@@ -2311,9 +2311,9 @@ protected virtual bool EvaluateTernaryConditionalOperator(string expression, Sta
             {
                 bool condition = (bool)ProcessStack(stack);
 
-                string restOfExpression = expression.Substring(i);
+                string restOfExpression = expression.Substring(i + 1);
 
-                for (int j = 1; j < restOfExpression.Length; j++)
+                for (int j = 0; j < restOfExpression.Length; j++)
                 {
                     string s2 = restOfExpression.Substring(j, 1);