-
Notifications
You must be signed in to change notification settings - Fork 110
/
MavenPublishPlugin.kt
146 lines (128 loc) · 5.39 KB
/
MavenPublishPlugin.kt
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
package com.vanniktech.maven.publish
import org.gradle.api.JavaVersion
import org.gradle.api.Plugin
import org.gradle.api.Project
import org.gradle.api.plugins.JavaPluginExtension
import org.gradle.api.publish.maven.MavenPublication
import org.gradle.api.tasks.javadoc.Javadoc
import org.gradle.external.javadoc.StandardJavadocDocletOptions
import org.jetbrains.dokka.gradle.DokkaTask
open class MavenPublishPlugin : Plugin<Project> {
override fun apply(project: Project) {
project.plugins.apply(MavenPublishBasePlugin::class.java)
val baseExtension = project.baseExtension
project.setCoordinates()
val sonatypeHost = project.findOptionalProperty("SONATYPE_HOST")
if (sonatypeHost != null && sonatypeHost.isNotBlank()) {
baseExtension.publishToMavenCentral(SonatypeHost.valueOf(sonatypeHost))
}
val releaseSigning = project.findOptionalProperty("RELEASE_SIGNING_ENABLED")?.toBoolean()
if (releaseSigning == true) {
baseExtension.signAllPublications()
}
baseExtension.pomFromGradleProperties()
project.configurePlatform()
}
}
private fun Project.setCoordinates() {
group = project.findOptionalProperty("GROUP") ?: group
version = project.findOptionalProperty("VERSION_NAME") ?: version
// Artifact id defaults to project name which is not mutable.
// Some created publications use derived artifact ids (e.g. library, library-jvm, library-js) so it needs to be
// replaced instead of just set.
val artifactId = project.findOptionalProperty("POM_ARTIFACT_ID")
if (artifactId != null && artifactId != project.name) {
gradlePublishing.publications
.withType(MavenPublication::class.java)
.configureEach { publication ->
// skip the plugin marker artifact which has it's own artifact id based on the plugin id
if (publication.name.endsWith("PluginMarkerMaven")) {
return@configureEach
}
val projectName = name
val updatedArtifactId = publication.artifactId.replace(projectName, artifactId)
publication.artifactId = updatedArtifactId
// in Kotlin MPP projects some publications change our manually set artifactId again
afterEvaluate {
gradlePublishing.publications.withType(MavenPublication::class.java).named(publication.name).configure { publication ->
if (publication.artifactId != updatedArtifactId) {
publication.artifactId = publication.artifactId.replace(projectName, artifactId)
}
}
}
}
}
}
private fun Project.configurePlatform() {
plugins.withId("org.jetbrains.kotlin.multiplatform") {
baseExtension.configure(KotlinMultiplatform(defaultJavaDocOption() ?: JavadocJar.Empty()))
}
plugins.withId("com.android.library") {
// afterEvaluate is too late but we can't run this synchronously because we shouldn't call the APIs for
// multiplatform projects that use Android
androidComponents.finalizeDsl {
if (!plugins.hasPlugin("org.jetbrains.kotlin.multiplatform")) {
val variant = project.findOptionalProperty("ANDROID_VARIANT_TO_PUBLISH") ?: "release"
baseExtension.configure(AndroidSingleVariantLibrary(variant))
}
}
}
afterEvaluate {
when {
plugins.hasPlugin("org.jetbrains.kotlin.multiplatform") -> {} // Handled above.
plugins.hasPlugin("com.android.library") -> {} // Handled above.
plugins.hasPlugin("java-gradle-plugin") ->
baseExtension.configure(GradlePlugin(defaultJavaDocOption() ?: javadoc()))
plugins.hasPlugin("org.jetbrains.kotlin.jvm") ->
baseExtension.configure(KotlinJvm(defaultJavaDocOption() ?: javadoc()))
plugins.hasPlugin("org.jetbrains.kotlin.js") ->
baseExtension.configure(KotlinJs(defaultJavaDocOption() ?: JavadocJar.Empty()))
plugins.hasPlugin("java-library") ->
baseExtension.configure(JavaLibrary(defaultJavaDocOption() ?: javadoc()))
plugins.hasPlugin("java") ->
baseExtension.configure(JavaLibrary(defaultJavaDocOption() ?: javadoc()))
else -> logger.warn("No compatible plugin found in project $name for publishing")
}
}
}
private fun Project.defaultJavaDocOption(): JavadocJar? {
return if (plugins.hasPlugin("org.jetbrains.dokka") || plugins.hasPlugin("org.jetbrains.dokka-android")) {
JavadocJar.Dokka(findDokkaTask())
} else {
null
}
}
private fun Project.javadoc(): JavadocJar {
tasks.withType(Javadoc::class.java).configureEach {
val options = it.options as StandardJavadocDocletOptions
val javaVersion = javaVersion()
if (javaVersion.isJava9Compatible) {
options.addBooleanOption("html5", true)
}
if (javaVersion.isJava8Compatible) {
options.addStringOption("Xdoclint:none", "-quiet")
}
}
return JavadocJar.Javadoc()
}
private fun Project.javaVersion(): JavaVersion {
try {
val extension = project.extensions.findByType(JavaPluginExtension::class.java)
if (extension != null) {
val toolchain = extension.toolchain
val version = toolchain.languageVersion.get().asInt()
return JavaVersion.toVersion(version)
}
} catch (t: Throwable) {
// ignore failures and fallback to java version in which Gradle is running
}
return JavaVersion.current()
}
private fun Project.findDokkaTask(): String {
val tasks = project.tasks.withType(DokkaTask::class.java)
return if (tasks.size == 1) {
tasks.first().name
} else {
tasks.findByName("dokkaHtml")?.name ?: "dokka"
}
}