build.gradle

buildscript {
    repositories {
        mavenCentral()
        gradlePluginPortal()
    }
    dependencies {
        classpath 'ru.vyarus:gradle-quality-plugin:4.7.0'
        classpath 'pl.allegro.tech.build:axion-release-plugin:1.14.2'
        classpath 'io.github.gradle-nexus:publish-plugin:1.1.0'
        classpath 'com.diffplug.spotless:spotless-plugin-gradle:6.13.0' // above this version requires Java 11
    }
}
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 = 'SRU2023'
}

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

tasks.withType(JavaCompile) {
    options.encoding = 'UTF-8'
    java {
        toolchain {
            languageVersion.set(JavaLanguageVersion.of(8))
        }
    }
    doFirst {
        println 'Compiling with ' + getJavaCompiler().get().getMetadata().getInstallationPath()
    }
}

repositories {
    mavenCentral()
}

dependencies {
    implementation 'org.apache.commons:commons-lang3:3.12.0'
    implementation 'com.google.code.gson:gson:2.9.0'

    compileOnly 'javax.persistence:javax.persistence-api:2.2'
    compileOnly 'javax.xml.bind:jaxb-api:2.3.1'
    compileOnly 'javax.validation:validation-api:2.0.1.Final'

    testImplementation 'javax.persistence:javax.persistence-api:2.2'
    testImplementation('org.junit.jupiter:junit-jupiter:5.8.2')
    testImplementation group: 'org.assertj', name: 'assertj-core', version: '3.22.0'
    testImplementation group: 'org.xmlunit', name: 'xmlunit-core', version: '2.9.0'
    testImplementation group: 'org.xmlunit', name: 'xmlunit-matchers', version: '2.9.0'
    testImplementation group: 'org.xmlunit', name: 'xmlunit-assertj', version: '2.9.0'
}

sourceSets.main.java.srcDirs = ['src/main/java', 'src/generated/java']

test {
    useJUnitPlatform()
}

tasks.withType(Jar) {
    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': project.sourceCompatibility,
        'Target-Compatibility': project.targetCompatibility,
        '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
}

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 = 'http://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 = 'http://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) {
    // 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()
}
nexusPublishing {
    repositories {
        sonatype()
    }
}

// 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
}

// Alternative (manual) staging upload to OSS Sonatype
tasks.register('bundle', Jar) {
    dependsOn build
    onlyIf {
        project.hasProperty('SONATYPE_RELEASE')
    }
    description 'Creates the bundle.jar for Maven Central distribution'
    from jar
    from sourcesJar
    from javadocJar
    from ("$buildDir/publications/mavenJava/pom-default.xml") {
        rename ".*", "pom.xml"
    }
    from ("$buildDir/publications/mavenJava/pom-default.xml.asc") {
        rename ".*", "pom.xml.asc"
    }
    from ("$buildDir/libs") {
        include '*.asc'
    }
    archiveName 'bundle.jar'
}

tasks.withType(Test) {
    doFirst {
        println 'Running test on ' + getJavaLauncher().get().getMetadata().getInstallationPath()
    }
}

task('testOn11', type: Test) {
    javaLauncher = javaToolchains.launcherFor {
        languageVersion = JavaLanguageVersion.of(11)
    }
}

task('testOn17', type: Test) {
    javaLauncher = javaToolchains.launcherFor {
        languageVersion = JavaLanguageVersion.of(17)
    }
}

jacocoTestReport {
    reports {
        xml.enabled true
        csv.enabled false
        html.enabled 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)