aboutsummaryrefslogtreecommitdiff
path: root/core
diff options
context:
space:
mode:
Diffstat (limited to 'core')
-rw-r--r--core/build.gradle1
-rw-r--r--core/src/main/kotlin/DokkaGenerator.kt17
-rw-r--r--core/src/test/kotlin/multiplatform/BasicMultiplatformTest.kt2
-rw-r--r--core/src/test/kotlin/testRunner/DokkaTestGenerator.kt41
-rw-r--r--core/src/test/kotlin/testRunner/TestRunner.kt206
-rw-r--r--core/testApi/build.gradle6
-rw-r--r--core/testApi/src/main/kotlin/testApi/DokkaConfigurationTestImplementations.kt81
-rw-r--r--core/testApi/src/main/kotlin/testApi/TestAPI.kt353
8 files changed, 10 insertions, 697 deletions
diff --git a/core/build.gradle b/core/build.gradle
index 23e2ff24..31833cf9 100644
--- a/core/build.gradle
+++ b/core/build.gradle
@@ -21,6 +21,7 @@ allprojects {
}
dependencies {
+ testCompile project(':testApi')
compile project(":integration")
compile project(path: ":coreDependencies", configuration: "shadow")
diff --git a/core/src/main/kotlin/DokkaGenerator.kt b/core/src/main/kotlin/DokkaGenerator.kt
index 06de6c27..036cbfda 100644
--- a/core/src/main/kotlin/DokkaGenerator.kt
+++ b/core/src/main/kotlin/DokkaGenerator.kt
@@ -7,7 +7,6 @@ import org.jetbrains.dokka.pages.ModulePageNode
import org.jetbrains.dokka.pages.PlatformData
import org.jetbrains.dokka.plugability.DokkaContext
import org.jetbrains.dokka.plugability.single
-import org.jetbrains.dokka.renderers.FileWriter
import org.jetbrains.dokka.utilities.DokkaLogger
import org.jetbrains.kotlin.cli.common.messages.CompilerMessageLocation
import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity
@@ -51,43 +50,43 @@ class DokkaGenerator(
render(transformedPages, context)
}
- internal fun setUpAnalysis(configuration: DokkaConfiguration): Map<PlatformData, EnvironmentAndFacade> =
+ fun setUpAnalysis(configuration: DokkaConfiguration): Map<PlatformData, EnvironmentAndFacade> =
configuration.passesConfigurations.map {
PlatformData(it.moduleName, it.analysisPlatform, it.targets) to createEnvironmentAndFacade(it)
}.toMap()
- internal fun initializePlugins(
+ fun initializePlugins(
configuration: DokkaConfiguration,
logger: DokkaLogger,
platforms: Map<PlatformData, EnvironmentAndFacade>
) = DokkaContext.create(configuration, logger, platforms)
- internal fun createDocumentationModels(
+ fun createDocumentationModels(
platforms: Map<PlatformData, EnvironmentAndFacade>,
context: DokkaContext
) = platforms.map { (pdata, _) -> translateDescriptors(pdata, context) }
- internal fun mergeDocumentationModels(
+ fun mergeDocumentationModels(
modulesFromPlatforms: List<Module>,
context: DokkaContext
) = context.single(CoreExtensions.documentationMerger).invoke(modulesFromPlatforms, context)
- internal fun transformDocumentationModel(
+ fun transformDocumentationModel(
documentationModel: Module,
context: DokkaContext
) = context[CoreExtensions.documentationTransformer].fold(documentationModel) { acc, t -> t(acc, context) }
- internal fun createPages(
+ fun createPages(
transformedDocumentation: Module,
context: DokkaContext
) = context.single(CoreExtensions.documentationToPageTranslator).invoke(transformedDocumentation, context)
- internal fun transformPages(
+ fun transformPages(
pages: ModulePageNode,
context: DokkaContext
) = context[CoreExtensions.pageTransformer].fold(pages) { acc, t -> t(acc, context) }
- internal fun render(
+ fun render(
transformedPages: ModulePageNode,
context: DokkaContext
) {
diff --git a/core/src/test/kotlin/multiplatform/BasicMultiplatformTest.kt b/core/src/test/kotlin/multiplatform/BasicMultiplatformTest.kt
index da5103c2..ad165cdb 100644
--- a/core/src/test/kotlin/multiplatform/BasicMultiplatformTest.kt
+++ b/core/src/test/kotlin/multiplatform/BasicMultiplatformTest.kt
@@ -1,7 +1,7 @@
package multiplatform
import org.junit.Test
-import testRunner.AbstractCoreTest
+import testApi.testRunner.AbstractCoreTest
import kotlin.test.assertEquals
class BasicMultiplatformTest : AbstractCoreTest() {
diff --git a/core/src/test/kotlin/testRunner/DokkaTestGenerator.kt b/core/src/test/kotlin/testRunner/DokkaTestGenerator.kt
deleted file mode 100644
index 840ab10e..00000000
--- a/core/src/test/kotlin/testRunner/DokkaTestGenerator.kt
+++ /dev/null
@@ -1,41 +0,0 @@
-package testRunner
-
-import org.jetbrains.dokka.DokkaConfiguration
-import org.jetbrains.dokka.DokkaGenerator
-import org.jetbrains.dokka.EnvironmentAndFacade
-import org.jetbrains.dokka.pages.PlatformData
-import org.jetbrains.dokka.utilities.DokkaLogger
-
-internal class DokkaTestGenerator(
- private val configuration: DokkaConfiguration,
- private val logger: DokkaLogger,
- private val testMethods: TestMethods
-) {
-
- fun generate() = with(testMethods) {
- val dokkaGenerator = DokkaGenerator(configuration, logger)
-
- val platforms: Map<PlatformData, EnvironmentAndFacade> = dokkaGenerator.setUpAnalysis(configuration)
- analysisSetupStage(platforms)
-
- val context = dokkaGenerator.initializePlugins(configuration, logger, platforms)
- pluginsSetupStage(context)
-
- val modulesFromPlatforms = dokkaGenerator.createDocumentationModels(platforms, context)
- documentablesCreationStage(modulesFromPlatforms)
-
- val documentationModel = dokkaGenerator.mergeDocumentationModels(modulesFromPlatforms, context)
- documentablesMergingStage(documentationModel)
-
- val transformedDocumentation = dokkaGenerator.transformDocumentationModel(documentationModel, context)
- documentablesTransformationStage(transformedDocumentation)
-
- val pages = dokkaGenerator.createPages(transformedDocumentation, context)
- pagesGenerationStage(pages)
-
- val transformedPages = dokkaGenerator.transformPages(pages, context)
- pagesTransformationStage(transformedPages)
-
- dokkaGenerator.render(transformedPages, context)
- }
-} \ No newline at end of file
diff --git a/core/src/test/kotlin/testRunner/TestRunner.kt b/core/src/test/kotlin/testRunner/TestRunner.kt
deleted file mode 100644
index a2b0f96c..00000000
--- a/core/src/test/kotlin/testRunner/TestRunner.kt
+++ /dev/null
@@ -1,206 +0,0 @@
-package testRunner
-
-import org.jetbrains.dokka.*
-import org.jetbrains.dokka.model.Module
-import org.jetbrains.dokka.pages.ModulePageNode
-import org.jetbrains.dokka.pages.PlatformData
-import org.jetbrains.dokka.plugability.DokkaContext
-import org.jetbrains.dokka.utilities.DokkaConsoleLogger
-import org.junit.rules.TemporaryFolder
-import java.io.File
-import java.nio.charset.Charset
-import java.nio.file.Files
-import java.nio.file.InvalidPathException
-import java.nio.file.Path
-import java.nio.file.Paths
-
-// TODO: take dokka configuration from file
-abstract class AbstractCoreTest {
- protected val logger = DokkaConsoleLogger
-
- protected fun getTestDataDir(name: String) =
- File("src/test/resources/$name").takeIf { it.exists() }?.toPath()
- ?: throw InvalidPathException(name, "Cannot be found")
-
- protected fun testFromData(
- configuration: DokkaConfigurationImpl,
- cleanupOutput: Boolean = true,
- block: TestBuilder.() -> Unit
- ) {
- val testMethods = TestBuilder().apply(block).build()
- val tempDir = getTempDir(cleanupOutput)
- if (!cleanupOutput)
- logger.info("Output generated under: ${tempDir.root.absolutePath}")
- val newConfiguration =
- configuration.copy(
- outputDir = tempDir.root.toPath().toAbsolutePath().toString()
- )
- DokkaTestGenerator(newConfiguration, logger, testMethods).generate()
- }
-
- protected fun testInline(
- query: String,
- configuration: DokkaConfigurationImpl,
- cleanupOutput: Boolean = true,
- block: TestBuilder.() -> Unit
- ) {
- val testMethods = TestBuilder().apply(block).build()
- val testDirPath = getTempDir(cleanupOutput).root.toPath()
- val fileMap = query.toFileMap()
- fileMap.materializeFiles(testDirPath.toAbsolutePath())
- if (!cleanupOutput)
- logger.info("Output generated under: ${testDirPath.toAbsolutePath()}")
- val newConfiguration =
- configuration.copy(
- outputDir = testDirPath.toAbsolutePath().toString(),
- passesConfigurations = configuration.passesConfigurations
- .map { it.copy(sourceRoots = it.sourceRoots.map { it.copy(path = "${testDirPath.toAbsolutePath()}/${it.path}") }) }
- )
- DokkaTestGenerator(newConfiguration, logger, testMethods).generate()
- }
-
- private fun String.toFileMap(): Map<String, String> = this.replace("\r\n", "\n")
- .split("\n/")
- .map { fileString ->
- fileString.split("\n", limit = 2)
- .let {
- it.first().trim().removePrefix("/") to it.last().trim()
- }
- }.toMap()
-
- private fun Map<String, String>.materializeFiles(
- root: Path = Paths.get("."),
- charset: Charset = Charset.forName("utf-8")
- ) = this.map { (path, content) ->
- val file = root.resolve(path)
- Files.createDirectories(file.parent)
- Files.write(file, content.toByteArray(charset))
- }
-
- private fun getTempDir(cleanupOutput: Boolean) = if (cleanupOutput) {
- TemporaryFolder().apply { create() }
- } else {
- object : TemporaryFolder() {
- override fun after() {}
- }.apply { create() }
- }
-
- protected class TestBuilder {
- var analysisSetupStage: (Map<PlatformData, EnvironmentAndFacade>) -> Unit = {}
- var pluginsSetupStage: (DokkaContext) -> Unit = {}
- var documentablesCreationStage: (List<Module>) -> Unit = {}
- var documentablesMergingStage: (Module) -> Unit = {}
- var documentablesTransformationStage: (Module) -> Unit = {}
- var pagesGenerationStage: (ModulePageNode) -> Unit = {}
- var pagesTransformationStage: (ModulePageNode) -> Unit = {}
-
- fun build() = TestMethods(
- analysisSetupStage,
- pluginsSetupStage,
- documentablesCreationStage,
- documentablesMergingStage,
- documentablesTransformationStage,
- pagesGenerationStage,
- pagesTransformationStage
- )
- }
-
- protected fun dokkaConfiguration(block: DokkaConfigurationBuilder.() -> Unit): DokkaConfigurationImpl =
- DokkaConfigurationBuilder().apply(block).build()
-
- @DslMarker
- protected annotation class DokkaConfigurationDsl
-
- @DokkaConfigurationDsl
- protected class DokkaConfigurationBuilder {
- var outputDir: String = "out"
- var format: String = "html"
- var generateIndexPages: Boolean = true
- var cacheRoot: String? = null
- var pluginsClasspath: List<File> = emptyList()
- private val passesConfigurations = mutableListOf<PassConfigurationImpl>()
-
- fun build() = DokkaConfigurationImpl(
- outputDir = outputDir,
- format = format,
- generateIndexPages = generateIndexPages,
- cacheRoot = cacheRoot,
- impliedPlatforms = emptyList(),
- passesConfigurations = passesConfigurations,
- pluginsClasspath = pluginsClasspath
- )
-
- fun passes(block: Passes.() -> Unit) {
- passesConfigurations.addAll(Passes().apply(block))
- }
- }
-
- @DokkaConfigurationDsl
- protected class Passes : ArrayList<PassConfigurationImpl>() {
- fun pass(block: DokkaPassConfigurationBuilder.() -> Unit) =
- add(DokkaPassConfigurationBuilder().apply(block).build())
- }
-
- @DokkaConfigurationDsl
- protected class DokkaPassConfigurationBuilder(
- var moduleName: String = "root",
- var classpath: List<String> = emptyList(),
- var sourceRoots: List<String> = emptyList(),
- var samples: List<String> = emptyList(),
- var includes: List<String> = emptyList(),
- var includeNonPublic: Boolean = true,
- var includeRootPackage: Boolean = true,
- var reportUndocumented: Boolean = false,
- var skipEmptyPackages: Boolean = false,
- var skipDeprecated: Boolean = false,
- var jdkVersion: Int = 6,
- var languageVersion: String? = null,
- var apiVersion: String? = null,
- var noStdlibLink: Boolean = false,
- var noJdkLink: Boolean = false,
- var suppressedFiles: List<String> = emptyList(),
- var collectInheritedExtensionsFromLibraries: Boolean = true,
- var analysisPlatform: String = "jvm",
- var targets: List<String> = listOf("jvm"),
- var sinceKotlin: String? = null,
- var perPackageOptions: List<PackageOptionsImpl> = emptyList(),
- var externalDocumentationLinks: List<ExternalDocumentationLinkImpl> = emptyList(),
- var sourceLinks: List<SourceLinkDefinitionImpl> = emptyList()
- ) {
- fun build() = PassConfigurationImpl(
- moduleName = moduleName,
- classpath = classpath,
- sourceRoots = sourceRoots.map { SourceRootImpl(it) },
- samples = samples,
- includes = includes,
- includeNonPublic = includeNonPublic,
- includeRootPackage = includeRootPackage,
- reportUndocumented = reportUndocumented,
- skipEmptyPackages = skipEmptyPackages,
- skipDeprecated = skipDeprecated,
- jdkVersion = jdkVersion,
- languageVersion = languageVersion,
- apiVersion = apiVersion,
- noStdlibLink = noStdlibLink,
- noJdkLink = noJdkLink,
- suppressedFiles = suppressedFiles,
- collectInheritedExtensionsFromLibraries = collectInheritedExtensionsFromLibraries,
- analysisPlatform = Platform.fromString(analysisPlatform),
- targets = targets,
- sinceKotlin = sinceKotlin,
- perPackageOptions = perPackageOptions,
- externalDocumentationLinks = externalDocumentationLinks,
- sourceLinks = sourceLinks
- )
- }
-}
-
-data class TestMethods(
- val analysisSetupStage: (Map<PlatformData, EnvironmentAndFacade>) -> Unit,
- val pluginsSetupStage: (DokkaContext) -> Unit,
- val documentablesCreationStage: (List<Module>) -> Unit,
- val documentablesMergingStage: (Module) -> Unit,
- val documentablesTransformationStage: (Module) -> Unit,
- val pagesGenerationStage: (ModulePageNode) -> Unit,
- val pagesTransformationStage: (ModulePageNode) -> Unit
-) \ No newline at end of file
diff --git a/core/testApi/build.gradle b/core/testApi/build.gradle
deleted file mode 100644
index 82d0fd41..00000000
--- a/core/testApi/build.gradle
+++ /dev/null
@@ -1,6 +0,0 @@
-dependencies {
- compileOnly project(":core")
- implementation group: 'junit', name: 'junit', version: '4.12'
- implementation group: 'org.jetbrains.kotlin', name: 'kotlin-test-junit', version: kotlin_version
- implementation ideaRT()
-} \ No newline at end of file
diff --git a/core/testApi/src/main/kotlin/testApi/DokkaConfigurationTestImplementations.kt b/core/testApi/src/main/kotlin/testApi/DokkaConfigurationTestImplementations.kt
deleted file mode 100644
index 58356e27..00000000
--- a/core/testApi/src/main/kotlin/testApi/DokkaConfigurationTestImplementations.kt
+++ /dev/null
@@ -1,81 +0,0 @@
-package org.jetbrains.dokka.testApi
-
-import org.jetbrains.dokka.DokkaConfiguration
-import org.jetbrains.dokka.Platform
-import java.io.File
-
-
-data class SourceLinkDefinitionImpl(override val path: String,
- override val url: String,
- override val lineSuffix: String?) : DokkaConfiguration.SourceLinkDefinition {
- companion object {
- fun parseSourceLinkDefinition(srcLink: String): DokkaConfiguration.SourceLinkDefinition {
- val (path, urlAndLine) = srcLink.split('=')
- return SourceLinkDefinitionImpl(
- File(path).canonicalPath,
- urlAndLine.substringBefore("#"),
- urlAndLine.substringAfter("#", "").let { if (it.isEmpty()) null else "#$it" })
- }
- }
-}
-
-class SourceRootImpl(path: String) : DokkaConfiguration.SourceRoot {
- override val path: String = File(path).absolutePath
-
- companion object {
- fun parseSourceRoot(sourceRoot: String): DokkaConfiguration.SourceRoot = SourceRootImpl(sourceRoot)
- }
-}
-
-data class PackageOptionsImpl(override val prefix: String,
- override val includeNonPublic: Boolean = false,
- override val reportUndocumented: Boolean = true,
- override val skipDeprecated: Boolean = false,
- override val suppress: Boolean = false) : DokkaConfiguration.PackageOptions
-
- class DokkaConfigurationImpl(
- override val outputDir: String = "",
- override val format: String = "html",
- override val generateIndexPages: Boolean = false,
- override val cacheRoot: String? = null,
- override val impliedPlatforms: List<String> = emptyList(),
- override val passesConfigurations: List<DokkaConfiguration.PassConfiguration> = emptyList()
-) : DokkaConfiguration
-
-class PassConfigurationImpl (
- override val classpath: List<String> = emptyList(),
- override val moduleName: String = "",
- override val sourceRoots: List<DokkaConfiguration.SourceRoot> = emptyList(),
- override val samples: List<String> = emptyList(),
- override val includes: List<String> = emptyList(),
- override val includeNonPublic: Boolean = false,
- override val includeRootPackage: Boolean = false,
- override val reportUndocumented: Boolean = false,
- override val skipEmptyPackages: Boolean = false,
- override val skipDeprecated: Boolean = false,
- override val jdkVersion: Int = 6,
- override val sourceLinks: List<DokkaConfiguration.SourceLinkDefinition> = emptyList(),
- override val perPackageOptions: List<DokkaConfiguration.PackageOptions> = emptyList(),
- externalDocumentationLinks: List<DokkaConfiguration.ExternalDocumentationLink> = emptyList(),
- override val languageVersion: String? = null,
- override val apiVersion: String? = null,
- override val noStdlibLink: Boolean = false,
- override val noJdkLink: Boolean = false,
- override val suppressedFiles: List<String> = emptyList(),
- override val collectInheritedExtensionsFromLibraries: Boolean = false,
- override val analysisPlatform: Platform = Platform.DEFAULT,
- override val targets: List<String> = emptyList(),
- override val sinceKotlin: String? = null
-): DokkaConfiguration.PassConfiguration {
- private val defaultLinks = run {
- val links = mutableListOf<DokkaConfiguration.ExternalDocumentationLink>()
- if (!noJdkLink)
- links += DokkaConfiguration.ExternalDocumentationLink.Builder("https://docs.oracle.com/javase/$jdkVersion/docs/api/").build()
-
- if (!noStdlibLink)
- links += DokkaConfiguration.ExternalDocumentationLink.Builder("https://kotlinlang.org/api/latest/jvm/stdlib/").build()
- links
- }
- override val externalDocumentationLinks = defaultLinks + externalDocumentationLinks
-}
-
diff --git a/core/testApi/src/main/kotlin/testApi/TestAPI.kt b/core/testApi/src/main/kotlin/testApi/TestAPI.kt
deleted file mode 100644
index 7856591c..00000000
--- a/core/testApi/src/main/kotlin/testApi/TestAPI.kt
+++ /dev/null
@@ -1,353 +0,0 @@
-package org.jetbrains.dokka.testApi
-
-import com.google.inject.Guice
-import com.intellij.openapi.application.PathManager
-import com.intellij.openapi.util.Disposer
-import com.intellij.openapi.util.io.FileUtil
-import com.intellij.rt.execution.junit.FileComparisonFailure
-import org.jetbrains.dokka.*
-import org.jetbrains.dokka.Utilities.DokkaAnalysisModule
-import org.jetbrains.dokka.Utilities.DokkaRunModule
-import org.jetbrains.kotlin.cli.common.config.ContentRoot
-import org.jetbrains.kotlin.cli.common.config.KotlinSourceRoot
-import org.jetbrains.kotlin.cli.common.messages.CompilerMessageLocation
-import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity
-import org.jetbrains.kotlin.cli.common.messages.MessageCollector
-import org.jetbrains.kotlin.cli.jvm.config.JavaSourceRoot
-import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
-import org.jetbrains.kotlin.utils.PathUtil
-import org.junit.Assert
-import org.junit.Assert.fail
-import java.io.File
-
-data class ModelConfig(
- val roots: Array<ContentRoot> = arrayOf(),
- val withJdk: Boolean = false,
- val withKotlinRuntime: Boolean = false,
- val format: String = "html",
- val includeNonPublic: Boolean = true,
- val perPackageOptions: List<DokkaConfiguration.PackageOptions> = emptyList(),
- val analysisPlatform: Platform = Platform.DEFAULT,
- val defaultPlatforms: List<String> = emptyList(),
- val noStdlibLink: Boolean = true,
- val collectInheritedExtensionsFromLibraries: Boolean = false,
- val sourceLinks: List<DokkaConfiguration.SourceLinkDefinition> = emptyList()
-)
-
-fun verifyModel(
- modelConfig: ModelConfig,
- verifier: (DocumentationModule) -> Unit
-) {
- val documentation = DocumentationModule("test")
-
- val passConfiguration = PassConfigurationImpl(
- includeNonPublic = modelConfig.includeNonPublic,
- skipEmptyPackages = false,
- includeRootPackage = true,
- sourceLinks = modelConfig.sourceLinks,
- perPackageOptions = modelConfig.perPackageOptions,
- noStdlibLink = modelConfig.noStdlibLink,
- noJdkLink = false,
- languageVersion = null,
- apiVersion = null,
- collectInheritedExtensionsFromLibraries = modelConfig.collectInheritedExtensionsFromLibraries
- )
- val configuration = DokkaConfigurationImpl(
- outputDir = "",
- format = modelConfig.format,
- generateIndexPages = false,
- cacheRoot = "default",
- passesConfigurations = listOf(passConfiguration)
- )
-
- appendDocumentation(documentation, configuration, passConfiguration, modelConfig)
- documentation.prepareForGeneration(configuration)
-
- verifier(documentation)
-}
-
-fun appendDocumentation(
- documentation: DocumentationModule,
- dokkaConfiguration: DokkaConfiguration,
- passConfiguration: DokkaConfiguration.PassConfiguration,
- modelConfig: ModelConfig
-) {
- val messageCollector = object : MessageCollector {
- override fun clear() {
-
- }
-
- override fun report(severity: CompilerMessageSeverity, message: String, location: CompilerMessageLocation?) {
- when (severity) {
- CompilerMessageSeverity.STRONG_WARNING,
- CompilerMessageSeverity.WARNING,
- CompilerMessageSeverity.LOGGING,
- CompilerMessageSeverity.OUTPUT,
- CompilerMessageSeverity.INFO,
- CompilerMessageSeverity.ERROR -> {
- println("$severity: $message at $location")
- }
- CompilerMessageSeverity.EXCEPTION -> {
- fail("$severity: $message at $location")
- }
- }
- }
-
- override fun hasErrors() = false
- }
-
- val environment = AnalysisEnvironment(messageCollector, modelConfig.analysisPlatform)
- environment.apply {
- if (modelConfig.withJdk || modelConfig.withKotlinRuntime) {
- addClasspath(PathUtil.getJdkClassesRootsFromCurrentJre())
- }
- if (modelConfig.withKotlinRuntime) {
- if (analysisPlatform == Platform.jvm) {
- val kotlinStrictfpRoot = PathManager.getResourceRoot(Strictfp::class.java, "/kotlin/jvm/Strictfp.class")
- addClasspath(File(kotlinStrictfpRoot))
- }
- if (analysisPlatform == Platform.js) {
- val kotlinStdlibJsRoot = PathManager.getResourceRoot(Any::class.java, "/kotlin/jquery")
- addClasspath(File(kotlinStdlibJsRoot))
- }
-
- if (analysisPlatform == Platform.common) {
- // TODO: Feels hacky
- val kotlinStdlibCommonRoot = ClassLoader.getSystemResource("kotlin/UInt.kotlin_metadata")
- addClasspath(File(kotlinStdlibCommonRoot.file.replace("file:", "").replaceAfter(".jar", "")))
- }
- }
- addRoots(modelConfig.roots.toList())
-
- loadLanguageVersionSettings(passConfiguration.languageVersion, passConfiguration.apiVersion)
- }
- val defaultPlatformsProvider = object : DefaultPlatformsProvider {
- override fun getDefaultPlatforms(descriptor: DeclarationDescriptor) = modelConfig.defaultPlatforms
- }
-
- val globalInjector = Guice.createInjector(
- DokkaRunModule(dokkaConfiguration)
- )
-
- val injector = globalInjector.createChildInjector(
- DokkaAnalysisModule(
- environment,
- dokkaConfiguration,
- defaultPlatformsProvider,
- documentation.nodeRefGraph,
- passConfiguration,
- DokkaConsoleLogger
- )
- )
-
- buildDocumentationModule(injector, documentation)
- Disposer.dispose(environment)
-}
-
-fun checkSourceExistsAndVerifyModel(
- source: String,
- modelConfig: ModelConfig = ModelConfig(),
- verifier: (DocumentationModule) -> Unit
-) {
- require(File(source).exists()) {
- "Cannot find test data file $source"
- }
- verifyModel(
- ModelConfig(
- roots = arrayOf(contentRootFromPath(source)),
- withJdk = modelConfig.withJdk,
- withKotlinRuntime = modelConfig.withKotlinRuntime,
- format = modelConfig.format,
- includeNonPublic = modelConfig.includeNonPublic,
- sourceLinks = modelConfig.sourceLinks,
- analysisPlatform = modelConfig.analysisPlatform
- ),
-
- verifier = verifier
- )
-}
-
-fun verifyPackageMember(
- source: String,
- modelConfig: ModelConfig = ModelConfig(),
- verifier: (DocumentationNode) -> Unit
-) {
- checkSourceExistsAndVerifyModel(
- source,
- modelConfig = ModelConfig(
- withJdk = modelConfig.withJdk,
- withKotlinRuntime = modelConfig.withKotlinRuntime,
- analysisPlatform = modelConfig.analysisPlatform
- )
- ) { model ->
- val pkg = model.members.single()
- verifier(pkg.members.single())
- }
-}
-
-fun verifyJavaModel(
- source: String,
- modelConfig: ModelConfig = ModelConfig(),
- verifier: (DocumentationModule) -> Unit
-) {
- val tempDir = FileUtil.createTempDirectory("dokka", "")
- try {
- val sourceFile = File(source)
- FileUtil.copy(sourceFile, File(tempDir, sourceFile.name))
- verifyModel(
- ModelConfig(
- roots = arrayOf(JavaSourceRoot(tempDir, null)),
- withJdk = true,
- withKotlinRuntime = modelConfig.withKotlinRuntime,
- analysisPlatform = modelConfig.analysisPlatform
- ),
- verifier = verifier
- )
- } finally {
- FileUtil.delete(tempDir)
- }
-}
-
-fun verifyJavaPackageMember(
- source: String,
- modelConfig: ModelConfig = ModelConfig(),
- verifier: (DocumentationNode) -> Unit
-) {
- verifyJavaModel(source, modelConfig) { model ->
- val pkg = model.members.single()
- verifier(pkg.members.single())
- }
-}
-
-fun verifyOutput(
- modelConfig: ModelConfig = ModelConfig(),
- outputExtension: String,
- outputGenerator: (DocumentationModule, StringBuilder) -> Unit
-) {
- verifyModel(modelConfig) {
- verifyModelOutput(it, outputExtension, modelConfig.roots.first().path, outputGenerator)
- }
-}
-
-fun verifyOutput(
- path: String,
- outputExtension: String,
- modelConfig: ModelConfig = ModelConfig(),
- outputGenerator: (DocumentationModule, StringBuilder) -> Unit
-) {
- verifyOutput(
- ModelConfig(
- roots = arrayOf(contentRootFromPath(path)) + modelConfig.roots,
- withJdk = modelConfig.withJdk,
- withKotlinRuntime = modelConfig.withKotlinRuntime,
- format = modelConfig.format,
- includeNonPublic = modelConfig.includeNonPublic,
- analysisPlatform = modelConfig.analysisPlatform,
- noStdlibLink = modelConfig.noStdlibLink,
- collectInheritedExtensionsFromLibraries = modelConfig.collectInheritedExtensionsFromLibraries
- ),
- outputExtension,
- outputGenerator
- )
-}
-
-fun verifyModelOutput(
- it: DocumentationModule,
- outputExtension: String,
- sourcePath: String,
- outputGenerator: (DocumentationModule, StringBuilder) -> Unit
-) {
- val output = StringBuilder()
- outputGenerator(it, output)
- val ext = outputExtension.removePrefix(".")
- val expectedFile = File(sourcePath.replaceAfterLast(".", ext, sourcePath + "." + ext))
- assertEqualsIgnoringSeparators(expectedFile, output.toString())
-}
-
-fun verifyJavaOutput(
- path: String,
- outputExtension: String,
- modelConfig: ModelConfig = ModelConfig(),
- outputGenerator: (DocumentationModule, StringBuilder) -> Unit
-) {
- verifyJavaModel(path, modelConfig) { model ->
- verifyModelOutput(model, outputExtension, path, outputGenerator)
- }
-}
-
-fun assertEqualsIgnoringSeparators(expectedFile: File, output: String) {
- if (!expectedFile.exists()) expectedFile.createNewFile()
- val expectedText = expectedFile.readText().replace("\r\n", "\n")
- val actualText = output.replace("\r\n", "\n")
-
- if (expectedText != actualText)
- throw FileComparisonFailure("", expectedText, actualText, expectedFile.canonicalPath)
-}
-
-fun assertEqualsIgnoringSeparators(expectedOutput: String, output: String) {
- Assert.assertEquals(expectedOutput.replace("\r\n", "\n"), output.replace("\r\n", "\n"))
-}
-
-fun StringBuilder.appendChildren(node: ContentBlock): StringBuilder {
- for (child in node.children) {
- val childText = child.toTestString()
- append(childText)
- }
- return this
-}
-
-fun StringBuilder.appendNode(node: ContentNode): StringBuilder {
- when (node) {
- is ContentText -> {
- append(node.text)
- }
- is ContentEmphasis -> append("*").appendChildren(node).append("*")
- is ContentBlockCode -> {
- if (node.language.isNotBlank())
- appendln("[code lang=${node.language}]")
- else
- appendln("[code]")
- appendChildren(node)
- appendln()
- appendln("[/code]")
- }
- is ContentNodeLink -> {
- append("[")
- appendChildren(node)
- append(" -> ")
- append(node.node.toString())
- append("]")
- }
- is ContentBlock -> {
- appendChildren(node)
- }
- is NodeRenderContent -> {
- append("render(")
- append(node.node)
- append(",")
- append(node.mode)
- append(")")
- }
- is ContentSymbol -> {
- append(node.text)
- }
- is ContentEmpty -> { /* nothing */
- }
- else -> throw IllegalStateException("Don't know how to format node $node")
- }
- return this
-}
-
-fun ContentNode.toTestString(): String {
- val node = this
- return StringBuilder().apply {
- appendNode(node)
- }.toString()
-}
-
-val ContentRoot.path: String
- get() = when (this) {
- is KotlinSourceRoot -> path
- is JavaSourceRoot -> file.path
- else -> throw UnsupportedOperationException()
- }
generated by cgit (git 2.46.0) at 2024-11-23 20:46:19 +0000