Move PropertyPath to data.util.

Author: mp911de

src/main/java/org/springframework/data/mapping/PersistentPropertyPaths.java

@@ -18,6 +18,7 @@
 import java.util.Optional;
 import java.util.function.Predicate;
 
+import org.springframework.data.util.PropertyPath;
 import org.springframework.data.util.Streamable;
 
 /**

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

@@ -15,213 +15,17 @@
  */
 package org.springframework.data.mapping;
 
-import java.util.Iterator;
-import java.util.regex.Pattern;
-
-import org.jspecify.annotations.Nullable;
-
-import org.springframework.data.util.Streamable;
-import org.springframework.data.util.TypeInformation;
-import org.springframework.util.Assert;
-
 /**
- * Abstraction of a {@link PropertyPath} within a domain class.
+ * Abstraction of a {@code PropertyPath} within a domain class.
  *
  * @author Oliver Gierke
  * @author Christoph Strobl
  * @author Mark Paluch
  * @author Mariusz Mączkowski
  * @author Johannes Englmeier
+ * @deprecated since 4.1, use its replacement that moved to {@code org.springframework.data.util} package.
  */
-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 xxx
-	 */
-	public static <T, R> TypedPropertyPath<T, R> of(TypedPropertyPath<T, R> propertyPath) {
-		return TypedPropertyPath.of(propertyPath);
-	}
-
-	/**
-	 * Returns the owning type of the {@link PropertyPath}.
-	 *
-	 * @return the owningType will never be {@literal null}.
-	 */
-	TypeInformation<?> getOwningType();
-
-	/**
-	 * Returns the first part of the {@link PropertyPath}. For example:
-	 *
-	 * <pre class="code">
-	 * PropertyPath.from("a.b.c", Some.class).getSegment();
-	 * </pre>
-	 *
-	 * results in {@code a}.
-	 *
-	 * @return the name will never be {@literal null}.
-	 */
-	String getSegment();
-
-	/**
-	 * Returns the leaf property of the {@link PropertyPath}.
-	 *
-	 * @return will never be {@literal null}.
-	 */
-	default PropertyPath getLeafProperty() {
-
-		PropertyPath result = this;
-
-		while (result != null && result.hasNext()) {
-			result = result.next();
-		}
-
-		return result == null ? this : result;
-	}
-
-	/**
-	 * Returns the type of the leaf property of the current {@link PropertyPath}.
-	 *
-	 * @return will never be {@literal null}.
-	 */
-	default Class<?> getLeafType() {
-		return getLeafProperty().getType();
-	}
-
-	/**
-	 * Returns the actual type of the property. Will return the plain resolved type for simple properties, the component
-	 * type for any {@link Iterable} or the value type of a {@link java.util.Map}.
-	 *
-	 * @return the actual type of the property.
-	 */
-	default Class<?> getType() {
-		return getTypeInformation().getRequiredActualType().getType();
-	}
-
-	/**
-	 * Returns the type information of the property.
-	 *
-	 * @return the actual type of the property.
-	 */
-	TypeInformation<?> getTypeInformation();
-
-	/**
-	 * Returns the {@link PropertyPath} path that results from removing the first element of the current one. For example:
-	 *
-	 * <pre class="code">
-	 * PropertyPath.from("a.b.c", Some.class).next().toDotPath();
-	 * </pre>
-	 *
-	 * results in the output: {@code b.c}
-	 *
-	 * @return the next nested {@link PropertyPath} or {@literal null} if no nested {@link PropertyPath} available.
-	 * @see #hasNext()
-	 */
-	@Nullable
-	PropertyPath next();
-
-	/**
-	 * Returns whether there is a nested {@link PropertyPath}. If this returns {@literal true} you can expect
-	 * {@link #next()} to return a non- {@literal null} value.
-	 *
-	 * @return
-	 */
-	default boolean hasNext() {
-		return next() != null;
-	}
-
-	/**
-	 * Returns the {@link PropertyPath} in dot notation.
-	 *
-	 * @return the {@link PropertyPath} in dot notation.
-	 */
-	default String toDotPath() {
-
-		PropertyPath next = next();
-		return next != null ? getSegment() + "." + next.toDotPath() : getSegment();
-	}
-
-	/**
-	 * Returns whether the {@link PropertyPath} is actually a collection.
-	 *
-	 * @return {@literal true} whether the {@link PropertyPath} is actually a collection.
-	 */
-	default boolean isCollection() {
-		return getTypeInformation().isCollectionLike();
-	}
-
-	/**
-	 * Returns the {@link PropertyPath} for the path nested under the current property.
-	 *
-	 * @param path must not be {@literal null} or empty.
-	 * @return will never be {@literal null}.
-	 */
-	default PropertyPath nested(String path) {
-
-		Assert.hasText(path, "Path must not be null or empty");
-
-		String lookup = toDotPath().concat(".").concat(path);
-
-		return SimplePropertyPath.from(lookup, getOwningType());
-	}
-
-	/**
-	 * Returns an {@link Iterator Iterator of PropertyPath} that iterates over all the partial property paths with the
-	 * same leaf type but decreasing length. For example:
-	 *
-	 * <pre class="code">
-	 * PropertyPath propertyPath = PropertyPath.from("a.b.c", Some.class);
-	 * propertyPath.forEach(p -> p.toDotPath());
-	 * </pre>
-	 *
-	 * results in the dot paths:
-	 *
-	 * <pre class="code">
-	 * a.b.c
-	 * b.c
-	 * c
-	 * </pre>
-	 */
-	@Override
-	Iterator<PropertyPath> iterator();
-
-	/**
-	 * Extracts the {@link PropertyPath} chain from the given source {@link String} and {@link TypeInformation}. <br />
-	 * 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 "."} or by {@code "_"} or by camel case. When the match to
-	 * properties is ambiguous longer property names are preferred. So for {@code userAddressCity} the interpretation
-	 * {@code userAddress.city} is preferred over {@code user.address.city}.
-	 *
-	 * @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}.
-	 */
-	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 />
-	 * 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 "."} or by {@code "_"} or by camel case. When the match to
-	 * properties is ambiguous longer property names are preferred. So for {@code userAddressCity} the interpretation
-	 * {@code userAddress.city} is preferred over {@code user.address.city}.
-	 *
-	 * @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}.
-	 */
-	static PropertyPath from(String source, TypeInformation<?> type) {
-		return SimplePropertyPath.from(source, type);
-	}
+@Deprecated
+public interface PropertyPath extends org.springframework.data.util.PropertyPath {
 
 }

src/main/java/org/springframework/data/mapping/PropertyReferenceException.java

@@ -16,140 +16,34 @@
 package org.springframework.data.mapping;
 
 import java.io.Serial;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.HashSet;
 import java.util.List;
-import java.util.Set;
 
-import org.jspecify.annotations.Nullable;
-
-import org.springframework.beans.PropertyMatches;
-import org.springframework.data.util.Lazy;
+import org.springframework.data.util.PropertyPath;
 import org.springframework.data.util.TypeInformation;
-import org.springframework.util.Assert;
-import org.springframework.util.StringUtils;
 
 /**
  * Exception being thrown when creating {@link PropertyPath} instances.
  *
  * @author Oliver Gierke
  * @author Christoph Strobl
  * @author John Blum
+ * @since 4.1, use its replacement from the {@code org.springframework.data.util} package.
  */
-public class PropertyReferenceException extends RuntimeException {
+@Deprecated(since = "4.1")
+public class PropertyReferenceException extends org.springframework.data.util.PropertyReferenceException {
 
 	private static final @Serial long serialVersionUID = -5254424051438976570L;
 
-	static final String ERROR_TEMPLATE = "No property '%s' found for type '%s'";
-	static final String HINTS_TEMPLATE = "Did you mean %s";
-
-	private final String propertyName;
-	private final TypeInformation<?> type;
-	private final List<? extends PropertyPath> alreadyResolvedPath;
-	private final Lazy<Set<String>> propertyMatches;
-
 	/**
 	 * Creates a new {@link PropertyReferenceException}.
 	 *
 	 * @param propertyName the name of the property not found on the given type, must not be {@literal null} or empty.
 	 * @param type the type the property could not be found on, must not be {@literal null}.
-	 * @param alreadyResolvedPah the previously calculated {@link PropertyPath}s, must not be {@literal null}.
+	 * @param alreadyResolvedPaths the previously calculated {@link PropertyPath}s, must not be {@literal null}.
 	 */
 	public PropertyReferenceException(String propertyName, TypeInformation<?> type,
-			List<? extends PropertyPath> alreadyResolvedPah) {
-
-		Assert.hasText(propertyName, "Property name must not be null");
-		Assert.notNull(type, "Type must not be null");
-		Assert.notNull(alreadyResolvedPah, "Already resolved paths must not be null");
-
-		this.propertyName = propertyName;
-		this.type = type;
-		this.alreadyResolvedPath = alreadyResolvedPah;
-		this.propertyMatches = Lazy.of(() -> detectPotentialMatches(propertyName, type.getType()));
-	}
-
-	/**
-	 * Returns the name of the property not found.
-	 *
-	 * @return will not be {@literal null} or empty.
-	 */
-	public String getPropertyName() {
-		return propertyName;
-	}
-
-	/**
-	 * Returns the type the property could not be found on.
-	 *
-	 * @return will never be {@literal null}.
-	 */
-	public TypeInformation<?> getType() {
-		return type;
-	}
-
-	/**
-	 * Returns the properties that the invalid property might have been meant to be referred to.
-	 *
-	 * @return will never be {@literal null}.
-	 */
-	Collection<String> getPropertyMatches() {
-		return propertyMatches.get();
-	}
-
-	@Override
-	public String getMessage() {
-
-		StringBuilder builder = new StringBuilder(
-				String.format(ERROR_TEMPLATE, propertyName, type.getType().getSimpleName()));
-
-		Collection<String> potentialMatches = getPropertyMatches();
-		if (!potentialMatches.isEmpty()) {
-			String matches = StringUtils.collectionToDelimitedString(potentialMatches, ",", "'", "'");
-			builder.append("; ");
-			builder.append(String.format(HINTS_TEMPLATE, matches));
-		}
-
-		if (!alreadyResolvedPath.isEmpty()) {
-			builder.append("; Traversed path: ");
-			builder.append(alreadyResolvedPath.get(0).toString());
-		}
-
-		return builder.toString();
+			List<? extends PropertyPath> alreadyResolvedPaths) {
+		super(propertyName, type, alreadyResolvedPaths);
 	}
 
-	/**
-	 * Returns the {@link PropertyPath} which could be resolved so far.
-	 *
-	 * @return
-	 */
-	public @Nullable PropertyPath getBaseProperty() {
-		return alreadyResolvedPath.isEmpty() ? null : alreadyResolvedPath.get(alreadyResolvedPath.size() - 1);
-	}
-
-	/**
-	 * Returns whether the given {@link PropertyReferenceException} has a deeper resolution depth (i.e. a longer path of
-	 * already resolved properties) than the current exception.
-	 *
-	 * @param exception must not be {@literal null}.
-	 * @return
-	 */
-	public boolean hasDeeperResolutionDepthThan(PropertyReferenceException exception) {
-		return this.alreadyResolvedPath.size() > exception.alreadyResolvedPath.size();
-	}
-
-	/**
-	 * Detects all potential matches for the given property name and type.
-	 *
-	 * @param propertyName must not be {@literal null} or empty.
-	 * @param type must not be {@literal null}.
-	 * @return
-	 */
-	private static Set<String> detectPotentialMatches(String propertyName, Class<?> type) {
-
-		Set<String> result = new HashSet<>();
-		result.addAll(Arrays.asList(PropertyMatches.forField(propertyName, type).getPossibleMatches()));
-		result.addAll(Arrays.asList(PropertyMatches.forProperty(propertyName, type).getPossibleMatches()));
-
-		return result;
-	}
 }

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

@@ -56,7 +56,6 @@
 import org.springframework.data.mapping.PersistentProperty;
 import org.springframework.data.mapping.PersistentPropertyPath;
 import org.springframework.data.mapping.PersistentPropertyPaths;
-import org.springframework.data.mapping.PropertyPath;
 import org.springframework.data.mapping.model.ClassGeneratingPropertyAccessorFactory;
 import org.springframework.data.mapping.model.EntityInstantiators;
 import org.springframework.data.mapping.model.InstantiationAwarePropertyAccessorFactory;
@@ -70,6 +69,7 @@
 import org.springframework.data.util.KotlinReflectionUtils;
 import org.springframework.data.util.NullableWrapperConverters;
 import org.springframework.data.util.Optionals;
+import org.springframework.data.util.PropertyPath;
 import org.springframework.data.util.Streamable;
 import org.springframework.data.util.TypeInformation;
 import org.springframework.util.Assert;

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

@@ -25,7 +25,7 @@
 import org.springframework.data.mapping.PersistentProperty;
 import org.springframework.data.mapping.PersistentPropertyPath;
 import org.springframework.data.mapping.PersistentPropertyPaths;
-import org.springframework.data.mapping.PropertyPath;
+import org.springframework.data.util.PropertyPath;
 import org.springframework.data.util.TypeInformation;
 
 /**