desruisseaux commented on code in PR #11505:
URL: https://github.com/apache/maven/pull/11505#discussion_r2616327039
##########
impl/maven-core/src/main/java/org/apache/maven/project/DefaultProjectBuilder.java:
##########
@@ -1099,6 +1123,190 @@ public Set<Entry<K, V>> entrySet() {
}
}
+ /**
+ * Context object for resource handling configuration.
+ * Groups parameters shared between main and test resource handling to
reduce method parameter count.
+ */
+ private record ResourceHandlingContext(
+ MavenProject project,
+ Path baseDir,
+ Set<String> modules,
+ boolean modularProject,
+ ModelBuilderResult result) {}
+
+ /**
+ * Handles resource configuration for a given scope (main or test).
+ * This method applies the resource priority rules:
+ * <ol>
+ * <li>Modular project: use resources from <sources> if present,
otherwise inject defaults</li>
+ * <li>Classic project: use resources from <sources> if present,
otherwise use legacy resources</li>
+ * </ol>
+ *
+ * @param ctx the resource handling context containing project info
+ * @param resources the legacy resource list (from <resources> or
<testResources>)
+ * @param hasResourcesInSources whether resources are configured via
<sources>
+ * @param scope the project scope (MAIN or TEST)
+ */
+ private void handleResourceConfiguration(
+ ResourceHandlingContext ctx, List<Resource> resources, boolean
hasResourcesInSources, ProjectScope scope) {
+
+ String scopeId = scope.id();
+ String scopeName = scope == ProjectScope.MAIN ? "Main" : "Test";
+ String legacyElement = scope == ProjectScope.MAIN ? "<resources>" :
"<testResources>";
+ String sourcesConfig = scope == ProjectScope.MAIN
+ ? "<source><lang>resources</lang></source>"
+ : "<source><lang>resources</lang><scope>test</scope></source>";
+
+ if (ctx.modularProject()) {
+ if (hasResourcesInSources) {
+ // Modular project with resources configured via <sources> -
already added above
+ if (hasExplicitLegacyResources(resources, ctx.baseDir(),
scopeId)) {
+ logger.warn(
+ "Legacy {} element is ignored because {} resources
are configured via {} in <sources>",
+ legacyElement,
+ scopeId,
+ sourcesConfig);
+ }
+ logger.debug(
+ "{} resources configured via <sources> element,
ignoring legacy {} element",
+ scopeName,
+ legacyElement);
+ } else {
+ // Modular project without resources in <sources> - inject
module-aware defaults
+ if (hasExplicitLegacyResources(resources, ctx.baseDir(),
scopeId)) {
+ String message = "Legacy " + legacyElement
+ + " element is ignored because modular sources are
configured. "
+ + "Use " + sourcesConfig + " in <sources> for
custom resource paths.";
+ logger.warn(message);
+ ctx.result()
+ .getProblemCollector()
+ .reportProblem(new
org.apache.maven.impl.model.DefaultModelProblem(
+ message,
+ Severity.WARNING,
+ Version.V41,
+ ctx.project().getModel().getDelegate(),
+ -1,
+ -1,
+ null));
+ }
+ logger.debug(
+ "Injecting module-aware {} resource roots for {}
modules",
+ scopeId,
+ ctx.modules().size());
+ for (String module : ctx.modules()) {
+ Path resourcePath = ctx.baseDir()
+ .resolve("src")
+ .resolve(module)
+ .resolve(scopeId)
+ .resolve("resources");
+ logger.debug(" - Adding {} resource root: {} (module:
{})", scopeId, resourcePath, module);
+
ctx.project().addSourceRoot(createModularResourceRoot(ctx.baseDir(), module,
scope));
+ }
+ }
+ } else {
+ // Classic (non-modular) project
+ if (hasResourcesInSources) {
+ // Resources configured via <sources> - already added above
+ if (hasExplicitLegacyResources(resources, ctx.baseDir(),
scopeId)) {
+ logger.warn(
+ "Legacy {} element is ignored because {} resources
are configured via {} in <sources>",
+ legacyElement,
+ scopeId,
+ sourcesConfig);
+ }
+ logger.debug(
+ "{} resources configured via <sources> element,
ignoring legacy {} element",
+ scopeName,
+ legacyElement);
+ } else {
+ // Use legacy resources element
+ logger.debug(
+ "Using explicit or default {} resources ({} resources
configured)", scopeId, resources.size());
+ for (Resource resource : resources) {
+ ctx.project().addSourceRoot(new
DefaultSourceRoot(ctx.baseDir(), scope, resource));
+ }
+ }
+ }
+ }
+
+ /**
+ * Extracts unique module names from the given list of source elements.
+ * A project is considered modular if it has at least one module name.
+ *
+ * @param sources list of source elements from the build
+ * @return set of non-blank module names
+ */
+ private static Set<String>
extractModules(List<org.apache.maven.api.model.Source> sources) {
+ return sources.stream()
+ .map(org.apache.maven.api.model.Source::getModule)
+ .filter(Objects::nonNull)
+ .map(String::trim)
+ .filter(s -> !s.isBlank())
+ .collect(Collectors.toSet());
+ }
+
+ /**
+ * Creates a DefaultSourceRoot for module-aware resource directories.
+ * Generates paths following the pattern:
src/<module>/<scope>/resources
Review Comment:
Same as previous, I rather suggest to use `{@code
src/<module>/<scope>/resources}`.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: [email protected]
For queries about this service, please contact Infrastructure at:
[email protected]
