build.gradle

// GPars - Groovy Parallel Systems
//
// Copyright © 2008--2011  The original author or authors
//
// 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.

//  Author: Václav Pech
//  Author: Russel Winder
//  Author: Dierk König
//  Author: Hans Dockter
//  Author: Hamlet D'Arcy - Updated OSGi configuration

// gradle imports these by default, but IDEA doesn't know

apply plugin: 'groovy'
apply plugin: 'maven'
apply plugin: 'osgi'
//apply plugin: 'code-quality'

defaultTasks 'test'

archivesBaseName = 'gpars'
group = 'org.codehaus.gpars'
version = '0.12'
bundleVersion = version

sourceCompatibility = 5
targetCompatibility = 5

def theVendor = 'gpars.org'
def theTitle = 'GPars: Groovy Parallel Systems'
jar {
    manifest {
        name = 'gpars'
        version = this.version
        symbolicName = 'gpars.org'
        instruction 'Bundle-Vendor', theVendor
        instruction 'Bundle-Description', group
        instruction 'Bundle-DocURL', 'http://gpars.codehaus.org'
        instruction 'Built-By', System.properties.'user.name'
        instruction 'Extension-Name', archivesBaseName
        instruction 'Specification-Title', theTitle
        instruction 'Specification-Version', version
        instruction 'Specification-Vendor', theVendor
        instruction 'Implementation-Title', theTitle
        instruction 'Implementation-Version', version
        instruction 'Implementation-Vendor', theVendor
        instruction 'provider', theVendor
        instruction 'Export-Package', "*;version=${version}"
        instruction 'Import-Package', '*;resolution:=optional'
    }
}

repositories {
    mavenCentral()
    mavenRepo urls: ['http://repository.jboss.org/maven2/']
    mavenRepo urls: ['http://repository.codehaus.org']
    mavenRepo urls: ['http://snapshots.repository.codehaus.org']
    mavenRepo urls: ['http://download.java.net/maven/2/']

}

configurations {
    deployerJars
    docs
    cover
}

dependencies {
    groovy group: 'org.codehaus.groovy', name: 'groovy-all', version: hasProperty('groovyVersion') ? groovyVersion : '1.7.9'
    testCompile group: 'junit', name: 'junit', version: hasProperty('junitVersion') ? junitVersion : '4.8.2'
    testCompile group: 'org.spockframework', name: 'spock-core', version: hasProperty('spockVersion') ? spockVersion : '0.5-groovy-1.7'
    //compile group: 'org.coconut.forkjoin', name: 'jsr166y', version: hasProperty('jsr166yVersion') ? jsr166yVersion : '070108'
    compile 'org.codehaus.jsr166-mirror:jsr166y:1.7.0'
    compile 'org.codehaus.jsr166-mirror:extra166y:1.7.0'
    compile 'org.multiverse:multiverse-beta:0.7-RC-1'
    compile group: 'org.jboss.netty', name: 'netty', version: hasProperty('nettyVersion') ? nettyVersion : '3.1.5.GA'
    //compile group: 'org.jboss.netty', name: 'netty', version: hasProperty('nettyVersion') ? nettyVersion : '3.1.5.GA' {maven.optional = true}
    compile group: 'org.codehaus.jcsp', name: 'jcsp', version: '1.1-rc5'
    docs group: 'org.grails', name: 'grails-docs', version: '1.3.6'
    docs group: 'radeox', name: 'radeox', version: '1.0-b2'
    docs group: 'com.lowagie', name: 'itext', version: '2.0.8'
    docs group: 'org.slf4j', name: 'slf4j-api', version: '1.6.1'
    docs group: 'org.xhtmlrenderer', name: 'core-renderer', version: 'R8'
    docs group: 'commons-logging', name: 'commons-logging', version: '1.1.1'
    //deployerJars 'org.apache.maven.wagon:wagon-webdav-jackrabbit:1.0-beta-7'
    //deployerJars "org.apache.maven.wagon:wagon-http:1.0-beta-6"
    deployerJars "org.apache.maven.wagon:wagon-http-lightweight:1.0-beta-6"
    cover 'net.sourceforge.cobertura:cobertura:1.9.4.1'
    testRuntime 'net.sourceforge.cobertura:cobertura:1.9.4.1'
}

//  To get the details of the "unchecked" issues.
compileGroovy.options.compilerArgs = ['-Xlint']

[compileGroovy, compileTestGroovy]*.groovyOptions*.fork(memoryInitialSize: '128M', memoryMaximumSize: '320M')

gradle.taskGraph.whenReady {taskGraph ->
    if (!taskGraph.hasTask(':release')) {
        version += '-SNAPSHOT'
    }
    if (taskGraph.hasTask(':test') && taskGraph.hasTask(':withCoverage')) {
        new Coverage(this).setup()
    }
}

task release(dependsOn: ['build']) << {
    println 'We release now'
}

task withCoverage { // only here such that it can be put on the command line for enabling coverage
    description = 'Prepare the test task to use code coverage if needed.'
}

test {
    forkEvery = 600
    maxParallelForks = hasProperty('gpars_maxTestForks') ? gpars_maxTestForks : 1
    exclude '**/integration/**/*.*'
}

task integrationTest(type: Test, dependsOn: 'test') {
    include '**/integration/**/*.*'
}

apply {
    from 'docs.gradle'
}

// codenarc configuration
codeNarcConfigFileName = "./config/codenarc/codenarc.groovy"
task checkstyleMain(overwrite: true) << {};
task checkstyleTest(overwrite: true) << {};
// don't fail build on CodeNarc tasks
tasks.withType(CodeNarc).all { codeNarcTask ->
    codeNarcTask.ignoreFailures = true
}

//build.dependsOn integrationTest

try {
    uploadArchives {
        project.deployer = repositories.mavenDeployer {
            uniqueVersion = false
            configuration = configurations.deployerJars
            repository(url: 'https://dav.codehaus.org/repository/gpars/') {
                authentication(userName: codehausUsername, password: codehausPassword)
            }
            snapshotRepository(url: 'https://dav.codehaus.org/snapshots.repository/gpars/') {
                authentication(userName: codehausUsername, password: codehausPassword)
            }
            pom.project {
                name 'GPars'
                description 'The Groovy and Java high-level concurrency library offering actors, dataflow, CSP, agents, parallel collections, fork/join and more'
                url 'http://gpars.codehaus.org'
                inceptionYear '2009'
                licenses {
                    license {
                        name 'The Apache Software License, Version 2.0'
                        url 'http://www.apache.org/licenses/LICENSE-2.0.txt'
                        distribution 'repo'
                    }
                }
            }
            // In the future Gradle will allow to use dynamic props for dependencies to deal with optionals
            pom.whenConfigured {pom ->
                // dependency is a native Maven dependency object (With properties artifactId, groupId, ...)
                pom.dependencies.each {dependency ->
                    if (dependency.artifactId in ['netty', 'jcsp', 'multiverse-beta']) {
                        dependency.optional = true
                    }
                }
                // Remove test dependencies from all poms
                pom.dependencies.removeAll(pom.dependencies.findAll { it.scope == 'test' })
            }
        }
    }
} catch (Exception e) {
    //  It may be that codehausUsername and/or codehausPassword are not defined in which case an exception
    //  will be thrown.  As it is impossible to do an upload if these are not defined then we don't really
    //  care that the uploadArchives specification hasn't completed.
    println 'Upload archives thrown an exception.'
    e.printStackTrace()
}

def titleForDocumentation = archivesBaseName + ' ' + version
def copyrightString = 'Copyright &#169; 2008&#8211;2010  V&#225;clav Pech.  All Rights Reserved.'
def packageTitle = group

javadoc {
    options.overview('overview.html')
    options.showAll()
    options.encoding('UTF-8')
    options.setUse(true)
    options.author(true)
    options.version(true)
    options.windowTitle(titleForDocumentation)
    options.docTitle(titleForDocumentation)
    options.footer(copyrightString)
}
javadoc.doFirst {
    javadoc.title = titleForDocumentation
    javadoc.options.docTitle = javadoc.title
}

groovydoc {
    dependsOn(classes)
    includePrivate = true
    use = true
    windowTitle = packageTitle
    docTitle = packageTitle
    header = packageTitle
    footer = copyrightString
    include 'groovyx/gpars/**'
    overview = new File('overview.html')
}

task documentation(dependsOn: ['javadoc', 'groovydoc', 'buildGuide', 'pdfGuide'], description: 'Create the API documentation.')

task zipDoc(type: Jar, dependsOn: 'documentation') {
    classifier = 'javadoc'
    from docsDir
}

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

artifacts {
    archives(zipSrc)
    archives(zipDoc)
}

//task zipSamples(dependsOn: 'demo', type: Zip) {
task zipSamples(type: Zip) {
    appendix = 'samples'
    from sourceSets.test.allSource.matching {
        include 'groovyx/gpars/samples/**'
    }
}

task zipJavaDemo(type: Zip) {
    appendix = 'mvn-java-demo'
    from('java-demo') {
        include 'src/**'
        include 'pom.xml'
    }
}

task copyThirdPartyLibs(type: Copy) {
    from('lib')
    into('build/dist')
    exclude('junit*', 'netty-3.1.5.GA-sources.jar', 'jcsp.jar', 'jcsp-demos-util.jar', 'spock-core*')
}

task copyLibs(type: Copy) {
    from('build/libs')
    into('build/dist')
}

task copyDists(type: Copy) {
    from('build/distributions')
    into('build/dist')
}

task copyLicense(type: Copy) {
    from('src/main/resources/META-INF/')
    into('build/dist')
    include('LICENSE.txt', 'NOTICE.txt')
}

task zipDist(dependsOn: ['jar', 'copyThirdPartyLibs', 'copyLibs', 'copyDists', 'copyLicense'], type: Zip) {
    appendix = 'all'
    from 'build/dist'
}
zipDist << {
    ant.delete(dir: file('build/dist'), failonerror: true)
}

task wrapper(type: Wrapper) {
    jarFile = 'wrapper/gradle-wrapper.jar'
    gradleVersion = '1.0-milestone-3'
}

task demo(type: DemoTask, dependsOn: 'compileGroovy') {
    excludedDemos = [
            'DemoPotentialDeadlock',                      // may deadlock (on purpose)
            'DemoNonDeterministicDeadlockWithDataflows',  // may deadlock (on purpose)
            'DemoDeadLock',                               // deadlock (on purpose)
            'DemoRemote',                                 // doesn't work in an automated environment
            'DemoSwing',                                  // maybe we don't want these to run on the CI ..
            'DemoSwingMashup',                            // but they can be run locally
            'DemoSwingCollectionProcessing',
            'DemoSwingActors',
            'DemoSwingDataflowOperators',
            'DemoSwingFancyDataflow',                     // Shows UI
            'DemoSwingDataflowProgress',                  // Shows UI
            'DataflowDemo4',                              // Never stops
            'DemoWebPageProcessing',                      // Never stops
            'DemoWebPageProcessingWithCaching',           // Never stops
            'DemoMapReduce',                              // Relies on internet connection
            'DemoNumbers',                                //Never stops
            'FibonacciV1',                                //Never stops
            'FibonacciV2',                                //Never stops
            'DemoSieveEratosthenesCSP',                   //Never stops
            'DemoSieveEratosthenesTheGoWay',              //Never stops
            'DemoSieveEratosthenesTheGoWayWithOperators', //Never stops
            'DemoThreading',                              //Never stops
            'DemoProducerConsumer1',                      //Never stops
            'DemoPhysicalCalculations',                   //Needs user input
            'DemoFibonacci1',                             //Needs classes from its source folder
            'DemoFibonacci2',                             //Needs classes from its source folder
            'DemoNumbers',                                //Needs classes from its source folder
            'DemoActor_4_4',                              //Specifies absolute paths
            'RunReset',                                   //Starts UI
            'DemoSwingMergeSort',                         //Starts UI
            'DemoVisualForkJoinMergeSort',                //Starts UI
            'DemoStm',                                    //Stm
            'DemoDirectStm',                              //Stm
            'DemoRetry',                                  //Stm
            'DemoCustomBlocks',                           //Stm
    ]

    classpath = sourceSets.main.runtimeClasspath

    demoFiles = sourceSets.test.allGroovy.matching {
        include '**/*Demo*.groovy'
        exclude excludedDemos.collect {name -> "**/${name}.groovy" }
    }
}

class DemoTask extends DefaultTask {
    @org.gradle.api.tasks.InputFiles FileCollection classpath
    @org.gradle.api.tasks.InputFiles FileCollection demoFiles
    List excludedDemos

    @org.gradle.api.tasks.TaskAction
    def runDemos() {
        def shell = createShell()
        def failed = []
        def ok = 0
        demoFiles.files.each {File file ->
            println "*** starting demo $file.name"
            try {
                shell.evaluate(file)
                ok += 1
            } catch (Exception ex) {
                failed << [file: file, exception: ex]
            }
            println "*** done"
        }
        println "*** cleaning up"
        shell.evaluate("groovyx.gpars.dataflow.Dataflow.DATA_FLOW_GROUP.shutdown()")
        println "=== demos: $ok ok, ${failed.size()} failed"
        failed.each { println "${it.file}\n    ${it.exception}" }
    }

    private GroovyShell createShell() {
        URLClassLoader classloader = new URLClassLoader(
                classpath.files.collect {File classpathElement -> classpathElement.toURL()} as URL[],
                Thread.currentThread().contextClassLoader
        )
        System.metaClass.static.exit = {int returnCode -> println ">>> System.exit($returnCode) suppressed." }
        System.in.metaClass.read = {-> println ">>> System.in.read() suppressed"; 'Automated build' }
        System.in.metaClass.readLines = {-> println ">>> System.in.read() suppressed"; ['Automated build'] }
        new GroovyShell(classloader)
    }
}