DATAMONGO-1719 - Rename blocking fluent entry interfaces from …Operation to Executable… and remove Operation from intermediate interfaces.

Original Pull Request: spring-projects#487

Author: mp911de

spring-data-mongodb-benchmarks/src/main/java/org/springframework/data/mongodb/core/ProjectionsBenchmark.java

@@ -21,8 +21,8 @@
 import org.openjdk.jmh.annotations.TearDown;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.data.annotation.Id;
-import org.springframework.data.mongodb.core.ExecutableFindOperation.FindOperationWithQuery;
-import org.springframework.data.mongodb.core.ExecutableFindOperation.TerminatingFindOperation;
+import org.springframework.data.mongodb.core.ExecutableFindOperation.FindWithQuery;
+import org.springframework.data.mongodb.core.ExecutableFindOperation.TerminatingFind;
 import org.springframework.data.mongodb.core.mapping.Field;
 import org.springframework.data.mongodb.core.query.BasicQuery;
 import org.springframework.data.mongodb.microbenchmark.AbstractMicrobenchmark;
@@ -45,12 +45,12 @@ public class ProjectionsBenchmark extends AbstractMicrobenchmark {
 
 	private Person source;
 
-	private FindOperationWithQuery<Person> asPerson;
-	private FindOperationWithQuery<DtoProjection> asDtoProjection;
-	private FindOperationWithQuery<ClosedProjection> asClosedProjection;
-	private FindOperationWithQuery<OpenProjection> asOpenProjection;
+	private FindWithQuery<Person> asPerson;
+	private FindWithQuery<DtoProjection> asDtoProjection;
+	private FindWithQuery<ClosedProjection> asClosedProjection;
+	private FindWithQuery<OpenProjection> asOpenProjection;
 
-	private TerminatingFindOperation<Person> asPersonWithFieldsRestriction;
+	private TerminatingFind<Person> asPersonWithFieldsRestriction;
 	private Document fields = new Document("firstname", 1);
 
 	@Setup

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

@@ -31,7 +31,7 @@
  *     <code>
  *         aggregateAndReturn(Jedi.class)
  *             .by(newAggregation(Human.class, project("These are not the droids you are looking for")))
- *             .get();
+ *             .all();
  *     </code>
  * </pre>
  *
@@ -47,28 +47,28 @@ public interface ExecutableAggregationOperation {
 	 * input type for he aggregation.
 	 *
 	 * @param domainType must not be {@literal null}.
-	 * @return new instance of {@link AggregationOperation}.
+	 * @return new instance of {@link ExecutableAggregation}.
 	 * @throws IllegalArgumentException if domainType is {@literal null}.
 	 */
-	<T> AggregationOperation<T> aggregateAndReturn(Class<T> domainType);
+	<T> ExecutableAggregation<T> aggregateAndReturn(Class<T> domainType);
 
 	/**
 	 * Collection override (Optional).
 	 *
 	 * @author Christoph Strobl
 	 * @since 2.0
 	 */
-	interface AggregationOperationWithCollection<T> {
+	interface AggregationWithCollection<T> {
 
 		/**
 		 * Explicitly set the name of the collection to perform the query on. <br />
 		 * Skip this step to use the default collection derived from the domain type.
 		 *
 		 * @param collection must not be {@literal null} nor {@literal empty}.
-		 * @return new instance of {@link AggregationOperationWithAggregation}.
+		 * @return new instance of {@link AggregationWithAggregation}.
 		 * @throws IllegalArgumentException if collection is {@literal null}.
 		 */
-		AggregationOperationWithAggregation<T> inCollection(String collection);
+		AggregationWithAggregation<T> inCollection(String collection);
 	}
 
 	/**
@@ -77,7 +77,7 @@ interface AggregationOperationWithCollection<T> {
 	 * @author Christoph Strobl
 	 * @since 2.0
 	 */
-	interface TerminatingAggregationOperation<T> {
+	interface TerminatingAggregation<T> {
 
 		/**
 		 * Apply pipeline operations as specified and get all matching elements.
@@ -102,22 +102,21 @@ interface TerminatingAggregationOperation<T> {
 	 * @author Christoph Strobl
 	 * @since 2.0
 	 */
-	interface AggregationOperationWithAggregation<T> {
+	interface AggregationWithAggregation<T> {
 
 		/**
 		 * Set the aggregation to be used.
 		 *
 		 * @param aggregation must not be {@literal null}.
-		 * @return new instance of {@link TerminatingAggregationOperation}.
+		 * @return new instance of {@link TerminatingAggregation}.
 		 * @throws IllegalArgumentException if aggregation is {@literal null}.
 		 */
-		TerminatingAggregationOperation<T> by(Aggregation aggregation);
+		TerminatingAggregation<T> by(Aggregation aggregation);
 	}
 
 	/**
 	 * @author Christoph Strobl
 	 * @since 2.0
 	 */
-	interface AggregationOperation<T>
-			extends AggregationOperationWithCollection<T>, AggregationOperationWithAggregation<T> {}
+	interface ExecutableAggregation<T> extends AggregationWithCollection<T>, AggregationWithAggregation<T> {}
 }

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

@@ -28,6 +28,7 @@
  * Implementation of {@link ExecutableAggregationOperation} operating directly on {@link MongoTemplate}.
  *
  * @author Christoph Strobl
+ * @author Mark Paluch
  * @since 2.0
  */
 class ExecutableAggregationOperationSupport implements ExecutableAggregationOperation {
@@ -48,40 +49,40 @@ class ExecutableAggregationOperationSupport implements ExecutableAggregationOper
 	}
 
 	@Override
-	public <T> AggregationOperation<T> aggregateAndReturn(Class<T> domainType) {
+	public <T> ExecutableAggregation<T> aggregateAndReturn(Class<T> domainType) {
 
 		Assert.notNull(domainType, "DomainType must not be null!");
 
-		return new AggregationOperationSupport<>(template, null, domainType, null);
+		return new ExecutableAggregationSupport<>(template, null, domainType, null);
 	}
 
 	/**
 	 * @author Christoph Strobl
 	 * @since 2.0
 	 */
 	@RequiredArgsConstructor
-	static class AggregationOperationSupport<T>
-			implements AggregationOperationWithAggregation<T>, AggregationOperation<T>, TerminatingAggregationOperation<T> {
+	static class ExecutableAggregationSupport<T>
+			implements AggregationWithAggregation<T>, ExecutableAggregation<T>, TerminatingAggregation<T> {
 
 		private final MongoTemplate template;
 		private final Aggregation aggregation;
 		private final Class<T> domainType;
 		private final String collection;
 
 		@Override
-		public AggregationOperationWithAggregation<T> inCollection(String collection) {
+		public AggregationWithAggregation<T> inCollection(String collection) {
 
 			Assert.hasText(collection, "Collection must not be null nor empty!");
 
-			return new AggregationOperationSupport<>(template, aggregation, domainType, collection);
+			return new ExecutableAggregationSupport<>(template, aggregation, domainType, collection);
 		}
 
 		@Override
-		public TerminatingAggregationOperation<T> by(Aggregation aggregation) {
+		public TerminatingAggregation<T> by(Aggregation aggregation) {
 
 			Assert.notNull(aggregation, "Aggregation must not be null!");
 
-			return new AggregationOperationSupport<>(template, aggregation, domainType, collection);
+			return new ExecutableAggregationSupport<>(template, aggregation, domainType, collection);
 		}
 
 		@Override

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

@@ -54,18 +54,18 @@ public interface ExecutableFindOperation {
 	 * Start creating a find operation for the given {@literal domainType}.
 	 *
 	 * @param domainType must not be {@literal null}.
-	 * @return new instance of {@link FindOperation}.
+	 * @return new instance of {@link ExecutableFind}.
 	 * @throws IllegalArgumentException if domainType is {@literal null}.
 	 */
-	<T> FindOperation<T> query(Class<T> domainType);
+	<T> ExecutableFind<T> query(Class<T> domainType);
 
 	/**
 	 * Trigger find execution by calling one of the terminating methods.
 	 *
 	 * @author Christoph Strobl
 	 * @since 2.0
 	 */
-	interface TerminatingFindOperation<T> {
+	interface TerminatingFind<T> {
 
 		/**
 		 * Get exactly zero or one result.
@@ -137,7 +137,7 @@ default Optional<T> first() {
 	 * @author Christoph Strobl
 	 * @since 2.0
 	 */
-	interface TerminatingFindNearOperation<T> {
+	interface TerminatingFindNear<T> {
 
 		/**
 		 * Find all matching elements and return them as {@link org.springframework.data.geo.GeoResult}.
@@ -153,25 +153,25 @@ interface TerminatingFindNearOperation<T> {
 	 * @author Christoph Strobl
 	 * @since 2.0
 	 */
-	interface FindOperationWithQuery<T> extends TerminatingFindOperation<T> {
+	interface FindWithQuery<T> extends TerminatingFind<T> {
 
 		/**
 		 * Set the filter query to be used.
 		 *
 		 * @param query must not be {@literal null}.
-		 * @return new instance of {@link TerminatingFindOperation}.
+		 * @return new instance of {@link TerminatingFind}.
 		 * @throws IllegalArgumentException if query is {@literal null}.
 		 */
-		TerminatingFindOperation<T> matching(Query query);
+		TerminatingFind<T> matching(Query query);
 
 		/**
 		 * Set the filter query for the geoNear execution.
 		 *
 		 * @param nearQuery must not be {@literal null}.
-		 * @return new instance of {@link TerminatingFindNearOperation}.
+		 * @return new instance of {@link TerminatingFindNear}.
 		 * @throws IllegalArgumentException if nearQuery is {@literal null}.
 		 */
-		TerminatingFindNearOperation<T> near(NearQuery nearQuery);
+		TerminatingFindNear<T> near(NearQuery nearQuery);
 	}
 
 	/**
@@ -180,17 +180,17 @@ interface FindOperationWithQuery<T> extends TerminatingFindOperation<T> {
 	 * @author Christoph Strobl
 	 * @since 2.0
 	 */
-	interface FindOperationWithCollection<T> extends FindOperationWithQuery<T> {
+	interface FindWithCollection<T> extends FindWithQuery<T> {
 
 		/**
 		 * Explicitly set the name of the collection to perform the query on. <br />
 		 * Skip this step to use the default collection derived from the domain type.
 		 *
 		 * @param collection must not be {@literal null} nor {@literal empty}.
-		 * @return new instance of {@link FindOperationWithProjection}.
+		 * @return new instance of {@link FindWithProjection}.
 		 * @throws IllegalArgumentException if collection is {@literal null}.
 		 */
-		FindOperationWithProjection<T> inCollection(String collection);
+		FindWithProjection<T> inCollection(String collection);
 	}
 
 	/**
@@ -199,25 +199,25 @@ interface FindOperationWithCollection<T> extends FindOperationWithQuery<T> {
 	 * @author Christoph Strobl
 	 * @since 2.0
 	 */
-	interface FindOperationWithProjection<T> extends FindOperationWithQuery<T> {
+	interface FindWithProjection<T> extends FindWithQuery<T> {
 
 		/**
 		 * Define the target type fields should be mapped to. <br />
 		 * Skip this step if you are anyway only interested in the original domain type.
 		 *
 		 * @param resultType must not be {@literal null}.
 		 * @param <R> result type.
-		 * @return new instance of {@link FindOperationWithProjection}.
+		 * @return new instance of {@link FindWithProjection}.
 		 * @throws IllegalArgumentException if resultType is {@literal null}.
 		 */
-		<R> FindOperationWithQuery<R> as(Class<R> resultType);
+		<R> FindWithQuery<R> as(Class<R> resultType);
 	}
 
 	/**
-	 * {@link FindOperation} provides methods for constructing lookup operations in a fluent way.
+	 * {@link ExecutableFind} provides methods for constructing lookup operations in a fluent way.
 	 *
 	 * @author Christoph Strobl
 	 * @since 2.0
 	 */
-	interface FindOperation<T> extends FindOperationWithCollection<T>, FindOperationWithProjection<T> {}
+	interface ExecutableFind<T> extends FindWithCollection<T>, FindWithProjection<T> {}
 }

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

@@ -61,11 +61,11 @@ class ExecutableFindOperationSupport implements ExecutableFindOperation {
 	}
 
 	@Override
-	public <T> FindOperation<T> query(Class<T> domainType) {
+	public <T> ExecutableFind<T> query(Class<T> domainType) {
 
 		Assert.notNull(domainType, "DomainType must not be null!");
 
-		return new FindOperationSupport<>(template, domainType, domainType, null, ALL_QUERY);
+		return new ExecutableFindSupport<>(template, domainType, domainType, null, ALL_QUERY);
 	}
 
 	/**
@@ -74,8 +74,8 @@ public <T> FindOperation<T> query(Class<T> domainType) {
 	 * @since 2.0
 	 */
 	@RequiredArgsConstructor
-	static class FindOperationSupport<T> implements FindOperation<T>, FindOperationWithCollection<T>,
-			FindOperationWithProjection<T>, FindOperationWithQuery<T> {
+	static class ExecutableFindSupport<T>
+			implements ExecutableFind<T>, FindWithCollection<T>, FindWithProjection<T>, FindWithQuery<T> {
 
 		private final MongoTemplate template;
 		private final Class<?> domainType;
@@ -84,27 +84,27 @@ static class FindOperationSupport<T> implements FindOperation<T>, FindOperationW
 		private final Query query;
 
 		@Override
-		public FindOperationWithProjection<T> inCollection(String collection) {
+		public FindWithProjection<T> inCollection(String collection) {
 
 			Assert.hasText(collection, "Collection name must not be null nor empty!");
 
-			return new FindOperationSupport<>(template, domainType, returnType, collection, query);
+			return new ExecutableFindSupport<>(template, domainType, returnType, collection, query);
 		}
 
 		@Override
-		public <T1> FindOperationWithQuery<T1> as(Class<T1> returnType) {
+		public <T1> FindWithQuery<T1> as(Class<T1> returnType) {
 
 			Assert.notNull(returnType, "ReturnType must not be null!");
 
-			return new FindOperationSupport<>(template, domainType, returnType, collection, query);
+			return new ExecutableFindSupport<>(template, domainType, returnType, collection, query);
 		}
 
 		@Override
-		public TerminatingFindOperation<T> matching(Query query) {
+		public TerminatingFind<T> matching(Query query) {
 
 			Assert.notNull(query, "Query must not be null!");
 
-			return new FindOperationSupport<>(template, domainType, returnType, collection, query);
+			return new ExecutableFindSupport<>(template, domainType, returnType, collection, query);
 		}
 
 		@Override
@@ -142,7 +142,7 @@ public Stream<T> stream() {
 		}
 
 		@Override
-		public TerminatingFindNearOperation<T> near(NearQuery nearQuery) {
+		public TerminatingFindNear<T> near(NearQuery nearQuery) {
 			return () -> template.geoNear(nearQuery, domainType, getCollectionName(), returnType);
 		}