DATAMONGO-941 - Add support for Update $min.

Moved construction of validators to KeywordFactory. Reduced nesting in Keyword validation.

Author: Thomas Darimont

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

@@ -106,7 +106,7 @@ public QueryMapper(MongoConverter converter) {
 	public DBObject getMappedObject(DBObject query, MongoPersistentEntity<?> entity) {
 
 		if (isNestedKeyword(query)) {
-			return getMappedKeyword(keywordFor(query, entity, mappingContext), entity);
+			return getMappedKeyword(keywordFor(query, entity, null, mappingContext), entity);
 		}
 
 		DBObject result = new BasicDBObject();
@@ -124,8 +124,7 @@ public DBObject getMappedObject(DBObject query, MongoPersistentEntity<?> entity)
 			}
 
 			if (isKeyword(key)) {
-				result.putAll(getMappedKeyword(new Keyword(query, key, new KeywordContext(null, entity, mappingContext)),
-						entity));
+				result.putAll(getMappedKeyword(keywordFor(key, query.get(key), entity, null, mappingContext), entity));
 				continue;
 			}
 
@@ -531,41 +530,17 @@ protected boolean isKeyword(String candidate) {
 	static class Keyword {
 
 		private static final String N_OR_PATTERN = "\\$.*or";
-		private List<Validator> validators;
 		private final String key;
 		private final Object value;
 		private final KeywordContext context;
+		private final List<Validator> validators;
 
-		private static final Validator MIN_OPERATOR_VALIDATOR = KeywordParameterTypeValidator.whitelist(Byte.class,
-				Short.class, Integer.class, Long.class, Float.class, Double.class, Date.class);
-
-		public Keyword(DBObject dbo, KeywordContext context) {
-			this(dbo, assertAndReturnOnlySingleKey(dbo), context);
-		}
-
-		public Keyword(DBObject dbo, String key, KeywordContext context) {
+		public Keyword(String key, Object value, KeywordContext context, List<Validator> validators) {
 
 			this.key = key;
-			this.value = dbo.get(key);
+			this.value = value;
 			this.context = context;
-			this.validators = createValidators(key);
-		}
-
-		private List<Validator> createValidators(String key) {
-
-			if (key.equalsIgnoreCase("$min")) {
-				return Arrays.asList(MIN_OPERATOR_VALIDATOR);
-			}
-
-			return Collections.<Validator> emptyList();
-		}
-
-		static String assertAndReturnOnlySingleKey(DBObject dbo) {
-
-			Set<String> keys = dbo.keySet();
-			Assert.isTrue(keys.size() == 1, "Can only use a single value DBObject!");
-
-			return keys.iterator().next();
+			this.validators = validators;
 		}
 
 		/**
@@ -682,24 +657,55 @@ public MappingContext<? extends MongoPersistentEntity<?>, MongoPersistentPropert
 	 * @author Christoph Strobl
 	 * @since 1.7
 	 */
-	static class KeywordFactory {
+	static enum KeywordFactory {
+
+		INSTANCE;
+
+		private static final Validator VALID_MIN_OPERATOR_TYPES_VALIDATOR = KeywordParameterTypeValidator.whitelist(
+				Byte.class, Short.class, Integer.class, Long.class, Float.class, Double.class, Date.class);
 
 		static Keyword keywordFor(DBObject source,
 				MappingContext<? extends MongoPersistentEntity<?>, MongoPersistentProperty> mappingContext) {
-			return keywordFor(source, (MongoPersistentEntity<?>) null, mappingContext);
+			return keywordFor(source, (MongoPersistentEntity<?>) null, null, mappingContext);
 		}
 
-		static Keyword keywordFor(DBObject source, MongoPersistentEntity<?> entity,
+		static Keyword keywordFor(DBObject source, MongoPersistentProperty property,
 				MappingContext<? extends MongoPersistentEntity<?>, MongoPersistentProperty> mappingContext) {
-			return new Keyword(source, new KeywordContext(null, entity, mappingContext));
+			return keywordFor(source, null, property, mappingContext);
 		}
 
-		static Keyword keywordFor(DBObject source, MongoPersistentProperty property,
+		static Keyword keywordFor(DBObject source, MongoPersistentEntity<?> entity, MongoPersistentProperty property,
 				MappingContext<? extends MongoPersistentEntity<?>, MongoPersistentProperty> mappingContext) {
 
-			KeywordContext context = new KeywordContext(property, property == null ? null
+			String key = assertAndReturnOnlySingleKey(source);
+			return keywordFor(key, source.get(key), entity, property, mappingContext);
+		}
+
+		static Keyword keywordFor(String key, Object value, MongoPersistentEntity<?> entity,
+				MongoPersistentProperty property,
+				MappingContext<? extends MongoPersistentEntity<?>, MongoPersistentProperty> mappingContext) {
+
+			KeywordContext context = new KeywordContext(property, property == null ? entity
 					: (MongoPersistentEntity<?>) property.getOwner(), mappingContext);
-			return new Keyword(source, context);
+
+			return new Keyword(key, value, context, INSTANCE.getValidatorsFor(key));
+		}
+
+		private List<Validator> getValidatorsFor(String key) {
+
+			if (key.equalsIgnoreCase("$min")) {
+				return Arrays.asList(VALID_MIN_OPERATOR_TYPES_VALIDATOR);
+			}
+
+			return Collections.<Validator> emptyList();
+		}
+
+		static String assertAndReturnOnlySingleKey(DBObject dbo) {
+
+			Set<String> keys = dbo.keySet();
+			Assert.isTrue(keys.size() == 1, "Can only use a single value DBObject!");
+
+			return keys.iterator().next();
 		}
 	}
 
@@ -732,21 +738,25 @@ public void validate(Object target, Errors errors) {
 	 */
 	static class KeywordParameterTypeValidator extends KeywordValidator {
 
+		enum Mode {
+			WHITE_LIST, BLACK_LIST;
+		}
+
 		private final Set<Class<?>> types;
-		private final boolean invert;
+		private final Mode mode;
 
-		private KeywordParameterTypeValidator(boolean invert, Class<?>... supportedTypes) {
+		private KeywordParameterTypeValidator(Mode mode, Class<?>... supportedTypes) {
 
-			this.invert = invert;
+			this.mode = mode;
 			this.types = new HashSet<Class<?>>(Arrays.asList(supportedTypes));
 		}
 
 		public static KeywordParameterTypeValidator whitelist(Class<?>... supportedTypes) {
-			return new KeywordParameterTypeValidator(false, supportedTypes);
+			return new KeywordParameterTypeValidator(Mode.WHITE_LIST, supportedTypes);
 		}
 
 		public static KeywordParameterTypeValidator blacklist(Class<?>... unsupportedTypes) {
-			return new KeywordParameterTypeValidator(true, unsupportedTypes);
+			return new KeywordParameterTypeValidator(Mode.BLACK_LIST, unsupportedTypes);
 		}
 
 		private void doValidate(Object candidate, Errors errors) {
@@ -768,15 +778,11 @@ private void doValidate(Object candidate, Errors errors) {
 
 			Class<?> typeToValidate = ClassUtils.isAssignable(MongoPersistentProperty.class, candidate.getClass()) ? ((MongoPersistentProperty) candidate)
 					.getActualType() : candidate.getClass();
+			boolean givenTypeContainedInTypes = types.contains(ClassUtils.resolvePrimitiveIfNecessary(typeToValidate));
 
-			if (types.contains(ClassUtils.resolvePrimitiveIfNecessary(typeToValidate))) {
-				if (invert) {
-					errors.reject("", String.format("Using %s is not supported for %s.", typeToValidate, errors.getObjectName()));
-				}
-			} else {
-				if (!invert) {
-					errors.reject("", String.format("Using %s is not supported for %s.", typeToValidate, errors.getObjectName()));
-				}
+			if ((Mode.BLACK_LIST.equals(mode) && givenTypeContainedInTypes)
+					|| (Mode.WHITE_LIST.equals(mode) && !givenTypeContainedInTypes)) {
+				errors.reject("", String.format("Using %s is not supported for %s.", typeToValidate, errors.getObjectName()));
 			}
 		}
 
@@ -791,53 +797,58 @@ public void validate(Keyword target, Errors errors) {
 				return;
 			}
 
-			if (target.isDBObjectValue()) {
+			if (!target.isDBObjectValue()) {
 
-				DBObject dbo = (DBObject) target.getValue();
+				MongoPersistentProperty propertyToUse = target.getContext().getProperty();
 
-				Iterator<?> keysIterator = dbo.toMap().keySet().iterator();
-				while (keysIterator.hasNext()) {
+				if (propertyToUse == null && target.getContext().getEntity() != null) {
+					propertyToUse = target.getContext().getEntity().getPersistentProperty(errors.getObjectName());
+				}
 
-					String propertyName = keysIterator.next().toString();
+				doValidate(propertyToUse, errors);
+				return;
+			}
 
-					if (StringUtils.countOccurrencesOf(propertyName, ".") == 0) {
-						doValidate(target.getContext().getEntity().getPersistentProperty(propertyName), errors);
-						continue;
-					}
+			DBObject dbo = (DBObject) target.getValue();
 
-					MongoPersistentEntity<?> propertyScope = target.getContext().getEntity();
+			Iterator<?> keysIterator = dbo.keySet().iterator();
+			while (keysIterator.hasNext()) {
+				validatePropertyPath(keysIterator.next().toString(), target.getContext(), errors);
+			}
+		}
 
-					Iterator<String> partsIterator = Arrays.asList(propertyName.split("\\.")).iterator();
-					while (partsIterator.hasNext()) {
+		private void validatePropertyPath(String propertyPath, KeywordContext context, Errors errors) {
 
-						MongoPersistentProperty property = (MongoPersistentProperty) propertyScope
-								.getPersistentProperty(partsIterator.next());
+			if (StringUtils.countOccurrencesOf(propertyPath, ".") == 0) {
+				doValidate(context.getEntity().getPersistentProperty(propertyPath), errors);
+				return;
+			}
 
-						if (!partsIterator.hasNext()) {
-							doValidate(property, errors);
-							continue;
-						}
+			MongoPersistentEntity<?> persistentEntity = context.getEntity();
 
-						if (property != null && property.isEntity() && partsIterator.hasNext()) {
+			Iterator<String> partsIterator = Arrays.asList(propertyPath.split("\\.")).iterator();
+			while (partsIterator.hasNext()) {
 
-							propertyScope = target.getContext().getMappingContext().getPersistentEntity(property.getActualType());
+				MongoPersistentProperty persistentProperty = (MongoPersistentProperty) persistentEntity
+						.getPersistentProperty(partsIterator.next());
 
-							if (propertyScope == null) {
-								break;
-							}
-						}
-					}
+				if (persistentProperty == null) {
+					continue;
+				}
 
+				if (!partsIterator.hasNext()) {
+					doValidate(persistentProperty, errors);
+					return;
 				}
-			} else {
 
-				MongoPersistentProperty propertyToUse = target.getContext().getProperty();
+				if (persistentProperty.isEntity() && partsIterator.hasNext()) {
 
-				if (propertyToUse == null && target.getContext().getEntity() != null) {
-					propertyToUse = target.getContext().getEntity().getPersistentProperty(errors.getObjectName());
-				}
+					persistentEntity = context.getMappingContext().getPersistentEntity(persistentProperty.getActualType());
 
-				doValidate(propertyToUse, errors);
+					if (persistentEntity == null) {
+						return;
+					}
+				}
 			}
 		}
 	}