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
|
package org.jetbrains.dokka.pages
import org.jetbrains.dokka.model.doc.TagWrapper
import org.jetbrains.dokka.model.*
import org.jetbrains.dokka.model.Function
class DefaultPageBuilder(
override val rootContentGroup: RootContentBuilder
) : PageBuilder {
override fun pageForModule(m: Module): ModulePageNode =
ModulePageNode(m.name.ifEmpty { "root" }, contentForModule(m), m, m.packages.map { pageForPackage(it) })
override fun pageForPackage(p: Package) =
PackagePageNode(p.name, contentForPackage(p), setOf(p.dri), p,
p.classes.map { pageForClass(it) } +
p.functions.map { pageForMember(it) })
override fun pageForClass(c: Class): ClassPageNode =
ClassPageNode(c.name, contentForClass(c), setOf(c.dri), c,
c.constructors.map { pageForMember(it) } +
c.classes.map { pageForClass(it) } +
c.functions.map { pageForMember(it) })
override fun pageForMember(m: CallableNode): MemberPageNode =
when (m) {
is Function ->
MemberPageNode(m.name, contentForFunction(m), setOf(m.dri), m)
else -> throw IllegalStateException("$m should not be present here")
}
private fun group(node: Documentable, content: PageContentBuilderFunction) =
rootContentGroup(node, ContentKind.Main, content)
private fun contentForModule(m: Module) = group(m) {
header(1) { text("root") }
block("Packages", 2, ContentKind.Packages, m.packages, m.platformData) {
link(it.name, it.dri)
}
text("Index\n")
text("Link to allpage here")
}
private fun contentForPackage(p: Package) = group(p) {
header(1) { text("Package ${p.name}") }
block("Types", 2, ContentKind.Properties, p.classes, p.platformData) {
link(it.name, it.dri)
text(it.briefDocTagString)
}
block("Functions", 2, ContentKind.Functions, p.functions, p.platformData) {
link(it.name, it.dri)
signature(it)
text(it.briefDocTagString)
}
}
private fun contentForClass(c: Class) = group(c) {
header(1) { text(c.name) }
c.inherited.takeIf { it.isNotEmpty() }?.let {
header(2) { text("SuperInterfaces") }
linkTable(it)
}
c.platformInfo.forEach { platformInfo ->
platformInfo.documentationNode.children.forEach {
header(3) {
text(it.toHeaderString())
text("[${platformInfo.platformData.joinToString(", ") { it.platformType.name }}]")
}
comment(it.root)
text("\n")
}
}
block("Constructors", 2, ContentKind.Functions, c.constructors, c.platformData) {
link(it.name, it.dri)
signature(it)
text(it.briefDocTagString)
}
block("Functions", 2, ContentKind.Functions, c.functions, c.platformData) {
link(it.name, it.dri)
signature(it)
text(it.briefDocTagString)
}
block("Properties", 2, ContentKind.Properties, c.properties, c.platformData) {
link(it.name, it.dri)
text(it.briefDocTagString)
}
}
private fun contentForFunction(f: Function) = group(f) {
header(1) { text(f.name) }
signature(f)
f.platformInfo.forEach { platformInfo ->
platformInfo.documentationNode.children.forEach {
header(3) {
text(it.toHeaderString())
text("[${platformInfo.platformData.joinToString(", ") { it.platformType.name }}]")
}
comment(it.root)
text("\n")
}
}
block("Parameters", 2, ContentKind.Parameters, f.children, f.platformData) {
text(it.name ?: "<receiver>")
it.platformInfo.forEach { it.documentationNode.children.forEach { comment(it.root) } }
}
}
private fun TagWrapper.toHeaderString() = this.javaClass.toGenericString().split('.').last()
}
typealias RootContentBuilder = (Documentable, Kind, PageContentBuilderFunction) -> ContentGroup
interface PageBuilder {
val rootContentGroup: RootContentBuilder
fun pageForModule(m: Module): ModulePageNode
fun pageForPackage(p: Package): PackagePageNode
fun pageForMember(m: CallableNode): MemberPageNode
fun pageForClass(c: Class): ClassPageNode
}
|
