com.dropbox.gradle.plugins.dependencyguard.DependencyGuardPlugin.kt Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of dependency-guard Show documentation
A Gradle plugin that helps protect against unintentional transitive dependency changes.
The newest version!
package com.dropbox.gradle.plugins.dependencyguard

import com.dropbox.gradle.plugins.dependencyguard.internal.DependencyTreeDiffTaskNames
import com.dropbox.gradle.plugins.dependencyguard.internal.list.DependencyGuardListTask
import com.dropbox.gradle.plugins.dependencyguard.internal.tree.DependencyTreeDiffTask
import org.gradle.api.Plugin
import org.gradle.api.Project
import org.gradle.api.tasks.TaskProvider
import org.gradle.language.base.plugins.LifecycleBasePlugin

/**
 * A plugin for watching dependency changes
 */
public class DependencyGuardPlugin : Plugin {

    internal companion object {
        internal const val DEPENDENCY_GUARD_TASK_GROUP = "Dependency Guard"

        internal const val DEPENDENCY_GUARD_EXTENSION_NAME = "dependencyGuard"

        internal const val DEPENDENCY_GUARD_TASK_NAME = "dependencyGuard"

        internal const val DEPENDENCY_GUARD_BASELINE_TASK_NAME = "dependencyGuardBaseline"
    }

    override fun apply(target: Project) {
        val extension = target.extensions.create(
            DEPENDENCY_GUARD_EXTENSION_NAME,
            DependencyGuardPluginExtension::class.java,
            target.objects
        )

        val dependencyGuardBaselineTask = registerDependencyGuardBaselineTask(target, extension)
        val dependencyGuardTask = registerDependencyGuardTask(target, extension)
        registerTreeDiffTasks(
            target = target,
            extension = extension,
            baselineTask = dependencyGuardBaselineTask,
            guardTask = dependencyGuardTask
        )

        attachToCheckTask(
            target = target,
            dependencyGuardTask = dependencyGuardTask
        )
    }

    private fun attachToCheckTask(target: Project, dependencyGuardTask: TaskProvider) {
        // Only add to the "check" lifecycle task if the base plugin is applied
        target.pluginManager.withPlugin("base") {
            // Attach the "dependencyGuard" task to the "check" lifecycle task
            target.tasks.named(LifecycleBasePlugin.CHECK_TASK_NAME).configure {
                this.dependsOn(dependencyGuardTask)
            }
        }
    }

    private fun registerDependencyGuardBaselineTask(
        target: Project,
        extension: DependencyGuardPluginExtension
    ): TaskProvider {
        return target.tasks.register(
            DEPENDENCY_GUARD_BASELINE_TASK_NAME,
            DependencyGuardListTask::class.java
        ) {
            val task = this
            task.setParams(
                project = target,
                extension = extension,
                shouldBaseline = true
            )
        }
    }

    private fun registerDependencyGuardTask(
        target: Project,
        extension: DependencyGuardPluginExtension
    ): TaskProvider {
        return target.tasks.register(
            DEPENDENCY_GUARD_TASK_NAME,
            DependencyGuardListTask::class.java
        ) {
            setParams(
                project = target,
                extension = extension,
                shouldBaseline = false
            )
        }
    }

    private fun registerTreeDiffTasks(
        target: Project,
        extension: DependencyGuardPluginExtension,
        baselineTask: TaskProvider,
        guardTask: TaskProvider
    ) {
        extension.configurations.all {
            val dependencyGuardConfiguration = this
            if (dependencyGuardConfiguration.tree) {
                val taskClass = DependencyTreeDiffTask::class.java

                val treeGuardTask = target.tasks.register(
                    DependencyTreeDiffTaskNames.createDependencyTreeTaskNameForConfiguration(
                        configurationName = dependencyGuardConfiguration.configurationName
                    ),
                    taskClass
                ) {
                    setParams(
                        project = target,
                        configurationName = dependencyGuardConfiguration.configurationName,
                        shouldBaseline = false
                    )
                }
                guardTask.configure {
                    dependsOn(treeGuardTask)
                }

                val treeBaselineTask = target.tasks.register(
                    DependencyTreeDiffTaskNames.createDependencyTreeBaselineTaskNameForConfiguration(
                        configurationName = dependencyGuardConfiguration.configurationName
                    ),
                    taskClass
                ) {
                    setParams(
                        project = target,
                        configurationName = dependencyGuardConfiguration.configurationName,
                        shouldBaseline = true
                    )
                }
                baselineTask.configure {
                    dependsOn(treeBaselineTask)
                }
            }
        }
    }
}