build.gradle

import org.gradle.api.tasks.testing.logging.TestExceptionFormat
import org.gradle.api.tasks.testing.logging.TestLogEvent

buildscript {
    repositories {
        jcenter()
        maven { url 'https://plugins.gradle.org/m2/' }
        mavenCentral()
    }
    dependencies {
        classpath group: 'org.jetbrains.kotlin', name: 'kotlin-gradle-plugin', version: '1.3.72'
        classpath "org.jetbrains.dokka:dokka-gradle-plugin:1.5.31"
    }
}

plugins {
    id 'org.jetbrains.kotlin.jvm' version '1.3.72'
    id 'io.codearte.nexus-staging' version '0.20.0'
    id "de.marcphilipp.nexus-publish" version '0.2.0'
}

repositories {
    mavenCentral()
    mavenLocal()
    jcenter()
}

nexusStaging {
    packageGroup = "com.github.shynixn"
    username = project.hasProperty("ossrhUsername") ? project.findProperty("ossrhUsername") : System.getenv('SONATYPE_USERNAME')
    password = project.hasProperty("ossrhPassword") ? project.findProperty("ossrhPassword") : System.getenv('SONATYPE_PASSWORD')
    delayBetweenRetriesInMillis = 10000
    numberOfRetries = 100
}

allprojects {
    apply plugin: 'jacoco'
    apply plugin: 'org.jetbrains.dokka'
}

tasks.register("printVersion") {
    println(this.subprojects.getAt(0).version)
}

subprojects {
    group 'com.github.shynixn.structureblocklib'
    version '2.13.0'

    apply plugin: 'kotlin-platform-jvm'
    apply plugin: 'signing'
    apply plugin: 'maven-publish'
    apply plugin: 'java-library'
    apply plugin: "de.marcphilipp.nexus-publish"

    sourceCompatibility = 1.8
    targetCompatibility = 1.8

    jacocoTestReport {
        reports {
            xml.enabled = true
            html.enabled = false
        }
    }

    test {
        useJUnitPlatform()
        testLogging.showStandardStreams = true
        failFast = true

        testLogging {
            events(TestLogEvent.FAILED, TestLogEvent.PASSED, TestLogEvent.SKIPPED, TestLogEvent.STARTED)
            displayGranularity = 0
            showExceptions = true
            showCauses = true
            showStackTraces = true
            exceptionFormat = TestExceptionFormat.FULL
        }
    }

    task sourcesJar(type: Jar) {
        from sourceSets.main.allJava
        classifier = 'sources'
    }

    tasks.named("dokkaHtml") {
        outputDirectory = file("$buildDir/javadoc")
    }

    task javadocJar(type: Jar, dependsOn: dokkaHtml) {
        from javadoc
        classifier = 'javadoc'
    }

    publishing {
        publications {
            mavenJava(MavenPublication) {
                from components.java
                artifact sourcesJar
                artifact javadocJar
                pom {
                    name = 'StructureBlockLib'
                    description = 'StructureBlockLib is a bukkit implementation for handling structures on spigot server.'
                    url = 'https://github.com/Shynixn/StructureBlockLib'
                    licenses {
                        license {
                            name = 'MIT License'
                            url = 'http://www.opensource.org/licenses/mit-license.php'
                        }
                    }
                    developers {
                        developer {
                            name = 'Shynixn'
                            url = 'https://github.com/Shynixn'
                        }
                    }
                    contributors {
                        contributor {
                            name = 'HielkePlugins'
                            url = 'https://github.com/HielkePlugins'
                        }
                    }
                    scm {
                        connection = 'scm:git:git://github.com/Shynixn/StructureBlockLib.git'
                        developerConnection = 'scm:git:ssh://github.com:Shynixn/StructureBlockLib.git'
                        url = 'http://github.com/Shynixn/StructureBlockLib.git/tree/master'
                    }
                }
            }
        }
        repositories {
            maven {
                def releasesRepoUrl = "https://oss.sonatype.org/service/local/staging/deploy/maven2/"
                def snapshotsRepoUrl = "https://oss.sonatype.org/content/repositories/snapshots/"
                url = version.endsWith('SNAPSHOT') ? snapshotsRepoUrl : releasesRepoUrl

                credentials {
                    username = project.hasProperty("ossrhUsername") ? project.findProperty("ossrhUsername") : System.getenv('SONATYPE_USERNAME')
                    password = project.hasProperty("ossrhPassword") ? project.findProperty("ossrhPassword") : System.getenv('SONATYPE_PASSWORD')
                }
            }
        }
    }

    signing {
        sign publishing.publications.mavenJava
    }

    repositories {
        mavenCentral()
        mavenLocal()
        jcenter()
    }

    dependencies {
        testCompile 'org.jetbrains.kotlin:kotlin-test'
        testCompile 'org.jetbrains.kotlin:kotlin-test-junit'
        testCompile 'org.junit.jupiter:junit-jupiter-api:5.7.0'
        testCompile 'org.mockito:mockito-core:3.7.7'

        testRuntime 'org.junit.jupiter:junit-jupiter-engine:5.7.0'
    }
}

gradle.taskGraph.whenReady { taskGraph ->
    if (project.findProperty("signing.keyId") == null) {
        ext."signing.keyId" = System.getenv('SIGNING_KEY_ID')
        ext."signing.password" = System.getenv('SIGNING_KEY_PASSWORD')
        ext."signing.secretKeyRingFile" = System.getenv('SIGNING_KEY_FILE')
    }
}

task jacocoRootReport(type: org.gradle.testing.jacoco.tasks.JacocoReport) {
    reports {
        html.enabled = true
        xml.enabled = true
        csv.enabled = false
    }
}


task generateJavaDocPages(type: org.jetbrains.dokka.gradle.DokkaTask) {
    dokkaSourceSets {
        named("main") {
            outputDirectory = file("docs/apidocs")
            sourceRoots.from(file("structureblocklib-api/src/main/java"))
            sourceRoots.from(file("structureblocklib-bukkit-api/src/main/java"))
        }
    }
}