kotlin-fork/libraries/stdlib/js/build.gradle

plugins {
    id "com.moowork.node" version "1.2.0"
}

description = 'Kotlin Standard Library for JS'

apply plugin: 'kotlin2js'
apply plugin: 'idea'

configureDist(project)
configurePublishing(project)


def builtinsSrcDir = "${buildDir}/builtin-sources"
def builtinsSrcDir2 = "${buildDir}/builtin-sources-for-builtins"
def commonSrcDir = "${buildDir}/common-sources"
def commonTestSrcDir = "${buildDir}/common-test-sources"
def builtinsDir = "${rootDir}/core/builtins"
def experimentalSrcDir = "${rootDir}/libraries/stdlib/experimental"
def jsSrcGeneratedDir = "${rootDir}/js/js.libraries/src/core/generated" // to be removed soon
def jsSrcDir = "src"
def jsTestSrcDir = "test"
def jsSrcJsDir = "${jsSrcDir}/js"
def jsOutputFile = "${buildDir}/classes/kotlin.js"

def kotlinTestJsOutputFile = "${project(':kotlin-test:kotlin-test-js').buildDir}/classes/main/kotlin-test.js"

// TODO: take from sourcesets' outputs
def jsTestOutputFile = "${buildDir}/classes/kotlin/test/kotlin-stdlib-js_test.js"
def kotlinTestJsTestOutputFile = "${project(':kotlin-test:kotlin-test-js').buildDir}/classes/kotlin/test/kotlin-test-js_test.js"


sourceSets {
    builtins {
        kotlin {
            srcDir builtinsSrcDir2
            srcDir 'runtime'
        }
    }

    main {
        kotlin {
            srcDir builtinsSrcDir
            srcDir jsSrcDir
            srcDir jsSrcGeneratedDir
            srcDir commonSrcDir
        }
    }

    experimental {
        kotlin {
            srcDir experimentalSrcDir
        }
    }

    test {
        kotlin {
            srcDir commonTestSrcDir
            srcDir jsTestSrcDir
        }
    }
}

configurations {
    merger
}
dependencies {
    testCompile project(':kotlin-test:kotlin-test-js')
    merger project(":tools:kotlin-stdlib-js-merger")
}

idea {
    module {
        excludeDirs = excludeDirs + files('node_modules')
    }
}

createPreprocessorTask(project, "Main", "${projectDir}/../src/kotlin", commonSrcDir)
createPreprocessorTask(project, "Test", "${projectDir}/../test", commonTestSrcDir)

task prepareComparableSource(type: Copy) {
    doFirst {
        delete builtinsSrcDir2
    }
    from("${builtinsDir}/native/kotlin") {
        include "Comparable.kt"
    }
    into builtinsSrcDir2
}

task prepareBuiltinsSources(type: Copy) {
    doFirst {
        delete builtinsSrcDir
    }
    from("${builtinsDir}/native/kotlin") {
        include "Iterator.kt"
        include "Collections.kt"
        include "CharSequence.kt"
        include "Annotation.kt"
    }
    from("${builtinsDir}/src/kotlin/") {
        include "annotation/Annotations.kt"
        include "Function.kt"
        include "Iterators.kt"
        include "Range.kt"
        include "Progressions.kt"
        include "ProgressionIterators.kt"
        include "Ranges.kt"
        include "internal/InternalAnnotations.kt"
        include "internal/progressionUtil.kt"
        include "reflect/**/*.kt"
        include "Unit.kt"
    }
    into builtinsSrcDir
}

kotlin.experimental.coroutines "enable"

tasks.withType(org.jetbrains.kotlin.gradle.tasks.Kotlin2JsCompile) {
    kotlinOptions {
        main = "noCall"
        moduleKind = "commonjs"
        freeCompilerArgs = [
                "-version",
                "-Xallow-kotlin-package",
        ]
    }
}

compileBuiltinsKotlin2Js {
    dependsOn prepareComparableSource
    kotlinOptions {
        metaInfo = false
        outputFile = "${buildDir}/classes/builtins/kotlin.js"
        sourceMap = true
        sourceMapPrefix = "./"
    }
}

compileKotlin2Js {
    dependsOn preprocessSourcesMain, prepareBuiltinsSources
    kotlinOptions {
        outputFile = "${buildDir}/classes/main/kotlin.js"
        sourceMap = true
        sourceMapPrefix = "./"
        freeCompilerArgs += [ "-source-map-base-dirs", [builtinsSrcDir, jsSrcDir, commonSrcDir].collect { file(it).absoluteFile }.join(File.pathSeparator) ]
    }
}

compileExperimentalKotlin2Js {
    dependsOn compileKotlin2Js
    kotlinOptions {
        languageVersion = "1.3"
        apiVersion = "1.3"
        outputFile = "${buildDir}/classes/main/kotlin-experimental.js"
        sourceMap = true
        sourceMapPrefix = "./"
        freeCompilerArgs += [ "-source-map-base-dirs", [experimentalSrcDir].join(File.pathSeparator) ]
    }
}

compileTestKotlin2Js {
    dependsOn preprocessSourcesTest
    kotlinOptions {
        moduleKind = "umd"
    }
}

task compileJs(type: JavaExec) {
    dependsOn compileBuiltinsKotlin2Js, compileKotlin2Js, compileExperimentalKotlin2Js
    inputs.files(compileBuiltinsKotlin2Js.outputs.files)
    inputs.files(compileKotlin2Js.outputs.files)
    inputs.files(compileExperimentalKotlin2Js.outputs.files)
    inputs.dir(jsSrcDir)
    outputs.file(jsOutputFile)
    outputs.file("${jsOutputFile}.map")

    def inputFiles = fileTree(jsSrcJsDir) {
        include '**/*.js'
    }

    main = "org.jetbrains.kotlin.js.FileMergerKt"
    doFirst {
        args = [jsOutputFile, rootDir, "$jsSrcDir/wrapper.js"] + inputFiles.collect { it.path } +
               (compileBuiltinsKotlin2Js.outputs.files.collect { it.path } +
               compileKotlin2Js.outputs.files.collect { it.path } +
               compileExperimentalKotlin2Js.outputs.files.collect { it.path }).findAll {
                   it.endsWith(".js") && !it.endsWith(".meta.js")
               }
    }
    classpath = configurations.merger

    doLast {
        ant.replaceregexp(
                file: jsOutputFile,
                match: "module.exports,\\s*require\\([^)]+\\)",
                replace: "",
                byline: "true", encoding: "UTF-8")
        ant.replaceregexp(
                file: jsOutputFile,
                match: "function\\s*\\(_,\\s*Kotlin\\)",
                replace: "function()",
                byline: "true", encoding: "UTF-8")
        ant.replaceregexp(
                file: jsOutputFile,
                match: "return\\s+_;",
                replace: "",
                byline: "true", encoding: "UTF-8")

        def sourceMapFile = file("${jsOutputFile}.map")
        def sourceMap = new groovy.json.JsonSlurper().parseText(sourceMapFile.text)

        def sourceMapBasePaths = [
                "./",
                "libraries/stdlib/js/src/js/",
                "libraries/stdlib/js/src/",
        ]
        sourceMap.sources = sourceMap.sources.collect { sourcePath ->
            def prefixToRemove = sourceMapBasePaths.find { basePath -> sourcePath.startsWith(basePath) }
            if (prefixToRemove != null) sourcePath.substring(prefixToRemove.length()) else sourcePath
        }

        def sourceMapSourcesBaseDirs = [jsSrcDir, jsSrcJsDir, jsSrcGeneratedDir, builtinsSrcDir, commonSrcDir, projectDir]

        sourceMap.sourcesContent = sourceMap.sources.collect { sourceName ->
            def text = sourceMapSourcesBaseDirs.collect { file("$it/$sourceName") }.find { it.exists() }?.text
            if (text == null) logger.warn("Sources missing for file $sourceName")
            text
        }

        sourceMapFile.text = groovy.json.JsonOutput.toJson(sourceMap)
    }
}

classes.dependsOn compileJs


jar {
    enabled false
}

task mergedJar(type: Jar, dependsOn: classes) {
    classifier = null
    manifestAttributes(manifest, project, 'Main')

    // TODO: Use standard implementation title after js stdlib detector becomes more flexible
    Properties properties = new Properties()
    new File("${rootDir}/resources/kotlinManifest.properties").withInputStream {
        properties.load(it)
    }
    manifest.attributes 'Implementation-Title' : properties."manifest.impl.title.kotlin.javascript.stdlib"

    includeEmptyDirs false
    duplicatesStrategy DuplicatesStrategy.EXCLUDE
    from jsOutputFile
    from "${jsOutputFile}.map"
    from sourceSets.main.output
}

task sourcesJar(type: Jar, dependsOn: classes) {
    classifier = 'sources'
    includeEmptyDirs false
    from (sourceSets.builtins.allSource) {
        into 'kotlin'
    }
    from (sourceSets.main.allSource) {
        into 'kotlin'
        exclude '**/*.java'
        exclude 'org.w3c/**'
        exclude 'js/**'
    }
    from (sourceSets.main.allSource) {
        include 'org.w3c/**'
    }
    from (sourceSets.experimental.allSource) {
        into 'kotlin'
    }
}


artifacts {
    runtime mergedJar
    archives mergedJar
    archives sourcesJar
    archives javadocJar
}

task distJs(type: Copy) {
    from(compileJs)
    into "$distDir/js"
}

dist {
    dependsOn distJs
    [mergedJar, sourcesJar].forEach {
        from(it)
        // legacy
        from(it) {
            rename("kotlin-stdlib-js", 'kotlin-jslib')
        }
    }
}

task populateNodeModules(type: Copy, dependsOn: [compileJs, compileTestKotlin2Js]) {
    from jsOutputFile
    from kotlinTestJsOutputFile

    into "${buildDir}/node_modules"
}

node {
    download = true
    version = '8.9.4' // The default 6.9.1 has buggy hyperbolic functions implementation
    nodeModulesDir = buildDir
}

task installMocha(type: NpmTask, dependsOn: [populateNodeModules]) {
    args = ['install', 'mocha']
}

task installTeamcityReporter(type: NpmTask, dependsOn: [populateNodeModules]) {
    args = ['install', 'mocha-teamcity-reporter']
}

task runMocha(type: NodeTask, dependsOn: [compileTestKotlin2Js, populateNodeModules, installMocha]) {
    script = file("${buildDir}/node_modules/mocha/bin/mocha")
    args = [jsTestOutputFile]

    if (project.hasProperty("teamcity")) {
        dependsOn installTeamcityReporter
        args = ['--reporter', 'mocha-teamcity-reporter'] + args

        execOverrides {
            it.ignoreExitValue = true
        }
    }
}

test.dependsOn runMocha