build.gradle

import io.github.gradlenexus.publishplugin.NexusPublishExtension
import io.github.gradlenexus.publishplugin.NexusRepository
import io.github.gradlenexus.publishplugin.NexusRepositoryContainer

import java.util.regex.Pattern

plugins {
    id 'java-library'
    id 'signing'
    id 'maven-publish'
    alias(libs.plugins.axion)
    alias(libs.plugins.nexus.publish)
}

repositories {
    mavenCentral()
}

extensions.configure(NexusPublishExtension) { NexusPublishExtension extension ->
    extension.repositories { NexusRepositoryContainer container ->
        container.sonatype { NexusRepository sonatypeRepository ->
            sonatypeRepository.username.set project.findProperty(Constants.OSSRH_USER_NAME_PROPERTY_KEY_PREFIX).toString()
            sonatypeRepository.password.set project.findProperty(Constants.OSSRH_PASSWORD_PROPERTY_KEY_PREFIX).toString()
        }
    }
}

project.group = 'info.fingo.xactus'

extensions.configure(JavaPluginExtension) {
    it.toolchain { toolchain ->
        toolchain.languageVersion.set(JavaLanguageVersion.of(8))
    }
}

interface Constants {
    def CODE_GENERATION_TASK_GROUP = 'code generation'
    // this is to improve code searching
    def CODE_GENERATION_TARGET_DIRECTORY =
            'info.fingo.xactus.processor.internal'.replaceAll(Pattern.quote('.'), '/')
    def PGP_SECRET_KEY_PROPERTY_KEY = "pgpSecretKey"
    def PGP_SECRET_KEY_PASSWORD_PROPERTY_KEY = "pgpSecretKeyPassword"
    def PGP_KEY_ID_PROPERTY_KEY = "pgpKeyId"
    def OSSRH_USER_NAME_PROPERTY_KEY_PREFIX = "ossrhUserName"
    def OSSRH_PASSWORD_PROPERTY_KEY_PREFIX = "ossrhPassword"
    def PUBLICATION_NAME = 'mavenJava'
}

def generateJFlexTaskProvider = tasks.register('generateJFlex', JavaExec) {
    jFlexExec ->
        def outputDirectory = "${project.layout.buildDirectory.get()}/jflex-generated"
        def classesDestinationDirectory = file("$outputDirectory/$Constants.CODE_GENERATION_TARGET_DIRECTORY")
        def inputFile = file('src/main/jflex/xpath.lex')

        jFlexExec.group Constants.CODE_GENERATION_TASK_GROUP
        jFlexExec.classpath(configurations.named('jflex'))

        jFlexExec.inputs.file(inputFile)
        jFlexExec.outputs.dir("$outputDirectory")
        jFlexExec.outputs.cacheIf { true }

        jFlexExec.workingDir = classesDestinationDirectory

        jFlexExec.args '-d', classesDestinationDirectory.absolutePath, inputFile.absolutePath
        jFlexExec.mainClass.set 'jflex.Main'

        jFlexExec.doFirst {
            classesDestinationDirectory.mkdirs()
        }
}

def generateJCupTaskProvider = tasks.register('generateJCup', JavaExec) {
    jCupExec ->
        def outputDirectory = "${project.layout.buildDirectory.get()}/jcup-generated"
        def classesDestinationDirectory = file("$outputDirectory/$Constants.CODE_GENERATION_TARGET_DIRECTORY")
        def inputFile = file('src/main/jcup/xpath.cup')

        jCupExec.group Constants.CODE_GENERATION_TASK_GROUP

        jCupExec.classpath(configurations.named('jcup'))
        jCupExec.mainClass.set 'java_cup.Main'

        jCupExec.workingDir = classesDestinationDirectory

        jCupExec.inputs.file(inputFile)
        jCupExec.outputs.dir("$outputDirectory")
        jCupExec.outputs.cacheIf { true }

        jCupExec.args '-symbols', 'XpathSym', '-parser', 'XPathCup', inputFile.absolutePath

        jCupExec.doFirst {
            classesDestinationDirectory.mkdirs()
        }
}

sourceSets.main.java {
    SourceDirectorySet sourceDirectorySet ->
        sourceDirectorySet.srcDir(generateJCupTaskProvider)
        sourceDirectorySet.srcDir(generateJFlexTaskProvider)
}

configurations {
    jflex
    jcup
    implementation.extendsFrom jcup
}

tasks.named('test', Test).configure {
    it.filter {
        // exclude test suites
        it.excludeTestsMatching('*.All*Tests')
        it.excludeTestsMatching('info.fingo.xactus.processor.testutil.legacytestsuiteadapter.PsychopathTestContext')
    }
}

tasks.register('testSuite', Test).configure {
    it.filter {
        it.includeTestsMatching('*.All*Tests')
    }
}

tasks.withType(Test).configureEach {
    it.filter {
        // exclude disabled junit 3 tests
        it.excludeTestsMatching('*.disabled_*')
    }

    it.outputs.cacheIf { false }
    it.outputs.upToDateWhen { false }

    it.useJUnitPlatform()

    it.systemProperty 'junit.jupiter.execution.parallel.enabled', 'true'
    it.systemProperty 'junit.jupiter.execution.parallel.mode.default', 'same_thread'
    it.systemProperty 'junit.jupiter.execution.parallel.mode.classes.default', 'concurrent'
    it.systemProperty 'junit.jupiter.execution.parallel.config.strategy', 'dynamic'
}

extensions.configure(JavaPluginExtension) {
    it.withJavadocJar()
    it.withSourcesJar()
}

extensions.configure(PublishingExtension) { publishingExtension ->
    publishingExtension.repositories.maven { MavenArtifactRepository repo ->
        repo.name = 'local'
        repo.url = uri(isSnapshot() ? "${project.layout.buildDirectory.get()}/repos/snapshots" : "${project.layout.buildDirectory.get()}/repos/releases")
    }

    publishingExtension.publications.register(Constants.PUBLICATION_NAME, MavenPublication) {
        mavenPublication ->
            mavenPublication.from(project.components.getByName('java'))
            mavenPublication.pom { mavenPom ->
                mavenPom.name = 'Xactus'
                mavenPom.url = 'https://github.com/fingo/xactus'
                mavenPom.description = 'Open-source XPath 2.0 processing library based on Eclipse\'s implementation from the Eclipse Web Tools Platform project.'
                mavenPom.developers { mavenPomDeveloperSpec ->
                    mavenPomDeveloperSpec.developer { mavenPomDeveloper ->
                        mavenPomDeveloper.name = 'Janusz Wiśniowski'
                        mavenPomDeveloper.email = 'janusz@januszwisniowski.it'
                    }
                }
                mavenPom.licenses { licenseSpec ->
                    licenseSpec.license { license ->
                        license.name = 'Eclipse Public License - v 2.0'
                        license.url = 'https://www.eclipse.org/legal/epl-2.0/'
                    }
                }
                mavenPom.scm { mavenPomScm ->
                    mavenPomScm.url = 'https://github.com/fingo/xactus'
                    mavenPomScm.connection = 'scm:git:git://github.com/fingo/xactus'
                }
            }
    }
}

if (!isSnapshot()) {
    extensions.configure(SigningExtension) {
        if (project.hasProperty(Constants.PGP_SECRET_KEY_PROPERTY_KEY) &&
                project.hasProperty(Constants.PGP_SECRET_KEY_PASSWORD_PROPERTY_KEY)) {
            def pgpSecretKey = project.property(Constants.PGP_SECRET_KEY_PROPERTY_KEY).toString()
            def pgpKeyPassword = project.property(Constants.PGP_SECRET_KEY_PASSWORD_PROPERTY_KEY).toString()

            if (project.hasProperty(Constants.PGP_KEY_ID_PROPERTY_KEY)) {
                it.useInMemoryPgpKeys(project.property(Constants.PGP_KEY_ID_PROPERTY_KEY).toString(), pgpSecretKey, pgpKeyPassword)
            } else {
                it.useInMemoryPgpKeys(pgpSecretKey, pgpKeyPassword)
            }
        }

        it.sign(extensions.findByType(PublishingExtension).publications.getByName(Constants.PUBLICATION_NAME))
    }
}

tasks.named('javadoc', Javadoc).configure {
    it.failOnError = false
    it.options.encoding = 'UTF-8'
}

tasks.withType(JavaCompile).configureEach {
    it.options.with {
        it.encoding = 'UTF-8'
        it.compilerArgs << '-Xlint'
        it.deprecation = true
    }
}

dependencies {
    implementation libs.xerces
    implementation libs.icu4j
    jcup libs.jcup
    jflex libs.jflex

    testImplementation testLibs.bundles.jupiter
    testImplementation testLibs.bundles.xmlunit
    testImplementation testLibs.bundles.mockito

    testImplementation testLibs.bundles.assertj
    // LSSerializerImpl used to serialize ResultSequence to XML - see AbstractPsychoPathTest#buildXMLResultString
    testImplementation libs.xalan.serializer
}

@SuppressWarnings('GrMethodMayBeStatic')
def getDeploymentVersion() {
    scmVersion.version
}

def isSnapshot() {
    deploymentVersion.toString().endsWith("-SNAPSHOT")
}