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
|
package org.jetbrains.dokka.kotlinAsJava
import org.jetbrains.dokka.base.transformers.documentables.DefaultPageBuilder
import org.jetbrains.dokka.base.transformers.documentables.RootContentBuilder
import org.jetbrains.dokka.kotlinAsJava.conversions.asJava
import org.jetbrains.dokka.kotlinAsJava.conversions.asStatic
import org.jetbrains.dokka.kotlinAsJava.conversions.withClass
import org.jetbrains.dokka.links.DRI
import org.jetbrains.dokka.links.withClass
import org.jetbrains.dokka.model.*
import org.jetbrains.dokka.model.Enum
import org.jetbrains.dokka.model.Function
import org.jetbrains.dokka.pages.*
import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
import org.jetbrains.kotlin.descriptors.Visibilities
import org.jetbrains.kotlin.js.resolve.diagnostics.findPsi
fun DeclarationDescriptor.sourceLocation(): String? = this.findPsi()?.containingFile?.virtualFile?.path
fun <T : Documentable> List<T>.groupedByLocation(): Map<String, List<T>> =
this.map { DescriptorCache[it.dri]?.sourceLocation() to it }
.filter { it.first != null }.groupBy({ (location, _) ->
location!!.let { it.split("/").last().split(".").first() + "Kt" }
}) { it.second }
fun PlatformInfo.toClassPlatformInfo(inherited: List<DRI> = emptyList()) =
ClassPlatformInfo(this, emptyList())
class KotlinAsJavaPageBuilder(rootContentGroup: RootContentBuilder) : DefaultPageBuilder(rootContentGroup) {
override fun pageForModule(m: Module): ModulePageNode =
ModulePageNode(m.name.ifEmpty { "root" }, contentForModule(m), m, m.packages.map { pageForPackage(it) })
data class FunsAndProps(val key: String, val funs: List<Function>, val props: List<Property>)
override fun pageForPackage(p: Package): PackagePageNode {
val funs = p.functions.groupedByLocation()
val props = p.properties.groupedByLocation()
val zipped = (funs.keys + props.keys)
.map { k -> FunsAndProps(k, funs[k].orEmpty(), props[k].orEmpty()) }
val classes = (p.classlikes + zipped.map { (key, funs, props) ->
val dri = p.dri.withClass(key)
val actual =
(funs.flatMap { it.actual } + props.flatMap { it.actual }).distinct().map { it.toClassPlatformInfo() }
Class(
dri = dri,
name = key,
kind = KotlinClassKindTypes.CLASS,
constructors = emptyList(),
functions = funs.map { it.withClass(key, dri).asStatic() },
properties = props.map { it.withClass(key, dri) },
classlikes = emptyList(),
actual = actual,
expected = null,
visibility = p.platformData.map { it to Visibilities.PUBLIC }.toMap()
)
}).map { it.asJava() }
return PackagePageNode(
p.name, contentForPackage(p, classes), setOf(p.dri), p,
classes.map(::pageForClasslike)
)
}
private fun contentForPackage(p: Package, nClasses: List<Classlike>) = group(p) {
header(1) { text("Package ${p.name}") }
block("Types", 2, ContentKind.Properties, nClasses, p.platformData) {
link(it.name, it.dri)
text(it.briefDocTagString)
}
}
override fun contentForClasslike(c: Classlike): ContentGroup = when (c) {
is Class -> contentForClass(c)
is Enum -> contentForEnum(c)
else -> throw IllegalStateException("$c should not be present here")
}
}
|
