it.unibo.protelis2kotlin.Protelis2KotlinDocPlugin.kt Maven / Gradle / Ivy

Go to download
package it.unibo.protelis2kotlin

import org.gradle.api.Plugin
import org.gradle.api.Project
import org.gradle.api.internal.artifacts.dependencies.DefaultExternalModuleDependency
import org.gradle.api.provider.Property
import org.gradle.kotlin.dsl.invoke
import org.jetbrains.dokka.DokkaVersion
import org.jetbrains.dokka.gradle.DokkaTask
import org.jetbrains.kotlin.config.KotlinCompilerVersion
import java.io.File
import java.io.File.separator as SEP

/**
 * Extension for the Protelis2KotlinDoc plugin.
 * @param baseDir The base directory from which looking for Protelis files
 * @param destDir The directory that will contain the generated docs
 * @param kotlinDestDir destubatuib directirt for the intermediate Kotlin kode
 * @param debug enables debug output
 * @param
 */
open class ProtelisDocExtension @JvmOverloads constructor(
    private val project: Project,
    val baseDir: Property = project.propertyWithDefault(project.path),
    val destDir: Property = project.propertyWithDefault(project.buildDir.path + "${SEP}protelis-docs$SEP"),
    val kotlinDestDir: Property =
        project.propertyWithDefault(project.buildDir.path + "${SEP}kotlin-for-protelis$SEP"),
    val debug: Property = project.propertyWithDefault(false)
)

/**
 * Protelis2KotlinDoc Gradle Plugin:
 * reuses the Protelis2Kotlin and Dokka plugins to generate Kotlin docs from Protelis code.
 */
class Protelis2KotlinDocPlugin : Plugin {
    private val generateProtelisDocTaskName = "generateProtelisDoc"
    private val generateKotlinFromProtelisTaskName = "generateKotlinFromProtelis"
    private val protelis2KotlinPluginConfig = "protelisdoc"
    private val dokkaPluginName = "org.jetbrains.dokka"

    override fun apply(project: Project) {
        val extension = project.extensions
            .create(protelis2KotlinPluginConfig, ProtelisDocExtension::class.java, project)
        project.logger.debug(
            """
                Applying plugin ProtelisDoc.
                Default configuration:
                - debug = ${extension.debug.get()}
                - baseDir = ${extension.baseDir.get()}
                - destDir = ${extension.destDir.get()}
                - kotlinDestDir = ${extension.kotlinDestDir.get()}
            """.trimIndent()
        )
        if (!project.pluginManager.hasPlugin(dokkaPluginName)) {
            project.pluginManager.apply(dokkaPluginName)
        }
        val config = project.configurations.create(protelis2KotlinPluginConfig) { configuration ->
            project.configurations.findByName("implementation")?.let {
                configuration.extendsFrom(it)
            }
            configuration.dependencies.add(
                DefaultExternalModuleDependency(
                    "org.jetbrains.kotlin",
                    "kotlin-stdlib",
                    KotlinCompilerVersion.VERSION,
                )
            )
        }
        // Kotlin generation task
        val genKotlinTask = project.task(generateKotlinFromProtelisTaskName) {
            it.doLast {
                val debugFlag = if (extension.debug.get()) "1" else "0"
                main(arrayOf(extension.baseDir.get(), extension.kotlinDestDir.get(), debugFlag))
            }
        }
        // ProtelisDoc task, based on Dokka
        project.tasks.register(generateProtelisDocTaskName, DokkaTask::class.java) { dokkaTask ->
            dokkaTask.plugins.dependencies.add(
                project.dependencies.create("org.jetbrains.dokka:javadoc-plugin:${ DokkaVersion.version}")
            )
            dokkaTask.dependsOn(genKotlinTask)
            dokkaTask.outputDirectory.set(extension.destDir.map { File(it) })
            dokkaTask.dokkaSourceSets { sourceSetContainer ->
                sourceSetContainer.create("protelisdoc") { sourceSet ->
                    sourceSet.classpath.setFrom(config.resolve())
                    sourceSet.sourceRoots.setFrom(extension.kotlinDestDir.get())
                }
            }
            dokkaTask.outputDirectory.set(extension.destDir.map { File(it) })
        }
    }
}