build.gradle

/*
 * Copyright 2002-2024 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

buildscript {
    repositories {
        gradlePluginPortal()
        mavenCentral()
    }
    dependencies {
        classpath("io.spring.gradle:dependency-management-plugin:1.1.7")
        classpath("org.jfrog.buildinfo:build-info-extractor-gradle:5.2.5")
        classpath("io.spring.javaformat:spring-javaformat-gradle-plugin:0.0.43")
        classpath("io.spring.nohttp:nohttp-gradle:0.0.11")
    }
}

// NoHttp has to be applied at the root level
// so that it reads all the root files, including the gradle ones.
apply plugin: "io.spring.nohttp"

ext {
    springBootVersion = "3.4.1"
    springCloudVersion = "2024.0.0"
    javaCfEnvVersion = "3.3.0"
    nohttpVersion = "0.0.11"
    wireMockVersion = "3.10.0"
}

configure(allprojects) {
    group = "io.pivotal.spring.cloud"

    apply plugin: "maven-publish"
    apply plugin: "eclipse"
    apply plugin: "idea"
    apply plugin: "jacoco"
    apply plugin: "checkstyle"
    apply plugin: "io.spring.dependency-management"
    apply plugin: "io.spring.javaformat"

    ext {
        javadocLinks = [
                "https://docs.oracle.com/en/java/javase/17/docs/api",
                "https://docs.spring.io/spring-framework/docs/current/javadoc-api/"
        ] as String[]
    }

    repositories {
        mavenCentral()
        maven { url "https://repo.spring.io/release" }
        if (version =~ /((-M|-RC)[0-9]+|-SNAPSHOT)$/) {
            maven { url "https://repo.spring.io/milestone" }
        }
        if (version.endsWith('-SNAPSHOT')) {
            maven { url "https://repo.spring.io/snapshot" }
        }
    }
}

subprojects {
    apply from: "${rootProject.projectDir}/publish-maven.gradle"

    checkstyle {
        configDirectory = file("${project.rootDir}/ci/config/")
        toolVersion = 8.16
    }
}

configure(javaProjects) {
    apply plugin: "java-library"

    compileJava {
        sourceCompatibility = JavaVersion.VERSION_17
        targetCompatibility = JavaVersion.VERSION_17
        options.encoding = "UTF-8"
    }

    compileTestJava {
        sourceCompatibility = JavaVersion.VERSION_17
        targetCompatibility = JavaVersion.VERSION_17
        options.encoding = "UTF-8"
    }

    java {
        withJavadocJar()
        withSourcesJar()
    }

    [compileJava, compileTestJava]*.options*.compilerArgs = ["-Xlint:all"]

    test {
        // enable JUnit 5
        useJUnitPlatform()

        testLogging {
            // display all the events
            events 'PASSED', 'FAILED', 'SKIPPED'
            // display stdout and stderr
            showStandardStreams = true
        }

        // create a summary after the execution
        afterSuite { desc, result ->
            if (!desc.parent) {
                println "\nTest result: ${result.resultType}"
                println "Test summary: ${result.testCount} tests, " +
                        "${result.successfulTestCount} succeeded, " +
                        "${result.failedTestCount} failed, " +
                        "${result.skippedTestCount} skipped"
            }
        }

        // print failed tests after the execution
        def failedTests = []

        afterTest { test, result ->
            if (result.resultType == TestResult.ResultType.FAILURE) {
                failedTests << test
            }
        }

        afterSuite {
            failedTests.each { test -> println "FAILED test: ${test.className} > ${test.name}" }
        }

    }

    jar {
        manifest.attributes["Created-By"] =
                "${System.getProperty("java.version")} (${System.getProperty("java.specification.vendor")})"
        manifest.attributes["Implementation-Title"] = project.name
        manifest.attributes["Implementation-Version"] = project.version

        from("${rootProject.projectDir}/src/dist") {
            include "license.txt"
            include "notice.txt"
            into "META-INF"
            expand(copyright: new Date().format("yyyy"), version: project.version)
        }
    }

    javadoc {
        description = "Generates project-level javadoc for use in -javadoc jar"

        options.memberLevel = org.gradle.external.javadoc.JavadocMemberLevel.PROTECTED
        options.author = true
        options.header = project.name
        options.links(project.ext.javadocLinks)
        options.addStringOption('Xdoclint:none', '-quiet')
    }

    dependencies {
        testRuntimeOnly("io.spring.nohttp:nohttp:${nohttpVersion}")
    }

    dependencyManagement {
        imports {
            mavenBom "org.springframework.cloud:spring-cloud-dependencies:${springCloudVersion}"
            mavenBom "org.springframework.boot:spring-boot-dependencies:${springBootVersion}"
        }
    }

    task allDependencyInsight(type: DependencyInsightReportTask) {}
    task allDependencies(type: DependencyReportTask) {}
}

configure(rootProject) {
    description = "Spring Cloud Services Starter Build"

    task api(type: Javadoc) {
        group = "Documentation"
        description = "Generates aggregated Javadoc API documentation."
        title = "${rootProject.description} ${version} API"
        options.memberLevel = org.gradle.external.javadoc.JavadocMemberLevel.PROTECTED
        options.author = true
        options.header = rootProject.description
        options.links(project.ext.javadocLinks)
        options.addStringOption('Xdoclint:none', '-quiet')

        source projectsWithSource.collect { project ->
            project.sourceSets.main.allJava
        }

        classpath = files(projectsWithSource.collect { project ->
            project.sourceSets.main.compileClasspath
        })

        maxMemory = "1024m"
        destinationDir = new File(buildDir, "api")
    }

}

task codeCoverageReport(type: JacocoReport) {
    executionData fileTree(project.rootDir.absolutePath).include("**/build/jacoco/*.exec")

    projectsWithSource.each { subproject ->
        sourceSets subproject.sourceSets.main
    }

    reports {
        xml.required = true
        xml.destination new File("${buildDir}/reports/jacoco/report.xml")
        html.required = false
        csv.required = false
    }
}

codeCoverageReport.dependsOn {
    subprojects*.test
}

configure(subprojects) {
    dependencyManagement {
        dependencies {
            dependency "io.pivotal.cfenv:java-cfenv-boot-pivotal-scs:${javaCfEnvVersion}"
            dependency "io.pivotal.cfenv:java-cfenv:${javaCfEnvVersion}"
        }
    }
}

allprojects {
    tasks.withType(Test).forEach { Test task ->
        task.with {
            testLogging {
                exceptionFormat = "full"
                events = ["passed", "skipped", "failed"]
                showStandardStreams = false
            }

            StringBuilder testOutput = new StringBuilder()

            beforeTest {
                testOutput.setLength(0)
            }

            onOutput { descriptor, TestOutputEvent event ->
                testOutput.append(event.message)
            }

            afterTest { TestDescriptor descriptor, TestResult result ->
                if (result.resultType == TestResult.ResultType.FAILURE && testOutput.size() > 0) {
                    logger.lifecycle("\n\n${testOutput}")
                }
            }
        }
    }
}

def getProjectsWithSource() {
    [
            project(":spring-cloud-services-config-client-autoconfigure"),
            project(":spring-cloud-services-service-registry-autoconfigure")
    ]
}

def getJavaProjects() {
    subprojects - project(":spring-cloud-services-dependencies")
}