CSHARP-1608: Added support for $reverseArray.

Author: craiggwilson

src/MongoDB.Driver/Linq/Expressions/ExtensionExpressionType.cs

@@ -30,6 +30,7 @@ internal enum ExtensionExpressionType
         Intersect,
         Join,
         OrderBy,
+        Reverse,
         Sample,
         Select,
         SelectMany,

src/MongoDB.Driver/Linq/Expressions/ExtensionExpressionVisitor.cs

@@ -170,6 +170,11 @@ protected internal virtual ResultOperator VisitResultOperator(ResultOperator res
             return resultOperator.Update(this);
         }
 
+        protected internal virtual Expression VisitReverse(ReverseExpression node)
+        {
+            return node.Update(Visit(node.Source));
+        }
+
         protected internal virtual Expression VisitSample(SampleExpression node)
         {
             return node.Update(

src/MongoDB.Driver/Linq/Expressions/ReverseExpression.cs

@@ -0,0 +1,66 @@
+/* Copyright 2015 MongoDB Inc.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+using System;
+using System.Linq.Expressions;
+using MongoDB.Driver.Core.Misc;
+
+namespace MongoDB.Driver.Linq.Expressions
+{
+    internal sealed class ReverseExpression : ExtensionExpression, ISourcedExpression
+    {
+        private readonly Expression _source;
+
+        public ReverseExpression(Expression source)
+        {
+            _source = Ensure.IsNotNull(source, nameof(source));
+        }
+
+        public override ExtensionExpressionType ExtensionType
+        {
+            get { return ExtensionExpressionType.Reverse; }
+        }
+
+        public Expression Source
+        {
+            get { return _source; }
+        }
+
+        public override Type Type
+        {
+            get { return _source.Type; }
+        }
+
+        public override string ToString()
+        {
+            return string.Format("{0}.Reverse()", _source.ToString());
+        }
+
+        public ReverseExpression Update(Expression source)
+        {
+            if (source != _source)
+            {
+                return new ReverseExpression(source);
+            }
+
+            return this;
+        }
+
+        protected internal override Expression Accept(ExtensionExpressionVisitor visitor)
+        {
+            return visitor.VisitReverse(this);
+        }
+    }
+}

src/MongoDB.Driver/Linq/Processors/EmbeddedPipeline/EmbeddedPipelineBinder.cs

@@ -43,6 +43,7 @@ static EmbeddedPipelineBinder()
             infoBinder.Register(new MaxBinder(), MaxBinder.GetSupportedMethods());
             infoBinder.Register(new MinBinder(), MinBinder.GetSupportedMethods());
             infoBinder.Register(new OfTypeBinder(), OfTypeBinder.GetSupportedMethods());
+            infoBinder.Register(new ReverseBinder(), ReverseBinder.GetSupportedMethods());
             infoBinder.Register(new SelectBinder(), SelectBinder.GetSupportedMethods());
             infoBinder.Register(new SkipBinder(), SkipBinder.GetSupportedMethods());
             infoBinder.Register(new StandardDeviationBinder(), StandardDeviationBinder.GetSupportedMethods());

src/MongoDB.Driver/Linq/Processors/EmbeddedPipeline/MethodCallBinders/ReverseBinder.cs

@@ -0,0 +1,39 @@
+/* Copyright 2015 MongoDB Inc.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Reflection;
+using MongoDB.Driver.Linq.Expressions;
+
+namespace MongoDB.Driver.Linq.Processors.EmbeddedPipeline.MethodCallBinders
+{
+    internal sealed class ReverseBinder : IMethodCallBinder<EmbeddedPipelineBindingContext>
+    {
+        public static IEnumerable<MethodInfo> GetSupportedMethods()
+        {
+            yield return MethodHelper.GetMethodDefinition(() => Enumerable.Reverse<object>(null));
+            yield return MethodHelper.GetMethodDefinition(() => Queryable.Reverse<object>(null));
+        }
+
+        public Expression Bind(PipelineExpression pipeline, EmbeddedPipelineBindingContext bindingContext, MethodCallExpression node, IEnumerable<Expression> arguments)
+        {
+            return new PipelineExpression(
+                new ReverseExpression(pipeline.Source),
+                pipeline.Projector);
+        }
+    }
+}

src/MongoDB.Driver/Linq/Translators/AggregateLanguageTranslator.cs

@@ -120,6 +120,8 @@ private BsonValue TranslateValue(Expression node)
                                 return TranslateIntersect((IntersectExpression)node);
                             case ExtensionExpressionType.Pipeline:
                                 return TranslatePipeline((PipelineExpression)node);
+                            case ExtensionExpressionType.Reverse:
+                                return TranslateReverse((ReverseExpression)node);
                             case ExtensionExpressionType.Select:
                                 return TranslateSelect((SelectExpression)node);
                             case ExtensionExpressionType.Skip:
@@ -466,6 +468,11 @@ private BsonValue TranslatePipeline(PipelineExpression node)
             throw new NotSupportedException(message);
         }
 
+        private BsonValue TranslateReverse(ReverseExpression node)
+        {
+            return new BsonDocument("$reverseArray", TranslateValue(node.Source));
+        }
+
         private BsonValue TranslateSelect(SelectExpression node)
         {
             var inputValue = TranslateValue(node.Source);

src/MongoDB.Driver/MongoDB.Driver.csproj

@@ -123,6 +123,7 @@
     <Compile Include="Linq\Expressions\ExceptExpression.cs" />
     <Compile Include="Linq\Expressions\IntersectExpression.cs" />
     <Compile Include="Linq\Expressions\SampleExpression.cs" />
+    <Compile Include="Linq\Expressions\ReverseExpression.cs" />
     <Compile Include="Linq\Expressions\UnionExpression.cs" />
     <Compile Include="Linq\Expressions\WhereExpression.cs" />
     <Compile Include="Linq\Expressions\ISerializationExpression.cs" />
@@ -165,6 +166,7 @@
     <Compile Include="Linq\Processors\EmbeddedPipeline\MethodCallBinders\StandardDeviationBinder.cs" />
     <Compile Include="Linq\Processors\EmbeddedPipeline\MethodCallBinders\TakeBinder.cs" />
     <Compile Include="Linq\Processors\EmbeddedPipeline\MethodCallBinders\ToHashSetBinder.cs" />
+    <Compile Include="Linq\Processors\EmbeddedPipeline\MethodCallBinders\ReverseBinder.cs" />
     <Compile Include="Linq\Processors\EmbeddedPipeline\MethodCallBinders\UnionBinder.cs" />
     <Compile Include="Linq\Processors\EmbeddedPipeline\MethodCallBinders\IntersectBinder.cs" />
     <Compile Include="Linq\Processors\EmbeddedPipeline\MethodCallBinders\ExceptBinder.cs" />

tests/MongoDB.Driver.Tests/Linq/Translators/AggregateProjectTranslatorTests.cs

@@ -800,6 +800,18 @@ public void Should_translate_pow()
             result.Value.Result.Should().Be(161051);
         }
 
+        [SkippableFact]
+        public void Should_translate_reverse()
+        {
+            RequireServer.Where(minimumVersion: "3.3.4");
+
+            var result = Project(x => new { Result = x.M.Reverse() });
+
+            result.Projection.Should().Be("{ Result: { \"$reverseArray\": \"$M\" }, _id: 0 }");
+
+            result.Value.Result.Should().BeEquivalentTo(5, 4, 2);
+        }
+
         [Fact]
         public void Should_translate_second()
         {