Make TextParser public (#562)

Author: StefH

src/System.Linq.Dynamic.Core/Parser/ExpressionParser.cs

@@ -281,7 +281,7 @@ Expression ParseOrOperator()
         Expression ParseAndOperator()
         {
             Expression left = ParseIn();
-            while (_textParser.CurrentToken.Id == TokenId.DoubleAmphersand)
+            while (_textParser.CurrentToken.Id == TokenId.DoubleAmpersand)
             {
                 Token op = _textParser.CurrentToken;
                 _textParser.NextToken();
@@ -379,7 +379,7 @@ Expression ParseIn()
         Expression ParseLogicalAndOrOperator()
         {
             Expression left = ParseComparisonOperator();
-            while (_textParser.CurrentToken.Id == TokenId.Amphersand || _textParser.CurrentToken.Id == TokenId.Bar)
+            while (_textParser.CurrentToken.Id == TokenId.Ampersand || _textParser.CurrentToken.Id == TokenId.Bar)
             {
                 Token op = _textParser.CurrentToken;
                 _textParser.NextToken();
@@ -397,7 +397,7 @@ Expression ParseLogicalAndOrOperator()
 
                 switch (op.Id)
                 {
-                    case TokenId.Amphersand:
+                    case TokenId.Ampersand:
                         int parseValue;
                         if (left.Type == typeof(string) && left.NodeType == ExpressionType.Constant && int.TryParse((string)((ConstantExpression)left).Value, out parseValue) && TypeHelper.IsNumericType(right.Type))
                         {

src/System.Linq.Dynamic.Core/Tokenizer/TextParser.cs

@@ -4,11 +4,13 @@
 
 namespace System.Linq.Dynamic.Core.Tokenizer
 {
-    internal class TextParser
+    /// <summary>
+    /// TextParser which can be used to parse a text into tokens.
+    /// </summary>
+    public class TextParser
     {
         private const char DefaultNumberDecimalSeparator = '.';
-
-        private static readonly char[] EscapeCharacters = new[] { '\\', 'a', 'b', 'f', 'n', 'r', 't', 'v' };
+        private static readonly char[] EscapeCharacters = { '\\', 'a', 'b', 'f', 'n', 'r', 't', 'v' };
 
         // These aliases are supposed to simply the where clause and make it more human readable
         private static readonly Dictionary<string, TokenId> PredefinedOperatorAliases = new Dictionary<string, TokenId>(StringComparer.OrdinalIgnoreCase)
@@ -26,8 +28,8 @@ internal class TextParser
             { "GreaterThan", TokenId.GreaterThan },
             { "ge", TokenId.GreaterThanEqual },
             { "GreaterThanEqual", TokenId.GreaterThanEqual },
-            { "and", TokenId.DoubleAmphersand },
-            { "AndAlso", TokenId.DoubleAmphersand },
+            { "and", TokenId.DoubleAmpersand },
+            { "AndAlso", TokenId.DoubleAmpersand },
             { "or", TokenId.DoubleBar },
             { "OrElse", TokenId.DoubleBar },
             { "not", TokenId.Exclamation },
@@ -41,8 +43,17 @@ internal class TextParser
 
         private int _textPos;
         private char _ch;
+
+        /// <summary>
+        /// The current parsed <see cref="Token"/>.
+        /// </summary>
         public Token CurrentToken;
 
+        /// <summary>
+        /// Constructor for TextParser
+        /// </summary>
+        /// <param name="config"></param>
+        /// <param name="text"></param>
         public TextParser(ParsingConfig config, string text)
         {
             _config = config;
@@ -70,16 +81,18 @@ private void NextChar()
             _ch = _textPos < _textLen ? _text[_textPos] : '\0';
         }
 
+        /// <summary>
+        /// Peek the next character.
+        /// </summary>
+        /// <returns>The next character, or \0 if end of string.</returns>
         public char PeekNextChar()
         {
-            if (_textPos + 1 < _textLen)
-            {
-                return _text[_textPos + 1];
-            }
-
-            return '\0';
+            return _textPos + 1 < _textLen ? _text[_textPos + 1] : '\0';
         }
 
+        /// <summary>
+        /// Go to the next token.
+        /// </summary>
         public void NextToken()
         {
             while (char.IsWhiteSpace(_ch))
@@ -115,11 +128,11 @@ public void NextToken()
                     if (_ch == '&')
                     {
                         NextChar();
-                        tokenId = TokenId.DoubleAmphersand;
+                        tokenId = TokenId.DoubleAmpersand;
                     }
                     else
                     {
-                        tokenId = TokenId.Amphersand;
+                        tokenId = TokenId.Ampersand;
                     }
                     break;
 
@@ -431,19 +444,16 @@ public void NextToken()
             CurrentToken.Id = GetAliasedTokenId(tokenId, CurrentToken.Text);
         }
 
-        public void ValidateToken(TokenId t, string errorMessage)
-        {
-            if (CurrentToken.Id != t)
-            {
-                throw ParseError(errorMessage);
-            }
-        }
-
-        public void ValidateToken(TokenId t)
+        /// <summary>
+        /// Check if the current token is the specified <see cref="TokenId"/>.
+        /// </summary>
+        /// <param name="tokenId">The tokenId to check.</param>
+        /// <param name="errorMessage">The (optional) error message.</param>
+        public void ValidateToken(TokenId tokenId, string errorMessage = null)
         {
-            if (CurrentToken.Id != t)
+            if (CurrentToken.Id != tokenId)
             {
-                throw ParseError(Res.SyntaxError);
+                throw ParseError(errorMessage ?? Res.SyntaxError);
             }
         }
 

src/System.Linq.Dynamic.Core/Tokenizer/Token.cs

@@ -1,13 +1,28 @@
 namespace System.Linq.Dynamic.Core.Tokenizer
 {
-    internal struct Token
+    /// <summary>
+    /// Token
+    /// </summary>
+    public struct Token
     {
+        /// <summary>
+        /// The TokenId.
+        /// </summary>
         public TokenId Id { get; set; }
 
+        /// <summary>
+        /// The Original TokenId.
+        /// </summary>
         public TokenId OriginalId { get; set; }
 
+        /// <summary>
+        /// The text.
+        /// </summary>
         public string Text { get; set; }
 
+        /// <summary>
+        /// The position.
+        /// </summary>
         public int Pos { get; set; }
     }
-}
+}

src/System.Linq.Dynamic.Core/Tokenizer/TokenId.cs

@@ -1,6 +1,10 @@
-namespace System.Linq.Dynamic.Core.Tokenizer
+#pragma warning disable CS1591
+namespace System.Linq.Dynamic.Core.Tokenizer
 {
-    internal enum TokenId
+    /// <summary>
+    /// TokenId which defines the text which is parsed.
+    /// </summary>
+    public enum TokenId
     {
         Unknown,
         End,
@@ -10,7 +14,7 @@ internal enum TokenId
         RealLiteral,
         Exclamation,
         Percent,
-        Amphersand,
+        Ampersand,
         OpenParen,
         CloseParen,
         OpenCurlyParen,
@@ -30,7 +34,7 @@ internal enum TokenId
         CloseBracket,
         Bar,
         ExclamationEqual,
-        DoubleAmphersand,
+        DoubleAmpersand,
         LessThanEqual,
         LessGreater,
         DoubleEqual,
@@ -42,4 +46,4 @@ internal enum TokenId
         Lambda,
         NullPropagation
     }
-}
+}