Merge pull request #116 from pelavall/feature/supporteverqueries

Add a WasEver extension to support the Ever query verb

+semver: minor

src/Qwiq.Linq/QueryExtensions.cs

@@ -18,6 +18,11 @@ private static bool AsOf<T>(this T _, DateTime __)
         {
             return true;
         }
+
+        public static bool WasEver<T>(this T _, T __)
+        {
+            return true;
+        }
     }
 }
 

src/Qwiq.Linq/Qwiq.Linq.csproj

@@ -258,6 +258,7 @@
     <Compile Include="Visitors\PartialEvaluator.cs" />
     <Compile Include="Visitors\QueryRewriter.cs" />
     <Compile Include="Visitors\WiqlQueryBuilder.cs" />
+    <Compile Include="WiqlExpressions\WasEverExpression.cs" />
     <Compile Include="WiqlExpressions\AsOfExpression.cs" />
     <Compile Include="WiqlExpressions\ContainsExpression.cs" />
     <Compile Include="WiqlExpressions\IndexerExpression.cs" />

src/Qwiq.Linq/Visitors/QueryRewriter.cs

@@ -71,6 +71,14 @@ protected override Expression VisitMethodCall(MethodCallExpression node)
                 return new UnderExpression(node.Type, subject, target);
             }
 
+            if (node.Method.DeclaringType == typeof(QueryExtensions) && node.Method.Name == "WasEver")
+            {
+                var subject = Visit(node.Arguments[0]);
+                var target = Visit(node.Arguments[1]);
+
+                return new WasEverExpression(node.Type, subject, target);
+            }
+
             // This is a contains used to see if a value is in a list, such as: bug => aliases.Contains(bug.AssignedTo)
             if (node.Method.DeclaringType == typeof(Enumerable) && node.Method.Name == "Contains")
             {

src/Qwiq.Linq/WiqlExpressions/WasEverExpression.cs

@@ -0,0 +1,23 @@
+using System;
+using System.Linq.Expressions;
+
+namespace Microsoft.Qwiq.Linq.WiqlExpressions
+{
+    public class WasEverExpression : Expression
+    {
+        internal WasEverExpression(Type type, Expression subject, Expression target)
+        {
+            Type = type;
+            Subject = subject;
+            Target = target;
+        }
+
+        public override ExpressionType NodeType => (ExpressionType)WiqlExpressionType.WasEver;
+
+        public override Type Type { get; }
+
+        internal Expression Subject { get; private set; }
+        internal Expression Target { get; private set; }
+    }
+}
+

src/Qwiq.Linq/WiqlExpressions/WiqlExpressionType.cs

@@ -9,7 +9,8 @@ internal enum WiqlExpressionType
         AsOf,
         Contains,
         Select,
-        Indexer
+        Indexer,
+        WasEver
     }
 }
 

src/Qwiq.Linq/WiqlTranslator.cs

@@ -92,6 +92,8 @@ public override Expression Visit(Expression expression)
                         return VisitContains((ContainsExpression)expression);
                     case WiqlExpressionType.Indexer:
                         return VisitIndexer((IndexerExpression) expression);
+                    case WiqlExpressionType.WasEver:
+                        return VisitWasEver((WasEverExpression)expression);
                     default:
                         return base.Visit(expression);
                 }
@@ -150,6 +152,19 @@ protected virtual Expression VisitUnder(UnderExpression expression)
                 return expression;
             }
 
+            protected virtual Expression VisitWasEver(WasEverExpression expression)
+            {
+                _expressionInProgress.Enqueue(new GroupStartFragment());
+                Visit(expression.Subject);
+
+                _expressionInProgress.Enqueue(new StringFragment(" EVER "));
+
+                Visit(expression.Target);
+                _expressionInProgress.Enqueue(new GroupEndFragment());
+
+                return expression;
+            }
+
             protected virtual Expression VisitOrder(OrderExpression expression)
             {
                 Visit(expression.Source);

test/Qwiq.Linq.Tests/QueryBuilderTests.cs

@@ -325,6 +325,24 @@ public void the_StartsWith_is_translated_to_an_under_operator()
         }
     }
 
+    [TestClass]
+    // ReSharper disable once InconsistentNaming
+    public class when_a_where_clause_uses_the_ever_function : QueryBuilderTests
+    {
+        public override void When()
+        {
+            base.When();
+            Expected = "SELECT * FROM WorkItems WHERE (([Assigned To] EVER 'alias'))";
+            Actual = Query.Where(item => item.AssignedTo.WasEver("alias")).ToString();
+        }
+
+        [TestMethod]
+        public void the_WasEver_is_translated_to_an_ever_operator()
+        {
+            Actual.ShouldEqual(Expected);
+        }
+    }
+
     [TestClass]
     // ReSharper disable once InconsistentNaming
     public class when_a_where_clause_uses_the_Contains_string_function : QueryBuilderTests