CHANGELOG.md

@@ -7,19 +7,24 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 ### Added
-- Changelog plugin automatically applied to `project`
+- Changelog plugin automatically applied to `project`.
-- Feature matrix and Readme generation task for a `project` plugin
+- Feature matrix and Readme generation task for a `project` plugin.
+- Add `binary-compatibility-validator` to the `project` plugin.
+- Separate `yamlKt` serialization target
+- Separate `ain` plugin
 
 ### Changed
-- Remove node plugin and make node binaries available by default
+- Remove node plugin. Node binaries should be turned on manually.
-- Use default webpack distribution path
+- Use default webpack distribution path.
-- `ru.mipt.npm.base` -> `ru.mipt.npm.project`
+- `ru.mipt.npm.base` -> `ru.mipt.npm.project`.
 - Move publishing out of general extension and apply it to project plugin instead.
+- Platform plugins are now simple references to common plugin
 
 ### Deprecated
+- Support of `kaml` and `snake-yaml` in favor of `yamlKt`
 
 ### Removed
-- Node plugin
+- Node plugin.
 
 ### Fixed
 
@@ -28,14 +33,14 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 - Migrate to kotlin 1.4.0
-- Separate Native (current platform) and nodeJs plugins
+- Separate Native (current platform) and nodeJs plugins.
 - Add `application()` toggle in plugin configuration to produce binaries on JS and applicaion plugin on jvm.
-- Add `publish` to expose publishing configuration
+- Add `publish` to expose publishing configuration.
 
 ### Changed
--Publishing in bintray now is automatic
+-Publishing in bintray now is automatic.
 
 ## [0.5.2]
 
 ### Added
-- Copy resources for jvm modules and jvm source sets in mpp
+- Copy resources for jvm modules and jvm source sets in mpp.

build.gradle.kts

@@ -2,11 +2,11 @@ plugins {
     `java-gradle-plugin`
     `kotlin-dsl`
     `maven-publish`
-    id("org.jetbrains.changelog") version "0.5.0"
+    id("org.jetbrains.changelog") version "0.6.2"
 }
 
 group = "ru.mipt.npm"
-version = "0.6.1"
+version = "0.7.0"
 
 repositories {
     gradlePluginPortal()
@@ -16,7 +16,7 @@ repositories {
     maven("https://dl.bintray.com/kotlin/kotlin-dev")
 }
 
-val kotlinVersion = "1.4.10"
+val kotlinVersion = "1.4.20"
 
 java {
     targetCompatibility = JavaVersion.VERSION_1_8
@@ -27,13 +27,19 @@ dependencies {
     implementation("org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlinVersion")
     implementation("org.jetbrains.kotlin:kotlin-serialization:$kotlinVersion")
     implementation("org.jetbrains.kotlinx:atomicfu-gradle-plugin:0.14.4")
-    implementation("org.jetbrains.dokka:dokka-gradle-plugin:1.4.0")
+    implementation("org.jetbrains.dokka:dokka-gradle-plugin:1.4.10.2")
-    implementation("org.jetbrains.dokka:dokka-base:1.4.0")
+    implementation("org.jetbrains.dokka:dokka-base:1.4.10")
-    implementation("org.jetbrains.intellij.plugins:gradle-changelog-plugin:0.5.0")
+    implementation("org.jetbrains.intellij.plugins:gradle-changelog-plugin:0.6.2")
+    implementation("org.jetbrains.kotlinx:binary-compatibility-validator:0.2.4")
 }
 
 gradlePlugin {
     plugins {
+        create("kscience.common"){
+            id = "ru.mipt.npm.kscience"
+            description = "The generalized kscience plugin that works in conjunction with any kotlin plugin"
+            implementationClass = "ru.mipt.npm.gradle.KScienceCommonPlugin"
+        }
         create("kscience.project"){
             id = "ru.mipt.npm.project"
             description = "The root plugin for multimodule project infrastructure"
@@ -68,6 +74,12 @@ gradlePlugin {
             description = "Additional native targets to be use alongside mpp"
             implementationClass = "ru.mipt.npm.gradle.KScienceNativePlugin"
         }
+
+        create("kscience.node") {
+            id = "ru.mipt.npm.node"
+            description = "Additional nodejs target to be use alongside mpp"
+            implementationClass = "ru.mipt.npm.gradle.KScienceNodePlugin"
+        }
     }
 }
 

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-6.6.1-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-6.7-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

src/main/kotlin/ru/mipt/npm/gradle/KScienceCommonPlugin.kt

@@ -0,0 +1,140 @@
+package ru.mipt.npm.gradle
+
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.api.plugins.JavaPluginExtension
+import org.gradle.api.tasks.Copy
+import org.gradle.api.tasks.testing.Test
+import org.gradle.kotlin.dsl.*
+import org.jetbrains.kotlin.gradle.dsl.KotlinJsProjectExtension
+import org.jetbrains.kotlin.gradle.dsl.KotlinJvmCompile
+import org.jetbrains.kotlin.gradle.dsl.KotlinJvmProjectExtension
+import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
+
+open class KScienceCommonPlugin : Plugin<Project> {
+    override fun apply(project: Project): Unit = project.run {
+        //Common configuration
+        registerKScienceExtension()
+        repositories.applyRepos()
+
+        //Configuration for K-JVM plugin
+        pluginManager.withPlugin("org.jetbrains.kotlin.jvm") {
+            //logger.info("Applying KScience configuration for JVM project")
+            configure<KotlinJvmProjectExtension> {
+                explicitApiWarning()
+
+                sourceSets["main"].apply {
+                    languageSettings.applySettings()
+                }
+
+                sourceSets["test"].apply {
+                    languageSettings.applySettings()
+                    dependencies {
+                        implementation(kotlin("test-junit5"))
+                        implementation("org.junit.jupiter:junit-jupiter:5.6.1")
+                    }
+                }
+            }
+        }
+
+        pluginManager.withPlugin("org.jetbrains.kotlin.js") {
+            //logger.info("Applying KScience configuration for JS project")
+            configure<KotlinJsProjectExtension> {
+                explicitApiWarning()
+
+                js(IR) {
+                    browser()
+                }
+
+                sourceSets["main"].apply {
+                    languageSettings.applySettings()
+                }
+
+                sourceSets["test"].apply {
+                    languageSettings.applySettings()
+                    dependencies {
+                        implementation(kotlin("test-js"))
+                    }
+                }
+            }
+        }
+
+        pluginManager.withPlugin("org.jetbrains.kotlin.multiplatform") {
+            configure<KotlinMultiplatformExtension> {
+                explicitApiWarning()
+
+                jvm {
+                    compilations.all {
+                        kotlinOptions {
+//                        useIR = true
+                            jvmTarget = KScienceVersions.JVM_TARGET.toString()
+                        }
+                    }
+                }
+
+                js(IR) {
+                    browser()
+                }
+
+                sourceSets.invoke {
+                    val commonMain by getting
+                    val commonTest by getting {
+                        dependencies {
+                            implementation(kotlin("test-common"))
+                            implementation(kotlin("test-annotations-common"))
+                        }
+                    }
+                    val jvmMain by getting
+                    val jvmTest by getting {
+                        dependencies {
+                            implementation(kotlin("test-junit5"))
+                            implementation("org.junit.jupiter:junit-jupiter:5.6.1")
+                        }
+                    }
+                    val jsMain by getting
+                    val jsTest by getting {
+                        dependencies {
+                            implementation(kotlin("test-js"))
+                        }
+                    }
+                }
+
+                afterEvaluate {
+                    targets.all {
+                        sourceSets.all {
+                            languageSettings.applySettings()
+                        }
+                    }
+                }
+            }
+        }
+
+        afterEvaluate {
+            extensions.findByType<JavaPluginExtension>()?.apply {
+                targetCompatibility = KScienceVersions.JVM_TARGET
+                //withSourcesJar()
+                //withJavadocJar()
+            }
+
+            tasks.apply {
+                withType<KotlinJvmCompile> {
+                    kotlinOptions {
+    //                useIR = true
+                        jvmTarget = KScienceVersions.JVM_TARGET.toString()
+                    }
+                }
+                withType<Test> {
+                    useJUnitPlatform()
+                }
+
+                (findByName("processResources") as? Copy)?.apply {
+                    fromDependencies("runtimeClasspath")
+                }
+
+                (findByName("jsProcessResources") as? Copy)?.apply {
+                    fromDependencies("jsRuntimeClasspath")
+                }
+            }
+        }
+    }
+}

src/main/kotlin/ru/mipt/npm/gradle/KScienceExtension.kt

@@ -1,6 +1,7 @@
 package ru.mipt.npm.gradle
 
 import org.gradle.api.Project
+import org.gradle.api.plugins.ApplicationPlugin
 import org.gradle.kotlin.dsl.findByType
 import org.jetbrains.kotlin.gradle.dsl.KotlinJsProjectExtension
 import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
@@ -70,14 +71,17 @@ class KScienceExtension(val project: Project) {
         project.extensions.findByType<KotlinProjectExtension>()?.apply {
             explicitApi = null
         }
+
         project.pluginManager.withPlugin("org.jetbrains.kotlin.jvm") {
-            project.plugins.apply("org.gradle.application")
+            project.plugins.apply(ApplicationPlugin::class.java)
         }
+
         project.extensions.findByType<KotlinJsProjectExtension>()?.apply {
             js {
                 binaries.executable()
             }
         }
+
         project.extensions.findByType<KotlinMultiplatformExtension>()?.apply {
             js {
                 binaries.executable()
@@ -86,7 +90,6 @@ class KScienceExtension(val project: Project) {
                 binaries.executable()
             }
         }
-
     }
 }
 

src/main/kotlin/ru/mipt/npm/gradle/KScienceJSPlugin.kt

@@ -2,56 +2,15 @@ package ru.mipt.npm.gradle
 
 import org.gradle.api.Plugin
 import org.gradle.api.Project
-import org.gradle.api.tasks.Copy
+import org.gradle.kotlin.dsl.apply
-import org.gradle.kotlin.dsl.configure
-import org.gradle.kotlin.dsl.get
-import org.gradle.kotlin.dsl.getValue
-import org.gradle.kotlin.dsl.getting
-import org.jetbrains.kotlin.gradle.dsl.KotlinJsProjectExtension
 
 open class KScienceJSPlugin : Plugin<Project> {
     override fun apply(project: Project): Unit = project.run {
-        plugins.apply("org.jetbrains.kotlin.js")
+        if (plugins.findPlugin("org.jetbrains.kotlin.js") == null) {
-        registerKScienceExtension()
+            pluginManager.apply("org.jetbrains.kotlin.js")
-
+        } else {
-        repositories.applyRepos()
+            logger.info("Kotlin JS plugin is already present")
-
-        configure<KotlinJsProjectExtension> {
-            explicitApiWarning()
-            js(IR) {
-                browser()
-                nodejs()
         }
-            sourceSets["main"].apply {
+        plugins.apply(KScienceCommonPlugin::class)
-                languageSettings.applySettings()
-
-                dependencies {
-                    api(kotlin("stdlib-js"))
     }
-            }
-
-            sourceSets["test"].apply {
-                languageSettings.applySettings()
-                dependencies {
-                    implementation(kotlin("test-js"))
-                }
-            }
-        }
-
-        tasks.apply {
-
-            val processResources by getting(Copy::class)
-            processResources.copyJSResources(configurations["runtimeClasspath"])
-
-            findByName("jsBrowserDistribution")?.apply {
-                doLast {
-                    val indexFile = project.jsDistDirectory.resolve("index.html")
-                    if (indexFile.exists()) {
-                        println("Run JS distribution at: ${indexFile.canonicalPath}")
-                    }
-                }
-            }
-        }
-    }
-
 }

src/main/kotlin/ru/mipt/npm/gradle/KScienceJVMPlugin.kt

@@ -2,86 +2,16 @@ package ru.mipt.npm.gradle
 
 import org.gradle.api.Plugin
 import org.gradle.api.Project
-import org.gradle.api.plugins.JavaPluginExtension
+import org.gradle.kotlin.dsl.apply
-import org.gradle.api.publish.PublishingExtension
-import org.gradle.api.publish.maven.MavenPublication
-import org.gradle.api.tasks.Copy
-import org.gradle.api.tasks.bundling.Jar
-import org.gradle.api.tasks.testing.Test
-import org.gradle.kotlin.dsl.*
-import org.jetbrains.kotlin.gradle.dsl.KotlinJvmProjectExtension
-import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
 open class KScienceJVMPlugin : Plugin<Project> {
     override fun apply(project: Project): Unit = project.run {
-        plugins.apply("org.jetbrains.kotlin.jvm")
+        if (plugins.findPlugin("org.jetbrains.kotlin.jvm") == null) {
-        registerKScienceExtension()
+            pluginManager.apply("org.jetbrains.kotlin.jvm")
-
+        } else {
-        repositories.applyRepos()
+            logger.info("Kotlin JVM plugin is already present")
-
-        extensions.findByType<JavaPluginExtension>()?.apply {
-            targetCompatibility = KScienceVersions.JVM_TARGET
-        }
-
-        tasks.withType<KotlinCompile> {
-            kotlinOptions {
-//                useIR = true
-                jvmTarget = KScienceVersions.JVM_TARGET.toString()
-            }
-        }
-
-        configure<KotlinJvmProjectExtension> {
-            explicitApiWarning()
-            val sourceSet = sourceSets["main"].apply {
-                languageSettings.applySettings()
-            }
-
-            sourceSets["test"].apply {
-                languageSettings.applySettings()
-                dependencies {
-                    implementation(kotlin("test-junit5"))
-                    implementation("org.junit.jupiter:junit-jupiter:5.6.1")
-                }
-            }
-
-            val sourcesJar by tasks.registering(Jar::class) {
-                archiveClassifier.set("sources")
-                from(sourceSet.kotlin.srcDirs.first())
-            }
-
-            pluginManager.withPlugin("maven-publish") {
-
-                configure<PublishingExtension> {
-                    publications {
-                        register("jvm", MavenPublication::class) {
-                            from(components["java"])
-                            artifact(sourcesJar.get())
-                        }
-                    }
-                }
-
-//                pluginManager.withPlugin("org.jetbrains.dokka") {
-//                    logger.info("Adding dokka functionality to project ${project.name}")
-
-//                    val dokkaHtml by tasks.getting(DokkaTask::class){
-//                        dokkaSourceSets {
-//                            configureEach {
-//                                jdkVersion.set(11)
-//                            }
-//                        }
-//                    }
-//                }
-            }
-        }
-
-        tasks.apply {
-            withType<Test>() {
-                useJUnitPlatform()
-            }
-
-            val processResources by getting(Copy::class)
-            processResources.copyJVMResources(configurations["runtimeClasspath"])
         }
+        plugins.apply(KScienceCommonPlugin::class)
     }
 
 }

src/main/kotlin/ru/mipt/npm/gradle/KScienceMPPlugin.kt

@@ -2,110 +2,14 @@ package ru.mipt.npm.gradle
 
 import org.gradle.api.Plugin
 import org.gradle.api.Project
-import org.gradle.api.tasks.Copy
+import org.gradle.kotlin.dsl.apply
-import org.gradle.api.tasks.testing.Test
-import org.gradle.kotlin.dsl.*
-import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
 
 open class KScienceMPPlugin : Plugin<Project> {
     override fun apply(project: Project): Unit = project.run {
-        plugins.apply("org.jetbrains.kotlin.multiplatform")
+        if (plugins.findPlugin("org.jetbrains.kotlin.multiplatform") == null) {
-        registerKScienceExtension()
+            logger.info("Kotlin multiplatform plugin is not resolved. Adding it automatically")
-        repositories.applyRepos()
+            pluginManager.apply("org.jetbrains.kotlin.multiplatform")
-
-        configure<KotlinMultiplatformExtension> {
-            explicitApiWarning()
-
-            jvm {
-                compilations.all {
-                    kotlinOptions {
-//                        useIR = true
-                        jvmTarget = KScienceVersions.JVM_TARGET.toString()
-                    }
-                }
-            }
-
-            js(IR) {
-                browser()
-                nodejs()
-            }
-
-            sourceSets.invoke {
-                val commonMain by getting
-                val commonTest by getting {
-                    dependencies {
-                        implementation(kotlin("test-common"))
-                        implementation(kotlin("test-annotations-common"))
-                    }
-                }
-                val jvmMain by getting
-                val jvmTest by getting {
-                    dependencies {
-                        implementation(kotlin("test-junit5"))
-                        implementation("org.junit.jupiter:junit-jupiter:5.6.1")
-                    }
-                }
-                val jsMain by getting
-                val jsTest by getting {
-                    dependencies {
-                        implementation(kotlin("test-js"))
-                    }
-                }
-            }
-
-            afterEvaluate {
-                targets.all {
-                    sourceSets.all {
-                        languageSettings.applySettings()
-                    }
-                }
-            }
-
-//            pluginManager.withPlugin("org.jetbrains.dokka") {
-//                logger.info("Adding dokka functionality to project ${this@run.name}")
-//
-//                val dokkaHtml by tasks.getting(DokkaTask::class) {
-//                    dokkaSourceSets {
-//                        register("commonMain") {
-//                            displayName = "common"
-//                            platform = "common"
-//                        }
-//                        register("jvmMain") {
-//                            displayName = "jvm"
-//                            platform = "jvm"
-//                        }
-//                        register("jsMain") {
-//                            displayName = "js"
-//                            platform = "js"
-//                        }
-//                        configureEach {
-//                            jdkVersion = 11
-//                        }
-//                    }
-//                }
-//            }
-
-            tasks.apply {
-                withType<Test> {
-                    useJUnitPlatform()
-                }
-
-                val jsProcessResources by getting(Copy::class)
-                jsProcessResources.copyJSResources(configurations["jsRuntimeClasspath"])
-
-                val jvmProcessResources by getting(Copy::class)
-                jvmProcessResources.copyJVMResources(configurations["jvmRuntimeClasspath"])
-
-                findByName("jsBrowserDistribution")?.apply {
-                    doLast {
-                        val indexFile = project.jsDistDirectory.resolve("index.html")
-                        if (indexFile.exists()) {
-                            println("Run JS distribution at: ${indexFile.canonicalPath}")
-                        }
-                    }
-                }
-            }
-
         }
+        plugins.apply(KScienceCommonPlugin::class)
      }
 }

src/main/kotlin/ru/mipt/npm/gradle/KScienceNativePlugin.kt

@@ -9,30 +9,71 @@ import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
 class KScienceNativePlugin : Plugin<Project> {
     override fun apply(target: Project) = target.run {
         //Apply multiplatform plugin is not applied, apply it
-        if (plugins.findPlugin(KScienceMPPlugin::class) == null) {
+        if (plugins.findPlugin("org.jetbrains.kotlin.multiplatform") == null) {
-            logger.info("Multiplatform KScience plugin is not resolved. Adding it automatically")
+            logger.info("Kotlin multiplatform plugin is not resolved. Adding it automatically")
-            pluginManager.apply(KScienceMPPlugin::class)
+            pluginManager.apply("org.jetbrains.kotlin.multiplatform")
+        }
+        if (plugins.findPlugin(KScienceCommonPlugin::class) == null) {
+            logger.info("KScience plugin is not resolved. Adding it automatically")
+            pluginManager.apply(KScienceCommonPlugin::class)
         }
 
         configure<KotlinMultiplatformExtension> {
-            val hostOs = System.getProperty("os.name")
+            val ideaActive = System.getProperty("idea.active") == "true"
-            val isMingwX64 = hostOs.startsWith("Windows")
 
-            val nativeTarget = when {
+            if (ideaActive) {
+                //development mode
+                val hostOs = System.getProperty("os.name")
+
+                when {
                     hostOs == "Mac OS X" -> macosX64("native")
                     hostOs == "Linux" -> linuxX64("native")
-                isMingwX64 -> {
+                    hostOs.startsWith("Windows") -> mingwX64("native")
-                    mingwX64("native")
-                    linuxX64()
-                }
                     else -> throw GradleException("Host OS is not supported in Kotlin/Native.")
                 }
+            } else {
+                //deploy mode
+                linuxX64()
+                mingwX64()
+                macosX64()
 
-            sourceSets.invoke {
+                sourceSets{
-                val nativeMain by getting
+                    val commonMain by getting
-                findByName("linuxX64Main")?.dependsOn(nativeMain)
+                    val nativeMain by creating{
-                val nativeTest by getting
+                        dependsOn(commonMain)
-                findByName("linuxX64Test")?.dependsOn(nativeTest)
+                    }
+
+                    val commonTest by getting
+
+                    val nativeTest by creating{
+                        dependsOn(nativeMain)
+                        dependsOn(commonTest)
+                    }
+
+                    val linuxX64Main by getting{
+                        dependsOn(nativeMain)
+                    }
+
+                    val mingwX64Main by getting{
+                        dependsOn(nativeMain)
+                    }
+
+                    val macosX64Main by getting{
+                        dependsOn(nativeMain)
+                    }
+
+                    val linuxX64Test by getting{
+                        dependsOn(nativeTest)
+                    }
+
+                    val mingwX64Test by getting{
+                        dependsOn(nativeTest)
+                    }
+
+                    val macosX64Test by getting{
+                        dependsOn(nativeTest)
+                    }
+                }
             }
         }
     }

src/main/kotlin/ru/mipt/npm/gradle/KScienceNodePlugin.kt

@@ -0,0 +1,46 @@
+package ru.mipt.npm.gradle
+
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.kotlin.dsl.*
+import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
+
+/**
+ * Create a separate target for node
+ */
+class KScienceNodePlugin : Plugin<Project> {
+    override fun apply(target: Project) = target.run {
+        //Apply multiplatform plugin is not applied, apply it
+        if (plugins.findPlugin("org.jetbrains.kotlin.multiplatform") == null) {
+            logger.info("Kotlin multiplatform plugin is not resolved. Adding it automatically")
+            pluginManager.apply("org.jetbrains.kotlin.multiplatform")
+        }
+        if (plugins.findPlugin(KScienceCommonPlugin::class) == null) {
+            logger.info("KScience plugin is not resolved. Adding it automatically")
+            pluginManager.apply(KScienceCommonPlugin::class)
+        }
+
+        configure<KotlinMultiplatformExtension> {
+            js(name = "node", compiler = IR) {
+                nodejs()
+            }
+            sourceSets {
+                val commonMain by getting
+                val nodeMain by creating {
+                    dependsOn(commonMain)
+                    dependencies{
+                        api("org.jetbrains.kotlinx:kotlinx-nodejs:${KScienceVersions.kotlinxNodeVersion}")
+                    }
+                }
+
+                val commonTest by getting
+
+                val nodeTest by creating {
+                    dependsOn(nodeMain)
+                    dependsOn(commonTest)
+                }
+            }
+        }
+
+    }
+}

src/main/kotlin/ru/mipt/npm/gradle/KScienceProjectPlugin.kt

@@ -1,17 +1,16 @@
 package ru.mipt.npm.gradle
 
 import groovy.text.SimpleTemplateEngine
+import kotlinx.validation.BinaryCompatibilityValidatorPlugin
 import org.gradle.api.Plugin
 import org.gradle.api.Project
-import org.gradle.kotlin.dsl.apply
+import org.gradle.kotlin.dsl.*
-import org.gradle.kotlin.dsl.extra
-import org.gradle.kotlin.dsl.findByType
-import org.gradle.kotlin.dsl.provideDelegate
 import org.jetbrains.changelog.ChangelogPlugin
+import org.jetbrains.dokka.gradle.DokkaPlugin
+import org.jetbrains.dokka.gradle.DokkaTask
 import java.io.File
 import kotlin.collections.component1
 import kotlin.collections.component2
-import kotlin.reflect.KFunction
 
 class KSciencePublishingExtension(val project: Project) {
     var githubOrg: String? by project.extra
@@ -36,7 +35,7 @@ class KScienceReadmeExtension(val project: Project) {
     var description: String = ""
     var maturity: Maturity = Maturity.EXPERIMENTAL
 
-    var readmeTemplate: File = project.file("docs/README-TEMPLATE.md")//"docs/README-TEMPLATE.md"
+    var readmeTemplate: File = project.file("docs/README-TEMPLATE.md")
 
     data class Feature(val id: String, val ref: String, val description: String, val name: String = id)
 
@@ -46,31 +45,32 @@ class KScienceReadmeExtension(val project: Project) {
         features.add(Feature(id, ref, description, name))
     }
 
-    val properties: MutableMap<String, Any?> = mutableMapOf(
+    val properties: MutableMap<String, () -> Any?> = mutableMapOf(
-        "name" to project.name,
+        "name" to { project.name },
-        "group" to project.group,
+        "group" to { project.group },
-        "version" to project.version,
+        "version" to { project.version },
-        "features" to featuresString()
+        "features" to { featuresString() }
     )
 
-    private val actualizedProperties get() = properties.mapValues {(_,value)->
+    private fun getActualizedProperties() = properties.mapValues { (_, value) ->
-        if(value is KFunction<*>){
+        value.invoke()
-            value.call()
-        } else {
-            value
-        }
     }
 
     fun property(key: String, value: Any?) {
-        properties[key] = value
+        properties[key] = {value}
     }
 
-    fun propertyByTemplate(key: String, template: String){
+    fun propertyByTemplate(key: String, template: String) {
-        properties[key] = SimpleTemplateEngine().createTemplate(template).make(actualizedProperties).toString()
+        val actual = getActualizedProperties()
+        properties[key] = {SimpleTemplateEngine().createTemplate(template).make(actual).toString()}
     }
 
-    fun propertyByTemplate(key: String, template: File){
+    internal val additionalFiles = ArrayList<File>()
-        properties[key] = SimpleTemplateEngine().createTemplate(template).make(actualizedProperties).toString()
+
+    fun propertyByTemplate(key: String, template: File) {
+        val actual = getActualizedProperties()
+        properties[key] = {SimpleTemplateEngine().createTemplate(template).make(actual).toString()}
+        additionalFiles.add(template)
     }
 
     /**
@@ -87,7 +87,8 @@ class KScienceReadmeExtension(val project: Project) {
      */
     fun readmeString(): String? {
         return if (readmeTemplate.exists()) {
-            SimpleTemplateEngine().createTemplate(readmeTemplate).make(actualizedProperties).toString()
+            val actual = getActualizedProperties()
+            SimpleTemplateEngine().createTemplate(readmeTemplate).make(actual).toString()
         } else {
             null
         }
@@ -100,6 +101,9 @@ class KScienceReadmeExtension(val project: Project) {
 open class KScienceProjectPlugin : Plugin<Project> {
     override fun apply(target: Project): Unit = target.run {
         apply<ChangelogPlugin>()
+        apply<DokkaPlugin>()
+        apply<BinaryCompatibilityValidatorPlugin>()
+
         val rootReadmeExtension = KScienceReadmeExtension(this)
         extensions.add("ksciencePublish", KSciencePublishingExtension(this))
         extensions.add("readme", rootReadmeExtension)
@@ -108,25 +112,57 @@ open class KScienceProjectPlugin : Plugin<Project> {
         subprojects {
             val readmeExtension = KScienceReadmeExtension(this)
             extensions.add("readme", readmeExtension)
-            tasks.create("generateReadme") {
+            val generateReadme by tasks.creating {
                 group = "documentation"
                 description = "Generate a README file if stub is present"
+
+                if(readmeExtension.readmeTemplate.exists()) {
+                    inputs.file(readmeExtension.readmeTemplate)
+                }
+                readmeExtension.additionalFiles.forEach {
+                    if(it.exists()){
+                        inputs.file(it)
+                    }
+                }
+
+                val readmeFile = this@subprojects.file("README.md")
+                outputs.file(readmeFile)
+
                 doLast {
                     val readmeString = readmeExtension.readmeString()
                     if (readmeString != null) {
-                        val readmeFile = this@subprojects.file("README.md")
                         readmeFile.writeText(readmeString)
                     }
                 }
             }
+            tasks.withType<DokkaTask>{
+                dependsOn(generateReadme)
+            }
         }
 
-        tasks.create("generateReadme") {
+        val generateReadme by tasks.creating {
             group = "documentation"
             description = "Generate a README file and a feature matrix if stub is present"
 
+            subprojects {
+                tasks.findByName("generateReadme")?.let {
+                    dependsOn(it)
+                }
+            }
+
+            if(rootReadmeExtension.readmeTemplate.exists()) {
+                inputs.file(rootReadmeExtension.readmeTemplate)
+            }
+            rootReadmeExtension.additionalFiles.forEach {
+                if(it.exists()){
+                    inputs.file(it)
+                }
+            }
+
+            val readmeFile = project.file("README.md")
+            outputs.file(readmeFile)
+
             doLast {
-                val reader = groovy.json.JsonSlurper()
                 val projects = subprojects.associate {
                     it.name to it.extensions.findByType<KScienceReadmeExtension>()
                 }
@@ -135,15 +171,20 @@ open class KScienceProjectPlugin : Plugin<Project> {
 
                     val modulesString = buildString {
                         projects.entries.forEach { (name, ext) ->
-                            appendln("### [$name]($name)")
+                            appendln("<hr/>")
+                            appendln("\n* ### [$name]($name)")
                             if (ext != null) {
-                                appendln(ext.description)
+                                appendln("> ${ext.description}")
-                                appendln("**Maturity**: ${ext.maturity}")
+                                appendln(">\n> **Maturity**: ${ext.maturity}")
-                                appendln("#### Features:")
+                                val featureString = ext.featuresString(itemPrefix = "> - ", pathPrefix = "$name/")
-                                appendln(ext.featuresString(pathPrefix = "$name/"))
+                                if(featureString.isNotBlank()) {
+                                    appendln(">\n> **Features:**")
+                                    appendln(featureString)
                                 }
                             }
                         }
+                        appendln("<hr/>")
+                    }
 
                     val rootReadmeProperties: Map<String, Any?> = mapOf(
                         "name" to project.name,
@@ -152,13 +193,31 @@ open class KScienceProjectPlugin : Plugin<Project> {
                         "modules" to modulesString
                     )
 
-                    val readmeFile = project.file("README.md")
                     readmeFile.writeText(
-                        SimpleTemplateEngine().createTemplate(rootReadmeExtension.readmeTemplate).make(rootReadmeProperties).toString()
+                        SimpleTemplateEngine().createTemplate(rootReadmeExtension.readmeTemplate)
+                            .make(rootReadmeProperties).toString()
                     )
                 }
 
             }
         }
+
+        tasks.withType<DokkaTask>{
+            dependsOn(generateReadme)
+        }
+
+        val patchChangelog by tasks.getting
+
+        val release by tasks.creating{
+            group = RELEASE_GROUP
+            description = "Publish development or production release based on version suffix"
+            dependsOn(generateReadme, patchChangelog)
+            tasks.findByName("publishAllPublicationsToBintrayRepository")?.let {
+                dependsOn(it)
+            }
+        }
+    }
+    companion object{
+        const val RELEASE_GROUP = "release"
     }
 }

src/main/kotlin/ru/mipt/npm/gradle/KScienceVersions.kt

@@ -6,15 +6,19 @@ import org.gradle.api.JavaVersion
  * Build constants
  */
 object KScienceVersions {
-    const val coroutinesVersion = "1.3.9"
+    const val kotlinVersion = "1.4.20"
-    const val serializationVersion = "1.0.0-RC"
+    const val kotlinxNodeVersion = "0.0.7"
+    const val coroutinesVersion = "1.4.1"
+    const val serializationVersion = "1.0.1"
     const val atomicVersion = "0.14.4"
 
     val JVM_TARGET = JavaVersion.VERSION_11
 
     object Serialization{
-        const val xmlVersion = "0.80.0-RC"//to be fixed
+        const val xmlVersion = "0.80.1"
+        @Deprecated("Use yamlKt instead")
         const val yamlVersion = "0.21.0"
-        const val bsonVersion = "0.4.1-rc"
+        const val bsonVersion = "0.4.2"
+        const val yamlKtVersion = "0.7.4"
     }
 }

src/main/kotlin/ru/mipt/npm/gradle/SerializationTargets.kt

@@ -8,6 +8,17 @@ class SerializationTargets(
     val sourceSet: DependencySourceSet,
     val configuration: DependencyConfiguration
 ) {
+
+    fun Project.json(
+        version: String = KScienceVersions.serializationVersion
+    ) {
+        useCommonDependency(
+            "org.jetbrains.kotlinx:kotlinx-serialization-json:$version",
+            dependencySourceSet = sourceSet,
+            dependencyConfiguration = configuration
+        )
+    }
+
     fun Project.cbor(
         version: String = KScienceVersions.serializationVersion
     ) {
@@ -34,15 +45,14 @@ class SerializationTargets(
         repositories {
             maven("https://dl.bintray.com/pdvrieze/maven")
         }
-        useDependency(
+        useCommonDependency(
-            "common" to "net.devrieze:xmlutil-serialization:$version",
+            "net.devrieze:xmlutil-serialization:$version",
-            "jvm" to "net.devrieze:xmlutil-serialization:$version",
-            "js" to "net.devrieze:xmlutil-serialization:$version",
             dependencySourceSet = sourceSet,
             dependencyConfiguration = configuration
         )
     }
 
+    @Deprecated("Use multiplatform yamlKt instead")
     fun Project.yaml(
         version: String = KScienceVersions.Serialization.yamlVersion
     ) {
@@ -53,6 +63,16 @@ class SerializationTargets(
         )
     }
 
+    fun Project.yamlKt(
+        version: String = KScienceVersions.Serialization.yamlVersion
+    ) {
+        useCommonDependency(
+            "net.mamoe.yamlkt:yamlkt:$version",
+            dependencySourceSet = sourceSet,
+            dependencyConfiguration = configuration
+        )
+    }
+
     fun Project.bson(
         version: String = KScienceVersions.Serialization.bsonVersion
     ) {

src/main/kotlin/ru/mipt/npm/gradle/common.kt

@@ -1,13 +1,11 @@
 package ru.mipt.npm.gradle
 
-import org.gradle.api.Project
-import org.gradle.api.artifacts.Configuration
 import org.gradle.api.artifacts.ProjectDependency
 import org.gradle.api.artifacts.dsl.RepositoryHandler
 import org.gradle.api.tasks.Copy
+import org.gradle.kotlin.dsl.get
 import org.gradle.kotlin.dsl.maven
 import org.jetbrains.kotlin.gradle.plugin.LanguageSettingsBuilder
-import java.io.File
 
 internal fun LanguageSettingsBuilder.applySettings(): Unit {
     progressiveMode = true
@@ -17,6 +15,7 @@ internal fun LanguageSettingsBuilder.applySettings(): Unit {
     useExperimentalAnnotation("kotlin.ExperimentalStdlibApi")
     useExperimentalAnnotation("kotlin.time.ExperimentalTime")
     useExperimentalAnnotation("kotlin.contracts.ExperimentalContracts")
+    useExperimentalAnnotation("kotlin.js.ExperimentalJsExport")
 }
 
 internal fun RepositoryHandler.applyRepos(): Unit {
@@ -31,73 +30,54 @@ internal fun RepositoryHandler.applyRepos(): Unit {
     maven("https://dl.bintray.com/mipt-npm/dataforge")
 }
 
-
+internal fun Copy.fromDependencies(configurationName: String) = project.afterEvaluate {
-internal fun Copy.copyJSResources(configuration: Configuration): Unit = project.afterEvaluate {
+    val configuration = configurations[configurationName]
-    val projectDeps = configuration
+        ?: error("Configuration with name $configurationName could not be resolved.")
-        .allDependencies
+    val projectDeps = configuration.allDependencies.filterIsInstance<ProjectDependency>().map {
-        .filterIsInstance<ProjectDependency>()
+        it.dependencyProject
-        .map { it.dependencyProject }
+    }
-
+    into(buildDir.resolve("processedResources/js"))
-    val destination = destinationDir
-
     projectDeps.forEach { dep ->
+        dep.afterEvaluate {
             dep.pluginManager.withPlugin("org.jetbrains.kotlin.multiplatform") {
                 dep.tasks.findByName("jsProcessResources")?.let { task ->
-                val sourceDir = (task as Copy).destinationDir
-                inputs.files(sourceDir)
                     dependsOn(task)
-                from(sourceDir)
+                    from(task)
+                    //from(dep.buildDir.resolve("processedResources/js"))
                 }
+                //from(dep.buildDir.resolve("processedResources/js"))
             }
             dep.pluginManager.withPlugin("org.jetbrains.kotlin.js") {
                 dep.tasks.findByName("processResources")?.let { task ->
-                val sourceDir = (task as Copy).destinationDir
-                inputs.files(sourceDir)
                     dependsOn(task)
-                from(sourceDir)
+                    from(task)
+                    //from(dep.buildDir.resolve("processedResources/js"))
                 }
-        }
+                // from(dep.buildDir.resolve("processedResources/js"))
-    }
-}
-
-internal fun Copy.copyJVMResources(configuration: Configuration): Unit = project.afterEvaluate {
-    val projectDeps = configuration
-        .allDependencies
-        .filterIsInstance<ProjectDependency>()
-        .map { it.dependencyProject }
-
-    val destination = destinationDir
-
-    projectDeps.forEach { dep ->
-        dep.pluginManager.withPlugin("org.jetbrains.kotlin.multiplatform") {
-            dep.tasks.findByName("jvmProcessResources")?.let { task ->
-                val sourceDir = (task as Copy).destinationDir
-                inputs.files(sourceDir)
-                dependsOn(task)
-                from(sourceDir)
-            }
-        }
-        dep.pluginManager.withPlugin("org.jetbrains.kotlin.jvm") {
-            dep.tasks.findByName("processResources")?.let { task ->
-                val sourceDir = (task as Copy).destinationDir
-                inputs.files(sourceDir)
-                dependsOn(task)
-                from(sourceDir)
             }
         }
     }
 }
 
 
-val Project.jsDistDirectory: File
+//
-    get() {
+//internal fun Copy.copyJVMResources(configuration: Configuration): Unit = project.afterEvaluate {
-        val distributionName = listOf(
+//    val projectDeps = configuration.allDependencies
-            name,
+//        .filterIsInstance<ProjectDependency>()
-            "js",
+//        .map { it.dependencyProject }
-            version.toString()
+//
-        ).joinToString("-")
+//    projectDeps.forEach { dep ->
-
+//        dep.pluginManager.withPlugin("org.jetbrains.kotlin.multiplatform") {
-        return buildDir.resolve(
+//            dep.tasks.findByName("jvmProcessResources")?.let { task ->
-            "distributions/$distributionName"
+//                dependsOn(task)
-        )
+//                from(task)
-    }
+//            }
+//        }
+//        dep.pluginManager.withPlugin("org.jetbrains.kotlin.jvm") {
+//            dep.tasks.findByName("processResources")?.let { task ->
+//                dependsOn(task)
+//                from(task)
+//            }
+//        }
+//    }
+//}

src/main/kotlin/ru/mipt/npm/gradle/dependencies.kt

@@ -1,9 +1,10 @@
 package ru.mipt.npm.gradle
 
-import kotlinx.atomicfu.plugin.gradle.sourceSets
 import org.gradle.api.Project
-import org.gradle.kotlin.dsl.findByType
+import org.gradle.kotlin.dsl.configure
 import org.gradle.kotlin.dsl.invoke
+import org.jetbrains.kotlin.gradle.dsl.KotlinJsProjectExtension
+import org.jetbrains.kotlin.gradle.dsl.KotlinJvmProjectExtension
 import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
 
 enum class DependencyConfiguration {
@@ -23,7 +24,7 @@ internal fun Project.useDependency(
     dependencyConfiguration: DependencyConfiguration = DependencyConfiguration.IMPLEMENTATION
 ) {
     pluginManager.withPlugin("org.jetbrains.kotlin.multiplatform") {
-        extensions.findByType<KotlinMultiplatformExtension>()?.apply {
+        configure<KotlinMultiplatformExtension> {
             sourceSets {
                 pairs.forEach { (target, dep) ->
                     val name = target + dependencySourceSet.suffix
@@ -43,6 +44,7 @@ internal fun Project.useDependency(
 
     pairs.find { it.first == "jvm" }?.let { dep ->
         pluginManager.withPlugin("org.jetbrains.kotlin.jvm") {
+            configure<KotlinJvmProjectExtension> {
                 sourceSets.findByName(dependencySourceSet.setName)?.apply {
                     dependencies.apply {
                         val configurationName = when (dependencyConfiguration) {
@@ -55,9 +57,11 @@ internal fun Project.useDependency(
                 }
             }
         }
+    }
 
     pairs.find { it.first == "js" }?.let { dep ->
         pluginManager.withPlugin("org.jetbrains.kotlin.js") {
+            configure<KotlinJsProjectExtension> {
                 sourceSets.findByName(dependencySourceSet.setName)?.apply {
                     dependencies.apply {
                         val configurationName = when (dependencyConfiguration) {
@@ -70,15 +74,16 @@ internal fun Project.useDependency(
                 }
             }
         }
+    }
 }
 
 internal fun Project.useCommonDependency(
     dep: String,
     dependencySourceSet: DependencySourceSet = DependencySourceSet.MAIN,
     dependencyConfiguration: DependencyConfiguration = DependencyConfiguration.IMPLEMENTATION
-): Unit = pluginManager.run{
+): Unit = pluginManager.run {
-    withPlugin("org.jetbrains.kotlin.multiplatform"){
+    withPlugin("org.jetbrains.kotlin.multiplatform") {
-        extensions.findByType<KotlinMultiplatformExtension>()?.apply {
+        configure<KotlinMultiplatformExtension> {
             sourceSets.findByName("common${dependencySourceSet.suffix}")?.apply {
                 dependencies {
                     when (dependencyConfiguration) {
@@ -90,7 +95,10 @@ internal fun Project.useCommonDependency(
             }
         }
     }
+
+
     withPlugin("org.jetbrains.kotlin.jvm") {
+        configure<KotlinJvmProjectExtension> {
             sourceSets.findByName(dependencySourceSet.setName)?.apply {
                 dependencies.apply {
                     val configurationName = when (dependencyConfiguration) {
@@ -102,7 +110,9 @@ internal fun Project.useCommonDependency(
                 }
             }
         }
+    }
     withPlugin("org.jetbrains.kotlin.js") {
+        configure<KotlinJsProjectExtension> {
             sourceSets.findByName(dependencySourceSet.setName)?.apply {
                 dependencies.apply {
                     val configurationName = when (dependencyConfiguration) {
@@ -114,4 +124,5 @@ internal fun Project.useCommonDependency(
                 }
             }
         }
+    }
 }