Merge "Revert "Generate Javadoc with Dokka"" into androidx-master-dev

3 files changed, 60 insertions, 135 deletions

diff --git a/buildSrc/src/main/kotlin/androidx/build/dokka/Dokka.kt b/buildSrc/src/main/kotlin/androidx/build/dokka/Dokka.kt
index 9c930476035..f43a945d5e3 100644
--- a/buildSrc/src/main/kotlin/androidx/build/dokka/Dokka.kt
+++ b/buildSrc/src/main/kotlin/androidx/build/dokka/Dokka.kt
@@ -33,11 +33,9 @@ import org.jetbrains.dokka.gradle.PackageOptions
 import java.io.File
 
 object Dokka {
-    fun generatorTaskNameForType(docsType: String, language: String = ""): String {
-        val formattedLangauage = language.toLowerCase().capitalize()
-        return "dokka${formattedLangauage}${docsType}Docs"
+    fun generatorTaskNameForType(docsType: String): String {
+        return "dokka${docsType}Docs"
     }
-
     fun archiveTaskNameForType(docsType: String): String {
         return "dist${docsType}DokkaDocs"
     }
@@ -46,6 +44,7 @@ object Dokka {
         project: Project,
         hiddenPackages: List<String>
     ) {
+        val taskName = generatorTaskNameForType(docsType)
         val archiveTaskName = archiveTaskNameForType(docsType)
         project.apply<DokkaAndroidPlugin>()
         // We don't use the `dokka` task, but it normally appears in `./gradlew tasks`
@@ -54,71 +53,40 @@ object Dokka {
         if (project.name != "support" && project.name != "docs-runner") {
             throw Exception("Illegal project passed to createDocsTask: " + project.name)
         }
-
-        val kotlinDocsTask = createDokkaTask(project,
-            docsType,
-            hiddenPackages,
-            "Kotlin",
-            "dac",
-            "/reference/kotlin")
-        val javaDocsTask = createDokkaTask(project,
-            docsType,
-            hiddenPackages,
-            "Java",
-            "dac-as-java",
-            "/reference/")
-
-        project.tasks.create(archiveTaskName, Zip::class.java) { zipTask ->
-            zipTask.dependsOn(javaDocsTask)
-            zipTask.from(javaDocsTask.outputDirectory) { copySpec ->
-                copySpec.into("reference/java")
+        val docsTask = project.tasks.create(taskName, DokkaAndroidTask::class.java) { docsTask ->
+            docsTask.moduleName = project.name
+            docsTask.outputDirectory = File(project.buildDir, taskName).absolutePath
+            docsTask.description = "Generates $docsType Kotlin documentation in the style of " +
+                    "d.android.com.  Places docs in ${docsTask.outputDirectory}"
+            docsTask.outputFormat = "dac"
+            docsTask.outlineRoot = "androidx/"
+            docsTask.dacRoot = "/reference/kotlin"
+            docsTask.moduleName = ""
+            for (hiddenPackage in hiddenPackages) {
+                val opts = PackageOptions()
+                opts.prefix = hiddenPackage
+                opts.suppress = true
+                docsTask.perPackageOptions.add(opts)
             }
+        }
 
-            zipTask.dependsOn(kotlinDocsTask)
-            zipTask.from(kotlinDocsTask.outputDirectory) { copySpec ->
+        project.tasks.create(archiveTaskName, Zip::class.java) { zipTask ->
+            zipTask.dependsOn(docsTask)
+            zipTask.from(docsTask.outputDirectory) { copySpec ->
                 copySpec.into("reference/kotlin")
             }
-
             val buildId = getBuildId()
-            val archiveBaseName = generatorTaskNameForType(docsType)
-            zipTask.archiveBaseName.set(archiveBaseName)
+            zipTask.archiveBaseName.set(taskName)
             zipTask.archiveVersion.set(buildId)
             zipTask.destinationDirectory.set(project.getDistributionDirectory())
             val filePath = "${project.getDistributionDirectory().canonicalPath}/"
-            val fileName = "$archiveBaseName-$buildId.zip"
-            zipTask.description = "Zips $docsType documentation (generated via " +
+            val fileName = "$taskName-$buildId.zip"
+            zipTask.description = "Zips $docsType Kotlin documentation (generated via " +
                 "Dokka in the style of d.android.com) into ${filePath + fileName}"
             zipTask.group = JavaBasePlugin.DOCUMENTATION_GROUP
         }
     }
 
-    private fun createDokkaTask(
-        project: Project,
-        docsType: String,
-        hiddenPackages: List<String>,
-        language: String,
-        outputFormat: String,
-        dacRoot: String
-    ): DokkaAndroidTask {
-        val docTaskName = generatorTaskNameForType(docsType, language)
-        return project.tasks.create(docTaskName, DokkaAndroidTask::class.java) { task ->
-            task.moduleName = project.name
-            task.outputDirectory = File(project.buildDir, docTaskName).absolutePath
-            task.description = "Generates $docsType $language documentation in the style of " +
-                    "d.android.com.  Places docs in ${task.outputDirectory}"
-            task.outputFormat = outputFormat
-            task.outlineRoot = "androidx/"
-            task.dacRoot = dacRoot
-            task.moduleName = ""
-            for (hiddenPackage in hiddenPackages) {
-                val opts = PackageOptions()
-                opts.prefix = hiddenPackage
-                opts.suppress = true
-                task.perPackageOptions.add(opts)
-            }
-        }
-    }
-
     fun Project.configureAndroidProjectForDokka(
         library: LibraryExtension,
         extension: AndroidXExtension
diff --git a/buildSrc/src/main/kotlin/androidx/build/dokka/DokkaPublicDocs.kt b/buildSrc/src/main/kotlin/androidx/build/dokka/DokkaPublicDocs.kt
index 928461bb705..c313a711551 100644
--- a/buildSrc/src/main/kotlin/androidx/build/dokka/DokkaPublicDocs.kt
+++ b/buildSrc/src/main/kotlin/androidx/build/dokka/DokkaPublicDocs.kt
@@ -30,14 +30,13 @@ import org.gradle.api.DefaultTask
 import org.gradle.api.Project
 import org.gradle.api.tasks.TaskAction
 import org.gradle.api.tasks.Copy
-import org.gradle.api.tasks.TaskCollection
 import org.gradle.api.tasks.TaskContainer
 import org.gradle.api.tasks.util.PatternFilterable
 import org.jetbrains.dokka.gradle.DokkaTask
 
 object DokkaPublicDocs {
-    private const val DOCS_TYPE = "Public"
-    val ARCHIVE_TASK_NAME: String = Dokka.archiveTaskNameForType(DOCS_TYPE)
+    val ARCHIVE_TASK_NAME: String = Dokka.archiveTaskNameForType("Public")
+    private val RUNNER_TASK_NAME = Dokka.generatorTaskNameForType("Public")
     private const val UNZIP_DEPS_TASK_NAME = "unzipDokkaPublicDocsDeps"
 
     val hiddenPackages = listOf(
@@ -57,8 +56,6 @@ object DokkaPublicDocs {
         "androidx.work.impl.utils.futures",
         "androidx.work.impl.utils.taskexecutor")
 
-    private var docsTasks: TaskCollection<DokkaTask>? = null
-
     fun tryGetRunnerProject(project: Project): Project? {
         return project.rootProject.findProject(":docs-runner")
     }
@@ -67,52 +64,34 @@ object DokkaPublicDocs {
         return tryGetRunnerProject(project)!!
     }
 
-    fun getDocsTasks(project: Project): TaskCollection<DokkaTask>? {
-        docsTasks?.let {
-            return it
-        }
+    fun getDocsTask(project: Project): DokkaTask {
         val runnerProject = getRunnerProject(project)
-        docsTasks = runnerProject.tasks.getOrCreateDocsTask(runnerProject)
-        return docsTasks
+        return runnerProject.tasks.getOrCreateDocsTask(runnerProject)
     }
 
     fun getUnzipDepsTask(project: Project): LocateJarsTask {
         val runnerProject = getRunnerProject(project)
-        return runnerProject.tasks.getByName(UNZIP_DEPS_TASK_NAME) as LocateJarsTask
+        return runnerProject.tasks.getByName(DokkaPublicDocs.UNZIP_DEPS_TASK_NAME) as LocateJarsTask
     }
 
-    @Synchronized fun TaskContainer.getOrCreateDocsTask(runnerProject: Project):
-            TaskCollection<DokkaTask> {
+    @Synchronized fun TaskContainer.getOrCreateDocsTask(runnerProject: Project): DokkaTask {
         val tasks = this
-        var dokkaTasks = runnerProject.tasks.withType(DokkaTask::class.java)
-            .matching { it.name.contains(DOCS_TYPE) }
-        if (dokkaTasks.isEmpty()) {
-            Dokka.createDocsTask(
-                DOCS_TYPE,
+        if (tasks.findByName(RUNNER_TASK_NAME) == null) {
+            Dokka.createDocsTask("Public",
                 runnerProject,
                 hiddenPackages)
-
-            dokkaTasks = runnerProject.tasks.withType(DokkaTask::class.java)
-                .matching { it.name.contains(DOCS_TYPE) }
-
+            val docsTask = runnerProject.tasks.getByName(RUNNER_TASK_NAME) as DokkaTask
             tasks.create(UNZIP_DEPS_TASK_NAME, LocateJarsTask::class.java) { unzipTask ->
                 unzipTask.doLast {
                     for (jar in unzipTask.outputJars) {
-                        dokkaTasks.forEach {
-                            it.classpath += runnerProject.file(jar)
-                        }
-                    }
-                    dokkaTasks.forEach {
-                        it.classpath += androidJarFile(runnerProject)
+                        docsTask.classpath = docsTask.classpath.plus(runnerProject.file(jar))
                     }
+                    docsTask.classpath += androidJarFile(runnerProject)
                 }
-
-                dokkaTasks.forEach {
-                    it.dependsOn(unzipTask)
-                }
+                docsTask.dependsOn(unzipTask)
             }
         }
-        return dokkaTasks
+        return runnerProject.tasks.getByName(DokkaPublicDocs.RUNNER_TASK_NAME) as DokkaTask
     }
 
     // specifies that <project> exists and might need us to generate documentation for it
@@ -141,16 +120,13 @@ object DokkaPublicDocs {
 
     // specifies that <dependency> describes an artifact containing sources that we want to include in our generated documentation
     private fun registerPrebuilt(dependency: String, runnerProject: Project): Copy {
-        val dokkaTasks = getDocsTasks(runnerProject)
+        val docsTask = getDocsTask(runnerProject)
 
         // unzip the sources jar
         val unzipTask = getPrebuiltSources(runnerProject, "$dependency:sources")
         val sourceDir = unzipTask.destinationDir
-
-        dokkaTasks?.forEach {
-            it.dependsOn(unzipTask)
-            it.sourceDirs += sourceDir
-        }
+        docsTask.dependsOn(unzipTask)
+        docsTask.sourceDirs += sourceDir
 
         // also make a note to unzip any dependencies too
         getUnzipDepsTask(runnerProject).inputDependencies.add(dependency)
@@ -198,14 +174,11 @@ object DokkaPublicDocs {
     }
 
     private fun registerInputs(inputs: JavaCompileInputs, project: Project) {
-        val dokkaTasks = getDocsTasks(project)
-
-        dokkaTasks?.forEach {
-            it.sourceDirs += inputs.sourcePaths
-            it.classpath = it.classpath.plus(inputs.dependencyClasspath)
-                .plus(inputs.bootClasspath)
-            it.dependsOn(inputs.dependencyClasspath)
-        }
+        val docsTask = getDocsTask(project)
+        docsTask.sourceDirs += inputs.sourcePaths
+        docsTask.classpath = docsTask.classpath.plus(inputs.dependencyClasspath)
+            .plus(inputs.bootClasspath)
+        docsTask.dependsOn(inputs.dependencyClasspath)
     }
 }
 
diff --git a/buildSrc/src/main/kotlin/androidx/build/dokka/DokkaSourceDocs.kt b/buildSrc/src/main/kotlin/androidx/build/dokka/DokkaSourceDocs.kt
index 3745603f679..beffe9fe90a 100644
--- a/buildSrc/src/main/kotlin/androidx/build/dokka/DokkaSourceDocs.kt
+++ b/buildSrc/src/main/kotlin/androidx/build/dokka/DokkaSourceDocs.kt
@@ -24,19 +24,17 @@ import androidx.build.Release
 import com.android.build.gradle.LibraryExtension
 import org.gradle.api.Project
 import org.gradle.api.plugins.JavaPluginConvention
-import org.gradle.api.tasks.TaskCollection
 import org.gradle.api.tasks.TaskContainer
 import org.gradle.kotlin.dsl.getPlugin
 import org.jetbrains.dokka.gradle.DokkaTask
 
 object DokkaSourceDocs {
-    private const val DOCS_TYPE = "TipOfTree"
-    public val ARCHIVE_TASK_NAME: String = Dokka.archiveTaskNameForType(DOCS_TYPE)
+    private val RUNNER_TASK_NAME = Dokka.generatorTaskNameForType("TipOfTree")
+    public val ARCHIVE_TASK_NAME: String = Dokka.archiveTaskNameForType("TipOfTree")
     // TODO(b/72330103) make "generateDocs" be the only archive task once Doclava is fully removed
     private val ALTERNATE_ARCHIVE_TASK_NAME: String = "generateDocs"
 
     private val hiddenPackages = DokkaPublicDocs.hiddenPackages
-    private var docsTasks: TaskCollection<DokkaTask>? = null
 
     fun tryGetRunnerProject(project: Project): Project? {
         return project.rootProject.findProject(":docs-runner")
@@ -46,33 +44,22 @@ object DokkaSourceDocs {
         return tryGetRunnerProject(project)!!
     }
 
-    fun getDocsTasks(project: Project): TaskCollection<DokkaTask>? {
-        docsTasks?.let {
-            return it
-        }
-        val runnerProject = getRunnerProject(project)
-        docsTasks = runnerProject.tasks.getOrCreateDocsTask(runnerProject)
-        return docsTasks
+    fun getDocsTask(project: Project): DokkaTask {
+        var runnerProject = getRunnerProject(project)
+        return runnerProject.tasks.getOrCreateDocsTask(runnerProject)
     }
 
-    @Synchronized fun TaskContainer.getOrCreateDocsTask(runnerProject: Project):
-            TaskCollection<DokkaTask> {
+    @Synchronized fun TaskContainer.getOrCreateDocsTask(runnerProject: Project): DokkaTask {
         val tasks = this
-        var dokkaTasks = runnerProject.tasks.withType(DokkaTask::class.java)
-            .matching { it.name.contains(DOCS_TYPE) }
-
-        if (dokkaTasks.isEmpty()) {
-            Dokka.createDocsTask(DOCS_TYPE, runnerProject, hiddenPackages)
-            dokkaTasks = runnerProject.tasks.withType(DokkaTask::class.java)
-                .matching { it.name.contains(DOCS_TYPE) }
-
-            if (tasks.findByName(ALTERNATE_ARCHIVE_TASK_NAME) == null) {
+        if (tasks.findByName(DokkaSourceDocs.RUNNER_TASK_NAME) == null) {
+            Dokka.createDocsTask("TipOfTree", runnerProject, hiddenPackages)
+            if (tasks.findByName(DokkaSourceDocs.ALTERNATE_ARCHIVE_TASK_NAME) == null) {
                 tasks.create(ALTERNATE_ARCHIVE_TASK_NAME)
             }
             tasks.getByName(ALTERNATE_ARCHIVE_TASK_NAME)
                 .dependsOn(tasks.getByName(ARCHIVE_TASK_NAME))
         }
-        return dokkaTasks
+        return tasks.getByName(DokkaSourceDocs.RUNNER_TASK_NAME) as DokkaTask
     }
 
     fun registerAndroidProject(
@@ -117,13 +104,10 @@ object DokkaSourceDocs {
     }
 
     fun registerInputs(inputs: JavaCompileInputs, project: Project) {
-        val dokkaTasks = getDocsTasks(project)
-
-        dokkaTasks?.forEach {
-            it.sourceDirs += inputs.sourcePaths
-            it.classpath = it.classpath.plus(inputs.dependencyClasspath)
-                .plus(inputs.bootClasspath)
-            it.dependsOn(inputs.dependencyClasspath)
-        }
+        val docsTask = getDocsTask(project)
+        docsTask.sourceDirs += inputs.sourcePaths
+        docsTask.classpath = docsTask.classpath.plus(inputs.dependencyClasspath)
+            .plus(inputs.bootClasspath)
+        docsTask.dependsOn(inputs.dependencyClasspath)
     }
 }