Add smelt support for multi-module projects

Specifically, detect when a particular component does not reside in the
base directory of the repository, but rather a subdirectory thereof,
and act accordingly to build it from there when smelting.

Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>

Author: ctrueden

src/pombast/core/_pipeline.py

@@ -25,6 +25,7 @@
     write_dependency_tree_log,
 )
 from pombast.maven._pom_rewriter import patch_pom_urls, rewrite_pom_versions
+from pombast.maven._reactor import locate_module_dir
 from pombast.maven._scm import _guess_tag, resolve_scm
 from pombast.util._git import shallow_clone
 
@@ -245,6 +246,7 @@ def run(self) -> ValidationReport:
             # which would otherwise cause pombast to reuse an old clone even after a
             # version bump in the BOM.
             sentinel = f"{component.version}:{tag}"
+            fresh_clone = False
             if tag_file.exists() and tag_file.read_text().strip() == sentinel:
                 _log.info("%s: reusing existing clone at %s", component.coordinate, tag)
             else:
@@ -277,20 +279,52 @@ def run(self) -> ValidationReport:
                         )
                     )
                     continue
+                fresh_clone = True
+
+            # Locate the module subdirectory that builds this component. For a
+            # multi-module project (e.g. BoneJ2, scijava/scijava) the BOM manages
+            # each reactor module as its own component; pombast builds in the
+            # matching subdirectory and lets sibling modules resolve from the
+            # repository as ordinary released dependencies. For a single-module
+            # project this is the clone root itself.
+            build_dir = locate_module_dir(source_dir, component)
+            if build_dir is None:
+                _log.warning(
+                    "%s: no module POM matched in checkout — using clone root",
+                    component.coordinate,
+                )
+                build_dir = source_dir
+            elif build_dir != source_dir:
+                _log.info(
+                    "%s: building module subdir %s",
+                    component.coordinate,
+                    build_dir.relative_to(source_dir),
+                )
 
-                # Patch and rewrite POM only for a fresh clone; re-applying to an
-                # already-patched POM would corrupt the pinned versions.
-                pom_file = source_dir / "pom.xml"
-                if pom_file.exists():
-                    patch_pom_urls(pom_file)
-                    rewrite_pom_versions(pom_file, dep_mgmt)
+            if fresh_clone:
+                # Patch and rewrite POMs only for a fresh clone; re-applying to an
+                # already-patched POM would corrupt the pinned versions. Upgrade
+                # http→https across every POM in the checkout so inherited
+                # repository URLs in parent/aggregator POMs don't break the build,
+                # but pin versions only in this module's own POM — its own
+                # dependencyManagement takes precedence over anything inherited,
+                # so that is sufficient even when the module's parent lies outside
+                # the reactor (as with scijava/scijava's pom-scijava-parented
+                # modules).
+                for pom in source_dir.rglob("pom.xml"):
+                    if "target" in pom.relative_to(source_dir).parts:
+                        continue
+                    patch_pom_urls(pom)
+                module_pom = build_dir / "pom.xml"
+                if module_pom.exists():
+                    rewrite_pom_versions(module_pom, dep_mgmt)
 
                 tag_file.write_text(sentinel + "\n")
 
             # Determine the build JDK from the rewritten (BOM-pinned) POM, so jgo
             # resolves exactly the dependency set Maven will build. A per-component
             # override wins; otherwise use the detected version, then the default.
-            analysis = analyze_build_java(component, ctx, source_dir / "pom.xml")
+            analysis = analyze_build_java(component, ctx, build_dir / "pom.xml")
             comp_override = self.config.config.component_overrides.get(component.ga)
             if comp_override and "java-version" in comp_override:
                 java_ver = comp_override["java-version"]
@@ -316,12 +350,14 @@ def run(self) -> ValidationReport:
             # Record the resolved dependency tree (with Java-version rationale) next
             # to the build logs, mirroring mega-melt's dependency-tree.log.
             write_dependency_tree_log(
-                analysis, component, source_dir / "dependency-tree.log"
+                analysis, component, build_dir / "dependency-tree.log"
             )
 
             # Build and test. The resolved closure from Java-version analysis
             # doubles as the success-cache key, so no second resolution is needed.
-            source = ComponentSource(component=component, source_dir=source_dir)
+            source = ComponentSource(
+                component=component, source_dir=source_dir, build_dir=build_dir
+            )
             result = builder.build_and_test(
                 source, closure=analysis.closure, extra_properties=comp_properties
             )

src/pombast/maven/_builder.py

@@ -24,10 +24,23 @@
 
 @dataclass
 class ComponentSource:
-    """A checked-out source tree for a component."""
+    """A checked-out source tree for a component.
+
+    ``source_dir`` is the repository checkout root. ``build_dir`` is the module
+    subdirectory whose POM builds this component — they differ only for a
+    multi-module project, where pombast builds in the matching subdirectory
+    rather than from the reactor root. When ``build_dir`` is None it defaults to
+    ``source_dir`` (the single-module case).
+    """
 
     component: Component
     source_dir: Path
+    build_dir: Path | None = None
+
+    @property
+    def work_dir(self) -> Path:
+        """The directory to build, test, and write per-component logs in."""
+        return self.build_dir or self.source_dir
 
 
 class MavenComponentBuilder:
@@ -80,7 +93,7 @@ def build_and_test(
             BuildResult with status, log path, and duration.
         """
         component = source.component
-        log_dir = self.output_dir / component.group / component.name
+        log_dir = source.work_dir
 
         merged = {**self.extra_properties, **(extra_properties or {})}
 
@@ -105,7 +118,7 @@ def build_and_test(
         try:
             result = run_maven(
                 ["clean", "test"],
-                cwd=source.source_dir,
+                cwd=source.work_dir,
                 java_home=java_home,
                 extra_properties=merged,
                 log_path=source_log_path,
@@ -184,7 +197,7 @@ def _test_binary(
             # Step 3: Unpack JAR into target/classes.
             # Wipe the entire target/ dir first — generated sources, test-classes,
             # or other artifacts from a prior tag would otherwise linger.
-            target_dir = source.source_dir / "target"
+            target_dir = source.work_dir / "target"
             if target_dir.exists():
                 shutil.rmtree(target_dir)
             classes_dir = target_dir / "classes"
@@ -197,7 +210,7 @@ def _test_binary(
             # -Dmaven.resources.skip=true skips resource processing
             test_result = run_maven(
                 ["test"],
-                cwd=source.source_dir,
+                cwd=source.work_dir,
                 java_home=java_home,
                 extra_properties={
                     **(extra_properties or self.extra_properties),
@@ -279,7 +292,7 @@ def _write_smelt_script(
             ]
         lines += ['exec mvn "${MVN_ARGS[@]}" clean test', ""]
 
-        script_path = source.source_dir / "smelt.sh"
+        script_path = source.work_dir / "smelt.sh"
         try:
             script_path.write_text("\n".join(lines))
             script_path.chmod(0o755)

src/pombast/maven/_reactor.py

@@ -0,0 +1,78 @@
+"""Locate the module subdirectory that builds a given component.
+
+A multi-module Maven project is one checkout that produces several published
+artifacts, each managed separately in a BOM. pombast clones such a repo per
+component (the clones are cheap and independent) and builds, tests, and pins
+each component *in its own module subdirectory* rather than from the reactor
+root. Sibling modules resolve from the repository as ordinary released
+dependencies, so no whole-reactor build is required. This module maps a
+component's G:A coordinate to the directory whose POM builds it.
+"""
+
+from __future__ import annotations
+
+import logging
+import xml.etree.ElementTree as ET
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+    from pombast.core._component import Component
+
+_log = logging.getLogger(__name__)
+
+# Maven POM namespace.
+_NS = "http://maven.apache.org/POM/4.0.0"
+
+
+def _pom_ga(pom_path: Path) -> tuple[str, str] | None:
+    """Return the effective (groupId, artifactId) declared by a POM.
+
+    The groupId is frequently inherited rather than declared, so fall back to
+    ``<parent><groupId>`` when the module omits its own — true for every
+    pom-scijava-parented module (groupId ``org.scijava`` comes from the parent).
+    Returns None if the file cannot be parsed or lacks an artifactId.
+    """
+    try:
+        root = ET.parse(pom_path).getroot()
+    except ET.ParseError:
+        return None
+
+    artifact = root.find(f"{{{_NS}}}artifactId")
+    if artifact is None or not artifact.text:
+        return None
+
+    group = root.find(f"{{{_NS}}}groupId")
+    if group is None or not group.text:
+        parent = root.find(f"{{{_NS}}}parent")
+        if parent is not None:
+            group = parent.find(f"{{{_NS}}}groupId")
+    if group is None or not group.text:
+        return None
+
+    return group.text.strip(), artifact.text.strip()
+
+
+def locate_module_dir(repo_root: Path, component: Component) -> Path | None:
+    """Return the directory whose POM builds ``component``'s artifact.
+
+    Scans every ``pom.xml`` in the checkout (skipping build output under
+    ``target/``), matching on the effective groupId:artifactId. For a
+    single-module project this is the repo root itself, which is checked first
+    so the common case short-circuits. Returns None when no POM matches, leaving
+    the caller to fall back to the repo root.
+    """
+    target = (component.group, component.name)
+
+    root_pom = repo_root / "pom.xml"
+    if root_pom.exists() and _pom_ga(root_pom) == target:
+        return repo_root
+
+    for pom in sorted(repo_root.rglob("pom.xml")):
+        if "target" in pom.relative_to(repo_root).parts:
+            continue
+        if _pom_ga(pom) == target:
+            return pom.parent
+
+    return None

tests/unit/test_reactor.py

@@ -0,0 +1,82 @@
+"""Tests for locating the module subdirectory that builds a component."""
+
+from pathlib import Path
+
+from pombast.core._component import Component
+from pombast.maven._reactor import locate_module_dir
+
+NS = "http://maven.apache.org/POM/4.0.0"
+
+
+def _pom(group: str | None, artifact: str, parent_group: str | None = None) -> str:
+    group_elem = f"  <groupId>{group}</groupId>\n" if group else ""
+    parent = (
+        f"  <parent>\n    <groupId>{parent_group}</groupId>\n"
+        f"    <artifactId>some-parent</artifactId>\n"
+        f"    <version>1.0.0</version>\n  </parent>\n"
+        if parent_group
+        else ""
+    )
+    return (
+        f'<?xml version="1.0" encoding="UTF-8"?>\n'
+        f'<project xmlns="{NS}">\n'
+        f"  <modelVersion>4.0.0</modelVersion>\n"
+        f"{parent}{group_elem}"
+        f"  <artifactId>{artifact}</artifactId>\n"
+        f"  <version>1.0.0</version>\n"
+        f"</project>\n"
+    )
+
+
+def _write(path: Path, text: str) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(text)
+
+
+def test_single_module_returns_root(tmp_path: Path) -> None:
+    _write(tmp_path / "pom.xml", _pom("org.example", "my-app"))
+    component = Component(group="org.example", name="my-app", version="1.0.0")
+    assert locate_module_dir(tmp_path, component) == tmp_path
+
+
+def test_nested_module_matched(tmp_path: Path) -> None:
+    # Aggregator root with a different artifactId than any managed component.
+    _write(tmp_path / "pom.xml", _pom("org.bonej", "pom-bonej"))
+    _write(tmp_path / "Modern" / "ops" / "pom.xml", _pom("org.bonej", "bonej-ops"))
+    _write(
+        tmp_path / "Modern" / "wrapperPlugins" / "pom.xml",
+        _pom("org.bonej", "bonej-plugins"),
+    )
+    component = Component(group="org.bonej", name="bonej-plugins", version="7.2.0")
+    assert (
+        locate_module_dir(tmp_path, component)
+        == tmp_path / "Modern" / "wrapperPlugins"
+    )
+
+
+def test_group_inherited_from_parent(tmp_path: Path) -> None:
+    # scijava/scijava topology: module omits groupId; parent is pom-scijava.
+    _write(tmp_path / "pom.xml", _pom("org.scijava", "scijava-aggregator"))
+    _write(
+        tmp_path / "scijava-common3" / "pom.xml",
+        _pom(None, "scijava-common3", parent_group="org.scijava"),
+    )
+    component = Component(group="org.scijava", name="scijava-common3", version="1.0.0")
+    assert locate_module_dir(tmp_path, component) == tmp_path / "scijava-common3"
+
+
+def test_no_match_returns_none(tmp_path: Path) -> None:
+    _write(tmp_path / "pom.xml", _pom("org.example", "my-app"))
+    component = Component(group="org.example", name="absent", version="1.0.0")
+    assert locate_module_dir(tmp_path, component) is None
+
+
+def test_target_dirs_skipped(tmp_path: Path) -> None:
+    _write(tmp_path / "pom.xml", _pom("org.example", "aggregator"))
+    _write(tmp_path / "mod" / "pom.xml", _pom("org.example", "real"))
+    # A stray POM under target/ must never win.
+    _write(
+        tmp_path / "mod" / "target" / "pom.xml", _pom("org.example", "real")
+    )
+    component = Component(group="org.example", name="real", version="1.0.0")
+    assert locate_module_dir(tmp_path, component) == tmp_path / "mod"