build.gradle

buildscript {
    repositories {
        mavenCentral()
    }

    dependencies {
        classpath 'com.netflix.nebula:gradle-aggregate-javadocs-plugin:3.0.1'
    }
}

plugins {
    id "com.google.cloud.artifactregistry.gradle-plugin" version "2.2.1" apply false
}

// gradle aggregateJavadoc
apply plugin: 'nebula-aggregate-javadocs'
apply plugin: 'jacoco'

allprojects {
    group = 'io.emeraldpay.etherjar'
    version = "0.13.0-SNAPSHOT"

    repositories {
        mavenLocal()
        mavenCentral()
        maven { url 'https://oss.jfrog.org/artifactory/repo' }
    }
}

subprojects {
    apply plugin: 'java'
    apply plugin: 'java-library'
    apply plugin: 'groovy'
    apply plugin: 'jacoco'
    apply plugin: 'maven-publish'

    if (System.getenv("ENABLE_GCP") == "true") {
        apply plugin: "com.google.cloud.artifactregistry.gradle-plugin"
    }

    targetCompatibility = JavaVersion.VERSION_17
    sourceCompatibility = JavaVersion.VERSION_17

    [compileJava, compileTestJava]*.options*.encoding = 'UTF-8'

    compileJava.options.compilerArgs \
        << '-Xlint:unchecked' << '-Xlint:deprecation'

    dependencies {
        testImplementation 'org.objenesis:objenesis:3.3'
        testImplementation 'org.spockframework:spock-core:2.4-M2-groovy-4.0'
        testImplementation 'nl.jqno.equalsverifier:equalsverifier:3.15.8'
        testImplementation 'org.apache.groovy:groovy:4.0.20'
    }

    test {
        jvmArgs '-ea'

        testLogging.showStandardStreams = true
        testLogging.exceptionFormat = 'full'
        useJUnitPlatform()
    }

    jacocoTestReport {
        reports {
            xml.required = true
        }
    }

    jacoco {
        toolVersion = "0.8.11"
    }

    test.finalizedBy jacocoTestReport

    // Show the list of failed tests and output only for them, helpful for CI
    ext.failedTests = []
    tasks.withType(Test) {
        def stdout = new LinkedList<String>()
        beforeTest { TestDescriptor td ->
            stdout.clear()
        }
        onOutput { TestDescriptor td, TestOutputEvent toe ->
            stdout.addAll(toe.getMessage().split('(?m)$'))
            while (stdout.size() > 100) {
                stdout.remove()
            }
        }
        afterTest { TestDescriptor descriptor, TestResult result ->
            if(result.resultType == org.gradle.api.tasks.testing.TestResult.ResultType.FAILURE){
                failedTests << "${descriptor.className} > ${descriptor.name}"
                if (!stdout.isEmpty()) {
                    println("-------- ${descriptor.className} > ${descriptor.name} OUTPUT ".padRight(120, "-"))
                    stdout.each { print(it) }
                    println("================".padRight(120, "="))
                }
            }
        }
    }
    gradle.buildFinished {
        if(!failedTests.empty){
            println "Failed tests for ${project.name}:"
            failedTests.each { failedTest ->
                println failedTest
            }
            println ""
        }
    }

    java {
        withJavadocJar()
        withSourcesJar()
    }

    javadoc {
        options.addBooleanOption('html5', true)
    }

    artifacts {
        archives sourcesJar
        archives javadocJar
    }

    publishing {
        repositories {
            maven {
                url "artifactregistry://us-maven.pkg.dev/emeraldpay-prod/maven"
            }
        }

        publications {
            EtherJarPublication(MavenPublication) {
                from components.java

                groupId project.group
                artifactId project.name
                version project.version
                pom {
                    name = "EtherJar - Java Library to Build Applications on Ethereum"
                    licenses {
                        license {
                            name = "The Apache Software License, Version 2.0"
                            url = "http://www.apache.org/licenses/LICENSE-2.0.txt"
                        }
                    }
                    developers {
                        developer {
                            id = "splix"
                            name = "Igor Artamonov"
                        }
                    }

                    scm {
                        connection = "scm:git:git://github.com/emeraldpay/etherjar.git"
                        developerConnection = "scm:git:git://github.com/emeraldpay/etherjar.git"
                        url = "https://github.com/emeraldpay/etherjar"
                    }
                }
            }
        }
    }

}

task syncJars(type: Sync) {
    allprojects { p ->
        from p.tasks.withType(Jar)
    }
    into "${buildDir}/libs/"
}

jacoco {
    toolVersion = "0.8.11"
}

task coverageReport(type: JacocoReport) {
    dependsOn = [subprojects.test, subprojects.jacocoTestReport]
    additionalSourceDirs.setFrom files(subprojects.sourceSets.main.allSource.srcDirs)
    sourceDirectories.setFrom files(subprojects.sourceSets.main.allSource.srcDirs)
    classDirectories.setFrom files(subprojects.sourceSets.main.output)
    executionData.setFrom project.fileTree(dir: '.', include: '**/build/jacoco/test.exec')
    reports {
        xml.required = true
        csv.required = false
        html.required = true
    }
}