added filter support for Guid

src/GoatQuery/src/Ast/StringLiteral.cs

@@ -1,3 +1,5 @@
+using System;
+
 public sealed class StringLiteral : QueryExpression
 {
     public string Value { get; set; }
@@ -8,6 +10,16 @@ public StringLiteral(Token token, string value) : base(token)
     }
 }
 
+public sealed class GuidLiteral : QueryExpression
+{
+    public Guid Value { get; set; }
+
+    public GuidLiteral(Token token, Guid value) : base(token)
+    {
+        Value = value;
+    }
+}
+
 public sealed class IntegerLiteral : QueryExpression
 {
     public int Value { get; set; }

src/GoatQuery/src/Evaluator/FilterEvaluator.cs

@@ -22,6 +22,9 @@ public static Result<Expression> Evaluate(QueryExpression expression, ParameterE
 
                     switch (exp.Right)
                     {
+                        case GuidLiteral literal:
+                            value = Expression.Constant(literal.Value, property.Type);
+                            break;
                         case IntegerLiteral literal:
                             value = Expression.Constant(literal.Value, property.Type);
                             break;

src/GoatQuery/src/Lexer/Lexer.cs

@@ -1,3 +1,5 @@
+using System;
+
 public sealed class QueryLexer
 {
     private readonly string _input;
@@ -50,18 +52,24 @@ public Token NextToken()
                 token.Literal = ReadString();
                 break;
             default:
-                if (IsLetter(_character))
+                if (IsLetter(_character) || IsDigit(_character))
                 {
                     token.Literal = ReadIdentifier();
+                    if (IsGuid(token.Literal))
+                    {
+                        token.Type = TokenType.GUID;
+                        return token;
+                    }
+
+                    if (IsDigit(token.Literal[0]))
+                    {
+                        token.Type = TokenType.INT;
+                        return token;
+                    }
+
                     token.Type = TokenType.IDENT;
                     return token;
                 }
-                else if (IsDigit(_character))
-                {
-                    token.Literal = ReadNumber();
-                    token.Type = TokenType.INT;
-                    return token;
-                }
                 break;
         }
 
@@ -70,6 +78,11 @@ public Token NextToken()
         return token;
     }
 
+    private bool IsGuid(string value)
+    {
+        return Guid.TryParse(value, out _);
+    }
+
     private string ReadIdentifier()
     {
         var currentPosition = _position;
@@ -84,7 +97,7 @@ private string ReadIdentifier()
 
     private bool IsLetter(char ch)
     {
-        return 'a' <= ch && ch <= 'z' || 'A' <= ch && ch <= 'Z' || ch == '_';
+        return 'a' <= ch && ch <= 'z' || 'A' <= ch && ch <= 'Z' || ch == '_' || ch == '-';
     }
 
     private bool IsDigit(char ch)

src/GoatQuery/src/Parser/Parser.cs

@@ -139,7 +139,7 @@ private Result<InfixExpression> ParseFilterStatement()
 
         var statement = new InfixExpression(_currentToken, identifier, _currentToken.Literal);
 
-        if (!PeekTokenIn(TokenType.STRING, TokenType.INT))
+        if (!PeekTokenIn(TokenType.STRING, TokenType.INT, TokenType.GUID))
         {
             return Result.Fail("Invalid value type within filter");
         }
@@ -153,13 +153,19 @@ private Result<InfixExpression> ParseFilterStatement()
 
         switch (_currentToken.Type)
         {
+            case TokenType.GUID:
+                if (Guid.TryParse(_currentToken.Literal, out var guidValue))
+                {
+                    statement.Right = new GuidLiteral(_currentToken, guidValue);
+                }
+                break;
             case TokenType.STRING:
                 statement.Right = new StringLiteral(_currentToken, _currentToken.Literal);
                 break;
             case TokenType.INT:
-                if (int.TryParse(_currentToken.Literal, out var value))
+                if (int.TryParse(_currentToken.Literal, out var intValue))
                 {
-                    statement.Right = new IntegerLiteral(_currentToken, value);
+                    statement.Right = new IntegerLiteral(_currentToken, intValue);
                 }
                 break;
         }
@@ -185,11 +191,6 @@ private bool CurrentTokenIs(TokenType token)
         return _currentToken.Type == token;
     }
 
-    private bool PeekTokenIs(TokenType token)
-    {
-        return _peekToken.Type == token;
-    }
-
     private bool PeekTokenIn(params TokenType[] token)
     {
         return token.Contains(_peekToken.Type);

src/GoatQuery/src/Token/Token.cs

@@ -5,6 +5,7 @@ public enum TokenType
     IDENT,
     STRING,
     INT,
+    GUID,
     LPAREN,
     RPAREN,
 }

src/GoatQuery/tests/Filter/FilterLexerTest.cs

@@ -169,6 +169,17 @@ public static IEnumerable<object[]> Parameters()
                 new (TokenType.STRING, "10 Test Av"),
             }
         };
+
+        yield return new object[]
+        {
+            "id eq e4c7772b-8947-4e46-98ed-644b417d2a08",
+            new KeyValuePair<TokenType, string>[]
+            {
+                new (TokenType.IDENT, "id"),
+                new (TokenType.IDENT, "eq"),
+                new (TokenType.GUID, "e4c7772b-8947-4e46-98ed-644b417d2a08"),
+            }
+        };
     }
 
     [Theory]

src/GoatQuery/tests/Filter/FilterParserTest.cs

@@ -8,6 +8,7 @@ public sealed class FilterParserTest
     [InlineData("Age eq 21", "Age", "eq", "21")]
     [InlineData("Age ne 10", "Age", "ne", "10")]
     [InlineData("Name contains 'John'", "Name", "contains", "John")]
+    [InlineData("Id eq e4c7772b-8947-4e46-98ed-644b417d2a08", "Id", "eq", "e4c7772b-8947-4e46-98ed-644b417d2a08")]
     public void Test_ParsingFilterStatement(string input, string expectedLeft, string expectedOperator, string expectedRight)
     {
         var lexer = new QueryLexer(input);