Gradle cleanup (#121)

whyoleg · web-flow · commit fdf5813cf15d · 2020-12-05T14:32:48.000+03:00
* Extract all versions to gradle.properties
* Remove workaround for publishing
* Remove not needed logic in root build.gradle.kts
diff --git a/benchmarks/build.gradle.kts b/benchmarks/build.gradle.kts
@@ -18,8 +18,8 @@ import org.jetbrains.kotlin.gradle.plugin.mpp.*
 
 plugins {
     kotlin("multiplatform")
-    id("kotlinx.benchmark") version "0.2.0-dev-20"
-    kotlin("plugin.allopen") version "1.4.10"
+    id("kotlinx.benchmark")
+    kotlin("plugin.allopen")
 }
 
 repositories {
@@ -28,6 +28,7 @@ repositories {
 
 val rsocketJavaVersion: String by rootProject
 val kotlinxCoroutinesVersion: String by rootProject
+val kotlinxBenchmarkVersion: String by rootProject
 
 kotlin {
     val jvm = jvm() //common jvm source set
@@ -37,7 +38,7 @@ kotlin {
     sourceSets {
         val commonMain by getting {
             dependencies {
-                implementation("org.jetbrains.kotlinx:kotlinx.benchmark.runtime:0.2.0-dev-20")
+                implementation("org.jetbrains.kotlinx:kotlinx.benchmark.runtime:$kotlinxBenchmarkVersion")
                 implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:$kotlinxCoroutinesVersion")
             }
         }
diff --git a/build.gradle.kts b/build.gradle.kts
@@ -53,7 +53,7 @@ allprojects {
     }
 }
 
-//true when on CI, and false when local dev. Needed for native build configuration
+//true when on CI, and false when local dev. Needed for build configuration
 val ciRun = System.getenv("CI") == "true"
 
 //configure main host, for which jvm and js tests are enabled, true if locally, or linux on CI
@@ -62,7 +62,7 @@ val isMainHost: Boolean = !ciRun || HostManager.hostIsLinux
 // can be: macos, ios, watchos, tvos. If provided, compile and test only those targets
 val macTargetsCompilation: String? by project
 
-println("Configuration: CI=${System.getenv("CI")}, ciRun=$ciRun, isMainHost=$isMainHost, macTargetsCompilation=$macTargetsCompilation")
+println("Configuration: ciRun=$ciRun, isMainHost=$isMainHost, macTargetsCompilation=$macTargetsCompilation")
 
 val Project.publicationNames: Array<String>
     get() {
@@ -125,55 +125,55 @@ subprojects {
             }
 
             //native targets configuration
-            if (ciRun) {
-                fun KotlinNativeTarget.disableCompilation() {
-                    compilations.all { compileKotlinTask.enabled = false }
-                    binaries.all { linkTask.enabled = false }
-                }
+            val hostTargets = listOfNotNull(linuxX64(), macosX64(), if (supportMingw) mingwX64() else null)
 
-                val hostTargets = listOfNotNull(linuxX64(), macosX64(), if (supportMingw) mingwX64() else null)
+            val iosTargets = listOf(iosArm32(), iosArm64(), iosX64())
+            val tvosTargets = listOf(tvosArm64(), tvosX64())
+            val watchosTargets = listOf(watchosArm32(), watchosArm64(), watchosX86())
+            val nativeTargets = hostTargets + iosTargets + tvosTargets + watchosTargets
 
-                val iosTargets = listOf(iosArm32(), iosArm64(), iosX64())
-                val tvosTargets = listOf(tvosArm64(), tvosX64())
-                val watchosTargets = listOf(watchosArm32(), watchosArm64(), watchosX86())
-                val nativeTargets = hostTargets + iosTargets + tvosTargets + watchosTargets
+            val nativeMain by sourceSets.creating {
+                dependsOn(sourceSets["commonMain"])
+            }
+            val nativeTest by sourceSets.creating {
+                dependsOn(sourceSets["commonTest"])
+            }
 
-                val nativeMain by sourceSets.creating {
-                    dependsOn(sourceSets["commonMain"])
-                }
-                val nativeTest by sourceSets.creating {
-                    dependsOn(sourceSets["commonTest"])
-                }
+            nativeTargets.forEach {
+                sourceSets["${it.name}Main"].dependsOn(nativeMain)
+                sourceSets["${it.name}Test"].dependsOn(nativeTest)
+            }
 
-                nativeTargets.forEach {
-                    sourceSets["${it.name}Main"].dependsOn(nativeMain)
-                    sourceSets["${it.name}Test"].dependsOn(nativeTest)
-                }
+            fun KotlinNativeTarget.disableCompilation() {
+                compilations.all { compileKotlinTask.enabled = false }
+                binaries.all { linkTask.enabled = false }
+            }
 
-                //disable cross compilation of linux target on non linux hosts
-                if (!HostManager.hostIsLinux) linuxX64().disableCompilation()
-
-                //disable compilation of part of mac targets
-                if (HostManager.hostIsMac) when (macTargetsCompilation) {
-                    "macos"                  -> iosTargets + tvosTargets + watchosTargets
-                    "ios", "watchos", "tvos" -> {
-                        //disable test compilation for macos, but leave main to compile examples and playground
-                        macosX64 {
-                            compilations.all { if (name == "test") compileKotlinTask.enabled = false }
-                            binaries.all { linkTask.enabled = false }
-                        }
-                        when (macTargetsCompilation) {
-                            "ios"     -> tvosTargets + watchosTargets
-                            "watchos" -> iosTargets + tvosTargets
-                            "tvos"    -> iosTargets + watchosTargets
-                            else      -> emptyList()
-                        }
+            //disable cross compilation of linux target on non linux hosts
+            if (!HostManager.hostIsLinux) linuxX64().disableCompilation()
+
+            //disable compilation of part of mac targets
+            if (HostManager.hostIsMac) when (macTargetsCompilation) {
+                "macos"                  -> iosTargets + tvosTargets + watchosTargets
+                "ios", "watchos", "tvos" -> {
+                    //disable test compilation for macos, but leave main to compile examples and playground
+                    macosX64 {
+                        compilations.all { if (name == "test") compileKotlinTask.enabled = false }
+                        binaries.all { linkTask.enabled = false }
+                    }
+                    when (macTargetsCompilation) {
+                        "ios"     -> tvosTargets + watchosTargets
+                        "watchos" -> iosTargets + tvosTargets
+                        "tvos"    -> iosTargets + watchosTargets
+                        else      -> emptyList()
                     }
-                    else                     -> emptyList()
-                }.forEach(KotlinNativeTarget::disableCompilation)
+                }
+                else                     -> emptyList()
+            }.forEach(KotlinNativeTarget::disableCompilation)
 
-                //run tests on release + mimalloc to reduce tests execution time
-                //compilation is slower in that mode, but work with buffers is much faster
+            //run tests on release + mimalloc to reduce tests execution time
+            //compilation is slower in that mode, but work with buffers is much faster
+            if (ciRun) {
                 targets.all {
                     if (this is KotlinNativeTargetWithTests<*>) {
                         binaries.test(listOf(RELEASE))
@@ -183,13 +183,6 @@ subprojects {
                         }
                     }
                 }
-            } else {
-                //if not on CI, use only one native target same as host, DON'T PUBLISH IN THAT MODE LOCALLY!!!
-                when {
-                    HostManager.hostIsLinux                 -> linuxX64("native")
-                    HostManager.hostIsMingw && supportMingw -> mingwX64("native")
-                    HostManager.hostIsMac                   -> macosX64("native")
-                }
             }
         }
 
diff --git a/examples/multiplatform-chat/build.gradle.kts b/examples/multiplatform-chat/build.gradle.kts
@@ -18,10 +18,13 @@ import org.jetbrains.kotlin.konan.target.*
 
 plugins {
     kotlin("multiplatform")
-    kotlin("plugin.serialization") version "1.4.10"
+    kotlin("plugin.serialization")
     id("kotlinx-atomicfu")
 }
 
+val ktorVersion: String by rootProject
+val kotlinxSerializationVersion: String by rootProject
+
 kotlin {
     jvm("serverJvm")
     jvm("clientJvm")
@@ -49,7 +52,7 @@ kotlin {
             dependencies {
                 implementation(project(":rsocket-core"))
 
-                implementation("org.jetbrains.kotlinx:kotlinx-serialization-protobuf:1.0.0-RC")
+                implementation("org.jetbrains.kotlinx:kotlinx-serialization-protobuf:$kotlinxSerializationVersion")
             }
         }
 
@@ -63,21 +66,21 @@ kotlin {
         val serverJvmMain by getting {
             dependencies {
                 implementation(project(":rsocket-transport-ktor-server"))
-                implementation("io.ktor:ktor-server-cio:1.4.1")
+                implementation("io.ktor:ktor-server-cio:$ktorVersion")
             }
         }
 
         val clientJvmMain by getting {
             dependsOn(clientMain)
             dependencies {
-                implementation("io.ktor:ktor-client-cio:1.4.1")
+                implementation("io.ktor:ktor-client-cio:$ktorVersion")
             }
         }
 
         val clientJsMain by getting {
             dependsOn(clientMain)
             dependencies {
-                implementation("io.ktor:ktor-client-js:1.4.1")
+                implementation("io.ktor:ktor-client-js:$ktorVersion")
             }
         }
 
diff --git a/examples/nodejs-tcp-transport/build.gradle.kts b/examples/nodejs-tcp-transport/build.gradle.kts
@@ -18,6 +18,8 @@ plugins {
     kotlin("multiplatform")
 }
 
+val kotlinxNodejsVersion: String by rootProject
+
 kotlin {
     js(IR) {
         nodejs {
@@ -29,7 +31,7 @@ kotlin {
         val jsMain by getting {
             dependencies {
                 implementation(project(":rsocket-core"))
-                implementation("org.jetbrains.kotlinx:kotlinx-nodejs:0.0.7")
+                implementation("org.jetbrains.kotlinx:kotlinx-nodejs:$kotlinxNodejsVersion")
             }
         }
     }
diff --git a/gradle.properties b/gradle.properties
@@ -23,8 +23,15 @@ kotlinVersion=1.4.10
 ktorVersion=1.4.1
 kotlinxCoroutinesVersion=1.3.9-native-mt-2
 kotlinxAtomicfuVersion=0.14.4
+kotlinxSerializationVersion=1.0.0-RC
+kotlinxBenchmarkVersion=0.2.0-dev-20
+kotlinxNodejsVersion=0.0.7
+rsocketJavaVersion=1.1.0
 turbineVersion=0.2.1
-rsocketJavaVersion=1.1.0-M2
+bintrayVersion=1.8.5
+artifactoryVersion=4.17.2
+versionUpdatesVersion=0.33.0
+gradleEnterpriseVersion=3.4.1
 
 #Kotlin
 #kotlin.code.style=official
@@ -52,6 +59,3 @@ org.gradle.caching=true
 org.gradle.configureondemand=true
 org.gradle.jvmargs=-Xmx4g
 org.gradle.vfs.watch=true
-
-#Bintray publish workaround
-systemProp.org.gradle.internal.publish.checksums.insecure=true
diff --git a/settings.gradle.kts b/settings.gradle.kts
@@ -21,15 +21,28 @@ pluginManagement {
         maven("https://dl.bintray.com/kotlin/kotlinx")
     }
 
+    val kotlinVersion: String by settings
+    val bintrayVersion: String by settings
+    val artifactoryVersion: String by settings
+    val versionUpdatesVersion: String by settings
+    val gradleEnterpriseVersion: String by settings
+    val kotlinxBenchmarkVersion: String by settings
+
     plugins {
-        id("com.jfrog.bintray") version "1.8.5"
-        id("com.jfrog.artifactory") version "4.17.2"
-        id("com.github.ben-manes.versions") version "0.33.0"
+        kotlin("plugin.allopen") version kotlinVersion
+        kotlin("plugin.serialization") version kotlinVersion
+
+        id("kotlinx.benchmark") version kotlinxBenchmarkVersion
+
+        id("com.jfrog.bintray") version bintrayVersion
+        id("com.jfrog.artifactory") version artifactoryVersion
+        id("com.github.ben-manes.versions") version versionUpdatesVersion
+        id("com.gradle.enterprise") version gradleEnterpriseVersion
     }
 }
 
 plugins {
-    id("com.gradle.enterprise") version "3.4.1"
+    id("com.gradle.enterprise")
 }
 
 gradleEnterprise {

Original file line number	Diff line number	Diff line change
`@@ -18,10 +18,13 @@ import org.jetbrains.kotlin.konan.target.*`
`18`	`18`
`19`	`19`	`plugins {`
`20`	`20`	`kotlin("multiplatform")`
`21`		`- kotlin("plugin.serialization") version "1.4.10"`
	`21`	`+ kotlin("plugin.serialization")`
`22`	`22`	`id("kotlinx-atomicfu")`
`23`	`23`	`}`
`24`	`24`
	`25`	`+val ktorVersion: String by rootProject`
	`26`	`+val kotlinxSerializationVersion: String by rootProject`
	`27`	`+`
`25`	`28`	`kotlin {`
`26`	`29`	`jvm("serverJvm")`
`27`	`30`	`jvm("clientJvm")`
`@@ -49,7 +52,7 @@ kotlin {`
`49`	`52`	`dependencies {`
`50`	`53`	`implementation(project(":rsocket-core"))`
`51`	`54`
`52`		`- implementation("org.jetbrains.kotlinx:kotlinx-serialization-protobuf:1.0.0-RC")`
	`55`	`+ implementation("org.jetbrains.kotlinx:kotlinx-serialization-protobuf:$kotlinxSerializationVersion")`
`53`	`56`	`}`
`54`	`57`	`}`
`55`	`58`
`@@ -63,21 +66,21 @@ kotlin {`
`63`	`66`	`val serverJvmMain by getting {`
`64`	`67`	`dependencies {`
`65`	`68`	`implementation(project(":rsocket-transport-ktor-server"))`
`66`		`- implementation("io.ktor:ktor-server-cio:1.4.1")`
	`69`	`+ implementation("io.ktor:ktor-server-cio:$ktorVersion")`
`67`	`70`	`}`
`68`	`71`	`}`
`69`	`72`
`70`	`73`	`val clientJvmMain by getting {`
`71`	`74`	`dependsOn(clientMain)`
`72`	`75`	`dependencies {`
`73`		`- implementation("io.ktor:ktor-client-cio:1.4.1")`
	`76`	`+ implementation("io.ktor:ktor-client-cio:$ktorVersion")`
`74`	`77`	`}`
`75`	`78`	`}`
`76`	`79`
`77`	`80`	`val clientJsMain by getting {`
`78`	`81`	`dependsOn(clientMain)`
`79`	`82`	`dependencies {`
`80`		`- implementation("io.ktor:ktor-client-js:1.4.1")`
	`83`	`+ implementation("io.ktor:ktor-client-js:$ktorVersion")`
`81`	`84`	`}`
`82`	`85`	`}`
`83`	`86`
Original file line number	Diff line number	Diff line change
`@@ -18,6 +18,8 @@ plugins {`
`18`	`18`	`kotlin("multiplatform")`
`19`	`19`	`}`
`20`	`20`
	`21`	`+val kotlinxNodejsVersion: String by rootProject`
	`22`	`+`
`21`	`23`	`kotlin {`
`22`	`24`	`js(IR) {`
`23`	`25`	`nodejs {`
`@@ -29,7 +31,7 @@ kotlin {`
`29`	`31`	`val jsMain by getting {`
`30`	`32`	`dependencies {`
`31`	`33`	`implementation(project(":rsocket-core"))`
`32`		`- implementation("org.jetbrains.kotlinx:kotlinx-nodejs:0.0.7")`
	`34`	`+ implementation("org.jetbrains.kotlinx:kotlinx-nodejs:$kotlinxNodejsVersion")`
`33`	`35`	`}`
`34`	`36`	`}`
`35`	`37`	`}`