build.gradle

buildscript {
    repositories {
        mavenCentral()
        jcenter()
    }
    dependencies {
        classpath 'com.github.jengelman.gradle.plugins:shadow:1.2.3'
        classpath 'net.saliman:gradle-cobertura-plugin:2.3.1'
    }
}

ext.java8 = gradle.ext.java8 // See settings.gradle

subprojects {
    apply plugin: 'java'

    sourceCompatibility = '1.7'
    targetCompatibility = '1.7'

    tasks.withType(JavaCompile) {
        options.encoding = 'UTF-8'
    }

    group               = "co.paralleluniverse"
    version             = "0.7.9"
    status              = "integration"
    description         = "Fibers, Channels and Actors for the JVM"
    ext.url             = "http://puniverse.github.com/quasar"
    ext.vendor          = "Parallel Universe Software Co."
    ext.licenseName1    = "The GNU Lesser General Public License, version 3"
    ext.licenseUrl1     = "http://www.gnu.org/licenses/lgpl-3.0.txt"
    ext.licenseName2    = "Eclipse Public License - v 1.0"
    ext.licenseUrl2     = "http://www.eclipse.org/legal/epl-v10.html"
    ext.scmUrl          = "https://github.com/puniverse/quasar"
    ext.scmConnection   = "https://github.com/puniverse/quasar.git"
    ext.distDir         = "$buildDir/dist"
    ext.isReleaseVersion = !version.endsWith("SNAPSHOT")
    ext.baselib         = "${rootProject.projectDir}/baselib"
    ext.java8 = rootProject.ext.java8
    ext.jdkVer = ext.java8 ? "8" : "7"
    ext.quasarJar = "${rootProject.projectDir}/quasar-core/build/libs/quasar-core-${version}${ext.java8 ? "-jdk8" : ""}.jar" // project(':quasar-core').jar.archivePath

    ext.asmVer    = '5.2'
    ext.kotlinVer = '1.1.3-2'

    if (!project.hasProperty("sonatypeUsername") || !project.hasProperty("sonatypePassword")) {
        println "sonatype username or password not set"
        ext.sonatypeUsername = ""
        ext.sonatypePassword = ""
    }

    if (!project.hasProperty('mainClass')) { // must use project.hasProperty() rather than hasProperty in subprojects (gradle bug)
        ext.mainClass = ''
    }

    repositories {
        flatDir {
            dirs baselib
        }
        repositories {
            mavenLocal()
            mavenCentral()
            maven { url "https://oss.sonatype.org/content/repositories/releases" }
            maven { url "https://oss.sonatype.org/content/repositories/snapshots" }
            jcenter()
        }
    }

    configurations.all {
        resolutionStrategy {
            failOnVersionConflict()
        }
    }

    configurations {
        compileOnly
        provided
        timewarp
        // markdownDoclet
    }

    sourceSets {
        main {
            compileClasspath += configurations.compileOnly + configurations.provided
        }

        test {
            compileClasspath += configurations.compileOnly + configurations.provided
            runtimeClasspath += configurations.provided
        }

        jmh {
            compileClasspath += main.compileClasspath + main.output + test.compileClasspath + test.output
            runtimeClasspath += compileClasspath + main.runtimeClasspath + test.runtimeClasspath
        }
    }

    compileJmhJava {
        sourceCompatibility = '1.8'
        targetCompatibility = '1.8'
    }

    dependencies {
        compile("io.dropwizard.metrics:metrics-core:3.2.3") {
            exclude group: 'org.slf4j', module: '*'
        }
        provided "org.apache.ant:ant:1.9.9" // version 1.10 and upwards requires JDK 8
        compile "com.google.guava:guava:20.0" // version 21.0 and upwards requires JDK 8
        timewarp 'co.paralleluniverse:timewarp:0.1.0-SNAPSHOT'
        testCompile 'co.paralleluniverse:timewarp:0.1.0-SNAPSHOT'
        testCompile 'junit:junit:4.12'
        testCompile('com.google.truth:truth:0.34') {
            exclude group: 'com.google.guava', module: 'guava'
            exclude group: 'junit', module: 'junit'
        }
        testCompile 'org.hamcrest:hamcrest-all:1.3'
        testCompile("org.mockito:mockito-all:1.10.19") {
            exclude group: "org.ow2.asm", module: '*'
        }
        testCompile "org.ow2.asm:asm:$asmVer"

        jmhCompile 'org.openjdk.jmh:jmh-core:1.19'
        jmhCompile 'org.openjdk.jmh:jmh-generator-annprocess:1.19'

        compileOnly 'org.kohsuke.metainf-services:metainf-services:1.7'
        // compileOnly 'com.google.auto.service:auto-service:1.0-rc1' // same as metainf-services
        // markdownDoclet "ch.raffael.pegdown-doclet:pegdown-doclet:1.1.1"
    }

    //    tasks.withType(JavaCompile) {
    //        // options.compilerArgs << "-Xlint:unchecked"
    //        // options.compilerArgs << "-Xlint:deprecation"
    //    }

    compileJava.dependsOn processResources
    compileJava {
        if (project.name != 'quasar-kotlin') {
            doLast {
                scanAndInstrument(sourceSets.main, [configurations.provided, configurations.runtime])
            }
        }
    }

    test.dependsOn jar

    tasks.withType(Test) {
        useJUnit()
        // systemProperty 'co.paralleluniverse.fibers.verifyInstrumentation', 'true'

        // systemProperty "java.util.logging.config.file", "jul.properties"

        // Uncomment and add ${rootProject.projectDir}/log4j.xml, if not present, for logging
        // systemProperty "log4j.configurationFile", "${rootProject.projectDir}/log4j.xml"

        // systemProperty "Log4jContextSelector", "org.apache.logging.log4j.core.async.AsyncLoggerContextSelector"

        // systemProperty 'co.paralleluniverse.debugMode', 'true'
        systemProperty 'co.paralleluniverse.monitoring.flightRecorderLevel', '5'
        systemProperty 'co.paralleluniverse.globalFlightRecorder', 'true'
        systemProperty 'co.paralleluniverse.flightRecorderDumpFile', 'quasar.log'
        systemProperty 'co.paralleluniverse.monitoring.flightRecorderSize', '200000'

        if (project.name != 'quasar-core') {
            jvmArgs "-javaagent:${quasarJar}" // =vdmc (verbose, debug, allow monitors, check class)
        }

        if (project.name != 'quasar-kotlin') { // TODO investigate why kotlin-plugin 1.1.2+ doesn't like it
            jvmArgs "-Xbootclasspath/a:${configurations.timewarp.singleFile}"
            if (System.getenv("TRAVIS") == 'true') {
                jvmArgs "-javaagent:${configurations.timewarp.singleFile}=3" // slow clock down x3
            }
        }

        jvmArgs "-Xmx2048m"
        if (!project.ext.java8) {
            jvmArgs "-XX:MaxPermSize=512m" // Travis is having some trouble with PermGen
        }
        // jvmArgs "-XX:-UseCompressedOops"

        beforeTest { desc ->
            logger.quiet("Running test: " + desc)
        }

        afterTest { desc, result ->
            if(result.resultType == TestResult.ResultType.FAILURE) {
                logger.quiet("Failed test ${desc.name} [${desc.className}] with exception: ${result.exception}")
                if(result.exception != null) {
                    result.exception.printStackTrace()
                }
            }
        }

        doLast() {
            println "file://" + getReports().getHtml().getDestination() + "/index.html"
        }
    }

    ['run', 'debug'].each { name ->
        project.task(name, type: JavaExec, dependsOn:[testClasses]) {
            classpath = sourceSets.main.runtimeClasspath
            if(project.hasProperty('mainClass')){
                main = project.mainClass
            }
            if(project.hasProperty('args')){
                args project.args.split('\\s+')
            }

            jvmArgs '-Xmx2048m'
            // jvmArgs "-Xbootclasspath/p:${System.getProperty("user.home")}/jsr166.jar"
            // systemProperty 'co.paralleluniverse.fibers.DefaultFiberPool.parallelism', '1'

            systemProperty "log4j.configurationFile", "${rootProject.projectDir}/log4j.xml"
            systemProperty "Log4jContextSelector", "org.apache.logging.log4j.core.async.AsyncLoggerContextSelector"
            // systemProperty 'co.paralleluniverse.fibers.verifyInstrumentation', 'true'
            jvmArgs "-javaagent:${quasarJar}" // =vdmc (verbose, debug, allow monitors, check class)

            // jvmArgs '-XX:+UnlockCommercialFeatures', '-XX:+FlightRecorder', '-XX:StartFlightRecording=duration=60s,filename=recording.jfr,settings=heap'
        }
    }
    debug.debug = true

    project.afterEvaluate {
        run.dependsOn project(':quasar-core').tasks["jdk${project.ext.jdkVer}ShadowJar"]
    }

    tasks.withType(JavaExec) {
        classpath += sourceSets.test.runtimeClasspath + sourceSets.test.output + sourceSets.jmh.runtimeClasspath + sourceSets.jmh.output
    }

    //    tasks.withType(Debug) {
    //        classpath = sourceSets.test.runtimeClasspath
    //    }

    configure (javadoc) {
        classpath += configurations.provided
        options {
            // docletpath = configurations.markdownDoclet.files.asType(List)
            // doclet = 'ch.raffael.doclets.pegdown.PegdownDoclet'
            // addStringOption("parse-timeout", "10")
            if(project.ext.java8) {
                options.addStringOption('Xdoclint:none', '-quiet')
            }
            // stylesheetFile = rootProject.file('./baselib/javadoc.css')
            links = [
                "http://docs.oracle.com/javase/7/docs/api/",
                "http://google.github.io/guava/releases/19.0/api/docs/"
            ]
        }
    }

    defaultTasks 'build'

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

    task artifacts {
        group = "Help"
        description = "Displays the artifacts associated with each configuration of " + project
        doFirst {
            configurations.findAll().each { config ->
                println "${config}:"
                // config.allArtifacts.each { file -> println "--- " + file }
                config.allArtifacts.getFiles().each { file -> println "" + file }
                println ' '
            }
        }
    }

    ///////// Publish Artifacts
    apply plugin: 'maven'
    apply plugin: 'signing'

    artifacts {
        archives jar
        archives sourcesJar
        archives javadocJar
    }

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

    uploadArchives {
        repositories {
            mavenDeployer {
                beforeDeployment { deployment -> signing.signPom(deployment) }

                repository(
                    url: (isReleaseVersion ?
                        "https://oss.sonatype.org/service/local/staging/deploy/maven2" :
                        "https://oss.sonatype.org/content/repositories/snapshots")) {
                    // User and Password are taken from ~/.gradle/gradle.properties
                    authentication(userName: project.sonatypeUsername, password: project.sonatypePassword)
                }
                pom.project {
                    name project.name
                    packaging 'jar'
                    description project.description
                    url project.url
                    scm {
                        url project.scmUrl
                        connection project.scmConnection
                        developerConnection project.scmConnection
                    }
                    licenses {
                        license {
                            name project.licenseName1
                            url project.licenseUrl1
                            distribution 'repo'
                        }
                        license {
                            name project.licenseName2
                            url project.licenseUrl2
                            distribution 'repo'
                        }
                    }
                    developers {
                        developer {
                            id 'pron'
                            name 'Ron Pressler'
                        }
                    }
                }
            }
        }
    }
}

def scanAndInstrument(sset, configs) {
    def cp = '' + sset.output.classesDir + ':' + sset.output.resourcesDir + ':' + configs*.asPath.join(':')

    ant.taskdef(
        name:'scanSuspendables', classname:'co.paralleluniverse.fibers.instrument.SuspendablesScanner',
        classpath: cp)
    ant.scanSuspendables(
        auto: false,
        supersFile:"$sset.output.resourcesDir/META-INF/suspendable-supers",
        append: true) {
        fileset(dir: sset.output.classesDir)
    }

    ant.taskdef(name:'instrumentation', classname:'co.paralleluniverse.fibers.instrument.InstrumentationTask',
        classpath: cp)
    ant.instrumentation(verbose:'true', check:'true', debug:'true') {
        fileset(dir: sset.output.classesDir) {
            exclude(name: 'co/paralleluniverse/fibers/instrument/*.class')
        }
    }
}

project (':quasar-core') {
    /*
     * see:
     *   https://docs.gradle.org/current/userguide/java_plugin.html
     *   http://examples.javacodegeeks.com/core-java/gradle/gradle-sourcesets-example/
     *   http://stackoverflow.com/questions/15870662/gradle-create-a-new-jar-from-each-sourceset
     *   http://stackoverflow.com/questions/18190614/compiling-a-project-with-different-java-source-compatibility
     *   https://softnoise.wordpress.com/2014/09/07/gradle-sub-project-test-dependencies-in-multi-project-builds/
     */

    apply plugin: 'com.github.johnrengelman.shadow'

    // remove default artifact
    configurations.runtime.artifacts.with { archives ->
        archives.each {
            archives.remove(it)
        }
    }

    [compileJava, compileTestJava, classes, jar]*.enabled = false

    sourceSets {
        main {
            java {
                srcDir 'src/main/java'
                srcDir 'src/jdk7/java'
            }
        }

        jdk7 {
            java {
                srcDir 'src/main/java'
                srcDir 'src/jdk7/java'
            }

            compileClasspath += main.compileClasspath // += main.uoutput
            runtimeClasspath += main.runtimeClasspath // += main.uoutput
        }

        jdk7test {
            java {
                srcDir 'src/test/java'
            }

            compileClasspath += jdk7.output + test.compileClasspath
            runtimeClasspath += compileClasspath  + test.runtimeClasspath
        }

        jdk8 {
            java {
                srcDir 'src/main/java'
                srcDir 'src/jdk8/java'
            }

            compileClasspath += main.compileClasspath
            runtimeClasspath += compileClasspath
        }

        jdk8test {
            java {
                srcDir 'src/test/java'
                srcDir 'src/jdk8Test/java'
            }

            compileClasspath += jdk8.output + test.compileClasspath
            runtimeClasspath += compileClasspath + test.runtimeClasspath
        }

        jmh {
            java {
                srcDir 'src/jmh/java'
            }

            compileClasspath += jdk8.output + jdk8test.compileClasspath + jdk8test.output
            runtimeClasspath += compileClasspath + jdk8test.runtimeClasspath
        }

        classloadertest {
            java {
                srcDir 'src/classloadertest/java'
            }

            compileClasspath += jdk7.output + test.compileClasspath
            runtimeClasspath += compileClasspath + test.runtimeClasspath
        }
    }

    configurations {
        jdk7Archives.extendsFrom runtime
        jdk8Archives.extendsFrom runtime
    }

    dependencies {
        jdk7Compile ":jsr166e"
        compile ":high-scale-lib"
        compile "org.hdrhistogram:HdrHistogram:2.1.9"
        compile("org.latencyutils:LatencyUtils:2.0.3") {
            exclude group: "org.hdrhistogram", module: '*'
        }
        compile "org.ow2.asm:asm:$asmVer"
        compile "org.ow2.asm:asm-analysis:$asmVer"
        compile "org.ow2.asm:asm-commons:$asmVer"
        compile "org.ow2.asm:asm-util:$asmVer"

        // The exclusions are needed to get asm 5.0.4 whilst Kryo still depends on 5.0.3
        compile("com.esotericsoftware:kryo:4.0.0") {
            exclude group: "org.ow2.asm", module: '*'
        }
        compile("de.javakaffee:kryo-serializers:0.42") {
            exclude group: "com.esotericsoftware", module: '*'
            exclude group: "com.esotericsoftware.kryo", module: '*'
        }
        provided 'junit:junit:4.12'
    }

    def ssets = [sourceSets.jdk7]
    if(ext.java8) {
        ssets += sourceSets.jdk8
    }

    ssets.each { set ->
        configure(project.tasks["compile${capitalize(set.name)}Java"]) {
            doLast {
                rootProject.scanAndInstrument(set, [configurations["${set.name}Runtime"], configurations.provided, configurations.runtime])
            }
        }

        def shadowJarTask = task("${set.name}ShadowJar", type: com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar, dependsOn: classes) {
            classifier = '' // overwrite jar
            destinationDir = file("$buildDir/libs")

            from set.output

            configurations = [project.configurations.runtime, project.configurations["${set.name}Runtime"]]
            dependencies {
                include(dependency('org.ow2.asm:.*:.*'))
                include(dependency(':high-scale-lib'))
            }
            exclude 'META-INF/INDEX.LIST'

            relocate 'org.objectweb.asm.', 'co.paralleluniverse.asm.'

            manifest {
                attributes(
                    "Built-By"                  :   System.getProperty("user.name"),
                    "Implementation-Title"      :   project.name,
                    "Implementation-Version"    :   version,
                    "Implementation-Vendor"     :   vendor,
                    "Premain-Class"             :   "co.paralleluniverse.fibers.instrument.JavaAgent",
                    "Agent-Class"               :   "co.paralleluniverse.fibers.instrument.JavaAgent",
                    "Can-Retransform-Classes"   :   "true",
                    "Can-Redefine-Classes"      :   "true",
                    //  "Class-Path"                :   configurations.runtime.collect { "lib/"+it.getName() }.join(',')
                )
            }
        }

        def testTask = task("${set.name}Test", type: Test, dependsOn: [shadowJarTask, compileClassloadertestJava]) {
            testClassesDir = project.sourceSets["${set.name}test"].output.classesDir
            classpath = project.sourceSets["${set.name}test"].runtimeClasspath

            project.afterEvaluate {
                jvmArgs "-javaagent:${shadowJarTask.archivePath}" // =vdc
            }
        }

        artifacts {
            archives shadowJarTask
        }

        assemble.dependsOn shadowJarTask
        check.dependsOn testTask
    }

    compileJdk7Java {
        sourceCompatibility = '1.7'
        targetCompatibility = '1.7'
    }

    //    jdk7Jar {
    //        from zipTree("${baselib}/jsr166e.jar")  // include non-Maven jars
    //    }

    jdk7ShadowJar {
        dependencies {
            include(dependency(':jsr166e'))
        }
    }

    artifacts {
        jdk7Archives jdk7ShadowJar
    }

    if (ext.java8) {
        compileJdk8Java {
            sourceCompatibility = '1.8'
            targetCompatibility = '1.8'
        }

        compileJdk8testJava {
            sourceCompatibility = '1.8'
            targetCompatibility = '1.8'
        }

        //        jdk8Jar {
        //            classifier = 'jdk8'
        //        }

        jdk8ShadowJar {
            classifier = 'jdk8'
        }

        artifacts {
            jdk8Archives jdk8ShadowJar
        }

        tasks.withType(JavaExec) {
            classpath += sourceSets.jdk8test.runtimeClasspath + sourceSets.jdk8test.output
        }
        run.dependsOn compileJdk8Java, jdk8testClasses
    } else {
        tasks.withType(JavaExec) {
            classpath += sourceSets.jdk7test.runtimeClasspath + sourceSets.jdk7test.output
        }
        run.dependsOn compileJdk7Java, jdk7testClasses
    }

    javadoc {
        options.encoding = 'UTF-8'
        if (project.ext.java8) {
            source = sourceSets.jdk8.allJava
        } else {
            source = sourceSets.jdk7.allJava
        }
    }

    task shadowJar(dependsOn: tasks.withType(com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar), overwrite: true) {
    }

    assemble.dependsOn shadowJar
    build.dependsOn shadowJar
    install.dependsOn shadowJar
    signArchives.dependsOn shadowJar
    uploadArchives.dependsOn shadowJar

    def installer = install.repositories.mavenInstaller
    def deployer = uploadArchives.repositories.mavenDeployer

    [installer, deployer]*.pom*.whenConfigured {
        it.dependencies.removeAll { dep ->
            dep.artifactId.startsWith('jsr166e') ||
            dep.artifactId.startsWith('high-scale-lib') ||
            dep.groupId == 'org.ow2.asm'
        }
    }

    if (ext) {
        artifacts {
            archives sourcesJar
            archives javadocJar
        }
    }
}

project (':quasar-actors') {
    //project.evaluationDependsOn(':quasar-core')

    dependencies {
        provided project(path: ':quasar-core', configuration: "jdk${jdkVer}Archives")
        // compile 'org.mutabilitydetector:MutabilityDetector:0.9.2'
        compile "org.slf4j:slf4j-api:1.7.25"
        compile "net.bytebuddy:byte-buddy:1.7.1"
        testRuntime("org.apache.logging.log4j:log4j-slf4j-impl:2.8.2") {
            exclude group: "org.slf4j", module: '*'
        }
        testRuntime "org.apache.logging.log4j:log4j-api:2.8.2"
        testRuntime "org.apache.logging.log4j:log4j-core:2.8.2"
        testRuntime "com.lmax:disruptor:3.3.6" // required for log4j
    }
}

project (':quasar-galaxy') {
    dependencies {
        provided project(path: ':quasar-core', configuration: "jdk${jdkVer}Archives")
        compile project(':quasar-actors')

        compile ("co.paralleluniverse:galaxy:1.4")  {
            exclude group: 'com.lmax', module: 'disruptor'
            exclude group: 'de.javakaffee', module: 'kryo-serializers'
            exclude group: 'com.google.guava', module: 'guava'
            exclude group: "org.slf4j", module: '*'
        }

            testCompile ('org.gridkit.lab:telecontrol-ssh:0.7.24'){
            exclude group: 'org.ow2.asm', module: '*'
            exclude group: 'org.slf4j', module: '*'
        }
        testRuntime files(jar.archivePath)
    }

    tasks.withType(Test) {
        systemProperty "co.paralleluniverse.quasarJar", "${quasarJar}"
        systemProperty "jgroups.bind_addr", "127.0.0.1"
        systemProperty "galaxy.multicast.address", "225.0.0.1"
        systemProperty "galaxy.multicast.port", "7050"
        systemProperty "co.paralleluniverse.galaxy.configFile", "${sourceSets.main.output.resourcesDir}/config/peer.xml"
        systemProperty "co.paralleluniverse.galaxy.autoGoOnline", "true"
    }

    tasks.withType(JavaExec) {
        main = mainClass
        systemProperty "log4j.configurationFile", "${rootProject.projectDir}/log4j.xml"
        systemProperty "Log4jContextSelector", "org.apache.logging.log4j.core.async.AsyncLoggerContextSelector"
        // systemProperty 'co.paralleluniverse.fibers.verifyInstrumentation', 'true'
        // systemProperty "co.paralleluniverse.io.useJDKSerialization", "true"
        jvmArgs "-javaagent:${quasarJar}" // =v, =d
        jvmArgs "-ea", "-XX:MaxDirectMemorySize=100M"
        systemProperty "jgroups.bind_addr", "127.0.0.1"
        systemProperty "galaxy.multicast.address", "225.0.0.1"
        systemProperty "galaxy.multicast.port", "7050"
        systemProperty "co.paralleluniverse.galaxy.configFile", "${sourceSets.main.output.resourcesDir}/config/peer.xml"
        systemProperty "co.paralleluniverse.galaxy.autoGoOnline", "true"

        // systemProperty 'co.paralleluniverse.debugMode', 'true'
        systemProperty 'co.paralleluniverse.monitoring.flightRecorderLevel', '5'
        systemProperty 'co.paralleluniverse.globalFlightRecorder', 'true'
        systemProperty 'co.paralleluniverse.flightRecorderDumpFile', 'quasar-galaxy.log'
        systemProperty 'co.paralleluniverse.monitoring.flightRecorderSize', '200000'
    }
}

project (':quasar-reactive-streams') {
    //project.evaluationDependsOn(':quasar-core')

    dependencies {
        provided project(path: ':quasar-core', configuration: "jdk${jdkVer}Archives")
        compile "org.reactivestreams:reactive-streams:1.0.0"
        testCompile("org.reactivestreams:reactive-streams-tck:1.0.0") {
            exclude group: "junit", module: "*"
            exclude group: "org.testng", module: "testng"
        }
        testCompile('org.testng:testng:6.12') {
            exclude group: "com.google.guava", module: "*"
            exclude group: "junit", module: "*"
        }
    }

    test {
        useTestNG()
    }
}

project (':quasar-disruptor') {
    //project.evaluationDependsOn(':quasar-core')

    dependencies {
        provided project(path: ':quasar-core', configuration: "jdk${jdkVer}Archives")
        compile "com.lmax:disruptor:3.3.6"
    }
}

task javadoc(type: Javadoc, dependsOn: subprojects.javadoc) {
    title = "Quasar ${project(':quasar-core').version}"
    destinationDir = file("docs/javadoc")

    if (project.ext.java8) {
        source = project(':quasar-core').sourceSets.jdk8.allJava
    } else {
        source = project(':quasar-core').sourceSets.jdk7.allJava
    }
    source += project(':quasar-actors').sourceSets.main.allJava
    source += project(':quasar-reactive-streams').sourceSets.main.allJava

    classpath = files(subprojects.collect { project -> project.sourceSets.main.compileClasspath })
    options {
        // docletpath = project(':quasar-core').configurations.markdownDoclet.files.asType(List)
        // doclet = 'ch.raffael.doclets.pegdown.PegdownDoclet'
        // addStringOption("parse-timeout", "10")
        // stylesheetFile = rootProject.file('./baselib/javadoc.css')
        if(project.ext.java8) {
            options.addStringOption('Xdoclint:none', '-quiet')
        }
        links = [
        "http://docs.oracle.com/javase/7/docs/api/",
        "http://docs.guava-libraries.googlecode.com/git-history/v18.0/javadoc/"
        ]
    }
    excludes = [
        "co/paralleluniverse/actors/spi/**",
        "co/paralleluniverse/actors/ActorMonitor.java",
        "co/paralleluniverse/actors/GlobalRegistry.java",
        "co/paralleluniverse/actors/JMXActorMonitor.java",
        "co/paralleluniverse/actors/LifecycleListener.java",
        "co/paralleluniverse/actors/LifecycleListenerProxy.java",
        "co/paralleluniverse/actors/MutabilityTester.java",
        "co/paralleluniverse/actors/RemoteActorProxyFactoryService.java",
        "co/paralleluniverse/actors/RemoteActorRef.java",
        "co/paralleluniverse/actors/RemoteActorProxyFactory.java",
        "co/paralleluniverse/common/benchmark/**",
        "co/paralleluniverse/common/classloader/**",
        "co/paralleluniverse/common/logging/**",
        "co/paralleluniverse/common/monitoring/**",
        "co/paralleluniverse/common/reflection/**",
        "co/paralleluniverse/common/test/**",
        "co/paralleluniverse/common/util/**",
        "co/paralleluniverse/concurrent/forkjoin/**",
        "co/paralleluniverse/concurrent/util/**",
        "co/paralleluniverse/data/record/DynamicGeneratedRecord.java",
        "co/paralleluniverse/data/record/DynamicRecord.java",
        "co/paralleluniverse/fibers/DefaultFiberPool.java",
        "co/paralleluniverse/fibers/FibersMonitor.java",
        "co/paralleluniverse/fibers/FiberTimedScheduler.java",
        "co/paralleluniverse/fibers/Instrumented.java",
        "co/paralleluniverse/fibers/NoopFibersMonitor.java",
        "co/paralleluniverse/fibers/instrument/**",
        "co/paralleluniverse/io/serialization/**",
        "co/paralleluniverse/remote/**",
        "co/paralleluniverse/strands/channels/SelectActionImpl.java",
        "co/paralleluniverse/strands/channels/disruptor/**", // not ready
        "co/paralleluniverse/strands/queues/**",
    ]
}

task clean(dependsOn: subprojects.clean) << {
    delete 'docs/javadoc'
}

def capitalize(s) { s[0].toUpperCase() + s[1..-1].toLowerCase() }