build.gradle

buildscript {
    repositories {
        mavenCentral()
        gradlePluginPortal()
    }
    dependencies {
        classpath 'ru.vyarus:gradle-quality-plugin:6.1.0'
        classpath 'pl.allegro.tech.build:axion-release-plugin:1.18.18'
        classpath 'io.github.gradle-nexus:publish-plugin:2.0.0'
        classpath 'com.diffplug.spotless:spotless-plugin-gradle:7.0.3'
    }
}
apply plugin: 'pl.allegro.tech.build.axion-release'
apply plugin: 'java-library-distribution'
apply plugin: 'maven-publish'
apply plugin: 'signing'
apply plugin: 'jacoco'
apply plugin: 'idea'
apply plugin: 'eclipse'
apply plugin: 'ru.vyarus.quality'
apply plugin: 'io.github.gradle-nexus.publish-plugin'

archivesBaseName = 'pw-swift-core'
group 'com.prowidesoftware'

project.ext {
    SRU = 'SRU2025'
}

scmVersion {
    versionCreator('simple')
    tag {
        prefix = SRU
        versionSeparator = '-'
    }
}
project.version = "${SRU}-${scmVersion.version}"

java {
    toolchain {
        languageVersion.set(JavaLanguageVersion.of(11))
    }
}

tasks.withType(JavaCompile).configureEach {
    options.encoding = 'UTF-8'
    doFirst {
        println 'Compiling with ' + getJavaCompiler().get().getMetadata().getInstallationPath()
    }
}

repositories {
    mavenCentral()
}

dependencies {
    implementation 'org.apache.commons:commons-lang3:3.20.0'
    implementation 'org.apache.commons:commons-text:1.15.0'
    implementation 'com.google.code.gson:gson:2.14.0'

    // jakarta is only used for annotations, we do not add it as implementation dependency on purpose to avoid forcing
    // users to use jakarta jars in their project when they might not even be using JPA or JAXB at all
    compileOnly 'jakarta.persistence:jakarta.persistence-api:3.1.0' // jakarta 3.1 is Jakarta EE 10, jakarta 3.2 would imply migration to Jakarta EE 11
    compileOnly 'jakarta.xml.bind:jakarta.xml.bind-api:4.0.5'
    compileOnly 'jakarta.validation:jakarta.validation-api:3.1.1'

    testImplementation 'com.networknt:json-schema-validator:2.0.4'
    testImplementation 'jakarta.persistence:jakarta.persistence-api:3.1.0'
    testImplementation 'jakarta.validation:jakarta.validation-api:3.1.1'
    testImplementation 'org.junit.jupiter:junit-jupiter:5.14.4'
    testImplementation 'org.junit.platform:junit-platform-launcher:1.14.4'
    testImplementation 'org.assertj:assertj-core:3.27.6'
    testImplementation 'org.xmlunit:xmlunit-core:2.13.0'
    testImplementation 'org.xmlunit:xmlunit-matchers:2.13.0'
    testImplementation 'org.xmlunit:xmlunit-assertj:2.13.0'
}

sourceSets.named('main') {
    java {
        setSrcDirs(['src/main/java', 'src/generated/java'])
    }
}

test {
    useJUnitPlatform()
}

tasks.withType(Jar).configureEach {
    manifest.attributes(
        'Specification-Title': 'Prowide Core',
        'Specification-Version': project.version,
        'Specification-Vendor': "${SRU}",
        'Implementation-Title': 'Prowide Core',
        'Implementation-Version': project.version,
        'Implementation-Vendor': 'www.prowidesoftware.com',
        'Built-OS': System.getProperty('os.name'),
        'Source-Compatibility': JavaVersion.VERSION_11,
        'Target-Compatibility': JavaVersion.VERSION_11,
        'Built-Date': new Date().format("yyyy-MM-dd"),
        'Automatic-Module-Name': 'com.prowidesoftware.core'
    )
}

tasks.register('sourcesJar', Jar) {
    dependsOn classes
    archiveClassifier = 'sources'
    from sourceSets.main.allSource
}

static def formattedDate() {
    new Date().format('dd MMM yyyy')
}

javadoc {
    failOnError true
    options.overview = "overview.html"
    options.header = "${version}"
    options.windowTitle = "Prowide Core API Reference"
    options.footer="${SRU}, generated ${formattedDate()}"

    // this will fail when the option is not available (older JDK)
    options.addBooleanOption("-allow-script-in-comments", true)

    options.bottom = '<script src="//static.getclicky.com/js"></script><script>try{ clicky.init(101039278); }catch(e){}</script>'
    exclude "**/internal/**"

    options.addStringOption('Xdoclint:none', '-quiet')
}

tasks.register('javadocJar', Jar) {
    dependsOn javadoc
    archiveClassifier = 'javadoc'
    from javadoc.destinationDir
}

artifacts {
    archives javadocJar, sourcesJar
}

project.ext {
    nexusRepo = project.version.endsWith('-SNAPSHOT') ? 'maven-snapshots' : 'maven-releases'
}

publishing {
    publications {
        mavenJava(MavenPublication) {
            versionMapping {
                usage('java-api') {
                    fromResolutionOf('runtimeClasspath')
                }
                usage('java-runtime') {
                    fromResolutionResult()
                }
            }
            afterEvaluate {
                from components.java
                artifactId = 'pw-swift-core'
                groupId = 'com.prowidesoftware'
                version = "${version}"
                pom {
                    name = 'Prowide Core'
                    description = 'Prowide Library for SWIFT messages'
                    url = 'https://www.prowidesoftware.com'
                    scm {
                        url = 'https://github.com/prowide/prowide-core.git'
                        connection = 'git@github.com:prowide/prowide-core.git'
                    }
                    inceptionYear = '2006'
                    licenses {
                        license {
                            name = 'Apache License Version 2.0'
                            url = 'https://www.apache.org/licenses/LICENSE-2.0'
                            distribution = 'repo'
                        }
                    }
                    developers {
                        developer {
                            id = 'zubri'
                            name = 'Sebastian Zubrinic'
                            email = 'sebastian@prowidesoftware.com'
                        }
                    }
                    organization {
                        name = 'Prowide'
                        url = 'https://www.prowidesoftware.com'
                    }
                }
            }
        }
    }

    // Prowide repo releases
    if (project.hasProperty('prowideRepo')) {
        repositories {
            maven {
                url "${project.prowideRepo}/repository/${nexusRepo}/"
                credentials {
                    username "${project.prowideRepoUser}"
                    password "${project.prowideRepoPass}"
                }
            }
        }
    } else {
        project.logger.info('Prowide publishing disabled because repository properties are undefined')
    }
}
jar.finalizedBy generatePomFileForMavenJavaPublication

tasks.withType(GenerateModuleMetadata).configureEach {
    // to avoid metadata in the generated pom.xml files
    enabled = false
}

// OSS Sonatype releases
signing {
    required { project.hasProperty('SONATYPE_RELEASE') }
    sign publishing.publications.mavenJava
}
java {
    withJavadocJar()
    withSourcesJar()
}

// Zip GitHub releases
distributions {
    main {
        contents {
            from javadocJar
            from sourcesJar
            into ('lib') {
                from (project.configurations.runtimeClasspath)
            }
            from files('LICENSE.txt')
            from files('CHANGELOG.md')
            from ("$buildDir/publications/mavenJava/pom-default.xml") {
                rename ".*", "pom.xml"
            }
        }
    }
}

distTar.enabled = false

distZip {
    dependsOn generatePomFileForMavenJavaPublication
    duplicatesStrategy = DuplicatesStrategy.EXCLUDE
}

tasks.register('generateChecksums') {
    dependsOn jar, sourcesJar, javadocJar, generatePomFileForMavenJavaPublication
    description 'Generates MD5 and SHA1 checksums for artifacts and POM'
    doLast {
        def filesToChecksum = [
                "${buildDir}/libs/${project.archivesBaseName}-${project.version}.jar",
                "${buildDir}/libs/${project.archivesBaseName}-${project.version}-sources.jar",
                "${buildDir}/libs/${project.archivesBaseName}-${project.version}-javadoc.jar",
                "${buildDir}/publications/mavenJava/pom-default.xml"
        ]

        filesToChecksum.each { filePath ->
            def file = file(filePath)
            if (file.exists()) {
                // Generate MD5
                def md5Digest = java.security.MessageDigest.getInstance('MD5')
                file.withInputStream { stream ->
                    byte[] buffer = new byte[8192]
                    int read
                    while ((read = stream.read(buffer)) > 0) {
                        md5Digest.update(buffer, 0, read)
                    }
                }
                def md5Checksum = md5Digest.digest().encodeHex().toString()
                new File("${file}.md5").text = md5Checksum

                // Generate SHA1
                def sha1Digest = java.security.MessageDigest.getInstance('SHA1')
                file.withInputStream { stream ->
                    byte[] buffer = new byte[8192]
                    int read
                    while ((read = stream.read(buffer)) > 0) {
                        sha1Digest.update(buffer, 0, read)
                    }
                }
                def sha1Checksum = sha1Digest.digest().encodeHex().toString()
                new File("${file}.sha1").text = sha1Checksum
            } else {
                throw new GradleException("File not found: ${filePath}")
            }
        }
    }
}

// Alternative (manual) upload artifact for Maven Central Repository
tasks.register('bundle', Zip) {
    dependsOn build, signMavenJavaPublication, generateChecksums
    onlyIf {
        project.hasProperty('SONATYPE_RELEASE')
    }
    description 'Creates the bundle.zip for Maven Central distribution with Maven Repository Layout'

    def baseName = "${project.archivesBaseName}-${project.version}"
    def mavenPath = "com/prowidesoftware/${project.archivesBaseName}/${project.version}/"

    into(mavenPath) {
        from("${buildDir}/libs/${baseName}.jar") { rename { "${baseName}.jar" } }
        from("${buildDir}/libs/${baseName}-sources.jar") { rename { "${baseName}-sources.jar" } }
        from("${buildDir}/libs/${baseName}-javadoc.jar") { rename { "${baseName}-javadoc.jar" } }
        from("${buildDir}/libs/${baseName}.jar.asc") { rename { "${baseName}.jar.asc" } }
        from("${buildDir}/libs/${baseName}-sources.jar.asc") { rename { "${baseName}-sources.jar.asc" } }
        from("${buildDir}/libs/${baseName}-javadoc.jar.asc") { rename { "${baseName}-javadoc.jar.asc" } }
        from("${buildDir}/libs/${baseName}.jar.md5") { rename { "${baseName}.jar.md5" } }
        from("${buildDir}/libs/${baseName}-sources.jar.md5") { rename { "${baseName}-sources.jar.md5" } }
        from("${buildDir}/libs/${baseName}-javadoc.jar.md5") { rename { "${baseName}-javadoc.jar.md5" } }
        from("${buildDir}/libs/${baseName}.jar.sha1") { rename { "${baseName}.jar.sha1" } }
        from("${buildDir}/libs/${baseName}-sources.jar.sha1") { rename { "${baseName}-sources.jar.sha1" } }
        from("${buildDir}/libs/${baseName}-javadoc.jar.sha1") { rename { "${baseName}-javadoc.jar.sha1" } }
        from("${buildDir}/publications/mavenJava/pom-default.xml") { rename { "${baseName}.pom" } }
        from("${buildDir}/publications/mavenJava/pom-default.xml.asc") { rename { "${baseName}.pom.asc" } }
        from("${buildDir}/publications/mavenJava/pom-default.xml.md5") { rename { "${baseName}.pom.md5" } }
        from("${buildDir}/publications/mavenJava/pom-default.xml.sha1") { rename { "${baseName}.pom.sha1" } }
    }
    archiveFileName.set('bundle.zip')
}

tasks.withType(Test).configureEach {
    // DeprecationUtils#setEnv reflects into java.lang.ProcessEnvironment (and falls back to
    // java.util.Collections$UnmodifiableMap) on purpose; open both packages so the JVM does
    // not print illegal-access warnings on JDK 11+.
    jvmArgs '--add-opens=java.base/java.lang=ALL-UNNAMED', '--add-opens=java.base/java.util=ALL-UNNAMED'
    doFirst {
        println 'Running test on ' + getJavaLauncher().get().getMetadata().getInstallationPath()
    }
}

tasks.register('testOn17', Test) {
    javaLauncher = javaToolchains.launcherFor {
        languageVersion = JavaLanguageVersion.of(17)
    }
}

tasks.register('testOn21', Test) {
    javaLauncher = javaToolchains.launcherFor {
        languageVersion = JavaLanguageVersion.of(21)
    }
}

// Runs the suite on a Java 25 toolchain to verify the Java 11 artifacts execute correctly on Java 25.
// Needed to catch JDK-version behavior changes (e.g. JDK 24 tightened the JAXP entity size limits) that
// cannot manifest on the Java 11/17/21 the build otherwise uses. JDK 25 must be available to the Gradle
// toolchain (CI passes -Porg.gradle.java.installations.paths=/pw/dev/jdk25).
tasks.register('testOn25', Test) {
    description = 'Runs tests using a Java 25 toolchain to verify compatibility'
    group = 'verification'
    useJUnitPlatform()
    javaLauncher = javaToolchains.launcherFor {
        languageVersion = JavaLanguageVersion.of(25)
    }
    testClassesDirs = sourceSets.test.output.classesDirs
    classpath = sourceSets.test.runtimeClasspath
    reports {
        html.required = true
        html.outputLocation = layout.buildDirectory.dir("reports/tests/testOn25")
    }
    binaryResultsDirectory = layout.buildDirectory.dir("test-results/testOn25")
    dependsOn testClasses
}

jacocoTestReport {
    reports {
        xml.required.set(true)
        csv.required.set(false)
        html.required.set(false)
    }

    // exclude generated code
    afterEvaluate {
        getClassDirectories().setFrom(classDirectories.files.collect {
            fileTree(dir: it, exclude: [
                '**/SchemeConstants**',
                '**/mt0xx/**',
                '**/mt1xx/**',
                '**/mt2xx/**',
                '**/mt3xx/**',
                '**/mt4xx/**',
                '**/mt5xx/**',
                '**/mt6xx/**',
                '**/mt7xx/**',
                '**/mt8xx/**',
                '**/mt9xx/**'
            ])
        })
    }
}

test.finalizedBy jacocoTestReport

quality {
    strict = false
    // we limit this to spotbugs for the moment
    checkstyle = false
    codenarc = false
    cpd = false
    pmd = false
    spotbugsEffort = 'min'
    spotbugsMaxRank = 8
}

apply plugin: 'com.diffplug.spotless'

spotless {
    java {
        target '**/src/main/java/**/*.java', '**/src/test/java/**/*.java'
        palantirJavaFormat()
    }
}

test.finalizedBy(spotlessCheck)