1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
|
package org.jetbrains.dokka.gradle
import groovy.lang.Closure
import org.gradle.api.DefaultTask
import org.gradle.api.Plugin
import org.gradle.api.Project
import org.gradle.api.file.FileCollection
import org.gradle.api.plugins.JavaBasePlugin
import org.gradle.api.plugins.JavaPluginConvention
import org.gradle.api.tasks.*
import org.jetbrains.dokka.DokkaGenerator
import org.jetbrains.dokka.SourceLinkDefinition
import java.io.File
import java.util.ArrayList
public open class DokkaPlugin : Plugin<Project> {
override fun apply(project: Project) {
project.tasks.create("dokka", DokkaTask::class.java).apply {
moduleName = project.name
outputDirectory = File(project.buildDir, "dokka").absolutePath
}
}
}
public open class DokkaTask : DefaultTask() {
init {
group = JavaBasePlugin.DOCUMENTATION_GROUP
description = "Generates dokka documentation for Kotlin"
}
@Input
var moduleName: String = ""
@Input
var outputFormat: String = "html"
var outputDirectory: String = ""
@Input
var processConfigurations: List<Any?> = arrayListOf("compile")
@Input
var includes: List<Any?> = arrayListOf()
@Input
var linkMappings: ArrayList<LinkMapping> = arrayListOf()
@Input
var samples: List<Any?> = arrayListOf()
fun linkMapping(closure: Closure<Any?>) {
val mapping = LinkMapping()
closure.delegate = mapping
closure.call()
if (mapping.dir.isEmpty()) {
throw IllegalArgumentException("Link mapping should have dir")
}
if (mapping.url.isEmpty()) {
throw IllegalArgumentException("Link mapping should have url")
}
linkMappings.add(mapping)
}
@TaskAction
fun generate() {
val project = project
val sourceDirectories = getSourceDirectories()
val allConfigurations = project.configurations
val classpath =
processConfigurations
.map { allConfigurations?.getByName(it.toString()) ?: throw IllegalArgumentException("No configuration $it found") }
.flatMap { it }
if (sourceDirectories.isEmpty()) {
logger.warn("No source directories found: skipping dokka generation")
return
}
DokkaGenerator(
DokkaGradleLogger(logger),
classpath.map { it.absolutePath },
sourceDirectories.map { it.absolutePath },
samples.filterNotNull().map { project.file(it).absolutePath },
includes.filterNotNull().map { project.file(it).absolutePath },
moduleName,
outputDirectory,
outputFormat,
linkMappings.map { SourceLinkDefinition(project.file(it.dir).absolutePath, it.url, it.suffix) },
false
).generate()
}
fun getSourceDirectories(): List<File> {
val javaPluginConvention = project.convention.getPlugin(JavaPluginConvention::class.java)
val sourceSets = javaPluginConvention.sourceSets?.findByName(SourceSet.MAIN_SOURCE_SET_NAME)
return sourceSets?.allSource?.srcDirs?.filter { it.exists() } ?: emptyList()
}
@InputFiles
@SkipWhenEmpty
fun getIncludedFiles() : FileCollection = project.files(getSourceDirectories().map { project.fileTree(it) })
@OutputDirectory
fun getOutputDirectoryAsFile() : File = project.file(outputDirectory)
}
public open class LinkMapping {
var dir: String = ""
var url: String = ""
var suffix: String? = null
}
|
