Gradle-taakbeheer optimaliseren met Kotlin DSL en buildSrc

// build.gradle.kts (projet racine)
plugins {
    base // Appliqué au projet racine
}

allprojects {
    group = "com.example"
    version = "1.0.0"

    repositories {
        mavenCentral()
    }

    tasks.withType<org.gradle.api.tasks.testing.Test> {
        useJUnitPlatform() // Configuration commune des tests pour tous les projets
    }
}

subprojects {
    apply(plugin = "java")
    apply(plugin = "org.jetbrains.kotlin.jvm")

    dependencies {
        implementation("org.jetbrains.kotlin:kotlin-stdlib-jdk8")
    }

}

----
----
----
init {
    group = "verification"
    description = "Opens a test report in Firefox."
    dependsOn("check") // Assure que les rapports sont générés
}

@get:Input
abstract var reportPath: String

@TaskAction
fun openReport() {
    val separator = File.separator
    val reportFile = project.layout.projectDirectory.asFile.toPath()
        .resolve(reportPath.replace("/", separator))
        .toAbsolutePath()
        .toFile()

    if (!reportFile.exists()) {
        logger.warn("Report file does not exist: $reportFile. Ensure 'check' ran.")
        return
    }

    project.exec {
        commandLine("firefox", "--new-tab", reportFile.absolutePath)
    }
    logger.lifecycle("Opened test report: ${reportFile.absolutePath}")
}
----

## }

\=== Concreet Implementaties

Deze klassen erven van de abstracte taak en definiëren het specifieke pad van het rapport.

## [source,kotlin]

pakket com.yourpackage

abstracte klasse ReportUnitTestsTask : OpenTestReportTask() { init { description = "Opent het eenheidstestrapport in Firefox. reportPath = "build/reports/tests/test/index.html } }

package com.yourpackage

## abstract class ReportFunctionalTestsTask : OpenTestReportTask() { init { description = "Opent het functionele testrapport in Firefox." reportPath = "build/reports/tests/functionalTest/index.html" } }

\=== Registratie van de taken

In de`build.gradle.kts`van uw hoofdproject :

## [source,kotlin]

tasks.register\<com.yourpackage.ReportUnitTestsTask\>("reportTests") {} tasks.register\<com.yourpackage.ReportFunctionalTestsTask\>("reportFunctionalTests") {}

\=== UML-diagram van de rapporttaken (PlantUML-code)

Kopieer de onderstaande code en plak deze in een tool die PlantUML ondersteunt.

## [source,plantuml]

@startuml skinparam handgeschreven waar skinparam monochrome true

abstracte klasse DefaultTask { }

abstracte klasse Exec { \+ commandLine(args: String...) \+ exec() }

abstracte klasse OpenTestReportTask extends DefaultTask { \+ group: String = "verification \+ beschrijving: String \+ dependsOn("check") \+ abstract reportPath: String \+ openReport() : void }

abstracte klasse AbstractJbakeExecTask extends Exec { \+ group: String = "verificatie \+ beschrijving: String \+ dependsOn("check") + abstract reportRelativePath: String \+ exec() : void }

class ReportUnitTestsTask extends OpenTestReportTask { \+ reportPath: String = "build/reports/tests/test/index.html }

class ReportFunctionalTestsTask extends OpenTestReportTask { \+ reportPath: String = "build/reports/tests/functionalTest/index.html }

class ReportJbakeTestsTask extends AbstractJbakeExecTask { \+ reportRelativePath: String = "build/reports/tests/test/index.html }

class ReportJbakeFunctionalTestsTask extends AbstractJbakeExecTask { \+ reportRelativePath: String = "build/reports/tests/functionalTest/index.html }

OpenTestReportTask \<-- ReportUnitTestsTask OpenTestReportTask \<-- ReportFunctionalTestsTask

AbstractJbakeExecTask \<-- ReportJbakeTestsTask AbstractJbakeExecTask \<-- ReportJbakeFunctionalTestsTask

DefaultTask \<|-- OpenTestReportTask Exec \<|-- AbstractJbakeExecTask DefaultTask \<|-- Exec

## @enduml

\== Abstracte taak`AbstractJbakeExecTask`(ervend van`Exec`)

Als je taak vooral bestaat uit het uitvoeren van een externe opdracht met variabele argumenten, erf dan rechtstreeks van**Exec**is directer.

## [source,kotlin]

pakket com.yourpackage

import org.gradle.api.tasks.Exec import org.gradle.api.tasks.Input import java.io.File

abstracte klasse AbstractJbakeExecTask : Exec() {

----

init { group = "verification" description = "Opens a Jbake project report in Firefox." dependsOn("check") }

@get:Input abstract var reportRelativePath: String

override fun exec() { val separator = File.separator val reportFile = project.layout.projectDirectory.asFile.toPath() .resolve(reportRelativePath.replace("/", separator)) .toAbsolutePath() .toFile()

if (!reportFile.exists()) { logger.warn("Report file does not exist: $reportFile. Ensure 'check' ran.") return }

commandLine("firefox", "--new-tab", reportFile.absolutePath) logger.lifecycle("Attempting to open report: ${reportFile.absolutePath}") super.exec() // Appelle la méthode exec() de la super-classe Exec }

## }

\=== concreete implementaties voor`Exec`

## [source,kotlin]

package com.yourpackage

abstract class ReportJbakeTestsTask : AbstractJbakeExecTask() initialiseer { Het Jbake-unittestrapport openen in Firefox reportRelativePath = "build/reports/tests/test/index.html } }

pakket com.yourpackage

## abstract class ReportJbakeFunctionalTestsTask : AbstractJbakeExecTask() { init { description = "Opens the functional test report in Firefox." reportRelativePath = "build/reports/tests/functionalTest/index.html" } }

\== Zichtbaarheid van taken`buildSrc`

De taken en klassen die u definieert in**buildSrc**zijn :

***Zichtbaar en bruikbaar**door alle projecten van je hoofd-build (root en sub-projecten). Daarom kun je gebruiken`com.yourpackage.ReportUnitTestsTask`in`allprojects { ... }`. ***Niet uitvoerbare**direct als taken van buildSrc (bijvoorbeeld,`gradle :buildSrc:reportTests`zou niet werken als de taak niet specifiek wordt geregistreerd in`buildSrc/build.gradle.kts`).`buildSrc`is een compilatiemodule, geen uitvoerbaar applicatiemodule voor deze taken van de hoofdbuild.

\=== een rapport uitvoeren voor de tests van`buildSrc`zichzelf

Si `buildSrc`heeft zijn eigen tests en genereert rapporten, u kunt een rapporttaak direct registreren in`buildSrc/build.gradle.kts` :

## [source,kotlin]

plugins { `kotlin-jvm` }

dépôts { mavenCentral() }

tasks.withType\<Test\> { useJUnitPlatform() reports.html.outputLocation.set(layout.buildDirectory.dir("reports/tests")) }

import com.yourpackage.ReportJbakeTestsTask // Importeer uw taakklasse

tasks.register\<ReportJbakeTestsTask\>("reportBuildSrcTests") { // Het pad is al gedefinieerd in de klasse, het zal naar de buildSrc-rapporten wijzen }

U kunt vervolgens uitvoeren :`./gradlew :buildSrc:test`gevolgd door`./gradlew :buildSrc:reportBuildSrcTests`.

Door deze praktijken te volgen, bouw je Gradle-buildsystemen in Kotlin DSL die niet alleen krachtig zijn, maar ook buitengewoon modulair, onderhoudbaar en gemakkelijk te begrijpen.
----

## }

\=== Concrete Implementaties

Deze klassen erven van de abstracte taak en definiëren het specifieke pad van het rapport.

## [bron,kotlin]

package com.yourpackage

abstract class ReportUnitTestsTask : OpenTestReportTask() { init { description = "Opent het unit test-rapport in Firefox. reportPath = "build/reports/tests/test/index.html } }

package com.yourpackage

## abstract class ReportFunctionalTestsTask : OpenTestReportTask() { init { description = "Opent het functionele testrapport in Firefox." reportPath = "build/reports/tests/functionalTest/index.html" } }

\=== Registratie van Taken

In het`build.gradle.kts`van uw rootproject:

## [bron,kotlin]

## tasks.register\<com.yourpackage.ReportUnitTestsTask\>("reportTests") {} tasks.register\<com.yourpackage.ReportFunctionalTestsTask\>("reportFunctionalTests") {}

\=== UML-diagram van Rapporttaken (PlantUML-code)

Kopieer de onderstaande code en plak deze in een tool die PlantUML ondersteunt.

## [bron,plantuml]

@startuml skinparam handwritten true skinparam monochrome true

abstract class DefaultTask { }

abstract class Exec { \+ commandLine(args: String...) \+ exec() }

abstract class OpenTestReportTask extends DefaultTask { \+ group: String = "verification \+ beschrijving: String \+ dependsOn("check") \+ abstract reportPath: String \+ openReport() : void }

abstract class AbstractJbakeExecTask extends Exec { \+ group: String = "verification \+ beschrijving: String \+ dependsOn("check") \+ abstract reportRelativePath: String \+ exec() : void }

class ReportUnitTestsTask extends OpenTestReportTask { \+ reportPath: String = "build/reports/tests/test/index.html }

class ReportFunctionalTestsTask extends OpenTestReportTask { \+ reportPath: String = "build/reports/tests/functionalTest/index.html }

class ReportJbakeTestsTask extends AbstractJbakeExecTask { \+ reportRelativePath: String = "build/reports/tests/test/index.html }

class ReportJbakeFunctionalTestsTask extends AbstractJbakeExecTask { \+ reportRelativePath: String = "build/reports/tests/functionalTest/index.html }

OpenTestReportTask \<-- ReportUnitTestsTask OpenTestReportTask \<-- ReportFunctionalTestsTask

AbstractJbakeExecTask \<-- ReportJbakeTestsTask AbstractJbakeExecTask \<-- ReportJbakeFunctionalTestsTask

DefaultTask \<|-- OpenTestReportTask Exec \<|-- AbstractJbakeExecTask StandaardTaak \<|-- Exec

## @enduml

\== Abstracte Taak`AbstractJbakeExecTask`(ervend van`Exec`)

Als uw taak hoofdzakelijk bestaat uit het uitvoeren van een extern commando met variabele argumenten, erf dan rechtstreeks van**Uitvoeren**is directer.

## [bron,kotlin]

package com.yourpackage

import org.gradle.api.tasks.Exec import org.gradle.api.tasks.Input import java.io.File

abstract class AbstractJbakeExecTask : Exec() {

init {
    group = "verification"
    description = "Opens a Jbake project report in Firefox."
    dependsOn("check")
}

@get:Input
abstract var reportRelativePath: String

override fun exec() {
    val separator = File.separator
    val reportFile = project.layout.projectDirectory.asFile.toPath()
        .resolve(reportRelativePath.replace("/", separator))
        .toAbsolutePath()
        .toFile()

    if (!reportFile.exists()) {
        logger.warn("Report file does not exist: $reportFile. Ensure 'check' ran.")
        return
    }

    commandLine("firefox", "--new-tab", reportFile.absolutePath)
    logger.lifecycle("Attempting to open report: ${reportFile.absolutePath}")
    super.exec() // Appelle la méthode exec() de la super-classe Exec
}