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

    println("CUBA Platform - FTS Version ${ext.cubaVersion}")
    println("")

    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 group: 'com.haulmont.gradle', name: 'cuba-plugin', version: 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")
}

apply(plugin: 'cuba')

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

cuba {
    artifact {
        group = 'com.haulmont.fts'
        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 globalModule = project(':fts-global')
def coreModule = project(':fts-core')
def webModule = project(':fts-web')
def guiModule = project(':fts-gui')
def desktopModule = project(':fts-desktop')

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

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

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

    dependencies {
        testCompile(bom['org.junit.jupiter:junit-jupiter-api'])
        testCompile(bom['org.junit.jupiter:junit-jupiter-engine'])
        testCompile(bom['org.junit.vintage:junit-vintage-engine'])
        testCompile(bom['org.spockframework:spock-core']) {
            exclude(group: 'org.codehaus.groovy', module: 'groovy-all')
        }
    }

    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", "")
    }

    sourceSets {
        test {
            groovy {
                include 'spec/**'
                srcDir 'test'
            }
        }
    }

    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']
    }

    test {
        useJUnitPlatform()
    }
}

configure(globalModule) {
    dependencies {
        compile(group: 'com.haulmont.cuba', name: 'cuba-global', version: baseVersion)
    }

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

configure(coreModule) {
    configurations {
        jdbc
        dbscripts
    }

    dependencies {
        compile(globalModule)
        compile(group: 'com.haulmont.cuba', name: 'cuba-core', version: baseVersion)

        compile(bom['org.apache.lucene:lucene-core'])
        compile(bom['org.apache.lucene:lucene-analyzers-common'])
        compile(bom['org.apache.lucene:lucene-backward-codecs'])

        compile(bom['org.apache.lucene.morphology:russian'])
        compile(bom['org.apache.lucene.morphology:english'])

        compile(group: 'com.google.guava', name: 'guava', version: bom.getVersion('com.google.guava', 'guava'))

        //all "poi-*" dependencies must be the same version as "poi" dependency from the cuba
        compile(group: 'org.apache.poi', name: 'poi-ooxml-schemas', version: bom.getVersion('org.apache.poi', 'poi'))
        compile(group: 'org.apache.poi', name: 'poi-ooxml', version: bom.getVersion('org.apache.poi', 'poi'))
        compile(group: 'org.apache.poi', name: 'poi-scratchpad', version: bom.getVersion('org.apache.poi', 'poi'))
        compile(group: 'com.fasterxml.jackson.core', name: 'jackson-databind', version: bom.getVersion('com.fasterxml.jackson.core', 'jackson-databind'))

        compile(bom['org.apache.tika:tika-parsers']) {
            exclude(group: 'junit', module: 'junit')
            exclude(group: 'org.apache.poi', module: 'poi')
            exclude (group: 'edu.ucar', module: 'netcdf4')
            exclude (group: 'edu.ucar', module: 'grib')
            exclude (group: 'edu.ucar', module: 'cdm')
            exclude (group: 'edu.ucar', module: 'httpservices')
            exclude (group: 'com.github.junrar', module: 'junrar')
            exclude (group: 'edu.usc.ir', module: 'sentiment-analysis-parser')
            exclude (group: 'org.apache.cxf', module: 'cxf-rt-rs-client')
            exclude (group: 'org.apache.sis.core', module: 'sis-utility')
            exclude (group: 'org.apache.sis.core', module: 'sis-metadata')
            exclude (group: 'org.apache.sis.storage', module: 'sis-netcdf')
            exclude (group: 'org.gagravarr', module: 'vorbis-java-tika')
            exclude (group: 'org.gagravarr', module: 'vorbis-java-core')
            exclude (group: 'org.opengis', module: 'geoapi')
            exclude (group: 'com.healthmarketscience.jackcess', module: 'jackcess')
            exclude (group: 'com.healthmarketscience.jackcess', module: 'jackcess-encrypt')
            exclude (group: 'org.tallison', module: 'jmatio')
            exclude (group: 'org.codelibs', module: 'jhighlight')
            exclude (group: 'com.pff', module: 'java-libpst')
            exclude (group: 'org.apache.opennlp', module: 'opennlp-tools')
            exclude (group: 'com.rometools', module: 'rome')
            exclude (group: 'com.googlecode.mp4parser', module: 'isoparser')
            exclude (group: 'org.bouncycastle', module: 'bcmail-jdk15on')
            exclude (group: 'org.bouncycastle', module: 'bcprov-jdk15on')
        }

        jdbc(bom['org.hsqldb:hsqldb'])
        dbscripts(group: 'com.haulmont.cuba', name: 'cuba-core', version: baseVersion, classifier: 'db', ext: 'zip')
        testCompile(group: 'com.haulmont.cuba', name: 'cuba-core-tests', version: baseVersion)
        testRuntime(bom['org.hsqldb:hsqldb'])
    }

    assembleDbScripts {
    }

    entitiesEnhancing {
        test {
            enabled = true
        }
    }

    test {
        scanForTestClasses = false
        includes = ['**/*Test.class']

        if (System.getProperty('logback.configurationFile')) {
            systemProperty 'logback.configurationFile', System.getProperty('logback.configurationFile')
        }
    }

    def hsqlDbName = 'ftsdb'
    def hsqlPort = 9112

    task startDb(description: 'Starts local HSQLDB server', type: CubaHsqlStart) {
        dbPort = hsqlPort
        dbName = hsqlDbName
        showUi = !rootProject.hasProperty('headlessHsqlServer')        
    }

    task stopDb(description: 'Stops local HSQLDB server', type: CubaHsqlStop)  {
        dbPort = hsqlPort
        dbName = hsqlDbName
    }

    task removeDb(description: 'Removes local HSQL database', type: Delete) {
        delete new File("$rootProject.projectDir/data")
    }

    task killDb(description: "Kill local HSQLDB server process running on port $hsqlPort", type: CubaKillProcess) {
        port = hsqlPort
    }

    task createTestDb(dependsOn: assemble, description: 'Creates local HSQL database', type: CubaDbCreation) {
        dbms = 'hsql'
        host = "localhost:$hsqlPort"
        dbName = hsqlDbName
        dbUser = 'sa'
        dbPassword = ''
        auxiliaryScript = file('test/com/haulmont/fts/testmodel/create-db.sql')
    }
}

configure(webModule) {
    dependencies {
        compile(globalModule)
        compile(guiModule)
        compile(group: 'com.haulmont.cuba', name: 'cuba-web', version: baseVersion)
    }
}

configure(guiModule) {
    dependencies {
        compile(globalModule)
        compile(group: 'com.haulmont.cuba', name: 'cuba-gui', version: baseVersion)
    }
}

configure(desktopModule) {
    dependencies {
        compile(guiModule)
        compile(group: 'com.haulmont.cuba', name: 'cuba-desktop', version: baseVersion)
    }
}

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()} ${cubaVersion.replace('-SNAPSHOT','')} API"

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

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

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