build.gradle

import io.zucchini.build.docker.DockerPlugin
import io.zucchini.build.node.NodePlugin
import io.zucchini.build.node.NPMTask


buildscript {

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

}

plugins {
    id 'com.github.ben-manes.versions' version '0.11.3' apply false
    id 'us.kirchmeier.capsule' version '1.0.2' apply false
    id 'com.google.osdetector' version '1.4.0' apply false
    id 'org.ajoberstar.grgit' version '1.5.1' 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: 'org.ajoberstar.grgit'
    apply plugin: DockerPlugin
    apply plugin: NodePlugin

    repositories {
        mavenLocal()
        mavenCentral()
    }

    ext.versions = [
        dropwizard     : '1.0.2',
        orika          : '1.4.6',
        morphia        : '1.2.1',
        slf4j          : '1.7.21',
        spring         : '4.3.3.RELEASE',
        junit          : '4.12',
        assertj        : '3.5.2',
        mockito        : '2.2.0',
        junitQuickcheck: '0.6.1',
        capsule        : '1.0.3',
        groovy         : '2.4.7',
        cucumberGroovy : '1.2.5',
        jetty          : '9.3.9.v20160517',
    ]

    ext.getDockerTag = {
        String branchName = project.grgit.branch.current.name
        if (branchName == 'master') {
            return 'latest'
        }
        return "branch-${branchName}"
    }

    // Plugins to use with the java plugin

    project.afterEvaluate {

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

            // Add common dependencies

            project.dependencies {

                testCompile "junit:junit:${project.versions.junit}"
                testCompile "org.assertj:assertj-core:${project.versions.assertj}"
                testCompile "org.mockito:mockito-core:${project.versions.mockito}"

            }

            // Maven plugin

            project.apply plugin: 'maven'

            // Versions plugin

            project.apply plugin: 'com.github.ben-manes.versions'

            // PMD plugin

            project.apply plugin: 'pmd'

            project.pmd {
                ignoreFailures = true
            }

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

            // Findbugs plugin

            project.apply plugin: 'findbugs'

            project.findbugs {
                effort = "max"

                ignoreFailures = true

            }

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

        }

        project.configurations.all {

            resolutionStrategy {

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

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

            }

        }

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

            project.sourceCompatibility = '1.8'

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

        }

    }

}


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

    apply plugin: 'java'

    dependencies {

        compile "io.dropwizard:dropwizard-core:${versions.dropwizard}"
        compile "ma.glasnost.orika:orika-core:${versions.orika}"
        compile "org.mongodb.morphia:morphia:${versions.morphia}"
        compile "org.mongodb.morphia:morphia-logging-slf4j:${versions.morphia}"
        compile "org.slf4j:slf4j-api:${versions.slf4j}"
        compile "org.springframework:spring-context:${versions.spring}"
        compile "org.eclipse.jetty.websocket:javax-websocket-server-impl:${versions.jetty}"

        testCompile "org.assertj:assertj-core:${versions.assertj}"
        testCompile "com.pholser:junit-quickcheck-core:${versions.junitQuickcheck}"
        testCompile "com.pholser:junit-quickcheck-generators:${versions.junitQuickcheck}"

    }

    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('build/dist')

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

        inputs.dir('app')
        inputs.file('package.json')
        inputs.file('webpack.config.js')

        outputs.dir('build/dist')
    }

    tasks.processResources.dependsOn webpack

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

    tasks.check.dependsOn jsTest

}


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

    apply plugin: 'us.kirchmeier.capsule'

    dependencies {

        compile project(":${rootProject.name}-backend")
        compile project(":${rootProject.name}-frontend")
        compile "io.dropwizard:dropwizard-assets:${versions.dropwizard}"

    }

    capsule.version = versions.capsule

    task fatCapsule(type: FatCapsule, description: 'Build Capsule') {

        applicationClass 'io.zucchiniui.capsule.ZucchiniUIApplication'

        capsuleManifest {
            minJavaVersion = '1.8.0'
        }

    }

    task runCapsule(type: Exec, description: 'Run Capsule', dependsOn: fatCapsule) {
        commandLine 'java', '-jar', fatCapsule.archivePath, 'server', "${rootDir}/server-config.yml"
    }

    tasks.assemble.dependsOn fatCapsule

    docker {

        name = rootProject.name

        // Project version is required as a build arg
        buildArg 'VERSION', project.version

        // Add tag based on current Git branch
        tag project.getDockerTag()

    }

}


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

    apply plugin: 'groovy'

    dependencies {

        compile "org.codehaus.groovy:groovy-all:${versions.groovy}"
        compile "info.cukes:cucumber-groovy:${versions.cucumberGroovy}"
        compile "org.slf4j:slf4j-api:${versions.slf4j}"
        compile "org.assertj:assertj-core:${versions.assertj}"

    }

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

        classpath = sourceSets.main.runtimeClasspath

        main = 'cucumber.api.cli.Main'

        args += [
            '--glue', 'classpath:io.zucchiniui.examples',
            '--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.zucchiniui.examples',
            '--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 {
        tag project.getDockerTag()
    }

}