GH-11, GH-66, GH-67, GH-68 - Improve module canvas.

Overhauled the module canvas in various ways. By default, we now skip "empty" rows. In other words, if we do not find any published events for example, we skip the entire row. CanvasOptions.revealEmptyRows() can be used to keep those empty rows around. We now also expose all value types and Spring bean references.

Refactored the dependency lookup APIs on ApplicationModule. Both DependencyType and DependencyDepth are now top-level types. Also, ApplicationModuleDependency and ApplicationModuleDependencies were introduced as explicit types. In the course of that, ApplicationModule.getDependencies(…) has got its return type changed from List<ApplicationModule> to ApplicationModuleDependencies. The internal ModuleDependency type has been renamed to QualifiedDependency.

Author: odrotbohm

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

@@ -0,0 +1,93 @@
+/*
+ * Copyright 2022 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.modulith.model;
+
+import lombok.RequiredArgsConstructor;
+
+import java.util.List;
+import java.util.stream.Stream;
+
+import org.springframework.util.Assert;
+
+/**
+ * The materialized, in other words actually present dependencies of the current module towards other modules.
+ *
+ * @author Oliver Drotbohm
+ */
+@RequiredArgsConstructor(staticName = "of")
+public class ApplicationModuleDependencies {
+
+	private final List<ApplicationModuleDependency> dependencies;
+	private final ApplicationModules modules;
+
+	/**
+	 * Returns whether the dependencies contain the given {@link ApplicationModule}.
+	 *
+	 * @param module must not be {@literal null}.
+	 * @return will never be {@literal null}.
+	 */
+	public boolean contains(ApplicationModule module) {
+
+		Assert.notNull(module, "ApplicationModule must not be null!");
+
+		return dependencies.stream()
+				.map(ApplicationModuleDependency::getTargetModule)
+				.anyMatch(module::equals);
+	}
+
+	/**
+	 * Returns whether the dependencies contain the {@link ApplicationModule} with the given name.
+	 *
+	 * @param name must not be {@literal null} or empty.
+	 * @return will never be {@literal null}.
+	 */
+	public boolean containsModuleNamed(String name) {
+
+		Assert.hasText(name, "Module name must not be null or empty!");
+
+		return dependencies.stream()
+				.map(ApplicationModuleDependency::getTargetModule)
+				.map(ApplicationModule::getName)
+				.anyMatch(name::equals);
+	}
+
+	/**
+	 * Returns all {@link DefaultMaterializedDependency} instances as {@link Stream}.
+	 *
+	 * @return will never be {@literal null}.
+	 */
+	public Stream<ApplicationModuleDependency> stream() {
+		return dependencies.stream();
+	}
+
+	public ApplicationModuleDependencies withType(DependencyType type) {
+
+		var filtered = dependencies.stream()
+				.filter(it -> it.getDependencyType().equals(type))
+				.toList();
+
+		return ApplicationModuleDependencies.of(filtered, modules);
+	}
+
+	/**
+	 * Returns whether there are any dependencies at all.
+	 *
+	 * @return will never be {@literal null}.
+	 */
+	public boolean isEmpty() {
+		return dependencies.isEmpty();
+	}
+}

spring-modulith-core/src/main/java/org/springframework/modulith/model/ApplicationModuleDependencies.java

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2022 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.modulith.model;
+
+import com.tngtech.archunit.core.domain.JavaClass;
+
+/**
+ * A dependency between two {@link ApplicationModule}s.
+ *
+ * @author Oliver Drotbohm
+ */
+public interface ApplicationModuleDependency {
+
+	/**
+	 * The source java type establishing the dependency.
+	 *
+	 * @return will never be {@literal null}.
+	 */
+	JavaClass getSourceType();
+
+	/**
+	 * The dependency target type.
+	 *
+	 * @return will never be {@literal null}.
+	 */
+	JavaClass getTargetType();
+
+	/**
+	 * The type of the dependency.
+	 *
+	 * @return will never be {@literal null}.
+	 */
+	DependencyType getDependencyType();
+
+	/**
+	 * The target {@link ApplicationModule}.
+	 *
+	 * @return will never be {@literal null}.
+	 */
+	ApplicationModule getTargetModule();
+}

spring-modulith-core/src/main/java/org/springframework/modulith/model/ApplicationModuleDependency.java

@@ -32,7 +32,6 @@
 import java.util.Optional;
 import java.util.Set;
 import java.util.function.Predicate;
-import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
 import org.springframework.data.repository.core.RepositoryMetadata;
@@ -81,7 +80,7 @@ public static ArchitecturallyEvidentType of(JavaClass type, Classes beanTypes) {
 				delegates.add(new SpringDataAwareArchitecturallyEvidentType(type, beanTypes));
 			}
 
-			delegates.add(new SpringAwareArchitecturallyEvidentType(type));
+			delegates.add(new SpringAwareArchitecturallyEvidentType(type, beanTypes));
 
 			return DelegatingType.of(type, delegates);
 		});
@@ -135,6 +134,14 @@ public boolean isConfigurationProperties() {
 		return false;
 	}
 
+	public boolean isInjectable() {
+		return isService() || isController() || isEventListener() || isConfigurationProperties();
+	}
+
+	public boolean isValueObject() {
+		return false;
+	}
+
 	/**
 	 * Returns other types that are interesting in the context of the current {@link ArchitecturallyEvidentType}. For
 	 * example, for an event listener this might be the event types the particular listener is interested in.
@@ -195,8 +202,13 @@ static class SpringAwareArchitecturallyEvidentType extends ArchitecturallyEviden
 		private static final Predicate<JavaMethod> IS_EVENT_LISTENER = IS_ANNOTATED_EVENT_LISTENER
 				.or(IS_IMPLEMENTING_EVENT_LISTENER);
 
-		public SpringAwareArchitecturallyEvidentType(JavaClass type) {
+		private final boolean injectable;
+
+		public SpringAwareArchitecturallyEvidentType(JavaClass type, Classes beanTypes) {
+
 			super(type);
+
+			this.injectable = beanTypes.contains(type);
 		}
 
 		/*
@@ -253,6 +265,15 @@ public boolean isConfigurationProperties() {
 			return Types.isAnnotatedWith(SpringTypes.AT_CONFIGURATION_PROPERTIES).test(getType());
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.modulith.model.ArchitecturallyEvidentType#isInjectable()
+		 */
+		@Override
+		public boolean isInjectable() {
+			return injectable || SpringTypes.isComponent().test(getType()) || super.isInjectable();
+		}
+
 		/*
 		 * (non-Javadoc)
 		 * @see org.springframework.modulith.model.ArchitecturallyEvidentType#getOtherTypeReferences()
@@ -411,20 +432,35 @@ public boolean isService() {
 		public boolean isEventListener() {
 			return getType().getMethods().stream().anyMatch(IS_ANNOTATED_EVENT_LISTENER);
 		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.modulith.model.ArchitecturallyEvidentType#isValueObject()
+		 */
+		@Override
+		public boolean isValueObject() {
+
+			JavaClass type = getType();
+
+			return Types.isAnnotatedWith(org.jmolecules.ddd.annotation.ValueObject.class).test(type)
+					|| type.isAssignableTo(org.jmolecules.ddd.types.ValueObject.class);
+		}
 	}
 
 	static class DelegatingType extends ArchitecturallyEvidentType {
 
 		private final Supplier<Boolean> isAggregateRoot, isRepository, isEntity, isService, isController,
-				isEventListener,
-				isConfigurationProperties;
+				isEventListener, isConfigurationProperties, isInjectable, isValueObject;
+
 		private final Supplier<Collection<JavaClass>> referenceTypes;
 		private final Supplier<Collection<ReferenceMethod>> referenceMethods;
 
 		DelegatingType(JavaClass type, Supplier<Boolean> isAggregateRoot,
 				Supplier<Boolean> isRepository, Supplier<Boolean> isEntity, Supplier<Boolean> isService,
 				Supplier<Boolean> isController, Supplier<Boolean> isEventListener,
 				Supplier<Boolean> isConfigurationProperties,
+				Supplier<Boolean> isInjectable,
+				Supplier<Boolean> isValueObject,
 				Supplier<Collection<JavaClass>> referenceTypes,
 				Supplier<Collection<ReferenceMethod>> referenceMethods) {
 
@@ -437,43 +473,49 @@ static class DelegatingType extends ArchitecturallyEvidentType {
 			this.isController = isController;
 			this.isEventListener = isEventListener;
 			this.isConfigurationProperties = isConfigurationProperties;
+			this.isInjectable = isInjectable;
+			this.isValueObject = isValueObject;
 			this.referenceTypes = referenceTypes;
 			this.referenceMethods = referenceMethods;
 		}
 
 		public static DelegatingType of(JavaClass type, List<ArchitecturallyEvidentType> types) {
 
-			Supplier<Boolean> isAggregateRoot = Suppliers
+			var isAggregateRoot = Suppliers
 					.memoize(() -> types.stream().anyMatch(ArchitecturallyEvidentType::isAggregateRoot));
 
-			Supplier<Boolean> isRepository = Suppliers
+			var isRepository = Suppliers
 					.memoize(() -> types.stream().anyMatch(ArchitecturallyEvidentType::isRepository));
 
-			Supplier<Boolean> isEntity = Suppliers
+			var isEntity = Suppliers
 					.memoize(() -> types.stream().anyMatch(ArchitecturallyEvidentType::isEntity));
 
-			Supplier<Boolean> isService = Suppliers
+			var isService = Suppliers
 					.memoize(() -> types.stream().anyMatch(ArchitecturallyEvidentType::isService));
 
-			Supplier<Boolean> isController = Suppliers
+			var isController = Suppliers
 					.memoize(() -> types.stream().anyMatch(ArchitecturallyEvidentType::isController));
 
-			Supplier<Boolean> isEventListener = Suppliers
+			var isEventListener = Suppliers
 					.memoize(() -> types.stream().anyMatch(ArchitecturallyEvidentType::isEventListener));
 
-			Supplier<Boolean> isConfigurationProperties = Suppliers
+			var isConfigurationProperties = Suppliers
 					.memoize(() -> types.stream().anyMatch(ArchitecturallyEvidentType::isConfigurationProperties));
 
+			var isInjectable = Suppliers.memoize(() -> types.stream().anyMatch(ArchitecturallyEvidentType::isInjectable));
+
+			var isValueObject = Suppliers.memoize(() -> types.stream().anyMatch(ArchitecturallyEvidentType::isValueObject));
+
 			Supplier<Collection<JavaClass>> referenceTypes = Suppliers.memoize(() -> types.stream() //
 					.flatMap(ArchitecturallyEvidentType::getReferenceTypes) //
-					.collect(Collectors.toList()));
+					.toList());
 
 			Supplier<Collection<ReferenceMethod>> referenceMethods = Suppliers.memoize(() -> types.stream() //
 					.flatMap(ArchitecturallyEvidentType::getReferenceMethods) //
-					.collect(Collectors.toList()));
+					.toList());
 
 			return new DelegatingType(type, isAggregateRoot, isRepository, isEntity, isService, isController,
-					isEventListener, isConfigurationProperties, referenceTypes, referenceMethods);
+					isEventListener, isConfigurationProperties, isInjectable, isValueObject, referenceTypes, referenceMethods);
 		}
 
 		/*
@@ -541,6 +583,24 @@ public boolean isConfigurationProperties() {
 			return isConfigurationProperties.get();
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.modulith.model.ArchitecturallyEvidentType#isInjectable()
+		 */
+		@Override
+		public boolean isInjectable() {
+			return isInjectable.get();
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.modulith.model.ArchitecturallyEvidentType#isValueObject()
+		 */
+		@Override
+		public boolean isValueObject() {
+			return isValueObject.get();
+		}
+
 		/*
 		 * (non-Javadoc)
 		 * @see org.springframework.modulith.model.ArchitecturallyEvidentType#getOtherTypeReferences()

spring-modulith-core/src/main/java/org/springframework/modulith/model/ArchitecturallyEvidentType.java

@@ -0,0 +1,25 @@
+/*
+ * Copyright 2022 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.modulith.model;
+
+public enum DependencyDepth {
+
+	NONE,
+
+	IMMEDIATE,
+
+	ALL;
+}