feat(arch): Prefix module artifactIds and add shared Spring dependencies

Generated module artifactIds are now "{artifactId}-{dir}" (the parent is
"{artifactId}-parent"), with every parent, dependencyManagement, and
inter-module dependency reference updated to match.

Parent POM additions, all gated on includeSpring:
- dependencyManagement: spring-core, excluding commons-logging
- dependencies (test scope, all modules): spring-boot-starter-test,
  excluding commons-logging
- dependencies (compile scope, all modules): spring-boot-starter-logging,
  jspecify
- common-testing: spring-boot-starter-test at compile scope

Also:
- acceptance-tests package-info: the test package now describes the
  functional tests directly (no "Tests for " prefix); the main package
  describes supporting infrastructure for those tests
- *ComponentScan Javadoc reworded to
  "Anchor class for basePackageClasses component scanning."
- modules.adoc: document the module artifactId naming pattern

Updated all 15 integration-test verify scripts for the prefixed
coordinates and the new dependencies.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01McmUDzyMrkYpbyeU5UWrot

Author: jeffjensen

src/main/resources/META-INF/archetype-post-generate.groovy

@@ -33,7 +33,8 @@ def writeFile = { File base, String rel, String text ->
 }
 
 def srcTree = { File base, String module, String pkgPath,
-                List<String> mainSubs, List<String> testSubs, String description ->
+                List<String> mainSubs, List<String> testSubs, String description,
+                String testDescription = null ->
     ensureDir(base, "${module}/src/main/java")
     mainSubs.each { sub ->
         def fullPkg = (pkgPath + '/' + sub).replace('/', '.')
@@ -48,8 +49,10 @@ package ${fullPkg};
     }
     ensureDir(base, "${module}/src/main/resources")
     ensureDir(base, "${module}/src/test/java")
-    // Test-package Javadoc reuses the main wording, prefixed to mark it as the tests for that code.
-    def testDesc = 'Tests for ' + lcFirst(description.replaceAll(/\.\s*$/, '')) + '.'
+    // Test-package Javadoc reuses the main wording, prefixed to mark it as the tests for that code,
+    // unless the caller supplies an explicit testDescription (e.g. acceptance-tests, whose test
+    // package holds the functional tests themselves rather than tests *for* the main package).
+    def testDesc = testDescription ?: ('Tests for ' + lcFirst(description.replaceAll(/\.\s*$/, '')) + '.')
     testSubs.each { sub ->
         def fullPkg = (pkgPath + '/' + sub).replace('/', '.')
         def dir = "${module}/src/test/java/${pkgPath}/${sub}"
@@ -75,23 +78,37 @@ def failsafeSection = """\
   </build>
 """
 
-/** Builds a child-module pom.xml string (2-space indent).
- *  A dependency entry is either a String (an internal module artifactId, inheriting this project's
- *  groupId and BOM-managed version) or a Map [groupId:…, artifactId:…, scope:…] for an external
+/** Builds a child-module pom.xml string (2-space indent). `prefix` is the project artifactId;
+ *  every module's artifactId is rendered as "{prefix}-{aId}" and the inherited parent as
+ *  "{prefix}-parent".
+ *  A dependency entry is either a String (an internal module's bare name, rendered as
+ *  "{prefix}-{name}" with this project's groupId and BOM-managed version) or a Map
+ *  [groupId:…, artifactId:…, scope:…, exclusions:[[groupId:…, artifactId:…], …]] for an external
  *  dependency. Dependencies are grouped into a "<!-- TEST -->" section (scope 'test', emitted first)
  *  and a "<!-- PROD -->" section (everything else); both headers are always present. */
-def modulePom = { String gId, String parentAId, String ver,
+def modulePom = { String gId, String prefix, String ver,
                    String aId, String desc, List deps = [], String buildSection = '' ->
     def depsSection = ''
     if (deps) {
         def renderDep = { dep ->
             def dGroup = (dep instanceof Map) ? dep.groupId : gId
-            def dArtifact = (dep instanceof Map) ? dep.artifactId : dep
+            def dArtifact = (dep instanceof Map) ? dep.artifactId : "${prefix}-${dep}"
             def dScope = (dep instanceof Map && dep.scope) ? "\n      <scope>${dep.scope}</scope>" : ''
+            def dExclusions = ''
+            if (dep instanceof Map && dep.exclusions) {
+                def exLines = dep.exclusions.collect { ex ->
+                    """\
+        <exclusion>
+          <groupId>${ex.groupId}</groupId>
+          <artifactId>${ex.artifactId}</artifactId>
+        </exclusion>"""
+                }.join('\n')
+                dExclusions = "\n      <exclusions>\n${exLines}\n      </exclusions>"
+            }
             """\
     <dependency>
       <groupId>${dGroup}</groupId>
-      <artifactId>${dArtifact}</artifactId>${dScope}
+      <artifactId>${dArtifact}</artifactId>${dScope}${dExclusions}
     </dependency>"""
         }
         def isTest = { it instanceof Map && it.scope == 'test' }
@@ -115,12 +132,12 @@ def modulePom = { String gId, String parentAId, String ver,
 
   <parent>
     <groupId>${gId}</groupId>
-    <artifactId>${parentAId}</artifactId>
+    <artifactId>${prefix}-parent</artifactId>
     <version>${ver}</version>
     <relativePath>../parent/pom.xml</relativePath>
   </parent>
 
-  <artifactId>${aId}</artifactId>
+  <artifactId>${prefix}-${aId}</artifactId>
   <description>${desc}</description>
 ${depsSection}${buildSection}</project>
 """
@@ -272,7 +289,7 @@ def configClass = { String module, String mainSub ->
 package ${rootPkgFq};
 
 /**
- * Anchor class for based package class scanning.
+ * Anchor class for basePackageClasses component scanning.
  */
 public interface ${scanName} {
 }
@@ -314,11 +331,56 @@ def dmXml = allModules.collect { mod ->
     """\
       <dependency>
         <groupId>${groupId}</groupId>
-        <artifactId>${mod}</artifactId>
+        <artifactId>${artifactId}-${mod}</artifactId>
         <version>\${project.version}</version>
       </dependency>"""
 }.join('\n')
 
+// ─── Parent-pom dependency blocks (instructions 4–6) ──────────────────────────
+// All gated on includeSpring so a Spring-off project carries no Spring artifacts.
+//   #4 dependencyManagement PROD: manage spring-core, excluding commons-logging.
+//   #5 dependencies TEST: spring-boot-starter-test (test scope, all submodules), no commons-logging.
+//   #6 dependencies PROD: spring-boot-starter-logging + jspecify (compile scope, all submodules).
+def springCoreDm = !includeSpring ? '' : '\n' + [
+    '      <dependency>',
+    '        <groupId>org.springframework</groupId>',
+    '        <artifactId>spring-core</artifactId>',
+    '        <exclusions>',
+    '          <exclusion>',
+    '            <groupId>commons-logging</groupId>',
+    '            <artifactId>commons-logging</artifactId>',
+    '          </exclusion>',
+    '        </exclusions>',
+    '      </dependency>',
+].join('\n')
+
+def parentDependencies = !includeSpring ? '' : '\n' + [
+    '  <dependencies>',
+    '    <!-- TEST -->',
+    '    <dependency>',
+    '      <groupId>org.springframework.boot</groupId>',
+    '      <artifactId>spring-boot-starter-test</artifactId>',
+    '      <scope>test</scope>',
+    '      <exclusions>',
+    '        <exclusion>',
+    '          <groupId>commons-logging</groupId>',
+    '          <artifactId>commons-logging</artifactId>',
+    '        </exclusion>',
+    '      </exclusions>',
+    '    </dependency>',
+    '',
+    '    <!-- PROD -->',
+    '    <dependency>',
+    '      <groupId>org.springframework.boot</groupId>',
+    '      <artifactId>spring-boot-starter-logging</artifactId>',
+    '    </dependency>',
+    '    <dependency>',
+    '      <groupId>org.jspecify</groupId>',
+    '      <artifactId>jspecify</artifactId>',
+    '    </dependency>',
+    '  </dependencies>',
+].join('\n') + '\n'
+
 def parentInherit = includeSpring ? """\
   <parent>
     <groupId>org.springframework.boot</groupId>
@@ -338,11 +400,11 @@ def parentPom = """\
   <modelVersion>4.0.0</modelVersion>
 
 ${parentInherit}  <groupId>${groupId}</groupId>
-  <artifactId>${artifactId}</artifactId>
+  <artifactId>${artifactId}-parent</artifactId>
   <version>${version}</version>
   <packaging>pom</packaging>
 
-  <name>${artifactId}</name>
+  <name>${artifactId}-parent</name>
 
   <modules>
 ${modulesXml}
@@ -365,10 +427,13 @@ ${modulesXml}
 
   <dependencyManagement>
     <dependencies>
-${dmXml}
+      <!-- TEST -->
+
+      <!-- PROD -->
+${dmXml}${springCoreDm}
     </dependencies>
   </dependencyManagement>
-
+${parentDependencies}
   <build>
     <pluginManagement>
       <plugins>
@@ -537,11 +602,19 @@ configClass('common-domain', 'common/domain')
 
 // ─── common-testing ───────────────────────────────────────────────────────────
 
+// common-testing carries spring-boot-starter-test at compile scope (it is test-support code that
+// other modules compile their tests against), overriding the test-scoped copy every module inherits
+// from the parent (#5). No commons-logging exclusion is needed here — the parent already excludes it.
+def commonTestingDeps = ['common-domain']
+if (includeSpring) {
+    commonTestingDeps << [groupId: 'org.springframework.boot', artifactId: 'spring-boot-starter-test',
+                          scope: 'compile']
+}
 writeFile(projectDir, 'common-testing/pom.xml',
     modulePom(groupId, artifactId, version,
         'common-testing',
         'Testing infrastructure common to all test modules.',
-        ['common-domain']))
+        commonTestingDeps))
 srcTree(projectDir, 'common-testing', pkgPath,
     ['common/testing'], ['common/testing'],
     'Test infrastructure common to all modules.')
@@ -725,5 +798,8 @@ writeFile(projectDir, 'acceptance-tests/pom.xml',
         'Functional acceptance tests for the application.',
         atDeps,
         failsafeSection))
+// The test package holds the functional tests themselves (no "Tests for " prefix); the rarely-used
+// main package holds supporting classes / infrastructure for those tests.
 srcTree(projectDir, 'acceptance-tests', pkgPath, ['at'], ['at'],
+    'Supporting classes and infrastructure for the functional acceptance tests.',
     'Functional acceptance tests for the application.')

src/site/asciidoc/modules.adoc

@@ -12,6 +12,16 @@ Every module that the `app` composes also carries a Spring `@Configuration` clas
 `.config` sub-package; the `app` module's `Application` class `@Import`s them all so the
 whole tree assembles into a single Spring context.
 
+== Module Naming
+
+Throughout this page each module is referred to by its directory name (e.g. `common-domain`).
+A module's Maven `artifactId` is the project `artifactId`, followed by `-`, followed by that
+directory name. For a project generated with `artifactId=my-service`, the `common-domain`
+module's `artifactId` is `my-service-common-domain`, and the aggregator/BOM under `parent/`
+is `my-service-parent`. Every module inherits its `groupId` and `version` from `parent/`.
+This prefix applies to `artifactId`s only — the directory names and Java package names listed
+below are unaffected.
+
 == Fixed Modules
 
 These modules are always generated regardless of input.

src/test/resources/projects/basic/verify.groovy

@@ -15,9 +15,18 @@ def check = { String rel ->
     assert new File(basedir, rel).exists() : "Missing: $rel"
 }
 
-def text = { String rel ->
+// Instruction 2: each module's artifactId is "<artifactId property>-<dir name>". The inter-module
+// wiring assertions below are written in terms of bare module names, so text() strips the "<aid>-"
+// prefix from <artifactId> tags; the prefix itself is verified explicitly via raw() (each module's
+// own artifactId, the parent dependencyManagement, and the parent artifactId), and the generated
+// project's real Maven build — run before this script — would fail on any inconsistent reference.
+def aid = 'basic-test'
+def raw = { String rel ->
     new File(basedir, rel).text
 }
+def text = { String rel ->
+    raw(rel).replace("<artifactId>${aid}-", '<artifactId>')
+}
 
 // ── 1. parent/ module exists; no root pom.xml ────────────────────────────────
 
@@ -41,15 +50,15 @@ assert !new File(basedir, 'integration-database-main').exists(): "'database' mus
 
 // ── 4. parent/pom.xml lists every module with "../" relative paths ───────────
 
-def parentPom = text('parent/pom.xml')
+def parentPom = raw('parent/pom.xml')
 modules.each { m ->
-    assert parentPom.contains("<module>../${m}</module>")      : "parent <modules> missing: ../$m"
-    assert parentPom.contains("<artifactId>${m}</artifactId>") : "parent <dependencyManagement> missing: $m"
+    assert parentPom.contains("<module>../${m}</module>")             : "parent <modules> missing: ../$m"
+    assert parentPom.contains("<artifactId>${aid}-${m}</artifactId>") : "parent <dependencyManagement> missing: $m"
 }
 assert parentPom.contains('<packaging>pom</packaging>')  : "parent must have pom packaging"
 assert parentPom.contains('${project.version}')          : "dependencyManagement must use \${project.version}"
 assert parentPom.contains('<groupId>com.example</groupId>')      : 'parent must have correct groupId'
-assert parentPom.contains('<artifactId>basic-test</artifactId>') : 'parent must have correct artifactId'
+assert parentPom.contains('<artifactId>basic-test-parent</artifactId>') : 'parent must have correct artifactId'
 assert parentPom.contains('<version>1.0.0-SNAPSHOT</version>')   : 'parent must have correct version'
 assert parentPom.contains('<java.version>21</java.version>')     : 'parent must declare java.version=21'
 assert parentPom.contains('<maven.compiler.release>${java.version}</maven.compiler.release>') \
@@ -99,8 +108,9 @@ assert foundModules == moduleOrder : "parent <modules> not sorted alphabetically
 
 def dmBlock = (parentPom =~ /(?s)<dependencyManagement>.*?<\/dependencyManagement>/)[0]
 def dmIds = dmBlock.findAll(/<artifactId>[^<]+<\/artifactId>/).collect { it.replaceAll(/<\/?artifactId>/, '') }
-assert dmIds == modules.sort()        : "parent <dependencyManagement> not sorted alphabetically"
-assert dmIds.size() == modules.size() : "parent <dependencyManagement> wrong entry count: expected ${modules.size()}, got ${dmIds.size()}"
+def dmModuleIds = dmIds.findAll { it.startsWith("${aid}-") }.collect { it.substring(aid.length() + 1) }
+assert dmModuleIds == modules.sort()        : "parent <dependencyManagement> not sorted alphabetically"
+assert dmModuleIds.size() == modules.size() : "parent <dependencyManagement> wrong entry count: expected ${modules.size()}, got ${dmModuleIds.size()}"
 
 // ── 6. Child module <parent> references parent/pom.xml ───────────────────────
 
@@ -111,8 +121,8 @@ modules.each { m ->
 }
 
 modules.each { m ->
-    assert text("${m}/pom.xml").contains("<artifactId>${m}</artifactId>") \
-        : "${m}/pom.xml must declare its own artifactId as '${m}'"
+    assert raw("${m}/pom.xml").contains("<artifactId>${aid}-${m}</artifactId>") \
+        : "${m}/pom.xml must declare its own artifactId as '${aid}-${m}'"
 }
 
 // ── 7. Source directory skeletons ────────────────────────────────────────────

src/test/resources/projects/blank-presentation-types/verify.groovy

@@ -17,9 +17,17 @@ def check = { String rel ->
     assert new File(basedir, rel).exists() : "Missing: $rel"
 }
 
-def text = { String rel ->
+// Instruction 2: each module's artifactId is "<artifactId property>-<dir name>". The wiring
+// assertions below use bare module names, so text() strips the "<aid>-" prefix from <artifactId>
+// tags; the prefix is verified explicitly via raw() (module's own artifactId + parent DM), and the
+// generated project's real Maven build — run before this script — fails on any inconsistent reference.
+def aid = 'blank-pres-test'
+def raw = { String rel ->
     new File(basedir, rel).text
 }
+def text = { String rel ->
+    raw(rel).replace("<artifactId>${aid}-", '<artifactId>')
+}
 
 // ── 1. parent/ module exists; no root pom.xml ────────────────────────────────
 
@@ -42,10 +50,10 @@ assert !new File(basedir, 'presentation-rest').exists(): "Blank presentation ent
 
 // ── 4. parent/pom.xml completeness, packaging, sort order ────────────────────
 
-def parentPom = text('parent/pom.xml')
+def parentPom = raw('parent/pom.xml')
 modules.each { m ->
-    assert parentPom.contains("<module>../${m}</module>")      : "parent <modules> missing: ../$m"
-    assert parentPom.contains("<artifactId>${m}</artifactId>") : "parent <dependencyManagement> missing: $m"
+    assert parentPom.contains("<module>../${m}</module>")             : "parent <modules> missing: ../$m"
+    assert parentPom.contains("<artifactId>${aid}-${m}</artifactId>") : "parent <dependencyManagement> missing: $m"
 }
 assert parentPom.contains('<packaging>pom</packaging>') : "parent must have pom packaging"
 
@@ -55,8 +63,9 @@ assert moduleBlock.findAll(/<module>[^<]+<\/module>/) == moduleOrder : "parent <
 
 def dmBlock = (parentPom =~ /(?s)<dependencyManagement>.*?<\/dependencyManagement>/)[0]
 def dmIds = dmBlock.findAll(/<artifactId>[^<]+<\/artifactId>/).collect { it.replaceAll(/<\/?artifactId>/, '') }
-assert dmIds == modules.sort()        : "parent <dependencyManagement> not sorted alphabetically"
-assert dmIds.size() == modules.size() : "parent <dependencyManagement> wrong entry count: expected ${modules.size()}, got ${dmIds.size()}"
+def dmModuleIds = dmIds.findAll { it.startsWith("${aid}-") }.collect { it.substring(aid.length() + 1) }
+assert dmModuleIds == modules.sort()        : "parent <dependencyManagement> not sorted alphabetically"
+assert dmModuleIds.size() == modules.size() : "parent <dependencyManagement> wrong entry count: expected ${modules.size()}, got ${dmModuleIds.size()}"
 
 // ── 5. Child modules reference parent/pom.xml ────────────────────────────────
 
@@ -66,8 +75,8 @@ modules.each { m ->
 }
 
 modules.each { m ->
-    assert text("${m}/pom.xml").contains("<artifactId>${m}</artifactId>") \
-        : "${m}/pom.xml must declare its own artifactId as '${m}'"
+    assert raw("${m}/pom.xml").contains("<artifactId>${aid}-${m}</artifactId>") \
+        : "${m}/pom.xml must declare its own artifactId as '${aid}-${m}'"
 }
 
 // ── 6. Source skeletons ───────────────────────────────────────────────────────