build.gradle

/*
 * Copyright (c) 2008-2016 Haulmont.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */

buildscript {
    ext.cubaVersion = '7.3-SNAPSHOT'
    ext.cubaVersion = rootProject.hasProperty('buildVersion') ? rootProject['buildVersion'] : cubaVersion

    repositories {
        mavenLocal()

        if (System.getenv('HAULMONT_REPOSITORY_URL')) {
            maven {
                credentials {
                    username System.getenv('HAULMONT_REPOSITORY_USER')
                    password System.getenv('HAULMONT_REPOSITORY_PASSWORD')
                }
                url System.getenv('HAULMONT_REPOSITORY_URL')
            }
        } else {
            jcenter()
            maven { url "https://plugins.gradle.org/m2/" }
            maven { url "https://dl.bintray.com/cuba-platform/main" }
        }
    }
    dependencies {
        classpath "com.haulmont.gradle:cuba-plugin:$cubaVersion"
        classpath group: 'gradle.plugin.com.github.spotbugs.snom', name: 'spotbugs-gradle-plugin', version: '4.5.1'
    }
}

configurations {
    bom
}
dependencies {
    bom("com.haulmont.cuba:cuba-global:$cubaVersion")
}

def globalModule = project(':bpm-global')
def coreModule = project(':bpm-core')
def guiModule = project(':bpm-gui')
def webModule = project(':bpm-web')

def postgres = 'org.postgresql:postgresql:9.4-1201-jdbc41'

apply(plugin: 'cuba')

bom.load file('modules/global/src/com/haulmont/bpm/bom.properties')

cuba {
    artifact {
        group = 'com.haulmont.bpm'
        version = project.cubaVersion.replace('-SNAPSHOT', '')
        isSnapshot = project.cubaVersion.endsWith('-SNAPSHOT')
    }

    ide {
        vcs = 'Git'
        copyright = '''Copyright (c) 2008-$today.year Haulmont.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.'''
    }
}

def artifactVersion = cuba.artifact.version + (cuba.artifact.isSnapshot ? '-SNAPSHOT' : '')
def baseCubaVersion = rootProject.hasProperty('cuba.version') ? rootProject['cuba.version'] : artifactVersion

configure([globalModule, coreModule, guiModule, webModule]) {
    apply(plugin: 'java')
    apply(plugin: 'maven')
    apply(plugin: 'pmd')
    apply(plugin: 'cuba')

    // code quality
    apply(plugin: 'com.github.spotbugs')

    dependencies {
        testCompile(bom['junit:junit'])
    }

    task sourceJar(type: Jar) {
        from file('src')
        classifier = 'sources'
    }

    artifacts {
        archives sourceJar
    }

    jar {
        manifest {
            attributes("Implementation-Version": artifactVersion)
        }
    }

    javadoc {
        // move to plugin ?
        options.addStringOption("sourcepath", "")
    }

    spotbugs {
        toolVersion = "4.1.4"
        ignoreFailures = false
        omitVisitors = ['FindDoubleCheck']
        excludeFilter = rootProject.file("codestyle/exclude-filter.xml")
        effort = "max"
        reportLevel = "medium"
    }

    spotbugsMain {
        maxHeapSize = '2048m'

        reports {
            xml.enabled = false
            html {
                enabled = true
                stylesheet = rootProject.resources.text.fromFile("codestyle/fancy-hist.xsl")
                destination file("${project.buildDir}/reports/spotbugs/${project.name}.html")
            }
        }
    }

    spotbugsTest {
        maxHeapSize = '2048m'

        reports {
            xml.enabled = false
            html {
                enabled = true
                stylesheet = rootProject.resources.text.fromFile("codestyle/fancy-hist.xsl")
                destination file("${project.buildDir}/reports/spotbugs/test-${project.name}.html")
            }
        }
    }

    pmd {
        ignoreFailures = true
        sourceSets = [sourceSets.main]
        reportsDir = file("${project.buildDir}/reports/pmd")
        ruleSets = [
                "java-basic",
                "java-braces",
                "java-design",
                "java-unusedcode"
        ]
    }

    pmdMain {
        reports {
            xml.enabled = true
            html.enabled = false
        }
        source project.fileTree("src")
    }


    task pmdReport(dependsOn: pmdMain, group: 'verification', description:
            'Generates a HTML report after executing PMD checks.') {
        doLast {
            ant.xslt(
                    'in': "${project.buildDir}/reports/pmd/main.xml",
                    'style': "${rootDir}/findbugs/pmd-nicerhtml.xsl",
                    'out': "${project.buildDir}/reports/pmd/main.html")
        }
    }

    check {
        dependsOn += ['pmdReport']
    }
}

configure(globalModule) {
    dependencies {
        compile("com.haulmont.cuba:cuba-global:$baseCubaVersion")
    }

    entitiesEnhancing {
        main {
            enabled = true
        }
    }

    jar {
        manifest {
            attributes('App-Component-Id': cuba.artifact.group)
            attributes('App-Component-Version': artifactVersion)
        }
    }
}

configure(coreModule) {
    configurations {
        jdbc
        dbscripts
    }

    dependencies {
        compile(globalModule)

        compile(bom['com.fasterxml.jackson.core:jackson-databind']) // use the same version as rest-api
        compile(bom['com.fasterxml.jackson.core:jackson-annotations']) // use the same version as BPM
        compile(bom['org.codehaus.groovy:groovy-jsr223'])

        compileOnly(bom['javax.servlet:javax.servlet-api'])
        jdbc(postgres)
        testRuntime(postgres)

        compile("com.haulmont.cuba:cuba-core:$baseCubaVersion")

        compile(bom['org.activiti:activiti-engine']) {
            exclude group: 'org.springframework', module: 'spring-beans'
            exclude group: 'org.springframework', module: 'spring-core'
            exclude group: 'org.springframework', module: 'spring-context'
            exclude group: 'org.springframework', module: 'spring-jdbc'
            exclude group: 'org.springframework', module: 'spring-tx'
        }

        compile(bom['org.activiti:activiti-spring']) {
            exclude group: 'org.springframework', module: 'spring-beans'
            exclude group: 'org.springframework', module: 'spring-core'
            exclude group: 'org.springframework', module: 'spring-context'
            exclude group: 'org.springframework', module: 'spring-jdbc'
            exclude group: 'org.springframework', module: 'spring-orm'
            exclude group: 'org.springframework', module: 'spring-tx'
        }

        compile(bom['org.activiti:activiti-json-converter'])

        testCompile("com.haulmont.cuba:cuba-core-tests:$baseCubaVersion")
        dbscripts("com.haulmont.cuba:cuba-core:$baseCubaVersion:db@zip")
    }

    dbScriptsArchive {
        exclude '10-cuba/**'
    }

    assembleDbScripts {
        moduleAlias = '20-bpm'
    }

    task deploy(dependsOn: assemble, type: CubaDeployment) {
        appName = 'bpm-core'
        appJars('cuba-core', 'cuba-global', 
                'bpm-global', 'bpm-core')
    }

    task createDb(dependsOn: assembleDbScripts, description: 'Creates local database', type: CubaDbCreation) {
        dbms = 'postgres'
        host = 'localhost'
        dbName = 'bpm'
        dbUser = 'root'
        dbPassword = 'root'
    }

    task updateDb(dependsOn: assembleDbScripts, description: 'Updates local database', type: CubaDbUpdate) {
        dbms = 'postgres'
        host = 'localhost'
        dbName = 'bpm'
        dbUser = 'root'
        dbPassword = 'root'
    }

    task createTestDb(dependsOn: assembleDbScripts, description: 'Creates test database', type: CubaDbCreation) {
        dbms = 'postgres'
        host = 'localhost'
        dbName = 'bpm_test'
        dbUser = 'root'
        dbPassword = 'root'
    }
}

configure(guiModule) {
    dependencies {
        compile(globalModule)
        compile("com.haulmont.cuba:cuba-gui:$baseCubaVersion")

        compile(bom['com.fasterxml.jackson.core:jackson-databind'])
    }

    task deployConf(type: Copy) {
        from file('src')
        include "com/haulmont/bpm/**"
        into "$cuba.tomcat.dir/conf/bpm"
    }
}

configure(webModule) {
    configurations {
        modeler
        webcontent
    }

    dependencies {
        compileOnly(bom['javax.servlet:javax.servlet-api'])
        compile(globalModule)
        compile(guiModule)
        compile("com.haulmont.cuba:cuba-web:$baseCubaVersion")
        webcontent("com.haulmont.cuba:cuba-web:$baseCubaVersion:web@zip")
        webcontent("com.haulmont.cuba:cuba-web-toolkit:$baseCubaVersion:web@zip")

        modeler(bom['com.haulmont.bpm:cuba-modeler'] + ':web@zip')
    }

    task repackWebcontent(description: 'Repack webcontent') {
        doLast {
            def cubaModelerFile = configurations.modeler.files.find { dep ->
                dep.name.startsWith("cuba-modeler")
            }
            if (cubaModelerFile) {
                copy {
                    from zipTree(cubaModelerFile.absolutePath)
                    into "$webModule.buildDir/web"
                }
            }
        }
    }

    task webArchive(dependsOn: repackWebcontent, type: Zip) {
        from file("$webModule.buildDir/web")
        classifier = 'web'
    }

    artifacts {
        archives webArchive
    }

    task deployConf(type: Copy) {
        from file('src')
        include "com/haulmont/bpm/**"
        into "$cuba.tomcat.dir/conf/bpm"
    }
    
    task clearMessagesCache(type: CubaClearMessagesCache) {
        appName = 'bpm'
    }
    deployConf.dependsOn clearMessagesCache

    task cleanConf(description: 'Cleans up conf directory') {
        doLast {
            def dir = new File(cuba.tomcat.dir, '/conf/bpm')
            if (dir.isDirectory()) {
                ant.delete(includeemptydirs: true) {
                    fileset(dir: dir, includes: '**/*', excludes: 'local.app.properties')
                }
            }
        }
    }

    task deploy(dependsOn: [assemble, cleanConf], type: CubaDeployment) {
        appName = 'bpm'
        appJars('cuba-web', 'cuba-gui', 'cuba-client', 'cuba-global', 
                'bpm-global', 'bpm-gui', 'bpm-web')
    }
}

task aggregateJavadoc(type: Javadoc,
        description: 'Generate javadocs from all child projects as if it was a single project',
        group: 'Documentation') {

    destinationDir = file("$buildDir/docs/javadoc")
    title = "${project.name.toUpperCase()} ${baseCubaVersion.replace('-SNAPSHOT','')} API"

    options.encoding = 'UTF-8'
    options.addStringOption("sourcepath", "")
    options.memberLevel = org.gradle.external.javadoc.JavadocMemberLevel.PUBLIC

    exclude 'com/haulmont/bpm/web/toolkit/**'

    subprojects.each { proj ->
        def javadocTask = proj.tasks.getByPath('javadoc')

        source += javadocTask.source
        classpath += javadocTask.classpath
    }
}