Fix resource targetPath handling according to PR feedback

Based on PR comments, the solution has been updated:

1. SourceRoot.targetPath() returns a Path relative to the project's basedir
   (e.g., 'target/classes/custom-output')
   - Reverted DefaultSourceRoot to resolve targetPath against baseDir

2. ConnectedResource.getTargetPath() (Maven 3 API) returns a path relative to
   the output directory (e.g., 'custom-output')
   - Added computeRelativeTargetPath() method to make the path relative to
     the output directory when converting from SourceRoot to Resource

This maintains backward compatibility with Maven 3 API while using the new
Maven 4 API internally.

Changes:
- DefaultSourceRoot: Reverted to resolve targetPath against baseDir
- ConnectedResource: Added computeRelativeTargetPath() to convert from
  basedir-relative to outputdir-relative paths
- DefaultSourceRootTest: Updated tests to expect basedir-relative paths
- ResourceIncludeTest: Tests still pass with the new conversion logic

Author: gnodet

impl/maven-core/src/main/java/org/apache/maven/project/ConnectedResource.java

@@ -42,13 +42,53 @@ class ConnectedResource extends Resource {
                 .includes(sourceRoot.includes())
                 .excludes(sourceRoot.excludes())
                 .filtering(Boolean.toString(sourceRoot.stringFiltering()))
-                .targetPath(sourceRoot.targetPath().map(Path::toString).orElse(null))
+                .targetPath(computeRelativeTargetPath(sourceRoot, scope, project))
                 .build());
         this.originalSourceRoot = sourceRoot;
         this.scope = scope;
         this.project = project;
     }
 
+    /**
+     * Computes the targetPath relative to the output directory.
+     * In Maven 3 API, Resource.getTargetPath() is expected to be relative to the output directory
+     * (e.g., "custom-output"), while SourceRoot.targetPath() is relative to the project basedir
+     * (e.g., "target/classes/custom-output").
+     */
+    private static String computeRelativeTargetPath(SourceRoot sourceRoot, ProjectScope scope, MavenProject project) {
+        return sourceRoot
+                .targetPath()
+                .map(targetPath -> {
+                    // Get the output directory for this scope
+                    String outputDir = scope == ProjectScope.MAIN
+                            ? project.getBuild().getOutputDirectory()
+                            : project.getBuild().getTestOutputDirectory();
+                    Path outputDirPath = Path.of(outputDir);
+
+                    // If targetPath is absolute, try to make it relative to the output directory
+                    if (targetPath.isAbsolute()) {
+                        if (targetPath.startsWith(outputDirPath)) {
+                            return outputDirPath.relativize(targetPath).toString();
+                        }
+                        return targetPath.toString();
+                    }
+
+                    // If targetPath is relative, check if it starts with the output directory
+                    // (e.g., "target/classes/custom-output" should become "custom-output")
+                    Path baseDir = project.getBaseDirectory();
+                    Path resolvedTargetPath = baseDir.resolve(targetPath);
+                    Path resolvedOutputDir = baseDir.resolve(outputDirPath);
+
+                    if (resolvedTargetPath.startsWith(resolvedOutputDir)) {
+                        return resolvedOutputDir.relativize(resolvedTargetPath).toString();
+                    }
+
+                    // Otherwise, return as-is
+                    return targetPath.toString();
+                })
+                .orElse(null);
+    }
+
     @Override
     public void addInclude(String include) {
         // Update the underlying Resource model

impl/maven-impl/src/main/java/org/apache/maven/impl/DefaultSourceRoot.java

@@ -169,7 +169,7 @@ public DefaultSourceRoot(final Path baseDir, ProjectScope scope, Resource resour
                 resource.getIncludes(),
                 resource.getExcludes(),
                 Boolean.parseBoolean(resource.getFiltering()),
-                nonBlank(resource.getTargetPath()).map(Path::of).orElse(null),
+                nonBlank(resource.getTargetPath()).map(baseDir::resolve).orElse(null),
                 true);
     }
 

impl/maven-impl/src/test/java/org/apache/maven/impl/DefaultSourceRootTest.java

@@ -197,7 +197,8 @@ void testExtractsTargetPathFromResource() {
 
         Optional<Path> targetPath = sourceRoot.targetPath();
         assertTrue(targetPath.isPresent(), "targetPath should be present");
-        assertEquals(Path.of("test-output"), targetPath.get(), "targetPath should be kept as relative path");
+        assertEquals(
+                Path.of("myproject/test-output"), targetPath.get(), "targetPath should be resolved against baseDir");
         assertEquals(Path.of("myproject", "src", "test", "resources"), sourceRoot.directory());
         assertEquals(ProjectScope.TEST, sourceRoot.scope());
         assertEquals(Language.RESOURCES, sourceRoot.language());
@@ -246,9 +247,9 @@ void testHandlesPropertyPlaceholderInTargetPath() {
         Optional<Path> targetPath = sourceRoot.targetPath();
         assertTrue(targetPath.isPresent(), "Property placeholder targetPath should be present");
         assertEquals(
-                Path.of("${project.build.directory}/custom"),
+                Path.of("myproject/${project.build.directory}/custom"),
                 targetPath.get(),
-                "Property placeholder should be preserved as relative path");
+                "Property placeholder should be resolved against baseDir");
     }
 
     /*GH-11381*/
@@ -280,9 +281,9 @@ void testResourceConstructorPreservesOtherProperties() {
 
         // Verify all properties are preserved
         assertEquals(
-                Path.of("test-classes"),
+                Path.of("myproject/test-classes"),
                 sourceRoot.targetPath().orElseThrow(),
-                "targetPath should be kept as relative path");
+                "targetPath should be resolved against baseDir");
         assertTrue(sourceRoot.stringFiltering(), "Filtering should be true");
         assertEquals(1, sourceRoot.includes().size());
         assertTrue(sourceRoot.includes().contains("*.properties"));