build config: Use buildSrc convention plugins to configure the Dokka subprojects

build.gradle.kts

@@ -1,74 +1,16 @@
 import org.jetbrains.*
-import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
 plugins {
-    kotlin("jvm") apply false
-    id("java")
-    id("org.jetbrains.dokka") version "1.7.20"
+    org.jetbrains.conventions.base
+    id("org.jetbrains.dokka")
     id("io.github.gradle-nexus.publish-plugin")
 }
 
 val dokka_version: String by project
 
-allprojects {
-    configureDokkaVersion()
+group = "org.jetbrains.dokka"
+version = dokka_version
 
-    group = "org.jetbrains.dokka"
-    version = dokka_version
-
-
-    val language_version: String by project
-    tasks.withType(KotlinCompile::class).all {
-        kotlinOptions {
-            freeCompilerArgs = freeCompilerArgs + listOf(
-                "-opt-in=kotlin.RequiresOptIn",
-                "-Xjsr305=strict",
-                "-Xskip-metadata-version-check",
-                // need 1.4 support, otherwise there might be problems with Gradle 6.x (it's bundling Kotlin 1.4)
-                "-Xsuppress-version-warnings"
-            )
-            allWarningsAsErrors = true
-            languageVersion = language_version
-            apiVersion = language_version
-            jvmTarget = "1.8"
-        }
-    }
-
-    repositories {
-        mavenCentral()
-    }
-}
-
-subprojects {
-    apply {
-        plugin("org.jetbrains.kotlin.jvm")
-        plugin("java")
-        plugin("signing")
-        plugin("org.jetbrains.dokka")
-    }
-
-    // Gradle metadata
-    java {
-        @Suppress("UnstableApiUsage")
-        withSourcesJar()
-        targetCompatibility = JavaVersion.VERSION_1_8
-    }
-
-    tasks {
-        val dokkaOutputDir = "$buildDir/dokka"
-
-        dokkaHtml {
-            onlyIf { !isLocalPublication }
-            outputDirectory.set(file(dokkaOutputDir))
-        }
-
-        register<Jar>("javadocJar") {
-            archiveClassifier.set("javadoc")
-            dependsOn(dokkaHtml)
-            from(dokkaOutputDir)
-        }
-    }
-}
 
 println("Publication version: $dokka_version")
 tasks.register<ValidatePublications>("validatePublications")
@@ -82,7 +24,7 @@ nexusPublishing {
     }
 }
 
-tasks.maybeCreate("dokkaPublish").run {
+val dokkaPublish by tasks.registering {
     if (publicationChannels.any { it.isMavenRepository() }) {
         finalizedBy(tasks.named("closeAndReleaseSonatypeStagingRepository"))
     }

buildSrc/build.gradle.kts

@@ -7,7 +7,16 @@ repositories {
 }
 
 dependencies {
+    // Import Gradle Plugins that will be used in the buildSrc pre-compiled script plugins, and any `build.gradle.kts`
+    // files in the project.
+    // Use their Maven coordinates (plus versions), not Gradle plugin IDs!
+    // This should be the only place that Gradle plugin versions are defined, so they are aligned across all build scripts
+
+    implementation("org.jetbrains.kotlin:kotlin-gradle-plugin:1.7.20")
     implementation("com.github.jengelman.gradle.plugins:shadow:2.0.4")
+    implementation("gradle.plugin.com.github.johnrengelman:shadow:7.1.2")
     implementation("org.jetbrains.kotlinx:binary-compatibility-validator:0.10.1")
     implementation("io.github.gradle-nexus:publish-plugin:1.1.0")
+    implementation("org.jetbrains.dokka:dokka-gradle-plugin:1.7.10")
+    implementation("com.gradle.publish:plugin-publish-plugin:0.20.0")
 }

buildSrc/settings.gradle.kts

@@ -0,0 +1 @@
+rootProject.name = "buildSrc"

buildSrc/src/main/kotlin/org/jetbrains/conventions/base.gradle.kts

@@ -0,0 +1,12 @@
+package org.jetbrains.conventions
+
+plugins {
+    base
+}
+
+description = "common Gradle configuration that should be applied to all projets"
+
+if (project != rootProject) {
+    project.group = rootProject.group
+    project.version = rootProject.version
+}

buildSrc/src/main/kotlin/org/jetbrains/conventions/dokka-integration-test.gradle.kts

@@ -0,0 +1,47 @@
+package org.jetbrains.conventions
+
+import org.gradle.api.tasks.testing.logging.TestExceptionFormat
+import org.gradle.api.tasks.testing.logging.TestLogEvent
+
+plugins {
+    id("org.jetbrains.conventions.kotlin-jvm")
+}
+
+val integrationTestSourceSet = sourceSets.create("integrationTest") {
+    compileClasspath += sourceSets.main.get().output
+    runtimeClasspath += sourceSets.main.get().output
+}
+
+val integrationTest by tasks.registering(Test::class) {
+    maxHeapSize = "2G"
+    description = "Runs integration tests."
+    group = "verification"
+    useJUnit()
+
+
+    testClassesDirs = integrationTestSourceSet.output.classesDirs
+    classpath = integrationTestSourceSet.runtimeClasspath
+
+    setForkEvery(1)
+    project.properties["dokka_integration_test_parallelism"]?.toString()?.toIntOrNull()?.let { parallelism ->
+        maxParallelForks = parallelism
+    }
+    environment(
+        "isExhaustive",
+        project.properties["dokka_integration_test_is_exhaustive"]?.toString()?.toBoolean()
+            ?: System.getenv("DOKKA_INTEGRATION_TEST_IS_EXHAUSTIVE")?.toBoolean()
+            ?: false.toString()
+    )
+
+    testLogging {
+        exceptionFormat = TestExceptionFormat.FULL
+        events(TestLogEvent.SKIPPED, TestLogEvent.FAILED)
+        showExceptions = true
+        showCauses = true
+        showStackTraces = true
+    }
+}
+
+tasks.check {
+    dependsOn(integrationTest)
+}

buildSrc/src/main/kotlin/org/jetbrains/conventions/kotlin-jvm.gradle.kts

@@ -0,0 +1,47 @@
+package org.jetbrains.conventions
+
+import org.jetbrains.configureDokkaVersion
+import org.jetbrains.isLocalPublication
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
+
+plugins {
+    id("org.jetbrains.conventions.base")
+    kotlin("jvm")
+    id("org.jetbrains.dokka")
+}
+
+configureDokkaVersion()
+
+tasks.dokkaHtml {
+    onlyIf { !isLocalPublication }
+    outputDirectory.set(layout.buildDirectory.dir("dokka").map { it.asFile })
+}
+
+val javadocJar by tasks.registering(Jar::class) {
+    archiveClassifier.set("javadoc")
+    from(tasks.dokkaHtml)
+}
+
+val language_version: String by project
+
+tasks.withType<KotlinCompile>().configureEach {
+    kotlinOptions {
+        freeCompilerArgs = freeCompilerArgs + listOf(
+            "-opt-in=kotlin.RequiresOptIn",
+            "-Xjsr305=strict",
+            "-Xskip-metadata-version-check",
+            // need 1.4 support, otherwise there might be problems with Gradle 6.x (it's bundling Kotlin 1.4)
+            "-Xsuppress-version-warnings"
+        )
+        allWarningsAsErrors = true
+        languageVersion = language_version
+        apiVersion = language_version
+        jvmTarget = "1.8"
+    }
+}
+
+// Gradle metadata
+java {
+    withSourcesJar()
+    targetCompatibility = JavaVersion.VERSION_1_8
+}

buildSrc/src/main/kotlin/org/jetbrains/conventions/maven-publish.gradle.kts

@@ -0,0 +1,20 @@
+package org.jetbrains.conventions
+
+plugins {
+    id("org.jetbrains.conventions.base")
+    `maven-publish`
+    signing
+}
+
+publishing {
+    publications.withType<MavenPublication>().configureEach {
+        repositories {
+            // Publish to a project-local Maven directory, for verification. To test, run:
+            // ./gradlew publishAllPublicationsToMavenProjectLocalRepository
+            // and check $rootDir/build/maven-project-local
+            maven(rootProject.layout.buildDirectory.dir("maven-project-local")) {
+                name = "MavenProjectLocal"
+            }
+        }
+    }
+}

core/build.gradle.kts

@@ -2,7 +2,8 @@ import org.jetbrains.dokkaVersion
 import org.jetbrains.registerDokkaArtifactPublication
 
 plugins {
-    `maven-publish`
+    org.jetbrains.conventions.`kotlin-jvm`
+    org.jetbrains.conventions.`maven-publish`
 }
 
 dependencies {

core/content-matcher-test-utils/build.gradle.kts

@@ -1,3 +1,7 @@
+plugins {
+    org.jetbrains.conventions.`kotlin-jvm`
+}
+
 dependencies {
     implementation(project(":core:test-api"))
     implementation(kotlin("stdlib-jdk8"))

core/test-api/build.gradle.kts

@@ -1,7 +1,8 @@
 import org.jetbrains.registerDokkaArtifactPublication
 
 plugins {
-    `maven-publish`
+    org.jetbrains.conventions.`kotlin-jvm`
+    org.jetbrains.conventions.`maven-publish`
 }
 
 dependencies {

integration-tests/build.gradle.kts

@@ -1,61 +1,65 @@
-import org.gradle.api.tasks.testing.logging.TestExceptionFormat
-import org.gradle.api.tasks.testing.logging.TestLogEvent
+//import org.gradle.api.tasks.testing.logging.TestExceptionFormat
+//import org.gradle.api.tasks.testing.logging.TestLogEvent
 
-subprojects {
-    sourceSets {
-        create("integrationTest") {
-            compileClasspath += sourceSets.main.get().output
-            runtimeClasspath += sourceSets.main.get().output
-        }
-    }
-
-    configurations.getByName("integrationTestImplementation") {
-        extendsFrom(configurations.implementation.get())
-    }
-
-    configurations.getByName("integrationTestRuntimeOnly") {
-        extendsFrom(configurations.runtimeOnly.get())
-    }
-
-    dependencies {
-        implementation(project(":integration-tests"))
-    }
-
-    val integrationTest by tasks.register<Test>("integrationTest") {
-        maxHeapSize = "2G"
-        description = "Runs integration tests."
-        group = "verification"
-        useJUnit()
-
-
-        testClassesDirs = sourceSets["integrationTest"].output.classesDirs
-        classpath = sourceSets["integrationTest"].runtimeClasspath
-
-        setForkEvery(1)
-        project.properties["dokka_integration_test_parallelism"]?.toString()?.toIntOrNull()?.let { parallelism ->
-            maxParallelForks = parallelism
-        }
-        environment(
-            "isExhaustive",
-            project.properties["dokka_integration_test_is_exhaustive"]?.toString()?.toBoolean()
-                ?: System.getenv("DOKKA_INTEGRATION_TEST_IS_EXHAUSTIVE")?.toBoolean()
-                ?: false.toString()
-        )
-
-        testLogging {
-            exceptionFormat = TestExceptionFormat.FULL
-            events(TestLogEvent.SKIPPED, TestLogEvent.FAILED)
-            showExceptions = true
-            showCauses = true
-            showStackTraces = true
-        }
-    }
-
-    tasks.check {
-        dependsOn(integrationTest)
-    }
+plugins {
+    org.jetbrains.conventions.`kotlin-jvm`
 }
 
+//subprojects {
+//    sourceSets {
+//        create("integrationTest") {
+//            compileClasspath += sourceSets.main.get().output
+//            runtimeClasspath += sourceSets.main.get().output
+//        }
+//    }
+//
+//    configurations.getByName("integrationTestImplementation") {
+//        extendsFrom(configurations.implementation.get())
+//    }
+//
+//    configurations.getByName("integrationTestRuntimeOnly") {
+//        extendsFrom(configurations.runtimeOnly.get())
+//    }
+//
+//    dependencies {
+//        implementation(project(":integration-tests"))
+//    }
+//
+//    val integrationTest by tasks.register<Test>("integrationTest") {
+//        maxHeapSize = "2G"
+//        description = "Runs integration tests."
+//        group = "verification"
+//        useJUnit()
+//
+//
+//        testClassesDirs = sourceSets["integrationTest"].output.classesDirs
+//        classpath = sourceSets["integrationTest"].runtimeClasspath
+//
+//        setForkEvery(1)
+//        project.properties["dokka_integration_test_parallelism"]?.toString()?.toIntOrNull()?.let { parallelism ->
+//            maxParallelForks = parallelism
+//        }
+//        environment(
+//            "isExhaustive",
+//            project.properties["dokka_integration_test_is_exhaustive"]?.toString()?.toBoolean()
+//                ?: System.getenv("DOKKA_INTEGRATION_TEST_IS_EXHAUSTIVE")?.toBoolean()
+//                ?: false.toString()
+//        )
+//
+//        testLogging {
+//            exceptionFormat = TestExceptionFormat.FULL
+//            events(TestLogEvent.SKIPPED, TestLogEvent.FAILED)
+//            showExceptions = true
+//            showCauses = true
+//            showStackTraces = true
+//        }
+//    }
+//
+//    tasks.check {
+//        dependsOn(integrationTest)
+//    }
+//}
+
 dependencies {
     implementation(kotlin("stdlib"))
     api(project(":test-utils"))