build.gradle

apply plugin: 'java'
apply plugin: 'idea'
apply plugin: 'eclipse'
apply plugin: 'maven-publish'
apply plugin: 'jacoco'
apply plugin: 'distribution'
apply plugin: 'checkstyle'

sourceCompatibility = 1.8
targetCompatibility = 1.8

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

task wrapper(type: Wrapper) {
    gradleVersion = '4.3.1'
}

repositories {
    mavenCentral()
}

sourceSets {
    main {
        java {
            srcDirs 'src', 'toolsrc', 'xmlimplsrc'
        }
        resources {
            srcDirs 'src', 'toolsrc'
            exclude "build.xml"
            exclude "manifest"
        }
    }

    test {
        java {
            srcDirs "testsrc", 'examples'
            exclude 'tests/**'
        }
        resources {
            srcDirs "testsrc"
        }
    }
}

dependencies {
    testCompile "junit:junit:4.12"
    testCompile "org.yaml:snakeyaml:1.15"
    testCompile "net.trajano.caliper:caliper:1.2.1"
}

if (JavaVersion.current().isJava8Compatible()) {
    allprojects {
        tasks.withType(Javadoc) {
            options.addStringOption('Xdoclint:none', '-quiet')
        }
    }
}

test {
    useJUnit()
    exclude "**/benchmarks/**"
    systemProperty 'java.awt.headless', 'true'
    systemProperty 'mozilla.js.tests', 'testsrc/tests'
    systemProperty 'mozilla.js.tests.timeout', 60000
    systemProperty 'user.language', 'en'
    systemProperty 'user.country', 'US'
    systemProperty 'user.timezone', 'America/Los_Angeles'
    systemProperty 'file.encoding', 'UTF-8'
    maxHeapSize = "256m"
    testLogging.showStandardStreams = true
    // Many tests do not clean up contexts properly. This makes the tests much
    // more resilient at the expense of performance.
    forkEvery = 1
    maxParallelForks = 10
}

task sunSpiderBenchmark(type: JavaExec) {
    main "com.google.caliper.runner.CaliperMain"
    systemProperty 'rhino.benchmark.report', "${buildDir.absolutePath}"
    args "-Cresults.upload.class=org.mozilla.javascript.benchmarks.ResultPlotter", "-i", "runtime", "org.mozilla.javascript.benchmarks.CaliperSpiderBenchmark.Spider"
    classpath sourceSets.test.runtimeClasspath
}

task v8Benchmark(type: Test) {
    jacoco {
        enabled = false
    }
    include "**/benchmarks/V8Benchmark*"
    systemProperty 'rhino.benchmark.report', "${buildDir.absolutePath}"
    systemProperty 'file.encoding', 'UTF-8'
    workingDir = file("testsrc/benchmarks")
    maxHeapSize = "256m"
    testLogging.showStandardStreams = true
    forkEvery = 1
}

task testBenchmark() {}
testBenchmark.dependsOn sunSpiderBenchmark
testBenchmark.dependsOn v8Benchmark

task microBenchmark(type: JavaExec) {
    main "com.google.caliper.runner.CaliperMain"
    args "-i", "runtime", "org.mozilla.javascript.benchmarks.CaliperObjectBenchmark.FieldAccess", "-DstringKeys=100,1000", "-DintKeys=100,1000"
    classpath sourceSets.test.runtimeClasspath
}


idea {
    module {
        excludeDirs += file('testsrc/tests/src')
        excludeDirs += file('buildGradle')
        excludeDirs += file('build')
        excludeDirs += file('.idea')
        excludeDirs += file('lib')
    }
}

jar {
    from "LICENSE.txt"
    manifest {
        attributes(
            "Manifest-Version": "1.0",
            "Main-Class": "org.mozilla.javascript.tools.shell.Main",
            "Implementation-Version": project.version,
            "Implementation-Title":  "Mozilla Rhino",
            "Implementation-Vendor": "Mozilla Foundation",
            "Implementation-URL": "http://www.mozilla.org/rhino",
            "Built-Date": new Date().format("yyyy-MM-dd"),
            "Built-Time": new Date().format("HH:mm:ss")
        )
    }
}

task sourceJar(type: Jar) {
    from sourceSets.main.allJava
}

task rhinoJavadoc(type: Javadoc) {
    source = sourceSets.main.allJava
    if (JavaVersion.current().isJava8Compatible()) {
        options.addStringOption('Xdoclint:none', '-quiet')
    }
}

task rhinoJavadocJar(type: Jar, dependsOn: rhinoJavadoc) {
    from rhinoJavadoc.destinationDir
}

publishing {
    publications {
        rhino(MavenPublication) {
            groupId 'org.mozilla'
            artifactId 'rhino'

            pom.withXml {
                def root = asNode()

                root.appendNode('description', """
    Rhino is an open-source implementation of JavaScript written entirely in Java.
    It is typically embedded into Java applications to provide scripting to end users.
""")
                root.appendNode("url", "https://developer.mozilla.org/en/Rhino")

                def p = root.appendNode("parent")
                p.appendNode("groupId", "org.sonatype.oss")
                p.appendNode("artifactId", "oss-parent")
                p.appendNode("version", "7")

                def l = root.appendNode("licenses").appendNode("license")
                l.appendNode("name", "Mozilla Public License, Version 2.0")
                l.appendNode("url", "http://www.mozilla.org/MPL/2.0/index.txt")

                def scm = root.appendNode("scm")
                scm.appendNode("connection", "scm:git:git@github.com:mozilla/rhino.git")
                scm.appendNode("developerConnection", "scm:git:git@github.com:mozilla/rhino.git")
                scm.appendNode("url", "git@github.com:mozilla/rhino.git")

                def o = root.appendNode("organization")
                o.appendNode("name", "The Mozilla Foundation")
                o.appendNode("url", "http://www.mozilla.org")

            }
            from components.java
            artifact sourceJar {
                classifier "sources"
            }
            artifact rhinoJavadocJar {
                classifier "javadoc"
            }
        }
    }

    if (project.hasProperty("mavenPassword")) {
        repositories {
            maven {
                credentials {
                    username mavenUser
                    password mavenPassword
                }
                if (project.version.endsWith('-SNAPSHOT')) {
                    url mavenSnapshotRepo
                } else {
                    url mavenReleaseRepo
                }
            }
        }
    }
}

jacoco {
    toolVersion = "0.7.9"
}

jacocoTestReport.dependsOn test
jacocoTestReport {
    reports {
        html.destination file("${buildDir}/jacocoHtml")
    }
}

checkstyle {
    configFile = file("${projectDir}/checkstyle.xml")
    sourceSets = [project.sourceSets.main]
}

distributions {
    main {
        contents {
            from(sourceSets.main.java) {
                exclude 'man'
                into 'rhino' + project.version + '/src'
            }
            from(sourceSets.main.resources) {
                exclude '**/*.java'
                into 'rhino' + project.version + '/src'
            }
            from(javadoc.destinationDir) {
                into 'rhino' + project.version + '/docs'
            }
            from(jar.outputs.files) {
                into 'rhino' + project.version + '/lib'
            }
            from(sourceSets.main.allSource) {
                include 'man/*.1'
                into 'rhino' + project.version
            }
            from(file(".")) {
                include '*.txt', '*.md', 'build.gradle', 'build.properties', 'gradle.properties',
                        'gradle/**', 'gradlew'
                into 'rhino' + project.version 
            }
            into "/"
        }
    }
}

distZip.dependsOn javadoc, jar