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
177
178
179
180
181
182
183
184
185
186
|
@file:Suppress("FunctionName")
package org.jetbrains.dokka
import org.jetbrains.dokka.plugability.ConfigurableBlock
import org.jetbrains.dokka.utilities.parseJson
import org.jetbrains.dokka.utilities.toJsonString
import java.io.File
import java.io.Serializable
import java.net.URL
object DokkaDefaults {
val moduleName: String = "root"
val outputDir = File("./dokka")
const val format: String = "html"
val cacheRoot: File? = null
const val offlineMode: Boolean = false
const val failOnWarning: Boolean = false
const val delayTemplateSubstitution: Boolean = false
const val includeNonPublic: Boolean = false
const val reportUndocumented: Boolean = false
const val skipEmptyPackages: Boolean = true
const val skipDeprecated: Boolean = false
const val jdkVersion: Int = 8
const val noStdlibLink: Boolean = false
const val noJdkLink: Boolean = false
val analysisPlatform: Platform = Platform.DEFAULT
const val suppress: Boolean = false
const val sourceSetDisplayName = "JVM"
const val sourceSetName = "main"
val moduleVersion: String? = null
val pluginsConfiguration = mutableListOf<PluginConfigurationImpl>()
const val suppressObviousFunctions = true
}
enum class Platform(val key: String) {
jvm("jvm"),
js("js"),
native("native"),
common("common");
companion object {
val DEFAULT = jvm
fun fromString(key: String): Platform {
return when (key.toLowerCase()) {
jvm.key -> jvm
js.key -> js
native.key -> native
common.key -> common
"androidjvm", "android" -> jvm
"metadata" -> common
else -> throw IllegalArgumentException("Unrecognized platform: $key")
}
}
}
}
interface DokkaConfigurationBuilder<T : Any> {
fun build(): T
}
fun <T : Any> Iterable<DokkaConfigurationBuilder<T>>.build(): List<T> = this.map { it.build() }
data class DokkaSourceSetID(
/**
* Unique identifier of the scope that this source set is placed in.
* Each scope provide only unique source set names.
*
* E.g. One DokkaTask inside the Gradle plugin represents one source set scope, since there cannot be multiple
* source sets with the same name. However, a Gradle project will not be a proper scope, since there can be
* multple DokkaTasks that contain source sets with the same name (but different configuration)
*/
val scopeId: String,
val sourceSetName: String
) : Serializable {
override fun toString(): String {
return "$scopeId/$sourceSetName"
}
}
fun DokkaConfigurationImpl(json: String): DokkaConfigurationImpl = parseJson(json)
fun DokkaConfiguration.toJsonString(): String = toJsonString(this)
fun <T : ConfigurableBlock> T.toJsonString(): String = toJsonString(this)
interface DokkaConfiguration : Serializable {
val moduleName: String
val moduleVersion: String?
val outputDir: File
val cacheRoot: File?
val offlineMode: Boolean
val failOnWarning: Boolean
val sourceSets: List<DokkaSourceSet>
val modules: List<DokkaModuleDescription>
val pluginsClasspath: List<File>
val pluginsConfiguration: List<PluginConfiguration>
val delayTemplateSubstitution: Boolean
val suppressObviousFunctions: Boolean
val includes: Set<File>
enum class SerializationFormat : Serializable {
JSON, XML
}
interface PluginConfiguration : Serializable {
val fqPluginName: String
val serializationFormat: SerializationFormat
val values: String
}
interface DokkaSourceSet : Serializable {
val sourceSetID: DokkaSourceSetID
val displayName: String
val classpath: List<File>
val sourceRoots: Set<File>
val dependentSourceSets: Set<DokkaSourceSetID>
val samples: Set<File>
val includes: Set<File>
val includeNonPublic: Boolean
val reportUndocumented: Boolean
val skipEmptyPackages: Boolean
val skipDeprecated: Boolean
val jdkVersion: Int
val sourceLinks: Set<SourceLinkDefinition>
val perPackageOptions: List<PackageOptions>
val externalDocumentationLinks: Set<ExternalDocumentationLink>
val languageVersion: String?
val apiVersion: String?
val noStdlibLink: Boolean
val noJdkLink: Boolean
val suppressedFiles: Set<File>
val analysisPlatform: Platform
}
interface SourceLinkDefinition : Serializable {
val localDirectory: String
val remoteUrl: URL
val remoteLineSuffix: String?
}
interface DokkaModuleDescription : Serializable {
val name: String
val relativePathToOutputDirectory: File
val sourceOutputDirectory: File
val includes: Set<File>
}
interface PackageOptions : Serializable {
val matchingRegex: String
val includeNonPublic: Boolean
val reportUndocumented: Boolean?
val skipDeprecated: Boolean
val suppress: Boolean
}
interface ExternalDocumentationLink : Serializable {
val url: URL
val packageListUrl: URL
companion object
}
}
fun ExternalDocumentationLink(
url: URL? = null,
packageListUrl: URL? = null
): ExternalDocumentationLinkImpl {
return if (packageListUrl != null && url != null)
ExternalDocumentationLinkImpl(url, packageListUrl)
else if (url != null)
ExternalDocumentationLinkImpl(url, URL(url, "package-list"))
else
throw IllegalArgumentException("url or url && packageListUrl must not be null for external documentation link")
}
fun ExternalDocumentationLink(
url: String, packageListUrl: String? = null
): ExternalDocumentationLinkImpl =
ExternalDocumentationLink(url.let(::URL), packageListUrl?.let(::URL))
|
