Update to 1.5.0 and apply sam-with-receiver plugin

In order to use gradle API in a similar way as it is used in build scripts.

Author: ilya-g

build.gradle

@@ -1,23 +1,29 @@
 import java.nio.file.Files
-import java.nio.file.Paths
 
 buildscript {
     repositories {
         mavenCentral()
     }
+    dependencies {
+        classpath("org.jetbrains.kotlin:kotlin-sam-with-receiver:$kotlin_version")
+    }
 }
 
 plugins {
     id 'maven-publish'
     id 'java-gradle-plugin'
-    id 'org.jetbrains.kotlin.jvm' version "1.4.0"
+    id 'org.jetbrains.kotlin.jvm'
 }
+apply plugin: "kotlin-sam-with-receiver"
 
 // Load `local.properties` file, if it exists. You can put your spaceUser and spaceToken values there, that file is ignored by git
-if (Files.exists(Paths.get("$project.rootDir/local.properties"))) {
-    def localProperties = new Properties()
-    localProperties.load(new FileInputStream("$project.rootDir/local.properties"))
-    localProperties.each { prop -> project.ext.set(prop.key, prop.value) }
+def localPropertiesFile = file("$project.rootDir/local.properties")
+if (Files.exists(localPropertiesFile.toPath())) {
+    localPropertiesFile.withReader { reader ->
+        def localProperties = new Properties()
+        localProperties.load(reader)
+        localProperties.each { prop -> project.ext.set(prop.key, prop.value) }
+    }
 }
 
 repositories {
@@ -70,6 +76,10 @@ dependencies {
     testImplementation 'junit:junit:4.12'
 }
 
+samWithReceiver {
+    annotation("org.gradle.api.HasImplicitReceiver")
+}
+
 apply from: 'publish.gradle'
 
 if (project.hasProperty("teamcity")) {

gradle.properties

@@ -4,4 +4,4 @@ kotlin.code.style=official
 version = 0.3.0
 group = kotlinx.team
 
-kotlin_version=1.4.0
+kotlin_version=1.5.0

main/src/kotlinx/team/infra/InfraPlugin.kt

@@ -40,7 +40,7 @@ class InfraPlugin : Plugin<Project> {
         configureNativeMultiplatform()
 
         subprojects {
-            it.applyModule()
+            applyModule()
         }
     }
 

main/src/kotlinx/team/infra/NativeMultiplatform.kt

@@ -17,9 +17,10 @@ fun Project.configureNativeMultiplatform() {
     }
 
     val ideaActive = System.getProperty("idea.active")?.toBoolean() ?: false
-    subprojects { subproject ->
+    subprojects {
+        val subproject = this
         // Checking for MPP beforeEvaluate is too early, and in afterEvaluate too late because node plugin breaks
-        subproject.pluginManager.withPlugin("kotlin-multiplatform") { plugin ->
+        subproject.pluginManager.withPlugin("kotlin-multiplatform") {
             val kotlin = subproject.extensions.findByType(multiplatformExtensionClass)
             if (kotlin == null) {
                 logger.infra("Skipping native configuration for $subproject because multiplatform plugin has not been configured properly")
@@ -87,8 +88,8 @@ class NativeIdeaInfraExtension(project: Project, kotlin: KotlinMultiplatformExte
         }
 
         project.afterEvaluate {
-            kotlin.sourceSets.getByName("${sourceSetName}Main") { sourceSet ->
-                sourceSet.kotlin.srcDir("${hostPreset.name}Main/src")
+            kotlin.sourceSets.getByName("${sourceSetName}Main") {
+                kotlin.srcDir("${hostPreset.name}Main/src")
             }
         }
     }
@@ -120,11 +121,11 @@ class NativeBuildInfraExtension(project: Project, kotlin: KotlinMultiplatformExt
             sharedConfigs.forEach { config -> config() }
         }
 
-        kotlin.sourceSets.getByName("${preset.name}Main") { sourceSet ->
-            sourceSet.dependsOn(mainSourceSet)
+        kotlin.sourceSets.getByName("${preset.name}Main") {
+            dependsOn(mainSourceSet)
         }
-        kotlin.sourceSets.getByName("${preset.name}Test") { sourceSet ->
-            sourceSet.dependsOn(testSourceSet)
+        kotlin.sourceSets.getByName("${preset.name}Test") {
+            dependsOn(testSourceSet)
         }
     }
 

main/src/kotlinx/team/infra/Publishing.kt

@@ -129,20 +129,20 @@ private fun Project.createBuildRepository(name: String, rootBuildLocal: Task) {
     if (rootBuildLocal !== compositeTask)
         rootBuildLocal.dependsOn(compositeTask)
 
-    extensions.configure(PublishingExtension::class.java) { publishing ->
-        val repo = publishing.repositories.maven { repo ->
-            repo.name = name
-            repo.setUrl(dir)
+    extensions.configure(PublishingExtension::class.java) {
+        val repo = repositories.maven {
+            this.name = name
+            this.setUrl(dir)
         }
 
         afterEvaluate {
             tasks.named("clean", Delete::class.java) {
-                it.delete(dir)
+                delete(dir)
             }
 
-            tasks.withType(PublishToMavenRepository::class.java) { task ->
-                if (task.repository == repo) {
-                    compositeTask.dependsOn(task)
+            tasks.withType(PublishToMavenRepository::class.java) {
+                if (this.repository == repo) {
+                    compositeTask.dependsOn(this)
                 }
             }
         }
@@ -196,13 +196,13 @@ private fun Project.createSonatypeRepository() {
     val password =  project.sonatypePassword
         ?: throw KotlinInfrastructureException("Cannot setup publication. Password (API key) has not been specified.")
 
-    extensions.configure(PublishingExtension::class.java) { publishing ->
-        publishing.repositories.maven { repo ->
-            repo.name = "sonatype"
-            repo.url = sonatypeRepositoryUri()
-            repo.credentials { credentials ->
-                credentials.username = username
-                credentials.password = password.trim()
+    extensions.configure(PublishingExtension::class.java) {
+        repositories.maven {
+            name = "sonatype"
+            url = sonatypeRepositoryUri()
+            credentials {
+                this.username = username
+                this.password = password.trim()
             }
         }
     }
@@ -215,9 +215,9 @@ private fun Project.configurePublications(publishing: PublishingConfiguration) {
     val javadocJar = tasks.create("javadocJar", Jar::class.java).apply {
         archiveClassifier.set("javadoc")
     }
-    extensions.configure(PublishingExtension::class.java) { publishingExtension ->
-        publishingExtension.publications.all {
-            with(it as MavenPublication) {
+    extensions.configure(PublishingExtension::class.java) {
+        publications.all {
+            with(this as MavenPublication) {
                 artifact(javadocJar)
                 configureRequiredPomAttributes(project, publishing)
             }
@@ -226,34 +226,33 @@ private fun Project.configurePublications(publishing: PublishingConfiguration) {
 }
 
 fun Project.mavenPublicationsPom(action: Action<MavenPom>) {
-    extensions.configure(PublishingExtension::class.java) { publishingExtension ->
-        publishingExtension.publications.all {
-            action.execute((it as MavenPublication).pom)
+    extensions.configure(PublishingExtension::class.java) {
+        publications.all {
+            action.execute((this as MavenPublication).pom)
         }
     }
 }
 
 private fun MavenPublication.configureRequiredPomAttributes(project: Project, publishing: PublishingConfiguration) {
     val publication = this
-    // TODO: get rid of 'it's
     pom {
-        it.name.set(publication.artifactId)
-        it.description.set(project.description ?: publication.artifactId)
-        it.url.set(publishing.libraryRepoUrl)
-        it.licenses {
-            it.license {
-                it.name.set("The Apache License, Version 2.0")
-                it.url.set("http://www.apache.org/licenses/LICENSE-2.0.txt")
+        name.set(publication.artifactId)
+        description.set(project.description ?: publication.artifactId)
+        url.set(publishing.libraryRepoUrl)
+        licenses {
+            license {
+                name.set("The Apache License, Version 2.0")
+                url.set("http://www.apache.org/licenses/LICENSE-2.0.txt")
             }
         }
-        it.scm {
-            it.url.set(publishing.libraryRepoUrl)
+        scm {
+            url.set(publishing.libraryRepoUrl)
         }
-        it.developers {
-            it.developer {
-                it.name.set("JetBrains Team")
-                it.organization.set("JetBrains")
-                it.organizationUrl.set("https://www.jetbrains.com")
+        developers {
+            developer {
+                name.set("JetBrains Team")
+                organization.set("JetBrains")
+                organizationUrl.set("https://www.jetbrains.com")
             }
         }
     }
@@ -267,8 +266,8 @@ private fun Project.configureSigning() {
 
     if (keyId != null) {
         project.extensions.configure<SigningExtension>("signing") {
-            it.useInMemoryPgpKeys(keyId, signingKey, signingKeyPassphrase)
-            it.sign(extensions.getByType(PublishingExtension::class.java).publications) // all publications
+            useInMemoryPgpKeys(keyId, signingKey, signingKeyPassphrase)
+            sign(extensions.getByType(PublishingExtension::class.java).publications) // all publications
         }
     } else {
         logger.warn("INFRA: signing key id is not specified, artifact signing is not enabled.")

main/src/kotlinx/team/infra/TeamCity.kt

@@ -17,7 +17,7 @@ fun Project.configureTeamCityLogging() {
         println("##teamcity[buildNumber '${project.version}${teamcitySuffix?.let { " ($it)" } ?: ""}']")
 
         gradle.taskGraph.beforeTask {
-            println("##teamcity[progressMessage 'Gradle: ${it.project.path}:${it.name}']")
+            println("##teamcity[progressMessage 'Gradle: ${this.project.path}:${this.name}']")
         }
     }
 }

main/src/kotlinx/team/infra/api/ApiCheck.kt

@@ -27,32 +27,33 @@ fun Project.configureApiCheck(apiCheck: ApiCheckConfiguration) {
 
     includeProjects.forEach { subproject ->
         // Checking for MPP beforeEvaluate is too early, and in afterEvaluate too late because node plugin breaks
-        subproject.pluginManager.withPlugin("kotlin-multiplatform") { plugin ->
+        subproject.pluginManager.withPlugin("kotlin-multiplatform") {
             val multiplatform = multiplatformClass?.let { subproject.extensions.findByType(it) }
             if (multiplatform == null) {
                 logger.infra("Skipping apiCheck configuration for $subproject because multiplatform plugin has not been configured properly")
                 return@withPlugin
             }
 
             val apiCheckTask = subproject.tasks.create("checkApi") {
-                it.group = "verification"
-                it.description = "Runs API checks for 'main' compilations of all targets"
+                group = "verification"
+                description = "Runs API checks for 'main' compilations of all targets"
             }
 
             val apiPublishTask = subproject.tasks.create("publishApiToBuildLocal") {
-                it.group = "publishing"
-                it.description = "Publishes API for 'main' compilations of all targets into local build folder"
+                group = "publishing"
+                description = "Publishes API for 'main' compilations of all targets into local build folder"
             }
             tasks.findByName("publishToBuildLocal")?.dependsOn(apiPublishTask)
 
             val apiSyncTask = subproject.tasks.create("syncApi") {
-                it.group = "other"
-                it.description = "Syncs API for 'main' compilations of all targets"
+                group = "other"
+                description = "Syncs API for 'main' compilations of all targets"
             }
 
             subproject.tasks.getByName("check").dependsOn(apiCheckTask)
 
-            multiplatform.targets.all { target ->
+            multiplatform.targets.all {
+                val target = this
                 subproject.configureTargetApiCheck(target, apiCheckTask, apiSyncTask, apiPublishTask, apiCheck)
             }
         }

main/src/kotlinx/team/infra/api/DirectoryCompareTask.kt

@@ -33,11 +33,11 @@ open class DirectoryCompareTask : DefaultTask() {
         val actualFiles = mutableSetOf<RelativePath>()
         val expectedFiles = mutableSetOf<RelativePath>()
         logger.infra("Comparing $expectedDir and $actualDir")
-        project.fileTree(actualDir).visit { file ->
-            actualFiles.add(file.relativePath)
+        project.fileTree(actualDir).visit {
+            actualFiles.add(this.relativePath)
         }
-        project.fileTree(expectedDir).visit { file ->
-            expectedFiles.add(file.relativePath)
+        project.fileTree(expectedDir).visit {
+            expectedFiles.add(this.relativePath)
         }
 
         val missingFiles = expectedFiles - actualFiles

settings.gradle

@@ -1,7 +1,10 @@
 pluginManagement {
     repositories {
         mavenCentral()
-        maven { url 'https://plugins.gradle.org/m2/' }
+        gradlePluginPortal()
+    }
+    plugins {
+        id 'org.jetbrains.kotlin.jvm' version kotlin_version
     }
 }
 rootProject.name = 'kotlinx.team.infra'