Some parsing for markdown links

6 files changed, 189 insertions, 99 deletions

diff --git a/core/src/main/kotlin/DokkaGenerator.kt b/core/src/main/kotlin/DokkaGenerator.kt
index 5dd56624..2ac95812 100644
--- a/core/src/main/kotlin/DokkaGenerator.kt
+++ b/core/src/main/kotlin/DokkaGenerator.kt
@@ -3,6 +3,8 @@ package org.jetbrains.dokka
 import org.jetbrains.dokka.Model.Module
 import org.jetbrains.dokka.Utilities.pretty
 import org.jetbrains.dokka.links.DRI
+import org.jetbrains.dokka.pages.MarkdownToContentConverter
+import org.jetbrains.dokka.pages.PageNode
 import org.jetbrains.dokka.renderers.FileWriter
 import org.jetbrains.dokka.renderers.HtmlRenderer
 import org.jetbrains.dokka.resolvers.DefaultLocationProvider
@@ -35,24 +37,32 @@ class DokkaGenerator(
                 val environment = createCoreEnvironment()
                 val (facade, _) = createResolutionFacade(environment)
 
-                environment.getSourceFiles().asSequence()
+                val markdownConverter = MarkdownToContentConverter(facade, logger)
+
+                val module = environment.getSourceFiles().asSequence()
                     .map { it.packageFqName }
                     .distinct()
                     .mapNotNull { facade.resolveSession.getPackageFragment(it) }
                     .map { DokkaDescriptorVisitor.visitPackageFragmentDescriptor(it, DRI.topLevel) }
                     .toList()
-                    .let { Pair(pass, Module(it)) }
-            }.also { println("${pass.analysisPlatform}:\n${it.second.pretty()}\n\n") }
-        }.let {
-            DefaultDocumentationToPageTransformer().transform(it)
-        }.also {
-            HtmlRenderer(
-                FileWriter(configuration.outputDir, ""),
-                DefaultLocationProvider(it, configuration, ".${configuration.format}")
-            ).render(it)
+                    .let { Module(it) }
+                    .also { println("${pass.analysisPlatform}:\n${it.pretty()}\n\n") }
+
+                DefaultDocumentationToPageTransformer(markdownConverter).transform(pass, module)
+            }
         }
+            .merge()
+            .also {
+                HtmlRenderer(
+                    FileWriter(configuration.outputDir, ""),
+                    DefaultLocationProvider(it, configuration, ".${configuration.format}")
+                ).render(it)
+            }
     }
 }
+
+private fun Iterable<PageNode>.merge(): PageNode = first() // TODO: implement
+
 private class DokkaMessageCollector(private val logger: DokkaLogger) : MessageCollector {
     override fun clear() {
         seenErrors = false
diff --git a/core/src/main/kotlin/links/DRI.kt b/core/src/main/kotlin/links/DRI.kt
index 7ab25444..fced7dde 100644
--- a/core/src/main/kotlin/links/DRI.kt
+++ b/core/src/main/kotlin/links/DRI.kt
@@ -1,7 +1,9 @@
 package org.jetbrains.dokka.links
 
-import org.jetbrains.kotlin.descriptors.CallableDescriptor
+import org.jetbrains.kotlin.descriptors.*
+import org.jetbrains.kotlin.resolve.descriptorUtil.parentsWithSelf
 import org.jetbrains.kotlin.types.KotlinType
+import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull
 import java.text.ParseException
 
 /**
@@ -48,6 +50,19 @@ data class DRI(
             throw ParseException(s, 0)
         }
 
+        fun from(descriptor: DeclarationDescriptor) = descriptor.parentsWithSelf.run {
+            val callable = firstIsInstanceOrNull<CallableDescriptor>()
+            val params = callable?.let { listOfNotNull(it.extensionReceiverParameter) + it.valueParameters }.orEmpty()
+            DRI(
+                firstIsInstanceOrNull<PackageFragmentDescriptor>()?.fqName?.asString(),
+                filterIsInstance<ClassDescriptor>().toList().takeIf { it.isNotEmpty() }?.asReversed()
+                    ?.joinToString(separator = ".") { it.name.asString() },
+                callable?.let { Callable.from(it) },
+                firstIsInstanceOrNull<ParameterDescriptor>()?.let { params.indexOf(it) },
+                null
+            )
+        }
+
         val topLevel = DRI()
     }
 }
diff --git a/core/src/main/kotlin/pages/MarkdownToContentConverter.kt b/core/src/main/kotlin/pages/MarkdownToContentConverter.kt
index d541dc91..14b56226 100644
--- a/core/src/main/kotlin/pages/MarkdownToContentConverter.kt
+++ b/core/src/main/kotlin/pages/MarkdownToContentConverter.kt
@@ -2,13 +2,28 @@ package org.jetbrains.dokka.pages
 
 import org.intellij.markdown.MarkdownElementTypes
 import org.intellij.markdown.MarkdownTokenTypes
+import org.jetbrains.dokka.DokkaLogger
+import org.jetbrains.dokka.DokkaResolutionFacade
 import org.jetbrains.dokka.MarkdownNode
-
-class MarkdownToContentConverter {
-    fun buildContent(node: MarkdownNode, platforms: List<PlatformData>): List<ContentNode> {
+import org.jetbrains.dokka.Model.DocumentationNode
+import org.jetbrains.dokka.links.DRI
+import org.jetbrains.dokka.visit
+import org.jetbrains.kotlin.idea.kdoc.resolveKDocLink
+
+class MarkdownToContentConverter(
+    private val resolutionFacade: DokkaResolutionFacade,
+    private val logger: DokkaLogger
+) {
+    fun buildContent(
+        node: MarkdownNode,
+        platforms: List<PlatformData>,
+        documentationNode: DocumentationNode<*>
+    ): List<ContentNode> {
 //    println(tree.toTestString())
 
-        fun buildChildren(node: MarkdownNode) = node.children.flatMap { buildContent(it, platforms) }.coalesceText()
+        fun buildChildren(node: MarkdownNode) = node.children.flatMap {
+            buildContent(it, platforms, documentationNode)
+        }.coalesceText()
 
         return when (node.type) {
             MarkdownElementTypes.ATX_1 -> listOf(ContentHeader(buildChildren(node), 1, platforms))
@@ -47,7 +62,13 @@ class MarkdownToContentConverter {
                 val language = node.child(MarkdownTokenTypes.FENCE_LANG)?.text?.trim() ?: ""
                 listOf(ContentCode(buildChildren(node).toString(), language, platforms)) // TODO
             }
-            MarkdownElementTypes.PARAGRAPH -> listOf(ContentStyle(buildChildren(node), Style.Paragraph, platforms)) // TODO
+            MarkdownElementTypes.PARAGRAPH -> listOf(
+                ContentStyle(
+                    buildChildren(node),
+                    Style.Paragraph,
+                    platforms
+                )
+            ) // TODO
 
             MarkdownElementTypes.INLINE_LINK -> {
 //            val linkTextNode = node.child(MarkdownElementTypes.LINK_TEXT)
@@ -69,23 +90,27 @@ class MarkdownToContentConverter {
             }
             MarkdownElementTypes.SHORT_REFERENCE_LINK,
             MarkdownElementTypes.FULL_REFERENCE_LINK -> {
-//            val labelElement = node.child(MarkdownElementTypes.LINK_LABEL)
-//            if (labelElement != null) {
-//                val linkInfo = linkResolver.getLinkInfo(labelElement.text)
-//                val labelText = labelElement.getLabelText()
-//                val link =
-//                    linkInfo?.let { linkResolver.resolve(it.destination.toString()) } ?: linkResolver.resolve(
-//                        labelText
-//                    )
-//                val linkText = node.child(MarkdownElementTypes.LINK_TEXT)
-//                if (linkText != null) {
-//                    renderLinkTextTo(linkText, link, linkResolver)
-//                } else {
-//                    link.append(ContentText(labelText))
-//                }
-//                parent.append(link)
-//            }
-                TODO()
+                val descriptor = documentationNode.descriptor
+                if (descriptor != null) {
+                    val destinationNode = node.children.find { it.type == MarkdownElementTypes.LINK_DESTINATION }
+                            ?: node.children.first { it.type == MarkdownElementTypes.LINK_LABEL }
+                    val destination = destinationNode.children.find { it.type == MarkdownTokenTypes.TEXT }?.text
+                            ?:destinationNode.text
+
+                    resolveKDocLink(
+                        resolutionFacade.resolveSession.bindingContext,
+                        resolutionFacade,
+                        descriptor,
+                        null,
+                        destination.split('.')
+                    )
+                        .firstOrNull()
+                        ?.let { ContentLink(destination, DRI.from(it), platforms) }
+                        .let(::listOfNotNull)
+                } else {
+                    logger.error("Apparently descriptor for $documentationNode was needed in model")
+                    emptyList()
+                }
             }
             MarkdownTokenTypes.WHITE_SPACE -> {
                 // Don't append first space if start of header (it is added during formatting later)
@@ -169,23 +194,28 @@ class MarkdownToContentConverter {
             .sliceWhen { prev, next -> prev::class != next::class }
             .flatMap { nodes ->
                 when (nodes.first()) {
-                    is ContentText -> listOf(ContentText(nodes.joinToString("") { (it as ContentText).text }, nodes.first().platforms))
+                    is ContentText -> listOf(
+                        ContentText(
+                            nodes.joinToString("") { (it as ContentText).text },
+                            nodes.first().platforms
+                        )
+                    )
                     else -> nodes
                 }
             }
 }
 
-fun <T> Collection<T>.sliceWhen(predicate: (before: T, after: T)->Boolean): Collection<Collection<T>> {
+fun <T> Collection<T>.sliceWhen(predicate: (before: T, after: T) -> Boolean): Collection<Collection<T>> {
     val newCollection = mutableListOf<Collection<T>>()
     var currentSlice = mutableListOf<T>()
     for ((prev, next) in this.windowed(2, 1, false)) {
         currentSlice.add(prev)
-        if(predicate(prev, next)) {
+        if (predicate(prev, next)) {
             newCollection.add(currentSlice)
             currentSlice = mutableListOf<T>()
         }
     }
-    if(this.isNotEmpty()) {
+    if (this.isNotEmpty()) {
         currentSlice.add(this.last())
         newCollection.add(currentSlice)
     }
diff --git a/core/src/main/kotlin/renderers/DefaultRenderer.kt b/core/src/main/kotlin/renderers/DefaultRenderer.kt
index 5c6b3751..a2ca4131 100644
--- a/core/src/main/kotlin/renderers/DefaultRenderer.kt
+++ b/core/src/main/kotlin/renderers/DefaultRenderer.kt
@@ -19,7 +19,7 @@ abstract class DefaultRenderer(val fileWriter: FileWriter, val locationProvider:
 
     protected open fun ContentNode.build(pageContext: PageNode): String = buildContentNode(this, pageContext)
 
-    protected open fun buildContentNode(node: ContentNode, pageContext: PageNode) =
+    protected open fun buildContentNode(node: ContentNode, pageContext: PageNode): String =
         when(node) {
             is ContentText -> buildText(node.text)
             is ContentComment -> buildComment(node.parts, pageContext)
@@ -29,6 +29,7 @@ abstract class DefaultRenderer(val fileWriter: FileWriter, val locationProvider:
             is ContentLink -> buildLink(node.text, locationProvider.resolve(node.address, node.platforms, pageContext))
             is ContentGroup -> buildGroup(node.children, pageContext)
             is ContentHeader -> buildHeader(node.level, node.items, pageContext)
+            is ContentStyle -> node.items.joinToString(separator = "\n") { buildContentNode(it, pageContext) }
             else -> ""
         }
 
diff --git a/core/src/main/kotlin/transformers/DefaultDocumentationToPageTransformer.kt b/core/src/main/kotlin/transformers/DefaultDocumentationToPageTransformer.kt
index ce4691b6..54fd9a27 100644
--- a/core/src/main/kotlin/transformers/DefaultDocumentationToPageTransformer.kt
+++ b/core/src/main/kotlin/transformers/DefaultDocumentationToPageTransformer.kt
@@ -4,18 +4,22 @@ import org.jetbrains.dokka.DokkaConfiguration
 import org.jetbrains.dokka.Model.*
 import org.jetbrains.dokka.Model.Function
 import org.jetbrains.dokka.links.Callable
+import org.jetbrains.dokka.links.DRI
 import org.jetbrains.dokka.pages.*
+import org.jetbrains.dokka.parseMarkdown
+import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe
 
 
-class DefaultDocumentationToPageTransformer: DocumentationToPageTransformer {
-    override fun transform(modules: Collection<Pair<DokkaConfiguration.PassConfiguration, Module>>): PageNode {
-        val module = modules.first().second // TODO only one module for starters
-        val platformData = modules.first().first.targets.map { PlatformData(it, modules.first().first.analysisPlatform) }
+class DefaultDocumentationToPageTransformer(
+    private val markdownConverter: MarkdownToContentConverter
+) : DocumentationToPageTransformer {
+    override fun transform(passConfiguration: DokkaConfiguration.PassConfiguration, module: Module): PageNode {
+        val platformData = passConfiguration.targets.map { PlatformData(it, passConfiguration.analysisPlatform) }
         return PageBuilder(platformData).pageForModule(module)
     }
 
-    class PageBuilder(private val platformData: List<PlatformData>) {
+    private inner class PageBuilder(private val platformData: List<PlatformData>) {
         fun pageForModule(m: Module) =
             ModulePageNode("root", contentForModule(m), documentationNode = m).apply {
                 // TODO change name
@@ -44,62 +48,92 @@ class DefaultDocumentationToPageTransformer: DocumentationToPageTransformer {
                 else -> throw IllegalStateException("$m should not be present here")
             }
 
-        private fun contentForModule(m: Module) = listOf(
-            ContentHeader(listOf(ContentText("root", platformData)), 1, platformData),
-            ContentBlock("Packages", m.packages.map { ContentLink(it.name, it.dri, platformData) }, platformData),
-            ContentText("Index", platformData),
-            ContentText("Link to allpage here", platformData)
-        )
-
-        private fun contentForPackage(p: Package) = listOf(
-            ContentHeader(listOf(ContentText("Package ${p.name}", platformData)), 1, platformData),
-            ContentBlock("Types", p.classes.map { ContentGroup(
-                listOf(
-                    ContentLink(it.name, it.dri, platformData),
-                    ContentText(it.briefDocstring, platformData),
-                ContentText("signature for class", platformData)
-                ), platformData)
-            }, platformData),
-            ContentBlock("Functions", p.functions.map { ContentGroup(
-                listOf(
-                    ContentLink(it.name, it.dri, platformData),
-                    ContentText(it.briefDocstring, platformData),
-                    ContentText("signature for function", platformData)
-                ), platformData)
-            }, platformData)
-        )
-
-        private fun contentForClass(c: Class) = listOf(
-            ContentHeader(listOf(ContentText(c.name, platformData)), 1, platformData),
-            ContentText(c.rawDocstring, platformData),
-            ContentBlock("Constructors", c.descriptor.constructors.map { ContentGroup(
-                listOf(
-                    ContentLink(it.fqNameSafe.asString(), c.dri.copy(callable = Callable(it.fqNameSafe.asString() /* TODO: identifier for filename here */, "", "", it.valueParameters.map {it.fqNameSafe.asString()})), platformData),
-                    ContentText("message to Pawel from the future: you forgot about extracting constructors, didn't you?", platformData),
-                    ContentText("signature for constructor", platformData)
-                ), platformData)
-            }, platformData),
-            ContentBlock("Functions", c.functions.map { ContentGroup(
-                listOf(
-                    ContentLink(it.name, it.dri, platformData),
-                    ContentText(it.briefDocstring, platformData),
-                    ContentText("signature for function", platformData)
-                ), platformData)
-            }, platformData)
-        )
-
-        private fun contentForFunction(f: Function) = listOf(
-            ContentHeader(listOf(ContentText(f.name, platformData)), 1, platformData),
-            ContentText("signature for function", platformData),
-            ContentText(f.rawDocstring, platformData),
-            ContentBlock("Parameters", f.parameters.map { ContentGroup(
-                listOf(
-                    ContentText(it.name ?: "?", platformData),
-                    ContentText(it.rawDocstring, platformData)
-                ), platformData)
-            }, platformData)
-        )
+        private fun contentForModule(m: Module) = content(platformData) {
+            header(1) { text("root") }
+            block("Packages", m.packages) { link(it.name, it.dri) }
+            text("Index")
+            text("Link to allpage here")
+        }
+
+        private fun contentForPackage(p: Package) = content(platformData) {
+            header(1) { text("Package ${p.name}") }
+            block("Types", p.classes) {
+                link(it.name, it.dri)
+                text(it.briefDocstring)
+                text("signature for class")
+            }
+            block("Functions", p.functions) {
+                link(it.name, it.dri)
+                text(it.briefDocstring)
+                text("signature for function")
+            }
+        }
+
+        private fun contentForClass(c: Class) = content(platformData) {
+            header(1) { text(c.name) }
+            markdown(c.rawDocstring, c)
+            text("PING PAWEL TO ADD CONSTRUCTORS TO MODEL!!!")
+            block("Constructors", emptyList<Function>() /* TODO: CONSTRUCTORS*/) {
+                link(it.name, it.dri)
+                text(it.briefDocstring)
+                text("message to Pawel from the future: you forgot about extracting constructors, didn't you?")
+            }
+            block("Functions", c.functions) {
+                link(it.name, it.dri)
+                text(it.briefDocstring)
+                text("signature for function")
+            }
+        }
+
+        private fun contentForFunction(f: Function) = content(platformData) {
+            header(1) { text(f.name) }
+            text("signature for function")
+            markdown(f.rawDocstring, f)
+            block("Parameters", f.children) {
+                group {
+                    text(it.name ?: "RECEIVER")
+                    markdown(it.rawDocstring, it)
+                }
+            }
+        }
+    }
+
+    // TODO: Make some public builder or merge it with page builder, whateva
+    private inner class ContentBuilder(private val platformData: List<PlatformData>) {
+        private val contents = mutableListOf<ContentNode>()
+
+        fun build() = contents.toList()
+
+        fun header(level: Int, block: ContentBuilder.() -> Unit) {
+            contents += ContentHeader(content(block), level, platformData)
+        }
+
+        fun text(text: String) {
+            contents += ContentText(text, platformData)
+        }
+
+        fun <T> block(name: String, elements: Iterable<T>, block: ContentBuilder.(T) -> Unit) {
+            contents += ContentBlock(name, content { elements.forEach { block(it) } }, platformData)
+        }
+
+        fun group(block: ContentBuilder.() -> Unit) {
+            contents += ContentGroup(content(block), platformData)
+        }
+
+        fun link(text: String, address: DRI) {
+            contents += ContentLink(text, address, platformData)
+        }
+
+        fun markdown(raw: String, node: DocumentationNode<*>) {
+            contents += markdownConverter.buildContent(parseMarkdown(raw), platformData, node)
+        }
+
+        private fun content(block: ContentBuilder.() -> Unit): List<ContentNode> = content(platformData, block)
     }
+
+    private fun content(platformData: List<PlatformData>, block: ContentBuilder.() -> Unit): List<ContentNode> =
+        ContentBuilder(platformData).apply(block).build()
+
 }
 
 fun DocumentationNode<*>.identifier(platformData: List<PlatformData>): List<ContentNode> {
diff --git a/core/src/main/kotlin/transformers/DocumentationToPageTransformer.kt b/core/src/main/kotlin/transformers/DocumentationToPageTransformer.kt
index f75f8d8e..c7859f73 100644
--- a/core/src/main/kotlin/transformers/DocumentationToPageTransformer.kt
+++ b/core/src/main/kotlin/transformers/DocumentationToPageTransformer.kt
@@ -6,5 +6,5 @@ import org.jetbrains.dokka.Model.Module
 import org.jetbrains.dokka.pages.PageNode
 
 interface DocumentationToPageTransformer {
-    fun transform (modules: Collection<Pair<DokkaConfiguration.PassConfiguration, Module>>): PageNode // TODO refactor this
+    fun transform(passConfiguration: DokkaConfiguration.PassConfiguration, module: Module): PageNode // TODO refactor this... some more?
 }
\ No newline at end of file