added lte, gt & gte

Author: Jamess-Lucass

src/GoatQuery/src/Evaluator/FilterEvaluator.cs

@@ -56,6 +56,12 @@ public static Result<Expression> Evaluate(QueryExpression expression, ParameterE
                             return Expression.Call(property, method, value);
                         case Keywords.Lt:
                             return Expression.LessThan(property, value);
+                        case Keywords.Lte:
+                            return Expression.LessThanOrEqual(property, value);
+                        case Keywords.Gt:
+                            return Expression.GreaterThan(property, value);
+                        case Keywords.Gte:
+                            return Expression.GreaterThanOrEqual(property, value);
                         default:
                             return Result.Fail($"Unsupported operator: {exp.Operator}");
                     }

src/GoatQuery/src/Extensions/StringExtension.cs

@@ -0,0 +1,10 @@
+using System;
+using System.Linq;
+
+public static class StringExtension
+{
+    public static bool In(this string str, params string[] strings)
+    {
+        return strings.Contains(str, StringComparer.OrdinalIgnoreCase);
+    }
+}

src/GoatQuery/src/Parser/Parser.cs

@@ -130,7 +130,7 @@ private Result<InfixExpression> ParseFilterStatement()
     {
         var identifier = new Identifier(_currentToken, _currentToken.Literal);
 
-        if (!PeekIdentifierIn(Keywords.Eq, Keywords.Ne, Keywords.Contains, Keywords.Lt))
+        if (!PeekIdentifierIn(Keywords.Eq, Keywords.Ne, Keywords.Contains, Keywords.Lt, Keywords.Lte, Keywords.Gt, Keywords.Gte))
         {
             return Result.Fail("Invalid conjunction within filter");
         }
@@ -151,9 +151,9 @@ private Result<InfixExpression> ParseFilterStatement()
             return Result.Fail("Value must be a string when using 'contains' operand");
         }
 
-        if (statement.Operator.Equals(Keywords.Lt) && _currentToken.Type != TokenType.INT)
+        if (statement.Operator.In(Keywords.Lt, Keywords.Lte, Keywords.Gt, Keywords.Gte) && _currentToken.Type != TokenType.INT)
         {
-            return Result.Fail("Value must be an integer when using 'lt' operand");
+            return Result.Fail($"Value must be an integer when using '{statement.Operator}' operand");
         }
 
         switch (_currentToken.Type)

src/GoatQuery/src/Token/Token.cs

@@ -18,6 +18,9 @@ public static class Keywords
     internal const string Ne = "ne";
     internal const string Contains = "contains";
     internal const string Lt = "lt";
+    internal const string Lte = "lte";
+    internal const string Gt = "gt";
+    internal const string Gte = "gte";
     internal const string And = "and";
     internal const string Or = "or";
 }

src/GoatQuery/tests/Filter/FilterLexerTest.cs

@@ -191,6 +191,39 @@ public static IEnumerable<object[]> Parameters()
                 new (TokenType.INT, "50"),
             }
         };
+
+        yield return new object[]
+        {
+            "age lte 50",
+            new KeyValuePair<TokenType, string>[]
+            {
+                new (TokenType.IDENT, "age"),
+                new (TokenType.IDENT, "lte"),
+                new (TokenType.INT, "50"),
+            }
+        };
+
+        yield return new object[]
+        {
+            "age gt 50",
+            new KeyValuePair<TokenType, string>[]
+            {
+                new (TokenType.IDENT, "age"),
+                new (TokenType.IDENT, "gt"),
+                new (TokenType.INT, "50"),
+            }
+        };
+
+        yield return new object[]
+        {
+            "age gte 50",
+            new KeyValuePair<TokenType, string>[]
+            {
+                new (TokenType.IDENT, "age"),
+                new (TokenType.IDENT, "gte"),
+                new (TokenType.INT, "50"),
+            }
+        };
     }
 
     [Theory]

src/GoatQuery/tests/Filter/FilterParserTest.cs

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

src/GoatQuery/tests/Filter/FilterTest.cs

@@ -113,6 +113,26 @@ public static IEnumerable<object[]> Parameters()
             "age lt 1",
             Array.Empty<User>()
         };
+
+        yield return new object[] {
+            "age lte 2",
+            new[] { _users["John"], _users["Jane"], _users["Apple"], _users["Harry"] }
+        };
+
+        yield return new object[] {
+            "age gt 1",
+            new[] { _users["John"], _users["Apple"], _users["Doe"], _users["Egg"] }
+        };
+
+        yield return new object[] {
+            "age gte 3",
+            new[] { _users["Doe"], _users["Egg"] }
+        };
+
+        yield return new object[] {
+            "age lt 3 and age gt 1",
+            new[] { _users["John"], _users["Apple"] }
+        };
     }
 
     [Theory]