build.gradle

 /*
 * Copyright 2012-2015 Canoo Engineering AG.
 *
 * 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 {
    repositories {
        jcenter()
    }
    dependencies {
        classpath 'org.kt3k.gradle.plugin:coveralls-gradle-plugin:2.0.1'
    }
}

allprojects {
    apply plugin: 'idea'
    apply plugin: 'eclipse'
}

apply plugin: 'jacoco'
apply plugin: 'com.github.kt3k.coveralls'

subprojects {
    apply plugin: 'groovy'

    plugins.withType(JavaPlugin) {
        configurations {
            compileOnly
            testCompileOnly
        }

        sourceSets {
            main {
                compileClasspath += [configurations.compileOnly]
            }
            test {
                compileClasspath += [configurations.testCompileOnly]
            }
        }

        javadoc {
            classpath += [configurations.compileOnly]
        }

        idea {
            module {
                scopes.PROVIDED.plus += [configurations.compileOnly]
                scopes.PROVIDED.plus += [configurations.testCompileOnly]
            }
        }
    }

    configurations { // only needed such that groovydoc can work with groovy core plus groovy-ant module only
        groovyAnt.extendsFrom(runtime)
    }

    groovydoc {
        groovyClasspath = project.configurations.groovyAnt
    }

    archivesBaseName = "dolphin-${project.name}"

    repositories {
        mavenLocal()
        jcenter()
        mavenCentral()
    }

    dependencies {
        compile "org.codehaus.groovy:groovy:$groovyVersion"

        groovyAnt  "org.codehaus.groovy:groovy-ant:$groovyVersion"

        testCompile "org.codehaus.groovy:groovy-test:$groovyVersion"
        testCompile 'org.spockframework:spock-core:0.7-groovy-2.0', {
            exclude group: 'org.codehaus.groovy'
        }
    }

    task makeDirs(description: 'make all dirs for project setup') << {
        def sources = [sourceSets.main, sourceSets.test]
        sources*.allSource*.srcDirs.flatten().each { File srcDir ->
            println "making $srcDir"
            srcDir.mkdirs()
        }
    }
}

def coverageProjects() {
    [
            project(':client'),
            project(':client-javafx'),
            project(':shared'),
            project(':server'),
            project(':combined')
    ]
}

def mavenizedProjects() {
    coverageProjects() + [
            project(':logo-javafx'),
            project(':demo-javafx-server'), // for testing with dolphin-grails
            project(':demo-javafx-shared'), // for testing with dolphin-grails
    ]
}

List coverageSources = []
Set coverageClasses = [] as Set
coverageProjects().each {
    coverageClasses << file("subprojects/${it.name}/build/classes/main")
}
coverageProjects().each {
    coverageSources << file("subprojects/${it.name}/src/main/groovy")
    coverageSources << file("subprojects/${it.name}/src/main/java")
}

jacoco {
    toolVersion = jacocoVersion
}

configure(coverageProjects()) {
    apply plugin: 'jacoco'

    jacoco {
        toolVersion = jacocoVersion
    }

    test {
        jacoco {
            excludes = ['org.opendolphin.logo.*']
        }
    }

    jacocoTestReport {
        group = "Reporting"
        description = "Generate Jacoco coverage reports after running tests."

        additionalSourceDirs = project.files(coverageSources)
        sourceDirectories = project.files(coverageSources)
        classDirectories = files(coverageClasses)

        reports {
            xml.enabled = true
            csv.enabled = false
            html.enabled = true
        }
    }
}

configure(mavenizedProjects()) {
    apply plugin: 'maven'
    apply plugin: 'signing'

    task sourcesJar(type: Jar, dependsOn: classes) {
        classifier = 'sources'
        from sourceSets.main.allSource
    }

    javadoc {
        failOnError = false
    }

    task groovydocJar(type: Jar, dependsOn:groovydoc) {
        classifier = 'javadoc'
        from groovydoc.destinationDir
    }

    artifacts {
        archives sourcesJar
        archives groovydocJar
    }

    signing {
        required { gradle.taskGraph.hasTask(uploadArchives) }
        sign configurations.archives
    }

    gradle.taskGraph.whenReady { taskGraph ->
        if (taskGraph.hasTask(uploadArchives)) {
            uploadArchives {
                repositories.mavenDeployer {
                    def nexusURL = version.endsWith('SNAPSHOT') ? nexusDeployURL : nexusReleaseDelopyURL
                    def sonatypeURL = version.endsWith('SNAPSHOT') ? sonatypeDeployURL : sonatypeReleaseDeployURL
                    beforeDeployment { MavenDeployment deployment ->
                        signing.signPom(deployment)
                    }
                    if (project.hasProperty('mavenCentral')) {
                        repository(url: sonatypeURL) {
                            authentication(userName: sonatypeUser, password: sonatypePassword)
                        }
                    } else {
                        repository(url: nexusURL) {
                            authentication(userName: nexusDeployUser, password: nexusDeployPassword)
                        }
                    }
                    pom.project {
                        name 'Open Dolphin'
                        packaging 'jar'
                        description 'Dolphin is a free open-source library that bridges the worlds of enterprise Java and desktop Java.' +
                                    ' It uses presentation models to bind client-side views to server-side actions.'
                        url 'http://open-dolphin.org/'

                        scm {
                            url 'https://github.com/canoo/open-dolphin.git'
                            connection 'scm:git@github.com:canoo/open-dolphin.git'
                            developerConnection 'scm:git@github.com:canoo/open-dolphin.git'
                        }

                        licenses {
                            license {
                                name 'The Apache Software License, Version 2.0'
                                url 'http://www.apache.org/licenses/LICENSE-2.0.txt'
                                distribution 'repo'
                            }
                        }

                        developers {
                            developer {
                                id 'aalmiray'
                                name 'Andres Almiray'
                            }
                            developer {
                                id 'clipp'
                                name 'Christoph Lipp'
                            }
                            developer {
                                id 'DieterHolz'
                                name 'Dieter Holz'
                            }
                            developer {
                                id 'detlef-brendle'
                                name 'Detlef Brendle'
                            }
                            developer {
                                id 'Dierk'
                                name 'Dierk Koenig'
                            }
                            developer {
                                id 'svene'
                                name 'Sven Ehrke'
                            }
                            developer {
                                id 'jporzelt'
                                name 'Johannes Porzelt'
                            }
                            developer {
                                id 'kunsingh'
                                name 'Kunal Singh'
                            }
                            developer {
                                id 'Nicolai82'
                                name 'Nicolai Kilian'
                            }
                            developer {
                                id 'ToddCostella'
                                name 'Todd Costella'
                            }
                        }
                    }
                }
            }
        }
    }

}

def distDir = new File(rootDir, 'dist')
subprojects.each { proj ->
    evaluationDependsOn proj.path
    proj.jar.doLast { jarTask ->
        copy {
            from jarTask.archivePath
            into distDir
        }
    }
    proj.tasks.create(name: 'sourceZip', type: Zip) {
        classifier = 'src'
        destinationDir = distDir
        from proj.sourceSets*.allSource
    }
}

task wrap(type: Wrapper, description: "create a gradlew") {
    gradleVersion = '2.0'
}

apply {
    from 'buildSrc/scripts/docsDependencies.gradle'
    from 'buildSrc/scripts/docs.gradle'
}


task apidoc(group: 'Documentation', type: Groovydoc) {
    def coreProjects = subprojects.findAll { !it.name.contains('demo') }
    source coreProjects.collect { project -> project.sourceSets.main.allSource }
    classpath = files(subprojects.collect { project -> project.sourceSets.main.compileClasspath })
    groovyClasspath = classpath
    destinationDir = new File(buildDir, 'api')
    docTitle = "Open Dolphin API documentation"
    footer = "Created ${new java.text.SimpleDateFormat().format(new Date())}"
    header = docTitle
    windowTitle = docTitle
    overview = new File('docs/docOverview.html')
    link("http://download.oracle.com/javase/7/docs/api", "java.", "javax.")
    link("http://docs.oracle.com/javafx/2/api/", "javafx.")
    link("http://groovy.codehaus.org/api", "groovy.", "org.codehaus.groovy.")
}

def demos = new File(rootDir, 'subprojects/demo-javafx/combined/src/main/groovy/org/opendolphin/demo')
        .list()
        .findAll { it.startsWith('start') && it.endsWith('Demo.groovy') }
.collect { it - 'start' - 'Demo.groovy' }

task listDemos(description: "List all available demos") << { demos.sort().each { println "gradlew ${it}Demo" } }

demos.each { demo ->
    task "${demo}DemoPreparation"(description: "internal") << {
        project(':demo-javafx-combined').ext.set('demoApplicationName', demo)
    }
    def group = demo.startsWith('Grails') ? 'Demo (server required)' : 'Demo'
    task "${demo}Demo"(group: group, dependsOn: ["${demo}DemoPreparation", ':demo-javafx-combined:run'],
            description: "start the ${demo} demo") {}
}

task clean(type: Delete) {
    delete 'build'
    delete 'dist'
}

task jacocoRootReport(type: org.gradle.testing.jacoco.tasks.JacocoReport) {
    group = "Reporting"
    description = "Aggregate Jacoco coverage reports."
    additionalSourceDirs = files(coverageProjects().sourceSets.main.allSource.srcDirs)
    sourceDirectories = files(coverageProjects().sourceSets.main.allSource.srcDirs)
    classDirectories = files(coverageProjects().sourceSets.main.output)
    executionData = files(coverageProjects().jacocoTestReport.executionData)
    reports {
        html.enabled = true
        xml.enabled = true
        csv.enabled = false
        html.destination = "${buildDir}/reports/jacoco/test/html"
        xml.destination = "${buildDir}/reports/jacoco/test/jacocoTestReport.xml"
    }
}