diff options
Diffstat (limited to 'plugins/base/src/main/kotlin')
3 files changed, 206 insertions, 130 deletions
diff --git a/plugins/base/src/main/kotlin/renderers/html/HtmlRenderer.kt b/plugins/base/src/main/kotlin/renderers/html/HtmlRenderer.kt index c62c5d3c..792eb1dc 100644 --- a/plugins/base/src/main/kotlin/renderers/html/HtmlRenderer.kt +++ b/plugins/base/src/main/kotlin/renderers/html/HtmlRenderer.kt @@ -7,6 +7,7 @@ import org.jetbrains.dokka.base.DokkaBase import org.jetbrains.dokka.base.renderers.DefaultRenderer import org.jetbrains.dokka.links.DRI import org.jetbrains.dokka.model.SourceSetData +import org.jetbrains.dokka.model.properties.PropertyContainer import org.jetbrains.dokka.pages.* import org.jetbrains.dokka.plugability.DokkaContext import org.jetbrains.dokka.plugability.plugin @@ -36,6 +37,30 @@ open class HtmlRenderer( ) { val additionalClasses = node.style.joinToString(" ") { it.toString().toLowerCase() } return when { + node.hasStyle(ContentStyle.TabbedContent) -> div(additionalClasses) { + val secondLevel = node.children.filterIsInstance<ContentComposite>().flatMap { it.children }.filterIsInstance<ContentHeader>().flatMap { it.children }.filterIsInstance<ContentText>() + val firstLevel = node.children.filterIsInstance<ContentHeader>().flatMap { it.children }.filterIsInstance<ContentText>() + + val renderable = firstLevel.union(secondLevel) + + div(classes = "tabs-section"){ + attributes["tabs-section"] = "tabs-section" + renderable.forEachIndexed { index, node -> + button(classes = "section-tab"){ + if(index == 0 ) attributes["data-active"] = "" + attributes["data-togglable"] = node.text + text(node.text) + } + } + } + div(classes = "tabs-section-body"){ + childrenCallback() + } + } + node.hasStyle(ContentStyle.WithExtraAttributes) -> div() { + node.extra.extraHtmlAttributes().forEach { attributes[it.extraKey] = it.extraValue } + childrenCallback() + } node.dci.kind == ContentKind.Symbol -> div("symbol $additionalClasses") { childrenCallback() } node.dci.kind == ContentKind.BriefComment -> div("brief $additionalClasses") { childrenCallback() } node.dci.kind == ContentKind.Cover -> div("cover $additionalClasses") { childrenCallback() } @@ -46,15 +71,18 @@ open class HtmlRenderer( } override fun FlowContent.buildPlatformDependent(content: PlatformHintedContent, pageContext: ContentPage) = - buildPlatformDependent(content.sourceSets.map { it to setOf(content.inner) }.toMap(), pageContext) + buildPlatformDependent(content.sourceSets.map { it to setOf(content.inner) }.toMap(), pageContext, content.extra) private fun FlowContent.buildPlatformDependent( nodes: Map<SourceSetData, Collection<ContentNode>>, - pageContext: ContentPage + pageContext: ContentPage, + extra: PropertyContainer<ContentNode> = PropertyContainer.empty() ) { var mergedToOneSourceSet : SourceSetData? = null div("platform-hinted") { attributes["data-platform-hinted"] = "data-platform-hinted" + extra.extraHtmlAttributes().forEach { attributes[it.extraKey] = it.extraValue } + val additionalClasses = if(nodes.toList().size == 1) "single-content" else "" var counter = 0 val contents = nodes.toList().map { (sourceSet, elements) -> sourceSet to createHTML(prettyPrint = false).div { @@ -66,7 +94,7 @@ open class HtmlRenderer( sourceSets.filterNot { sourceSetDependencyMap[it].orEmpty().any { dependency -> sourceSets.contains(dependency) } }.map { - it to createHTML(prettyPrint = false).div(classes = "content") { + it to createHTML(prettyPrint = false).div(classes = "content $additionalClasses") { if (counter++ == 0) attributes["data-active"] = "" attributes["data-togglable"] = it.sourceSetName unsafe { @@ -130,27 +158,29 @@ open class HtmlRenderer( distinct.forEach { val groupedDivergent = it.value.groupBy { it.second } - consumer.onTagContentUnsafe { +it.key.first } consumer.onTagContentUnsafe { - +createHTML(prettyPrint = false).div("main-subrow") { - if (node.implicitlySourceSetHinted) { - buildPlatformDependent( - groupedDivergent.map { (sourceSet, elements) -> - sourceSet to elements.map { e -> e.first.divergent } - }.toMap(), - pageContext - ) - if (distinct.size > 1 && groupedDivergent.size == 1) { - createPlatformTags(node, groupedDivergent.keys) - } - } else { - it.value.forEach { - buildContentNode(it.first.divergent, pageContext, setOf(it.second)) + +createHTML().div("divergent-group"){ + consumer.onTagContentUnsafe { +it.key.first } + div("main-subrow") { + if (node.implicitlySourceSetHinted) { + buildPlatformDependent( + groupedDivergent.map { (sourceSet, elements) -> + sourceSet to elements.map { e -> e.first.divergent } + }.toMap(), + pageContext + ) + if (distinct.size > 1 && groupedDivergent.size == 1) { + createPlatformTags(node, groupedDivergent.keys) + } + } else { + it.value.forEach { + buildContentNode(it.first.divergent, pageContext, setOf(it.second)) + } } } + consumer.onTagContentUnsafe { +it.key.second } } } - consumer.onTagContentUnsafe { +it.key.second } } } @@ -273,6 +303,7 @@ open class HtmlRenderer( sourceSetRestriction: Set<SourceSetData>? ) { div(classes = "table") { + node.extra.extraHtmlAttributes().forEach { attributes[it.extraKey] = it.extraValue } node.children.forEach { buildRow(it, pageContext, sourceSetRestriction) } @@ -435,4 +466,6 @@ fun List<SimpleAttr>.joinAttr() = joinToString(" ") { it.extraKey + "=" + it.ext private fun String.stripDiv() = drop(5).dropLast(6) // TODO: Find a way to do it without arbitrary trims private val PageNode.isNavigable: Boolean - get() = this !is RendererSpecificPage || strategy != RenderingStrategy.DoNothing
\ No newline at end of file + get() = this !is RendererSpecificPage || strategy != RenderingStrategy.DoNothing + +fun PropertyContainer<ContentNode>.extraHtmlAttributes() = allOfType<SimpleAttr>()
\ No newline at end of file diff --git a/plugins/base/src/main/kotlin/transformers/pages/sourcelinks/SourceLinksTransformer.kt b/plugins/base/src/main/kotlin/transformers/pages/sourcelinks/SourceLinksTransformer.kt index c0b8233c..e324c5bb 100644 --- a/plugins/base/src/main/kotlin/transformers/pages/sourcelinks/SourceLinksTransformer.kt +++ b/plugins/base/src/main/kotlin/transformers/pages/sourcelinks/SourceLinksTransformer.kt @@ -70,7 +70,8 @@ class SourceLinksTransformer(val context: DokkaContext, val builder: PageContent }, DCI(node.dri, ContentKind.Source), node.documentable!!.sourceSets.toSet(), - style = emptySet() + style = emptySet(), + extra = mainExtra + SimpleAttr.header("Sources") ) } @@ -91,9 +92,22 @@ class SourceLinksTransformer(val context: DokkaContext, val builder: PageContent private fun ContentNode.addTable(table: ContentGroup): ContentNode = when (this) { - is ContentGroup -> copy( - children = children + table - ) + is ContentGroup -> { + if(hasTabbedContent()){ + copy( + children = children.map { + if(it.hasStyle(ContentStyle.TabbedContent) && it is ContentGroup){ + it.copy(children = it.children + table) + } else { + it + } + } + ) + } else { + copy(children = children + table) + } + + } else -> ContentGroup( children = listOf(this, table), extra = this.extra, @@ -114,4 +128,6 @@ data class SourceLink(val path: String, val url: String, val lineSuffix: String? constructor(sourceLinkDefinition: DokkaConfiguration.SourceLinkDefinition, sourceSetData: SourceSetData) : this( sourceLinkDefinition.path, sourceLinkDefinition.url, sourceLinkDefinition.lineSuffix, sourceSetData ) -}
\ No newline at end of file +} + +fun ContentGroup.hasTabbedContent(): Boolean = children.any { it.hasStyle(ContentStyle.TabbedContent) }
\ No newline at end of file diff --git a/plugins/base/src/main/kotlin/translators/documentables/DefaultPageCreator.kt b/plugins/base/src/main/kotlin/translators/documentables/DefaultPageCreator.kt index d4ee88d8..409b0d6f 100644 --- a/plugins/base/src/main/kotlin/translators/documentables/DefaultPageCreator.kt +++ b/plugins/base/src/main/kotlin/translators/documentables/DefaultPageCreator.kt @@ -7,6 +7,7 @@ import org.jetbrains.dokka.base.translators.documentables.PageContentBuilder.Doc import org.jetbrains.dokka.links.DRI import org.jetbrains.dokka.model.* import org.jetbrains.dokka.model.doc.* +import org.jetbrains.dokka.model.properties.PropertyContainer import org.jetbrains.dokka.model.properties.WithExtraProperties import org.jetbrains.dokka.pages.* import org.jetbrains.dokka.utilities.DokkaLogger @@ -67,6 +68,7 @@ open class DefaultPageCreator( group(kind = ContentKind.Cover) { header(1, m.name) } + +contentForDescription(m) +contentForComments(m) block("Packages", 2, ContentKind.Packages, m.packages, m.sourceSets.toSet()) { link(it.name, it.dri) @@ -78,14 +80,17 @@ open class DefaultPageCreator( protected open fun contentForPackage(p: DPackage) = contentBuilder.contentFor(p) { group(kind = ContentKind.Cover) { header(1, "Package ${p.name}") + +contentForDescription(p) } - +contentForComments(p) - +contentForScope(p, p.dri, p.sourceSets) - block("Type aliases", 2, ContentKind.TypeAliases, p.typealiases, p.sourceSets.toSet()) { - link(it.name, it.dri, kind = ContentKind.Main) - sourceSetDependentHint(it.dri, it.sourceSets.toSet(), kind = ContentKind.SourceSetDependantHint) { - +buildSignature(it) - contentForBrief(it) + group(styles = setOf(ContentStyle.TabbedContent)){ + +contentForComments(p) + +contentForScope(p, p.dri, p.sourceSets) + block("Type aliases", 2, ContentKind.TypeAliases, p.typealiases, p.sourceSets.toSet(), extra = mainExtra + SimpleAttr.header("Type aliases")) { + link(it.name, it.dri, kind = ContentKind.Main) + sourceSetDependentHint(it.dri, it.sourceSets.toSet(), kind = ContentKind.SourceSetDependantHint, styles = emptySet()) { + +buildSignature(it) + contentForBrief(it) + } } } } @@ -95,9 +100,9 @@ open class DefaultPageCreator( dri: DRI, sourceSets: List<SourceSetData> ) = contentBuilder.contentFor(s as Documentable) { - divergentBlock("Types", s.classlikes, ContentKind.Classlikes) - divergentBlock("Functions", s.functions, ContentKind.Functions) - block("Properties", 2, ContentKind.Properties, s.properties, sourceSets.toSet()) { + divergentBlock("Types", s.classlikes, ContentKind.Classlikes, extra = mainExtra + SimpleAttr.header("Types")) + divergentBlock("Functions", s.functions, ContentKind.Functions, extra = mainExtra + SimpleAttr.header( "Functions")) + block("Properties", 2, ContentKind.Properties, s.properties, sourceSets.toSet(), extra = mainExtra + SimpleAttr.header( "Properties")) { link(it.name, it.dri, kind = ContentKind.Main) sourceSetDependentHint(it.dri, it.sourceSets.toSet(), kind = ContentKind.SourceSetDependantHint) { +buildSignature(it) @@ -122,7 +127,8 @@ open class DefaultPageCreator( }, DCI(setOf(dri), ContentKind.Inheritors), sourceSets.toSet(), - style = emptySet() + style = emptySet(), + extra = mainExtra + SimpleAttr.header( "Inheritors") ) } } @@ -132,9 +138,12 @@ open class DefaultPageCreator( group(kind = ContentKind.Cover) { header(1, e.name) +buildSignature(e) + +contentForDescription(e) + } + group(styles = setOf(ContentStyle.TabbedContent)){ + +contentForComments(e) + +contentForScope(e, e.dri, e.sourceSets) } - +contentForComments(e) - +contentForScope(e, e.dri, e.sourceSets) } protected open fun contentForClasslike(c: DClasslike) = contentBuilder.contentFor(c) { @@ -142,36 +151,39 @@ open class DefaultPageCreator( header(1, c.name.orEmpty()) sourceSetDependentHint(c.dri, c.sourceSets.toSet()) { +buildSignature(c) + +contentForDescription(c) } } - +contentForComments(c) - - if (c is WithConstructors) { - block( - "Constructors", - 2, - ContentKind.Constructors, - c.constructors.filter { it.extra[PrimaryConstructorExtra] == null }, - c.sourceSets.toSet() - ) { - link(it.name, it.dri, kind = ContentKind.Main) - sourceSetDependentHint(it.dri, it.sourceSets.toSet(), kind = ContentKind.SourceSetDependantHint) { - +buildSignature(it) - contentForBrief(it) + + group(styles = setOf(ContentStyle.TabbedContent)) { + +contentForComments(c) + if (c is WithConstructors) { + block( + "Constructors", + 2, + ContentKind.Constructors, + c.constructors.filter { it.extra[PrimaryConstructorExtra] == null }, + c.sourceSets.toSet(), + extra = PropertyContainer.empty<ContentNode>() + SimpleAttr.header("Constructors") + ) { + link(it.name, it.dri, kind = ContentKind.Main) + sourceSetDependentHint(it.dri, it.sourceSets.toSet(), kind = ContentKind.SourceSetDependantHint, styles = emptySet()) { + +buildSignature(it) + contentForBrief(it) + } } } - } - if (c is DEnum) { - block("Entries", 2, ContentKind.Classlikes, c.entries, c.sourceSets.toSet()) { - link(it.name, it.dri) - sourceSetDependentHint(it.dri, it.sourceSets.toSet(), kind = ContentKind.SourceSetDependantHint) { - +buildSignature(it) - contentForBrief(it) + if (c is DEnum) { + block("Entries", 2, ContentKind.Classlikes, c.entries, c.sourceSets.toSet(), extra = mainExtra + SimpleAttr.header("Entries"), styles = emptySet()) { + link(it.name, it.dri) + sourceSetDependentHint(it.dri, it.sourceSets.toSet(), kind = ContentKind.SourceSetDependantHint) { + +buildSignature(it) + contentForBrief(it) + } } } + +contentForScope(c, c.dri, c.sourceSets) } - - +contentForScope(c, c.dri, c.sourceSets) } @Suppress("UNCHECKED_CAST") @@ -188,16 +200,16 @@ open class DefaultPageCreator( private inline fun <reified T : TagWrapper> GroupedTags.isNotEmptyForTag(): Boolean = this[T::class]?.isNotEmpty() ?: false - protected open fun contentForComments( + protected open fun contentForDescription( d: Documentable - ): List<ContentNode> { + ): ContentNode { val tags: GroupedTags = d.documentation.flatMap { (pd, doc) -> doc.children.asSequence().map { pd to it }.toList() }.groupBy { it.second::class } val platforms = d.sourceSets - fun DocumentableContentBuilder.contentForDescription() { + return contentBuilder.contentFor(d) { val description = tags.withTypeUnnamed<Description>() if (description.any { it.value.root.children.isNotEmpty() }) { platforms.forEach { platform -> @@ -208,34 +220,60 @@ open class DefaultPageCreator( } } } + + val unnamedTags: List<SourceSetDependent<TagWrapper>> = + tags.filterNot { (k, _) -> k.isSubclassOf(NamedTagWrapper::class) || k in specialTags } + .map { (_, v) -> v.mapNotNull { (k,v) -> k?.let { it to v } }.toMap() } + platforms.forEach { platform -> + unnamedTags.forEach { pdTag -> + pdTag[platform]?.also { tag -> + group(sourceSets = setOf(platform)) { + header(4, tag.toHeaderString()) + comment(tag.root) + } + } + } + } } + } + + protected open fun contentForComments( + d: Documentable + ): List<ContentNode> { + val tags: GroupedTags = d.documentation.flatMap { (pd, doc) -> + doc.children.asSequence().map { pd to it }.toList() + }.groupBy { it.second::class } + + val platforms = d.sourceSets fun DocumentableContentBuilder.contentForParams() { if (tags.isNotEmptyForTag<Param>()) { - val receiver = tags.withTypeUnnamed<Receiver>() - val params = tags.withTypeNamed<Param>() - platforms.forEach { - header(4, "Parameters", kind = ContentKind.Parameters, platformData = setOf(it)) - } - table(kind = ContentKind.Parameters) { - platforms.flatMap { platform -> - val receiverRow = receiver[platform]?.let { - buildGroup(sourceSets = setOf(platform), kind = ContentKind.Parameters) { - text("<receiver>", styles = mainStyles + ContentStyle.RowTitle) - comment(it.root) - } - } + header(2, "Parameters") + group(extra = mainExtra + SimpleAttr.header("Parameters"), styles = setOf(ContentStyle.WithExtraAttributes)){ + sourceSetDependentHint(sourceSets = platforms.toSet(), kind = ContentKind.SourceSetDependantHint) { + val receiver = tags.withTypeUnnamed<Receiver>() + val params = tags.withTypeNamed<Param>() + table(kind = ContentKind.Parameters) { + platforms.flatMap { platform -> + val receiverRow = receiver[platform]?.let { + buildGroup(sourceSets = setOf(platform), kind = ContentKind.Parameters) { + text("<receiver>", styles = mainStyles + ContentStyle.RowTitle) + comment(it.root) + } + } - val paramRows = params.mapNotNull { (_, param) -> - param[platform]?.let { - buildGroup(sourceSets = setOf(platform), kind = ContentKind.Parameters) { - text(it.name, kind = ContentKind.Parameters, styles = mainStyles + ContentStyle.RowTitle) - comment(it.root) + val paramRows = params.mapNotNull { (_, param) -> + param[platform]?.let { + buildGroup(sourceSets = setOf(platform), kind = ContentKind.Parameters) { + text(it.name, kind = ContentKind.Parameters, styles = mainStyles + ContentStyle.RowTitle) + comment(it.root) + } + } } + + listOfNotNull(receiverRow) + paramRows } } - - listOfNotNull(receiverRow) + paramRows } } } @@ -243,18 +281,20 @@ open class DefaultPageCreator( fun DocumentableContentBuilder.contentForSeeAlso() { if (tags.isNotEmptyForTag<See>()) { - val seeAlsoTags = tags.withTypeNamed<See>() - platforms.forEach { - header(4, "See also", kind = ContentKind.Comment, platformData = setOf(it)) - } - table(kind = ContentKind.Sample) { - platforms.flatMap { platform -> - seeAlsoTags.mapNotNull { (_, see) -> - see[platform]?.let { - buildGroup(sourceSets = setOf(platform), kind = ContentKind.Comment, styles = mainStyles + ContentStyle.RowTitle) { - if (it.address != null) link(it.name, it.address!!, kind = ContentKind.Comment) - else text(it.name, kind = ContentKind.Comment) - comment(it.root) + header(2, "See also") + group(extra = mainExtra + SimpleAttr.header("See also"), styles = setOf(ContentStyle.WithExtraAttributes)){ + sourceSetDependentHint(sourceSets = platforms.toSet(), kind = ContentKind.SourceSetDependantHint) { + val seeAlsoTags = tags.withTypeNamed<See>() + table(kind = ContentKind.Sample) { + platforms.flatMap { platform -> + seeAlsoTags.mapNotNull { (_, see) -> + see[platform]?.let { + buildGroup(sourceSets = setOf(platform), kind = ContentKind.Comment, styles = mainStyles + ContentStyle.RowTitle) { + if (it.address != null) link(it.name, it.address!!, kind = ContentKind.Comment) + else text(it.name, kind = ContentKind.Comment) + comment(it.root) + } + } } } } @@ -266,13 +306,17 @@ open class DefaultPageCreator( fun DocumentableContentBuilder.contentForSamples() { val samples = tags.withTypeNamed<Sample>() if (samples.isNotEmpty()) { - platforms.forEach { platformData -> - val content = samples.filter { it.value.isEmpty() || platformData in it.value } - if (content.isNotEmpty()) { - group(sourceSets = setOf(platformData)) { - header(4, "Samples", kind = ContentKind.Comment) - content.forEach { - comment(Text(it.key)) + header(2, "Samples") + group(extra = mainExtra + SimpleAttr.header("Samples"), styles = setOf(ContentStyle.WithExtraAttributes)){ + sourceSetDependentHint(sourceSets = platforms.toSet(), kind = ContentKind.SourceSetDependantHint) { + table(kind = ContentKind.Sample) { + platforms.map { platformData -> + val content = samples.filter { it.value.isEmpty() || platformData in it.value } + buildGroup(sourceSets = setOf(platformData), styles = setOf(ContentStyle.RowTitle)) { + content.forEach { + comment(Text(it.key)) + } + } } } } @@ -280,32 +324,11 @@ open class DefaultPageCreator( } } - fun DocumentableContentBuilder.contentForUnnamedTags() { - val unnamedTags: List<SourceSetDependent<TagWrapper>> = - tags.filterNot { (k, _) -> k.isSubclassOf(NamedTagWrapper::class) || k in specialTags } - .map { (_, v) -> v.mapNotNull { (k,v) -> k?.let { it to v } }.toMap() } - platforms.forEach { platform -> - unnamedTags.forEach { pdTag -> - pdTag[platform]?.also { tag -> - group(sourceSets = setOf(platform)) { - header(4, tag.toHeaderString()) - comment(tag.root) - } - } - } - } - } - return contentBuilder.contentFor(d) { if (tags.isNotEmpty()) { - header(3, "Description") - sourceSetDependentHint(sourceSets = platforms.toSet()) { - contentForDescription() - contentForSamples() - contentForParams() - contentForUnnamedTags() - contentForSeeAlso() - } + contentForSamples() + contentForSeeAlso() + contentForParams() } }.children } @@ -323,13 +346,16 @@ open class DefaultPageCreator( protected open fun contentForFunction(f: DFunction) = contentForMember(f) protected open fun contentForTypeAlias(t: DTypeAlias) = contentForMember(t) protected open fun contentForMember(d: Documentable) = contentBuilder.contentFor(d) { - header(1, d.name.orEmpty()) + group(kind = ContentKind.Cover) { + header(1, d.name.orEmpty()) + } divergentGroup(ContentDivergentGroup.GroupID("member")) { instance(setOf(d.dri), d.sourceSets.toSet()) { divergent(kind = ContentKind.Symbol) { +buildSignature(d) } after { + +contentForDescription(d) +contentForComments(d) } } @@ -339,11 +365,12 @@ open class DefaultPageCreator( protected open fun DocumentableContentBuilder.divergentBlock( name: String, collection: Collection<Documentable>, - kind: ContentKind + kind: ContentKind, + extra: PropertyContainer<ContentNode> = mainExtra, ) { if (collection.any()) { header(2, name) - table(kind) { + table(kind, extra = extra) { collection.groupBy { it.name }.map { (elementName, elements) -> // This groupBy should probably use LocationProvider buildGroup(elements.map { it.dri }.toSet(), elements.flatMap { it.sourceSets }.toSet(), kind = kind) { link(elementName.orEmpty(), elements.first().dri, kind = kind) |