build.gradle

import kotlinx.kover.gradle.plugin.dsl.CoverageUnit

plugins {
    id "java-library"
    id "signing"
    id "maven-publish"
    id "org.jetbrains.kotlin.jvm" version "${kotlinVersion}"
    id "io.gitlab.arturbosch.detekt" version "${detektVersion}"
    id "org.jetbrains.kotlinx.kover" version "${koverVersion}"
    id "io.github.gradle-nexus.publish-plugin" version "${publishPluginVersion}"
    id "com.github.ben-manes.versions" version "${benManerVersionsVersion}"
}

kover {
    reports {
        total {
            verify {
                rule {
                    bound {
                        coverageUnits = CoverageUnit.BRANCH
                        it.minValue = 90
                    }
                    bound {
                        coverageUnits = CoverageUnit.INSTRUCTION
                        it.minValue = 90
                    }
                    bound {
                        coverageUnits = CoverageUnit.BRANCH
                        it.minValue = 90
                    }
                }
            }
            it.html {
                onCheck = true
            }
        }
    }
}

dependencies {
    kover(project(":core"))
    kover(project(":graaljs-evaluator"))
    kover(project(":kotlin-evaluator"))
    kover(project(":rhino-evaluator"))
    kover(project(":jackson"))
}

allprojects {
    apply plugin: "java-library"
    apply plugin: "signing"
    apply plugin: "maven-publish"
    apply plugin: "org.jetbrains.kotlin.jvm"
    apply plugin: "io.gitlab.arturbosch.detekt"
    apply plugin: "org.jetbrains.kotlinx.kover"
    apply plugin: "com.github.ben-manes.versions"

    group "com.rapatao.ruleset"

    repositories {
        mavenCentral()
    }

    dependencies {
        implementation("org.jetbrains.kotlin:kotlin-stdlib:${kotlinVersion}")
        implementation("org.jetbrains.kotlin:kotlin-reflect:${kotlinVersion}")
    }

    test {
        useJUnitPlatform()
    }

    java {
        withSourcesJar()
        withJavadocJar()
        toolchain {
            languageVersion = JavaLanguageVersion.of(javaVersion)
        }
    }

    detekt {
        buildUponDefaultConfig = true
        allRules = false
    }

    signing {
        useGpgCmd()
        sign publishing.publications
    }

    publishing {
        publications {
            maven(MavenPublication) {
                from components.java

                pom {
                    name = "RuleSet Engine"
                    description = "Simple yet powerful rules engine that offers the flexibility of using the built-in engine and creating a custom one."
                    url = "https://github.com/rapatao/ruleset-engine"
                    packaging = "jar"
                    licenses {
                        license {
                            name = "The Apache License, Version 2.0"
                            url = "http://www.apache.org/licenses/LICENSE-2.0.txt"
                        }
                    }
                    developers {
                        developer {
                            id = "rapatao"
                            name = "Luiz Henrique Rapatao"
                            email = "rapatao@rapatao.com"
                        }
                    }
                    scm {
                        connection = "scm:git:git://github.com/rapatao/ruleset-engine.git"
                        developerConnection = "scm:git:ssh://github.com/rapatao/ruleset-engine.git"
                        url = "https://github.com/rapatao/ruleset-engine"
                    }
                    issueManagement {
                        system = "GitHub"
                        url = "https://github.com/rapatao/ruleset-engine/issues"
                    }
                }
            }
        }
    }

    tasks.named("dependencyUpdates").configure {
        rejectVersionIf {
            isNonStable(it.candidate.version)
        }
    }
}

nexusPublishing {
    repositories {
        sonatype {
            username = System.getenv('OSSRH_USERNAME')
            password = System.getenv('OSSRH_PASSWORD')
        }
    }
}

def isNonStable = { String version ->
    def stableKeyword = ['RELEASE', 'FINAL', 'GA'].any { it -> version.toUpperCase().contains(it) }
    def regex = /^[0-9,.v-]+(-r)?$/
    return !stableKeyword && !(version ==~ regex)
}