kotlin-fork/dependencies/build.gradle

/*
 * Copyright 2010-2017 JetBrains s.r.o.
 *
 * 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.
 */


import groovy.transform.stc.ClosureParams
import groovy.transform.stc.ClosureSignatureHint
import groovy.transform.stc.FirstParam
import groovy.transform.stc.FromString
import org.jetbrains.kotlin.konan.target.*
import org.jetbrains.kotlin.konan.util.DependencyProcessor
import static org.jetbrains.kotlin.konan.target.KonanTarget.*
import static org.jetbrains.kotlin.konan.util.VisibleNamedKt.*
import org.jetbrains.kotlin.konan.properties.KonanProperties
import org.jetbrains.kotlin.konan.properties.*

buildscript {
    apply from: "$rootDir/gradle/kotlinGradlePlugin.gradle"

    repositories {
        jcenter()
    }
}

configurations {
    kotlin_compiler_jar
    kotlin_compiler_pom
    kotlin_compiler_src
    kotlin_compiler_doc

    kotlin_gradle_plugin_jar
    kotlin_gradle_plugin_pom
    kotlin_gradle_plugin_src
    kotlin_gradle_plugin_doc

    kotlin_stdlib_jdk8_jar
    kotlin_stdlib_jdk8_pom
    kotlin_stdlib_jdk8_src
    kotlin_stdlib_jdk8_doc

    kotlin_stdlib_jar
    kotlin_stdlib_pom
    kotlin_stdlib_src
    kotlin_stdlib_doc

    kotlin_reflect_jar
    kotlin_reflect_pom
    kotlin_reflect_src
    kotlin_reflect_doc

    kotlin_script_runtime_jar
    kotlin_script_runtime_pom
    kotlin_script_runtime_src
    kotlin_script_runtime_doc

}

def kotlinGradleModule = "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlinGradlePluginVersion"
def kotlinStdLibJdk8Module = "org.jetbrains.kotlin:kotlin-stdlib-jre8:$kotlinStdLibJdk8Version"

// TODO: Check if we really need the our bintray mirror and delete the uploading code below if we don't.
repositories {
    maven { url kotlinCompilerRepo }
}

dependencies {
    kotlin_compiler_jar "$kotlinCompilerModule@jar"
    kotlin_compiler_pom "$kotlinCompilerModule@pom"
    kotlin_compiler_src "$kotlinCompilerModule:sources@jar"
    kotlin_compiler_doc "$kotlinCompilerModule:javadoc@jar"

    kotlin_gradle_plugin_jar "$kotlinGradleModule@jar"
    kotlin_gradle_plugin_pom "$kotlinGradleModule@pom"
    kotlin_gradle_plugin_src "$kotlinGradleModule:sources@jar"
    kotlin_gradle_plugin_doc "$kotlinGradleModule:javadoc@jar"

    kotlin_stdlib_jdk8_jar "$kotlinStdLibJdk8Module@jar"
    kotlin_stdlib_jdk8_pom "$kotlinStdLibJdk8Module@pom"
    kotlin_stdlib_jdk8_src "$kotlinStdLibJdk8Module:sources@jar"
    kotlin_stdlib_jdk8_doc "$kotlinStdLibJdk8Module:javadoc@jar"

    kotlin_stdlib_jar "$kotlinStdLibModule@jar"
    kotlin_stdlib_pom "$kotlinStdLibModule@pom"
    kotlin_stdlib_src "$kotlinStdLibModule:sources@jar"
    kotlin_stdlib_doc "$kotlinStdLibModule:javadoc@jar"

    kotlin_reflect_jar "$kotlinReflectModule@jar"
    kotlin_reflect_pom "$kotlinReflectModule@pom"
    kotlin_reflect_src "$kotlinReflectModule:sources@jar"
    kotlin_reflect_doc "$kotlinReflectModule:javadoc@jar"

    kotlin_script_runtime_jar "$kotlinScriptRuntimeModule@jar"
    kotlin_script_runtime_pom "$kotlinScriptRuntimeModule@pom"
    kotlin_script_runtime_src "$kotlinScriptRuntimeModule:sources@jar"
    kotlin_script_runtime_doc "$kotlinScriptRuntimeModule:javadoc@jar"
}

def modules = ['compiler'      : kotlinCompilerModule,
               'gradle_plugin' : kotlinGradleModule,
               'stdlib_jdk8'   : kotlinStdLibJdk8Module,
               'stdlib'        : kotlinStdLibModule,
               'reflect'       : kotlinReflectModule,
               'script_runtime': kotlinScriptRuntimeModule
]
def uploads = modules.keySet()
uploads.each { target ->
    task("${target}Upload", type:GradleBuild) {
        tasks = ['bintrayUpload']
        buildFile project.file("upload.gradle")
        dir project.projectDir
        startParameter.projectProperties = [
                'user'    :  "${project.hasProperty('bintrayUser') ? project['bintrayUser'] : System.getenv('BINTRAY_USER')}",
                'key'     : "${ project.hasProperty('bintrayKey') ? project.property('bintrayKey') : System.getenv('BINTRAY_KEY')}",
                'module'  : modules["${target}"],
                'jar'     : project.configurations.getByName("kotlin_${target}_jar").files.collect {it.path},
                'src'     : project.configurations.getByName("kotlin_${target}_src").files.collect {it.path},
                'doc'     : project.configurations.getByName("kotlin_${target}_doc").files.collect {it.path},
                'pom'     : project.configurations.getByName("kotlin_${target}_pom").files.collect {it.path},
                'override': project.hasProperty("override") && project["override"]

        ]
    }
}

task update_kotlin_compiler(type: DefaultTask) {
    dependsOn uploads.collect{"${it}Upload"}
}

abstract class NativeDep extends DefaultTask {
    protected final String hostSystem = TargetManager.longerSystemName();
    static final String baseUrl = "https://jetbrains.bintray.com/kotlin-native-dependencies"

    @Input
    abstract String getFileName()

    protected String getUrl() {
        return "$baseUrl/$fileName"
    }

    protected File getBaseOutDir() {
        final File res = project.rootProject.ext.dependenciesDir
        res.mkdirs()
        return res
    }

    protected File download() {
        File result = new File(baseOutDir, fileName)
        if (!result.exists())
            ant.get(src: url, dest: result, usetimestamp: true)
        return result
    }
}

class TgzNativeDep extends NativeDep {
    String baseName

    @Override
    String getFileName() {
        return "${baseName}.tar.gz"
    }

    @OutputDirectory
    File getOutputDir() {
        return new File(baseOutDir, baseName)
    }

    @TaskAction
    public void downloadAndExtract() {
        File archived = this.download()

        try {
            // Builtin Gradle unpacking tools seem to unable to handle symlinks;
            // Use external "tar" executable as workaround:
            project.exec {
                executable "tar"
                workingDir baseOutDir
                args "xf", archived
            }
        } catch (Throwable e) {
            e.printStackTrace()
            project.delete(outputDir)
            throw e
        }
    }
}

class HelperNativeDep extends TgzNativeDep {

    Properties konanProperties = new Properties()

    @TaskAction
    public void downloadAndExtract() {
        def downloader = new DependencyProcessor(baseOutDir, konanProperties, [baseName], baseUrl, false)
        downloader.showInfo = false
        downloader.run()
    }
}

enum DependencyKind {
    LLVM(            "llvm",            { it.llvmHome },       { "llvmDir" }        ),
    GCC_TOOLCHAIN(   "gccToolchain",    { it.gccToolchain },   { "gccToolchainDir" }),
    SYSROOT(         "sysroot",         { it.targetSysRoot }                        ),
    LIBFFI(          "libffi",          { it.libffiDir }                            ),
    TARGET_TOOLCHAIN("targetToolchain", { it.targetToolchain }                      )


    DependencyKind(String name,
            @ClosureParams(value = FromString.class, options = "KonanProperties") Closure<String> dirGetter,
            @ClosureParams(value = FromString.class, options = "KonanTarget") Closure<String> propertyNameGetter =
                           {target -> "${getVisibleName(target)}${name.capitalize()}Dir"}) {
        this.name = name
        this.dirGetter = dirGetter
        this.propertyNameGetter = propertyNameGetter
    }

    private String name
    private Closure<String> dirGetter           // KonanProperties -> String
    private Closure<String> propertyNameGetter  // KonanTarget -> String

    String getDirectory(KonanProperties properties) {
        return dirGetter(properties)
    }

    String getPropertyName(KonanTarget target) {
        return propertyNameGetter(target)
    }

    String toString() { return name }
}

TargetManager.enabled.each { target ->
    def konanProperties = new KonanProperties(target,
            rootProject.ext.konanProperties,
            rootProject.ext.dependenciesDir.canonicalPath
    )

    konanProperties.dependencies.each { dependency ->
        if (tasks.findByName(dependency) == null) {
            task "${dependency}"(type: HelperNativeDep) {
                baseName = dependency
                it.konanProperties = rootProject.ext.konanProperties
            }
        }
    }

    // Also resolves all dependencies:
    final DependencyProcessor dependencyProcessor = new DependencyProcessor(
            project.rootProject.ext.dependenciesDir,
            rootProject.ext.konanProperties,
            konanProperties.dependencies,
            HelperNativeDep.baseUrl,
            false
    )

    DependencyKind.values().each { kind ->
        def dir = kind.getDirectory(konanProperties)
        if (dir != null) {
            String path = dependencyProcessor.resolveRelative(dir).canonicalPath
            rootProject.ext.set(kind.getPropertyName(target), path)
        }
    }
}

task update(type: Copy) {
    dependsOn tasks.withType(NativeDep)
}

task rmDotKonan(type: Delete) {
    delete "${System.getProperty("user.home")}/.konan"
}