Introduce dedicated of(…) methods for dot-path parsing. Introduce PartPropertyPaths utility.

Author: mp911de

src/main/java/org/springframework/data/core/PropertyPath.java

@@ -35,19 +35,6 @@
  */
 public interface PropertyPath extends Streamable<PropertyPath> {
 
-	/**
-	 * Syntax sugar to create a {@link TypedPropertyPath} from an existing one, ideal for method handles.
-	 *
-	 * @param propertyPath
-	 * @return
-	 * @param <T> owning type.
-	 * @param <R> property type.
-	 * @since 4.1
-	 */
-	static <T, R> TypedPropertyPath<T, R> of(TypedPropertyPath<T, R> propertyPath) {
-		return TypedPropertyPath.of(propertyPath);
-	}
-
 	/**
 	 * Returns the owning type of the {@link PropertyPath}.
 	 *
@@ -167,7 +154,7 @@ default PropertyPath nested(String path) {
 
 		String lookup = toDotPath().concat(".").concat(path);
 
-		return SimplePropertyPath.from(lookup, getOwningType());
+		return SimplePropertyPath.of(lookup, getOwningType());
 	}
 
 	/**
@@ -191,7 +178,8 @@ default PropertyPath nested(String path) {
 	Iterator<PropertyPath> iterator();
 
 	/**
-	 * Extracts the {@link PropertyPath} chain from the given source {@link String} and {@link TypeInformation}. <br />
+	 * Extracts the {@link PropertyPath} chain from the given source {@link String} and {@link Class}.
+	 * <p>
 	 * Uses {@code (?:[%s]?([%s]*?[^%s]+))} by default and {@code (?:[%s]?([%s]*?[^%s]+))} for
 	 * {@link Pattern#quote(String) quoted} literals.
 	 * <p>
@@ -202,13 +190,17 @@ default PropertyPath nested(String path) {
 	 * @param source a String denoting the property path, must not be {@literal null}.
 	 * @param type the owning type of the property path, must not be {@literal null}.
 	 * @return a new {@link PropertyPath} guaranteed to be not {@literal null}.
+	 * @deprecated since 4.1, use {@code org.springframework.data.core.PropertyPath#from(…)} for parsing property paths
+	 *             using letter casing and underscores as delimiters.
 	 */
+	@Deprecated(since = "4.1")
 	static PropertyPath from(String source, Class<?> type) {
 		return from(source, TypeInformation.of(type));
 	}
 
 	/**
-	 * Extracts the {@link PropertyPath} chain from the given source {@link String} and {@link TypeInformation}. <br />
+	 * Extracts the {@link PropertyPath} chain from the given source {@link String} and {@link TypeInformation}.
+	 * <p>
 	 * Uses {@code (?:[%s]?([%s]*?[^%s]+))} by default and {@code (?:[%s]?([%s]*?[^%s]+))} for
 	 * {@link Pattern#quote(String) quoted} literals.
 	 * <p>
@@ -219,9 +211,61 @@ static PropertyPath from(String source, Class<?> type) {
 	 * @param source a String denoting the property path, must not be {@literal null}.
 	 * @param type the owning type of the property path, must not be {@literal null}.
 	 * @return a new {@link PropertyPath} guaranteed to be not {@literal null}.
+	 * @deprecated since 4.1, use {@code org.springframework.data.core.PropertyPath#from(…)} for parsing property paths
+	 *             using letter casing and underscores as delimiters.
 	 */
+	@Deprecated(since = "4.1")
 	static PropertyPath from(String source, TypeInformation<?> type) {
 		return SimplePropertyPath.from(source, type);
 	}
 
+	/**
+	 * Creates a {@link PropertyPath} chain from the given source {@link String} and {@link Class} using dot path
+	 * notation.
+	 * <p>
+	 * Uses {@code (?:[%s]?([%s]*?[^%s]+))} by default and {@code (?:[%s]?([%s]*?[^%s]+))} for
+	 * {@link Pattern#quote(String) quoted} literals.
+	 * <p>
+	 * Separate parts of the path may be separated by {@code "."}.
+	 *
+	 * @param source a String denoting the property path, must not be {@literal null}.
+	 * @param type the owning type of the property path, must not be {@literal null}.
+	 * @return a new {@link PropertyPath} guaranteed to be not {@literal null}.
+	 * @since 4.1
+	 */
+	static PropertyPath of(String source, Class<?> type) {
+		return of(source, TypeInformation.of(type));
+	}
+
+	/**
+	 * Creates a {@link PropertyPath} chain from the given source {@link String} and {@link TypeInformation} using dot
+	 * path notation.
+	 * <p>
+	 * Uses {@code (?:[%s]?([%s]*?[^%s]+))} by default and {@code (?:[%s]?([%s]*?[^%s]+))} for
+	 * {@link Pattern#quote(String) quoted} literals.
+	 * <p>
+	 * Separate parts of the path may be separated by {@code "."}.
+	 *
+	 * @param source a String denoting the property path, must not be {@literal null}.
+	 * @param type the owning type of the property path, must not be {@literal null}.
+	 * @return a new {@link PropertyPath} guaranteed to be not {@literal null}.
+	 * @since 4.1
+	 */
+	static PropertyPath of(String source, TypeInformation<?> type) {
+		return SimplePropertyPath.of(source, type);
+	}
+
+	/**
+	 * Syntax sugar to create a {@link TypedPropertyPath} from an existing one, ideal for method handles.
+	 *
+	 * @param propertyPath
+	 * @return
+	 * @param <T> owning type.
+	 * @param <R> property type.
+	 * @since 4.1
+	 */
+	static <T, R> TypedPropertyPath<T, R> of(TypedPropertyPath<T, R> propertyPath) {
+		return TypedPropertyPath.of(propertyPath);
+	}
+
 }

src/main/java/org/springframework/data/core/SimplePropertyPath.java

@@ -45,11 +45,15 @@ class SimplePropertyPath implements PropertyPath {
 
 	private static final String PARSE_DEPTH_EXCEEDED = "Trying to parse a path with depth greater than 1000; This has been disabled for security reasons to prevent parsing overflows";
 
-	private static final String DELIMITERS = "_\\.";
+	private static final String DOT_DELIMITER = "\\.";
+	private static final String DELIMITERS = "_" + DOT_DELIMITER;
+	private static final Pattern DOT_SPLITTER = Pattern
+			.compile("(?:[%s]?([%s]*?[^%s]+))".replaceAll("%s", DOT_DELIMITER));
 	private static final Pattern SPLITTER = Pattern.compile("(?:[%s]?([%s]*?[^%s]+))".replaceAll("%s", DELIMITERS));
 	private static final Pattern SPLITTER_FOR_QUOTED = Pattern.compile("(?:[%s]?([%s]*?[^%s]+))".replaceAll("%s", "\\."));
 	private static final Pattern NESTED_PROPERTY_PATTERN = Pattern.compile("\\p{Lu}[\\p{Ll}\\p{Nd}]*$");
 	private static final Map<Property, SimplePropertyPath> cache = new ConcurrentReferenceHashMap<>();
+	private static final Map<Property, SimplePropertyPath> dotPathCache = new ConcurrentReferenceHashMap<>();
 
 	private final TypeInformation<?> owningType;
 	private final String name;
@@ -201,24 +205,6 @@ public int hashCode() {
 		return Objects.hash(owningType, name, typeInformation, actualTypeInformation, isCollection, next);
 	}
 
-	/**
-	 * Returns the next {@link SimplePropertyPath}.
-	 *
-	 * @return the next {@link SimplePropertyPath}.
-	 * @throws IllegalStateException it there's no next one.
-	 */
-	private SimplePropertyPath requiredNext() {
-
-		SimplePropertyPath result = next;
-
-		if (result == null) {
-			throw new IllegalStateException(
-					"No next path available; Clients should call hasNext() before invoking this method");
-		}
-
-		return result;
-	}
-
 	/**
 	 * Extracts the {@link SimplePropertyPath} chain from the given source {@link String} and {@link TypeInformation}.
 	 * <br />
@@ -234,36 +220,69 @@ private SimplePropertyPath requiredNext() {
 	 * @param type the owning type of the property path, must not be {@literal null}.
 	 * @return a new {@link SimplePropertyPath} guaranteed to be not {@literal null}.
 	 */
-	public static SimplePropertyPath from(String source, Class<?> type) {
-		return from(source, TypeInformation.of(type));
+	public static SimplePropertyPath from(String source, TypeInformation<?> type) {
+
+		Assert.hasText(source, "Source must not be null or empty");
+		Assert.notNull(type, "TypeInformation must not be null or empty");
+
+		return cache.computeIfAbsent(new Property(type, source), it -> {
+
+			List<String> iteratorSource = new ArrayList<>();
+
+			Matcher matcher = isQuoted(it.path) ? SPLITTER_FOR_QUOTED.matcher(it.path.replace("\\Q", "").replace("\\E", ""))
+					: SPLITTER.matcher("_" + it.path);
+
+			while (matcher.find()) {
+				iteratorSource.add(matcher.group(1));
+			}
+
+			Iterator<String> parts = iteratorSource.iterator();
+
+			SimplePropertyPath result = null;
+			Stack<SimplePropertyPath> current = new Stack<>();
+
+			while (parts.hasNext()) {
+				if (result == null) {
+					result = create(parts.next(), it.type, current, true);
+					current.push(result);
+				} else {
+					current.push(create(parts.next(), current, true));
+				}
+			}
+
+			if (result == null) {
+				throw new IllegalStateException(
+						String.format("Expected parsing to yield a PropertyPath from '%s' but got null", source));
+			}
+
+			return result;
+		});
 	}
 
 	/**
 	 * Extracts the {@link SimplePropertyPath} chain from the given source {@link String} and {@link TypeInformation}.
 	 * <br />
-	 * Uses {@link #SPLITTER} by default and {@link #SPLITTER_FOR_QUOTED} for {@link Pattern#quote(String) quoted}
+	 * Uses {@link #DOT_SPLITTER} by default and {@link #SPLITTER_FOR_QUOTED} for {@link Pattern#quote(String) quoted}
 	 * literals.
 	 * <p>
-	 * Separate parts of the path may be separated by {@code "."} or by {@code "_"} or by camel case. When the match to
-	 * properties is ambiguous longer property names are preferred. So for "userAddressCity" the interpretation
-	 * "userAddress.city" is preferred over "user.address.city".
+	 * Separate parts of the path may be separated by {@code "."}.
 	 * </p>
 	 *
 	 * @param source a String denoting the property path, must not be {@literal null}.
 	 * @param type the owning type of the property path, must not be {@literal null}.
 	 * @return a new {@link SimplePropertyPath} guaranteed to be not {@literal null}.
 	 */
-	public static SimplePropertyPath from(String source, TypeInformation<?> type) {
+	public static SimplePropertyPath of(String source, TypeInformation<?> type) {
 
 		Assert.hasText(source, "Source must not be null or empty");
 		Assert.notNull(type, "TypeInformation must not be null or empty");
 
-		return cache.computeIfAbsent(new Property(type, source), it -> {
+		return dotPathCache.computeIfAbsent(new Property(type, source), it -> {
 
 			List<String> iteratorSource = new ArrayList<>();
 
 			Matcher matcher = isQuoted(it.path) ? SPLITTER_FOR_QUOTED.matcher(it.path.replace("\\Q", "").replace("\\E", ""))
-					: SPLITTER.matcher("_" + it.path);
+					: DOT_SPLITTER.matcher("." + it.path);
 
 			while (matcher.find()) {
 				iteratorSource.add(matcher.group(1));
@@ -276,16 +295,16 @@ public static SimplePropertyPath from(String source, TypeInformation<?> type) {
 
 			while (parts.hasNext()) {
 				if (result == null) {
-					result = create(parts.next(), it.type, current);
+					result = create(parts.next(), it.type, current, false);
 					current.push(result);
 				} else {
-					current.push(create(parts.next(), current));
+					current.push(create(parts.next(), current, false));
 				}
 			}
 
 			if (result == null) {
 				throw new IllegalStateException(
-						String.format("Expected parsing to yield a PropertyPath from %s but got null", source));
+						String.format("Expected parsing to yield a PropertyPath from '%s' but got null", source));
 			}
 
 			return result;
@@ -303,11 +322,12 @@ private static boolean isQuoted(String source) {
 	 * @param base
 	 * @return
 	 */
-	private static SimplePropertyPath create(String source, Stack<SimplePropertyPath> base) {
+	private static SimplePropertyPath create(String source, Stack<SimplePropertyPath> base, boolean considerNested) {
 
 		SimplePropertyPath previous = base.peek();
 
-		SimplePropertyPath propertyPath = create(source, previous.typeInformation.getRequiredActualType(), base);
+		SimplePropertyPath propertyPath = create(source, previous.typeInformation.getRequiredActualType(), base,
+				considerNested);
 		previous.next = propertyPath;
 		return propertyPath;
 	}
@@ -322,8 +342,9 @@ private static SimplePropertyPath create(String source, Stack<SimplePropertyPath
 	 * @param type
 	 * @return
 	 */
-	private static SimplePropertyPath create(String source, TypeInformation<?> type, List<SimplePropertyPath> base) {
-		return create(source, type, "", base);
+	private static SimplePropertyPath create(String source, TypeInformation<?> type, List<SimplePropertyPath> base,
+			boolean considerNested) {
+		return create(source, type, "", base, considerNested);
 	}
 
 	/**
@@ -337,7 +358,7 @@ private static SimplePropertyPath create(String source, TypeInformation<?> type,
 	 * @return
 	 */
 	private static SimplePropertyPath create(String source, TypeInformation<?> type, String addTail,
-			List<SimplePropertyPath> base) {
+			List<SimplePropertyPath> base, boolean considerNested) {
 
 		if (base.size() > 1000) {
 			throw new IllegalArgumentException(PARSE_DEPTH_EXCEEDED);
@@ -358,7 +379,7 @@ private static SimplePropertyPath create(String source, TypeInformation<?> type,
 			newBase.add(current);
 
 			if (StringUtils.hasText(addTail)) {
-				current.next = create(addTail, current.actualTypeInformation, newBase);
+				current.next = create(addTail, current.actualTypeInformation, newBase, considerNested);
 			}
 
 			return current;
@@ -372,18 +393,21 @@ private static SimplePropertyPath create(String source, TypeInformation<?> type,
 			exception = e;
 		}
 
-		Matcher matcher = NESTED_PROPERTY_PATTERN.matcher(source);
+		if (considerNested) {
+
+			Matcher matcher = NESTED_PROPERTY_PATTERN.matcher(source);
 
-		if (matcher.find() && matcher.start() != 0) {
+			if (matcher.find() && matcher.start() != 0) {
 
-			int position = matcher.start();
-			String head = source.substring(0, position);
-			String tail = source.substring(position);
+				int position = matcher.start();
+				String head = source.substring(0, position);
+				String tail = source.substring(position);
 
-			try {
-				return create(head, type, tail + addTail, base);
-			} catch (PropertyReferenceException e) {
-				throw e.hasDeeperResolutionDepthThan(exception) ? e : exception;
+				try {
+					return create(head, type, tail + addTail, base, considerNested);
+				} catch (PropertyReferenceException e) {
+					throw e.hasDeeperResolutionDepthThan(exception) ? e : exception;
+				}
 			}
 		}
 

src/main/java/org/springframework/data/mapping/context/PersistentPropertyPathFactory.java

@@ -355,7 +355,7 @@ public Optional<PersistentPropertyPath<P>> getFirst() {
 
 		@Override
 		public boolean contains(String path) {
-			return contains(PropertyPath.from(path, type));
+			return contains(PropertyPath.of(path, type));
 		}
 
 		@Override

src/main/java/org/springframework/data/projection/EntityProjectionIntrospector.java

@@ -139,7 +139,7 @@ public <M, D> EntityProjection<M, D> introspect(Class<M> mappedType, Class<D> do
 			boolean container = isContainer(actualType);
 
 			PropertyPath nestedPropertyPath = propertyPath == null
-					? PropertyPath.from(persistentProperty.getName(), persistentEntity.getTypeInformation())
+					? PropertyPath.of(persistentProperty.getName(), persistentEntity.getTypeInformation())
 					: propertyPath.nested(persistentProperty.getName());
 
 			TypeInformation<?> unwrappedReturnedType = unwrapContainerType(actualType);

src/main/java/org/springframework/data/querydsl/binding/PropertyPathInformation.java

@@ -48,7 +48,7 @@ record PropertyPathInformation(PropertyPath path) implements PathInformation {
 	 * @return
 	 */
 	public static PropertyPathInformation of(String path, Class<?> type) {
-		return PropertyPathInformation.of(PropertyPath.from(path, type));
+		return PropertyPathInformation.of(PropertyPath.of(path, type));
 	}
 
 	/**
@@ -59,7 +59,7 @@ public static PropertyPathInformation of(String path, Class<?> type) {
 	 * @return
 	 */
 	public static PropertyPathInformation of(String path, TypeInformation<?> type) {
-		return PropertyPathInformation.of(PropertyPath.from(path, type));
+		return PropertyPathInformation.of(PropertyPath.of(path, type));
 	}
 
 	private static PropertyPathInformation of(PropertyPath path) {

src/main/java/org/springframework/data/repository/query/parser/OrderBySource.java

@@ -107,7 +107,7 @@ private Order createOrder(String propertySource, Optional<Direction> direction,
 
 		return domainClass.map(type -> {
 
-			PropertyPath propertyPath = PropertyPath.from(propertySource, type);
+			PropertyPath propertyPath = PartPropertyPaths.from(propertySource, type);
 			return direction.map(it -> new Order(it, propertyPath.toDotPath()))
 					.orElseGet(() -> Order.by(propertyPath.toDotPath()));
 

src/main/java/org/springframework/data/repository/query/parser/Part.java

@@ -78,7 +78,7 @@ public Part(String source, Class<?> clazz, boolean alwaysIgnoreCase) {
 		}
 
 		this.type = Type.fromProperty(partToUse);
-		this.propertyPath = PropertyPath.from(type.extractProperty(partToUse), clazz);
+		this.propertyPath = PartPropertyPaths.from(type.extractProperty(partToUse), clazz);
 	}
 
 	private String detectAndSetIgnoreCase(String part) {