build.gradle

/*
 * MIT License
 *
 * Copyright (c) 2022-2023 TweetWallFX
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

plugins {
    id 'base'
    id 'build-dashboard'
    id 'java-platform'
    id 'com.diffplug.spotless' version '6.22.0'
    id 'com.github.ben-manes.versions' version '0.49.0'
    id 'com.github.spotbugs' version '5.2.1' apply false
    id 'com.google.osdetector' version '1.7.3'
    id 'com.netflix.nebula.info' version '12.1.6' apply false
    id 'com.netflix.nebula.maven-base-publish' version '20.3.0' apply false
    id 'net.ltgt.errorprone' version '3.1.0' apply false
    id 'org.sonarqube' version '4.4.1.3373'
    id 'com.autonomousapps.dependency-analysis' version '1.25.0'
}

ext {
    javaFxPlatform = osdetector.os == 'osx' ? 'mac' : osdetector.os == 'windows' ? 'win' : osdetector.os
    javaFxPlatform = osdetector.arch == 'aarch_64' ? javaFxPlatform + '-aarch64' : javaFxPlatform
}

javaPlatform {
    allowDependencies()
}

dependencies {
    api platform('org.junit:junit-bom:5.10.0')
    api platform('org.apache.logging.log4j:log4j-bom:2.21.1')

    constraints {
        api 'com.github.spotbugs:spotbugs-annotations:4.8.0'
        api 'jakarta.ws.rs:jakarta.ws.rs-api:3.1.0'
        api 'org.slf4j:slf4j-api:2.0.9'
    }
}

allprojects {
    int[] versionSplit = currentVersion.split('[.]').collect{it as int}
    assert 3 == versionSplit.length : 'currentVersion property requires all three version parts (major, minor, patch)'

    group = mavenGroupName
    version = String.format('release' == System.getenv('GITHUB_REF_NAME') ? '%d.%d.%d' : '%d.%d-SNAPSHOT', versionSplit)
    description = "${projectDescriptionBase} (${name})"

    repositories {
        mavenCentral()
        jcenter()
    }

    // configuring Spotless
    apply plugin: 'com.diffplug.spotless'

    afterEvaluate {
        spotless {
            if (!System.env.CI) {
                // https://docs.github.com/en/actions/learn-github-actions/environment-variables#default-environment-variables
                // only format files which have changed since this ref
                // TODO: Figure out a way to get this working in CI (i.e. Github Workflows)
                ratchetFrom 'origin/main'
            }

            format 'textBasedFiles', {
                target(
                    '*.gradle',
                    '**/*.gradle',
                    '**/*.asciidoc',
                    '**/*.adoc',
                    '**/*.asc',
                    '**/*.css',
                    '**/*.json',
                    '**/*.md',
                    '**/*.properties',
                    '.gitignore',
                )
                targetExclude(
                    '.*/**',
                )

                trimTrailingWhitespace()
                indentWithSpaces(4)
                endWithNewline()
                replaceRegex 'noMultipleEmptyLines', '\n{3,}', '\n\n'
            }

            def closure = {
                trimTrailingWhitespace()
                indentWithSpaces(4)
                endWithNewline()
                importOrder(
                    '\\#',    // static imports
                    'com',   // classes from com root package
                    'java',   // classes from java root package
                    'javafx',  // classes from javafx root package
                    'javax',  // classes from javax root package
                    'jakarta',  // classes from javax root package
                    'org',  // classes from org root package
                    '',       // any other import
                )
                replaceRegex 'noStarImports', /\nimport (static )?[a-zA-Z0-9.]*[.][\*];\n/, '\n'
                replaceRegex 'noMultipleEmptyLines', '\n{3,}', '\n\n'
                replaceRegex 'Remove @author javadoc taglets.', '\n\\s*\\*\\s*@author.*', ''
                replaceRegex 'Remove trailing empty comment lines.', '\n\\s*\\*(\n\\s*\\*/\n)', '$1'
                replaceRegex 'Remove empty javadoc', '\n\\s*/\\*\\*\n\\s*\\*/\n', '\n\n'
                replaceRegex 'Remove empty lines before end of block', '\\n[\\n]+(\\s*})(?=\\n)', '\n$1'
                licenseHeaderFile rootProject.file('LICENSE.spotlessJavaTemplate')
            }

            if (plugins.hasPlugin(GroovyPlugin)) {
                groovy(closure)
            } else if (plugins.hasPlugin(JavaPlugin)) {
                java(closure)
            }
        }

        tasks.named('check') {
            dependsOn spotlessCheck
        }
    }

    // configuring dependencyAnalysis
    plugins.withType(com.autonomousapps.DependencyAnalysisPlugin) {
        if (rootProject == project) {
            dependencyAnalysis {
                issues {
                    all { // applies to all projects
                        onUsedTransitiveDependencies {
                            severity 'ignore'
                        }
                        onUnusedDependencies {
                            severity 'warn' // default
                        }
                        onRedundantPlugins {
                            severity 'fail'
                        }
                    }
                }
            }

            afterEvaluate {
                tasks.named('buildHealth').configure {
                    printBuildHealth = true
                }
            }
        }
    }

    // now configuring for projects that contain code not just structuring the project
    if (childProjects.isEmpty()) {
        // configuring standard java project
        apply plugin: 'java-library'
        apply plugin: 'idea'
        apply plugin: 'jacoco'
        apply plugin: 'eclipse'
        apply plugin: 'com.netflix.nebula.info'
        apply plugin: 'maven-publish'

        java {
            withJavadocJar()
            withSourcesJar()
            toolchain {
                languageVersion.set(JavaLanguageVersion.of(Integer.parseInt(System.getenv('JAVA_PLATFORM_VERSION') ?: '17')))
            }
        }

        jacoco {
            toolVersion = '0.8.10'
        }

        configurations {
            javafx {
                description = 'Java FX libraries'
            }
            jaxb {
                description = 'JAXB libraries'
            }

            all {
                resolutionStrategy.eachDependency { DependencyResolveDetails details ->
                    if (details.requested.group == 'org.ow2.asm' &&
                        details.requested.name == 'asm') {
                        details.useVersion '9.5'
                        details.because 'workaround for spotbugs not yet supporting JDK 21 class formats'
                    }
/*
                    if (details.requested.group == 'com.fasterxml.jackson' &&
                        details.requested.name == 'jackson-bom' &&
                        details.requested.version == '2.13.2.1') {
                        details.useVersion '2.13.2.20220324'
                        details.because 'fixes CVE-2020-36518 and resolved version does not (pom) match expectation'
                    }
*/
                }
            }

            compileOnly {
                extendsFrom configurations.javafx
            }

            testFramework {
                description = 'Libraries for testing'
                // exclude old junit api
                exclude group: 'junit'
            }
            testImplementation.extendsFrom testFramework
        }

        dependencies {
            // get recommended versions from the platform project
            api platform(rootProject)

            javafx group: 'org.openjfx', name: 'javafx-base', version: '21.0.1', classifier: javaFxPlatform
            javafx group: 'org.openjfx', name: 'javafx-graphics', version: '21.0.1', classifier: javaFxPlatform
            javafx group: 'org.openjfx', name: 'javafx-fxml', version: '21.0.1', classifier: javaFxPlatform
            javafx group: 'org.openjfx', name: 'javafx-controls', version: '21.0.1', classifier: javaFxPlatform

            jaxb 'jakarta.activation:jakarta.activation-api:2.1.2'
            jaxb 'org.eclipse.angus:angus-activation:2.0.1'
            jaxb 'jakarta.xml.bind:jakarta.xml.bind-api:4.0.1'
            jaxb 'org.glassfish.jaxb:jaxb-runtime:4.0.4'

            testFramework 'org.assertj:assertj-core:3.24.2'
            testFramework 'org.junit.jupiter:junit-jupiter-api'
            testFramework 'org.junit.jupiter:junit-jupiter-params'
            testFramework 'org.mockito:mockito-junit-jupiter:5.6.0'

            testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine'
            testRuntimeOnly 'org.junit.platform:junit-platform-runner'
            testRuntimeOnly 'org.mockito:mockito-inline:5.2.0'
        }

        ext {
            getJvmModulePath = { -> (configurations.javafx + configurations.jaxb).asPath}
            getJvmAdditionalModules = { ->
                [
                    'jakarta.activation',
                    'jakarta.xml.bind',
                    'javafx.controls',
                    'javafx.fxml',
                    'javafx.graphics',
                ].toUnique().toSorted().join(',')
            }
        }

        tasks.named('jar') {
            manifest.attributes provider: 'gradle'
        }

        tasks.named('javadoc') {
            options.addStringOption('-module-path', getJvmModulePath())
            options.addStringOption('-add-modules', getJvmAdditionalModules())
            enabled = false // TODO: re-enable (currently breaks build with ClassCastException)
        }

        tasks.withType(JavaCompile).configureEach {
            options.compilerArgs.addAll([
                    // lint everithing except preview (as using preview features would generate a warnig and thus break the build)
                    '-Xlint:all,-preview',
                    '--enable-preview',
                    '-Werror',
                    '-proc:none',
                    '--module-path',
                    getJvmModulePath(),
                    '--add-modules',
                    getJvmAdditionalModules(),
            ])
        }

        tasks.withType(JavaExec).configureEach {
            jvmArgs '--enable-preview'
            jvmArgs '--module-path'
            jvmArgs getJvmModulePath()
            jvmArgs '--add-modules'
            jvmArgs getJvmAdditionalModules()
            jvmArgs '--add-opens'
            jvmArgs 'java.base/jdk.internal.misc=ALL-UNNAMED'
        }

        tasks.withType(Test).configureEach {
            jvmArgs '--enable-preview'
            jvmArgs '--module-path'
            jvmArgs getJvmModulePath()
            jvmArgs '--add-modules'
            jvmArgs getJvmAdditionalModules()
            systemProperty 'org.tweetwallfx.tests.executeConferenceClientLiveTests', executeConferenceClientLiveTests

            useJUnitPlatform()
            testLogging {
                events 'skipped', 'passed', 'failed'
            }
        }

        tasks.named('check') {
            dependsOn javadoc
        }

        if (!JavaVersion.current().isCompatibleWith(JavaVersion.VERSION_18)) {
            // jacoco not yet compatible with JDK18
            tasks.named('test') {
                finalizedBy jacocoTestReport
            }
        }

        // configuring Errorprone
        apply plugin: 'net.ltgt.errorprone'

        dependencies {
            errorprone 'com.google.errorprone:error_prone_core:2.23.0'
        }

        if (System.env.CI || project.findProperty('applySpotbugs')) {
            // configuring Spotbugs
            apply plugin: 'com.github.spotbugs'

            tasks.withType(com.github.spotbugs.snom.SpotBugsTask).configureEach {
                // fail build in case a failure was detected
                ignoreFailures = false

                jvmArgs.add '--module-path'
                jvmArgs.add getJvmModulePath()
                jvmArgs.add '--add-modules'
                jvmArgs.add getJvmAdditionalModules()

                excludeFilter = rootProject.file('spotbugs-exclude.xml')

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

                auxClassPaths = auxClassPaths + configurations.javafx + configurations.jaxb
            }
        }

        // configuring Versions plugin
        tasks.withType(com.github.benmanes.gradle.versions.updates.DependencyUpdatesTask).configureEach {
            outputFormatter = 'plain,html'
            gradleReleaseChannel = 'current'

            resolutionStrategy {
                def rejectedQualifierParts = ['alpha', 'beta', 'rc', 'cr', 'm', 'preview', 'b', 'pr', 'ea']
                componentSelection { rules ->
                    rules.all { ComponentSelection selection ->
                        boolean rejected = rejectedQualifierParts.any { qualifier ->
                            selection.candidate.version ==~ /(?i).*[.-]${qualifier}[.\d-+]*/
                        }
                        if (rejected) {
                            selection.reject('Release candidate')
                        }
                    }
                }
            }
        }

        plugins.withType(GroovyPlugin) {
            dependencies {
                implementation 'org.codehaus.groovy:groovy-all:4.0.2'
                testFramework 'org.spockframework:spock-core:2.3-groovy-4.0'
            }
        }

        apply plugin: 'com.netflix.nebula.maven-base-publish'
        apply plugin: 'com.netflix.nebula.publish-verification'
    }
}

if (extensions.findByName('buildScan')) {
    buildScan {
        termsOfServiceUrl = 'https://gradle.com/terms-of-service'
        termsOfServiceAgree = 'yes'
    }
}

tasks.register('createFolders') {
    description = 'Creates the folders for the projects and sourceSets should they not exist.'

    rootProject.allprojects.each {p ->
        if (!p.getProjectDir().isDirectory()) {
            logger.lifecycle 'Creating project folder: {}', p.getProjectDir()
            p.getProjectDir().mkdirs()
        }

        if (p.hasProperty('sourceSets')) {
            p.sourceSets*.allSource*.srcDirs*.each { File srcDir ->
                if (!srcDir.isDirectory()) {
                    logger.lifecycle 'Creating source folder: {}', srcDir
                    srcDir.mkdirs()
                }
            }
        }
    }
}

subprojects { project ->
    if (!project.projectDir.name.contains('-') &&
        new File(project.projectDir, 'src/main/resources').listFiles().collect().find{it.name.endsWith('.css')}) {
        plugins.withType(JavaPlugin) {
            rootProject.tasks.register('run' + project.projectDir.name.capitalize()) {
                group = 'Runner'
                description = 'Runs the ' + project.projectDir.name.capitalize() + ' Tweetwall'
                dependsOn project.path + ':run'
            }
        }
    }
}