build.gradle

import com.github.spotbugs.SpotBugsTask
import io.zucchini.build.docker.DockerPlugin
import io.zucchini.build.node.NodePlugin
import io.zucchini.build.node.YarnTask

buildscript {

    repositories {
        maven {
            url 'https://plugins.gradle.org/m2/'
        }
        jcenter()
    }

}

plugins {
    id 'com.github.ben-manes.versions' version '0.27.0'
    id 'com.google.osdetector' version '1.6.2'
    id 'org.ajoberstar.grgit' version '4.0.1'
    id 'com.github.spotbugs' version '3.0.0' apply false
    id 'com.github.johnrengelman.shadow' version '5.2.0' apply false
}

/**
 * Replace version used by a group of dependencies.
 *
 * @param details Dependency details
 * @param group Group of the dependency
 * @param version Version to set
 */
void replaceDependencyGroupVersion(DependencyResolveDetails details, String group, String version) {
    if (details.requested.group == group || details.requested.group.startsWith(group + '.')) {
        details.useVersion version
    }
}


allprojects {

    group = 'io.zucchini-ui'

    apply plugin: 'idea'
    apply plugin: DockerPlugin
    apply plugin: NodePlugin
    apply plugin: 'com.github.ben-manes.versions'

    repositories {
        mavenLocal()
        mavenCentral()
    }

    ext.getDockerTags = {
        List<String> dockerTags = []

        // Branch slug, without special characters
        String branchName = project.grgit.branch.current.name
        String branchSlug = branchName.replace('/', '-')

        // If the Git branch is the master branch, then the Docker image will be tagged "latest"
        dockerTags << "branch-${branchSlug}"
        if (branchName == 'master') {
            dockerTags << 'latest'
        }

        return dockerTags
    }

    // Plugins to use with the java plugin

    afterEvaluate {

        if (project.pluginManager.hasPlugin('java')) {

            // Add common dependencies

            project.dependencies {

                testImplementation 'junit:junit:4.13'
                testImplementation 'org.assertj:assertj-core:3.15.0'
                testImplementation 'org.mockito:mockito-core:3.2.4'

            }

            // Maven plugin

            project.apply plugin: 'maven-publish'

            // PMD plugin

            project.apply plugin: 'pmd'

            project.pmd {
                ignoreFailures = true
            }

            tasks.withType(Pmd) {
                reports {
                    xml.enabled = false
                    html.enabled = true
                }
            }

            // Spotbugs plugin
            // Only on JDK < 11
            if (JavaVersion.current() <= JavaVersion.VERSION_11) {
                project.apply plugin: 'com.github.spotbugs'

                project.spotbugs {
                    ignoreFailures = true
                    effort = 'max'
                }

                tasks.withType(SpotBugsTask) {
                    reports {
                        xml.enabled = false
                        html.enabled = true
                    }
                }
            }

        }

        // Shared Java compiler config
        project.tasks.withType(JavaCompile) {

            project.sourceCompatibility = '11'
            project.targetCompatibility = '11'

            options.encoding = 'UTF-8'
            options.deprecation = true
            options.compilerArgs << '-parameters'
            options.compilerArgs << '-Werror'

        }

    }

    configurations.all {

        resolutionStrategy {

            // Replace commons logging by slf4j, if present
            dependencySubstitution {
                substitute module('commons-logging:commons-logging') with module('org.slf4j:jcl-over-slf4j:1.7.26')
            }

            // Override some dependency versions
            eachDependency { DependencyResolveDetails details ->
                replaceDependencyGroupVersion(details, 'org.slf4j', '1.7.26')
            }

        }

    }

    // Remove milestones, release candidates, etc from dependency updates check
    dependencyUpdates.resolutionStrategy = {
        componentSelection { rules ->
            rules.all { ComponentSelection selection ->
                boolean rejected = ['alpha', 'beta', 'rc', 'cr', 'm'].any { qualifier ->
                    selection.candidate.version ==~ /(?i).*-${qualifier}.*/
                }
                if (rejected) {
                    selection.reject('Release candidate')
                }
            }
        }
    }


}


project("${rootProject.name}-backend") {

    apply plugin: 'java'

    dependencies {

        annotationProcessor 'org.hibernate:hibernate-validator-annotation-processor:6.1.2.Final'

        implementation 'io.dropwizard:dropwizard-core:2.0.1'
        implementation 'ma.glasnost.orika:orika-core:1.5.4'
        implementation 'xyz.morphia.morphia:core:1.4.0'
        implementation 'xyz.morphia.morphia:logging-slf4j:1.4.0'
        implementation 'org.slf4j:slf4j-api:1.7.30'
        implementation 'org.springframework:spring-context:5.2.3.RELEASE'
        implementation 'org.eclipse.jetty.websocket:javax-websocket-server-impl:9.4.18.v20190429'
        implementation 'org.apache.commons:commons-text:1.8'

        implementation 'com.rabbitmq:amqp-client:5.9.0'

        implementation 'org.javassist:javassist:3.26.0-GA'

        implementation 'javax.xml.bind:jaxb-api:2.3.1'
        runtimeOnly 'org.glassfish.jaxb:jaxb-runtime:2.3.2'

        testImplementation 'org.assertj:assertj-core:3.12.2'
        testImplementation 'com.pholser:junit-quickcheck-core:0.9.1'
        testImplementation 'com.pholser:junit-quickcheck-generators:0.9.1'

    }

    task runBackend(type: JavaExec, description: 'Run backend server') {

        classpath = sourceSets.main.runtimeClasspath

        main = 'io.zucchiniui.backend.BackendApplication'

        args += ['serve', "${rootDir}/server-config.yml"]
    }

    task runJsonImporter(type: JavaExec, description: 'Execute JsonImportTest') {

        classpath = sourceSets.main.runtimeClasspath

        main = 'io.zucchiniui.backend.JsonImportTest'

        if (project.hasProperty('jsonFilePath')) {
            args = [jsonFilePath]
        }
    }
}


project("${rootProject.name}-frontend") {

    apply plugin: 'java'

    project.sourceSets.main.resources.srcDir("$project.buildDir/ui-resources")

    task webpack(type: YarnTask, description: 'Run Webpack') {
        command = 'run'
        args = ['build']

        inputs.dir('src')
        inputs.file('yarn.lock')
        inputs.file('postcss.config.js')
        inputs.file('webpack.config.js')
        inputs.file('babel.config.js')
        inputs.file('.browserslistrc')

        outputs.dir('build/dist')
    }

    task jsTest(type: YarnTask, description: 'Test JavaScript') {
        command = 'test'

        inputs.dir('src')
        inputs.dir('test')
        inputs.file('package.json')
    }

    task copyAssets(type: Copy, dependsOn: webpack) {
        from 'build/dist'
        into "$project.buildDir/ui-resources/ui"
    }

    task copyIndexHtml(type: Copy) {
        from 'index.html'
        into "$project.buildDir/ui-resources/ui"
    }

    tasks.processResources.dependsOn(copyAssets, copyIndexHtml)
    tasks.test.dependsOn jsTest

}


project("${rootProject.name}-app") {

    apply plugin: 'java'
    apply plugin: 'application'
    apply plugin: 'com.github.johnrengelman.shadow'

    mainClassName = 'io.zucchiniui.app.ZucchiniUIApplication'

    dependencies {

        implementation project(":${rootProject.name}-backend")
        implementation project(":${rootProject.name}-frontend")
        implementation 'io.dropwizard:dropwizard-assets:2.0.1'

    }

    runShadow {
        args 'server', "${rootDir}/server-config.yml"
    }

    shadowJar {
        mergeServiceFiles()
        exclude 'META-INF/*.DSA'
        exclude 'META-INF/*.RSA'
    }

   tasks.assemble.dependsOn shadowJar

    docker {
        name = rootProject.name
        tags += project.getDockerTags()
    }

    dockerBuild {
        buildArg 'ZUCCHINI_VERSION': "${project.version}"
    }

    dockerComposeUp {
        detach = true
        environment 'ZUCCHINI_VERSION': "${project.version}"
    }

}


project("${rootProject.name}-example-features") {

    apply plugin: 'java'

    dependencies {

        implementation 'info.cukes:cucumber-java:1.2.6'
        implementation 'org.slf4j:slf4j-api:1.7.26'
        implementation 'org.assertj:assertj-core:3.12.2'
        implementation 'com.google.guava:guava:28.2-jre'

    }

    task runCucumber(type: JavaExec, description: 'Run Cucumber features') {

        classpath = sourceSets.main.runtimeClasspath

        main = 'cucumber.api.cli.Main'

        args += [
            '--glue', 'classpath:io.zucchini.examples.glues',
            '--plugin', 'pretty',
            '--plugin', "html:${project.buildDir}/cucumber/html",
            '--plugin', "json:${project.buildDir}/cucumber/report.json",
            '--tags', '~@ignored',
            'src/features',
        ]

        ignoreExitValue true

    }

    task dryRunCucumber(type: JavaExec, description: 'Dry run Cucumber features') {

        classpath = sourceSets.main.runtimeClasspath

        main = 'cucumber.api.cli.Main'

        args += [
            '--glue', 'classpath:io.zucchini.examples.glues',
            '--plugin', 'pretty',
            '--plugin', "html:${project.buildDir}/cucumber-dry/html",
            '--plugin', "json:${project.buildDir}/cucumber-dry/report.json",
            '--dry-run',
            'src/features',
        ]

        ignoreExitValue true

    }

}


project("${rootProject.name}-mongo") {

    docker {
        tags += project.getDockerTags()
    }

}


project("${rootProject.name}-e2e-tests") {

    task jsTest(type: YarnTask, description: 'Test E2E') {
        command = 'test'
    }

}