Simplify Gradle Plugin

.run/it-basic_dokka.run.xml

@@ -4,7 +4,7 @@
       <option name="executionName" />
       <option name="externalProjectPath" value="$PROJECT_DIR$/integration-tests/gradle/projects/it-basic" />
       <option name="externalSystemIdString" value="GRADLE" />
-      <option name="scriptParameters" value="" />
+      <option name="scriptParameters" value="--configuration-cache" />
       <option name="taskDescriptions">
         <list />
       </option>

core/src/main/kotlin/DokkaBootstrapImpl.kt

@@ -70,38 +70,8 @@ class DokkaBootstrapImpl : DokkaBootstrap {
 
     private lateinit var generator: DokkaGenerator
 
-    fun configure(logger: DokkaLogger, configuration: DokkaConfigurationImpl) = with(configuration) {
-
-        fun defaultLinks(config: DokkaSourceSetImpl): List<ExternalDocumentationLinkImpl> {
-            val links = mutableListOf<ExternalDocumentationLinkImpl>()
-            if (!config.noJdkLink) {
-                val javadocLink =
-                    if (config.jdkVersion < 11) "https://docs.oracle.com/javase/${config.jdkVersion}/docs/api/"
-                    else "https://docs.oracle.com/en/java/javase/${config.jdkVersion}/docs/api/java.base/"
-                val packageListLink =
-                    if (config.jdkVersion < 11) "${javadocLink}/package-list"
-                    else "https://docs.oracle.com/en/java/javase/${config.jdkVersion}/docs/api/element-list"
-                links += DokkaConfiguration.ExternalDocumentationLink
-                    .Builder(javadocLink, packageListLink)
-                    .build() as ExternalDocumentationLinkImpl
-            }
-
-            if (!config.noStdlibLink)
-                links += DokkaConfiguration.ExternalDocumentationLink
-                    .Builder("https://kotlinlang.org/api/latest/jvm/stdlib/")
-                    .build() as ExternalDocumentationLinkImpl
-            return links
-        }
-
-        val configurationWithLinks = configuration.copy(
-            sourceSets = sourceSets.map {
-                val links: List<ExternalDocumentationLinkImpl> =
-                    it.externalDocumentationLinks + defaultLinks(it)
-                it.copy(externalDocumentationLinks = links)
-            }
-        )
-
-        generator = DokkaGenerator(configurationWithLinks, logger)
+    fun configure(logger: DokkaLogger, configuration: DokkaConfigurationImpl) {
+        generator = DokkaGenerator(configuration, logger)
     }
 
     override fun configure(serializedConfigurationJSON: String, logger: BiConsumer<String, String>) = configure(

core/src/main/kotlin/configuration.kt

@@ -2,21 +2,20 @@
 
 package org.jetbrains.dokka
 
-import org.jetbrains.dokka.utilities.toJsonString
 import org.jetbrains.dokka.utilities.parseJson
+import org.jetbrains.dokka.utilities.toJsonString
 import java.io.File
 import java.io.Serializable
 import java.net.URL
 
 object DokkaDefaults {
-    const val outputDir = "./dokka"
+    val outputDir = File("./dokka")
     const val format: String = "html"
-    val cacheRoot: String? = null
+    val cacheRoot: File? = null
     const val offlineMode: Boolean = false
     const val failOnWarning: Boolean = false
 
     const val includeNonPublic: Boolean = false
-    const val includeRootPackage: Boolean = false
     const val reportUndocumented: Boolean = false
     const val skipEmptyPackages: Boolean = true
     const val skipDeprecated: Boolean = false
@@ -45,12 +44,20 @@ enum class Platform(val key: String) {
                 js.key -> js
                 native.key -> native
                 common.key -> common
+                "androidjvm", "android" -> jvm
+                "metadata" -> common
                 else -> throw IllegalArgumentException("Unrecognized platform: $key")
             }
         }
     }
 }
 
+interface DokkaConfigurationBuilder<T : Any> {
+    fun build(): T
+}
+
+fun <T : Any> Iterable<DokkaConfigurationBuilder<T>>.build(): List<T> = this.map { it.build() }
+
 data class DokkaSourceSetID(
     val moduleName: String,
     val sourceSetName: String
@@ -65,8 +72,8 @@ fun DokkaConfigurationImpl(json: String): DokkaConfigurationImpl = parseJson(jso
 fun DokkaConfiguration.toJsonString(): String = toJsonString(this)
 
 interface DokkaConfiguration : Serializable {
-    val outputDir: String
-    val cacheRoot: String?
+    val outputDir: File
+    val cacheRoot: File?
     val offlineMode: Boolean
     val failOnWarning: Boolean
     val sourceSets: List<DokkaSourceSet>
@@ -78,42 +85,37 @@ interface DokkaConfiguration : Serializable {
         val sourceSetID: DokkaSourceSetID
         val displayName: String
         val moduleDisplayName: String
-        val classpath: List<String>
-        val sourceRoots: List<SourceRoot>
+        val classpath: List<File>
+        val sourceRoots: Set<File>
         val dependentSourceSets: Set<DokkaSourceSetID>
-        val samples: List<String>
-        val includes: List<String>
+        val samples: Set<File>
+        val includes: Set<File>
         val includeNonPublic: Boolean
-        val includeRootPackage: Boolean
         val reportUndocumented: Boolean
         val skipEmptyPackages: Boolean
         val skipDeprecated: Boolean
         val jdkVersion: Int
-        val sourceLinks: List<SourceLinkDefinition>
+        val sourceLinks: Set<SourceLinkDefinition>
         val perPackageOptions: List<PackageOptions>
-        val externalDocumentationLinks: List<ExternalDocumentationLink>
+        val externalDocumentationLinks: Set<ExternalDocumentationLink>
         val languageVersion: String?
         val apiVersion: String?
         val noStdlibLink: Boolean
         val noJdkLink: Boolean
-        val suppressedFiles: List<String>
+        val suppressedFiles: Set<File>
         val analysisPlatform: Platform
     }
 
-    interface SourceRoot : Serializable {
-        val path: String
-    }
-
     interface SourceLinkDefinition : Serializable {
-        val path: String
-        val url: String
-        val lineSuffix: String?
+        val localDirectory: String
+        val remoteUrl: URL
+        val remoteLineSuffix: String?
     }
 
     interface DokkaModuleDescription : Serializable {
         val name: String
-        val path: String
-        val docFile: String
+        val path: File
+        val docFile: File
     }
 
     interface PackageOptions : Serializable {
@@ -128,22 +130,26 @@ interface DokkaConfiguration : Serializable {
         val url: URL
         val packageListUrl: URL
 
-        open class Builder(
-            open var url: URL? = null,
-            open var packageListUrl: URL? = null
-        ) {
-
-            constructor(root: String, packageList: String? = null) : this(URL(root), packageList?.let { URL(it) })
-
-            fun build(): ExternalDocumentationLink =
-                if (packageListUrl != null && url != null)
-                    ExternalDocumentationLinkImpl(url!!, packageListUrl!!)
-                else if (url != null)
-                    ExternalDocumentationLinkImpl(url!!, URL(url!!, "package-list"))
-                else
-                    throw IllegalArgumentException("url or url && packageListUrl must not be null for external documentation link")
-        }
+        companion object
     }
 }
 
+fun ExternalDocumentationLink(
+    url: URL? = null,
+    packageListUrl: URL? = null
+): ExternalDocumentationLinkImpl {
+    return if (packageListUrl != null && url != null)
+        ExternalDocumentationLinkImpl(url, packageListUrl)
+    else if (url != null)
+        ExternalDocumentationLinkImpl(url, URL(url, "package-list"))
+    else
+        throw IllegalArgumentException("url or url && packageListUrl must not be null for external documentation link")
+}
+
+
+fun ExternalDocumentationLink(
+    url: String, packageListUrl: String? = null
+): ExternalDocumentationLinkImpl =
+    ExternalDocumentationLink(url.let(::URL), packageListUrl?.let(::URL))
+
 

core/src/main/kotlin/defaultConfiguration.kt

@@ -5,8 +5,8 @@ import java.io.File
 import java.net.URL
 
 data class DokkaConfigurationImpl(
-    override val outputDir: String = DokkaDefaults.outputDir,
-    override val cacheRoot: String? = DokkaDefaults.cacheRoot,
+    override val outputDir: File = DokkaDefaults.outputDir,
+    override val cacheRoot: File? = DokkaDefaults.cacheRoot,
     override val offlineMode: Boolean = DokkaDefaults.offlineMode,
     override val sourceSets: List<DokkaSourceSetImpl> = emptyList(),
     override val pluginsClasspath: List<File> = emptyList(),
@@ -15,53 +15,49 @@ data class DokkaConfigurationImpl(
     override val failOnWarning: Boolean = DokkaDefaults.failOnWarning
 ) : DokkaConfiguration
 
+
 data class DokkaSourceSetImpl(
     override val moduleDisplayName: String,
     override val displayName: String = DokkaDefaults.sourceSetDisplayName,
     override val sourceSetID: DokkaSourceSetID,
-    override val classpath: List<String> = emptyList(),
-    override val sourceRoots: List<SourceRootImpl>,
+    override val classpath: List<File> = emptyList(),
+    override val sourceRoots: Set<File> = emptySet(),
     override val dependentSourceSets: Set<DokkaSourceSetID> = emptySet(),
-    override val samples: List<String> = emptyList(),
-    override val includes: List<String> = emptyList(),
+    override val samples: Set<File> = emptySet(),
+    override val includes: Set<File> = emptySet(),
     override val includeNonPublic: Boolean = DokkaDefaults.includeNonPublic,
-    override val includeRootPackage: Boolean = DokkaDefaults.includeRootPackage,
     override val reportUndocumented: Boolean = DokkaDefaults.reportUndocumented,
     override val skipEmptyPackages: Boolean = DokkaDefaults.skipEmptyPackages,
     override val skipDeprecated: Boolean = DokkaDefaults.skipDeprecated,
     override val jdkVersion: Int = DokkaDefaults.jdkVersion,
-    override val sourceLinks: List<SourceLinkDefinitionImpl> = emptyList(),
+    override val sourceLinks: Set<SourceLinkDefinitionImpl> = emptySet(),
     override val perPackageOptions: List<PackageOptionsImpl> = emptyList(),
-    override var externalDocumentationLinks: List<ExternalDocumentationLinkImpl> = emptyList(),
+    override val externalDocumentationLinks: Set<ExternalDocumentationLinkImpl> = emptySet(),
     override val languageVersion: String? = null,
     override val apiVersion: String? = null,
     override val noStdlibLink: Boolean = DokkaDefaults.noStdlibLink,
     override val noJdkLink: Boolean = DokkaDefaults.noJdkLink,
-    override val suppressedFiles: List<String> = emptyList(),
+    override val suppressedFiles: Set<File> = emptySet(),
     override val analysisPlatform: Platform = DokkaDefaults.analysisPlatform
 ) : DokkaSourceSet
 
 data class DokkaModuleDescriptionImpl(
     override val name: String,
-    override val path: String,
-    override val docFile: String
+    override val path: File,
+    override val docFile: File
 ) : DokkaConfiguration.DokkaModuleDescription
 
-data class SourceRootImpl(
-    override val path: String
-) : DokkaConfiguration.SourceRoot
-
 data class SourceLinkDefinitionImpl(
-    override val path: String,
-    override val url: String,
-    override val lineSuffix: String?
+    override val localDirectory: String,
+    override val remoteUrl: URL,
+    override val remoteLineSuffix: String?
 ) : DokkaConfiguration.SourceLinkDefinition {
     companion object {
         fun parseSourceLinkDefinition(srcLink: String): SourceLinkDefinitionImpl {
             val (path, urlAndLine) = srcLink.split('=')
             return SourceLinkDefinitionImpl(
                 File(path).canonicalPath,
-                urlAndLine.substringBefore("#"),
+                URL(urlAndLine.substringBefore("#")),
                 urlAndLine.substringAfter("#", "").let { if (it.isEmpty()) null else "#$it" })
         }
     }

core/src/main/kotlin/defaultExternalLinks.kt

@@ -0,0 +1,30 @@
+package org.jetbrains.dokka
+
+import org.jetbrains.dokka.DokkaConfiguration.ExternalDocumentationLink
+import java.net.URL
+
+
+fun ExternalDocumentationLink.Companion.jdk(jdkVersion: Int): ExternalDocumentationLinkImpl =
+    ExternalDocumentationLink(
+        url =
+        if (jdkVersion < 11) "https://docs.oracle.com/javase/${jdkVersion}/docs/api/"
+        else "https://docs.oracle.com/en/java/javase/${jdkVersion}/docs/api/java.base/",
+        packageListUrl =
+        if (jdkVersion < 11) "https://docs.oracle.com/javase/${jdkVersion}/docs/api/package-list"
+        else "https://docs.oracle.com/en/java/javase/${jdkVersion}/docs/api/element-list"
+    )
+
+
+fun ExternalDocumentationLink.Companion.kotlinStdlib(): ExternalDocumentationLinkImpl =
+    ExternalDocumentationLink("https://kotlinlang.org/api/latest/jvm/stdlib/")
+
+
+fun ExternalDocumentationLink.Companion.androidSdk(): ExternalDocumentationLinkImpl =
+    ExternalDocumentationLink("https://developer.android.com/reference/")
+
+
+fun ExternalDocumentationLink.Companion.androidX(): ExternalDocumentationLinkImpl = ExternalDocumentationLink(
+    url = URL("https://developer.android.com/reference/kotlin/"),
+    packageListUrl = URL("https://developer.android.com/reference/androidx/package-list")
+)
+

core/src/main/kotlin/utilities/json.kt

@@ -1,26 +1,18 @@
 package org.jetbrains.dokka.utilities
 
 import com.fasterxml.jackson.core.JsonGenerator
-import com.fasterxml.jackson.core.JsonParser
-import com.fasterxml.jackson.databind.DeserializationContext
 import com.fasterxml.jackson.databind.DeserializationFeature
 import com.fasterxml.jackson.databind.SerializerProvider
-import com.fasterxml.jackson.databind.deser.std.StdScalarDeserializer
 import com.fasterxml.jackson.databind.module.SimpleModule
 import com.fasterxml.jackson.databind.ser.std.StdScalarSerializer
 import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
 import com.fasterxml.jackson.module.kotlin.jacksonTypeRef
-import org.jetbrains.dokka.DokkaConfiguration.SourceRoot
-import org.jetbrains.dokka.SourceRootImpl
 import java.io.File
 import com.fasterxml.jackson.core.type.TypeReference as JacksonTypeReference
 
 private val objectMapper = run {
     val module = SimpleModule().apply {
         addSerializer(FileSerializer)
-        addSerializer(SourceRoot::class.java, SourceRootSerializer)
-        addDeserializer(SourceRootImpl::class.java, SourceRootImplDeserializer)
-        addDeserializer(SourceRoot::class.java, SourceRootImplDeserializer)
     }
     jacksonObjectMapper()
         .registerModule(module)
@@ -53,13 +45,3 @@ private object FileSerializer : StdScalarSerializer<File>(File::class.java) {
         g.writeString(value.path)
     }
 }
-
-private object SourceRootSerializer : StdScalarSerializer<SourceRoot>(SourceRoot::class.java) {
-    override fun serialize(value: SourceRoot, g: JsonGenerator, provider: SerializerProvider) {
-        g.writeString(value.path)
-    }
-}
-
-private object SourceRootImplDeserializer : StdScalarDeserializer<SourceRootImpl>(SourceRootImpl::class.java) {
-    override fun deserialize(p: JsonParser, ctxt: DeserializationContext): SourceRootImpl = SourceRootImpl(p.text)
-}

core/src/test/kotlin/utilities/DokkaConfigurationJsonTest.kt

@@ -9,12 +9,12 @@ class DokkaConfigurationJsonTest {
     @Test
     fun `simple configuration toJsonString then parseJson`() {
         val configuration = DokkaConfigurationImpl(
-            outputDir = "customOutputDir",
+            outputDir = File("customOutputDir"),
             pluginsClasspath = listOf(File("plugins/customPlugin.jar")),
             sourceSets = listOf(
                 DokkaSourceSetImpl(
                     moduleDisplayName = "customModuleDisplayName",
-                    sourceRoots = listOf(SourceRootImpl("customSourceRoot")),
+                    sourceRoots = setOf(File("customSourceRoot")),
                     sourceSetID = DokkaSourceSetID("customModuleName", "customSourceSetName")
                 )
             )
@@ -48,14 +48,14 @@ class DokkaConfigurationJsonTest {
         val parsedConfiguration = DokkaConfigurationImpl(json)
         assertEquals(
             DokkaConfigurationImpl(
-                outputDir = "customOutputDir",
+                outputDir = File("customOutputDir"),
                 pluginsClasspath = listOf(File("plugins/customPlugin.jar")),
                 sourceSets = listOf(
                     DokkaSourceSetImpl(
                         moduleDisplayName = "customModuleDisplayName",
-                        sourceRoots = listOf(SourceRootImpl("customSourceRoot")),
+                        sourceRoots = setOf(File("customSourceRoot")),
                         sourceSetID = DokkaSourceSetID("customModuleName", "customSourceSetName"),
-                        classpath = listOf("classpath/custom1.jar", "classpath/custom2.jar")
+                        classpath = listOf(File("classpath/custom1.jar"), File("classpath/custom2.jar"))
                     )
                 )
             ),

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,6 @@
+#Tue Jul 21 13:56:13 CEST 2020
+distributionUrl=https\://services.gradle.org/distributions/gradle-6.5.1-all.zip
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-6.5.1-bin.zip
-zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
+zipStoreBase=GRADLE_USER_HOME