First version of javadoc output generation

66 files changed, 39521 insertions, 14 deletions

diff --git a/plugins/base/frontend/build.gradle.kts b/plugins/base/frontend/build.gradle.kts
index c1654f99..990b7828 100644
--- a/plugins/base/frontend/build.gradle.kts
+++ b/plugins/base/frontend/build.gradle.kts
@@ -7,6 +7,7 @@ tasks {
         inputs.dir("$projectDir/src/main/")
         inputs.files("$projectDir/package.json", "$projectDir/webpack.config.js")
         outputs.dir("$projectDir/dist/")
+        outputs.cacheIf { true }
     }
 
     register("generateFrontendFiles") {
diff --git a/plugins/base/src/main/kotlin/DokkaBase.kt b/plugins/base/src/main/kotlin/DokkaBase.kt
index af04d435..46c92c15 100644
--- a/plugins/base/src/main/kotlin/DokkaBase.kt
+++ b/plugins/base/src/main/kotlin/DokkaBase.kt
@@ -130,7 +130,7 @@ class DokkaBase : DokkaPlugin() {
     }
 
     val rootCreator by extending {
-        htmlPreprocessors with RootCreator
+        htmlPreprocessors with RootCreator applyIf { format == "html" }
     }
 
     val defaultSamplesTransformer by extending {
@@ -153,19 +153,19 @@ class DokkaBase : DokkaPlugin() {
     }
 
     val navigationPageInstaller by extending {
-        htmlPreprocessors with NavigationPageInstaller order { after(rootCreator) }
+        htmlPreprocessors with NavigationPageInstaller order { after(rootCreator) } applyIf { format == "html" }
     }
 
     val searchPageInstaller by extending {
-        htmlPreprocessors with SearchPageInstaller order { after(rootCreator) }
+        htmlPreprocessors with SearchPageInstaller order { after(rootCreator) } applyIf { format == "html" }
     }
 
     val resourceInstaller by extending {
-        htmlPreprocessors with ResourceInstaller order { after(rootCreator) }
+        htmlPreprocessors with ResourceInstaller order { after(rootCreator) } applyIf { format == "html" }
     }
 
     val styleAndScriptsAppender by extending {
-        htmlPreprocessors with StyleAndScriptsAppender order { after(rootCreator) }
+        htmlPreprocessors with StyleAndScriptsAppender order { after(rootCreator) } applyIf { format == "html" }
     }
 
     val packageListCreator by extending {
@@ -175,7 +175,7 @@ class DokkaBase : DokkaPlugin() {
                 "html",
                 "html"
             )
-        } order { after(rootCreator) }
+        } order { after(rootCreator) } applyIf { format == "html" }
     }
 
     val sourcesetDependencyAppender by extending {
diff --git a/plugins/base/src/test/kotlin/basic/DokkaBasicTests.kt b/plugins/base/src/test/kotlin/basic/DokkaBasicTests.kt
index c1044e09..c9f4b156 100644
--- a/plugins/base/src/test/kotlin/basic/DokkaBasicTests.kt
+++ b/plugins/base/src/test/kotlin/basic/DokkaBasicTests.kt
@@ -31,8 +31,9 @@ class DokkaBasicTests : AbstractCoreTest() {
             configuration
         ) {
             pagesGenerationStage = {
-                println(it.dri)
-                assertTrue(it.getClasslikeToMemberMap().filterKeys { it.name == "Test" }.entries.firstOrNull()?.value?.size == 2)
+                val root = it as ModulePageNode
+                println(root.dri)
+                assertTrue(root.getClasslikeToMemberMap().filterKeys { root.name == "Test" }.entries.firstOrNull()?.value?.size == 2)
             }
         }
     }
diff --git a/plugins/base/src/test/kotlin/enums/EnumsTest.kt b/plugins/base/src/test/kotlin/enums/EnumsTest.kt
index a8b78baa..125e37e2 100644
--- a/plugins/base/src/test/kotlin/enums/EnumsTest.kt
+++ b/plugins/base/src/test/kotlin/enums/EnumsTest.kt
@@ -231,7 +231,7 @@ class EnumsTest : AbstractCoreTest() {
     }
 
 
-    fun ModulePageNode.getClasslikeToMemberMap() =
+    fun RootPageNode.getClasslikeToMemberMap() =
         this.parentMap.filterValues { it is ClasslikePageNode }.entries.groupBy({ it.value }) { it.key }
 
     private fun ContentGroup.constructorSignature(): String =
diff --git a/plugins/base/src/test/kotlin/markdown/KDocTest.kt b/plugins/base/src/test/kotlin/markdown/KDocTest.kt
index f9d717b0..218f7244 100644
--- a/plugins/base/src/test/kotlin/markdown/KDocTest.kt
+++ b/plugins/base/src/test/kotlin/markdown/KDocTest.kt
@@ -39,7 +39,7 @@ abstract class KDocTest : AbstractCoreTest() {
             pagesGenerationStage = {
                 assertEquals(
                     expectedDocumentationNode,
-                    actualDocumentationNode(it)
+                    actualDocumentationNode(it as ModulePageNode)
                 )
             }
         }
diff --git a/plugins/build.gradle.kts b/plugins/build.gradle.kts
index e65f78ac..d681cf2a 100644
--- a/plugins/build.gradle.kts
+++ b/plugins/build.gradle.kts
@@ -1,6 +1,7 @@
 subprojects {
     apply {
         plugin("maven-publish")
+        plugin("com.jfrog.bintray")
     }
 
     dependencies {
diff --git a/plugins/javadoc/build.gradle.kts b/plugins/javadoc/build.gradle.kts
new file mode 100644
index 00000000..4414b1dd
--- /dev/null
+++ b/plugins/javadoc/build.gradle.kts
@@ -0,0 +1,19 @@
+import org.jetbrains.configureBintrayPublication
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
+
+publishing {
+    publications {
+        register<MavenPublication>("javadocPlugin") {
+            artifactId = "javadoc-plugin"
+            from(components["java"])
+        }
+    }
+}
+
+dependencies {
+    implementation("com.soywiz.korlibs.korte:korte-jvm:1.10.3")
+    implementation("org.jetbrains.kotlinx:kotlinx-html-jvm:0.6.10")
+    implementation(project(":plugins:base"))
+}
+
+configureBintrayPublication("javadocPlugin")
diff --git a/plugins/javadoc/src/main/kotlin/javadoc/JavadocDocumentableToPageTranslator.kt b/plugins/javadoc/src/main/kotlin/javadoc/JavadocDocumentableToPageTranslator.kt
new file mode 100644
index 00000000..840bdc55
--- /dev/null
+++ b/plugins/javadoc/src/main/kotlin/javadoc/JavadocDocumentableToPageTranslator.kt
@@ -0,0 +1,18 @@
+package javadoc
+
+import org.jetbrains.dokka.base.signatures.SignatureProvider
+import org.jetbrains.dokka.base.transformers.pages.comments.CommentsToContentConverter
+import org.jetbrains.dokka.model.DModule
+import org.jetbrains.dokka.pages.ModulePageNode
+import org.jetbrains.dokka.pages.RootPageNode
+import org.jetbrains.dokka.transformers.documentation.DocumentableToPageTranslator
+import org.jetbrains.dokka.utilities.DokkaLogger
+
+class JavadocDocumentableToPageTranslator(
+    private val commentsToContentConverter: CommentsToContentConverter,
+    private val signatureProvider: SignatureProvider,
+    private val logger: DokkaLogger
+) : DocumentableToPageTranslator {
+    override fun invoke(module: DModule): RootPageNode =
+        JavadocPageCreator(commentsToContentConverter, signatureProvider, logger).pageForModule(module)
+}
\ No newline at end of file
diff --git a/plugins/javadoc/src/main/kotlin/javadoc/JavadocLocationProvider.kt b/plugins/javadoc/src/main/kotlin/javadoc/JavadocLocationProvider.kt
new file mode 100644
index 00000000..520486f6
--- /dev/null
+++ b/plugins/javadoc/src/main/kotlin/javadoc/JavadocLocationProvider.kt
@@ -0,0 +1,103 @@
+package javadoc
+
+import javadoc.pages.*
+import org.jetbrains.dokka.Platform
+import org.jetbrains.dokka.base.DokkaBase
+import org.jetbrains.dokka.base.resolvers.local.LocationProvider
+import org.jetbrains.dokka.links.DRI
+import org.jetbrains.dokka.model.SourceSetData
+import org.jetbrains.dokka.pages.ContentPage
+import org.jetbrains.dokka.pages.PageNode
+import org.jetbrains.dokka.pages.RootPageNode
+import org.jetbrains.dokka.plugability.DokkaContext
+import org.jetbrains.dokka.plugability.plugin
+import org.jetbrains.dokka.plugability.query
+import java.nio.file.Paths
+import java.util.*
+
+class JavadocLocationProvider(pageRoot: RootPageNode, private val context: DokkaContext) : LocationProvider {
+    private val externalLocationProviderFactories =
+        context.plugin<DokkaBase>().query { externalLocationProviderFactory }
+    private val externalLocationProvider =
+        externalLocationProviderFactories.asSequence().map { it.getExternalLocationProvider("javadoc10") }
+            .filterNotNull().take(1).firstOrNull()
+    private val externalDocumentationLinks by lazy {
+        context.configuration.passesConfigurations
+            .filter { passConfig -> passConfig.analysisPlatform == Platform.jvm }
+            .flatMap { it.externalDocumentationLinks }
+            .distinct()
+    }
+
+    private val pathIndex = IdentityHashMap<PageNode, List<String>>().apply {
+        fun registerPath(page: PageNode, prefix: List<String> = emptyList()) {
+            val newPrefix = prefix + page.takeIf { it is JavadocPackagePageNode }?.name.orEmpty()
+            val path = (prefix + when (page) {
+                is AllClassesPage -> listOf("allclasses")
+                is TreeViewPage -> if (page.classes == null)
+                    listOf("overview-tree")
+                else
+                    listOf("package-tree")
+                is ContentPage -> if (page.dri.isNotEmpty() && page.dri.first().classNames != null)
+                    listOfNotNull(page.dri.first().classNames)
+                else if (page is JavadocPackagePageNode)
+                    listOf(page.name, "package-summary")
+                else
+                    listOf("index")
+                else -> emptyList()
+            }).filterNot { it.isEmpty() }
+
+            put(page, path)
+            page.children.forEach { registerPath(it, newPrefix) }
+
+        }
+        put(pageRoot, listOf("index"))
+        pageRoot.children.forEach { registerPath(it) }
+    }
+
+    private val nodeIndex = IdentityHashMap<DRI, PageNode>().apply {
+        fun registerNode(node: PageNode) {
+            if (node is ContentPage) put(node.dri.first(), node)
+
+            node.children.forEach(::registerNode)
+        }
+        registerNode(pageRoot)
+    }
+
+    private operator fun IdentityHashMap<PageNode, List<String>>.get(dri: DRI) = this[nodeIndex[dri]]
+
+    override fun resolve(dri: DRI, sourceSets: List<SourceSetData>, context: PageNode?): String =
+        context?.let { resolve(it, skipExtension = false) } ?: nodeIndex[dri]?.let {
+            resolve(it, skipExtension = true)
+        } ?: with(externalLocationProvider!!) {
+            dri.toLocation()
+        }
+
+    override fun resolve(node: PageNode, context: PageNode?, skipExtension: Boolean): String =
+        pathIndex[node]?.joinToString("/")?.let {
+            if (skipExtension) it.removeSuffix(".html") else it
+        } ?: run {
+            throw IllegalStateException("Path for ${node::class.java.canonicalName}:${node.name} not found")
+        }
+
+    fun resolve(link: LinkJavadocListEntry, dir: String = "", skipExtension: Boolean = true) = pathIndex[link.dri.first()]?.let {
+        when (link.kind) {
+            JavadocContentKind.Class -> it
+            JavadocContentKind.OverviewSummary -> it.dropLast(1) + "index"
+            JavadocContentKind.PackageSummary -> it.dropLast(1) + "package-summary"
+            JavadocContentKind.AllClasses -> it.dropLast(1) + "allclasses"
+            JavadocContentKind.OverviewTree -> it.dropLast(1) + "overview-tree"
+            JavadocContentKind.PackageTree -> it.dropLast(1) + "package-tree"
+            else -> it
+        }
+    }?.joinToString("/")?.let {if (skipExtension) "$it.html" else it}?.let {
+        Paths.get(dir).relativize(Paths.get(it)).toString()
+    } ?: run {throw IllegalStateException("Page for ${link.name} not found")}
+
+    override fun resolveRoot(node: PageNode): String {
+        TODO("Not yet implemented")
+    }
+
+    override fun ancestors(node: PageNode): List<PageNode> {
+        TODO("Not yet implemented")
+    }
+}
\ No newline at end of file
diff --git a/plugins/javadoc/src/main/kotlin/javadoc/JavadocPageCreator.kt b/plugins/javadoc/src/main/kotlin/javadoc/JavadocPageCreator.kt
new file mode 100644
index 00000000..f5ca4bb3
--- /dev/null
+++ b/plugins/javadoc/src/main/kotlin/javadoc/JavadocPageCreator.kt
@@ -0,0 +1,92 @@
+package javadoc
+
+import javadoc.pages.*
+import org.jetbrains.dokka.Platform
+import org.jetbrains.dokka.base.signatures.SignatureProvider
+import org.jetbrains.dokka.base.transformers.pages.comments.CommentsToContentConverter
+import org.jetbrains.dokka.model.*
+import org.jetbrains.dokka.pages.ContentKind
+import org.jetbrains.dokka.utilities.DokkaLogger
+
+open class JavadocPageCreator(
+    commentsToContentConverter: CommentsToContentConverter,
+    signatureProvider: SignatureProvider,
+    val logger: DokkaLogger
+) {
+    fun pageForModule(m: DModule): JavadocModulePageNode =
+        JavadocModulePageNode(
+            m.name.ifEmpty { "root" },
+            contentForModule(m),
+            m.packages.map { pageForPackage(it) },
+            setOf(m.dri)
+        )
+
+    fun pageForPackage(p: DPackage) =
+        JavadocPackagePageNode(p.name, contentForPackage(p), setOf(p.dri), p,
+            p.classlikes.map { pageForClasslike(it) } // TODO: nested classlikes
+        ).also {
+            it
+        }
+
+    fun pageForClasslike(c: DClasslike): JavadocClasslikePageNode {
+        val constructors = when (c) {
+            is DClass -> c.constructors
+            is DEnum -> c.constructors
+            else -> emptyList()
+        }
+
+        return JavadocClasslikePageNode(c.name.orEmpty(), contentForClasslike(c), setOf(c.dri), c, emptyList())
+    }
+
+    fun contentForModule(m: DModule): JavadocContentNode =
+        JavadocContentGroup(
+            setOf(m.dri),
+            JavadocContentKind.OverviewSummary,
+            m.sourceSets.filter { it.platform == Platform.jvm }.toSet()
+        ) {
+            title(m.name, "0.0.1", dri = setOf(m.dri), kind = ContentKind.Main)
+            list("Packages", "Package", setOf(m.dri), ContentKind.Packages, m.packages.map { p ->
+                val doc = p.documentation.entries.find { (k, _) -> k.platform == Platform.jvm }?.value?.let {
+                    it.children.joinToString("\n") { it.root.toString() }
+                }.orEmpty()
+                RowJavadocListEntry(
+                    LinkJavadocListEntry(p.name, setOf(p.dri), JavadocContentKind.PackageSummary, sourceSets),
+                    doc
+                )
+            })
+        }
+
+    fun contentForPackage(p: DPackage): JavadocContentNode =
+        JavadocContentGroup(
+            setOf(p.dri),
+            JavadocContentKind.PackageSummary,
+            p.sourceSets.filter { it.platform == Platform.jvm }.toSet()
+        ) {
+            title(p.name, "0.0.1", dri = setOf(p.dri), kind = ContentKind.Packages)
+            list("Packages", "Package", setOf(p.dri), ContentKind.Packages, p.classlikes.map { c ->
+                val doc = c.documentation.entries.find { (k, _) -> k.platform == Platform.jvm }?.value?.let {
+                    it.children.joinToString("\n") { it.root.toString() }
+                }.orEmpty()
+                RowJavadocListEntry(
+                    LinkJavadocListEntry(c.name.orEmpty(), setOf(c.dri), JavadocContentKind.Class, sourceSets),
+                    doc
+                )
+            })
+        }
+
+    fun contentForClasslike(c: DClasslike): JavadocContentNode =
+        JavadocContentGroup(
+            setOf(c.dri),
+            JavadocContentKind.Class,
+            c.sourceSets.filter { it.platform == Platform.jvm }.toSet()
+        ) {
+            title(
+                c.name.orEmpty(),
+                "0.0.1",
+                parent = c.dri.packageName,
+                dri = setOf(c.dri),
+                kind = JavadocContentKind.Class
+            )
+        }
+}
+
diff --git a/plugins/javadoc/src/main/kotlin/javadoc/JavadocPlugin.kt b/plugins/javadoc/src/main/kotlin/javadoc/JavadocPlugin.kt
new file mode 100644
index 00000000..f58faa49
--- /dev/null
+++ b/plugins/javadoc/src/main/kotlin/javadoc/JavadocPlugin.kt
@@ -0,0 +1,29 @@
+package org.jetbrains.dokka.javadoc
+
+import javadoc.JavadocDocumentableToPageTranslator
+import javadoc.KorteJavadocRenderer
+import org.jetbrains.dokka.CoreExtensions
+import org.jetbrains.dokka.base.DokkaBase
+import org.jetbrains.dokka.plugability.DokkaPlugin
+import org.jetbrains.dokka.plugability.querySingle
+
+class JavadocPlugin : DokkaPlugin() {
+    val dokkaJavadocPlugin by extending {
+        val dokkaBasePlugin = plugin<DokkaBase>()
+        CoreExtensions.renderer providing { ctx ->
+            KorteJavadocRenderer(dokkaBasePlugin.querySingle { outputWriter }, ctx, "views")
+        } applyIf { format == "javadoc" }
+    }
+
+    val pageTranslator by extending {
+        val dokkaBasePlugin = plugin<DokkaBase>()
+        CoreExtensions.documentableToPageTranslator providing { ctx ->
+            JavadocDocumentableToPageTranslator(
+                dokkaBasePlugin.querySingle { commentsToContentConverter },
+                dokkaBasePlugin.querySingle { signatureProvider },
+                ctx.logger
+            )
+        }
+    }
+}
+
diff --git a/plugins/javadoc/src/main/kotlin/javadoc/JavadocRenderer.kt b/plugins/javadoc/src/main/kotlin/javadoc/JavadocRenderer.kt
new file mode 100644
index 00000000..588d89ba
--- /dev/null
+++ b/plugins/javadoc/src/main/kotlin/javadoc/JavadocRenderer.kt
@@ -0,0 +1,28 @@
+package org.jetbrains.dokka.javadoc
+
+//class JavadocRenderer(val o