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
|
package org.jetbrains.dokka.base.renderers.html
import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
import org.jetbrains.dokka.Platform
import org.jetbrains.dokka.base.templating.AddToSearch
import org.jetbrains.dokka.links.DRI
import org.jetbrains.dokka.model.DisplaySourceSet
import org.jetbrains.dokka.model.dfs
import org.jetbrains.dokka.model.withDescendants
import org.jetbrains.dokka.pages.*
import org.jetbrains.dokka.plugability.DokkaContext
import org.jetbrains.dokka.transformers.pages.PageTransformer
typealias PageId = String
data class SearchRecord(
val name: String,
val description: String? = null,
val location: String,
val searchKeys: List<String> = listOf(name)
) {
companion object {}
}
open class SearchbarDataInstaller(val context: DokkaContext) : PageTransformer {
data class PageWithId(val dri: DRI, val page: ContentPage) {
val displayableSignature = getSymbolSignature(page, dri)?.let { flattenToText(it) } ?: page.name
val id: String
get() = listOfNotNull(
dri.packageName,
dri.classNames,
dri.callable?.name
).joinToString(".")
}
private val mapper = jacksonObjectMapper()
open fun generatePagesList(pages: List<PageWithId>, locationResolver: PageResolver): List<SearchRecord> =
pages.map { pageWithId ->
createSearchRecord(
name = pageWithId.displayableSignature,
description = pageWithId.id,
location = resolveLocation(locationResolver, pageWithId.page).orEmpty(),
searchKeys = listOf(
pageWithId.id.substringAfterLast("."),
pageWithId.displayableSignature,
pageWithId.id,
)
)
}.sortedWith(compareBy({ it.name }, { it.description }))
open fun createSearchRecord(
name: String,
description: String?,
location: String,
searchKeys: List<String>
): SearchRecord =
SearchRecord(name, description, location, searchKeys)
open fun processPage(page: PageNode): List<PageWithId> =
when (page) {
is ContentPage -> page.takeIf { page !is ModulePageNode && page !is PackagePageNode }?.dri
?.map { dri -> PageWithId(dri, page) }.orEmpty()
else -> emptyList()
}
private fun resolveLocation(locationResolver: PageResolver, page: ContentPage): String? =
locationResolver(page, null).also { location ->
if (location.isNullOrBlank()) context.logger.warn("Cannot resolve path for ${page.dri}")
}
override fun invoke(input: RootPageNode): RootPageNode {
val page = RendererSpecificResourcePage(
name = "scripts/pages.json",
children = emptyList(),
strategy = RenderingStrategy.PageLocationResolvableWrite { resolver ->
val content = input.withDescendants().fold(emptyList<PageWithId>()) { pageList, page ->
pageList + processPage(page)
}.run {
generatePagesList(this, resolver)
}
if (context.configuration.delayTemplateSubstitution) {
mapper.writeValueAsString(AddToSearch(context.configuration.moduleName, content))
} else {
mapper.writeValueAsString(content)
}
})
return input.modified(children = input.children + page)
}
}
private fun getSymbolSignature(page: ContentPage, dri: DRI) =
page.content.dfs { it.dci.kind == ContentKind.Symbol && it.dci.dri.contains(dri) }
private fun flattenToText(node: ContentNode): String {
fun getContentTextNodes(node: ContentNode, sourceSetRestriction: DisplaySourceSet): List<ContentText> =
when (node) {
is ContentText -> listOf(node)
is ContentComposite -> node.children
.filter { sourceSetRestriction in it.sourceSets }
.flatMap { getContentTextNodes(it, sourceSetRestriction) }
.takeIf { node.dci.kind != ContentKind.Annotations }
.orEmpty()
else -> emptyList()
}
val sourceSetRestriction =
node.sourceSets.find { it.platform == Platform.common } ?: node.sourceSets.first()
return getContentTextNodes(node, sourceSetRestriction).joinToString("") { it.text }
}
|
