Remove all unnecessary files

47 files changed, 0 insertions, 7013 deletions

diff --git a/core/src/main/kotlin/Formats/FormatService.kt b/core/src/main/kotlin/Formats/FormatService.kt
deleted file mode 100644
index 8f4855e3..00000000
--- a/core/src/main/kotlin/Formats/FormatService.kt
+++ /dev/null
@@ -1,32 +0,0 @@
-package org.jetbrains.dokka
-
-/**
- * Abstract representation of a formatting service used to output documentation in desired format
- *
- * Bundled Formatters:
- * * [HtmlFormatService] – outputs documentation to HTML format
- * * [MarkdownFormatService] – outputs documentation in Markdown format
- */
-interface FormatService {
-    /** Returns extension for output files */
-    val extension: String
-
-    /** extension which will be used for internal and external linking */
-    val linkExtension: String
-        get() = extension
-
-    fun createOutputBuilder(to: StringBuilder, location: Location): FormattedOutputBuilder
-
-    fun enumerateSupportFiles(callback: (resource: String, targetPath: String) -> Unit) {
-    }
-}
-
-interface FormattedOutputBuilder {
-    /** Appends formatted content */
-    fun appendNodes(nodes: Iterable<DocumentationNode>)
-}
-
-/** Format content to [String] using specified [location] */
-fun FormatService.format(location: Location, nodes: Iterable<DocumentationNode>): String = StringBuilder().apply {
-    createOutputBuilder(this, location).appendNodes(nodes)
-}.toString()
diff --git a/core/src/main/kotlin/Formats/GFMFormatService.kt b/core/src/main/kotlin/Formats/GFMFormatService.kt
deleted file mode 100644
index 036ec856..00000000
--- a/core/src/main/kotlin/Formats/GFMFormatService.kt
+++ /dev/null
@@ -1,61 +0,0 @@
-package org.jetbrains.dokka
-
-import com.google.inject.Inject
-import com.google.inject.name.Named
-import org.jetbrains.dokka.Utilities.impliedPlatformsName
-
-open class GFMOutputBuilder(
-        to: StringBuilder,
-        location: Location,
-        generator: NodeLocationAwareGenerator,
-        languageService: LanguageService,
-        extension: String,
-        impliedPlatforms: List<String>
-) : MarkdownOutputBuilder(to, location, generator, languageService, extension, impliedPlatforms) {
-    override fun appendTable(vararg columns: String, body: () -> Unit) {
-        to.appendln(columns.joinToString(" | ", "| ", " |"))
-        to.appendln("|" + "---|".repeat(columns.size))
-        body()
-    }
-
-    override fun appendUnorderedList(body: () -> Unit) {
-        if (inTableCell) {
-            wrapInTag("ul", body)
-        } else {
-            super.appendUnorderedList(body)
-        }
-    }
-
-    override fun appendOrderedList(body: () -> Unit) {
-        if (inTableCell) {
-            wrapInTag("ol", body)
-        } else {
-            super.appendOrderedList(body)
-        }
-    }
-
-    override fun appendListItem(body: () -> Unit) {
-        if (inTableCell) {
-            wrapInTag("li", body)
-        } else {
-            super.appendListItem(body)
-        }
-    }
-}
-
-open class GFMFormatService(
-        generator: NodeLocationAwareGenerator,
-        signatureGenerator: LanguageService,
-        linkExtension: String,
-        impliedPlatforms: List<String>
-) : MarkdownFormatService(generator, signatureGenerator, linkExtension, impliedPlatforms) {
-
-    @Inject constructor(
-            generator: NodeLocationAwareGenerator,
-            signatureGenerator: LanguageService,
-            @Named(impliedPlatformsName) impliedPlatforms: List<String>
-    ) : this(generator, signatureGenerator, "md", impliedPlatforms)
-
-    override fun createOutputBuilder(to: StringBuilder, location: Location): FormattedOutputBuilder =
-            GFMOutputBuilder(to, location, generator, languageService, extension, impliedPlatforms)
-}
diff --git a/core/src/main/kotlin/Formats/HtmlFormatService.kt b/core/src/main/kotlin/Formats/HtmlFormatService.kt
deleted file mode 100644
index d36ea0a2..00000000
--- a/core/src/main/kotlin/Formats/HtmlFormatService.kt
+++ /dev/null
@@ -1,166 +0,0 @@
-package org.jetbrains.dokka
-
-import com.google.inject.Inject
-import com.google.inject.name.Named
-import org.jetbrains.dokka.Utilities.impliedPlatformsName
-import java.io.File
-
-open class HtmlOutputBuilder(to: StringBuilder,
-                             location: Location,
-                             generator: NodeLocationAwareGenerator,
-                             languageService: LanguageService,
-                             extension: String,
-                             impliedPlatforms: List<String>,
-                             val templateService: HtmlTemplateService)
-    : StructuredOutputBuilder(to, location, generator, languageService, extension, impliedPlatforms)
-{
-    override fun appendText(text: String) {
-        to.append(text.htmlEscape())
-    }
-
-    override fun appendSymbol(text: String) {
-        to.append("<span class=\"symbol\">${text.htmlEscape()}</span>")
-    }
-
-    override fun appendKeyword(text: String) {
-        to.append("<span class=\"keyword\">${text.htmlEscape()}</span>")
-    }
-
-    override fun appendIdentifier(text: String, kind: IdentifierKind, signature: String?) {
-        val id = signature?.let { " id=\"$it\"" }.orEmpty()
-        to.append("<span class=\"identifier\"$id>${text.htmlEscape()}</span>")
-    }
-
-    override fun appendBlockCode(language: String, body: () -> Unit) {
-        val openTags = if (language.isNotBlank())
-            "<pre><code class=\"lang-$language\">"
-        else
-            "<pre><code>"
-        wrap(openTags, "</code></pre>", body)
-    }
-
-    override fun appendHeader(level: Int, body: () -> Unit) =
-        wrapInTag("h$level", body, newlineBeforeOpen = true, newlineAfterClose = true)
-    override fun appendParagraph(body: () -> Unit) =
-        wrapInTag("p", body, newlineBeforeOpen = true, newlineAfterClose = true)
-
-    override fun appendSoftParagraph(body: () -> Unit) = appendParagraph(body)
-
-    override fun appendLine() {
-        to.appendln("<br/>")
-    }
-
-    override fun appendAnchor(anchor: String) {
-        to.appendln("<a name=\"${anchor.htmlEscape()}\"></a>")
-    }
-
-    override fun appendTable(vararg columns: String, body: () -> Unit) =
-            wrapInTag("table", body, newlineAfterOpen = true, newlineAfterClose = true)
-    override fun appendTableBody(body: () -> Unit) =
-            wrapInTag("tbody", body, newlineAfterOpen = true, newlineAfterClose = true)
-    override fun appendTableRow(body: () -> Unit) =
-            wrapInTag("tr", body, newlineAfterOpen = true, newlineAfterClose = true)
-    override fun appendTableCell(body: () -> Unit) =
-            wrapInTag("td", body, newlineAfterOpen = true, newlineAfterClose = true)
-
-    override fun appendLink(href: String, body: () -> Unit) = wrap("<a href=\"$href\">", "</a>", body)
-
-    override fun appendStrong(body: () -> Unit) = wrapInTag("strong", body)
-    override fun appendEmphasis(body: () -> Unit) = wrapInTag("em", body)
-    override fun appendStrikethrough(body: () -> Unit) = wrapInTag("s", body)
-    override fun appendCode(body: () -> Unit) = wrapInTag("code", body)
-
-    override fun appendUnorderedList(body: () -> Unit) = wrapInTag("ul", body, newlineAfterClose = true)
-    override fun appendOrderedList(body: () -> Unit) = wrapInTag("ol", body, newlineAfterClose = true)
-    override fun appendListItem(body: () -> Unit) = wrapInTag("li", body, newlineAfterClose = true)
-
-    override fun appendBreadcrumbSeparator() {
-        to.append("&nbsp;/&nbsp;")
-    }
-
-    override fun appendNodes(nodes: Iterable<DocumentationNode>) {
-        templateService.appendHeader(to, getPageTitle(nodes), generator.relativePathToRoot(location))
-        super.appendNodes(nodes)
-        templateService.appendFooter(to)
-    }
-
-    override fun appendNonBreakingSpace() {
-        to.append("&nbsp;")
-    }
-
-    override fun ensureParagraph() {}
-}
-
-open class HtmlFormatService @Inject constructor(generator: NodeLocationAwareGenerator,
-                                                 signatureGenerator: LanguageService,
-                                                 val templateService: HtmlTemplateService,
-                                                 @Named(impliedPlatformsName) val impliedPlatforms: List<String>)
-: StructuredFormatService(generator, signatureGenerator, "html"), OutlineFormatService {
-
-    override fun enumerateSupportFiles(callback: (String, String) -> Unit) {
-        callback("/dokka/styles/style.css", "style.css")
-    }
-
-    override fun createOutputBuilder(to: StringBuilder, location: Location) =
-        HtmlOutputBuilder(to, location, generator, languageService, extension, impliedPlatforms, templateService)
-
-    override fun appendOutline(location: Location, to: StringBuilder, nodes: Iterable<DocumentationNode>) {
-        templateService.appendHeader(to, "Module Contents", generator.relativePathToRoot(location))
-        super.appendOutline(location, to, nodes)
-        templateService.appendFooter(to)
-    }
-
-    override fun getOutlineFileName(location: Location): File {
-        return File("${location.path}-outline.html")
-    }
-
-    override fun appendOutlineHeader(location: Location, node: DocumentationNode, to: StringBuilder) {
-        val link = ContentNodeDirectLink(node)
-        link.append(languageService.render(node, LanguageService.RenderMode.FULL))
-        val tempBuilder = StringBuilder()
-        createOutputBuilder(tempBuilder, location).appendContent(link)
-        to.appendln("<a href=\"${location.path}\">$tempBuilder</a><br/>")
-    }
-
-    override fun appendOutlineLevel(to: StringBuilder, body: () -> Unit) {
-        to.appendln("<ul>")
-        body()
-        to.appendln("</ul>")
-    }
-}
-
-fun getPageTitle(nodes: Iterable<DocumentationNode>): String? {
-    val breakdownByLocation = nodes.groupBy { node -> formatPageTitle(node) }
-    return breakdownByLocation.keys.singleOrNull()
-}
-
-fun formatPageTitle(node: DocumentationNode): String {
-    val path = node.path
-    val moduleName = path.first().name
-    if (path.size == 1) {
-        return moduleName
-    }
-
-    val qName = qualifiedNameForPageTitle(node)
-    return "$qName - $moduleName"
-}
-
-private fun qualifiedNameForPageTitle(node: DocumentationNode): String {
-    if (node.kind == NodeKind.Package) {
-        var packageName = node.qualifiedName()
-        if (packageName.isEmpty()) {
-            packageName = "root package"
-        }
-        return packageName
-    }
-
-    val path = node.path
-    var pathFromToplevelMember = path.dropWhile { it.kind !in NodeKind.classLike }
-    if (pathFromToplevelMember.isEmpty()) {
-        pathFromToplevelMember = path.dropWhile { it.kind != NodeKind.Property && it.kind != NodeKind.Function }
-    }
-    if (pathFromToplevelMember.isNotEmpty()) {
-        return pathFromToplevelMember.map { it.name }.filter { it.length > 0 }.joinToString(".")
-    }
-    return node.qualifiedName()
-}
diff --git a/core/src/main/kotlin/Formats/HtmlTemplateService.kt b/core/src/main/kotlin/Formats/HtmlTemplateService.kt
deleted file mode 100644
index a65a7b18..00000000
--- a/core/src/main/kotlin/Formats/HtmlTemplateService.kt
+++ /dev/null
@@ -1,38 +0,0 @@
-package org.jetbrains.dokka
-
-import java.io.File
-
-interface HtmlTemplateService {
-    fun appendHeader(to: StringBuilder, title: String?, basePath: File)
-    fun appendFooter(to: StringBuilder)
-
-    companion object {
-        fun default(css: String? = null): HtmlTemplateService {
-            return object : HtmlTemplateService {
-                override fun appendFooter(to: StringBuilder) {
-                    if (!to.endsWith('\n')) {
-                        to.append('\n')
-                    }
-                    to.appendln("</BODY>")
-                    to.appendln("</HTML>")
-                }
-                override fun appendHeader(to: StringBuilder, title: String?, basePath: File) {
-                    to.appendln("<HTML>")
-                    to.appendln("<HEAD>")
-                    to.appendln("<meta charset=\"UTF-8\">")
-                    if (title != null) {
-                        to.appendln("<title>$title</title>")
-                    }
-                    if (css != null) {
-                        val cssPath = basePath.resolve(css).toUnixString()
-                        to.appendln("<link rel=\"stylesheet\" href=\"$cssPath\">")
-                    }
-                    to.appendln("</HEAD>")
-                    to.appendln("<BODY>")
-                }
-            }
-        }
-    }
-}
-
-
diff --git a/core/src/main/kotlin/Formats/JavaLayoutHtml/JavaLayoutHtmlPackageListService.kt b/core/src/main/kotlin/Formats/JavaLayoutHtml/JavaLayoutHtmlPackageListService.kt
deleted file mode 100644
index 09bb2602..00000000
--- a/core/src/main/kotlin/Formats/JavaLayoutHtml/JavaLayoutHtmlPackageListService.kt
+++ /dev/null
@@ -1,117 +0,0 @@
-package org.jetbrains.dokka.Formats
-
-import org.jetbrains.dokka.*
-import org.jetbrains.dokka.ExternalDocumentationLinkResolver.Companion.DOKKA_PARAM_PREFIX
-import org.jetbrains.kotlin.descriptors.*
-import org.jetbrains.kotlin.descriptors.impl.EnumEntrySyntheticClassDescriptor
-import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameUnsafe
-import org.jetbrains.kotlin.resolve.descriptorUtil.isCompanionObject
-import org.jetbrains.kotlin.types.KotlinType
-
-class JavaLayoutHtmlPackageListService: PackageListService {
-
-    private fun StringBuilder.appendParam(name: String, value: String) {
-        append(DOKKA_PARAM_PREFIX)
-        append(name)
-        append(":")
-        appendln(value)
-    }
-
-    override fun formatPackageList(module: DocumentationModule): String {
-        val packages = module.members(NodeKind.Package).map { it.name }
-
-        return buildString {
-            appendParam("format", "java-layout-html")
-            appendParam("mode", "kotlin")
-            for (p in packages) {
-                appendln(p)
-            }
-        }
-    }
-
-}
-
-class JavaLayoutHtmlInboundLinkResolutionService(private val paramMap: Map<String, List<String>>) : InboundExternalLinkResolutionService {
-    private fun getContainerPath(symbol: DeclarationDescriptor): String? {
-        return when (symbol) {
-            is PackageFragmentDescriptor -> symbol.fqName.asString().replace('.', '/') + "/"
-            is ClassifierDescriptor -> getContainerPath(symbol.findPackage()) + symbol.nameWithOuter() + ".html"
-            else -> null
-        }
-    }
-
-    private fun DeclarationDescriptor.findPackage(): PackageFragmentDescriptor =
-        generateSequence(this) { it.containingDeclaration }.filterIsInstance<PackageFragmentDescriptor>().first()
-
-    private fun ClassifierDescriptor.nameWithOuter(): String =
-        generateSequence(this) { it.containingDeclaration as? ClassifierDescriptor }
-            .toList().asReversed().joinToString(".") { it.name.asString() }
-
-    private fun getPagePath(symbol: DeclarationDescriptor): String? {
-        return when (symbol) {
-            is PackageFragmentDescriptor -> getContainerPath(symbol) + "package-summary.html"
-            is EnumEntrySyntheticClassDescriptor -> getContainerPath(symbol.containingDeclaration) + "#" + symbol.signatureForAnchorUrlEncoded()
-            is ClassifierDescriptor -> getContainerPath(symbol) + "#"
-            is FunctionDescriptor, is PropertyDescriptor -> getContainerPath(symbol.containingDeclaration!!) + "#" + symbol.signatureForAnchorUrlEncoded()
-            else -> null
-        }
-    }
-
-    private fun DeclarationDescriptor.signatureForAnchor(): String? {
-
-        fun ReceiverParameterDescriptor.extractReceiverName(): String {
-            var receiverClass: DeclarationDescriptor = type.constructor.declarationDescriptor!!
-            if (receiverClass.isCompanionObject()) {
-                receiverClass = receiverClass.containingDeclaration!!
-            } else if (receiverClass is TypeParameterDescriptor) {
-                val upperBoundClass = receiverClass.upperBounds.singleOrNull()?.constructor?.declarationDescriptor
-                if (upperBoundClass != null) {
-                    receiverClass = upperBoundClass
-                }
-            }
-
-            return receiverClass.name.asString()
-        }
-
-        fun KotlinType.qualifiedNameForSignature(): String {
-            val desc = constructor.declarationDescriptor
-            return desc?.fqNameUnsafe?.asString() ?: "<ERROR TYPE NAME>"
-        }
-
-        fun StringBuilder.appendReceiverAndCompanion(desc: CallableDescriptor) {
-            if (desc.containingDeclaration.isCompanionObject()) {
-                append("Companion.")
-            }
-            desc.extensionReceiverParameter?.let {
-                append("(")
-                append(it.extractReceiverName())
-                append(").")
-            }
-        }
-
-        return when(this) {
-            is EnumEntrySyntheticClassDescriptor -> buildString {
-                append("ENUM_VALUE:")
-                append(name.asString())
-            }
-            is FunctionDescriptor -> buildString {
-                appendReceiverAndCompanion(this@signatureForAnchor)
-                append(name.asString())
-                valueParameters.joinTo(this, prefix = "(", postfix = ")") {
-                    it.type.qualifiedNameForSignature()
-                }
-            }
-            is PropertyDescriptor -> buildString {
-                appendReceiverAndCompanion(this@signatureForAnchor)
-                append(name.asString())
-                append(":")
-                append(returnType?.qualifiedNameForSignature())
-            }
-            else -> null
-        }
-    }
-
-    private fun DeclarationDescriptor.signatureForAnchorUrlEncoded(): String? = signatureForAnchor()?.urlEncoded()
-
-    override fun getPath(symbol: DeclarationDescriptor) = getPagePath(symbol)
-}
\ No newline at end of file
diff --git a/core/src/main/kotlin/Formats/JavaLayoutHtmlFormat.kt b/core/src/main/kotlin/Formats/JavaLayoutHtmlFormat.kt
deleted file mode 100644
index 885cdf6c..00000000
--- a/core/src/main/kotlin/Formats/JavaLayoutHtmlFormat.kt
+++ /dev/null
@@ -1,91 +0,0 @@
-package org.jetbrains.dokka.Formats
-
-import com.google.inject.Binder
-import com.google.inject.Inject
-import kotlinx.html.li
-import kotlinx.html.stream.appendHTML
-import kotlinx.html.ul
-import org.jetbrains.dokka.*
-import org.jetbrains.dokka.Samples.DefaultSampleProcessingService
-import org.jetbrains.dokka.Utilities.bind
-import org.jetbrains.dokka.Utilities.toType
-import java.io.File
-
-
-class JavaLayoutHtmlFormatDescriptor : FormatDescriptor, DefaultAnalysisComponent {
-    override val packageDocumentationBuilderClass = KotlinPackageDocumentationBuilder::class
-    override val javaDocumentationBuilderClass = KotlinJavaDocumentationBuilder::class
-    override val sampleProcessingService = DefaultSampleProcessingService::class
-    override val elementSignatureProvider = KotlinElementSignatureProvider::class
-
-    override fun configureOutput(binder: Binder): Unit = with(binder) {
-        bind<Generator>() toType generatorServiceClass
-    }
-
-    val formatServiceClass = JavaLayoutHtmlFormatService::class
-    val generatorServiceClass = JavaLayoutHtmlFormatGenerator::class
-}
-
-
-class JavaLayoutHtmlFormatService : FormatService {
-    override val extension: String
-        get() = TODO("not implemented")
-
-
-    override fun createOutputBuilder(to: StringBuilder, location: Location): FormattedOutputBuilder {
-        TODO("not implemented")
-    }
-}
-
-class JavaLayoutHtmlFormatOutputBuilder : FormattedOutputBuilder {
-    override fun appendNodes(nodes: Iterable<DocumentationNode>) {
-
-    }
-}
-
-
-class JavaLayoutHtmlFormatNavListBuilder @Inject constructor() : OutlineFormatService {
-    override fun getOutlineFileName(location: Location): File {
-        TODO()
-    }
-
-    override fun appendOutlineHeader(location: Location, node: DocumentationNode, to: StringBuilder) {
-        with(to.appendHTML()) {
-            //a(href = )
-            li {
-                when {
-                    node.kind == NodeKind.Package -> appendOutline(location, to, node.members)
-                }
-            }
-        }
-    }
-
-    override fun appendOutlineLevel(to: StringBuilder, body: () -> Unit) {
-        with(to.appendHTML()) {
-            ul { body() }
-        }
-    }
-
-}
-
-class JavaLayoutHtmlFormatGenerator @Inject constructor(
-        private val outlineFormatService: OutlineFormatService
-) : Generator {
-    override fun buildPages(nodes: Iterable<DocumentationNode>) {
-
-    }
-
-    override fun buildOutlines(nodes: Iterable<DocumentationNode>) {
-        for (node in nodes) {
-            if (node.kind == NodeKind.Module) {
-                //outlineFormatService.formatOutline()
-            }
-        }
-    }
-
-    override fun buildSupportFiles() {}
-
-    override fun buildPackageList(nodes: Iterable<DocumentationNode>) {
-
-    }
-}
\ No newline at end of file
diff --git a/core/src/main/kotlin/Formats/JekyllFormatService.kt b/core/src/main/kotlin/Formats/JekyllFormatService.kt
deleted file mode 100644
index a948dfa9..00000000
--- a/core/src/main/kotlin/Formats/JekyllFormatService.kt
+++ /dev/null
@@ -1,44 +0,0 @@
-package org.jetbrains.dokka
-
-import com.google.inject.Inject
-import com.google.inject.name.Named
-import org.jetbrains.dokka.Utilities.impliedPlatformsName
-
-open class JekyllOutputBuilder(to: StringBuilder,
-                               location: Location,
-                               generator: NodeLocationAwareGenerator,
-                               languageService: LanguageService,
-                               extension: String,
-                               impliedPlatforms: List<String>)
-    : MarkdownOutputBuilder(to, location, generator, languageService, extension, impliedPlatforms) {
-    override fun appendNodes(nodes: Iterable<DocumentationNode>) {
-        to.appendln("---")
-        appendFrontMatter(nodes, to)
-        to.appendln("---")
-        to.appendln("")
-        super.appendNodes(nodes)
-    }
-
-    protected open fun appendFrontMatter(nodes: Iterable<DocumentationNode>, to: StringBuilder) {
-        to.appendln("title: ${getPageTitle(nodes)}")
-    }
-}
-
-
-open class JekyllFormatService(
-        generator: NodeLocationAwareGenerator,
-        signatureGenerator: LanguageService,
-        linkExtension: String,
-        impliedPlatforms: List<String>
-) : MarkdownFormatService(generator, signatureGenerator, linkExtension, impliedPlatforms) {
-
-    @Inject constructor(
-            generator: NodeLocationAwareGenerator,
-            signatureGenerator: LanguageService,
-            @Named(impliedPlatformsName) impliedPlatforms: List<String>
-    ) : this(generator, signatureGenerator, "html", impliedPlatforms)
-
-    override fun createOutputBuilder(to: StringBuilder, location: Location): FormattedOutputBuilder =
-            JekyllOutputBuilder(to, location, generator, languageService, extension, impliedPlatforms)
-
-}
diff --git a/core/src/main/kotlin/Formats/KotlinWebsiteHtmlFormatService.kt b/core/src/main/kotlin/Formats/KotlinWebsiteHtmlFormatService.kt
deleted file mode 100644
index 3cdea156..00000000
--- a/core/src/main/kotlin/Formats/KotlinWebsiteHtmlFormatService.kt
+++ /dev/null
@@ -1,264 +0,0 @@
-pac