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

Merge branch 'kotlin-1.4.20' into dev

Browse Source 
# Conflicts:
#	gradle/wrapper/gradle-wrapper.properties
#	src/main/kotlin/ru/mipt/npm/gradle/KScienceJSPlugin.kt
#	src/main/kotlin/ru/mipt/npm/gradle/KScienceMPPlugin.kt
#	src/main/kotlin/ru/mipt/npm/gradle/common.kt
This commit is contained in:
Alexander Nozik 2020-11-26 13:12:26 +03:00
commit 8c038fb2e1
14 changed files with 373 additions and 318 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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.

22
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.10")
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.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"
}
}
}

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

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

@ -2,47 +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"])
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)
}
}

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

@ -2,101 +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"])
}
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)
}
}

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

@ -9,9 +9,13 @@ 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> {

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

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

@ -1,6 +1,7 @@
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.*
@ -101,6 +102,8 @@ 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)

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
) {

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

@ -1,9 +1,9 @@
package ru.mipt.npm.gradle
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
@ -15,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 {
@ -29,59 +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
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
}
into(buildDir.resolve("processedResources/js"))
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.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.js") {
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"))
}
}
}
}
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)
}
}
}
}
//
//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)
}
}
}