DATAMONGO-753 - Add support for nested field references in group operations.

Introduced FieldsExposingAggregationOperation to mark AggregationOperations that 
change the set of exposed fields available for processing by later AggregationOperations.
Extracted context state out of AggregationOperation to ExposedFieldsAggregationContext for better separation of concerns.
Modified toDbObject in Aggregation to only replace the aggregation context  when the "current" AggregationOperation was a FieldExposingAggregationOperation.
Removed the getFields() method of UnwindOperation and changed it's type to just AggregationOperation since the UnwindOperation doesn't expose new fields to the context 
and retains all fields that are currently available.
Resolution of nested field references are working now.

Author: Thomas Darimont

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

@@ -228,7 +228,7 @@ public DBObject toDbObject(String inputCollectionName, AggregationOperationConte
 			operationDocuments.add(operation.toDBObject(context));
 
 			if (operation instanceof FieldsExposingAggregationOperation) {
-				context = new CombiningAggregationOperationContext(context, (FieldsExposingAggregationOperation) operation);
+				context = new WrappingExposedFieldsAggregationOperationContext((FieldsExposingAggregationOperation) operation);
 			}
 		}
 
@@ -282,30 +282,4 @@ public FieldReference getReference(String name) {
 			return new FieldReference(new ExposedField(new AggregationField(name), true));
 		}
 	}
-
-	private static class CombiningAggregationOperationContext extends ExposedFieldsAggregationOperationContext {
-
-		private final AggregationOperationContext aggregationOperationContext;
-		private final FieldsExposingAggregationOperation fieldExposingOperation;
-
-		public CombiningAggregationOperationContext(AggregationOperationContext aggregationOperationContext,
-				FieldsExposingAggregationOperation fieldExposingOperation) {
-			this.aggregationOperationContext = aggregationOperationContext;
-			this.fieldExposingOperation = fieldExposingOperation;
-		}
-
-		@Override
-		public FieldReference getReference(String name) {
-			if (hasReferenceFor(name)) {
-				return super.getReference(name);
-			} else {
-				return aggregationOperationContext.getReference(name);
-			}
-		}
-
-		@Override
-		protected ExposedFields getFields() {
-			return fieldExposingOperation.getFields();
-		}
-	}
 }

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

@@ -49,6 +49,22 @@ public static ExposedFields from(ExposedField... fields) {
 		return from(Arrays.asList(fields));
 	}
 
+	/**
+	 * Creates a new {@link ExposedFields} instance from the given {@link ExposedFields}.
+	 * 
+	 * @param fields must not be {@literal null}.
+	 * @return
+	 */
+	public static ExposedFields from(ExposedFields fields) {
+
+		List<ExposedField> exposedFields = new ArrayList<ExposedFields.ExposedField>();
+		for (ExposedField field : fields) {
+			exposedFields.add(field);
+		}
+
+		return from(exposedFields);
+	}
+
 	/**
 	 * Creates a new {@link ExposedFields} instance from the given {@link ExposedField}s.
 	 * 
@@ -134,6 +150,24 @@ public ExposedFields and(ExposedField field) {
 		return new ExposedFields(field.synthetic ? originalFields : result, field.synthetic ? result : syntheticFields);
 	}
 
+	/**
+	 * Creates a new {@link ExposedFields} adding the given {@link ExposedFields}.
+	 * 
+	 * @param field must not be {@literal null}.
+	 * @return
+	 */
+	public ExposedFields and(ExposedFields fields) {
+
+		Assert.notNull(fields, "Exposed fields must not be null!");
+
+		ExposedFields result = from(this);
+		for (ExposedField field : fields) {
+			result = result.and(field);
+		}
+
+		return result;
+	}
+
 	/**
 	 * Returns the field with the given name or {@literal null} if no field with the given name is available.
 	 * 

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

@@ -15,7 +15,6 @@
  */
 package org.springframework.data.mongodb.core.aggregation;
 
-import org.springframework.data.mongodb.core.aggregation.ExposedFields.ExposedField;
 import org.springframework.data.mongodb.core.aggregation.ExposedFields.FieldReference;
 
 import com.mongodb.DBObject;
@@ -46,29 +45,4 @@ public DBObject getMappedObject(DBObject dbObject) {
 	public FieldReference getReference(Field field) {
 		return getReference(field.getTarget());
 	}
-
-	/* 
-	 * (non-Javadoc)
-	 * @see org.springframework.data.mongodb.core.aggregation.AggregationOperationContext#getReference(java.lang.String)
-	 */
-	@Override
-	public FieldReference getReference(String name) {
-
-		ExposedField field = getFields().getField(name);
-
-		if (field != null) {
-			return new FieldReference(field);
-		}
-
-		throw new IllegalArgumentException(String.format("Invalid reference '%s'!", name));
-	}
-
-	protected abstract ExposedFields getFields();
-
-	/* (non-Javadoc)
-	 * @see org.springframework.data.mongodb.core.aggregation.AggregationOperationContext#hasReferenceFor(java.lang.String)
-	 */
-	protected boolean hasReferenceFor(String name) {
-		return getFields().getField(name) != null;
-	}
 }

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

@@ -16,6 +16,9 @@
 package org.springframework.data.mongodb.core.aggregation;
 
 /**
+ * {@link AggregationOperation} that exposes new {@link ExposedFields} that can be used for later aggregation pipeline
+ * {@code AggregationOperation}s.
+ * 
  * @author Thomas Darimont
  */
 public interface FieldsExposingAggregationOperation extends AggregationOperation {

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

@@ -36,7 +36,7 @@
  * @author Oliver Gierke
  * @since 1.3
  */
-public class TypeBasedAggregationOperationContext implements AggregationOperationContext {
+public class TypeBasedAggregationOperationContext extends ExposedFieldsAggregationOperationContext {
 
 	private final Class<?> type;
 	private final MappingContext<? extends MongoPersistentEntity<?>, MongoPersistentProperty> mappingContext;

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

@@ -29,7 +29,7 @@
  * @author Oliver Gierke
  * @since 1.3
  */
-public class UnwindOperation implements FieldsExposingAggregationOperation {
+public class UnwindOperation implements AggregationOperation {
 
 	private final ExposedField field;
 
@@ -44,15 +44,6 @@ public UnwindOperation(Field field) {
 		this.field = new ExposedField(field, true);
 	}
 
-	/* 
-	 * (non-Javadoc)
-	 * @see org.springframework.data.mongodb.core.aggregation.ExposedFieldsAggregationOperationContext#getFields()
-	 */
-	@Override
-	public ExposedFields getFields() {
-		return ExposedFields.from(field);
-	}
-
 	/* 
 	 * (non-Javadoc)
 	 * @see org.springframework.data.mongodb.core.aggregation.AggregationOperation#toDBObject(org.springframework.data.mongodb.core.aggregation.AggregationOperationContext)

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

@@ -0,0 +1,49 @@
+package org.springframework.data.mongodb.core.aggregation;
+
+import org.springframework.data.mongodb.core.aggregation.ExposedFields.ExposedField;
+import org.springframework.data.mongodb.core.aggregation.ExposedFields.FieldReference;
+
+/**
+ * {@link AggregationOperationContext} that combines the available field references from a given
+ * {@code AggregationOperationContext} and an {@link FieldsExposingAggregationOperation}.
+ * 
+ * @author Thomas Darimont
+ * @since 1.4
+ */
+class WrappingExposedFieldsAggregationOperationContext extends ExposedFieldsAggregationOperationContext {
+
+	private final FieldsExposingAggregationOperation fieldExposingOperation;
+
+	/**
+	 * Creates a new {@link WrappingExposedFieldsAggregationOperationContext} from the given
+	 * {@link FieldsExposingAggregationOperation}.
+	 * 
+	 * @param fieldExposingOperation
+	 */
+	public WrappingExposedFieldsAggregationOperationContext(FieldsExposingAggregationOperation fieldExposingOperation) {
+		this.fieldExposingOperation = fieldExposingOperation;
+	}
+
+	/* (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.aggregation.ExposedFieldsAggregationOperationContext#getFields()
+	 */
+	private ExposedFields getFields() {
+		return fieldExposingOperation.getFields();
+	}
+
+	/* 
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.aggregation.AggregationOperationContext#getReference(java.lang.String)
+	 */
+	@Override
+	public FieldReference getReference(String name) {
+
+		ExposedField field = getFields().getField(name);
+
+		if (field != null) {
+			return new FieldReference(field);
+		}
+
+		throw new IllegalArgumentException(String.format("Invalid reference '%s'!", name));
+	}
+}

spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/AggregationTests.java

@@ -457,33 +457,34 @@ public void arithmenticOperatorsInProjectionExample() {
 
 	/**
 	 * @see DATAMONGO-753
+	 * @see http 
+	 *      ://stackoverflow.com/questions/18653574/spring-data-mongodb-aggregation-framework-invalid-reference-in-group
+	 *      -operati
 	 */
 	@Test
-	public void foo() {
+	public void allowNestedFieldReferencesAsGroupIdsInGroupExpressions() {
 
 		mongoTemplate.insert(new DATAMONGO753().withPDs(new PD("A", 1), new PD("B", 1), new PD("C", 1)));
 		mongoTemplate.insert(new DATAMONGO753().withPDs(new PD("B", 1), new PD("B", 1), new PD("C", 1)));
 
 		Aggregation agg = newAggregation( //
 				unwind("pd"), //
-				group("pd.pDch") //
+				group("pd.pDch") // the nested field expression
 						.sum("pd.up").as("uplift") //
-		);
+				, project("_id", "uplift"));
 
 		AggregationResults<DBObject> result = mongoTemplate.aggregate(agg, //
 				DATAMONGO753.class //
-				// "dATAMONGO753" //
 				, DBObject.class);
-
 		List<DBObject> stats = result.getMappedResults();
+
 		assertThat(stats.size(), is(3));
 		assertThat(stats.get(0).get("_id").toString(), is("C"));
 		assertThat((Integer) stats.get(0).get("uplift"), is(2));
 		assertThat(stats.get(1).get("_id").toString(), is("B"));
 		assertThat((Integer) stats.get(1).get("uplift"), is(3));
 		assertThat(stats.get(2).get("_id").toString(), is("A"));
 		assertThat((Integer) stats.get(2).get("uplift"), is(1));
-
 	}
 
 	private void assertLikeStats(LikeStats like, String id, long count) {

spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/AggregationUnitTests.java

@@ -15,32 +15,75 @@
  */
 package org.springframework.data.mongodb.core.aggregation;
 
+import static org.springframework.data.mongodb.core.aggregation.Aggregation.*;
+import static org.springframework.data.mongodb.core.query.Criteria.*;
+
 import org.junit.Test;
 
 /**
  * Unit tests for {@link Aggregation}.
  * 
  * @author Oliver Gierke
+ * @author Thomas Darimont
  */
 public class AggregationUnitTests {
 
 	@Test(expected = IllegalArgumentException.class)
 	public void rejectsNullAggregationOperation() {
-		Aggregation.newAggregation((AggregationOperation[]) null);
+		newAggregation((AggregationOperation[]) null);
 	}
 
 	@Test(expected = IllegalArgumentException.class)
 	public void rejectsNullTypedAggregationOperation() {
-		Aggregation.newAggregation(String.class, (AggregationOperation[]) null);
+		newAggregation(String.class, (AggregationOperation[]) null);
 	}
 
 	@Test(expected = IllegalArgumentException.class)
 	public void rejectsNoAggregationOperation() {
-		Aggregation.newAggregation(new AggregationOperation[0]);
+		newAggregation(new AggregationOperation[0]);
 	}
 
 	@Test(expected = IllegalArgumentException.class)
 	public void rejectsNoTypedAggregationOperation() {
-		Aggregation.newAggregation(String.class, new AggregationOperation[0]);
+		newAggregation(String.class, new AggregationOperation[0]);
+	}
+
+	/**
+	 * @see DATAMONGO-753
+	 */
+	@Test(expected = IllegalArgumentException.class)
+	public void checkForCorrectFieldScopeTransfer() {
+
+		newAggregation( //
+				project("a", "b"), //
+				group("a").count().as("cnt"), // a was introduced to the context by the project operation
+				project("cnt", "b") // b was removed from the context by the group operation
+		).toDbObject("foo", Aggregation.DEFAULT_CONTEXT); // -> triggers IllegalArgumentException
+	}
+
+	/**
+	 * @see DATAMONGO-753
+	 */
+	@Test
+	public void unwindOperationShouldNotChangeAvailableFields() {
+
+		newAggregation( //
+				project("a", "b"), //
+				unwind("a"), //
+				project("a", "b") // b should still be available
+		).toDbObject("foo", Aggregation.DEFAULT_CONTEXT);
+	}
+
+	/**
+	 * @see DATAMONGO-753
+	 */
+	@Test
+	public void matchOperationShouldNotChangeAvailableFields() {
+
+		newAggregation( //
+				project("a", "b"), //
+				match(where("a").gte(1)), //
+				project("a", "b") // b should still be available
+		).toDbObject("foo", Aggregation.DEFAULT_CONTEXT);
 	}
 }