Add type safe counterparts to Closure taking methods on DokkaTask

Signed-off-by: Paul Merlin <paul@gradle.com>

2 files changed, 72 insertions, 12 deletions

diff --git a/runners/gradle-integration-tests/testData/typeSafeConfiguration/build.gradle b/runners/gradle-integration-tests/testData/typeSafeConfiguration/build.gradle
index b5b09ff9..6cab34c8 100644
--- a/runners/gradle-integration-tests/testData/typeSafeConfiguration/build.gradle
+++ b/runners/gradle-integration-tests/testData/typeSafeConfiguration/build.gradle
@@ -46,6 +46,37 @@ def configureDokkaTypeSafely(Project project) {
             cacheRoot = null as String
             languageVersion = null as String
             apiVersion = null as String
+            kotlinTasks(new Callable<List<Object>>() {
+                @Override
+                List<Object> call() {
+                    return defaultKotlinTasks()
+                }
+            })
+            linkMapping(new Action<LinkMapping>() {
+                @Override
+                void execute(LinkMapping mapping) {
+                    mapping.dir = "some String"
+                    mapping.url = "some String"
+                }
+            })
+            sourceRoot(new Action<SourceRoot>() {
+                @Override
+                void execute(SourceRoot sourceRoot) {
+                    sourceRoot.path = "some String"
+                }
+            })
+            packageOptions(new Action<PackageOptions>() {
+                @Override
+                void execute(PackageOptions packageOptions) {
+                    packageOptions.prefix = "some String"
+                }
+            })
+            externalDocumentationLink(new Action<DokkaConfiguration.ExternalDocumentationLink.Builder>() {
+                @Override
+                void execute(DokkaConfiguration.ExternalDocumentationLink.Builder builder) {
+                    builder.url = uri("some URI").toURL()
+                }
+            })
         }
     }
 }
diff --git a/runners/gradle-plugin/src/main/kotlin/main.kt b/runners/gradle-plugin/src/main/kotlin/main.kt
index d3a341e0..9130a329 100644
--- a/runners/gradle-plugin/src/main/kotlin/main.kt
+++ b/runners/gradle-plugin/src/main/kotlin/main.kt
@@ -1,6 +1,7 @@
 package org.jetbrains.dokka.gradle
 
 import groovy.lang.Closure
+import org.gradle.api.Action
 import org.gradle.api.DefaultTask
 import org.gradle.api.Plugin
 import org.gradle.api.Project
@@ -147,14 +148,17 @@ open class DokkaTask : DefaultTask() {
     private var kotlinTasksConfigurator: () -> List<Any?>? = { defaultKotlinTasks() }
     private val kotlinTasks: List<Task> by lazy { extractKotlinCompileTasks() }
 
+    fun kotlinTasks(taskSupplier: Callable<List<Any>>) {
+        kotlinTasksConfigurator = { taskSupplier.call() }
+    }
+
     fun kotlinTasks(closure: Closure<Any?>) {
         kotlinTasksConfigurator = { closure.call() as? List<Any?> }
     }
 
-    fun linkMapping(closure: Closure<Unit>) {
+    fun linkMapping(action: Action<LinkMapping>) {
         val mapping = LinkMapping()
-        closure.delegate = mapping
-        closure.call()
+        action.execute(mapping)
 
         if (mapping.path.isEmpty()) {
             throw IllegalArgumentException("Link mapping should have dir")
@@ -166,27 +170,52 @@ open class DokkaTask : DefaultTask() {
         linkMappings.add(mapping)
     }
 
-    fun sourceRoot(closure: Closure<Unit>) {
+    fun linkMapping(closure: Closure<Unit>) {
+        linkMapping(Action { mapping ->
+            closure.delegate = mapping
+            closure.call()
+        })
+    }
+
+    fun sourceRoot(action: Action<SourceRoot>) {
         val sourceRoot = SourceRoot()
-        closure.delegate = sourceRoot
-        closure.call()
+        action.execute(sourceRoot)
         sourceRoots.add(sourceRoot)
     }
 
-    fun packageOptions(closure: Closure<Unit>) {
+    fun sourceRoot(closure: Closure<Unit>) {
+        sourceRoot(Action { sourceRoot ->
+            closure.delegate = sourceRoot
+            closure.call()
+        })
+    }
+
+    fun packageOptions(action: Action<PackageOptions>) {
         val packageOptions = PackageOptions()
-        closure.delegate = packageOptions
-        closure.call()
+        action.execute(packageOptions)
         perPackageOptions.add(packageOptions)
     }
 
-    fun externalDocumentationLink(closure: Closure<Unit>) {
+    fun packageOptions(closure: Closure<Unit>) {
+        packageOptions(Action { packageOptions ->
+            closure.delegate = packageOptions
+            closure.call()
+        })
+    }
+
+    fun externalDocumentationLink(action: Action<DokkaConfiguration.ExternalDocumentationLink.Builder>) {
         val builder = DokkaConfiguration.ExternalDocumentationLink.Builder()
-        closure.delegate = builder
-        closure.call()
+        action.execute(builder)
         externalDocumentationLinks.add(builder.build())
     }
 
+    fun externalDocumentationLink(closure: Closure<Unit>) {
+        externalDocumentationLink(Action { builder ->
+            closure.delegate = builder
+            closure.call()
+        })
+    }
+
     fun tryResolveFatJar(project: Project): File {
         return try {
             val dependency = project.buildscript.dependencies.create(dokkaFatJar)