GH-1494 - Improve inspectability of JavaPackage(s) and ApplicationModule for type inclusion.

Author: odrotbohm

spring-modulith-core/src/main/java/org/springframework/modulith/core/ApplicationModule.java

@@ -347,6 +347,23 @@ public boolean contains(Class<?> type) {
 		return classes.contains(type);
 	}
 
+	/**
+	 * Returns whether the module could contain the type independent of the actual types backing the current instance. The
+	 * mismatch usually comes from the distinction between production and test code. A module set up from the former would
+	 * not contain a test type within its package space. This method in contrast would acknowledge that the test type
+	 * logically belongs to the module, too.
+	 *
+	 * @param type must not be {@literal null}.
+	 * @see JavaPackage#couldContain(Class)
+	 * @since 1.4.6, 2.0.1
+	 */
+	public boolean couldContain(Class<?> type) {
+
+		Assert.notNull(type, "Class<?> must not be null!");
+
+		return contains(type) || !exclusions.couldContain(type) && basePackage.couldContain(type);
+	}
+
 	/**
 	 * Returns the {@link JavaClass} for the given candidate simple or fully-qualified type name.
 	 *

spring-modulith-core/src/main/java/org/springframework/modulith/core/JavaPackage.java

@@ -240,6 +240,19 @@ public Classes that(DescribedPredicate<? super JavaClass> predicate) {
 		return classes.that(predicate);
 	}
 
+	/**
+	 * Return whether the {@link JavaPackage} contains the given type.
+	 *
+	 * @param type must not be {@literal null}.
+	 * @since 1.4.6, 2.0.1
+	 */
+	public boolean contains(Class<?> type) {
+
+		Assert.notNull(type, "Type must not be null!");
+
+		return classes.contains(type);
+	}
+
 	/**
 	 * Return whether the {@link JavaPackage} contains the given type.
 	 *
@@ -264,6 +277,38 @@ public boolean contains(String typeName) {
 		return classes.contains(typeName);
 	}
 
+	/**
+	 * Returns whether the packages could contain the type independent of the actual types backing the current instance.
+	 * The mismatch usually comes from the distinction between production and test code. A {@link JavaPackage} set up from
+	 * the former would not contain a test type within the same package. This method in contrast would acknowledge that
+	 * the test type logically belongs to the package.
+	 *
+	 * @param type must not be {@literal null}.
+	 * @since 1.4.6, 2.0.1
+	 */
+	public boolean couldContain(Class<?> type) {
+
+		Assert.notNull(type, "Type must not be null!");
+
+		return name.contains(PackageName.ofType(type.getName()));
+	}
+
+	/**
+	 * Returns whether the packages could contain the type independent of the actual types backing the current instance.
+	 * The mismatch usually comes from the distinction between production and test code. A {@link JavaPackage} set up from
+	 * the former would not contain a test type within the same package. This method in contrast would acknowledge that
+	 * the test type logically belongs to the package.
+	 *
+	 * @param type must not be {@literal null}.
+	 * @since 1.4.6, 2.0.1
+	 */
+	public boolean couldContain(String type) {
+
+		Assert.notNull(type, "Type must not be null!");
+
+		return name.contains(PackageName.ofType(type));
+	}
+
 	/**
 	 * Returns a {@link Stream} of all {@link JavaClass}es contained in the {@link JavaPackage}.
 	 *

spring-modulith-core/src/main/java/org/springframework/modulith/core/JavaPackages.java

@@ -28,9 +28,9 @@
  * A collection of {@link JavaPackage}s.
  *
  * @author Oliver Drotbohm
- * @since 1.3
+ * @since 1.3, public since 1.4.6, 2.0.1
  */
-class JavaPackages implements Iterable<JavaPackage> {
+public class JavaPackages implements Iterable<JavaPackage> {
 
 	public static JavaPackages NONE = new JavaPackages(Collections.emptyList());
 
@@ -41,7 +41,7 @@ class JavaPackages implements Iterable<JavaPackage> {
 	 *
 	 * @param packages must not be {@literal null}.
 	 */
-	JavaPackages(Collection<JavaPackage> packages) {
+	public JavaPackages(Collection<JavaPackage> packages) {
 
 		Assert.notNull(packages, "Packages must not be null!");
 
@@ -75,7 +75,7 @@ JavaPackages flatten() {
 	 *
 	 * @return will never be {@literal null}.
 	 */
-	Stream<JavaPackage> stream() {
+	public Stream<JavaPackage> stream() {
 		return packages.stream();
 	}
 
@@ -95,6 +95,53 @@ JavaPackages getSubPackagesOf(JavaPackage pkg) {
 				.toList());
 	}
 
+	public boolean contains(JavaPackage pkg) {
+		return packages.contains(pkg);
+	}
+
+	/**
+	 * Returns whether any of the packages contains the given type.
+	 *
+	 * @param type must not be {@literal null}.
+	 * @since 1.4.6, 2.0.1
+	 */
+	boolean contains(Class<?> type) {
+
+		Assert.notNull(type, "Type must not be null!");
+
+		return stream().anyMatch(it -> it.contains(type));
+	}
+
+	/**
+	 * Returns whether any of the the packages could contain the type independent of the actual types backing the current
+	 * instance.
+	 *
+	 * @param type must not be {@literal null}.
+	 * @see JavaPackage#couldContain(Class)
+	 * @since 1.4.6, 2.0.1
+	 */
+	public boolean couldContain(Class<?> type) {
+
+		Assert.notNull(type, "Type must not be null!");
+
+		return stream().anyMatch(it -> it.couldContain(type));
+	}
+
+	/**
+	 * Returns whether any of the the packages could contain the type independent of the actual types backing the current
+	 * instance.
+	 *
+	 * @param type must not be {@literal null}.
+	 * @see JavaPackage#couldContain(String)
+	 * @since 1.4.6, 2.0.1
+	 */
+	public boolean couldContain(String type) {
+
+		Assert.notNull(type, "Type must not be null!");
+
+		return stream().anyMatch(it -> it.couldContain(type));
+	}
+
 	/*
 	 * (non-Javadoc)
 	 * @see java.lang.Iterable#iterator()