Refactoring, replace DocumentationOption with PassConfiguration

3 files changed, 70 insertions, 63 deletions

diff --git a/core/src/main/kotlin/Generation/DokkaGenerator.kt b/core/src/main/kotlin/Generation/DokkaGenerator.kt
index 0c4b3b7e..2e46d908 100644
--- a/core/src/main/kotlin/Generation/DokkaGenerator.kt
+++ b/core/src/main/kotlin/Generation/DokkaGenerator.kt
@@ -2,13 +2,11 @@ package org.jetbrains.dokka
 
 import com.google.inject.Guice
 import com.google.inject.Injector
-import com.intellij.openapi.application.PathManager
 import com.intellij.openapi.util.Disposer
 import com.intellij.openapi.vfs.VirtualFileManager
 import com.intellij.psi.PsiFile
 import com.intellij.psi.PsiJavaFile
 import com.intellij.psi.PsiManager
-import org.jetbrains.dokka.DokkaConfiguration.SourceRoot
 import org.jetbrains.dokka.Utilities.DokkaAnalysisModule
 import org.jetbrains.dokka.Utilities.DokkaOutputModule
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageLocation
@@ -18,7 +16,6 @@ import org.jetbrains.kotlin.cli.common.messages.MessageRenderer
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.cli.jvm.config.JavaSourceRoot
 import org.jetbrains.kotlin.config.JVMConfigurationKeys
-import org.jetbrains.kotlin.config.KotlinSourceRoot
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzer
 import org.jetbrains.kotlin.resolve.TopDownAnalysisMode
@@ -26,56 +23,49 @@ import org.jetbrains.kotlin.utils.PathUtil
 import java.io.File
 import kotlin.system.measureTimeMillis
 
-class DokkaGenerator(val logger: DokkaLogger,
-                     val classpath: List<String>,
-                     val sources: List<SourceRoot>,
-                     val samples: List<String>,
-                     val includes: List<String>,
-                     val moduleName: String,
-                     val options: DocumentationOptions) {
+class DokkaGenerator(val dokkaConfiguration: DokkaConfiguration,
+                     val logger: DokkaLogger) {
 
     private val documentationModules: MutableList<DocumentationModule> = mutableListOf()
 
-    fun generate() {
-        val sourcesGroupedByPlatform = sources.groupBy { it.platforms.firstOrNull() to it.analysisPlatform }
-        for ((platformsInfo, roots) in sourcesGroupedByPlatform) {
-            val (platform, analysisPlatform) = platformsInfo
 
-            val documentationModule = DocumentationModule(moduleName)
-            appendSourceModule(platform, analysisPlatform, roots, documentationModule)
+    fun generate() = with(dokkaConfiguration) {
+
+
+        for (pass in passesConfigurations) {
+            val documentationModule = DocumentationModule(pass.moduleName)
+            appendSourceModule(pass, documentationModule)
             documentationModules.add(documentationModule)
         }
 
         val totalDocumentationModule = DocumentationMerger(documentationModules).merge()
-        totalDocumentationModule.prepareForGeneration(options)
+        totalDocumentationModule.prepareForGeneration(dokkaConfiguration)
 
         val timeBuild = measureTimeMillis {
             logger.info("Generating pages... ")
-            val outputInjector = Guice.createInjector(DokkaOutputModule(options, logger))
+            val outputInjector = Guice.createInjector(DokkaOutputModule(dokkaConfiguration, logger))
             outputInjector.getInstance(Generator::class.java).buildAll(totalDocumentationModule)
         }
         logger.info("done in ${timeBuild / 1000} secs")
     }
 
     private fun appendSourceModule(
-        defaultPlatform: String?,
-        analysisPlatform: Platform,
-        sourceRoots: List<SourceRoot>,
+        passConfiguration: DokkaConfiguration.PassConfiguration,
         documentationModule: DocumentationModule
-    ) {
+    ) = with(passConfiguration) {
 
-        val sourcePaths = sourceRoots.map { it.path }
-        val environment = createAnalysisEnvironment(sourcePaths, analysisPlatform)
+        val sourcePaths = passConfiguration.sourceRoots.map { it.path }
+        val environment = createAnalysisEnvironment(sourcePaths, passConfiguration)
 
         logger.info("Module: $moduleName")
-        logger.info("Output: ${File(options.outputDir)}")
+        logger.info("Output: ${File(dokkaConfiguration.outputDir)}")
         logger.info("Sources: ${sourcePaths.joinToString()}")
         logger.info("Classpath: ${environment.classpath.joinToString()}")
 
         logger.info("Analysing sources and libraries... ")
         val startAnalyse = System.currentTimeMillis()
 
-        val defaultPlatformAsList = defaultPlatform?.let { listOf(it) }.orEmpty()
+        val defaultPlatformAsList =  listOf(passConfiguration.analysisPlatform.key)
         val defaultPlatformsProvider = object : DefaultPlatformsProvider {
             override fun getDefaultPlatforms(descriptor: DeclarationDescriptor): List<String> {
                 val containingFilePath = descriptor.sourcePsi()?.containingFile?.virtualFile?.canonicalPath
@@ -86,9 +76,9 @@ class DokkaGenerator(val logger: DokkaLogger,
         }
 
         val injector = Guice.createInjector(
-                DokkaAnalysisModule(environment, options, defaultPlatformsProvider, documentationModule.nodeRefGraph, logger))
+                DokkaAnalysisModule(environment, dokkaConfiguration, defaultPlatformsProvider, documentationModule.nodeRefGraph, passConfiguration, logger))
 
-        buildDocumentationModule(injector, documentationModule, { isNotSample(it) }, includes)
+        buildDocumentationModule(injector, documentationModule, { isNotSample(it, passConfiguration.samples) }, includes)
         documentationModule.nodeRefGraph.nodeMapView.forEach { (_, node) ->
             node.addReferenceTo(
                 DocumentationNode(analysisPlatform.key, Content.Empty, NodeKind.Platform),
@@ -102,28 +92,28 @@ class DokkaGenerator(val logger: DokkaLogger,
         Disposer.dispose(environment)
     }
 
-    fun createAnalysisEnvironment(sourcePaths: List<String>, analysisPlatform: Platform): AnalysisEnvironment {
-        val environment = AnalysisEnvironment(DokkaMessageCollector(logger), analysisPlatform)
+   fun createAnalysisEnvironment(sourcePaths: List<String>, passConfiguration: DokkaConfiguration.PassConfiguration): AnalysisEnvironment {
+        val environment = AnalysisEnvironment(DokkaMessageCollector(logger), passConfiguration.analysisPlatform)
 
         environment.apply {
             if (analysisPlatform == Platform.jvm) {
                 addClasspath(PathUtil.getJdkClassesRootsFromCurrentJre())
             }
             //   addClasspath(PathUtil.getKotlinPathsForCompiler().getRuntimePath())
-            for (element in this@DokkaGenerator.classpath) {
+            for (element in passConfiguration.classpath) {
                 addClasspath(File(element))
             }
 
             addSources(sourcePaths)
-            addSources(this@DokkaGenerator.samples)
+            addSources(passConfiguration.samples)
 
-            loadLanguageVersionSettings(options.languageVersion, options.apiVersion)
+            loadLanguageVersionSettings(passConfiguration.languageVersion, passConfiguration.apiVersion)
         }
 
         return environment
     }
 
-    fun isNotSample(file: PsiFile): Boolean {
+   fun isNotSample(file: PsiFile, samples: List<String>): Boolean {
         val sourceFile = File(file.virtualFile!!.path)
         return samples.none { sample ->
             val canonicalSample = File(sample).canonicalPath
diff --git a/core/src/main/kotlin/Generation/FileGenerator.kt b/core/src/main/kotlin/Generation/FileGenerator.kt
index b7c6cf63..eb6800b3 100644
--- a/core/src/main/kotlin/Generation/FileGenerator.kt
+++ b/core/src/main/kotlin/Generation/FileGenerator.kt
@@ -2,7 +2,6 @@ package org.jetbrains.dokka
 
 import com.google.inject.Inject
 import com.google.inject.name.Named
-import org.jetbrains.kotlin.utils.fileUtils.withReplacedExtensionOrNull
 import java.io.File
 import java.io.FileOutputStream
 import java.io.IOException
@@ -12,7 +11,7 @@ class FileGenerator @Inject constructor(@Named("outputDir") override val root: F
 
     @set:Inject(optional = true) var outlineService: OutlineFormatService? = null
     @set:Inject(optional = true) lateinit var formatService: FormatService
-    @set:Inject(optional = true) lateinit var options: DocumentationOptions
+    @set:Inject(optional = true) lateinit var dokkaConfiguration: DokkaConfiguration
     @set:Inject(optional = true) var packageListService: PackageListService? = null
 
     override fun location(node: DocumentationNode): FileLocation {
@@ -74,7 +73,7 @@ class FileGenerator @Inject constructor(@Named("outputDir") override val root: F
             val moduleRoot = location(module).file.parentFile
             val packageListFile = File(moduleRoot, "package-list")
 
-            packageListFile.writeText("\$dokka.format:${options.outputFormat}\n" +
+            packageListFile.writeText("\$dokka.format:${dokkaConfiguration.format}\n" +
                     packageListService!!.formatPackageList(module as DocumentationModule))
         }
 
diff --git a/core/src/main/kotlin/Generation/configurationImpl.kt b/core/src/main/kotlin/Generation/configurationImpl.kt
index 8829682a..3e39b4ed 100644
--- a/core/src/main/kotlin/Generation/configurationImpl.kt
+++ b/core/src/main/kotlin/Generation/configurationImpl.kt
@@ -45,29 +45,47 @@ data class PackageOptionsImpl(override val prefix: String,
                               override val suppress: Boolean = false) : DokkaConfiguration.PackageOptions
 
 data class DokkaConfigurationImpl(
-    override val moduleName: String,
-    override val classpath: List<String>,
-    override val sourceRoots: List<SourceRootImpl>,
-    override val samples: List<String>,
-    override val includes: List<String>,
-    override val outputDir: String,
-    override val format: String,
-    override val includeNonPublic: Boolean,
-    override val includeRootPackage: Boolean,
-    override val reportUndocumented: Boolean,
-    override val skipEmptyPackages: Boolean,
-    override val skipDeprecated: Boolean,
-    override val jdkVersion: Int,
-    override val generateIndexPages: Boolean,
-    override val sourceLinks: List<SourceLinkDefinitionImpl>,
-    override val impliedPlatforms: List<String>,
-    override val perPackageOptions: List<PackageOptionsImpl>,
-    override val externalDocumentationLinks: List<ExternalDocumentationLinkImpl>,
-    override val noStdlibLink: Boolean,
-    override val noJdkLink: Boolean,
-    override val cacheRoot: String?,
-    override val suppressedFiles: List<String>,
-    override val languageVersion: String?,
-    override val apiVersion: String?,
-    override val collectInheritedExtensionsFromLibraries: Boolean
-) : DokkaConfiguration
\ No newline at end of file
+    override val outputDir: String = "",
+    override val format: String = "html",
+    override val generateIndexPages: Boolean = false,
+    override val cacheRoot: String? = null,
+    override val impliedPlatforms: List<String> = listOf(),
+    override val passesConfigurations: List<DokkaConfiguration.PassConfiguration> = listOf()
+) : DokkaConfiguration
+
+class PassConfigurationImpl (
+    override val classpath: List<String> = listOf(),
+    override val moduleName: String = "",
+    override val sourceRoots: List<SourceRoot> = listOf(),
+    override val samples: List<String> = listOf(),
+    override val includes: List<String> = listOf(),
+    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<SourceLinkDefinition> = listOf(),
+    override val perPackageOptions: List<DokkaConfiguration.PackageOptions> = listOf(),
+    externalDocumentationLinks: List<DokkaConfiguration.ExternalDocumentationLink> = listOf(),
+    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> = listOf(),
+    override val collectInheritedExtensionsFromLibraries: Boolean = false,
+    override val analysisPlatform: Platform = Platform.DEFAULT,
+    override val targets: List<String> = listOf()
+): DokkaConfiguration.PassConfiguration {
+    private val defaultLinks = run {
+        val links = mutableListOf<DokkaConfiguration.ExternalDocumentationLink>()
+        if (!noJdkLink)
+            links += DokkaConfiguration.ExternalDocumentationLink.Builder("http://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
+}
+