DATAMONGO-1530 - Polishing.

Add missing transformations for ConstructorReference, OperatorNot, OpNE, OpEQ, OpGT, OpGE, OpLT, OpLE, OperatorPower, OpOr and OpAnd. This allows usage of logical operators &, || and ! as part of the expression, while ConstructorReference allows instantiating eg. arrays via an expression `new int[]{4,5,6}`. This can be useful eg. comparing arrays using $setEquals.

More complex aggregation operators like $filter can be created by defining the variable references as string inside the expression like filter(a, 'num', '$$num' > 10).
Commands like $let requires usage of InlineMap to pass in required arguments like eg. let({low:1, high:'$$low'}, gt('$$low', '$$high')).

Original Pull Request: #410

Author: christophstrobl

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/aggregation/SpelExpressionTransformer.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2014 the original author or authors.
+ * Copyright 2013-2016 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -26,19 +26,26 @@
 import org.springframework.data.mongodb.core.spel.ExpressionTransformationContextSupport;
 import org.springframework.data.mongodb.core.spel.LiteralNode;
 import org.springframework.data.mongodb.core.spel.MethodReferenceNode;
+import org.springframework.data.mongodb.core.spel.MethodReferenceNode.AggregationMethodReference;
+import org.springframework.data.mongodb.core.spel.MethodReferenceNode.AggregationMethodReference.ArgumentType;
+import org.springframework.data.mongodb.core.spel.NotOperatorNode;
 import org.springframework.data.mongodb.core.spel.OperatorNode;
 import org.springframework.expression.spel.ExpressionState;
 import org.springframework.expression.spel.SpelNode;
 import org.springframework.expression.spel.SpelParserConfiguration;
 import org.springframework.expression.spel.ast.CompoundExpression;
+import org.springframework.expression.spel.ast.ConstructorReference;
 import org.springframework.expression.spel.ast.Indexer;
 import org.springframework.expression.spel.ast.InlineList;
+import org.springframework.expression.spel.ast.InlineMap;
+import org.springframework.expression.spel.ast.OperatorNot;
 import org.springframework.expression.spel.ast.PropertyOrFieldReference;
 import org.springframework.expression.spel.standard.SpelExpression;
 import org.springframework.expression.spel.standard.SpelExpressionParser;
 import org.springframework.expression.spel.support.StandardEvaluationContext;
 import org.springframework.util.Assert;
 import org.springframework.util.NumberUtils;
+import org.springframework.util.ObjectUtils;
 
 import com.mongodb.BasicDBList;
 import com.mongodb.BasicDBObject;
@@ -48,6 +55,7 @@
  * Renders the AST of a SpEL expression as a MongoDB Aggregation Framework projection expression.
  * 
  * @author Thomas Darimont
+ * @author Christoph Strobl
  */
 class SpelExpressionTransformer implements AggregationExpressionTransformer {
 
@@ -69,6 +77,8 @@ public SpelExpressionTransformer() {
 		conversions.add(new PropertyOrFieldReferenceNodeConversion(this));
 		conversions.add(new CompoundExpressionNodeConversion(this));
 		conversions.add(new MethodReferenceNodeConversion(this));
+		conversions.add(new NotOperatorNodeConversion(this));
+		conversions.add(new ValueRetrievingNodeConversion(this));
 
 		this.conversions = Collections.unmodifiableList(conversions);
 	}
@@ -131,8 +141,8 @@ private ExpressionNodeConversion<ExpressionNode> lookupConversionFor(ExpressionN
 	 * @author Thomas Darimont
 	 * @author Oliver Gierke
 	 */
-	private static abstract class ExpressionNodeConversion<T extends ExpressionNode> implements
-			AggregationExpressionTransformer {
+	private static abstract class ExpressionNodeConversion<T extends ExpressionNode>
+			implements AggregationExpressionTransformer {
 
 		private final AggregationExpressionTransformer transformer;
 		private final Class<? extends ExpressionNode> nodeType;
@@ -235,8 +245,17 @@ public OperatorNodeConversion(AggregationExpressionTransformer transformer) {
 		protected Object convert(AggregationExpressionTransformationContext<OperatorNode> context) {
 
 			OperatorNode currentNode = context.getCurrentNode();
-
 			DBObject operationObject = createOperationObjectAndAddToPreviousArgumentsIfNecessary(context, currentNode);
+
+			if (currentNode.isLogicalOperator()) {
+
+				for (ExpressionNode expressionNode : currentNode) {
+					transform(expressionNode, currentNode, operationObject, context);
+				}
+
+				return operationObject;
+			}
+
 			Object leftResult = transform(currentNode.getLeft(), currentNode, operationObject, context);
 
 			if (currentNode.isUnaryMinus()) {
@@ -271,7 +290,8 @@ private DBObject createOperationObjectAndAddToPreviousArgumentsIfNecessary(
 			return nextDbObject;
 		}
 
-		private Object convertUnaryMinusOp(ExpressionTransformationContextSupport<OperatorNode> context, Object leftResult) {
+		private Object convertUnaryMinusOp(ExpressionTransformationContextSupport<OperatorNode> context,
+				Object leftResult) {
 
 			Object result = leftResult instanceof Number ? leftResult
 					: new BasicDBObject("$multiply", dbList(-1, leftResult));
@@ -289,7 +309,7 @@ private Object convertUnaryMinusOp(ExpressionTransformationContextSupport<Operat
 		 */
 		@Override
 		protected boolean supports(ExpressionNode node) {
-			return node.isMathematicalOperation();
+			return node.isMathematicalOperation() || node.isLogicalOperator();
 		}
 	}
 
@@ -462,13 +482,31 @@ public MethodReferenceNodeConversion(AggregationExpressionTransformer transforme
 		protected Object convert(AggregationExpressionTransformationContext<MethodReferenceNode> context) {
 
 			MethodReferenceNode node = context.getCurrentNode();
-			List<Object> args = new ArrayList<Object>();
+			AggregationMethodReference methodReference = node.getMethodReference();
 
-			for (ExpressionNode childNode : node) {
-				args.add(transform(childNode, context));
+			Object args = null;
+
+			if (ObjectUtils.nullSafeEquals(methodReference.getArgumentType(), ArgumentType.SINGLE)) {
+				args = transform(node.getChild(0), context);
+			} else if (ObjectUtils.nullSafeEquals(methodReference.getArgumentType(), ArgumentType.MAP)) {
+
+				DBObject dbo = new BasicDBObject();
+				for (int i = 0; i < methodReference.getArgumentMap().length; i++) {
+					dbo.put(methodReference.getArgumentMap()[i], transform(node.getChild(i), context));
+				}
+				args = dbo;
+			} else {
+
+				List<Object> argList = new ArrayList<Object>();
+
+				for (ExpressionNode childNode : node) {
+					argList.add(transform(childNode, context));
+				}
+
+				args = dbList(argList.toArray());
 			}
 
-			return context.addToPreviousOrReturn(new BasicDBObject(node.getMethodName(), dbList(args.toArray())));
+			return context.addToPreviousOrReturn(new BasicDBObject(methodReference.getMongoOperator(), args));
 		}
 	}
 
@@ -510,4 +548,81 @@ protected boolean supports(ExpressionNode node) {
 			return node.isOfType(CompoundExpression.class);
 		}
 	}
+
+	/**
+	 * @author Christoph Strobl
+	 * @since 1.10
+	 */
+	static class NotOperatorNodeConversion extends ExpressionNodeConversion<NotOperatorNode> {
+
+		/**
+		 * Creates a new {@link ExpressionNodeConversion}.
+		 *
+		 * @param transformer must not be {@literal null}.
+		 */
+		public NotOperatorNodeConversion(AggregationExpressionTransformer transformer) {
+			super(transformer);
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.aggregation.SpelExpressionTransformer.SpelNodeWrapper#convertSpelNodeToMongoObjectExpression(org.springframework.data.mongodb.core.aggregation.SpelExpressionTransformer.ExpressionConversionContext)
+		 */
+		@Override
+		protected Object convert(AggregationExpressionTransformationContext<NotOperatorNode> context) {
+
+			NotOperatorNode node = context.getCurrentNode();
+			List<Object> args = new ArrayList<Object>();
+
+			for (ExpressionNode childNode : node) {
+				args.add(transform(childNode, context));
+			}
+
+			return context.addToPreviousOrReturn(new BasicDBObject(node.getMongoOperator(), dbList(args.toArray())));
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.aggregation.SpelExpressionTransformer.NodeConversion#supports(org.springframework.data.mongodb.core.spel.ExpressionNode)
+		 */
+		@Override
+		protected boolean supports(ExpressionNode node) {
+			return node.isOfType(OperatorNot.class);
+		}
+	}
+
+	/**
+	 * @author Christoph Strobl
+	 * @since 1.10
+	 */
+	static class ValueRetrievingNodeConversion extends ExpressionNodeConversion<ExpressionNode> {
+
+		/**
+		 * Creates a new {@link ExpressionNodeConversion}.
+		 *
+		 * @param transformer must not be {@literal null}.
+		 */
+		public ValueRetrievingNodeConversion(AggregationExpressionTransformer transformer) {
+			super(transformer);
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.aggregation.SpelExpressionTransformer.SpelNodeWrapper#convertSpelNodeToMongoObjectExpression(org.springframework.data.mongodb.core.aggregation.SpelExpressionTransformer.ExpressionConversionContext)
+		 */
+		@Override
+		protected Object convert(AggregationExpressionTransformationContext<ExpressionNode> context) {
+			return context.getCurrentNode().getValue();
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.aggregation.SpelExpressionTransformer.NodeConversion#supports(org.springframework.data.mongodb.core.spel.ExpressionNode)
+		 */
+		@Override
+		protected boolean supports(ExpressionNode node) {
+			return node.isOfType(InlineMap.class) || node.isOfType(InlineList.class)
+					|| node.isOfType(ConstructorReference.class);
+		}
+	}
 }

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/spel/ExpressionNode.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013 the original author or authors.
+ * Copyright 2013-2016 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -23,12 +23,14 @@
 import org.springframework.expression.spel.ast.Literal;
 import org.springframework.expression.spel.ast.MethodReference;
 import org.springframework.expression.spel.ast.Operator;
+import org.springframework.expression.spel.ast.OperatorNot;
 import org.springframework.util.Assert;
 
 /**
  * A value object for nodes in an expression. Allows iterating ove potentially available child {@link ExpressionNode}s.
  * 
  * @author Oliver Gierke
+ * @author Christoph Strobl
  */
 public class ExpressionNode implements Iterable<ExpressionNode> {
 
@@ -79,6 +81,10 @@ public static ExpressionNode from(SpelNode node, ExpressionState state) {
 			return new LiteralNode((Literal) node, state);
 		}
 
+		if (node instanceof OperatorNot) {
+			return new NotOperatorNode((OperatorNot) node, state);
+		}
+
 		return new ExpressionNode(node, state);
 	}
 
@@ -122,6 +128,16 @@ public boolean isMathematicalOperation() {
 		return false;
 	}
 
+	/**
+	 * Returns whether the {@link ExpressionNode} is a logical conjunction operation like {@code &&, ||}.
+	 *
+	 * @return
+	 * @since 1.10
+	 */
+	public boolean isLogicalOperator() {
+		return false;
+	}
+
 	/**
 	 * Returns whether the {@link ExpressionNode} is a literal.
 	 * 

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/spel/LiteralNode.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013 the original author or authors.
+ * Copyright 2013-2016 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -15,7 +15,12 @@
  */
 package org.springframework.data.mongodb.core.spel;
 
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+
 import org.springframework.expression.spel.ExpressionState;
+import org.springframework.expression.spel.ast.BooleanLiteral;
 import org.springframework.expression.spel.ast.FloatLiteral;
 import org.springframework.expression.spel.ast.IntLiteral;
 import org.springframework.expression.spel.ast.Literal;
@@ -26,13 +31,29 @@
 
 /**
  * A node representing a literal in an expression.
- * 
+ *
  * @author Oliver Gierke
+ * @author Christoph Strobl
  */
 public class LiteralNode extends ExpressionNode {
 
+	private static final Set<Class<?>> SUPPORTED_LITERAL_TYPES;
 	private final Literal literal;
 
+	static {
+
+		Set<Class<?>> supportedTypes = new HashSet<Class<?>>(7, 1);
+		supportedTypes.add(BooleanLiteral.class);
+		supportedTypes.add(FloatLiteral.class);
+		supportedTypes.add(IntLiteral.class);
+		supportedTypes.add(LongLiteral.class);
+		supportedTypes.add(NullLiteral.class);
+		supportedTypes.add(RealLiteral.class);
+		supportedTypes.add(StringLiteral.class);
+
+		SUPPORTED_LITERAL_TYPES = Collections.unmodifiableSet(supportedTypes);
+	}
+
 	/**
 	 * Creates a new {@link LiteralNode} from the given {@link Literal} and {@link ExpressionState}.
 	 * 
@@ -66,7 +87,6 @@ public boolean isUnaryMinus(ExpressionNode parent) {
 	 */
 	@Override
 	public boolean isLiteral() {
-		return literal instanceof FloatLiteral || literal instanceof RealLiteral || literal instanceof IntLiteral
-				|| literal instanceof LongLiteral || literal instanceof StringLiteral || literal instanceof NullLiteral;
+		return SUPPORTED_LITERAL_TYPES.contains(literal.getClass());
 	}
 }