Fix/empty module component diagram

.mvn/extensions.xml

@@ -3,6 +3,6 @@
 	<extension>
 		<groupId>io.spring.develocity.conventions</groupId>
 		<artifactId>develocity-conventions-maven-extension</artifactId>
-		<version>0.0.26</version>
+		<version>0.0.27</version>
 	</extension>
 </extensions>

.mvn/wrapper/maven-wrapper.properties

@@ -1,3 +1,3 @@
 wrapperVersion=3.3.4
 distributionType=only-script
-distributionUrl=https://repo.maven.apache.org/maven2/org/apache/maven/apache-maven/3.9.16/apache-maven-3.9.16-bin.zip
+distributionUrl=https://repo.maven.apache.org/maven2/org/apache/maven/apache-maven/3.10.0/apache-maven-3.10.0-bin.zip

pom.xml

@@ -138,6 +138,12 @@ limitations under the License.
 
 		</profile>
 
+		<!-- Release train profile to make sure the default profile gets deactivated during releases -->
+
+		<profile>
+			<id>releaseTrain</id>
+		</profile>
+
 		<!-- For integration builds against milestones and snapshots -->
 
 		<profile>

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

@@ -152,7 +152,7 @@ public static FormattableType of(ResolvableType type) {
 				.toList();
 
 		return resolved != null
-				? CACHE.computeIfAbsent(type.toString(), __ -> new FormattableType(resolved.getName(), generics))
+				? CACHE.computeIfAbsent(type.toString(), __ -> new FormattableType(resolved.getTypeName(), generics))
 				: WILDCARD;
 	}
 

spring-modulith-core/src/test/java/org/springframework/modulith/core/FormattableTypeUnitTests.java

@@ -17,10 +17,15 @@
 
 import static org.assertj.core.api.Assertions.*;
 
+import java.lang.reflect.Method;
 import java.util.List;
 import java.util.Map;
+import java.util.stream.Stream;
 
+import org.junit.jupiter.api.DynamicTest;
+import org.junit.jupiter.api.NamedExecutable;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestFactory;
 import org.springframework.core.ResolvableType;
 import org.springframework.modulith.core.FormattableType.NonModuleTypeAbbreviation;
 
@@ -128,12 +133,56 @@ void rendersDeclaredGenerics() throws Exception {
 		assertThat(type.getAbbreviatedFullName()).isEqualTo("j.u.List<j.u.Map<j.l.String, j.l.Integer>>");
 	}
 
+	@TestFactory // GH-1901
+	Stream<DynamicTest> handlesArrayTypesFromResolvableType() throws Exception {
+
+		var method = Sample.class.getMethod("arrays", Integer[].class, byte[].class, Integer[][].class, List.class);
+
+		var tests = Stream.of(
+				new $(method, 0, "j.l.Integer[]"),
+				new $(method, 1, "byte[]"),
+				new $(method, 2, "j.l.Integer[][]"),
+				new $(method, 3, "j.u.List<j.l.Integer[]>"));
+
+		return DynamicTest.stream(tests);
+	}
+
+	@Test // GH-1901
+	void rendersArrayTypesConsistentlyIndependentOfLookupOrder() {
+
+		var fromResolvableType = FormattableType.of(ResolvableType.forClass(Sample[].class));
+		var fromClass = FormattableType.of(Sample[].class);
+
+		assertThat(fromClass.getFullName())
+				.isEqualTo(fromResolvableType.getFullName())
+				.isEqualTo("org.springframework.modulith.core.FormattableTypeUnitTests.Sample[]");
+	}
+
 	interface Sample {
 
 		<T> List<?> wildcarded(List<T> parameterized);
 
 		void classWildcard(Class<?> type);
 
 		List<Map<String, Integer>> genericReturnType();
+
+		void arrays(Integer[] integers, byte[] bytes, Integer[][] matrix, List<Integer[]> list);
+	}
+
+	record $(ResolvableType type, String expected) implements NamedExecutable {
+
+		public $(Method method, int parameterIndex, String expected) {
+			this(ResolvableType.forMethodParameter(method, parameterIndex), expected);
+		}
+
+		@Override
+		public final String toString() {
+			return "%s renders as %s".formatted(type, expected);
+		}
+
+		@Override
+		public void execute() throws Throwable {
+			assertThat(FormattableType.of(type).getAbbreviatedFullName()).isEqualTo(expected);
+		}
 	}
 }

spring-modulith-docs/src/main/java/org/springframework/modulith/docs/Documenter.java

@@ -818,7 +818,7 @@ public DiagramOptions withStyle(DiagramStyle style) {
 
 		/**
 		 * Configuration setting to define whether modules that do not have a relationship to any other module shall be
-		 * retained in the diagrams created. The default is {@link ElementsWithoutRelationships#HIDDEN}. See
+		 * retained in the diagrams created. The default is {@link ElementsWithoutRelationships#VISIBLE}. See
 		 * {@link DiagramOptions#withExclusions(Predicate)} for a more fine-grained way of defining which modules to exclude
 		 * in case you flip this to {@link ElementsWithoutRelationships#VISIBLE}.
 		 *
@@ -859,7 +859,7 @@ public DiagramOptions withSkinParam(String name, @Nullable String value) {
 		public static DiagramOptions defaults() {
 			return new DiagramOptions(ALL_TYPES, DependencyDepth.IMMEDIATE, it -> false, it -> true, it -> false, null,
 					__ -> Optional.empty(), it -> it.getDisplayName(), DiagramStyle.C4,
-					ElementsWithoutRelationships.HIDDEN, new LinkedHashMap<>());
+					ElementsWithoutRelationships.VISIBLE, new LinkedHashMap<>());
 		}
 
 		/**

spring-modulith-events/pom.xml

@@ -55,11 +55,16 @@
 
 		</profile>
 
-		<!-- Needs to be declared to disable default profile -->
+		<!-- Needs to be declared to disable profiles active by default during releases -->
+
 		<profile>
 			<id>sonatype</id>
 		</profile>
 
+		<profile>
+			<id>releaseTrain</id>
+		</profile>
+
 	</profiles>
 
 	<dependencies>

spring-modulith-events/spring-modulith-events-amqp/src/main/java/org/springframework/modulith/events/amqp/RabbitEventExternalizerConfiguration.java

@@ -68,6 +68,16 @@ class RabbitEventExternalizerConfiguration {
 	private static final Logger logger = LoggerFactory.getLogger(RabbitEventExternalizerConfiguration.class);
 	private static final String PUBLISHER_CONFIRM_TYPE = "spring.rabbitmq.publisher-confirm-type";
 
+	private final EvaluationContext evaluationContext;
+
+	RabbitEventExternalizerConfiguration(BeanFactory factory) {
+
+		var context = new StandardEvaluationContext();
+		context.setBeanResolver(new BeanFactoryResolver(factory));
+
+		this.evaluationContext = context;
+	}
+
 	@Bean
 	@ConditionalOnProperty(name = ExternalizationMode.PROPERTY, havingValue = "module-listener", matchIfMissing = true)
 	EventExternalizerModuleListener rabbitEventExternalizer(EventExternalizationConfiguration configuration,
@@ -76,22 +86,22 @@ EventExternalizerModuleListener rabbitEventExternalizer(EventExternalizationConf
 		logger.debug("Registering domain event externalization to RabbitMQ…");
 
 		return new EventExternalizerModuleListener(configuration,
-				createRabbitTransport(configuration, operations, factory));
+				createRabbitTransport(configuration, operations), factory);
 	}
 
 	@AutoConfiguration
 	@ConditionalOnProperty(name = ExternalizationMode.PROPERTY, havingValue = "outbox")
-	static class RabbitOutboxConfiguration {
+	class RabbitOutboxConfiguration {
 
 		private final OutboxEventExternalizer externalizer;
 
 		RabbitOutboxConfiguration(EventExternalizationConfiguration configuration, RabbitMessageOperations operations,
-				BeanFactory beanFactory, OutboxEventExternalizerFactory factory, Environment environment) {
+				OutboxEventExternalizerFactory factory, Environment environment) {
 
 			Assert.state("correlated".equalsIgnoreCase(environment.getProperty(PUBLISHER_CONFIRM_TYPE)),
 					() -> "RabbitMQ outbox event externalization requires " + PUBLISHER_CONFIRM_TYPE + "=correlated!");
 
-			this.externalizer = factory.forTransport(createConfirmingRabbitTransport(configuration, operations, beanFactory));
+			this.externalizer = factory.forTransport(createConfirmingRabbitTransport(configuration, operations));
 		}
 
 		@AutoConfiguration
@@ -121,28 +131,26 @@ JobRunrExternalizationTransport jobRunrRabbitOutboxExternalizer() {
 		}
 	}
 
-	private static EventExternalizationTransport createRabbitTransport(
-			EventExternalizationConfiguration configuration, RabbitMessageOperations operations,
-			BeanFactory factory) {
+	private EventExternalizationTransport createRabbitTransport(
+			EventExternalizationConfiguration configuration, RabbitMessageOperations operations) {
 
 		return (payload, target) -> {
 
-			send(payload, target, configuration, Collections.emptyMap(), operations, factory);
+			send(payload, target, configuration, Collections.emptyMap(), operations);
 
 			return CompletableFuture.completedFuture(null);
 		};
 	}
 
-	private static EventExternalizationTransport createConfirmingRabbitTransport(
-			EventExternalizationConfiguration configuration, RabbitMessageOperations operations,
-			BeanFactory factory) {
+	private EventExternalizationTransport createConfirmingRabbitTransport(EventExternalizationConfiguration configuration,
+			RabbitMessageOperations operations) {
 
 		return (payload, target) -> {
 
 			var correlation = new CorrelationData();
 			var headers = Map.of(AmqpHeaders.PUBLISH_CONFIRM_CORRELATION, (Object) correlation);
 
-			send(payload, target, configuration, headers, operations, factory);
+			send(payload, target, configuration, headers, operations);
 
 			return correlation.getFuture().thenAccept(confirm -> {
 
@@ -154,22 +162,13 @@ private static EventExternalizationTransport createConfirmingRabbitTransport(
 		};
 	}
 
-	private static void send(Object payload, RoutingTarget target, EventExternalizationConfiguration configuration,
-			Map<String, Object> additionalHeaders, RabbitMessageOperations operations, BeanFactory factory) {
-
-		var routing = BrokerRouting.of(target, createContext(factory));
+	private void send(Object payload, RoutingTarget target, EventExternalizationConfiguration configuration,
+			Map<String, Object> additionalHeaders, RabbitMessageOperations operations) {
 
+		var routing = BrokerRouting.of(target, evaluationContext);
 		var headers = new HashMap<>(configuration.getHeadersFor(payload));
 		headers.putAll(additionalHeaders);
 
 		operations.convertAndSend(routing.getTarget(payload), routing.getKey(payload), payload, additionalHeaders);
 	}
-
-	private static EvaluationContext createContext(BeanFactory factory) {
-
-		var context = new StandardEvaluationContext();
-		context.setBeanResolver(new BeanFactoryResolver(factory));
-
-		return context;
-	}
 }

spring-modulith-events/spring-modulith-events-core/src/main/java/org/springframework/modulith/events/config/EventExternalizationAutoConfiguration.java

@@ -26,7 +26,7 @@
 import org.springframework.boot.autoconfigure.AutoConfigureAfter;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
-import org.springframework.context.ApplicationEventPublisher;
+import org.springframework.context.ApplicationContext;
 import org.springframework.context.ApplicationListener;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Role;
@@ -89,8 +89,8 @@ static EventExternalizationConfiguration eventExternalizationConfiguration(BeanF
 	@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
 	@ConditionalOnProperty(name = ExternalizationMode.PROPERTY, havingValue = "outbox")
 	static OutboxEventExternalizerFactory outboxEventExternalizerFactory(EventExternalizationConfiguration configuration,
-			ApplicationEventPublisher publisher) {
-		return new OutboxEventExternalizerFactory(configuration, publisher);
+			ApplicationContext context) {
+		return new OutboxEventExternalizerFactory(configuration, context);
 	}
 
 	/**

spring-modulith-events/spring-modulith-events-core/src/main/java/org/springframework/modulith/events/config/EventPublicationAutoConfiguration.java

@@ -113,8 +113,9 @@ static DefaultFailedEventPublications failedEventPublications(
 	@Bean
 	@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
 	@ConditionalOnBean(EventPublicationRegistry.class)
-	static CompletionRegisteringAdvisor completionRegisteringAdvisor(ObjectFactory<EventPublicationRegistry> registry) {
-		return EventPublicationConfiguration.completionRegisteringAdvisor(registry);
+	static CompletionRegisteringAdvisor completionRegisteringAdvisor(ObjectFactory<EventPublicationRegistry> registry,
+			ObjectFactory<Environment> environment) {
+		return EventPublicationConfiguration.completionRegisteringAdvisor(registry, environment);
 	}
 
 	@Bean

spring-modulith-events/spring-modulith-events-core/src/main/java/org/springframework/modulith/events/config/EventPublicationConfiguration.java

@@ -28,6 +28,7 @@
 import org.springframework.modulith.events.core.DefaultAbandonedEventPublications;
 import org.springframework.modulith.events.core.DefaultEventPublicationRegistry;
 import org.springframework.modulith.events.core.DefaultFailedEventPublications;
+import org.springframework.modulith.events.core.EventListenerMethodMetadata;
 import org.springframework.modulith.events.core.EventPublicationRegistry;
 import org.springframework.modulith.events.core.EventPublicationRepository;
 import org.springframework.modulith.events.support.CompletionRegisteringAdvisor;
@@ -81,7 +82,9 @@ static DefaultFailedEventPublications failedEventPublications(
 
 	@Bean
 	@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
-	static CompletionRegisteringAdvisor completionRegisteringAdvisor(ObjectFactory<EventPublicationRegistry> registry) {
-		return new CompletionRegisteringAdvisor(registry::getObject);
+	static CompletionRegisteringAdvisor completionRegisteringAdvisor(ObjectFactory<EventPublicationRegistry> registry,
+			ObjectFactory<Environment> environment) {
+		return new CompletionRegisteringAdvisor(registry::getObject,
+				EventListenerMethodMetadata.of(environment::getObject));
 	}
 }

spring-modulith-events/spring-modulith-events-core/src/main/java/org/springframework/modulith/events/config/StalenessProperties.java

@@ -65,17 +65,18 @@ public class StalenessProperties implements Staleness {
 			@Nullable Duration resubmitted,
 			@Nullable Duration checkInterval) {
 
-		this.published = published == null ? Duration.ZERO : published;
-		this.processing = processing == null ? Duration.ZERO : processing;
-		this.resubmitted = resubmitted == null ? Duration.ZERO : resubmitted;
-		this.checkInterval = checkInterval == null ? Duration.ofMinutes(1) : checkInterval;
+		this.published = published == null ? UNCONFIGURED_DURATION : requirePositive(published, "published");
+		this.processing = processing == null ? UNCONFIGURED_DURATION : requirePositive(processing, "processing");
+		this.resubmitted = resubmitted == null ? UNCONFIGURED_DURATION : requirePositive(resubmitted, "resubmitted");
+		this.checkInterval = checkInterval == null ? Duration.ofMinutes(1)
+				: requirePositive(checkInterval, "checkInterval");
 	}
 
 	boolean monitorStaleness() {
 
-		return !published.equals(Duration.ZERO)
-				|| !processing.equals(Duration.ZERO)
-				|| !resubmitted.equals(Duration.ZERO);
+		return !published.equals(UNCONFIGURED_DURATION)
+				|| !processing.equals(UNCONFIGURED_DURATION)
+				|| !resubmitted.equals(UNCONFIGURED_DURATION);
 	}
 
 	Duration getCheckInterval() {
@@ -95,7 +96,15 @@ public Duration getStaleness(Status status) {
 			case PUBLISHED -> published;
 			case PROCESSING -> processing;
 			case RESUBMITTED -> resubmitted;
-			default -> Duration.ZERO;
+			default -> throw new IllegalArgumentException("Unsupported status: " + status);
 		};
 	}
+
+	private static Duration requirePositive(Duration duration, String name) {
+
+		Assert.isTrue(!duration.isZero() && !duration.isNegative(),
+				() -> "Staleness property '%s' must be greater than zero but was %s!".formatted(name, duration));
+
+		return duration;
+	}
 }

spring-modulith-events/spring-modulith-events-core/src/main/java/org/springframework/modulith/events/core/DefaultEventPublicationRegistry.java

@@ -409,6 +409,10 @@ private void propagateStateTransition(Object event, PublicationTargetIdentifier
 
 	private void markFailed(Status status, Staleness staleness) {
 
+		if (!staleness.isMonitored(status)) {
+			return;
+		}
+
 		var duration = staleness.getStaleness(status);
 		var reference = clock.instant().minus(duration);
 		var result = events.findByStatus(status).stream()