Move some of the codes needed by ProjectSourcesHelper in an utility class that we can reuse in other packages.

desruisseaux · desruisseaux · commit ee261f79306d · 2026-02-21T14:56:20.000+01:00
diff --git a/impl/maven-core/src/main/java/org/apache/maven/project/DefaultProjectBuilder.java b/impl/maven-core/src/main/java/org/apache/maven/project/DefaultProjectBuilder.java
@@ -655,7 +655,6 @@ private void initProject(MavenProject project, ModelBuilderResult result) {
             // only set those on 2nd phase, ignore on 1st pass
             if (project.getFile() != null) {
                 Build build = project.getBuild().getDelegate();
-                List<org.apache.maven.api.model.Source> sources = build.getSources();
                 Path baseDir = project.getBaseDirectory();
                 Function<ProjectScope, String> outputDirectory = (scope) -> {
                     if (scope == ProjectScope.MAIN) {
@@ -666,23 +665,11 @@ private void initProject(MavenProject project, ModelBuilderResult result) {
                         return build.getDirectory();
                     }
                 };
-                // Extract modules from sources to detect modular projects
-                Set<String> modules = extractModules(sources);
-                boolean isModularProject = !modules.isEmpty();
-
-                logger.trace(
-                        "Module detection for project {}: found {} module(s) {} - modular project: {}.",
-                        project.getId(),
-                        modules.size(),
-                        modules,
-                        isModularProject);
-
                 // Create source handling context for unified tracking of all lang/scope combinations
-                SourceHandlingContext sourceContext =
-                        new SourceHandlingContext(project, baseDir, modules, isModularProject, result);
+                final SourceHandlingContext sourceContext = new SourceHandlingContext(project, result);
 
                 // Process all sources, tracking enabled ones and detecting duplicates
-                for (var source : sources) {
+                for (org.apache.maven.api.model.Source source : sourceContext.sources) {
                     var sourceRoot = DefaultSourceRoot.fromModel(session, baseDir, outputDirectory, source);
                     // Track enabled sources for duplicate detection and hasSources() queries
                     // Only add source if it's not a duplicate enabled source (first enabled wins)
@@ -711,7 +698,7 @@ private void initProject(MavenProject project, ModelBuilderResult result) {
                        implicit fallback (only if they match the default, e.g., inherited)
                      - This allows incremental adoption (e.g., custom resources + default Java)
                 */
-                if (sources.isEmpty()) {
+                if (sourceContext.sources.isEmpty()) {
                     // Classic fallback: no <sources> configured, use legacy directories
                     project.addScriptSourceRoot(build.getScriptSourceDirectory());
                     project.addCompileSourceRoot(build.getSourceDirectory());
@@ -724,8 +711,7 @@ implicit fallback (only if they match the default, e.g., inherited)
                     if (!sourceContext.hasSources(Language.SCRIPT, ProjectScope.MAIN)) {
                         project.addScriptSourceRoot(build.getScriptSourceDirectory());
                     }
-
-                    if (isModularProject) {
+                    if (sourceContext.usesModuleSourceHierarchy()) {
                         // Modular: reject ALL legacy directory configurations
                         failIfLegacyDirectoryPresent(
                                 build.getSourceDirectory(),
@@ -1243,22 +1229,6 @@ public Set<Entry<K, V>> entrySet() {
         }
     }
 
-    /**
-     * 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());
-    }
-
     private Model injectLifecycleBindings(
             Model model,
             ModelBuilderRequest request,
diff --git a/impl/maven-core/src/main/java/org/apache/maven/project/SourceHandlingContext.java b/impl/maven-core/src/main/java/org/apache/maven/project/SourceHandlingContext.java
@@ -27,6 +27,7 @@
 import org.apache.maven.api.ProjectScope;
 import org.apache.maven.api.SourceRoot;
 import org.apache.maven.api.model.Resource;
+import org.apache.maven.api.model.Source;
 import org.apache.maven.api.services.BuilderProblem.Severity;
 import org.apache.maven.api.services.ModelBuilderResult;
 import org.apache.maven.api.services.ModelProblem.Version;
@@ -37,9 +38,7 @@
 
 /**
  * Handles source configuration for Maven projects with unified tracking for all language/scope combinations.
- * <p>
- * This class replaces the previous approach of hardcoded boolean flags (hasMain, hasTest, etc.)
- * with a flexible set-based tracking mechanism that works for any language and scope combination.
+ * This class uses a flexible set-based tracking mechanism that works for any language and scope combination.
  * <p>
  * Key features:
  * <ul>
@@ -51,7 +50,7 @@
  *
  * @since 4.0.0
  */
-class SourceHandlingContext {
+final class SourceHandlingContext {
 
     private static final Logger LOGGER = LoggerFactory.getLogger(SourceHandlingContext.class);
 
@@ -60,26 +59,38 @@ class SourceHandlingContext {
      */
     record SourceKey(Language language, ProjectScope scope, String module, Path directory) {}
 
+    /**
+     * The {@code <source>} elements declared in the {@code <build>} elements.
+     */
+    final List<Source> sources;
+
     private final MavenProject project;
-    private final Path baseDir;
     private final Set<String> modules;
-    private final boolean modularProject;
     private final ModelBuilderResult result;
     private final Set<SourceKey> declaredSources;
 
-    SourceHandlingContext(
-            MavenProject project,
-            Path baseDir,
-            Set<String> modules,
-            boolean modularProject,
-            ModelBuilderResult result) {
+    SourceHandlingContext(MavenProject project, ModelBuilderResult result) {
         this.project = project;
-        this.baseDir = baseDir;
-        this.modules = modules;
-        this.modularProject = modularProject;
+        this.sources = project.getBuild().getDelegate().getSources();
+        this.modules = SourceQueries.getModuleNames(sources);
         this.result = result;
         // Each module typically has main, test, main resources, test resources = 4 sources
         this.declaredSources = new HashSet<>(4 * modules.size());
+        if (usesModuleSourceHierarchy()) {
+            LOGGER.trace("Found {} module(s) in the \"{}\" project: {}.", project.getId(), modules.size(), modules);
+        } else {
+            LOGGER.trace("Project \"{}\" is non-modular.", project.getId());
+        }
+    }
+
+    /**
+     * Whether the project uses module source hierarchy.
+     * Note that this is not synonymous of whether the project is modular,
+     * because it is possible to create a single Java module in a classic Maven project
+     * (i.e., using package hierarchy).
+     */
+    boolean usesModuleSourceHierarchy() {
+        return !modules.isEmpty();
     }
 
     /**
@@ -112,7 +123,7 @@ boolean shouldAddSource(SourceRoot sourceRoot) {
         SourceKey key = new SourceKey(
                 sourceRoot.language(), sourceRoot.scope(), sourceRoot.module().orElse(null), normalizedDir);
 
-        if (declaredSources.contains(key)) {
+        if (!declaredSources.add(key)) {
             String message = String.format(
                     "Duplicate enabled source detected: lang=%s, scope=%s, module=%s, directory=%s. "
                             + "First enabled source wins, this duplicate is ignored.",
@@ -130,7 +141,6 @@ boolean shouldAddSource(SourceRoot sourceRoot) {
             return false; // Don't add duplicate enabled source
         }
 
-        declaredSources.add(key);
         LOGGER.debug(
                 "Adding and tracking enabled source: lang={}, scope={}, module={}, dir={}",
                 key.language(),
@@ -151,6 +161,13 @@ boolean hasSources(Language language, ProjectScope scope) {
         return declaredSources.stream().anyMatch(key -> language.equals(key.language()) && scope.equals(key.scope()));
     }
 
+    /**
+     * {@return the source directory as defined by Maven conventions}
+     */
+    private Path getStandardSourceDirectory() {
+        return project.getBaseDirectory().resolve("src");
+    }
+
     /**
      * Fails the build if modular and classic (non-modular) sources are mixed within {@code <sources>}.
      * <p>
@@ -164,30 +181,32 @@ boolean hasSources(Language language, ProjectScope scope) {
     void failIfMixedModularAndClassicSources() {
         for (ProjectScope scope : List.of(ProjectScope.MAIN, ProjectScope.TEST)) {
             for (Language language : List.of(Language.JAVA_FAMILY, Language.RESOURCES)) {
-                boolean hasModular = declaredSources.stream()
-                        .anyMatch(key ->
-                                language.equals(key.language()) && scope.equals(key.scope()) && key.module() != null);
-                boolean hasClassic = declaredSources.stream()
-                        .anyMatch(key ->
-                                language.equals(key.language()) && scope.equals(key.scope()) && key.module() == null);
-
-                if (hasModular && hasClassic) {
-                    String message = String.format(
-                            "Mixed modular and classic sources detected for lang=%s, scope=%s. "
-                                    + "A project must be either fully modular (all sources have a module) "
-                                    + "or fully classic (no sources have a module). "
-                                    + "The compiler plugin cannot handle mixed configurations.",
-                            language.id(), scope.id());
-                    LOGGER.error(message);
-                    result.getProblemCollector()
-                            .reportProblem(new DefaultModelProblem(
-                                    message,
-                                    Severity.ERROR,
-                                    Version.V41,
-                                    project.getModel().getDelegate(),
-                                    -1,
-                                    -1,
-                                    null));
+                boolean hasModular = false;
+                boolean hasClassic = false;
+                for (SourceKey key : declaredSources) {
+                    if (language.equals(key.language()) && scope.equals(key.scope())) {
+                        String module = key.module();
+                        hasModular |= (module != null);
+                        hasClassic |= (module == null);
+                        if (hasModular && hasClassic) {
+                            String message = String.format(
+                                    "Mixed modular and classic sources detected for lang=%s, scope=%s. "
+                                            + "A project must be either fully modular (all sources have a module) "
+                                            + "or fully classic (no sources have a module).",
+                                    language.id(), scope.id());
+                            LOGGER.error(message);
+                            result.getProblemCollector()
+                                    .reportProblem(new DefaultModelProblem(
+                                            message,
+                                            Severity.ERROR,
+                                            Version.V41,
+                                            project.getModel().getDelegate(),
+                                            -1,
+                                            -1,
+                                            null));
+                            break;
+                        }
+                    }
                 }
             }
         }
@@ -219,7 +238,7 @@ void handleResourceConfiguration(ProjectScope scope) {
                 ? "<source><lang>resources</lang></source>"
                 : "<source><lang>resources</lang><scope>test</scope></source>";
 
-        if (modularProject) {
+        if (usesModuleSourceHierarchy()) {
             if (hasResourcesInSources) {
                 // Modular project with resources configured via <sources> - already added above
                 if (hasExplicitLegacyResources(resources, scopeId)) {
@@ -298,6 +317,7 @@ void handleResourceConfiguration(ProjectScope scope) {
                 // Use legacy resources element
                 LOGGER.debug(
                         "Using explicit or default {} resources ({} resources configured).", scopeId, resources.size());
+                Path baseDir = project.getBaseDirectory();
                 for (Resource resource : resources) {
                     project.addSourceRoot(new DefaultSourceRoot(baseDir, scope, resource));
                 }
@@ -315,7 +335,7 @@ void handleResourceConfiguration(ProjectScope scope) {
      */
     private DefaultSourceRoot createModularResourceRoot(String module, ProjectScope scope) {
         Path resourceDir =
-                baseDir.resolve("src").resolve(module).resolve(scope.id()).resolve("resources");
+                getStandardSourceDirectory().resolve(module).resolve(scope.id()).resolve("resources");
 
         return new DefaultSourceRoot(
                 scope,
@@ -345,12 +365,10 @@ private boolean hasExplicitLegacyResources(List<Resource> resources, String scop
         }
 
         // Super POM default paths
-        String defaultPath =
-                baseDir.resolve("src").resolve(scope).resolve("resources").toString();
-        String defaultFilteredPath = baseDir.resolve("src")
-                .resolve(scope)
-                .resolve("resources-filtered")
-                .toString();
+        Path srcDir = getStandardSourceDirectory();
+        String defaultPath = srcDir.resolve(scope).resolve("resources").toString();
+        String defaultFilteredPath =
+                srcDir.resolve(scope).resolve("resources-filtered").toString();
 
         // Check if any resource differs from Super POM defaults
         for (Resource resource : resources) {
diff --git a/impl/maven-core/src/main/java/org/apache/maven/project/SourceQueries.java b/impl/maven-core/src/main/java/org/apache/maven/project/SourceQueries.java
@@ -0,0 +1,84 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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
+ *
+ *   http://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.apache.maven.project;
+
+import java.util.Collection;
+import java.util.LinkedHashSet;
+import java.util.Objects;
+import java.util.Set;
+
+import org.apache.maven.api.model.Source;
+
+/**
+ * Static utility methods for analyzing {@code <source>} elements of a project.
+ * <p>
+ * <strong>Warning:</strong> This is an internal utility class, not part of the public API.
+ * It can be changed or removed without prior notice.
+ *
+ * @since 4.0.0
+ */
+public final class SourceQueries {
+    private SourceQueries() {}
+
+    /**
+     * Returns whether at least one source in the collection has a non-blank module name,
+     * indicating a modular source hierarchy.
+     *
+     * @param sources the source elements to check
+     * @return {@code true} if at least one source declares a module
+     */
+    public static boolean usesModuleSourceHierarchy(Collection<Source> sources) {
+        return sources.stream().map(Source::getModule).filter(Objects::nonNull).anyMatch(s -> !s.isBlank());
+    }
+
+    /**
+     * Returns whether at least one source in the collection is enabled.
+     *
+     * @param sources the source elements to check
+     * @return {@code true} if at least one source is enabled
+     */
+    public static boolean hasEnabledSources(Collection<Source> sources) {
+        for (Source source : sources) {
+            if (source.isEnabled()) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Extracts unique, non-blank module names from the source elements, preserving declaration order.
+     * The following relationship should always be true:
+     *
+     * <pre>getModuleNames(sources).isEmpty() == !usesModuleSourceHierarchy(sources)</pre>
+     *
+     * @param sources the source elements to extract module names from
+     * @return set of non-blank module names in declaration order
+     */
+    public static Set<String> getModuleNames(Collection<Source> sources) {
+        var modules = new LinkedHashSet<String>();
+        sources.stream()
+                .map(Source::getModule)
+                .filter(Objects::nonNull)
+                .map(String::strip)
+                .filter(s -> !s.isEmpty())
+                .forEach(modules::add);
+        return modules;
+    }
+}
