From 7e7ec5d3a0454d21ec543edcbc017e4be5604d46 Mon Sep 17 00:00:00 2001 From: Adam <897017+aSemy@users.noreply.github.com> Date: Mon, 4 Sep 2023 19:26:00 +0200 Subject: [PATCH] initial included-build refactor --- build.gradle.kts | 26 ++--- dokka-integration-tests/settings.gradle.kts | 31 ++++++ dokka-runners/cli/settings.gradle.kts | 30 +++++ .../gradle-plugin-classic/build.gradle.kts | 102 +++++++++++++++++ .../gradle-plugin-classic/gradle.properties | 6 + .../gradle-plugin-classic/settings.gradle.kts | 33 ++++++ .../gradle-plugin/settings.gradle.kts | 30 +++++ .../maven-plugin/settings.gradle.kts | 32 ++++++ .../analysis-java-psi/build.gradle.kts | 22 ++++ .../analysis-kotlin-api/build.gradle.kts | 18 +++ .../build.gradle.kts | 24 ++++ .../build.gradle.kts | 17 +++ .../build.gradle.kts | 52 +++++++++ .../analysis-kotlin-symbols/build.gradle.kts | 103 ++++++++++++++++++ .../analysis-markdown-jb/build.gradle.kts | 21 ++++ dokka-subprojects/build.gradle.kts | 12 ++ .../build.gradle.kts | 14 +++ .../core-test-api/build.gradle.kts | 20 ++++ dokka-subprojects/core/build.gradle.kts | 18 +++ dokka-subprojects/gradle.properties | 10 ++ .../plugin-all-modules-page/build.gradle.kts | 34 ++++++ .../build.gradle.kts | 33 ++++++ .../plugin-base-frontend/build.gradle.kts | 52 +++++++++ .../plugin-base-test-utils/build.gradle.kts | 34 ++++++ .../plugin-base/build.gradle.kts | 82 ++++++++++++++ .../build.gradle.kts | 29 +++++ dokka-subprojects/plugin-gfm/build.gradle.kts | 33 ++++++ .../plugin-javadoc/build.gradle.kts | 32 ++++++ .../build.gradle.kts | 31 ++++++ .../plugin-jekyll/build.gradle.kts | 26 +++++ .../plugin-kotlin-as-java/build.gradle.kts | 30 +++++ .../plugin-mathjax/build.gradle.kts | 34 ++++++ .../plugin-templating/build.gradle.kts | 32 ++++++ .../plugin-versioning/build.gradle.kts | 35 ++++++ dokka-subprojects/settings.gradle.kts | 90 +++++++++++++++ settings.gradle.kts | 87 ++++++++------- 36 files changed, 1262 insertions(+), 53 deletions(-) create mode 100644 dokka-integration-tests/settings.gradle.kts create mode 100644 dokka-runners/cli/settings.gradle.kts create mode 100644 dokka-runners/gradle-plugin-classic/build.gradle.kts create mode 100644 dokka-runners/gradle-plugin-classic/gradle.properties create mode 100644 dokka-runners/gradle-plugin-classic/settings.gradle.kts create mode 100644 dokka-runners/gradle-plugin/settings.gradle.kts create mode 100644 dokka-runners/maven-plugin/settings.gradle.kts create mode 100644 dokka-subprojects/analysis-java-psi/build.gradle.kts create mode 100644 dokka-subprojects/analysis-kotlin-api/build.gradle.kts create mode 100644 dokka-subprojects/analysis-kotlin-descriptors-compiler/build.gradle.kts create mode 100644 dokka-subprojects/analysis-kotlin-descriptors-ide/build.gradle.kts create mode 100644 dokka-subprojects/analysis-kotlin-descriptors/build.gradle.kts create mode 100644 dokka-subprojects/analysis-kotlin-symbols/build.gradle.kts create mode 100644 dokka-subprojects/analysis-markdown-jb/build.gradle.kts create mode 100644 dokka-subprojects/build.gradle.kts create mode 100644 dokka-subprojects/core-content-matcher-test-utils/build.gradle.kts create mode 100644 dokka-subprojects/core-test-api/build.gradle.kts create mode 100644 dokka-subprojects/core/build.gradle.kts create mode 100644 dokka-subprojects/gradle.properties create mode 100644 dokka-subprojects/plugin-all-modules-page/build.gradle.kts create mode 100644 dokka-subprojects/plugin-android-documentation/build.gradle.kts create mode 100644 dokka-subprojects/plugin-base-frontend/build.gradle.kts create mode 100644 dokka-subprojects/plugin-base-test-utils/build.gradle.kts create mode 100644 dokka-subprojects/plugin-base/build.gradle.kts create mode 100644 dokka-subprojects/plugin-gfm-template-processing/build.gradle.kts create mode 100644 dokka-subprojects/plugin-gfm/build.gradle.kts create mode 100644 dokka-subprojects/plugin-javadoc/build.gradle.kts create mode 100644 dokka-subprojects/plugin-jekyll-template-processing/build.gradle.kts create mode 100644 dokka-subprojects/plugin-jekyll/build.gradle.kts create mode 100644 dokka-subprojects/plugin-kotlin-as-java/build.gradle.kts create mode 100644 dokka-subprojects/plugin-mathjax/build.gradle.kts create mode 100644 dokka-subprojects/plugin-templating/build.gradle.kts create mode 100644 dokka-subprojects/plugin-versioning/build.gradle.kts create mode 100644 dokka-subprojects/settings.gradle.kts diff --git a/build.gradle.kts b/build.gradle.kts index 6326572a87..c11fb21810 100644 --- a/build.gradle.kts +++ b/build.gradle.kts @@ -10,7 +10,7 @@ plugins { id("org.jetbrains.conventions.base") id("org.jetbrains.conventions.dokka") - alias(libs.plugins.kotlinx.binaryCompatibilityValidator) +// alias(libs.plugins.kotlinx.binaryCompatibilityValidator) alias(libs.plugins.nexusPublish) } @@ -38,15 +38,15 @@ val dokkaPublish by tasks.registering { } } -apiValidation { - // note that subprojects are ignored by their name, not their path https://github.com/Kotlin/binary-compatibility-validator/issues/16 - ignoredProjects += setOf( - // NAME PATH - "frontend", // :plugins:base:frontend - - "integration-tests", // :integration-tests - "gradle", // :integration-tests:gradle - "cli", // :integration-tests:cli - "maven", // integration-tests:maven - ) -} +//apiValidation { +// // note that subprojects are ignored by their name, not their path https://github.com/Kotlin/binary-compatibility-validator/issues/16 +// ignoredProjects += setOf( +// // NAME PATH +// "frontend", // :plugins:base:frontend +// +// "integration-tests", // :integration-tests +// "gradle", // :integration-tests:gradle +// "cli", // :integration-tests:cli +// "maven", // integration-tests:maven +// ) +//} diff --git a/dokka-integration-tests/settings.gradle.kts b/dokka-integration-tests/settings.gradle.kts new file mode 100644 index 0000000000..9ee555925d --- /dev/null +++ b/dokka-integration-tests/settings.gradle.kts @@ -0,0 +1,31 @@ +/* + * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license. + */ + +@file:Suppress("UnstableApiUsage") + +rootProject.name = "dokka-integration-tests" + +pluginManagement { + includeBuild("../build-logic") + + repositories { + gradlePluginPortal() + mavenCentral() + } +} + +dependencyResolutionManagement { + repositories { + mavenCentral() + } +} + +enableFeaturePreview("TYPESAFE_PROJECT_ACCESSORS") + +include( + ":cli", + ":gradle", + ":maven", + ":utilities", +) diff --git a/dokka-runners/cli/settings.gradle.kts b/dokka-runners/cli/settings.gradle.kts new file mode 100644 index 0000000000..82842a6923 --- /dev/null +++ b/dokka-runners/cli/settings.gradle.kts @@ -0,0 +1,30 @@ +/* + * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license. + */ + +@file:Suppress("UnstableApiUsage") + +rootProject.name = "cli" + +pluginManagement { + includeBuild("../../build-logic") + + repositories { + mavenCentral() + gradlePluginPortal() + } +} + +dependencyResolutionManagement { + repositories { + mavenCentral() + } + + versionCatalogs { + create("libs") { + from(files("../../gradle/libs.versions.toml")) + } + } +} + +enableFeaturePreview("TYPESAFE_PROJECT_ACCESSORS") diff --git a/dokka-runners/gradle-plugin-classic/build.gradle.kts b/dokka-runners/gradle-plugin-classic/build.gradle.kts new file mode 100644 index 0000000000..43e45ade27 --- /dev/null +++ b/dokka-runners/gradle-plugin-classic/build.gradle.kts @@ -0,0 +1,102 @@ +/* + * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license. + */ + +import org.jetbrains.* + +plugins { + id("org.jetbrains.conventions.gradle-plugin") +} + +dependencies { + // TODO dependency should be `org.jetbrains.dokka:dokka-core`, because that's the published artifact ID, but the + // core subproject name doesn't match this + api("org.jetbrains.dokka:core") + + compileOnly(libs.gradlePlugin.kotlin) + compileOnly(libs.gradlePlugin.android) + + testImplementation(kotlin("test")) + testImplementation(libs.gradlePlugin.kotlin) + testImplementation(libs.gradlePlugin.android) +} + +// Gradle will put its own version of the stdlib in the classpath, so not pull our own we will end up with +// warnings like 'Runtime JAR files in the classpath should have the same version' +configurations.api.configure { + excludeGradleCommonDependencies() +} + +/** + * These dependencies will be provided by Gradle, and we should prevent version conflict + * Code taken from the Kotlin Gradle plugin: + * https://github.com/JetBrains/kotlin/blob/70e15b281cb43379068facb82b8e4bcb897a3c4f/buildSrc/src/main/kotlin/GradleCommon.kt#L72 + */ +fun Configuration.excludeGradleCommonDependencies() { + dependencies + .withType() + .configureEach { + exclude(group = "org.jetbrains.kotlin", module = "kotlin-stdlib") + exclude(group = "org.jetbrains.kotlin", module = "kotlin-stdlib-jdk7") + exclude(group = "org.jetbrains.kotlin", module = "kotlin-stdlib-jdk8") + exclude(group = "org.jetbrains.kotlin", module = "kotlin-stdlib-common") + exclude(group = "org.jetbrains.kotlin", module = "kotlin-reflect") + exclude(group = "org.jetbrains.kotlin", module = "kotlin-script-runtime") + } +} + +gradlePlugin { + plugins { + create("dokkaGradlePlugin") { + id = "org.jetbrains.dokka" + displayName = "Dokka plugin" + description = "Dokka, the Kotlin documentation tool" + implementationClass = "org.jetbrains.dokka.gradle.DokkaPlugin" + version = dokkaVersion + isAutomatedPublishing = true + } + } +} + +pluginBundle { + website = "https://www.kotlinlang.org/" + vcsUrl = "https://github.com/kotlin/dokka.git" + tags = listOf("dokka", "kotlin", "kdoc", "android", "documentation") + + mavenCoordinates { + groupId = "org.jetbrains.dokka" + artifactId = "dokka-gradle-plugin" + } +} + +publishing { + publications { + register("dokkaGradlePluginForIntegrationTests") { + artifactId = "dokka-gradle-plugin" + from(components["java"]) + version = "for-integration-tests-SNAPSHOT" + } + + register("pluginMaven") { + artifactId = "dokka-gradle-plugin" + } + } +} + +tasks.validatePlugins { + enableStricterValidation.set(true) +} + +tasks.withType().configureEach { + onlyIf { publication != publishing.publications["dokkaGradlePluginForIntegrationTests"] } +} + +afterEvaluate { // Workaround for an interesting design choice https://github.com/gradle/gradle/blob/c4f935f77377f1783f70ec05381c8182b3ade3ea/subprojects/plugin-development/src/main/java/org/gradle/plugin/devel/plugins/MavenPluginPublishPlugin.java#L49 + configureSpacePublicationIfNecessary("pluginMaven", "dokkaGradlePluginPluginMarkerMaven") + configureSonatypePublicationIfNecessary("pluginMaven", "dokkaGradlePluginPluginMarkerMaven") + createDokkaPublishTaskIfNecessary() +} + +tasks.processResources { + duplicatesStrategy = DuplicatesStrategy.WARN +} diff --git a/dokka-runners/gradle-plugin-classic/gradle.properties b/dokka-runners/gradle-plugin-classic/gradle.properties new file mode 100644 index 0000000000..e15b9c880a --- /dev/null +++ b/dokka-runners/gradle-plugin-classic/gradle.properties @@ -0,0 +1,6 @@ +# +# Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license. +# + +# Project Settings +dokka_version=1.9.10-SNAPSHOT diff --git a/dokka-runners/gradle-plugin-classic/settings.gradle.kts b/dokka-runners/gradle-plugin-classic/settings.gradle.kts new file mode 100644 index 0000000000..c7b440af7c --- /dev/null +++ b/dokka-runners/gradle-plugin-classic/settings.gradle.kts @@ -0,0 +1,33 @@ +/* + * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license. + */ + +@file:Suppress("UnstableApiUsage") + +rootProject.name = "gradle-plugin-classic" + +pluginManagement { + includeBuild("../../build-logic") + + repositories { + mavenCentral() + gradlePluginPortal() + } +} + +dependencyResolutionManagement { + repositories { + mavenCentral() + google() + } + + versionCatalogs { + create("libs") { + from(files("../../gradle/libs.versions.toml")) + } + } +} + +enableFeaturePreview("TYPESAFE_PROJECT_ACCESSORS") + +includeBuild("../../dokka-subprojects") diff --git a/dokka-runners/gradle-plugin/settings.gradle.kts b/dokka-runners/gradle-plugin/settings.gradle.kts new file mode 100644 index 0000000000..f0032695b8 --- /dev/null +++ b/dokka-runners/gradle-plugin/settings.gradle.kts @@ -0,0 +1,30 @@ +/* + * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license. + */ + +@file:Suppress("UnstableApiUsage") + +rootProject.name = "gradle-plugin" + +pluginManagement { + includeBuild("../../build-logic") + + repositories { + mavenCentral() + gradlePluginPortal() + } +} + +dependencyResolutionManagement { + repositories { + mavenCentral() + } + + versionCatalogs { + create("libs") { + from(files("../../gradle/libs.versions.toml")) + } + } +} + +enableFeaturePreview("TYPESAFE_PROJECT_ACCESSORS") diff --git a/dokka-runners/maven-plugin/settings.gradle.kts b/dokka-runners/maven-plugin/settings.gradle.kts new file mode 100644 index 0000000000..8112fc4727 --- /dev/null +++ b/dokka-runners/maven-plugin/settings.gradle.kts @@ -0,0 +1,32 @@ +/* + * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license. + */ + +@file:Suppress("UnstableApiUsage") + +rootProject.name = "maven-plugin" + +pluginManagement { + includeBuild("../../build-logic") + + repositories { + mavenCentral() + gradlePluginPortal() + } +} + +dependencyResolutionManagement { + repositories { + mavenCentral() + } + + versionCatalogs { + create("libs") { + from(files("../../gradle/libs.versions.toml")) + } + } +} + +enableFeaturePreview("TYPESAFE_PROJECT_ACCESSORS") + +includeBuild("../../dokka-subprojects") diff --git a/dokka-subprojects/analysis-java-psi/build.gradle.kts b/dokka-subprojects/analysis-java-psi/build.gradle.kts new file mode 100644 index 0000000000..99d6f68d07 --- /dev/null +++ b/dokka-subprojects/analysis-java-psi/build.gradle.kts @@ -0,0 +1,22 @@ +/* + * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license. + */ + +plugins { + id("org.jetbrains.conventions.kotlin-jvm") +} + +dependencies { + compileOnly(projects.core) + + api(libs.intellij.java.psi.api) + + implementation(projects.analysisMarkdownJb) + + implementation(libs.intellij.java.psi.impl) + implementation(libs.intellij.platform.util.api) + implementation(libs.intellij.platform.util.rt) + + implementation(libs.kotlinx.coroutines.core) + implementation(libs.jsoup) +} diff --git a/dokka-subprojects/analysis-kotlin-api/build.gradle.kts b/dokka-subprojects/analysis-kotlin-api/build.gradle.kts new file mode 100644 index 0000000000..58247479e5 --- /dev/null +++ b/dokka-subprojects/analysis-kotlin-api/build.gradle.kts @@ -0,0 +1,18 @@ +/* + * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license. + */ + +import org.jetbrains.registerDokkaArtifactPublication + +plugins { + id("org.jetbrains.conventions.kotlin-jvm") + id("org.jetbrains.conventions.maven-publish") +} + +dependencies { + compileOnly(projects.core) +} + +registerDokkaArtifactPublication("analysisKotlinApi") { + artifactId = "analysis-kotlin-api" +} diff --git a/dokka-subprojects/analysis-kotlin-descriptors-compiler/build.gradle.kts b/dokka-subprojects/analysis-kotlin-descriptors-compiler/build.gradle.kts new file mode 100644 index 0000000000..2fa1868688 --- /dev/null +++ b/dokka-subprojects/analysis-kotlin-descriptors-compiler/build.gradle.kts @@ -0,0 +1,24 @@ +/* + * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license. + */ + +plugins { + id("org.jetbrains.conventions.kotlin-jvm") +} + +dependencies { + compileOnly(projects.core) + compileOnly(projects.analysisKotlinApi) + + api(libs.kotlin.compiler) + + implementation(projects.analysisMarkdownJb) + implementation(projects.analysisJavaPsi) + + testImplementation(kotlin("test")) + testImplementation(projects.coreContentMatcherTestUtils) + testImplementation(projects.coreTestApi) + + // TODO [beresnev] get rid of it + compileOnly(libs.kotlinx.coroutines.core) +} diff --git a/dokka-subprojects/analysis-kotlin-descriptors-ide/build.gradle.kts b/dokka-subprojects/analysis-kotlin-descriptors-ide/build.gradle.kts new file mode 100644 index 0000000000..062bc4cf26 --- /dev/null +++ b/dokka-subprojects/analysis-kotlin-descriptors-ide/build.gradle.kts @@ -0,0 +1,17 @@ +/* + * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license. + */ + +plugins { + id("org.jetbrains.conventions.kotlin-jvm") +} + +dependencies { + compileOnly(projects.core) + compileOnly(projects.analysisKotlinApi) + + implementation(projects.analysisKotlinDescriptorsCompiler) + + // TODO [beresnev] get rid of it + compileOnly(libs.kotlinx.coroutines.core) +} diff --git a/dokka-subprojects/analysis-kotlin-descriptors/build.gradle.kts b/dokka-subprojects/analysis-kotlin-descriptors/build.gradle.kts new file mode 100644 index 0000000000..d4ebedc123 --- /dev/null +++ b/dokka-subprojects/analysis-kotlin-descriptors/build.gradle.kts @@ -0,0 +1,52 @@ +/* + * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license. + */ + +import org.jetbrains.DokkaPublicationBuilder +import org.jetbrains.registerDokkaArtifactPublication + +plugins { + id("org.jetbrains.conventions.kotlin-jvm") + id("org.jetbrains.conventions.maven-publish") + id("com.github.johnrengelman.shadow") +} + +dependencies { + // to override some interfaces (JvmAnnotationEnumFieldValue, JvmAnnotationConstantValue) from compiler since thet are empty there + // should be `api` since we already have it in :analysis-java-psi + api(libs.intellij.java.psi.api) { + isTransitive = false + } + implementation(projects.analysisKotlinApi) + implementation(projects.analysisKotlinDescriptorsCompiler) + implementation(projects.analysisKotlinDescriptorsIde) +} + +tasks { + // There are several reasons for shadowing all dependencies in one place: + // 1. Some of the artifacts Dokka depends on, like com.jetbrains.intellij.java:java-psi, are not + // published to Maven Central, so the users would need to add custom repositories to their build scripts. + // 2. There are many intertwining transitive dependencies of different versions, as well as direct copy-paste, + // that can lead to runtime errors due to classpath conflicts, so it's best to let Gradle take care of + // dependency resolution, and then pack everything into a single jar in a single place that can be tuned. + // 3. The compiler and ide modules are internal details that are likely to change, so packing everything into + // a single jar provides some stability for the CLI users, while not exposing too many internals. Publishing + // the compiler, ide and other subprojects separately would make it difficult to refactor the project structure. + shadowJar { + val dokka_version: String by project + + // cannot be named exactly like the artifact (i.e analysis-kotlin-descriptors-VER.jar), + // otherwise leads to obscure test failures when run via CLI, but not via IJ + archiveFileName.set("analysis-kotlin-descriptors-all-$dokka_version.jar") + archiveClassifier.set("") + + // service files are merged to make sure all Dokka plugins + // from the dependencies are loaded, and not just a single one. + mergeServiceFiles() + } +} + +registerDokkaArtifactPublication("analysisKotlinDescriptors") { + artifactId = "analysis-kotlin-descriptors" + component = DokkaPublicationBuilder.Component.Shadow +} diff --git a/dokka-subprojects/analysis-kotlin-symbols/build.gradle.kts b/dokka-subprojects/analysis-kotlin-symbols/build.gradle.kts new file mode 100644 index 0000000000..2500050a38 --- /dev/null +++ b/dokka-subprojects/analysis-kotlin-symbols/build.gradle.kts @@ -0,0 +1,103 @@ +/* + * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license. + */ + +import org.jetbrains.DokkaPublicationBuilder +import org.jetbrains.registerDokkaArtifactPublication + +plugins { + id("org.jetbrains.conventions.kotlin-jvm") + id("org.jetbrains.conventions.maven-publish") + id("com.github.johnrengelman.shadow") +} + +dependencies { + compileOnly(projects.core) + compileOnly(projects.analysisKotlinApi) + + implementation(projects.analysisMarkdownJb) + implementation(projects.analysisJavaPsi) + + + // ----------- IDE dependencies ---------------------------------------------------------------------------- + + listOf( + libs.intellij.platform.util.rt, + libs.intellij.platform.util.api, + libs.intellij.java.psi.api, + libs.intellij.java.psi.impl + ).forEach { + runtimeOnly(it) { isTransitive = false } + } + + implementation(libs.intellij.java.psi.api) { isTransitive = false } + + + // TODO move to toml + listOf( + "com.jetbrains.intellij.platform:util-class-loader", + "com.jetbrains.intellij.platform:util-text-matching", + "com.jetbrains.intellij.platform:util-base", + "com.jetbrains.intellij.platform:util-xml-dom", + "com.jetbrains.intellij.platform:core-impl", + "com.jetbrains.intellij.platform:extensions", + ).forEach { + runtimeOnly("$it:213.7172.25") { isTransitive = false } + } + + implementation("com.jetbrains.intellij.platform:core:213.7172.25") { + isTransitive = false + } // for Standalone prototype + + // ----------- Analysis dependencies ---------------------------------------------------------------------------- + + listOf( + libs.kotlin.high.level.api.api, + libs.kotlin.analysis.api.standalone, + libs.kotlin.high.level.api.impl // for Standalone prototype + ).forEach { + implementation(it) { + isTransitive = false // see KTIJ-19820 + } + } + listOf( + libs.kotlin.high.level.api.impl, + libs.kotlin.high.level.api.fir, + libs.kotlin.high.level.api.fe10, + libs.kotlin.low.level.api.fir, + libs.kotlin.analysis.project.structure, + libs.kotlin.analysis.api.providers, + libs.kotlin.symbol.light.classes + ).forEach { + runtimeOnly(it) { + isTransitive = false // see KTIJ-19820 + } + } + runtimeOnly(libs.kotlinx.collections.immutable) + implementation(libs.kotlin.compiler.k2) { + isTransitive = false + } + + // TODO [beresnev] get rid of it + compileOnly(libs.kotlinx.coroutines.core) +} + +tasks { + shadowJar { + val dokka_version: String by project + + // cannot be named exactly like the artifact (i.e analysis-kotlin-symbols-VER.jar), + // otherwise leads to obscure test failures when run via CLI, but not via IJ + archiveFileName.set("analysis-kotlin-symbols-all-$dokka_version.jar") + archiveClassifier.set("") + + // service files are merged to make sure all Dokka plugins + // from the dependencies are loaded, and not just a single one. + mergeServiceFiles() + } +} + +registerDokkaArtifactPublication("analysisKotlinSymbols") { + artifactId = "analysis-kotlin-symbols" + component = DokkaPublicationBuilder.Component.Shadow +} diff --git a/dokka-subprojects/analysis-markdown-jb/build.gradle.kts b/dokka-subprojects/analysis-markdown-jb/build.gradle.kts new file mode 100644 index 0000000000..96b72a8592 --- /dev/null +++ b/dokka-subprojects/analysis-markdown-jb/build.gradle.kts @@ -0,0 +1,21 @@ +/* + * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license. + */ + +import org.jetbrains.registerDokkaArtifactPublication + +plugins { + id("org.jetbrains.conventions.kotlin-jvm") + id("org.jetbrains.conventions.maven-publish") +} + +dependencies { + compileOnly(projects.core) + + implementation(libs.jsoup) + implementation(libs.jetbrains.markdown) +} + +registerDokkaArtifactPublication("analysisMarkdown") { + artifactId = "analysis-markdown" +} diff --git a/dokka-subprojects/build.gradle.kts b/dokka-subprojects/build.gradle.kts new file mode 100644 index 0000000000..88a79de152 --- /dev/null +++ b/dokka-subprojects/build.gradle.kts @@ -0,0 +1,12 @@ +/* + * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license. + */ + +plugins { + id("org.jetbrains.conventions.base") +} + +val dokka_version: String by project + +group = "org.jetbrains.dokka" +version = dokka_version diff --git a/dokka-subprojects/core-content-matcher-test-utils/build.gradle.kts b/dokka-subprojects/core-content-matcher-test-utils/build.gradle.kts new file mode 100644 index 0000000000..71ec23b302 --- /dev/null +++ b/dokka-subprojects/core-content-matcher-test-utils/build.gradle.kts @@ -0,0 +1,14 @@ +/* + * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license. + */ + +plugins { + id("org.jetbrains.conventions.kotlin-jvm") +} + +dependencies { + implementation(projects.coreTestApi) + + implementation(kotlin("reflect")) + implementation(kotlin("test")) +} diff --git a/dokka-subprojects/core-test-api/build.gradle.kts b/dokka-subprojects/core-test-api/build.gradle.kts new file mode 100644 index 0000000000..7a067d1e6b --- /dev/null +++ b/dokka-subprojects/core-test-api/build.gradle.kts @@ -0,0 +1,20 @@ +/* + * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license. + */ + +import org.jetbrains.registerDokkaArtifactPublication + +plugins { + id("org.jetbrains.conventions.kotlin-jvm") + id("org.jetbrains.conventions.maven-publish") +} + +dependencies { + api(projects.core) + + implementation(kotlin("reflect")) +} + +registerDokkaArtifactPublication("dokkaTestApi") { + artifactId = "dokka-test-api" +} diff --git a/dokka-subprojects/core/build.gradle.kts b/dokka-subprojects/core/build.gradle.kts new file mode 100644 index 0000000000..fa38697596 --- /dev/null +++ b/dokka-subprojects/core/build.gradle.kts @@ -0,0 +1,18 @@ +import org.jetbrains.registerDokkaArtifactPublication + +/* + * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license. + */ + +plugins { + id("org.jetbrains.conventions.kotlin-jvm") + id("org.jetbrains.conventions.maven-publish") +} + +dependencies { + api("org.jetbrains.dokka:dokka-core:1.9.0") +} + +registerDokkaArtifactPublication("dokkaCore") { + artifactId = "dokka-core" +} diff --git a/dokka-subprojects/gradle.properties b/dokka-subprojects/gradle.properties new file mode 100644 index 0000000000..d2081dd4ba --- /dev/null +++ b/dokka-subprojects/gradle.properties @@ -0,0 +1,10 @@ +# +# Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license. +# + +# Project Settings +dokka_version=1.9.10-SNAPSHOT +org.jetbrains.dokka.javaToolchain.mainCompiler=8 +org.jetbrains.dokka.javaToolchain.testLauncher=8 +org.jetbrains.dokka.kotlinLanguageLevel=1.4 +dokka_integration_test_parallelism=2 diff --git a/dokka-subprojects/plugin-all-modules-page/build.gradle.kts b/dokka-subprojects/plugin-all-modules-page/build.gradle.kts new file mode 100644 index 0000000000..79e102fc88 --- /dev/null +++ b/dokka-subprojects/plugin-all-modules-page/build.gradle.kts @@ -0,0 +1,34 @@ +/* + * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license. + */ + +import org.jetbrains.registerDokkaArtifactPublication + +plugins { + id("org.jetbrains.conventions.kotlin-jvm") + id("org.jetbrains.conventions.maven-publish") +} + +registerDokkaArtifactPublication("dokkaAllModulesPage") { + artifactId = "all-modules-page-plugin" +} + +dependencies { + compileOnly(projects.core) + compileOnly(projects.analysisKotlinApi) + + implementation(projects.pluginBase) + implementation(projects.pluginTemplating) + + implementation(projects.analysisMarkdownJb) + + implementation(libs.kotlinx.html) + + testImplementation(kotlin("test")) + testImplementation(projects.pluginBase) + testImplementation(projects.pluginBaseTestUtils) + testImplementation(projects.pluginGfm) + testImplementation(projects.pluginGfmTemplateProcessing) + testImplementation(projects.coreContentMatcherTestUtils) + testImplementation(projects.coreTestApi) +} diff --git a/dokka-subprojects/plugin-android-documentation/build.gradle.kts b/dokka-subprojects/plugin-android-documentation/build.gradle.kts new file mode 100644 index 0000000000..d032defbe4 --- /dev/null +++ b/dokka-subprojects/plugin-android-documentation/build.gradle.kts @@ -0,0 +1,33 @@ +/* + * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license. + */ + +import org.jetbrains.registerDokkaArtifactPublication + +plugins { + id("org.jetbrains.conventions.kotlin-jvm") + id("org.jetbrains.conventions.maven-publish") + id("org.jetbrains.conventions.base-unit-test") +} + +dependencies { + compileOnly(projects.core) + + implementation(projects.pluginBase) + + implementation(kotlin("reflect")) + + testImplementation(kotlin("test")) + testImplementation(projects.pluginBase) + testImplementation(projects.coreTestApi) + + symbolsTestConfiguration(project(path = ":analysis-kotlin-symbols", configuration = "shadow")) + descriptorsTestConfiguration(project(path = ":analysis-kotlin-descriptors", configuration = "shadow")) + testImplementation(projects.pluginBaseTestUtils) { + exclude(module = "analysis-kotlin-descriptors") + } +} + +registerDokkaArtifactPublication("androidDocumentationPlugin") { + artifactId = "android-documentation-plugin" +} diff --git a/dokka-subprojects/plugin-base-frontend/build.gradle.kts b/dokka-subprojects/plugin-base-frontend/build.gradle.kts new file mode 100644 index 0000000000..a4e0bbc04d --- /dev/null +++ b/dokka-subprojects/plugin-base-frontend/build.gradle.kts @@ -0,0 +1,52 @@ +/* + * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license. + */ + +import com.github.gradle.node.npm.task.NpmTask +import org.jetbrains.kotlin.util.parseSpaceSeparatedArgs + +@Suppress("DSL_SCOPE_VIOLATION") // fixed in Gradle 8.1 https://github.com/gradle/gradle/pull/23639 +plugins { + id("org.jetbrains.conventions.dokka-html-frontend-files") + alias(libs.plugins.gradleNode) +} + +node { + version.set(libs.versions.node) + + // https://github.com/node-gradle/gradle-node-plugin/blob/3.5.1/docs/faq.md#is-this-plugin-compatible-with-centralized-repositories-declaration + download.set(true) + distBaseUrl.set(null as String?) // Strange cast to avoid overload ambiguity +} + +val distributionDirectory = layout.projectDirectory.dir("dist") + +val npmRunBuild by tasks.registering(NpmTask::class) { + dependsOn(tasks.npmInstall) + + npmCommand.set(parseSpaceSeparatedArgs("run build")) + + inputs.dir("src/main") + inputs.files( + "package.json", + "webpack.config.js", + ) + + outputs.dir(distributionDirectory) + outputs.cacheIf { true } +} + +configurations.dokkaHtmlFrontendFilesElements.configure { + outgoing { + artifact(distributionDirectory) { + builtBy(npmRunBuild) + } + } +} + +tasks.clean { + delete( + file("node_modules"), + file("dist"), + ) +} diff --git a/dokka-subprojects/plugin-base-test-utils/build.gradle.kts b/dokka-subprojects/plugin-base-test-utils/build.gradle.kts new file mode 100644 index 0000000000..5f8285dc04 --- /dev/null +++ b/dokka-subprojects/plugin-base-test-utils/build.gradle.kts @@ -0,0 +1,34 @@ +/* + * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license. + */ + +import org.jetbrains.registerDokkaArtifactPublication + +plugins { + id("org.jetbrains.conventions.kotlin-jvm") + id("org.jetbrains.conventions.maven-publish") +} + +dependencies { + compileOnly(projects.core) + compileOnly(projects.pluginBase) + + api(projects.analysisKotlinApi) + + // TODO [beresnev] analysis switcher + //runtimeOnly(project(path = ":subprojects:analysis-kotlin-symbols", configuration = "shadow")) + runtimeOnly(project(path = ":analysis-kotlin-descriptors", configuration = "shadow")) + + implementation(kotlin("reflect")) + implementation(libs.jsoup) + + implementation(kotlin("test")) + implementation(projects.coreTestApi) + + testImplementation(kotlin("test")) + testImplementation(projects.coreTestApi) +} + +registerDokkaArtifactPublication("dokkaBaseTestUtils") { + artifactId = "dokka-base-test-utils" +} diff --git a/dokka-subprojects/plugin-base/build.gradle.kts b/dokka-subprojects/plugin-base/build.gradle.kts new file mode 100644 index 0000000000..ddae98ca39 --- /dev/null +++ b/dokka-subprojects/plugin-base/build.gradle.kts @@ -0,0 +1,82 @@ +/* + * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license. + */ + +import org.jetbrains.registerDokkaArtifactPublication + +plugins { + id("org.jetbrains.conventions.kotlin-jvm") + id("org.jetbrains.conventions.maven-publish") + id("org.jetbrains.conventions.dokka-html-frontend-files") + id("org.jetbrains.conventions.base-unit-test") +} + +dependencies { + compileOnly(projects.core) + compileOnly(projects.analysisKotlinApi) + + implementation(projects.analysisMarkdownJb) + + // Other + implementation(kotlin("reflect")) + implementation(libs.kotlinx.coroutines.core) + implementation(libs.jsoup) + implementation(libs.freemarker) + implementation(libs.kotlinx.html) + implementation(libs.jackson.kotlin) + constraints { + implementation(libs.jackson.databind) { + because("CVE-2022-42003") + } + } + + // Test only + testImplementation(kotlin("test")) + testImplementation(libs.junit.jupiterParams) + + symbolsTestConfiguration(project(path = ":analysis-kotlin-symbols", configuration = "shadow")) + descriptorsTestConfiguration(project(path = ":analysis-kotlin-descriptors", configuration = "shadow")) + testImplementation(projects.pluginBaseTestUtils) { + exclude(module = "analysis-kotlin-descriptors") + } + testImplementation(projects.coreContentMatcherTestUtils) + testImplementation(projects.coreTestApi) + + dokkaHtmlFrontendFiles(projects.pluginBaseFrontend) { + because("fetch frontend files from subproject :plugin-base-frontend") + } +} + +// access the frontend files via the dependency on :plugins:base:frontend +val dokkaHtmlFrontendFiles: Provider = + configurations.dokkaHtmlFrontendFiles.map { frontendFiles -> + frontendFiles.incoming.artifacts.artifactFiles + } + +val preparedokkaHtmlFrontendFiles by tasks.registering(Sync::class) { + description = "copy Dokka Base frontend files into the resources directory" + + from(dokkaHtmlFrontendFiles) { + include("*.js") + into("dokka/scripts") + } + + from(dokkaHtmlFrontendFiles) { + include("*.css") + into("dokka/styles") + } + + into(layout.buildDirectory.dir("generated/src/main/resources")) +} + +sourceSets.main { + resources.srcDir(preparedokkaHtmlFrontendFiles.map { it.destinationDir }) +} + +tasks.test { + maxHeapSize = "4G" +} + +registerDokkaArtifactPublication("dokkaBase") { + artifactId = "dokka-base" +} diff --git a/dokka-subprojects/plugin-gfm-template-processing/build.gradle.kts b/dokka-subprojects/plugin-gfm-template-processing/build.gradle.kts new file mode 100644 index 0000000000..db7675c8af --- /dev/null +++ b/dokka-subprojects/plugin-gfm-template-processing/build.gradle.kts @@ -0,0 +1,29 @@ +/* + * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license. + */ + +import org.jetbrains.registerDokkaArtifactPublication + +plugins { + id("org.jetbrains.conventions.kotlin-jvm") + id("org.jetbrains.conventions.maven-publish") +} + +dependencies { + compileOnly(projects.core) + + implementation(projects.pluginBase) + implementation(projects.pluginGfm) + implementation(projects.pluginAllModulesPage) + implementation(projects.pluginTemplating) + + implementation(kotlin("reflect")) + implementation(libs.kotlinx.coroutines.core) + + testImplementation(kotlin("test")) + testImplementation(projects.coreTestApi) +} + +registerDokkaArtifactPublication("dokkaGfmTemplateProcessing") { + artifactId = "gfm-template-processing-plugin" +} diff --git a/dokka-subprojects/plugin-gfm/build.gradle.kts b/dokka-subprojects/plugin-gfm/build.gradle.kts new file mode 100644 index 0000000000..c8763f0975 --- /dev/null +++ b/dokka-subprojects/plugin-gfm/build.gradle.kts @@ -0,0 +1,33 @@ +/* + * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license. + */ + +import org.jetbrains.registerDokkaArtifactPublication + +plugins { + id("org.jetbrains.conventions.kotlin-jvm") + id("org.jetbrains.conventions.maven-publish") +} + +dependencies { + compileOnly(projects.core) + + implementation(projects.pluginBase) + + implementation(kotlin("reflect")) + implementation(libs.jackson.kotlin) + constraints { + implementation(libs.jackson.databind) { + because("CVE-2022-42003") + } + } + + testImplementation(kotlin("test")) + testImplementation(projects.pluginBase) + testImplementation(projects.pluginBaseTestUtils) + testImplementation(projects.coreTestApi) +} + +registerDokkaArtifactPublication("gfmPlugin") { + artifactId = "gfm-plugin" +} diff --git a/dokka-subprojects/plugin-javadoc/build.gradle.kts b/dokka-subprojects/plugin-javadoc/build.gradle.kts new file mode 100644 index 0000000000..6450c632fa --- /dev/null +++ b/dokka-subprojects/plugin-javadoc/build.gradle.kts @@ -0,0 +1,32 @@ +/* + * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license. + */ + +import org.jetbrains.registerDokkaArtifactPublication + +plugins { + id("org.jetbrains.conventions.kotlin-jvm") + id("org.jetbrains.conventions.maven-publish") +} + +dependencies { + compileOnly(projects.core) + compileOnly(projects.analysisKotlinApi) + + implementation(projects.pluginBase) + implementation(projects.pluginKotlinAsJava) + + implementation(kotlin("reflect")) + implementation(libs.soywiz.korte) + implementation(libs.kotlinx.html) + implementation(libs.kotlinx.coroutines.core) + + testImplementation(kotlin("test")) + testImplementation(projects.pluginBaseTestUtils) + testImplementation(projects.coreTestApi) + testImplementation(libs.jsoup) +} + +registerDokkaArtifactPublication("javadocPlugin") { + artifactId = "javadoc-plugin" +} diff --git a/dokka-subprojects/plugin-jekyll-template-processing/build.gradle.kts b/dokka-subprojects/plugin-jekyll-template-processing/build.gradle.kts new file mode 100644 index 0000000000..7dc67741e3 --- /dev/null +++ b/dokka-subprojects/plugin-jekyll-template-processing/build.gradle.kts @@ -0,0 +1,31 @@ +/* + * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license. + */ + +import org.jetbrains.registerDokkaArtifactPublication + +plugins { + id("org.jetbrains.conventions.kotlin-jvm") + id("org.jetbrains.conventions.maven-publish") +} + +dependencies { + compileOnly(projects.core) + + implementation(projects.pluginBase) + implementation(projects.pluginJekyll) + implementation(projects.pluginAllModulesPage) + implementation(projects.pluginTemplating) + implementation(projects.pluginGfm) + implementation(projects.pluginGfmTemplateProcessing) + + implementation(kotlin("reflect")) + implementation(libs.kotlinx.coroutines.core) + + testImplementation(kotlin("test")) + testImplementation(projects.coreTestApi) +} + +registerDokkaArtifactPublication("dokkaJekyllTemplateProcessing") { + artifactId = "jekyll-template-processing-plugin" +} diff --git a/dokka-subprojects/plugin-jekyll/build.gradle.kts b/dokka-subprojects/plugin-jekyll/build.gradle.kts new file mode 100644 index 0000000000..c753d07259 --- /dev/null +++ b/dokka-subprojects/plugin-jekyll/build.gradle.kts @@ -0,0 +1,26 @@ +/* + * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license. + */ + +import org.jetbrains.registerDokkaArtifactPublication + +plugins { + id("org.jetbrains.conventions.kotlin-jvm") + id("org.jetbrains.conventions.maven-publish") +} + +dependencies { + compileOnly(projects.core) + + implementation(projects.pluginBase) + implementation(projects.pluginGfm) + + implementation(kotlin("reflect")) + + testImplementation(kotlin("test")) + testImplementation(projects.coreTestApi) +} + +registerDokkaArtifactPublication("jekyllPlugin") { + artifactId = "jekyll-plugin" +} diff --git a/dokka-subprojects/plugin-kotlin-as-java/build.gradle.kts b/dokka-subprojects/plugin-kotlin-as-java/build.gradle.kts new file mode 100644 index 0000000000..02af9c57c2 --- /dev/null +++ b/dokka-subprojects/plugin-kotlin-as-java/build.gradle.kts @@ -0,0 +1,30 @@ +/* + * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license. + */ + +import org.jetbrains.registerDokkaArtifactPublication + +plugins { + id("org.jetbrains.conventions.kotlin-jvm") + id("org.jetbrains.conventions.maven-publish") +} + +dependencies { + compileOnly(projects.core) + compileOnly(projects.analysisKotlinApi) + + implementation(projects.pluginBase) + + implementation(kotlin("reflect")) + + testImplementation(kotlin("test")) + testImplementation(libs.jsoup) + testImplementation(projects.pluginBase) + testImplementation(projects.pluginBaseTestUtils) + testImplementation(projects.coreContentMatcherTestUtils) + testImplementation(projects.coreTestApi) +} + +registerDokkaArtifactPublication("kotlinAsJavaPlugin") { + artifactId = "kotlin-as-java-plugin" +} diff --git a/dokka-subprojects/plugin-mathjax/build.gradle.kts b/dokka-subprojects/plugin-mathjax/build.gradle.kts new file mode 100644 index 0000000000..505e8bdc35 --- /dev/null +++ b/dokka-subprojects/plugin-mathjax/build.gradle.kts @@ -0,0 +1,34 @@ +/* + * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license. + */ + +import org.jetbrains.registerDokkaArtifactPublication + +plugins { + id("org.jetbrains.conventions.kotlin-jvm") + id("org.jetbrains.conventions.maven-publish") + id("org.jetbrains.conventions.base-unit-test") +} + +dependencies { + compileOnly(projects.core) + + implementation(projects.pluginBase) + + implementation(kotlin("reflect")) + + testImplementation(kotlin("test")) + testImplementation(libs.jsoup) + testImplementation(projects.coreContentMatcherTestUtils) + testImplementation(projects.coreTestApi) + + symbolsTestConfiguration(project(path = ":analysis-kotlin-symbols", configuration = "shadow")) + descriptorsTestConfiguration(project(path = ":analysis-kotlin-descriptors", configuration = "shadow")) + testImplementation(projects.pluginBaseTestUtils) { + exclude(module = "analysis-kotlin-descriptors") + } +} + +registerDokkaArtifactPublication("mathjaxPlugin") { + artifactId = "mathjax-plugin" +} diff --git a/dokka-subprojects/plugin-templating/build.gradle.kts b/dokka-subprojects/plugin-templating/build.gradle.kts new file mode 100644 index 0000000000..e5c49bb51d --- /dev/null +++ b/dokka-subprojects/plugin-templating/build.gradle.kts @@ -0,0 +1,32 @@ +/* + * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license. + */ + +import org.jetbrains.registerDokkaArtifactPublication + +plugins { + id("org.jetbrains.conventions.kotlin-jvm") + id("org.jetbrains.conventions.maven-publish") +} + +registerDokkaArtifactPublication("templating-plugin") { + artifactId = "templating-plugin" +} + +dependencies { + compileOnly(projects.core) + + api(libs.jsoup) + + implementation(projects.pluginBase) + + implementation(kotlin("reflect")) + implementation(libs.kotlinx.coroutines.core) + + testImplementation(kotlin("test")) + testImplementation(libs.junit.jupiterParams) + + testImplementation(projects.pluginBaseTestUtils) + testImplementation(projects.coreTestApi) + testImplementation(libs.kotlinx.html) +} diff --git a/dokka-subprojects/plugin-versioning/build.gradle.kts b/dokka-subprojects/plugin-versioning/build.gradle.kts new file mode 100644 index 0000000000..837a54fbca --- /dev/null +++ b/dokka-subprojects/plugin-versioning/build.gradle.kts @@ -0,0 +1,35 @@ +/* + * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license. + */ + +import org.jetbrains.registerDokkaArtifactPublication + +plugins { + id("org.jetbrains.conventions.kotlin-jvm") + id("org.jetbrains.conventions.maven-publish") +} + +registerDokkaArtifactPublication("versioning-plugin") { + artifactId = "versioning-plugin" +} + +dependencies { + compileOnly(projects.core) + + implementation(projects.pluginBase) + implementation(projects.pluginTemplating) + + implementation(kotlin("reflect")) + implementation(libs.kotlinx.coroutines.core) + implementation(libs.kotlinx.html) + implementation(libs.apacheMaven.artifact) + implementation(libs.jackson.kotlin) + constraints { + implementation(libs.jackson.databind) { + because("CVE-2022-42003") + } + } + + testImplementation(kotlin("test")) + testImplementation(projects.coreTestApi) +} diff --git a/dokka-subprojects/settings.gradle.kts b/dokka-subprojects/settings.gradle.kts new file mode 100644 index 0000000000..1f85622f7c --- /dev/null +++ b/dokka-subprojects/settings.gradle.kts @@ -0,0 +1,90 @@ +/* + * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license. + */ + +@file:Suppress("UnstableApiUsage") + +rootProject.name = "dokka-subprojects" + +pluginManagement { + includeBuild("../build-logic") + + repositories { + mavenCentral() + gradlePluginPortal() + } +} + +dependencyResolutionManagement { + repositories { + mavenCentral() + google() + + maven("https://cache-redirector.jetbrains.com/maven.pkg.jetbrains.space/kotlin/p/kotlin/kotlin-ide") + maven("https://cache-redirector.jetbrains.com/maven.pkg.jetbrains.space/kotlin/p/kotlin/kotlin-ide-plugin-dependencies") + + maven("https://cache-redirector.jetbrains.com/intellij-repository/releases") + maven("https://cache-redirector.jetbrains.com/intellij-third-party-dependencies") + + // Declare the Node.js & Yarn download repositories + // Required by Gradle Node plugin: https://github.com/node-gradle/gradle-node-plugin/blob/3.5.1/docs/faq.md#is-this-plugin-compatible-with-centralized-repositories-declaration + exclusiveContent { + forRepository { + ivy("https://cache-redirector.jetbrains.com/nodejs.org/dist/") { + name = "Node Distributions at $url" + patternLayout { artifact("v[revision]/[artifact](-v[revision]-[classifier]).[ext]") } + metadataSources { artifact() } + content { includeModule("org.nodejs", "node") } + } + } + filter { includeGroup("org.nodejs") } + } + + exclusiveContent { + forRepository { + ivy("https://github.com/yarnpkg/yarn/releases/download") { + name = "Yarn Distributions at $url" + patternLayout { artifact("v[revision]/[artifact](-v[revision]).[ext]") } + metadataSources { artifact() } + content { includeModule("com.yarnpkg", "yarn") } + } + } + filter { includeGroup("com.yarnpkg") } + } + } + + versionCatalogs { + create("libs") { + from(files("../gradle/libs.versions.toml")) + } + } +} + +enableFeaturePreview("TYPESAFE_PROJECT_ACCESSORS") + +include( + ":analysis-java-psi", + ":analysis-kotlin-api", + ":analysis-kotlin-descriptors", + ":analysis-kotlin-descriptors-compiler", + ":analysis-kotlin-descriptors-ide", + ":analysis-kotlin-symbols", + ":analysis-markdown-jb", + ":core", + ":core-content-matcher-test-utils", + ":core-test-api", + ":plugin-all-modules-page", + ":plugin-android-documentation", + ":plugin-base", + ":plugin-base-frontend", + ":plugin-base-test-utils", + ":plugin-gfm", + ":plugin-gfm-template-processing", + ":plugin-javadoc", + ":plugin-jekyll", + ":plugin-jekyll-template-processing", + ":plugin-kotlin-as-java", + ":plugin-mathjax", + ":plugin-templating", + ":plugin-versioning", +) diff --git a/settings.gradle.kts b/settings.gradle.kts index 9934e1e7e5..108a35ead8 100644 --- a/settings.gradle.kts +++ b/settings.gradle.kts @@ -58,47 +58,54 @@ plugins { `gradle-enterprise` } +includeBuild("dokka-integration-tests") +includeBuild("dokka-subprojects") +includeBuild("dokka-runners/gradle-plugin") +includeBuild("dokka-runners/gradle-plugin-classic") +includeBuild("dokka-runners/maven-plugin") +includeBuild("dokka-runners/cli") + include( - ":core", - ":core:test-api", - ":core:content-matcher-test-utils", - - ":subprojects", - - ":subprojects:analysis-java-psi", - ":subprojects:analysis-kotlin-api", - ":subprojects:analysis-kotlin-descriptors", - ":subprojects:analysis-kotlin-descriptors:compiler", - ":subprojects:analysis-kotlin-descriptors:ide", - ":subprojects:analysis-kotlin-symbols", - ":subprojects:analysis-markdown-jb", - - ":runners:gradle-plugin", - ":runners:cli", - ":runners:maven-plugin", - - ":plugins:base", - ":plugins:base:frontend", - ":plugins:base:base-test-utils", - ":plugins:all-modules-page", - ":plugins:templating", - ":plugins:versioning", - ":plugins:android-documentation", - - ":plugins:mathjax", - ":plugins:gfm", - ":plugins:gfm:gfm-template-processing", - ":plugins:jekyll", - ":plugins:jekyll:jekyll-template-processing", - ":plugins:kotlin-as-java", - ":plugins:javadoc", - - ":integration-tests", - ":integration-tests:gradle", - ":integration-tests:cli", - ":integration-tests:maven", - - ":docs-developer", +// ":core", +// ":core:test-api", +// ":core:content-matcher-test-utils", +// +// ":subprojects", +// +// ":subprojects:analysis-java-psi", +// ":subprojects:analysis-kotlin-api", +// ":subprojects:analysis-kotlin-descriptors", +// ":subprojects:analysis-kotlin-descriptors:compiler", +// ":subprojects:analysis-kotlin-descriptors:ide", +// ":subprojects:analysis-kotlin-symbols", +// ":subprojects:analysis-markdown-jb", +// +//// ":runners:gradle-plugin", +//// ":runners:cli", +//// ":runners:maven-plugin", +// +// ":plugins:base", +// ":plugins:base:frontend", +// ":plugins:base:base-test-utils", +// ":plugins:all-modules-page", +// ":plugins:templating", +// ":plugins:versioning", +// ":plugins:android-documentation", +// +// ":plugins:mathjax", +// ":plugins:gfm", +// ":plugins:gfm:gfm-template-processing", +// ":plugins:jekyll", +// ":plugins:jekyll:jekyll-template-processing", +// ":plugins:kotlin-as-java", +// ":plugins:javadoc", +// +//// ":integration-tests", +//// ":integration-tests:gradle", +//// ":integration-tests:cli", +//// ":integration-tests:maven", +// +// ":docs-developer", ) val isCiBuild = System.getenv("GITHUB_ACTIONS") != null || System.getenv("TEAMCITY_VERSION") != null