Refactor PageBuilder and PageContentBuilder

Also PageBuilder has been renamed to DefaultPageCreator

1 files changed, 222 insertions, 186 deletions

diff --git a/plugins/base/src/main/kotlin/translators/documentables/PageContentBuilder.kt b/plugins/base/src/main/kotlin/translators/documentables/PageContentBuilder.kt
index 48456910..588d9cb8 100644
--- a/plugins/base/src/main/kotlin/translators/documentables/PageContentBuilder.kt
+++ b/plugins/base/src/main/kotlin/translators/documentables/PageContentBuilder.kt
@@ -9,210 +9,246 @@ import org.jetbrains.dokka.model.doc.DocTag
 import org.jetbrains.dokka.pages.*
 import org.jetbrains.dokka.utilities.DokkaLogger
 
-open class DefaultPageContentBuilder(
-    protected val dri: Set<DRI>,
-    protected val platformData: Set<PlatformData>,
-    protected val kind: Kind,
-    protected val commentsConverter: CommentsToContentConverter,
-    val logger: DokkaLogger,
-    protected val styles: Set<Style> = emptySet(),
-    protected val extras: Set<Extra> = emptySet()
-) : PageContentBuilder {
-    protected val contents = mutableListOf<ContentNode>()
-
-    protected fun createText(text: String, kind: Kind = ContentKind.Symbol) =
-        ContentText(text, DCI(dri, kind), platformData, styles, extras)
-
-    protected fun build() = ContentGroup(
-        contents.toList(),
-        DCI(dri, kind),
-        platformData,
-        styles,
-        extras
-    )
-
-    override fun header(level: Int, block: PageContentBuilderFunction) {
-        contents += ContentHeader(level, group(ContentKind.Symbol, block))
-    }
-
-    override fun text(text: String, kind: Kind) {
-        contents += createText(text, kind)
-    }
+@DslMarker
+annotation class ContentBuilderMarker
+
+@ContentBuilderMarker
+open class PageContentBuilder(
+    val commentsConverter: CommentsToContentConverter,
+    val logger: DokkaLogger
+) {
+    fun contentFor(
+        dri: DRI,
+        platformData: Set<PlatformData>,
+        kind: Kind = ContentKind.Main,
+        styles: Set<Style> = emptySet(),
+        extras: Set<Extra> = emptySet(),
+        block: DocumentableContentBuilder.() -> Unit
+    ): ContentGroup =
+        DocumentableContentBuilder(dri, platformData, styles, extras)
+            .apply(block)
+            .build(platformData, kind, styles, extras)
+
+    fun contentFor(
+        d: Documentable,
+        kind: Kind = ContentKind.Main,
+        styles: Set<Style> = emptySet(),
+        extras: Set<Extra> = emptySet(),
+        block: DocumentableContentBuilder.() -> Unit
+    ): ContentGroup =
+        DocumentableContentBuilder(d.dri, d.platformData.toSet(), styles, extras)
+            .apply(block)
+            .build(d.platformData.toSet(), kind, styles, extras)
+
+    @ContentBuilderMarker
+    open inner class DocumentableContentBuilder(
+        val mainDRI: DRI,
+        val mainPlatformData: Set<PlatformData>,
+        val mainStyles: Set<Style>,
+        val mainExtras: Set<Extra>
+    ) {
+        protected val contents = mutableListOf<ContentNode>()
 
-    protected fun signature(f: Function, block: PageContentBuilderFunction) {
-        contents += group(setOf(f.dri), f.platformData, ContentKind.Symbol, block)
-    }
+        fun build(
+            platformData: Set<PlatformData>,
+            kind: Kind,
+            styles: Set<Style>,
+            extras: Set<Extra>
+        ) = ContentGroup(
+            contents.toList(),
+            DCI(setOf(mainDRI), kind),
+            platformData,
+            styles,
+            extras
+        )
 
-    override fun signature(f: Function) = signature(f) {
-        text("fun ")
-        f.receiver?.also {
-            type(it.type)
-            text(".")
-        }
-        link(f.name, f.dri)
-        text("(")
-        list(f.parameters) {
-            link(it.name!!, it.dri)
-            text(": ")
-            type(it.type)
-        }
-        text(")")
-        val returnType = f.returnType
-        if (!f.isConstructor && returnType != null &&
-            returnType.constructorFqName != Unit::class.qualifiedName
+        fun header(
+            level: Int,
+            kind: Kind = ContentKind.Main,
+            styles: Set<Style> = mainStyles,
+            extras: Set<Extra> = mainExtras,
+            block: DocumentableContentBuilder.() -> Unit
         ) {
-            text(": ")
-            type(returnType)
+            contents += ContentHeader(
+                level,
+                this@PageContentBuilder.contentFor(mainDRI, mainPlatformData, kind, styles, extras, block)
+            )
         }
-    }
-
-    override fun linkTable(elements: List<DRI>) {
-        contents += ContentTable(
-            emptyList(),
-            elements.map { group(dri, platformData, ContentKind.Classes) { link(it.classNames ?: "", it) } },
-            DCI(dri, kind),
-            platformData, styles, extras
-        )
-    }
 
-    override fun <T : Documentable> block(
-        name: String,
-        level: Int,
-        kind: Kind,
-        elements: Iterable<T>,
-        platformData: Set<PlatformData>,
-        operation: PageContentBuilder.(T) -> Unit
-    ) {
-        header(level) { text(name) }
+        fun text(
+            text: String,
+            kind: Kind = ContentKind.Main,
+            platformData: Set<PlatformData> = mainPlatformData,
+            styles: Set<Style> = mainStyles,
+            extras: Set<Extra> = mainExtras
+        ) {
+            contents += createText(text, kind, platformData, styles, extras)
+        }
 
-        contents += ContentTable(
-            emptyList(),
-            elements.map { group(setOf(it.dri), it.platformData, kind) { operation(it) } },
-            DCI(dri, kind),
-            platformData, styles, extras
-        )
-    }
+        fun signature(f: Function, block: DocumentableContentBuilder.() -> Unit) {
+            contents += group(f.dri, f.platformData.toSet(), ContentKind.Symbol, mainStyles, mainExtras, block)
+        }
 
-    override fun <T> list(
-        elements: List<T>,
-        prefix: String,
-        suffix: String,
-        separator: String,
-        operation: PageContentBuilder.(T) -> Unit
-    ) {
-        if (elements.isNotEmpty()) {
-            if (prefix.isNotEmpty()) text(prefix)
-            elements.dropLast(1).forEach {
-                operation(it)
-                text(separator)
+        fun signature(f: Function) = signature(f) {
+            text("fun ")
+            f.receiver?.also {
+                // TODO signature should be rewritten
+                type(it.type)
+                text(".")
+            }
+            link(f.name, f.dri)
+            text("(")
+            list(f.parameters) {
+                link(it.name!!, it.dri)
+                text(": ")
+                type(it.type)
+            }
+            text(")")
+            val returnType = f.type
+            if (!f.isConstructor && returnType.constructorFqName != Unit::class.qualifiedName) {
+                text(": ")
+                type(returnType)
             }
-            operation(elements.last())
-            if (suffix.isNotEmpty()) text(suffix)
         }
-    }
 
-    override fun link(text: String, address: DRI, kind: Kind) {
-        contents += ContentDRILink(
-            listOf(createText(text)),
-            address,
-            DCI(dri, kind),
-            platformData
-        )
-    }
+        fun linkTable(
+            elements: List<DRI>,
+            kind: Kind = ContentKind.Main,
+            platformData: Set<PlatformData> = mainPlatformData,
+            styles: Set<Style> = mainStyles,
+            extras: Set<Extra> = mainExtras
+        ) {
+            contents += ContentTable(
+                emptyList(),
+                elements.map {
+                    this@PageContentBuilder.contentFor(it, platformData, kind, styles, extras) {
+                        link(it.classNames ?: "", it)
+                    }
+                },
+                DCI(setOf(mainDRI), kind),
+                platformData, styles, extras
+            )
+        }
 
-    override fun link(address: DRI, kind: Kind, block: PageContentBuilderFunction) {
-        contents += ContentDRILink(
-            group(ContentKind.Main, block).children,
-            address,
-            DCI(dri, kind),
-            platformData
-        )
-    }
+        fun <T : Documentable> block(
+            name: String,
+            level: Int,
+            kind: Kind = ContentKind.Main,
+            elements: Iterable<T>,
+            platformData: Set<PlatformData> = mainPlatformData,
+            styles: Set<Style> = mainStyles,
+            extras: Set<Extra> = mainExtras,
+            operation: DocumentableContentBuilder.(T) -> Unit
+        ) {
+            header(level) { text(name) }
+            contents += ContentTable(
+                emptyList(),
+                elements.map {
+                    group(it.dri, it.platformData.toSet(), kind, styles, extras) {
+                        // TODO this will fail
+                        operation(it)
+                    }
+                },
+                DCI(setOf(mainDRI), kind),
+                platformData, styles, extras
+            )
+        }
 
-    override fun comment(docTag: DocTag) {
-        contents += group(ContentKind.Comment) {
-            with(this as DefaultPageContentBuilder) {
-                contents += commentsConverter.buildContent(
-                    docTag,
-                    DCI(dri, ContentKind.Comment),
-                    platformData
-                )
+        fun <T> list(
+            elements: List<T>,
+            prefix: String = "",
+            suffix: String = "",
+            separator: String = ",",
+            operation: DocumentableContentBuilder.(T) -> Unit
+        ) {
+            if (elements.isNotEmpty()) {
+                if (prefix.isNotEmpty()) text(prefix)
+                elements.dropLast(1).forEach {
+                    operation(it)
+                    text(separator)
+                }
+                operation(elements.last())
+                if (suffix.isNotEmpty()) text(suffix)
             }
         }
-    }
 
-    fun group(kind: Kind, block: PageContentBuilderFunction): ContentGroup =
-        group(dri, platformData, kind, block)
+        fun link(
+            text: String,
+            address: DRI,
+            kind: Kind = ContentKind.Main,
+            platformData: Set<PlatformData> = mainPlatformData,
+            styles: Set<Style> = mainStyles,
+            extras: Set<Extra> = mainExtras
+        ) {
+            contents += ContentDRILink(
+                listOf(createText(text, kind, platformData, styles, extras)),
+                address,
+                DCI(setOf(mainDRI), kind),
+                platformData
+            )
+        }
 
-    override fun group(
-        dri: Set<DRI>,
-        platformData: Set<PlatformData>,
-        kind: Kind,
-        block: PageContentBuilderFunction
-    ): ContentGroup = group(dri, platformData, kind, commentsConverter, logger, block)
+        fun link(
+            address: DRI,
+            kind: Kind = ContentKind.Main,
+            platformData: Set<PlatformData> = mainPlatformData,
+            styles: Set<Style> = mainStyles,
+            extras: Set<Extra> = mainExtras,
+            block: DocumentableContentBuilder.() -> Unit
+        ) {
+            contents += ContentDRILink(
+                this@PageContentBuilder.contentFor(mainDRI, platformData, kind, styles, extras, block).children,
+                address,
+                DCI(setOf(mainDRI), kind),
+                platformData
+            )
+        }
+
+        fun comment(
+            docTag: DocTag,
+            kind: Kind = ContentKind.Comment,
+            platformData: Set<PlatformData> = mainPlatformData,
+            styles: Set<Style> = mainStyles,
+            extras: Set<Extra> = mainExtras
+        ) {
+            val content = this@PageContentBuilder.commentsConverter.buildContent(
+                docTag,
+                DCI(setOf(mainDRI), kind),
+                platformData
+            )
+            contents += ContentGroup(content, DCI(setOf(mainDRI), kind), platformData, styles, extras)
+        }
 
-    companion object {
         fun group(
-            dri: Set<DRI>,
-            platformData: Set<PlatformData>,
+            dri: DRI = mainDRI,
+            platformData: Set<PlatformData> = mainPlatformData,
+            kind: Kind = ContentKind.Main,
+            styles: Set<Style> = mainStyles,
+            extras: Set<Extra> = mainExtras,
+            block: DocumentableContentBuilder.() -> Unit
+        ): ContentGroup = this@PageContentBuilder.contentFor(dri, platformData, kind, styles, extras, block)
+
+        protected fun createText(
+            text: String,
             kind: Kind,
-            commentsConverter: CommentsToContentConverter,
-            logger: DokkaLogger,
-            block: PageContentBuilderFunction
-        ): ContentGroup =
-            DefaultPageContentBuilder(dri, platformData, kind, commentsConverter, logger).apply(block).build()
-    }
-}
-
-
-fun PageContentBuilder.type(t: TypeWrapper) {
-    if (t.constructorNamePathSegments.isNotEmpty() && t.dri != null)
-        link(t.constructorNamePathSegments.last(), t.dri!!)
-    else if (t.constructorNamePathSegments.isNotEmpty() && t.dri == null)
-        text(t.toString())
-    else (this as? DefaultPageContentBuilder)?.let {
-        logger.error("type $t cannot be resolved")
-        text("???")
-    }
-    list(t.arguments, prefix = "<", suffix = ">") {
-        type(it)
+            platformData: Set<PlatformData>,
+            styles: Set<Style>,
+            extras: Set<Extra>
+        ) =
+            ContentText(text, DCI(setOf(mainDRI), kind), platformData, styles, extras)
+
+        fun type(t: TypeWrapper) {
+            if (t.constructorNamePathSegments.isNotEmpty() && t.dri != null)
+                link(t.constructorNamePathSegments.last(), t.dri!!)
+            else if (t.constructorNamePathSegments.isNotEmpty() && t.dri == null)
+                text(t.toString())
+            else {
+                this@PageContentBuilder.logger.error("type $t cannot be resolved")
+                text("???")
+            }
+            list(t.arguments, prefix = "<", suffix = ">") {
+                type(it)
+            }
+        }
     }
-}
-
-typealias PageContentBuilderFunction = PageContentBuilder.() -> Unit
-
-@DslMarker
-annotation class ContentMarker
-
-@ContentMarker
-interface PageContentBuilder {
-    fun group(
-        dri: Set<DRI>,
-        platformData: Set<PlatformData>,
-        kind: Kind, block: PageContentBuilderFunction
-    ): ContentGroup
-
-    fun text(text: String, kind: Kind = ContentKind.Symbol)
-    fun signature(f: Function)
-    fun link(text: String, address: DRI, kind: Kind = ContentKind.Symbol)
-    fun link(address: DRI, kind: Kind = ContentKind.Symbol, block: PageContentBuilderFunction)
-    fun linkTable(elements: List<DRI>)
-    fun comment(docTag: DocTag)
-    fun header(level: Int, block: PageContentBuilderFunction)
-    fun <T> list(
-        elements: List<T>,
-        prefix: String = "",
-        suffix: String = "",
-        separator: String = ",",
-        operation: PageContentBuilder.(T) -> Unit
-    )
-
-    fun <T : Documentable> block(
-        name: String,
-        level: Int,
-        kind: Kind,
-        elements: Iterable<T>,
-        platformData: Set<PlatformData>,
-        operation: PageContentBuilder.(T) -> Unit
-    )
 }
\ No newline at end of file