build.gradle

buildscript {
    dependencies {
        classpath "org.yaml:snakeyaml:1.25"
    }
}

plugins {
    id "org.jetbrains.kotlin.multiplatform" apply false
    id "org.jetbrains.kotlin.js" apply false
    id("io.github.gradle-nexus.publish-plugin") version "1.3.0"
}

import org.gradle.nativeplatform.platform.internal.DefaultNativePlatform
import org.yaml.snakeyaml.Yaml

project.ext.letsPlotTaskGroup = 'lets-plot'

allprojects {
    group = 'org.jetbrains.lets-plot'
    version = "4.0.0-rc1"
    // see also: python-package/lets_plot/_version.py

    // Generate JVM 1.8 bytecode
    tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).configureEach {
        kotlinOptions.jvmTarget = "1.8"
    }

    tasks.withType(JavaCompile).configureEach {
        sourceCompatibility = "1.8"
        targetCompatibility = "1.8"
    }

    project.ext.jfx_platform = { -> //getJfxPlatform()
        OperatingSystem os = org.gradle.nativeplatform.platform.internal.DefaultNativePlatform.currentOperatingSystem
        if (os.isWindows()) {
            return "win"
        } else if (os.isLinux()) {
            return "linux"
        } else if (os.isMacOsX()) {
            return "mac"
        } else {
            return "unknown"
        }
    }

    project.ext.jfx_platform_resolved = project.ext.jfx_platform()

    repositories {
        mavenCentral()
    }
}

// Read build settings from commandline parameters (for build_release.py script):
def readSettingsFromParameters() {
    def settings = [
            build_python_extension: false,
            enable_python_package : false,
            python                : [bin_path: "", include_path: ""],
            pypi                  : [test: [username: null, password: null],
                                     prod: [username: null, password: null]]
    ]
    if (project.hasProperty("build_python_extension")) {
        settings.build_python_extension = project.getProperty("build_python_extension")
        assert settings.build_python_extension != null
    }
    if (project.hasProperty("enable_python_package")) {
        settings.enable_python_package = project.getProperty("enable_python_package")
        assert settings.enable_python_package != null
    }
    if (settings.build_python_extension) {
        settings.python.bin_path = project.getProperty("python_bin_path")
        settings.python.include_path = project.getProperty("python_include_path")
        assert !settings.python.bin_path.isEmpty()
        assert !settings.python.include_path.isEmpty()
    }
    return settings
}

// Read build settings from build_settings.yml:
def readSettingsFromYaml() {
    def build_settings_file = new File(rootDir, "build_settings.yml")
    if (!build_settings_file.canRead()) {
        throw new GradleException("Couldn't read build_settings.yml")
    }
    def settings = new Yaml().load(build_settings_file.newInputStream())
    if (settings.build_python_extension) {
        assert settings.python.include_path != null
    }
    if (settings.enable_python_package) {
        assert settings.build_python_extension
        assert settings.python.bin_path != null
    }
    return settings
}

// Get Python's arch to define Kotlin targets:
def getPythonArch() {
    def python_bin_path = project.buildSettings.python.bin_path
    def getArchOutput = new ByteArrayOutputStream()
    exec {
        commandLine "${python_bin_path}/python",
                "-c",
                "import platform; print(platform.machine())"
        standardOutput = getArchOutput
    }
    return getArchOutput.toString().trim()
}


// For build_release.py settings will be read from commandline parameters.
// If not, settings will be read from build_settings.yml.
if (project.hasProperty("build_release")) {
    project.ext.buildSettings = readSettingsFromParameters()
} else {
    project.ext.buildSettings = readSettingsFromYaml() as LinkedHashMap
}

// Read Python arch from commandline parameter if used:
if (project.hasProperty("build_arch")) {
    project.ext.pythonArch = project.getProperty("build_arch")
    assert !project.pythonArch.isEmpty()
} else if (project.buildSettings.build_python_extension) {
    project.ext.pythonArch = getPythonArch()
}

// Maven publication settings
// define local Maven Repository path:
project.ext.localMavenRepository = "$rootDir/.maven-publish-dev-repo"

// define Sonatype nexus repository manager settings:
nexusPublishing {
    repositories {
        maven {
            username = project.buildSettings?.sonatype?.username
            password = project.buildSettings?.sonatype?.password
            stagingProfileId = "11c25ff9a87b89"
            nexusUrl.set(uri("https://oss.sonatype.org/service/local/"))
            snapshotRepositoryUrl.set(uri("https://oss.sonatype.org/content/repositories/snapshots/"))
        }
    }
}


// "JavaDoc" artifact for all publications.
task jarJavaDocs(type: Jar) {
    group project.letsPlotTaskGroup
    classifier 'javadoc'
    from("$rootDir/README.md")
}

// Publish some sub-projects as Kotlin Multiproject libraries.
task publishLetsPlotCoreModulesToMavenLocalRepository {
    group project.letsPlotTaskGroup
}
task publishLetsPlotCoreModulesToMavenRepository {
    group project.letsPlotTaskGroup
}

subprojects {
    // Configure Kotlin targets.
    // List of modules used in Python native extension:
    if (name in [
            'commons',
            'datamodel',
            'plot-base',
            'plot-builder',
            'plot-stem',
            'platf-native',
            'demo-and-test-shared',
    ]) {
        apply plugin: "org.jetbrains.kotlin.multiplatform"

        def currentOs = DefaultNativePlatform.getCurrentOperatingSystem()

        kotlin {
            if (project.buildSettings.build_python_extension) {
                if (currentOs.macOsX & project.pythonArch == "x86_64") {
                    macosX64()
                } else if (currentOs.macOsX & project.pythonArch == "arm64") {
                    if (project.hasProperty("build_release")) {
                        macosX64()
                        macosArm64()
                    } else {
                        macosArm64()
                    }
                } else if (currentOs.linux) {
                    if (project.hasProperty("build_release")) {
                        linuxX64()
                        linuxArm64()
                    } else if (project.pythonArch == "x86_64") {
                        linuxX64()
                    }
                } else if (currentOs.windows) {
                    mingwX64()
                } else {
                    throw new Exception("Unsupported platform.")
                }
            }
        }
    }

    // Configure publishing core artifacts.
    if (name in [
            'commons',
            'datamodel',
            'canvas',
            'gis',
            'livemap',
            'plot-base',
            'plot-builder',
            'plot-stem',
            'plot-livemap',
            'platf-awt',
            'platf-batik',
            'platf-jfx-swing',
            'deprecated-in-v4'
    ]) {
        apply plugin: "org.jetbrains.kotlin.multiplatform"
        kotlin.jvm {}   // for `jvmSourcesJar` task

        apply plugin: "maven-publish"
        apply plugin: "signing"

        // Do not publish 'native' targets.
        def publications_to_publish = ["jvm", "js", "kotlinMultiplatform", "metadata"]

        publishing {
            publications {
                withType(MavenPublication) {
                    if (name in publications_to_publish) {
                        // Configure this publication.
                        artifact rootProject.jarJavaDocs

                        pom {
                            name = "Lets-Plot core artifact"
                            description = "A part of the Lets-Plot library."

                            url = "https://github.com/JetBrains/lets-plot"
                            licenses {
                                license {
                                    name = "MIT"
                                    url = "https://raw.githubusercontent.com/JetBrains/lets-plot/master/LICENSE"
                                }
                            }
                            developers {
                                developer {
                                    id = "jetbrains"
                                    name = "JetBrains"
                                    email = "lets-plot@jetbrains.com"
                                }
                            }
                            scm {
                                url = "https://github.com/JetBrains/lets-plot"
                            }
                        }
                    }
                }
            }
            repositories {
                mavenLocal {
                    url = uri(project.localMavenRepository)
                }
            }
        }

        afterEvaluate {

            // Add LICENSE file to the META-INF folder inside published JAR files
            jvmJar {
                metaInf {
                    from("$rootDir") {
                        include "LICENSE"
                    }
                }
            }

            // Configure artifacts signing process.
            def publications_to_sign = []
            for (task in it.tasks.withType(PublishToMavenRepository)) {
                if (task.getPublication().name in publications_to_publish) {
                    def repoName = task.repository.name
                    if (repoName == "MavenLocal") {
                        publishLetsPlotCoreModulesToMavenLocalRepository.dependsOn += task
                    } else if (repoName == "maven") {
                        publishLetsPlotCoreModulesToMavenRepository.dependsOn += task
                        publications_to_sign += task.getPublication()
                    } else {
                        throw new IllegalStateException("Repository expected: 'MavenLocal' or 'maven' but was: '$repoName'.")
                    }
                }
            }
            // Sign artifacts.
            publications_to_sign.each {
                signing.sign(it)
            }
        }
    }
}