name.remal.gradle_plugins.dsl.BaseReflectiveProjectPlugin.kt Maven / Gradle / Ivy

Go to download
package name.remal.gradle_plugins.dsl

import name.remal.findDeclaredConstructor
import name.remal.getMetaAnnotation
import name.remal.gradle_plugins.dsl.extensions.*
import name.remal.gradle_plugins.dsl.reflective_project_plugin.action_param_injector.invoke
import name.remal.gradle_plugins.dsl.reflective_project_plugin.info.*
import org.gradle.api.Project
import org.gradle.util.GradleVersion
import kotlin.Any
import kotlin.Exception
import kotlin.IllegalStateException
import kotlin.UnsupportedOperationException
import kotlin.jvm.java
import kotlin.let
import java.lang.Deprecated as JavaDeprecated
import kotlin.Deprecated as KotlinDeprecated

abstract class BaseReflectiveProjectPlugin : BaseProjectPlugin() {

    final override fun applyImpl(project: Project) {
        val pluginInfo = PluginInfoCollector.collect(javaClass) ?: throw IllegalStateException("Plugin info can't be collected for $javaClass")

        if (pluginInfo.doesNotSupportCurrentGradleVersion) {
            logger.warn("{}: Plugin {} doesn't support {}, as it requires {}", project, pluginInfo.id, GradleVersion.current(), pluginInfo.minGradleVersion)
            return
        }

        val deprecationMessage = javaClass.getMetaAnnotation(KotlinDeprecated::class.java)?.message ?: javaClass.getMetaAnnotation(JavaDeprecated::class.java)?.let { "" }
        if (deprecationMessage != null) {
            if (deprecationMessage.isNotEmpty()) {
                logger.warn("{}: Plugin {} is deprecated: {}", project, pluginInfo.id, deprecationMessage)
            } else {
                logger.warn("{}: Plugin {} is deprecated", project, pluginInfo.id)
            }
        }

        doActions(project, pluginInfo, this, pluginInfo)
    }

    private fun doActions(project: Project, pluginInfo: PluginInfo, actionsGroup: Any, actionsInfo: WithPluginActions) {
        if (actionsInfo.doesNotSupportCurrentGradleVersion) {
            logger.debug("{}: Plugin {}: {} doesn't support {}, as it requires {}", project, pluginInfo.id, actionsInfo, GradleVersion.current(), pluginInfo.minGradleVersion)
            return
        }

        for (conditionInfo in actionsInfo.conditionMethods) {
            if (!conditionInfo.invoke(actionsGroup, project)) {
                logger.debug("{}: Plugin {}: Skipping because of failed condition {}", pluginInfo.id, conditionInfo)
                return
            }
        }

        project.withPlugins(actionsInfo.requirePluginIds) {
            actionsInfo.applyPluginIds.forEach { project.applyPlugin(it) }
            actionsInfo.applyPluginClasses.forEach { project.applyPlugin(it) }
            actionsInfo.applyOptionalPluginIds.forEach { project.tryApplyPlugin(it) }

            for (action in actionsInfo.actions) {
                if (action is ActionMethodInfo) {
                    if (action.doesNotSupportCurrentGradleVersion) {
                        logger.debug("{}: Plugin {}: {} doesn't support {}, as it requires {}", project, pluginInfo.id, action, GradleVersion.current(), pluginInfo.minGradleVersion)
                        return@withPlugins
                    }

                    project.withPlugins(action.requirePluginIds) {
                        try {
                            action.applyPluginIds.forEach { project.applyPlugin(it) }
                            action.applyPluginClasses.forEach { project.applyPlugin(it) }
                            action.applyOptionalPluginIds.forEach { project.tryApplyPlugin(it) }

                            if (action.isAfterProjectEvaluation) {
                                project.afterEvaluateOrNow {
                                    logger.debug("{}: Plugin {}: Executing plugin action: {}", project, pluginInfo.id, action)
                                    action.invoke(actionsGroup, it)
                                }
                            } else {
                                logger.debug("{}: Plugin {}: Executing plugin action: {}", project, pluginInfo.id, action)
                                action.invoke(actionsGroup, project)
                            }

                            action.applyPluginIdsAtTheEnd.forEach { project.applyPlugin(it) }
                            action.applyPluginClassesAtTheEnd.forEach { project.applyPlugin(it) }
                            action.applyOptionalPluginIdsAtTheEnd.forEach { project.tryApplyPlugin(it) }

                        } catch (e: Exception) {
                            throw Exception("$project: Error applying plugin ${[email protected]().name}: $e", e)
                        }
                    }

                } else if (action is ActionsGroupInfo) {
                    val innerActionsGroup = action.actionsGroupClass.let {
                        it.findDeclaredConstructor(actionsGroup.javaClass)?.newInstance(actionsGroup)
                            ?: it.getDeclaredConstructor().newInstance()
                    }
                    doActions(project, pluginInfo, innerActionsGroup, action)

                } else {
                    throw UnsupportedOperationException("Unsupported action type: ${action.javaClass}")
                }
            }

            actionsInfo.applyPluginIdsAtTheEnd.forEach { project.applyPlugin(it) }
            actionsInfo.applyPluginClassesAtTheEnd.forEach { project.applyPlugin(it) }
            actionsInfo.applyOptionalPluginIdsAtTheEnd.forEach { project.tryApplyPlugin(it) }
        }
    }

}