build.gradle

plugins {
    id 'com.gradleup.shadow' version '9.2.2' apply false
}

allprojects {
    group = 'net.hasor'
}

subprojects {
    plugins.withId('java-library') {
        apply plugin: 'jacoco'
        jacoco {
            toolVersion = '0.8.15'
        }
        tasks.named('jacocoTestReport') {
            dependsOn tasks.named('test')
            reports {
                xml.required = true
                html.required = true
            }
        }
        tasks.named('jacocoTestCoverageVerification') {
            dependsOn tasks.named('test')
            violationRules {
                rule {
                    element = 'PACKAGE'
                    includes = ['net.hasor.dataway*', 'net.hasor.dataql*']
                }
            }
        }
        tasks.named('check') {
            dependsOn tasks.named('jacocoTestReport'), tasks.named('jacocoTestCoverageVerification')
        }
    }

    plugins.withType(JavaPlugin).configureEach {
        java {
            toolchain.languageVersion = JavaLanguageVersion.of(17)
        }
        tasks.withType(JavaCompile).configureEach {
            options.encoding = 'UTF-8'
            options.release = 17
        }
        tasks.withType(Javadoc).configureEach {
            options.encoding = 'UTF-8'
            options.addStringOption('Xdoclint:none', '-quiet')
            failOnError = false
        }
        tasks.withType(Test).configureEach {
            useJUnitPlatform()
            jvmArgs '--add-opens', 'java.base/java.lang=ALL-UNNAMED',
                    '--add-opens', 'java.base/java.lang.reflect=ALL-UNNAMED',
                    '--add-opens', 'java.base/java.io=ALL-UNNAMED',
                    '--add-opens', 'java.base/java.net=ALL-UNNAMED'
        }
        tasks.withType(GenerateModuleMetadata).configureEach { enabled = false }
        dependencies {
            testImplementation "junit:junit:${property('lib.junit')}"
            testImplementation platform('org.junit:junit-bom:6.1.3')
            testImplementation 'org.junit.jupiter:junit-jupiter'
            testRuntimeOnly 'org.junit.vintage:junit-vintage-engine'
            testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
            testRuntimeOnly 'org.slf4j:slf4j-simple:2.0.17'
        }

        plugins.withId('maven-publish') {
            apply plugin: 'signing'
            java {
                withSourcesJar()
                withJavadocJar()
            }
            publishing {
                publications {
                    mavenJava(MavenPublication) {
                        from components.java
                        pom {
                            name = providers.provider { project.findProperty('pomName') ?: project.name }
                            description = providers.provider { project.description ?: project.name }
                            url = 'https://www.dataql.net/'
                            licenses { license { name = 'The Apache Software License, Version 2.0'; url = 'https://www.apache.org/licenses/LICENSE-2.0.txt' } }
                            developers { developer { name = '赵永春(Mr.Zhao)'; email = 'zyc@hasor.net' } }
                            scm {
                                connection = 'scm:git:git@gitee.com:zycgit/dataql.git'
                                developerConnection = connection
                                url = 'https://gitee.com/zycgit/dataql'
                                tag = 'HEAD'
                            }
                            withXml {
                                def excluded = new LinkedHashSet(configurations.compileOnly.dependencies)
                                excluded.addAll(configurations.testImplementation.dependencies)
                                excluded.addAll(configurations.testRuntimeOnly.dependencies)
                                if (configurations.findByName('shaded')) {
                                    excluded.addAll(configurations.shaded.dependencies)
                                }
                                if (configurations.findByName('antlr')) {
                                    excluded.addAll(configurations.antlr.dependencies)
                                }

                                excluded.each { dep ->
                                    def groupId = dep.group ?: project.group
                                    def dependenciesNode = asNode().dependencies[0]
                                    dependenciesNode?.dependency?.findAll {
                                        it.groupId.text() == groupId.toString() && it.artifactId.text() == dep.name
                                    }?.each {
                                        dependenciesNode.remove(it)
                                    }
                                }
                            }
                        }
                    }
                }
                if (findProperty('centralBundleDir')) {
                    repositories { maven { name = 'centralBundle'; url = uri(findProperty('centralBundleDir')) } }
                }
            }
            afterEvaluate {
                if (plugins.hasPlugin('com.gradleup.shadow')) {
                    publishing.publications.mavenJava.setArtifacts([tasks.shadowJar, tasks.sourcesJar, tasks.javadocJar])
                }
            }
            signing {
                required { findProperty('centralRelease') == 'true' }
                def key = findProperty('maven.central.signing_key')
                if (key) {
                    useInMemoryPgpKeys(key.replace('\\n', '\n'), findProperty('maven.central.signing_password'))
                }
                sign publishing.publications.mavenJava
            }
        }
    }
}