Changing how multimodule location provider works and improving gfm link substitution

6 files changed, 0 insertions, 286 deletions

diff --git a/plugins/all-module-page/src/main/kotlin/templates/DirectiveBasedTemplateProcessing.kt b/plugins/all-module-page/src/main/kotlin/templates/DirectiveBasedTemplateProcessing.kt
deleted file mode 100644
index feba2d4e..00000000
--- a/plugins/all-module-page/src/main/kotlin/templates/DirectiveBasedTemplateProcessing.kt
+++ /dev/null
@@ -1,138 +0,0 @@
-package org.jetbrains.dokka.allModulesPage.templates
-
-import kotlinx.coroutines.Dispatchers.IO
-import kotlinx.coroutines.coroutineScope
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.withContext
-import org.jetbrains.dokka.allModulesPage.AllModulesPagePlugin
-import org.jetbrains.dokka.base.templating.*
-import org.jetbrains.dokka.plugability.DokkaContext
-import org.jetbrains.dokka.plugability.plugin
-import org.jetbrains.dokka.plugability.query
-import org.jsoup.Jsoup
-import org.jsoup.nodes.*
-import org.jsoup.parser.Tag
-import java.io.File
-import java.nio.file.Files
-import java.util.concurrent.ConcurrentHashMap
-
-class DirectiveBasedHtmlTemplateProcessingStrategy(private val context: DokkaContext) : TemplateProcessingStrategy {
-    private val navigationFragments = ConcurrentHashMap<String, Element>()
-
-    private val substitutors = context.plugin<AllModulesPagePlugin>().query { substitutor }
-    private val externalModuleLinkResolver = ExternalModuleLinkResolver(context)
-
-    override suspend fun process(input: File, output: File): Boolean = coroutineScope {
-        if (input.extension == "html") {
-            launch {
-                val document = withContext(IO) { Jsoup.parse(input, "UTF-8") }
-                document.outputSettings().indentAmount(0).prettyPrint(false)
-                document.select("dokka-template-command").forEach {
-                    when (val command = parseJson<Command>(it.attr("data"))) {
-                        is ResolveLinkCommand -> resolveLink(it, command, output)
-                        is AddToNavigationCommand -> navigationFragments[command.moduleName] = it
-                        is SubstitutionCommand -> substitute(it, TemplatingContext(input, output, it, command))
-                        else -> context.logger.warn("Unknown templating command $command")
-                    }
-                }
-                withContext(IO) { Files.write(output.toPath(), listOf(document.outerHtml())) }
-            }
-            true
-        } else false
-    }
-
-    private fun substitute(element: Element, commandContext: TemplatingContext<SubstitutionCommand>) {
-        val regex = commandContext.command.pattern.toRegex()
-        element.children().forEach { it.traverseToSubstitute(regex, commandContext) }
-
-        val childrenCopy = element.children().toList()
-        val position = element.elementSiblingIndex()
-        val parent = element.parent()
-        element.remove()
-
-        parent.insertChildren(position, childrenCopy)
-    }
-
-    private fun Node.traverseToSubstitute(regex: Regex, commandContext: TemplatingContext<SubstitutionCommand>) {
-        when (this) {
-            is TextNode -> replaceWith(TextNode(wholeText.substitute(regex, commandContext)))
-            is DataNode -> replaceWith(DataNode(wholeData.substitute(regex, commandContext)))
-            is Element -> {
-                attributes().forEach { attr(it.key, it.value.substitute(regex, commandContext)) }
-                childNodes().forEach { it.traverseToSubstitute(regex, commandContext) }
-            }
-        }
-    }
-
-    private fun String.substitute(regex: Regex, commandContext: TemplatingContext<SubstitutionCommand>) = buildString {
-        var lastOffset = 0
-        regex.findAll(this@substitute).forEach { match ->
-            append(this@substitute, lastOffset, match.range.first)
-            append(findSubstitution(commandContext, match))
-            lastOffset = match.range.last + 1
-        }
-        append(this@substitute, lastOffset, this@substitute.length)
-    }
-
-    private fun findSubstitution(commandContext: TemplatingContext<SubstitutionCommand>, match: MatchResult): String =
-        substitutors.asSequence().mapNotNull { it.trySubstitute(commandContext, match) }.firstOrNull() ?: match.value
-
-    override suspend fun finish(output: File) {
-        val attributes = Attributes().apply {
-            put("class", "sideMenu")
-        }
-        val node = Element(Tag.valueOf("div"), "", attributes)
-        navigationFragments.entries.sortedBy { it.key }.forEach { (moduleName, command) ->
-            command.select("a").forEach { a ->
-                a.attr("href")?.also { a.attr("href", "${moduleName}/${it}") }
-            }
-            command.childNodes().toList().forEachIndexed { index, child ->
-                if (index == 0) {
-                    child.attr("id", "$moduleName-nav-submenu")
-                }
-                node.appendChild(child)
-            }
-        }
-
-        withContext(IO) {
-            Files.write(output.resolve("navigation.html").toPath(), listOf(node.outerHtml()))
-        }
-
-        node.select("a").forEach { a ->
-            a.attr("href")?.also { a.attr("href", "../${it}") }
-        }
-        navigationFragments.keys.forEach {
-            withContext(IO) {
-                Files.write(
-                    output.resolve(it).resolve("navigation.html").toPath(),
-                    listOf(node.outerHtml())
-                )
-            }
-        }
-    }
-
-    private fun resolveLink(it: Element, command: ResolveLinkCommand, fileContext: File) {
-
-        val link = externalModuleLinkResolver.resolve(command.dri, fileContext)
-        if (link == null) {
-            val children = it.childNodes().toList()
-            val attributes = Attributes().apply {
-                put("data-unresolved-link", command.dri.toString())
-            }
-            val element = Element(Tag.valueOf("span"), "", attributes).apply {
-                children.forEach { ch -> appendChild(ch) }
-            }
-            it.replaceWith(element)
-            return
-        }
-
-        val attributes = Attributes().apply {
-            put("href", link) // TODO: resolve
-        }
-        val children = it.childNodes().toList()
-        val element = Element(Tag.valueOf("a"), "", attributes).apply {
-            children.forEach { ch -> appendChild(ch) }
-        }
-        it.replaceWith(element)
-    }
-}
diff --git a/plugins/all-module-page/src/main/kotlin/templates/ExternalModuleLinkResolver.kt b/plugins/all-module-page/src/main/kotlin/templates/ExternalModuleLinkResolver.kt
deleted file mode 100644
index 5a3d3d33..00000000
--- a/plugins/all-module-page/src/main/kotlin/templates/ExternalModuleLinkResolver.kt
+++ /dev/null
@@ -1,49 +0,0 @@
-package org.jetbrains.dokka.allModulesPage.templates
-
-import org.jetbrains.dokka.base.DokkaBase
-import org.jetbrains.dokka.base.resolvers.shared.ExternalDocumentation
-import org.jetbrains.dokka.base.resolvers.shared.PackageList
-import org.jetbrains.dokka.links.DRI
-import org.jetbrains.dokka.plugability.DokkaContext
-import org.jetbrains.dokka.plugability.plugin
-import org.jetbrains.dokka.plugability.query
-import java.net.URL
-import java.io.File
-
-class ExternalModuleLinkResolver(val context: DokkaContext) {
-    private val elpFactory = context.plugin<DokkaBase>().query { externalLocationProviderFactory }
-    private val externalDocumentations by lazy(::setupExternalDocumentations)
-    private val elps by lazy {
-        elpFactory.flatMap { externalDocumentations.map { ed -> it.getExternalLocationProvider(ed) } }.filterNotNull()
-    }
-
-    private fun setupExternalDocumentations(): List<ExternalDocumentation> {
-        val packageLists =
-            context.configuration.modules.map { it.sourceOutputDirectory.resolve(it.relativePathToOutputDirectory) }
-                .map { module ->
-                    module to PackageList.load(
-                        URL("file:" + module.resolve("package-list").path),
-                        8,
-                        true
-                    )
-                }.toMap()
-        return packageLists.map { (module, pckgList) ->
-            ExternalDocumentation(
-                URL("file:/${module.name}/${module.name}"),
-                pckgList!!
-            )
-        }
-    }
-
-    fun resolve(dri: DRI, fileContext: File): String? {
-        val absoluteLink = elps.mapNotNull { it.resolve(dri) }.firstOrNull() ?: return null
-        val modulePath = context.configuration.outputDir.absolutePath.split(File.separator)
-        val contextPath = fileContext.absolutePath.split(File.separator)
-        val commonPathElements = modulePath.zip(contextPath)
-            .takeWhile { (a, b) -> a == b }.count()
-
-        return (List(contextPath.size - commonPathElements - 1) { ".." } + modulePath.drop(commonPathElements)).joinToString(
-            "/"
-        ) + absoluteLink.removePrefix("file:")
-    }
-}
\ No newline at end of file
diff --git a/plugins/all-module-page/src/main/kotlin/templates/FallbackTemplateProcessingStrategy.kt b/plugins/all-module-page/src/main/kotlin/templates/FallbackTemplateProcessingStrategy.kt
deleted file mode 100644
index 9b5251ac..00000000
--- a/plugins/all-module-page/src/main/kotlin/templates/FallbackTemplateProcessingStrategy.kt
+++ /dev/null
@@ -1,18 +0,0 @@
-package org.jetbrains.dokka.allModulesPage.templates
-
-import kotlinx.coroutines.Dispatchers.IO
-import kotlinx.coroutines.coroutineScope
-import kotlinx.coroutines.launch
-import org.jetbrains.dokka.plugability.DokkaContext
-import java.io.File
-import java.nio.file.Files
-
-class FallbackTemplateProcessingStrategy(dokkaContext: DokkaContext) : TemplateProcessingStrategy {
-
-    override suspend fun process(input: File, output: File): Boolean  = coroutineScope {
-        launch(IO) {
-            Files.copy(input.toPath(), output.toPath())
-        }
-        true
-    }
-}
\ No newline at end of file
diff --git a/plugins/all-module-page/src/main/kotlin/templates/PathToRootSubstitutor.kt b/plugins/all-module-page/src/main/kotlin/templates/PathToRootSubstitutor.kt
deleted file mode 100644
index 5056b724..00000000
--- a/plugins/all-module-page/src/main/kotlin/templates/PathToRootSubstitutor.kt
+++ /dev/null
@@ -1,14 +0,0 @@
-package org.jetbrains.dokka.allModulesPage.templates
-
-import org.jetbrains.dokka.base.templating.PathToRootSubstitutionCommand
-import org.jetbrains.dokka.base.templating.SubstitutionCommand
-import org.jetbrains.dokka.plugability.DokkaContext
-import java.io.File
-
-class PathToRootSubstitutor(private val dokkaContext: DokkaContext) : Substitutor {
-    override fun trySubstitute(context: TemplatingContext<SubstitutionCommand>, match: MatchResult): String? =
-        if (context.command is PathToRootSubstitutionCommand) {
-            context.output.toPath().parent.relativize(dokkaContext.configuration.outputDir.toPath()).toString().split(File.separator).joinToString(separator = "/", postfix = "/") { it }
-        } else null
-
-}
\ No newline at end of file
diff --git a/plugins/all-module-page/src/main/kotlin/templates/Substitutor.kt b/plugins/all-module-page/src/main/kotlin/templates/Substitutor.kt
deleted file mode 100644
index 98f1d88e..00000000
--- a/plugins/all-module-page/src/main/kotlin/templates/Substitutor.kt
+++ /dev/null
@@ -1,7 +0,0 @@
-package org.jetbrains.dokka.allModulesPage.templates
-
-import org.jetbrains.dokka.base.templating.SubstitutionCommand
-
-fun interface Substitutor {
-    fun trySubstitute(context: TemplatingContext<SubstitutionCommand>, match: MatchResult): String?
-}
\ No newline at end of file
diff --git a/plugins/all-module-page/src/main/kotlin/templates/TemplateProcessor.kt b/plugins/all-module-page/src/main/kotlin/templates/TemplateProcessor.kt
deleted file mode 100644
index 18d63df0..00000000
--- a/plugins/all-module-page/src/main/kotlin/templates/TemplateProcessor.kt
+++ /dev/null
@@ -1,60 +0,0 @@
-package org.jetbrains.dokka.allModulesPage.templates
-
-import kotlinx.coroutines.*
-import org.jetbrains.dokka.allModulesPage.AllModulesPagePlugin
-import org.jetbrains.dokka.base.templating.Command
-import org.jetbrains.dokka.plugability.DokkaContext
-import org.jetbrains.dokka.plugability.plugin
-import org.jetbrains.dokka.plugability.query
-import org.jsoup.nodes.Element
-import java.io.File
-import java.nio.file.Files
-import java.nio.file.Path
-import kotlin.coroutines.coroutineContext
-
-interface TemplateProcessor {
-    fun process()
-}
-
-interface TemplateProcessingStrategy {
-    suspend fun process(input: File, output: File): Boolean
-    suspend fun finish(output: File) {}
-}
-
-class DefaultTemplateProcessor(
-    private val context: DokkaContext,
-): TemplateProcessor {
-
-    private val strategies: List<TemplateProcessingStrategy> = context.plugin<AllModulesPagePlugin>().query { templateProcessingStrategy }
-
-    override fun process() = runBlocking(Dispatchers.Default) {
-        coroutineScope {
-            context.configuration.modules.forEach {
-                launch {
-                    it.sourceOutputDirectory.visit(context.configuration.outputDir.resolve(it.relativePathToOutputDirectory))
-                }
-            }
-        }
-        strategies.map { it.finish(context.configuration.outputDir) }
-        Unit
-    }
-
-    private suspend fun File.visit(target: File): Unit = coroutineScope {
-        val source = this@visit
-        if (source.isDirectory) {
-           target.mkdir()
-           source.list()?.forEach {
-               launch { source.resolve(it).visit(target.resolve(it)) }
-           }
-        } else {
-            strategies.asSequence().first { it.process(source, target) }
-        }
-    }
-}
-
-data class TemplatingContext<out T: Command>(
-    val input: File,
-    val output: File,
-    val element: Element,
-    val command: T,
-)
\ No newline at end of file