-
Notifications
You must be signed in to change notification settings - Fork 6
/
DokkatooFormatPlugin.kt
176 lines (143 loc) · 6.17 KB
/
DokkatooFormatPlugin.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
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
package dev.adamko.dokkatoo.formats
import dev.adamko.dokkatoo.DokkatooBasePlugin
import dev.adamko.dokkatoo.DokkatooExtension
import dev.adamko.dokkatoo.adapters.DokkatooAndroidAdapter
import dev.adamko.dokkatoo.adapters.DokkatooJavaAdapter
import dev.adamko.dokkatoo.adapters.DokkatooKotlinAdapter
import dev.adamko.dokkatoo.internal.*
import javax.inject.Inject
import org.gradle.api.Plugin
import org.gradle.api.Project
import org.gradle.api.artifacts.Dependency
import org.gradle.api.artifacts.dsl.DependencyHandler
import org.gradle.api.file.FileSystemOperations
import org.gradle.api.model.ObjectFactory
import org.gradle.api.provider.Property
import org.gradle.api.provider.Provider
import org.gradle.api.provider.ProviderFactory
import org.gradle.kotlin.dsl.*
/**
* Base Gradle Plugin for setting up a Dokka Publication for a specific format.
*
* [DokkatooBasePlugin] must be applied for this plugin (or any subclass) to have an effect.
*
* Anyone can use this class as a basis for a generating a Dokka Publication in a custom format.
*/
abstract class DokkatooFormatPlugin(
val formatName: String,
) : Plugin<Project> {
@get:Inject
@DokkatooInternalApi
protected abstract val objects: ObjectFactory
@get:Inject
@DokkatooInternalApi
protected abstract val providers: ProviderFactory
@get:Inject
@DokkatooInternalApi
protected abstract val files: FileSystemOperations
override fun apply(target: Project) {
// apply DokkatooBasePlugin
target.pluginManager.apply(DokkatooBasePlugin::class)
// apply the plugin that will autoconfigure Dokkatoo to use the sources of a Kotlin project
target.pluginManager.apply(type = DokkatooKotlinAdapter::class)
target.pluginManager.apply(type = DokkatooJavaAdapter::class)
target.pluginManager.apply(type = DokkatooAndroidAdapter::class)
target.plugins.withType<DokkatooBasePlugin>().configureEach {
val dokkatooExtension = target.extensions.getByType(DokkatooExtension::class)
val publication = dokkatooExtension.dokkatooPublications.create(formatName)
val dokkatooConsumer =
target.configurations.named(DokkatooBasePlugin.dependencyContainerNames.dokkatoo)
val dependencyContainers = DokkatooFormatDependencyContainers(
formatName = formatName,
dokkatooConsumer = dokkatooConsumer,
project = target,
)
val dokkatooTasks = DokkatooFormatTasks(
project = target,
publication = publication,
dokkatooExtension = dokkatooExtension,
dependencyContainers = dependencyContainers,
providers = providers,
)
dependencyContainers.dokkaModuleOutgoing.configure {
outgoing {
artifact(dokkatooTasks.prepareModuleDescriptor.flatMap { it.dokkaModuleDescriptorJson })
}
outgoing {
artifact(dokkatooTasks.generateModule.flatMap { it.outputDirectory }) {
type = "directory"
}
}
}
// TODO DokkaCollect replacement - share raw files without first generating a Dokka Module
//dependencyCollections.dokkaParametersOutgoing.configure {
// outgoing {
// artifact(dokkatooTasks.prepareParametersTask.flatMap { it.dokkaConfigurationJson })
// }
//}
val context = DokkatooFormatPluginContext(
project = target,
dokkatooExtension = dokkatooExtension,
dokkatooTasks = dokkatooTasks,
formatName = formatName,
)
context.configure()
if (context.addDefaultDokkaDependencies) {
with(context) {
addDefaultDokkaDependencies()
}
}
}
}
/** Format specific configuration - to be implemented by subclasses */
open fun DokkatooFormatPluginContext.configure() {}
@DokkatooInternalApi
class DokkatooFormatPluginContext(
val project: Project,
val dokkatooExtension: DokkatooExtension,
val dokkatooTasks: DokkatooFormatTasks,
formatName: String,
) {
private val dependencyContainerNames = DokkatooBasePlugin.DependencyContainerNames(formatName)
var addDefaultDokkaDependencies = true
/** Create a [Dependency] for a Dokka module */
fun DependencyHandler.dokka(module: String): Provider<Dependency> =
dokkatooExtension.versions.jetbrainsDokka.map { version -> create("org.jetbrains.dokka:$module:$version") }
/** Add a dependency to the Dokka plugins classpath */
fun DependencyHandler.dokkaPlugin(dependency: Provider<Dependency>): Unit =
addProvider(dependencyContainerNames.dokkaPluginsClasspath, dependency)
/** Add a dependency to the Dokka plugins classpath */
fun DependencyHandler.dokkaPlugin(dependency: String) {
add(dependencyContainerNames.dokkaPluginsClasspath, dependency)
}
/** Add a dependency to the Dokka Generator classpath */
fun DependencyHandler.dokkaGenerator(dependency: Provider<Dependency>) {
addProvider(dependencyContainerNames.dokkaGeneratorClasspath, dependency)
}
/** Add a dependency to the Dokka Generator classpath */
fun DependencyHandler.dokkaGenerator(dependency: String) {
add(dependencyContainerNames.dokkaGeneratorClasspath, dependency)
}
}
private fun DokkatooFormatPluginContext.addDefaultDokkaDependencies() {
project.dependencies {
/** lazily create a [Dependency] with the provided [version] */
infix fun String.version(version: Property<String>): Provider<Dependency> =
version.map { v -> create("$this:$v") }
with(dokkatooExtension.versions) {
dokkaPlugin(dokka("dokka-analysis"))
dokkaPlugin(dokka("templating-plugin"))
dokkaPlugin(dokka("dokka-base"))
dokkaPlugin(dokka("kotlin-analysis-intellij"))
dokkaPlugin(dokka("kotlin-analysis-compiler"))
// dokkaPlugin(dokka("all-modules-page-plugin"))
dokkaPlugin("org.jetbrains.kotlinx:kotlinx-html" version kotlinxHtml)
dokkaPlugin("org.freemarker:freemarker" version freemarker)
dokkaGenerator(dokka("dokka-core"))
// TODO why does org.jetbrains:markdown need a -jvm suffix?
dokkaGenerator("org.jetbrains:markdown-jvm" version jetbrainsMarkdown)
dokkaGenerator("org.jetbrains.kotlinx:kotlinx-coroutines-core" version kotlinxCoroutines)
}
}
}
}