1
java {
2
    toolchain {
3
        languageVersion.set(JavaLanguageVersion.of(21))
4
    }
5
}

1
tasks.withType<JavaCompile>().configureEach {
2
    options.compilerArgs.add("-parameters")
3
    options.encoding = "UTF-8"
4
    options.release.set(21)
5
}

1
configurations {
2
    compileOnly {
3
        extendsFrom(configurations.annotationProcessor.get())
4
    }
5
}
6

7
dependencies {
8
    compileOnly("org.projectlombok:lombok")                 // version via Boot BOM
9
    annotationProcessor("org.projectlombok:lombok")
10
    implementation("org.mapstruct:mapstruct:${property("mapstruct.version")}")
11
    annotationProcessor("org.mapstruct:mapstruct-processor:${property("mapstruct.version")}")
12
}

1
tasks.withType<KotlinJvmCompile>().configureEach {
2
    compilerOptions {
3
        jvmTarget.set(JvmTarget.JVM_21)
4
        freeCompilerArgs.addAll(
5
            "-Xjsr305=strict",       // strict null-safety for Java interop
6
            "-Xcontext-parameters"   // Spring annotation support
7
        )
8
        allWarningsAsErrors.set(true)
9
    }
10
}

1
tasks.withType<Javadoc>().configureEach {
2
    (options as StandardJavadocDocletOptions).apply {
3
        addStringOption("Xdoclint:all", "-quiet")
4
        encoding = "UTF-8"
5
    }
6
}
7

8
java {
9
    withJavadocJar()
10
    withSourcesJar()
11
}

1
platform-service/
2
├── domain/                                        # pure logic, no framework
3
├── application/                                   # use cases + ports
4
├── infrastructure/
5
│   ├── entry-points/                              # inbound adapters
6
│   │   ├── rest-controller/
7
│   │   ├── scheduler-task/
8
│   │   ├── <topic>-consumer/                      # e.g. order-consumer, payment-consumer
9
│   │   └── graphql-controller/
10
│   └── driven-adapters/                           # outbound adapters
11
│       ├── jdbc-repository/
12
│       ├── redis-cache/
13
│       ├── metrics-publisher/
14
│       └── <provider>-adapter/                    # e.g. stripe-adapter, paypal-adapter
15
├── bootstrap/                                     # Spring Boot wiring, runs the app
16
├── build.gradle.kts                               # root build
17
├── settings.gradle.kts                            # module includes
18
└── gradle.properties                              # versions

1
rootProject.name = "platform-service"
2

3
include(":domain")
4
project(":domain").projectDir = file("./domain")
5

6
include(":application")
7
project(":application").projectDir = file("./application")
8

9
include(":bootstrap")
10
project(":bootstrap").projectDir = file("./bootstrap")
11

12
// Entry points
13
include(":rest-controller")
14
project(":rest-controller").projectDir = file("./infrastructure/entry-points/rest-controller")
15

16
include(":scheduler-task")
17
project(":scheduler-task").projectDir = file("./infrastructure/entry-points/scheduler-task")
18

19
include(":order-consumer")
20
project(":order-consumer").projectDir = file("./infrastructure/entry-points/order-consumer")
21

22
// Driven adapters
23
include(":jdbc-repository")
24
project(":jdbc-repository").projectDir = file("./infrastructure/driven-adapters/jdbc-repository")
25

26
include(":stripe-adapter")
27
project(":stripe-adapter").projectDir = file("./infrastructure/driven-adapters/stripe-adapter")

1
tasks.getByName<Jar>("bootJar") {
2
    enabled = false
3
}

1
tasks.getByName<org.springframework.boot.gradle.tasks.bundling.BootJar>("bootJar") {
2
    archiveFileName.set("${project.parent?.name}.${archiveExtension.get()}")
3
    enabled = true
4
}
5

6
tasks.getByName<Jar>("jar") {
7
    enabled = false
8
}

1
plugins {
2
    java
3
    id("org.springframework.boot") version "4.0.2" apply false
4
    id("io.spring.dependency-management") version "1.1.7"
5
    id("com.diffplug.spotless") version "8.1.0"
6
    id("jacoco")
7
    id("org.sonarqube") version "7.1.0.6387"
8
}
9

10
allprojects {
11
    group = "com.example.platform"
12
    version = "0.0.1-SNAPSHOT"
13

14
    repositories {
15
        mavenCentral()
16
        // see §9 for GitHub Packages
17
    }
18
}
19

20
subprojects {
21
    apply(plugin = "java")
22
    // NOTE: do NOT apply org.springframework.boot here — only :bootstrap applies it (§3.3) and produces the BootJar.
23
    // subprojects inherit the BOM via io.spring.dependency-management only.
24
    apply(plugin = "io.spring.dependency-management")
25
    apply(plugin = "com.diffplug.spotless")
26
    apply(plugin = "jacoco")
27
    apply(plugin = "org.sonarqube")
28

29
    java.sourceCompatibility = JavaVersion.VERSION_21
30
    java.targetCompatibility = JavaVersion.VERSION_21
31

32
    dependencyManagement {
33
        imports {
34
            mavenBom("org.springframework.boot:spring-boot-dependencies:${property("spring.boot.version")}")
35
            mavenBom("org.springframework.cloud:spring-cloud-dependencies:${property("spring.cloud.version")}")
36
        }
37
    }
38

39
    tasks.withType<Test>().configureEach {
40
        useJUnitPlatform()
41
        finalizedBy("jacocoTestReport")
42
        testLogging { events("passed", "skipped", "failed") }
43
    }
44

45
    // bootJar/jar toggling lives in :bootstrap (the only module with the boot plugin), not here.
46
}
47

48
// Only :bootstrap applies the Spring Boot plugin and produces the executable BootJar (§3.3).
49
project(":bootstrap") {
50
    apply(plugin = "org.springframework.boot")
51
}

1
spotless {
2
    java {
3
        googleJavaFormat("1.17.0")
4
        target("src/**/*.java")
5
        trimTrailingWhitespace()
6
        endWithNewline()
7
        removeUnusedImports()
8
    }
9
}

1
spotless {
2
    kotlin {
3
        target("**/*.kt")
4
        ktlint()
5
        trimTrailingWhitespace()
6
        endWithNewline()
7
    }
8
    kotlinGradle { ktlint() }
9
}

1
plugins {
2
    id("io.gitlab.arturbosch.detekt") version "1.23.8" apply false
3
}
4

5
subprojects {
6
    plugins.withId("org.jetbrains.kotlin.jvm") {
7
        apply(plugin = "io.gitlab.arturbosch.detekt")
8

9
        configure<io.gitlab.arturbosch.detekt.extensions.DetektExtension> {
10
            toolVersion = "1.23.8"
11
            config.setFrom(files("$rootDir/config/detekt/detekt.yml"))
12
            baseline = file("$rootDir/config/detekt/baseline.xml")
13
            buildUponDefaultConfig = true
14
            allRules = false
15
            autoCorrect = false
16
            parallel = true
17
            ignoreFailures = false
18
        }
19

20
        dependencies {
21
            "detektPlugins"("io.gitlab.arturbosch.detekt:detekt-formatting:1.23.8")
22
        }
23

24
        tasks.withType<io.gitlab.arturbosch.detekt.Detekt>().configureEach {
25
            jvmTarget = "21"
26
            reports {
27
                html.required.set(true)
28
                xml.required.set(true)
29
                sarif.required.set(true)
30
            }
31
            exclude("**/build/**", "**/generated/**", "**/resources/**")
32
        }
33

34
        tasks.named("check") { dependsOn("detekt") }
35
    }
36
}

1
build:
2
  maxIssues: 0
3
  weights: { complexity: 2, LongParameterList: 1, style: 1 }
4

5
complexity:
6
  active: true
7
  LongMethod: { threshold: 10 }                # aligns with rules/coding-style.md
8
  LongParameterList: { functionThreshold: 3, constructorThreshold: 5 }
9
  CyclomaticComplexMethod: { threshold: 8 }
10
  TooManyFunctions: { thresholdInClasses: 11, thresholdInObjects: 11 }
11

12
style:
13
  active: true
14
  MagicNumber: { ignoreNumbers: ['-1', '0', '1', '2'] }
15
  MaxLineLength: { maxLineLength: 120 }
16
  ReturnCount: { max: 2 }
17
  WildcardImport: { active: true }
18

19
formatting:
20
  active: true
21
  android: false
22
  autoCorrect: false

1
val jacocoExclusions = listOf("**/config/**", "**/*Application*")
2

3
fun org.gradle.testing.jacoco.tasks.JacocoReportBase.applyExclusions() {
4
    classDirectories.setFrom(
5
        files(classDirectories.files.map { fileTree(it) { exclude(jacocoExclusions) } })
6
    )
7
}
8

9
tasks.named<JacocoReport>("jacocoTestReport") {
10
    dependsOn(tasks.named("test"))
11
    applyExclusions()
12
    reports {
13
        xml.required = true
14
        html.required = true
15
    }
16
}
17

18
tasks.named<JacocoCoverageVerification>("jacocoTestCoverageVerification") {
19
    dependsOn(tasks.named("test"))
20
    applyExclusions()
21
    violationRules {
22
        rule {
23
            limit {
24
                counter = "LINE"
25
                minimum = "0.80".toBigDecimal()   // 0.90 for SDKs / shared libs
26
            }
27
        }
28
    }
29
}
30

31
tasks.named("check") {
32
    dependsOn(tasks.named("jacocoTestCoverageVerification"))
33
}

1
tasks.register<JacocoReport>("codeCoverageReport") {
2
    description = "Generates aggregated coverage report from all subprojects."
3
    group = JavaBasePlugin.VERIFICATION_GROUP
4

5
    dependsOn(subprojects.mapNotNull { it.tasks.findByName("test")?.let { _ -> it.tasks.named("test") } })
6

7
    val excludedPatterns = listOf("**/config/**", "**/*Application*")
8
    val allClassDirs = files()
9
    val allSourceDirs = files()
10
    val allExecData = files()
11

12
    subprojects {
13
        plugins.withType<JacocoPlugin>().configureEach {
14
            tasks.withType<Test>().configureEach {
15
                val jacocoExt = extensions.findByType<JacocoTaskExtension>()
16
                jacocoExt?.destinationFile?.let { allExecData.from(it) }
17
            }
18
            val sourceSets = extensions.getByType<SourceSetContainer>()
19
            val mainSourceSet = sourceSets.findByName("main") ?: return@configureEach
20
            allSourceDirs.from(mainSourceSet.allSource.srcDirs)
21
            allClassDirs.from(
22
                mainSourceSet.output.classesDirs.asFileTree.matching { exclude(excludedPatterns) }
23
            )
24
        }
25
    }
26

27
    classDirectories.setFrom(allClassDirs)
28
    sourceDirectories.setFrom(allSourceDirs)
29
    executionData.setFrom(allExecData)
30

31
    reports { xml.required = true; html.required = true }
32
}

1
sonar {
2
    properties {
3
        property("sonar.projectKey", "example_platform-service")
4
        property("sonar.organization", "example")
5
        property("sonar.host.url", "https://sonarcloud.io")
6
        property("sonar.token", System.getenv("SONAR_TOKEN") ?: "")
7
        property("sonar.java.coveragePlugin", "jacoco")
8
        property("sonar.gradle.skipCompile", "true")
9
        property("sonar.kotlin.file.suffixes", ".kt")
10
        property(
11
            "sonar.coverage.jacoco.xmlReportPaths",
12
            subprojects.joinToString(",") {
13
                "$projectDir/${it.name}/build/reports/jacoco/test/jacocoTestReport.xml"
14
            }
15
        )
16
        property("sonar.exclusions", "**/src/test/**,**/*Test.java,**/*IT.java")
17
        property("sonar.coverage.exclusions", "**/config/**,**/*Application*")
18
        property("sonar.cpd.exclusions", "**/*Config*")
19
    }
20
}

1
classDiagrams {
2
    diagram {
3
        name("${project.name} Class Diagram")
4
        include(packages().withName("com.example.platform"))
5
        writeTo(file("$rootDir/architecture/diagrams/${project.name}-class-diagram.puml"))
6
        renderTo(file("$rootDir/architecture/diagrams/${project.name}-class-diagram.svg"))
7
    }
8

9
    packageDiagram {
10
        name("${project.name} Packages Diagram")
11
        include(packages().withName("com.example.platform"))
12
        writeTo(file("$rootDir/architecture/diagrams/${project.name}-packages-diagram.puml"))
13
        renderTo(file("$rootDir/architecture/diagrams/${project.name}-packages-diagram.svg"))
14
    }
15
}

1
val structurizr: Configuration by configurations.creating {
2
    isCanBeResolved = true
3
    isCanBeConsumed = false
4
}
5

6
dependencies {
7
    structurizr("com.structurizr:structurizr-dsl:3.1.0")
8
    structurizr("com.structurizr:structurizr-export:3.1.0")
9
}
10

11
val structurizrWorkspace = "$rootDir/architecture/structurizr/workspace.dsl"
12
val structurizrOutputDir = "$rootDir/architecture/structurizr/export"
13
val structurizrSrc = "$rootDir/architecture/structurizr/src"
14

15
val compileStructurizrExporter by tasks.registering(JavaCompile::class) {
16
    source = fileTree(structurizrSrc)
17
    classpath = structurizr
18
    destinationDirectory.set(layout.buildDirectory.dir("structurizr-classes"))
19
    sourceCompatibility = "21"
20
    targetCompatibility = "21"
21
}
22

23
tasks.register<JavaExec>("structurizrExport") {
24
    description = "Exports Structurizr C4 diagrams to PlantUML and Mermaid"
25
    group = "documentation"
26
    dependsOn(compileStructurizrExporter)
27
    classpath = files(compileStructurizrExporter.get().destinationDirectory) + structurizr
28
    mainClass.set("structurizr.StructurizrExporter")
29
    args = listOf(structurizrWorkspace, structurizrOutputDir)
30
}

1
dependencies {
2
    // Logging
3
    implementation("org.slf4j:slf4j-api")
4
    implementation("ch.qos.logback:logback-classic")
5

6
    // JSON (Jackson 3.x — note `tools.jackson` group)
7
    implementation("tools.jackson.core:jackson-databind")
8

9
    // Code-gen
10
    compileOnly("org.projectlombok:lombok")
11
    annotationProcessor("org.projectlombok:lombok")
12
    implementation("org.mapstruct:mapstruct:${property("mapstruct.version")}")
13
    annotationProcessor("org.mapstruct:mapstruct-processor:${property("mapstruct.version")}")
14

15
    // Testing
16
    testImplementation("org.springframework.boot:spring-boot-starter-test")
17
    testImplementation("org.mockito:mockito-junit-jupiter")
18
    testImplementation("org.junit.jupiter:junit-jupiter-engine")
19
    testRuntimeOnly("org.junit.platform:junit-platform-launcher")
20

21
    // Architecture testing
22
    testImplementation("com.tngtech.archunit:archunit-junit5:1.5.1")
23
}

1
dependencies {
2
    implementation("org.jetbrains.kotlin:kotlin-reflect")
3
    // version managed by the Boot BOM; avoid hardcoding (move to gradle/libs.versions.toml if an override is needed)
4
    implementation(platform("tools.jackson:jackson-bom"))
5
    implementation("tools.jackson.core:jackson-databind")
6
    implementation("org.slf4j:slf4j-api:${property("slf4j.version")}")
7

8
    testImplementation(kotlin("test"))
9
    testImplementation("io.mockk:mockk:${property("mockk.version")}")
10
    testRuntimeOnly("org.junit.platform:junit-platform-launcher")
11
}

1
dependencies {
2
    implementation(project(":application"))
3
    implementation(project(":domain"))
4
    // include every adapter module
5
    implementation(project(":rest-controller"))
6
    implementation(project(":jdbc-repository"))
7
    // ...
8

9
    // Spring Boot core
10
    implementation("org.springframework.boot:spring-boot-starter")
11
    implementation("org.springframework.boot:spring-boot-starter-web")
12
    implementation("org.springframework.boot:spring-boot-starter-actuator")
13
    implementation("org.springframework.boot:spring-boot-autoconfigure")
14
    implementation("org.springframework.boot:spring-boot-configuration-processor")
15

16
    // Messaging — RabbitMQ
17
    implementation("org.springframework.boot:spring-boot-starter-amqp")
18
    // Messaging — Kafka
19
    // implementation("org.springframework.kafka:spring-kafka")
20

21
    // Cloud config
22
    implementation("io.awspring.cloud:spring-cloud-aws-starter-parameter-store:4.0.0")
23

24
    // Observability — see observability.md
25
    implementation("io.micrometer:micrometer-tracing-bridge-otel")
26
    implementation("io.micrometer:micrometer-registry-otlp")
27
    implementation("io.micrometer:micrometer-registry-prometheus")
28
    implementation("io.opentelemetry:opentelemetry-exporter-otlp")
29

30
    // Dev only — not packaged in production image
31
    developmentOnly("org.springframework.boot:spring-boot-devtools")
32
    developmentOnly("org.springframework.boot:spring-boot-docker-compose")
33

34
    // Integration testing
35
    testImplementation("org.springframework.boot:spring-boot-testcontainers")
36
    // Testcontainers 2.x — version managed by the Spring Boot 4 BOM; 2.x artifacts carry the `testcontainers-` prefix
37
    testImplementation("org.testcontainers:testcontainers-junit-jupiter")
38
    testImplementation("org.testcontainers:testcontainers-postgresql")   // OR testcontainers-mssqlserver
39
    testImplementation("org.testcontainers:testcontainers-rabbitmq")     // OR testcontainers-kafka
40
    testImplementation("org.wiremock.integrations:wiremock-spring-boot:3.6.0")
41
    testImplementation("io.karatelabs:karate-junit5:1.5.0")
42
}

1
tasks.getByName<Jar>("bootJar") { enabled = false }

1
dependencies {
2
    implementation(project(":domain"))
3
}
4

5
tasks.getByName<Jar>("bootJar") { enabled = false }

1
dependencies {
2
    implementation(project(":application"))
3
    implementation(project(":domain"))
4

5
    implementation("org.springframework.boot:spring-boot-starter-data-jdbc")
6
    implementation("org.liquibase:liquibase-core")
7
    runtimeOnly("org.postgresql:postgresql")                    // OR mssql-jdbc
8

9
    testImplementation("org.testcontainers:testcontainers-postgresql")   // version from Spring Boot BOM
10
}
11

12
tasks.getByName<Jar>("bootJar") { enabled = false }

1
dependencies {
2
    implementation(project(":application"))
3
    implementation(project(":domain"))
4

5
    implementation("com.stripe:stripe-java:25.0.0")  // pin per provider
6

7
    testImplementation("org.wiremock.integrations:wiremock-spring-boot:3.6.0")
8
}
9

10
tasks.getByName<Jar>("bootJar") { enabled = false }

1
plugins {
2
    id("java")
3
    id("maven-publish")
4
    id("jacoco")
5
    id("com.diffplug.spotless") version "8.1.0"
6
    id("org.sonarqube") version "7.1.0.6387"
7
}
8

9
group = "com.example.platform"
10
version = "1.0.0"

1
dependencies {
2
    implementation(platform("org.springframework.boot:spring-boot-dependencies:4.0.2"))
3

4
    implementation("org.slf4j:slf4j-api")
5
    implementation("org.springframework.boot:spring-boot-autoconfigure")
6

7
    // Consumer brings these — SDK only compiles against them
8
    compileOnly("org.springframework:spring-jdbc")
9
    compileOnly("org.springframework:spring-tx")
10
    compileOnly("org.springframework.amqp:spring-rabbit")
11
    compileOnly("tools.jackson.core:jackson-databind")
12
    compileOnly("org.projectlombok:lombok:1.18.38")
13
    annotationProcessor("org.projectlombok:lombok:1.18.38")
14

15
    // Genuinely owned by the SDK
16
    implementation("net.javacrumbs.shedlock:shedlock-spring:7.2.0")
17

18
    testImplementation(platform("org.junit:junit-bom:5.10.0"))
19
    testImplementation("org.junit.jupiter:junit-jupiter")
20
    testRuntimeOnly("org.junit.platform:junit-platform-launcher")
21
    testImplementation("org.springframework.boot:spring-boot-starter-test")
22
    testImplementation("org.springframework:spring-jdbc")
23
    testImplementation("org.springframework:spring-tx")
24
    testImplementation("org.springframework.amqp:spring-rabbit")
25
    testImplementation("tools.jackson.core:jackson-databind")
26
    testRuntimeOnly("com.h2database:h2")
27
}

1
java {
2
    toolchain { languageVersion.set(JavaLanguageVersion.of(21)) }
3
    withJavadocJar()
4
    withSourcesJar()
5
}

1
tasks.named<JacocoCoverageVerification>("jacocoTestCoverageVerification") {
2
    dependsOn(tasks.test)
3
    violationRules {
4
        rule { limit { counter = "LINE"; minimum = "0.90".toBigDecimal() } }
5
    }
6
}
7

8
tasks.named("check") {
9
    dependsOn(tasks.named("jacocoTestCoverageVerification"))
10
}

1
publishing {
2
    repositories {
3
        maven {
4
            name = "GitHubPackages"
5
            url = uri("${project.findProperty("github_packages_url")}/your-sdk-name")
6
            credentials {
7
                username = System.getenv("GH_PACKAGES_USERNAME")
8
                password = System.getenv("GH_PACKAGES_TOKEN")
9
            }
10
        }
11
    }
12

13
    publications {
14
        create<MavenPublication>("mavenJava") {
15
            from(components["java"])
16
            groupId = project.group.toString()
17
            artifactId = project.name
18
            version = project.version.toString()
19
        }
20
    }
21
}

1
src/main/resources/META-INF/spring/
2
└── org.springframework.boot.autoconfigure.AutoConfiguration.imports

1
com.example.platform.messaging.config.EventMessagingAutoConfiguration

1
dependencyManagement {
2
    imports {
3
        mavenBom("org.springframework.boot:spring-boot-dependencies:${property("spring.boot.version")}")
4
        mavenBom("org.springframework.cloud:spring-cloud-dependencies:${property("spring.cloud.version")}")
5
    }
6
}

1
// GOOD — BOM resolves
2
implementation("org.springframework.boot:spring-boot-starter-web")
3

4
// BAD — drift risk
5
implementation("org.springframework.boot:spring-boot-starter-web:4.0.2")

1
allprojects {
2
    repositories {
3
        mavenLocal()                    // dev only — see §9.3
4
        mavenCentral()                  // canonical OSS
5
        maven {                         // private registry
6
            name = "GitHubPackages"
7
            url = uri("${project.findProperty("github_packages_url")}/your-org")
8
            credentials {
9
                username = System.getenv("GH_PACKAGES_USERNAME")
10
                password = System.getenv("GH_PACKAGES_TOKEN")
11
            }
12
        }
13
    }
14
}

1
# ~/.gradle/gradle.properties (NOT committed)
2
GH_PACKAGES_USERNAME=yourgithubuser
3
GH_PACKAGES_TOKEN=ghp_xxx

1
credentials {
2
    username = System.getenv("GH_PACKAGES_USERNAME") ?: providers.gradleProperty("GH_PACKAGES_USERNAME").orNull
3
    password = System.getenv("GH_PACKAGES_TOKEN") ?: providers.gradleProperty("GH_PACKAGES_TOKEN").orNull
4
}

1
configurations.testRuntimeClasspath {
2
    resolutionStrategy.eachDependency {
3
        if (requested.group == "org.eclipse.jetty"
4
            || requested.group.startsWith("org.eclipse.jetty.")) {
5
            useVersion("12.0.15")
6
            because("Avoid jetty-core 12.1.x vs ee10 12.0.x NoSuchMethodError")
7
        }
8
    }
9
}

1
implementation("com.github.javafaker:javafaker:1.0.2") {
2
    exclude(group = "org.yaml")        // pulls vulnerable SnakeYAML
3
}

1
import java.text.SimpleDateFormat
2
import java.util.Date
3

4
tasks.register("createMigrationFile") {
5
    description = "Generates Liquibase migration file with timestamp"
6
    doLast {
7
        val timestamp = SimpleDateFormat("yyyyMMddHHmmss").format(Date())
8
        val migrationFileName = "V${timestamp}__change_name_here.sql"
9
        val migrationFilePath = "src/main/resources/db/changelog/changes/$migrationFileName"
10
        file(migrationFilePath).createNewFile()
11
        println("Created migration file: $migrationFileName")
12
    }
13
}

1
tasks.register("jacocoLogCodeCoverage") {
2
    description = "Logs code coverage summary per subproject and total from JaCoCo XML reports."
3
    group = JavaBasePlugin.VERIFICATION_GROUP
4
    dependsOn("codeCoverageReport")
5

6
    doLast {
7
        val excludedPackages = listOf("config")
8

9
        var totalInstr = 0L to 0L   // (covered, missed)
10
        var totalBranch = 0L to 0L
11
        var totalLine = 0L to 0L
12

13
        val separator = "-".repeat(90)
14
        println("\n$separator")
15
        println(" JaCoCo Code Coverage Summary")
16
        println(separator)
17
        println(String.format("  %-30s %12s %12s %12s", "Module", "Instruction%", "Branch%", "Line%"))
18
        println(separator)
19

20
        subprojects.sortedBy { it.name }.forEach { sub ->
21
            val reportFile = file("${sub.layout.buildDirectory.get()}/reports/jacoco/test/jacocoTestReport.xml")
22
            if (!reportFile.exists()) return@forEach
23

24
            val doc = javax.xml.parsers.DocumentBuilderFactory.newInstance().apply {
25
                setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false)
26
            }.newDocumentBuilder().parse(reportFile)
27

28
            var instr = 0L to 0L; var branch = 0L to 0L; var line = 0L to 0L
29
            val packages = doc.getElementsByTagName("package")
30
            for (i in 0 until packages.length) {
31
                val pkg = packages.item(i) as org.w3c.dom.Element
32
                val pkgName = pkg.getAttribute("name")
33
                if (excludedPackages.any { pkgName.contains(it) }) continue
34

35
                val counters = pkg.getElementsByTagName("counter")
36
                for (j in 0 until counters.length) {
37
                    val counter = counters.item(j) as org.w3c.dom.Element
38
                    if (counter.parentNode != pkg) continue
39
                    val missed = counter.getAttribute("missed").toLong()
40
                    val covered = counter.getAttribute("covered").toLong()
41
                    when (counter.getAttribute("type")) {
42
                        "INSTRUCTION" -> instr = (instr.first + covered) to (instr.second + missed)
43
                        "BRANCH" -> branch = (branch.first + covered) to (branch.second + missed)
44
                        "LINE" -> line = (line.first + covered) to (line.second + missed)
45
                    }
46
                }
47
            }
48

49
            totalInstr = (totalInstr.first + instr.first) to (totalInstr.second + instr.second)
50
            totalBranch = (totalBranch.first + branch.first) to (totalBranch.second + branch.second)
51
            totalLine = (totalLine.first + line.first) to (totalLine.second + line.second)
52

53
            fun pct(c: Long, m: Long): String =
54
                if ((c + m) == 0L) "N/A" else String.format("%.2f%%", c * 100.0 / (c + m))
55

56
            println(String.format("  %-30s %12s %12s %12s",
57
                sub.name,
58
                pct(instr.first, instr.second),
59
                pct(branch.first, branch.second),
60
                pct(line.first, line.second)))
61
        }
62

63
        fun pct(c: Long, m: Long): String =
64
            if ((c + m) == 0L) "N/A" else String.format("%.2f%%", c * 100.0 / (c + m))
65

66
        println(separator)
67
        println(String.format("  %-30s %12s %12s %12s",
68
            "TOTAL",
69
            pct(totalInstr.first, totalInstr.second),
70
            pct(totalBranch.first, totalBranch.second),
71
            pct(totalLine.first, totalLine.second)))
72
        println("$separator\n")
73
    }
74
}

1
------------------------------------------------------------------------------------------
2
 JaCoCo Code Coverage Summary
3
------------------------------------------------------------------------------------------
4
  Module                          Instruction%      Branch%        Line%
5
------------------------------------------------------------------------------------------
6
  application                          92.41%       85.71%       93.21%
7
  domain                               98.05%       91.30%       98.55%
8
  jdbc-repository                      87.62%       72.41%       89.10%
9
  rest-controller                      89.33%       78.92%       91.04%
10
------------------------------------------------------------------------------------------
11
  TOTAL                                91.85%       82.08%       93.22%
12
------------------------------------------------------------------------------------------

1
# Build engine
2
org.gradle.daemon=false                 # CI determinism; flip to `true` for local dev
3
org.gradle.parallel=true
4
org.gradle.caching=true
5

6
# Java toolchain
7
org.gradle.java.installations.auto-download=true
8
org.gradle.java.installations.auto-detect=true
9

10
# Framework BOMs
11
spring.boot.version=4.0.2
12
spring.cloud.version=2025.1.1
13
spring.dependency.management.version=1.1.7
14

15
# Plugins
16
sonarqube.plugin.version=7.1.0.6387
17

18
# Libraries
19
mapstruct.version=1.6.3
20
javafaker.version=1.0.2
21
slf4j.version=2.0.17
22

23
# Private registries (NEVER commit credentials)
24
github_packages_url=https://maven.pkg.github.com/your-org