kotlin-fork/dependencies/build.gradle

/*
 * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
 * that can be found in the LICENSE file.
 */
import groovy.transform.stc.ClosureParams
import groovy.transform.stc.FromString
import org.jetbrains.kotlin.konan.target.*
import static org.jetbrains.kotlin.konan.target.KonanTarget.*
import org.jetbrains.kotlin.konan.util.Named
import org.jetbrains.kotlin.konan.properties.KonanPropertiesLoader
import org.jetbrains.kotlin.konan.util.ArchiveType
import org.jetbrains.kotlin.konan.util.DependencyProcessor

import static org.jetbrains.kotlin.konan.util.VisibleNamedKt.getVisibleName

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

    repositories {
        maven {
            url = 'https://cache-redirector.jetbrains.com/jcenter'
        }
    }
}

/**
 * Downloads dependencies from the given URL into the given directory.
 * The set of dependencies is determined by konanPropertiesLoader.
 */
class NativeDep extends DefaultTask {
    static final String baseUrl = "https://cache-redirector.jetbrains.com/download.jetbrains.com/kotlin/native"

    KonanPropertiesLoader konanPropertiesLoader = null

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

    @TaskAction
    void downloadAndExtract() {
        def downloader = new DependencyProcessor(baseOutDir, konanPropertiesLoader, baseUrl, false, ArchiveType.systemDefault)
        downloader.showInfo = false
        downloader.run()
    }
}

enum DependencyKind {
    LLVM(            "llvm",            { it.llvmHome },       { "llvmDir" }        ),
    LIBFFI(          "libffi",          { it.libffiDir }                            )


    DependencyKind(String name,
            @ClosureParams(value = FromString.class, options = "KonanPropertiesLoader") Closure<String> dirGetter,
            @ClosureParams(value = FromString.class, options = "KonanTarget") Closure<String> propertyNameGetter =
                           {target -> "${target.visibleName}${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(KonanPropertiesLoader properties) {
        return dirGetter(properties)
    }

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

    String toString() { return name }
}

def platformManager = rootProject.ext.platformManager


platformManager.filteredOutEnabledButNotSupported.each { target ->
    def loader = platformManager.loader(target)

    task "${target}Dependencies"(type: NativeDep) {
        konanPropertiesLoader = loader
    }

    // Also resolves all dependencies:
    final DependencyProcessor dependencyProcessor = new DependencyProcessor(
            project.rootProject.ext.dependenciesDir,
            loader.properties,
            loader.dependencies,
            NativeDep.baseUrl,
            false,
            ArchiveType.systemDefault
    )

    DependencyKind.values().each { kind ->
        def dir = kind.getDirectory(loader)
        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) {
    def dir = System.getenv("KONAN_DATA_DIR") ?: "${System.getProperty("user.home")}/.konan"
    delete dir
}