build.gradle

import groovy.io.FileType
import groovy.text.GStringTemplateEngine

buildscript {
    repositories {
        mavenCentral()
    }
}

plugins {
    id("org.jetbrains.kotlin.multiplatform").version("1.5.21")
    id("org.jetbrains.kotlin.plugin.serialization").version("1.5.21")
    id "maven-publish"
}

group 'ru.spbstu'
version (findProperty('forceVersion') ?: '0.0.2.4')

repositories {
    mavenCentral()
}

task gen() {
    def srcDir = file("src/commonMain/resources/kotlin")
    def dstDir = file("src/commonMain/kotlin")

    outputs.dir(dstDir)
    inputs.dir(srcDir)
    doLast {
        def binding = [number: Integer.parseInt(project.findProperty("generationDepth") ?: "7")]
        def engine = new GStringTemplateEngine()

        def newFiles = []

        mkdir dstDir

        srcDir.eachFileRecurse(FileType.FILES) { file ->
            if (file.name.endsWith(".template")) {
                println "Processing template " + file

                def rel = srcDir.toURI().relativize(file.toURI())
                def newFile = new File(dstDir.toURI().resolve(rel))

                newFile = new File(newFile.parentFile, newFile.name.replace(".template", ""))
                mkdir newFile.parentFile
                newFile.createNewFile()
                newFiles.add([file, newFile])
            }
        }

        newFiles.each { file ->
            List.metaClass.map = { lambda -> delegate.map(lambda) }
            List.metaClass.repeat = { lambda -> delegate.collect(lambda).join(', ') }
            Integer.metaClass.join = { lambda -> (0..<delegate).repeat(lambda) }

            def template = engine.createTemplate(file[0]).make(binding)

            println "Writing file " + file[1]

            file[1].withWriter { writer -> template.writeTo(writer) }
        }
    }

}

kotlin {
    jvm {
        compilations.all {
            kotlinOptions {
                jvmTarget = "1.8"
            }
        }
    }
    js(BOTH) {
        nodejs()
        browser {
            testTask {
                useKarma {
                    useFirefoxHeadless()
                }
            }
        }
    }

    targets.all {
        compilations.all {
            compileKotlinTask.dependsOn(gen)
        }
    }

    sourceSets {
        all {
            languageSettings {
                languageVersion = "1.5"
                apiVersion = "1.5"
                useExperimentalAnnotation("kotlin.RequiresOptIn")
            }
        }

        commonMain {
            dependencies {
                implementation("org.jetbrains.kotlinx:kotlinx-serialization-core:1.2.2")
            }
        }
        commonTest {
            dependsOn(commonMain)
            dependencies {
                implementation(kotlin("test-common"))
                implementation(kotlin("test-annotations-common"))
                implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.2.2")
            }
        }
        jvmMain {
            dependsOn(commonMain)
        }
        jvmTest {
            dependsOn(commonTest)
            dependsOn(jvmMain)
            dependencies {
                implementation(kotlin("test"))
            }
        }
        jsMain {
            dependsOn(commonMain)
        }
        jsTest {
            dependsOn(commonTest)
            dependsOn(jsMain)
            dependencies {
                api(kotlin("test-js"))
            }
        }
    }
}

clean {
    afterEvaluate {
        delete 'src/commonMain/kotlin'
    }
}

publishing {
    repositories {
        maven {
            name = "GitHubPackages"
            url = "https://maven.pkg.github.com/vorpal-research/kotlin-maven"
            credentials {
                username = (project.findProperty('githubActor') ?: System.getenv('GITHUB_ACTOR'))
                password = (project.findProperty('githubToken') ?: System.getenv('GITHUB_TOKEN'))
            }
        }
    }
}