kscience/gradle-tools
8
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 9 Wiki Activity

Dev #5

Merged
altavir merged 24 commits from dev into master 2020-12-28 09:44:15 +03:00
Conversation 0 Commits 24 Files Changed 20 +516 -402
15 changed files with 516 additions and 402 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit fc8f03e47e - Show all commits

25
CHANGELOG.md
View File

@ -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`
- Feature matrix and Readme generation task for a `project` plugin
- Changelog plugin automatically applied to `project`.
- 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
- Use default webpack distribution path
- `ru.mipt.npm.base` -> `ru.mipt.npm.project`
- Remove node plugin. Node binaries should be turned on manually.
- Use default webpack distribution path.
- `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.

24
build.gradle.kts
View File

@ -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-base:1.4.0")
implementation("org.jetbrains.intellij.plugins:gradle-changelog-plugin:0.5.0")
implementation("org.jetbrains.dokka:dokka-gradle-plugin:1.4.10.2")
implementation("org.jetbrains.dokka:dokka-base:1.4.10")
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"
}
}
}

2
gradle/wrapper/gradle-wrapper.properties vendored
View File

@ -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

140
src/main/kotlin/ru/mipt/npm/gradle/KScienceCommonPlugin.kt Normal file
View File

@ -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")
}
}
}
}
}

7
src/main/kotlin/ru/mipt/npm/gradle/KScienceExtension.kt
View File

@ -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()
}
}
}
}

53
src/main/kotlin/ru/mipt/npm/gradle/KScienceJSPlugin.kt
View File

@ -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.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
import org.gradle.kotlin.dsl.apply
open class KScienceJSPlugin : Plugin<Project> {
override fun apply(project: Project): Unit = project.run {
plugins.apply("org.jetbrains.kotlin.js")
registerKScienceExtension()
repositories.applyRepos()
configure<KotlinJsProjectExtension> {
explicitApiWarning()
js(IR) {
browser()
nodejs()
}
sourceSets["main"].apply {
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}")
}
}
}
if (plugins.findPlugin("org.jetbrains.kotlin.js") == null) {
pluginManager.apply("org.jetbrains.kotlin.js")
} else {
logger.info("Kotlin JS plugin is already present")
}
plugins.apply(KScienceCommonPlugin::class)
}
}

82
src/main/kotlin/ru/mipt/npm/gradle/KScienceJVMPlugin.kt
View File

@ -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.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
import org.gradle.kotlin.dsl.apply
open class KScienceJVMPlugin : Plugin<Project> {
override fun apply(project: Project): Unit = project.run {
plugins.apply("org.jetbrains.kotlin.jvm")
registerKScienceExtension()
repositories.applyRepos()
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"])
if (plugins.findPlugin("org.jetbrains.kotlin.jvm") == null) {
pluginManager.apply("org.jetbrains.kotlin.jvm")
} else {
logger.info("Kotlin JVM plugin is already present")
}
plugins.apply(KScienceCommonPlugin::class)
}
}

108
src/main/kotlin/ru/mipt/npm/gradle/KScienceMPPlugin.kt
View File

@ -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.api.tasks.testing.Test
import org.gradle.kotlin.dsl.*
import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
import org.gradle.kotlin.dsl.apply
open class KScienceMPPlugin : Plugin<Project> {
override fun apply(project: Project): Unit = project.run {
plugins.apply("org.jetbrains.kotlin.multiplatform")
registerKScienceExtension()
repositories.applyRepos()
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}")
}
}
}
}
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")
}
}
plugins.apply(KScienceCommonPlugin::class)
}
}

77
src/main/kotlin/ru/mipt/npm/gradle/KScienceNativePlugin.kt
View File

@ -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) {
logger.info("Multiplatform KScience plugin is not resolved. Adding it automatically")
pluginManager.apply(KScienceMPPlugin::class)
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> {
val hostOs = System.getProperty("os.name")
val isMingwX64 = hostOs.startsWith("Windows")
val ideaActive = System.getProperty("idea.active") == "true"
val nativeTarget = when {
hostOs == "Mac OS X" -> macosX64("native")
hostOs == "Linux" -> linuxX64("native")
isMingwX64 -> {
mingwX64("native")
linuxX64()
if (ideaActive) {
//development mode
val hostOs = System.getProperty("os.name")
when {
hostOs == "Mac OS X" -> macosX64("native")
hostOs == "Linux" -> linuxX64("native")
hostOs.startsWith("Windows") -> mingwX64("native")
else -> throw GradleException("Host OS is not supported in Kotlin/Native.")
}
else -> throw GradleException("Host OS is not supported in Kotlin/Native.")
}
} else {
//deploy mode
linuxX64()
mingwX64()
macosX64()
sourceSets.invoke {
val nativeMain by getting
findByName("linuxX64Main")?.dependsOn(nativeMain)
val nativeTest by getting
findByName("linuxX64Test")?.dependsOn(nativeTest)
sourceSets{
val commonMain by getting
val nativeMain by creating{
dependsOn(commonMain)
}
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)
}
}
}
}
}

46
src/main/kotlin/ru/mipt/npm/gradle/KScienceNodePlugin.kt Normal file
View File

@ -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)
}
}
}
}
}

127
src/main/kotlin/ru/mipt/npm/gradle/KScienceProjectPlugin.kt
View File

@ -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.extra
import org.gradle.kotlin.dsl.findByType
import org.gradle.kotlin.dsl.provideDelegate
import org.gradle.kotlin.dsl.*
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(
"name" to project.name,
"group" to project.group,
"version" to project.version,
"features" to featuresString()
val properties: MutableMap<String, () -> Any?> = mutableMapOf(
"name" to { project.name },
"group" to { project.group },
"version" to { project.version },
"features" to { featuresString() }
)
private val actualizedProperties get() = properties.mapValues {(_,value)->
if(value is KFunction<*>){
value.call()
} else {
value
}
private fun getActualizedProperties() = properties.mapValues { (_, value) ->
value.invoke()
}
fun property(key: String, value: Any?) {
properties[key] = value
properties[key] = {value}
}
fun propertyByTemplate(key: String, template: String){
properties[key] = SimpleTemplateEngine().createTemplate(template).make(actualizedProperties).toString()
fun propertyByTemplate(key: String, template: String) {
val actual = getActualizedProperties()
properties[key] = {SimpleTemplateEngine().createTemplate(template).make(actual).toString()}
}
fun propertyByTemplate(key: String, template: File){
properties[key] = SimpleTemplateEngine().createTemplate(template).make(actualizedProperties).toString()
internal val additionalFiles = ArrayList<File>()
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,14 +171,19 @@ 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("**Maturity**: ${ext.maturity}")
appendln("#### Features:")
appendln(ext.featuresString(pathPrefix = "$name/"))
appendln("> ${ext.description}")
appendln(">\n> **Maturity**: ${ext.maturity}")
val featureString = ext.featuresString(itemPrefix = "> - ", pathPrefix = "$name/")
if(featureString.isNotBlank()) {
appendln(">\n> **Features:**")
appendln(featureString)
}
}
}
appendln("<hr/>")
}
val rootReadmeProperties: Map<String, Any?> = mapOf(
@ -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"
}
}

12
src/main/kotlin/ru/mipt/npm/gradle/KScienceVersions.kt
View File

@ -6,15 +6,19 @@ import org.gradle.api.JavaVersion
* Build constants
*/
object KScienceVersions {
const val coroutinesVersion = "1.3.9"
const val serializationVersion = "1.0.0-RC"
const val kotlinVersion = "1.4.20"
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"
}
}

28
src/main/kotlin/ru/mipt/npm/gradle/serialization.kt → src/main/kotlin/ru/mipt/npm/gradle/SerializationTargets.kt
View File

@ -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(
"common" to "net.devrieze:xmlutil-serialization:$version",
"jvm" to "net.devrieze:xmlutil-serialization:$version",
"js" to "net.devrieze:xmlutil-serialization:$version",
useCommonDependency(
"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
) {

108
src/main/kotlin/ru/mipt/npm/gradle/common.kt
View File

@ -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.copyJSResources(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("jsProcessResources")?.let { task ->
val sourceDir = (task as Copy).destinationDir
inputs.files(sourceDir)
dependsOn(task)
from(sourceDir)
}
}
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)
}
}
internal fun Copy.fromDependencies(configurationName: String) = project.afterEvaluate {
val configuration = configurations[configurationName]
?: error("Configuration with name $configurationName could not be resolved.")
val projectDeps = configuration.allDependencies.filterIsInstance<ProjectDependency>().map {
it.dependencyProject
}
}
internal fun Copy.copyJVMResources(configuration: Configuration): Unit = project.afterEvaluate {
val projectDeps = configuration
.allDependencies
.filterIsInstance<ProjectDependency>()
.map { it.dependencyProject }
val destination = destinationDir
into(buildDir.resolve("processedResources/js"))
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.afterEvaluate {
dep.pluginManager.withPlugin("org.jetbrains.kotlin.multiplatform") {
dep.tasks.findByName("jsProcessResources")?.let { task ->
dependsOn(task)
from(task)
//from(dep.buildDir.resolve("processedResources/js"))
}
//from(dep.buildDir.resolve("processedResources/js"))
}
}
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)
dep.pluginManager.withPlugin("org.jetbrains.kotlin.js") {
dep.tasks.findByName("processResources")?.let { task ->
dependsOn(task)
from(task)
//from(dep.buildDir.resolve("processedResources/js"))
}
// from(dep.buildDir.resolve("processedResources/js"))
}
}
}
}
val Project.jsDistDirectory: File
get() {
val distributionName = listOf(
name,
"js",
version.toString()
).joinToString("-")
return buildDir.resolve(
"distributions/$distributionName"
)
}
//
//internal fun Copy.copyJVMResources(configuration: Configuration): Unit = project.afterEvaluate {
// val projectDeps = configuration.allDependencies
// .filterIsInstance<ProjectDependency>()
// .map { it.dependencyProject }
//
// projectDeps.forEach { dep ->
// dep.pluginManager.withPlugin("org.jetbrains.kotlin.multiplatform") {
// dep.tasks.findByName("jvmProcessResources")?.let { task ->
// dependsOn(task)
// from(task)
// }
// }
// dep.pluginManager.withPlugin("org.jetbrains.kotlin.jvm") {
// dep.tasks.findByName("processResources")?.let { task ->
// dependsOn(task)
// from(task)
// }
// }
// }
//}

79
src/main/kotlin/ru/mipt/npm/gradle/dependencies.kt
View File

@ -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,14 +44,16 @@ internal fun Project.useDependency(
pairs.find { it.first == "jvm" }?.let { dep ->
pluginManager.withPlugin("org.jetbrains.kotlin.jvm") {
sourceSets.findByName(dependencySourceSet.setName)?.apply {
dependencies.apply {
val configurationName = when (dependencyConfiguration) {
DependencyConfiguration.API -> apiConfigurationName
DependencyConfiguration.IMPLEMENTATION -> implementationConfigurationName
DependencyConfiguration.COMPILE_ONLY -> compileOnlyConfigurationName
configure<KotlinJvmProjectExtension> {
sourceSets.findByName(dependencySourceSet.setName)?.apply {
dependencies.apply {
val configurationName = when (dependencyConfiguration) {
DependencyConfiguration.API -> apiConfigurationName
DependencyConfiguration.IMPLEMENTATION -> implementationConfigurationName
DependencyConfiguration.COMPILE_ONLY -> compileOnlyConfigurationName
}
add(configurationName, dep.second)
}
add(configurationName, dep.second)
}
}
}
@ -58,14 +61,16 @@ internal fun Project.useDependency(
pairs.find { it.first == "js" }?.let { dep ->
pluginManager.withPlugin("org.jetbrains.kotlin.js") {
sourceSets.findByName(dependencySourceSet.setName)?.apply {
dependencies.apply {
val configurationName = when (dependencyConfiguration) {
DependencyConfiguration.API -> apiConfigurationName
DependencyConfiguration.IMPLEMENTATION -> implementationConfigurationName
DependencyConfiguration.COMPILE_ONLY -> compileOnlyConfigurationName
configure<KotlinJsProjectExtension> {
sourceSets.findByName(dependencySourceSet.setName)?.apply {
dependencies.apply {
val configurationName = when (dependencyConfiguration) {
DependencyConfiguration.API -> apiConfigurationName
DependencyConfiguration.IMPLEMENTATION -> implementationConfigurationName
DependencyConfiguration.COMPILE_ONLY -> compileOnlyConfigurationName
}
add(configurationName, dep.second)
}
add(configurationName, dep.second)
}
}
}
@ -76,9 +81,9 @@ internal fun Project.useCommonDependency(
dep: String,
dependencySourceSet: DependencySourceSet = DependencySourceSet.MAIN,
dependencyConfiguration: DependencyConfiguration = DependencyConfiguration.IMPLEMENTATION
): Unit = pluginManager.run{
withPlugin("org.jetbrains.kotlin.multiplatform"){
extensions.findByType<KotlinMultiplatformExtension>()?.apply {
): Unit = pluginManager.run {
withPlugin("org.jetbrains.kotlin.multiplatform") {
configure<KotlinMultiplatformExtension> {
sourceSets.findByName("common${dependencySourceSet.suffix}")?.apply {
dependencies {
when (dependencyConfiguration) {
@ -90,27 +95,33 @@ internal fun Project.useCommonDependency(
}
}
}
withPlugin("org.jetbrains.kotlin.jvm") {
sourceSets.findByName(dependencySourceSet.setName)?.apply {
dependencies.apply {
val configurationName = when (dependencyConfiguration) {
DependencyConfiguration.API -> apiConfigurationName
DependencyConfiguration.IMPLEMENTATION -> implementationConfigurationName
DependencyConfiguration.COMPILE_ONLY -> compileOnlyConfigurationName
configure<KotlinJvmProjectExtension> {
sourceSets.findByName(dependencySourceSet.setName)?.apply {
dependencies.apply {
val configurationName = when (dependencyConfiguration) {
DependencyConfiguration.API -> apiConfigurationName
DependencyConfiguration.IMPLEMENTATION -> implementationConfigurationName
DependencyConfiguration.COMPILE_ONLY -> compileOnlyConfigurationName
}
add(configurationName, dep)
}
add(configurationName, dep)
}
}
}
withPlugin("org.jetbrains.kotlin.js") {
sourceSets.findByName(dependencySourceSet.setName)?.apply {
dependencies.apply {
val configurationName = when (dependencyConfiguration) {
DependencyConfiguration.API -> apiConfigurationName
DependencyConfiguration.IMPLEMENTATION -> implementationConfigurationName
DependencyConfiguration.COMPILE_ONLY -> compileOnlyConfigurationName
configure<KotlinJsProjectExtension> {
sourceSets.findByName(dependencySourceSet.setName)?.apply {
dependencies.apply {
val configurationName = when (dependencyConfiguration) {
DependencyConfiguration.API -> apiConfigurationName
DependencyConfiguration.IMPLEMENTATION -> implementationConfigurationName
DependencyConfiguration.COMPILE_ONLY -> compileOnlyConfigurationName
}
add(configurationName, dep)
}
add(configurationName, dep)
}
}
}