atomicfu/build.gradle

/*
 * Copyright 2017-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
 */


apply plugin: 'kotlin-multiplatform'
apply from: rootProject.file("gradle/targets.gradle")

project.ext.nativeMainSets = []
project.ext.nativeTestSets = []
project.ext.nativeCompilations = []

kotlin {
    targets.metaClass.addTarget = { preset ->
        def target = delegate.fromPreset(preset, preset.name)
        project.ext.nativeMainSets.add(target.compilations['main'].kotlinSourceSets.first())
        project.ext.nativeTestSets.add(target.compilations['test'].kotlinSourceSets.first())
        project.ext.nativeCompilations.add(target.compilations['main'])
    }

    targets {
        // JVM & JS -- always
        fromPreset(presets.jvm, 'jvm')
        fromPreset(presets.js, 'js')

        if (project.ext.ideaActive) {
            fromPreset(project.ext.ideaPreset, 'native')
        } else {
            addTarget(presets.linuxX64)
            addTarget(presets.iosArm64)
            addTarget(presets.iosArm32)
            addTarget(presets.iosX64)
            addTarget(presets.macosX64)
            addTarget(presets.mingwX64)
            addTarget(presets.tvosArm64)
            addTarget(presets.tvosX64)
            addTarget(presets.watchosArm32)
            addTarget(presets.watchosArm64)
            addTarget(presets.watchosX86)
        }
    }
    sourceSets {
        commonMain {
            dependencies {
                implementation 'org.jetbrains.kotlin:kotlin-stdlib-common'
            }
        }
        commonTest {
            dependencies {
                implementation 'org.jetbrains.kotlin:kotlin-test-common'
                implementation 'org.jetbrains.kotlin:kotlin-test-annotations-common'
            }
        }
        jsMain {
            dependencies {
                implementation 'org.jetbrains.kotlin:kotlin-stdlib-js'
            }
        }
        jsTest {
            dependencies {
                implementation 'org.jetbrains.kotlin:kotlin-test-js'
            }
        }
        jvmMain {
            dependencies {
                implementation 'org.jetbrains.kotlin:kotlin-stdlib'
            }
        }
        jvmTest {
            dependencies {
                implementation 'org.jetbrains.kotlin:kotlin-reflect'
                implementation 'org.jetbrains.kotlin:kotlin-test'
                implementation 'org.jetbrains.kotlin:kotlin-test-junit'
                implementation "junit:junit:$junit_version"
            }
        }
        nativeMain { dependsOn commonMain }

        nativeTest {}

        if (!project.ext.ideaActive) {
            configure(nativeMainSets) {
                dependsOn nativeMain
            }

            configure(nativeTestSets) {
                dependsOn nativeTest
            }
        }
    }

    configure(project.ext.nativeCompilations) {
        cinterops {
            interop {
                defFile 'src/nativeInterop/cinterop/interop.def'
            }
        }
    }
}

configurations {
    transformer
}

apply from: rootProject.file('gradle/compile-options.gradle')

ext.configureKotlin(org.jetbrains.kotlin.gradle.tasks.KotlinCompile)

dependencies {
    transformer project(":atomicfu-transformer")
}

// ==== CONFIGURE JS =====

tasks.withType(compileKotlinJs.getClass()) {
    kotlinOptions {
        moduleKind = "umd"
        sourceMap = true
        metaInfo = true
    }
}

compileKotlinJs {
    kotlinOptions {
        // NOTE: Module base-name must be equal to the package name declared in package.json
        def baseName = "kotlinx-atomicfu"
        outputFile = new File(outputFile.parent, baseName + ".js")
    }
}

apply from: file("$rootProject.projectDir/gradle/node-js.gradle")
apply from: file("$rootProject.projectDir/gradle/test-mocha-js.gradle")
apply from: file("$rootProject.projectDir/gradle/publish-npm-js.gradle")

// Workaround the problem with Node downloading
repositories.whenObjectAdded {
    if (it instanceof IvyArtifactRepository) {
        metadataSources {
            artifact()
        }
    }
}

def originalJsFile = "$buildDir/classes/kotlin/js/test/atomicfu_test.js"
def transformedJsFile = "$buildDir/classes/kotlin/js/test/atomicfu_test_transformed.js"

task transformJS(type: JavaExec, dependsOn: [compileTestKotlinJs]) {
    main = "kotlinx.atomicfu.transformer.AtomicFUTransformerJSKt"
    args = [originalJsFile, transformedJsFile, true]
    classpath = configurations.transformer
    inputs.file(originalJsFile)
    outputs.file(transformedJsFile)
}

testMochaNode.dependsOn transformJS

// ==== CONFIGURE JVM =====

def classesPreAtomicFuDir = file("$buildDir/classes/kotlin/jvm/test")
def classesPostTransformFU = file("$buildDir/classes/kotlin/jvm/postTransformedFU")
def classesPostTransformVH = file("$buildDir/classes/kotlin/jvm/postTransformedVH")
def classesPostTransformBOTH = file("$buildDir/classes/kotlin/jvm/postTransformedBOTH")

task transformFU(type: JavaExec, dependsOn: compileTestKotlinJvm) {
    main = "kotlinx.atomicfu.transformer.AtomicFUTransformerKt"
    args = [classesPreAtomicFuDir, classesPostTransformFU, "FU"]
    classpath = configurations.transformer
    inputs.dir(classesPreAtomicFuDir)
    outputs.dir(classesPostTransformFU)
}

task transformBOTH(type: JavaExec, dependsOn: compileTestKotlinJvm) {
    main = "kotlinx.atomicfu.transformer.AtomicFUTransformerKt"
    args = [classesPreAtomicFuDir, classesPostTransformBOTH, "BOTH"]
    classpath = configurations.transformer
    inputs.dir(classesPreAtomicFuDir)
    outputs.dir(classesPostTransformBOTH)
}

task transformVH(type: JavaExec, dependsOn: compileTestKotlinJvm) {
    main = "kotlinx.atomicfu.transformer.AtomicFUTransformerKt"
    args = [classesPreAtomicFuDir, classesPostTransformVH, "VH"]
    classpath = configurations.transformer
    inputs.dir(classesPreAtomicFuDir)
    outputs.dir(classesPostTransformVH)
}

task checkJdk16() {
    doLast {
        if (!System.env.JDK_16) {
            throw new GradleException("JDK_16 environment variable is not defined. " +
                    "Can't build against JDK 1.6 runtime and run JDK 1.6 compatibility tests. " +
                    "Please ensure JDK 1.6 is installed and that JDK_16 points to it.")
        }
    }
}

task transformedTestFU_6(type: Test, dependsOn: [checkJdk16, transformFU]) {
    executable = "$System.env.JDK_16/bin/java"
    classpath = configurations.jvmTestRuntimeClasspath + project.files(classesPostTransformFU)
    testClassesDirs = project.files(classesPostTransformFU)
    exclude '**/*LFTest.*'
}

task transformedTestFU_current(type: Test, dependsOn: transformFU) {
    classpath = files(configurations.jvmTestRuntimeClasspath, classesPostTransformFU)
    testClassesDirs = project.files(classesPostTransformFU)
    exclude '**/*LFTest.*'
}

task transformedTestBOTH_6(type: Test, dependsOn: [checkJdk16, transformBOTH]) {
    executable = "$System.env.JDK_16/bin/java"
    classpath = files(configurations.jvmTestRuntimeClasspath, classesPostTransformBOTH)
    testClassesDirs = project.files(classesPostTransformBOTH)
    exclude '**/*LFTest.*'
}

task transformedTestBOTH_current(type: Test, dependsOn: transformBOTH) {
    classpath = files(configurations.jvmTestRuntimeClasspath, classesPostTransformBOTH)
    testClassesDirs = project.files(classesPostTransformBOTH)
    exclude '**/*LFTest.*'
}

task transformedTestVH(type: Test, dependsOn: transformVH) {
    classpath = files(configurations.jvmTestRuntimeClasspath, classesPostTransformVH)
    testClassesDirs = project.files(classesPostTransformVH)
    exclude '**/*LFTest.*'
}

transformedTestVH.onlyIf {
    logger.println(JavaVersion.current())
    JavaVersion.current().ordinal() >= JavaVersion.VERSION_1_9.ordinal()
}

task jvmTestAll(dependsOn: [
        transformedTestFU_6,
        transformedTestFU_current,
        transformedTestBOTH_6,
        transformedTestBOTH_current,
        transformedTestVH])

tasks.withType(Test) {
    testLogging {
        showStandardStreams = true
        events "passed", "failed"
    }
}

jvmTest.dependsOn jvmTestAll

afterEvaluate {
    publishing.publications {
        jvm.artifactId = 'atomicfu'
        js.artifactId = 'atomicfu-js'
        metadata.artifactId = 'atomicfu-common'
        kotlinMultiplatform.artifactId = 'atomicfu-native'
    }
}