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
|
@file:Suppress("FunctionName")
package org.jetbrains.dokka
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 outputDir = File("./dokka")
const val format: String = "html"
val cacheRoot: File? = null
const val offlineMode: Boolean = false
const val failOnWarning: Boolean = false
const val includeNonPublic: Boolean = false
const val includeRootPackage: 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"
}
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
else -> throw IllegalArgumentException("Unrecognized platform: $key")
}
}
}
}
interface DokkaConfigurationBuilder<T : Any> {
fun build(): T
}
fun <T : Any> Iterable<DokkaConfigurationBuilder<T>>.build(): List<T> {
return this.map { it.build() }
}
data class DokkaSourceSetID(
val moduleName: String,
val sourceSetName: String
) : Serializable {
override fun toString(): String {
return "$moduleName/$sourceSetName"
}
}
fun DokkaConfigurationImpl(json: String): DokkaConfigurationImpl = parseJson(json)
fun DokkaConfiguration.toJsonString(): String = toJsonString(this)
interface DokkaConfiguration : Serializable {
val outputDir: File
val cacheRoot: File?
val offlineMode: Boolean
val failOnWarning: Boolean
val sourceSets: List<DokkaSourceSet>
val modules: List<DokkaModuleDescription>
val pluginsClasspath: Set<File>
val pluginsConfiguration: Map<String, String>
interface DokkaSourceSet : Serializable {
val sourceSetID: DokkaSourceSetID
val displayName: String
val moduleDisplayName: String
val classpath: Set<File>
val sourceRoots: Set<File>
val dependentSourceSets: Set<DokkaSourceSetID>
val samples: Set<File>
val includes: Set<File>
val includeNonPublic: Boolean
val includeRootPackage: 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 path: String
val url: String
val lineSuffix: String?
}
interface DokkaModuleDescription : Serializable {
val name: String
val path: File
val docFile: File
}
interface PackageOptions : Serializable {
val prefix: String
val includeNonPublic: Boolean
val reportUndocumented: Boolean?
val skipDeprecated: Boolean
val suppress: Boolean
}
interface ExternalDocumentationLink : Serializable {
val url: URL
val packageListUrl: URL
open class Builder(
open var url: URL? = null,
open var packageListUrl: URL? = null
) {
constructor(root: String, packageList: String? = null) : this(URL(root), packageList?.let { URL(it) })
fun build(): ExternalDocumentationLinkImpl =
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: URL? = null,
packageListUrl: URL? = null
): ExternalDocumentationLinkImpl =
DokkaConfiguration.ExternalDocumentationLink.Builder(url = url, packageListUrl = packageListUrl).build()
fun ExternalDocumentationLink(
url: String, packageListUrl: String? = null
): ExternalDocumentationLinkImpl =
DokkaConfiguration.ExternalDocumentationLink.Builder(root = url, packageList = packageListUrl).build()
|
