fix(maven-plugin): a relative <sourceDir> resolved against the shell's working directory, not the module

AbstractMetaDataMojo.getSourceDir() did new File(<sourceDir>), which resolves
against the JVM's working directory. Maven keeps the reactor root as the working
directory for every module, so the documented
<sourceDir>src/main/metaobjects</sourceDir> failed "SourceDir [...] does not
exist" in any multi-module build run from the parent, and under
mvn -f <module>/pom.xml. A relative <sourceDir> now resolves against
${project.basedir}, as every relative path in a pom does; an absolute one is
unchanged. The resolved path is what reaches the loader, so <sources> entries
under it resolve correctly too.

The plugin's own test had recorded the old behavior in a comment ("paths here
are ABSOLUTE on purpose") instead of fixing it. New test pins the relative case
(red before, green after); maven-plugin suite 46/0. Found building an adopter
estate's Java port with mvn -f from its root; that build now passes.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: dmealing

CHANGELOG.md

@@ -292,6 +292,15 @@ edit (two registered `description` strings) and was ruled a hold, as 1.0.4's was
   reject both; the answers are truthful, and an adopter who wants the 400 owns that generator.
   **Adopters with committed generated code should run `mvn metaobjects:generate`.**
 
+- **Maven plugin: a relative `<sourceDir>` resolved against the shell's working directory,
+  not the module.** The documented `<sourceDir>src/main/metaobjects</sourceDir>` therefore
+  failed `SourceDir [src/main/metaobjects] does not exist` in any multi-module reactor build
+  run from the parent (Maven keeps the root as the working directory for every module) and
+  under `mvn -f <module>/pom.xml`. It now resolves against `${project.basedir}`, as every
+  relative path in a pom does; an absolute `<sourceDir>` is unchanged. The plugin's own test
+  had pinned the old behavior in a comment ("paths here are ABSOLUTE on purpose") instead of
+  fixing it. Nothing to do on upgrade.
+
 - **TypeScript: two `@metaobjectsdev/runtime-ts` writable mounts answered `PUT` with a 404.**
   The cross-port REST contract (FR-008) makes the update verb reachable via BOTH `PATCH`
   and `PUT`, routed to one handler, and every other port's controller maps both. The

server/java/maven-plugin/src/main/java/com/metaobjects/mojo/AbstractMetaDataMojo.java

@@ -278,7 +278,7 @@ protected MetaDataLoader createLoader(ClassLoader projectClassLoader) {
         String sourceDir = null;
         File srcDir = getSourceDir();
         if (srcDir != null) {
-            sourceDir = loaderConfig.getSourceDir();
+            sourceDir = srcDir.getPath(); // basedir-resolved, not the pom's raw string
         }
 
         // Precedence ladder (spec §5): when the pom names neither <sourceDir> nor
@@ -532,11 +532,21 @@ protected void addDirIfExists(List<String> classpathElements, String s) {
         if ( f.exists() ) classpathElements.add( f.getPath() );
     }
 
+    /**
+     * The pom's {@code <sourceDir>}, a relative one resolved against the module basedir the
+     * way every relative path in a pom is. {@code new File(relative)} alone resolves against
+     * the JVM's working directory, which in a reactor build is the PARENT for every module —
+     * so the documented {@code <sourceDir>src/main/metaobjects</sourceDir>} failed "does not
+     * exist" from the root, and under {@code mvn -f <module>/pom.xml}.
+     */
     protected File getSourceDir() {
         String srcDir = loaderConfig.getSourceDir();
         File sourceDir = null;
         if ( srcDir != null ) {
-            sourceDir = new File( loaderConfig.getSourceDir() );
+            sourceDir = new File( srcDir );
+            if ( !sourceDir.isAbsolute() && project != null && project.getBasedir() != null ) {
+                sourceDir = new File( project.getBasedir(), srcDir );
+            }
             if ( !sourceDir.exists() ) {
                 getLog().error( "SourceDir ["+srcDir+"] did not exist: "+sourceDir.getPath() );
                 throw new IllegalArgumentException( "SourceDir [" + srcDir + "] does not exist" );

server/java/maven-plugin/src/test/java/com/metaobjects/mojo/SourceDirWithoutSourcesTest.java

@@ -39,9 +39,11 @@
  * that does not exist (already loud, an {@code IllegalArgumentException} naming the
  * path), and one that exists but holds no metadata at all.
  *
- * <p>Paths here are ABSOLUTE on purpose — {@code <sourceDir>} resolves against the
- * process working directory, not the module basedir, so a relative path in a test
- * would be measuring the runner's cwd rather than the mojo.
+ * <p>A RELATIVE {@code <sourceDir>} resolves against the module basedir, as every
+ * relative path in a pom does. It used to resolve against the process working
+ * directory, so the documented {@code src/main/metaobjects} failed with "does not
+ * exist" in any reactor build run from the parent — {@code mvn} keeps the root as the
+ * working directory for every module — and under {@code mvn -f <module>/pom.xml}.
  */
 public class SourceDirWithoutSourcesTest {
 
@@ -93,6 +95,25 @@ public void sourceDirAloneLoadsThatDirectorysMetadata() throws IOException {
         }
     }
 
+    @Test
+    public void aRelativeSourceDirResolvesAgainstTheModuleBasedirNotTheWorkingDirectory() throws IOException {
+        Path root = Files.createTempDirectory("mo-mojo-srcdir-relative-").toAbsolutePath().normalize();
+        try {
+            Path metaDir = root.resolve("src/main/metaobjects");
+            Files.createDirectories(metaDir);
+            Files.write(metaDir.resolve("meta.widget.json"), WIDGET_JSON.getBytes(StandardCharsets.UTF_8));
+
+            // The test JVM's working directory is this plugin module, never `root`.
+            MetaDataGeneratorMojo mojo = mojoWithSourceDirOnly(root, "src/main/metaobjects");
+            MetaDataLoader loaded = mojo.createLoader(mojo.createProjectClassLoader());
+
+            assertEquals(1, loaded.getMetaObjects().size());
+            assertEquals("Widget", loaded.getMetaObjects().get(0).getShortName());
+        } finally {
+            deleteRecursive(root);
+        }
+    }
+
     @Test
     public void aSourceDirThatDoesNotExistFailsRatherThanLoadingNothing() throws IOException {
         Path root = Files.createTempDirectory("mo-mojo-srcdir-missing-").toAbsolutePath().normalize();