From e299ba188ef90097db490fdf1970a5ff2944606d Mon Sep 17 00:00:00 2001
From: Martin Desruisseaux <martin.desruisseaux@geomatys.com>
Date: Wed, 29 Jul 2026 18:56:45 +0200
Subject: [PATCH] Remove the optimization which was skipping the path
 normalization. That optimization can produce false positive if the pattern
 appears in the base directory. For example if the base directory is
 "something/target/test-classes" and if an include or exclude pattern is
 "**/test-classes" where "test-classes" is another directory as a child of the
 base directory, the optimization would always consider that there is a match.

---
 .../org/apache/maven/impl/PathSelector.java   | 43 ++-----------------
 1 file changed, 4 insertions(+), 39 deletions(-)

diff --git a/impl/maven-impl/src/main/java/org/apache/maven/impl/PathSelector.java b/impl/maven-impl/src/main/java/org/apache/maven/impl/PathSelector.java
index 0f3d1a3c1259..bc90337c64ec 100644
--- a/impl/maven-impl/src/main/java/org/apache/maven/impl/PathSelector.java
+++ b/impl/maven-impl/src/main/java/org/apache/maven/impl/PathSelector.java
@@ -213,13 +213,6 @@ final class PathSelector implements PathMatcher {
      */
     private final Path baseDirectory;
 
-    /**
-     * Whether paths must be relativized before being given to a matcher. If {@code true}, then every paths
-     * will be made relative to {@link #baseDirectory} for allowing patterns like {@code "foo/bar/*.java"}
-     * to work. As a slight optimization, we can skip this step if all patterns start with {@code "**"}.
-     */
-    private final boolean needRelativize;
-
     /**
      * Creates a new selector from the given includes and excludes.
      *
@@ -240,7 +233,6 @@ private PathSelector(
         FileSystem fileSystem = baseDirectory.getFileSystem();
         this.includes = matchers(fileSystem, includePatterns);
         this.excludes = matchers(fileSystem, excludePatterns);
-        needRelativize = needRelativize(includePatterns) || needRelativize(excludePatterns);
     }
 
     /**
@@ -472,21 +464,6 @@ private static String[] normalizePatterns(final Collection<String> patterns, fin
         return normalized.toArray(String[]::new);
     }
 
-    /**
-     * Returns {@code true} if at least one pattern requires path being relativized before to be matched.
-     *
-     * @param patterns include or exclude patterns
-     * @return whether at least one pattern require relativization
-     */
-    private static boolean needRelativize(String[] patterns) {
-        for (String pattern : patterns) {
-            if (!pattern.startsWith(DEFAULT_SYNTAX + WILDCARD_FOR_ANY_PREFIX)) {
-                return true;
-            }
-        }
-        return false;
-    }
-
     /**
      * Creates the path matchers for the given patterns.
      * The syntax (usually {@value #DEFAULT_SYNTAX}) must be specified for each pattern.
@@ -504,16 +481,8 @@ private static PathMatcher[] matchers(final FileSystem fs, final String[] patter
      */
     @SuppressWarnings("checkstyle:MissingSwitchDefault")
     private PathMatcher simplify() {
-        if (excludes.length == 0) {
-            switch (includes.length) {
-                case 0:
-                    return INCLUDES_ALL;
-                case 1:
-                    if (needRelativize) {
-                        break;
-                    }
-                    return includes[0];
-            }
+        if (excludes.length == 0 && includes.length == 0) {
+            return INCLUDES_ALL;
         }
         return this;
     }
@@ -527,9 +496,7 @@ private PathMatcher simplify() {
      */
     @Override
     public boolean matches(Path path) {
-        if (needRelativize) {
-            path = baseDirectory.relativize(path);
-        }
+        path = baseDirectory.relativize(path);
         return (includes.length == 0 || isMatched(path, includes))
                 && (excludes.length == 0 || !isMatched(path, excludes));
     }
@@ -648,9 +615,7 @@ public boolean matches(Path directory) {
             if (baseDirectory.equals(directory)) {
                 return true;
             }
-            if (needRelativize) {
-                directory = baseDirectory.relativize(directory);
-            }
+            directory = baseDirectory.relativize(directory);
             if (isMatched(directory, dirExcludes)) {
                 return false;
             }