Merge pull request #291 from nebula-plugins/modernization

OdysseusLives · web-flow · commit 480b93eea851 · 2026-02-06T14:30:25.000-08:00
Modernization, Phase 3: Lazy property access via Provider API and findProperty
diff --git a/src/main/groovy/nebula/plugin/dependencylock/DependencyLockReader.groovy b/src/main/groovy/nebula/plugin/dependencylock/DependencyLockReader.groovy
@@ -67,21 +67,25 @@ class DependencyLockReader {
         Map overrides = [:]
 
         // Load overrides from a file if the user has specified one via a property.
-        if (project.hasProperty(OVERRIDE_FILE)) {
-            File dependenciesLock = new File(project.rootDir, project[OVERRIDE_FILE] as String)
+        // Use findProperty() to check both gradle properties (-P) and project extras (ext)
+        def overrideFile = project.findProperty(OVERRIDE_FILE)
+        if (overrideFile) {
+            File dependenciesLock = new File(project.rootDir, overrideFile as String)
             def lockOverride = parseLockFile(dependenciesLock)
             def isDeprecatedFormat = lockOverride.any { it.value.getClass() != String && it.value.locked }
             // the old lock override files specified the version to override under the "locked" property
             if (isDeprecatedFormat) {
                 logger.warn("The override file ${dependenciesLock.name} is using a deprecated format. Support for this format may be removed in future versions.")
             }
             lockOverride.each { overrides[it.key] = isDeprecatedFormat ? it.value.locked : it.value }
-            logger.debug "Override file loaded: ${project[OVERRIDE_FILE]}"
+            logger.debug "Override file loaded: ${overrideFile}"
         }
 
         // Allow the user to specify overrides via a property as well.
-        if (project.hasProperty('dependencyLock.override')) {
-            project['dependencyLock.override'].tokenize(',').each {
+        // Use findProperty() to check both gradle properties (-P) and project extras (ext)
+        def override = project.findProperty('dependencyLock.override')
+        if (override) {
+            override.toString().tokenize(',').each {
                 def (group, artifact, version) = it.tokenize(':')
                 overrides["${group}:${artifact}".toString()] = version
                 logger.debug "Override added for: ${it}"
diff --git a/src/main/groovy/nebula/plugin/dependencylock/DependencyLockTaskConfigurer.groovy b/src/main/groovy/nebula/plugin/dependencylock/DependencyLockTaskConfigurer.groovy
@@ -66,8 +66,9 @@ class DependencyLockTaskConfigurer {
     }
 
     private boolean isGlobalLockDisabled() {
-        return project.hasProperty(DISABLE_GLOBAL_LOCK) &&
-               Boolean.parseBoolean(project.property(DISABLE_GLOBAL_LOCK) as String)
+        return project.providers.gradleProperty(DISABLE_GLOBAL_LOCK)
+            .map { it.toBoolean() }
+            .getOrElse(false)
     }
 
     String configureTasks(String globalLockFilename, String lockFilename, DependencyLockExtension extension, DependencyLockCommitExtension commitExtension, Map overrides) {
@@ -137,14 +138,24 @@ class DependencyLockTaskConfigurer {
                 if (globalSaveTask) {
                     it.mustRunAfter(globalSaveTask)
                 }
-                String commitMessageValue = project.hasProperty('commitDependencyLock.message') ?
-                        project['commitDependencyLock.message'] : commitExtension.message.get()
-                commitMessage.set(commitMessageValue)
+                // Use provider to allow gradle property to override extension
+                commitMessage.set(
+                    project.providers.gradleProperty('commitDependencyLock.message')
+                        .orElse(commitExtension.message)
+                )
                 patternsToCommit.set(getPatternsToCommit(clLockFileName, globalLockFileName, lockExtension))
                 remoteRetries.set(commitExtension.remoteRetries.get())
-                shouldCreateTag.set(project.hasProperty('commitDependencyLock.tag') ?: commitExtension.shouldCreateTag.get())
-                String tagValue = project.hasProperty('commitDependencyLock.tag') ? project['commitDependencyLock.tag'] : commitExtension.tag.get()
-                tag.set(tagValue)
+                
+                // If gradle property is present, shouldCreateTag is true
+                shouldCreateTag.set(
+                    project.providers.gradleProperty('commitDependencyLock.tag')
+                        .map { true }
+                        .orElse(commitExtension.shouldCreateTag)
+                )
+                tag.set(
+                    project.providers.gradleProperty('commitDependencyLock.tag')
+                        .orElse(commitExtension.tag)
+                )
                 rootDirPath.set(project.rootProject.projectDir.absolutePath)
             }
         }
@@ -372,12 +383,16 @@ class DependencyLockTaskConfigurer {
     }
 
     public static boolean shouldIgnoreDependencyLock(Project project) {
-        if (project.hasProperty('dependencyLock.ignore')) {
-            def prop = project.property('dependencyLock.ignore')
-            (prop instanceof String) ? prop.toBoolean() : prop.asBoolean()
-        } else {
-            false
-        }
+        // Use provider that checks both gradle properties (-P) and project extras (ext)
+        // This maintains backward compatibility with existing usage
+        return project.providers.provider {
+            def prop = project.findProperty('dependencyLock.ignore')
+            if (prop != null) {
+                // Handle both String and other types (Boolean, Integer, etc.)
+                return (prop instanceof String) ? prop.toBoolean() : prop.asBoolean()
+            }
+            return false
+        }.get()
     }
 
     private TaskProvider<DiffLockTask> configureDiffLockTask(String lockFileName, DependencyLockExtension extension) {
diff --git a/src/main/groovy/nebula/plugin/dependencylock/utils/CoreLockingHelper.groovy b/src/main/groovy/nebula/plugin/dependencylock/utils/CoreLockingHelper.groovy
@@ -44,7 +44,10 @@ class CoreLockingHelper {
 
     CoreLockingHelper(Project project) {
         this.project = project
-        shouldLockAllConfigurations = project.hasProperty("lockAllConfigurations") && (project.property("lockAllConfigurations") as String).toBoolean()
+        // Use provider API for lazy evaluation
+        shouldLockAllConfigurations = project.providers.gradleProperty("lockAllConfigurations")
+            .map { it.toBoolean() }
+            .getOrElse(false)
         configsWithActivatedDependencyLocking = new HashSet<Configuration>()
         configsNotGettingLocked = new HashSet<Configuration>()
     }
@@ -128,9 +131,10 @@ class CoreLockingHelper {
 
     private Collection<String> gatherAdditionalConfigurationsToLock() {
         def dependencyLockExtension = project.extensions.findByType(DependencyLockExtension)
-        def additionalConfigurationsToLockViaProperty = project.hasProperty(ADDITIONAL_CONFIGS_TO_LOCK)
-                ? (project[ADDITIONAL_CONFIGS_TO_LOCK] as String).split(",") as Set<String>
-                : []
+        // Use provider API for lazy evaluation
+        def additionalConfigurationsToLockViaProperty = project.providers.gradleProperty(ADDITIONAL_CONFIGS_TO_LOCK)
+                .map { it.split(",") as Set<String> }
+                .getOrElse([] as Set)
         def additionalConfigurationsToLockViaExtension = dependencyLockExtension.additionalConfigurationsToLock.get() as Set<String>
         def additionalConfigNames = additionalConfigurationsToLockViaProperty + additionalConfigurationsToLockViaExtension
         additionalConfigNames
diff --git a/src/main/kotlin/nebula/plugin/dependencylock/DependencyLockPlugin.kt b/src/main/kotlin/nebula/plugin/dependencylock/DependencyLockPlugin.kt
@@ -144,7 +144,11 @@ class DependencyLockPlugin @Inject constructor(val buildFeatures: BuildFeatures)
                         " - Legacy global lock: ${globalLockFile.absolutePath}")
             }
         } else {
-            val lockAfterEvaluating = if (project.hasProperty(LOCK_AFTER_EVALUATING)) project.property(LOCK_AFTER_EVALUATING).toString().toBoolean() else extension.lockAfterEvaluating.get()
+            // Use provider chain to allow gradle property to override extension property
+            val lockAfterEvaluating = project.providers.gradleProperty(LOCK_AFTER_EVALUATING)
+                .map { it.toBoolean() }
+                .orElse(extension.lockAfterEvaluating)
+                .get()
             if (lockAfterEvaluating) {
                 LOGGER.info("Delaying dependency lock apply until beforeResolve ($LOCK_AFTER_EVALUATING set to true)")
             } else {
@@ -203,11 +207,32 @@ class DependencyLockPlugin @Inject constructor(val buildFeatures: BuildFeatures)
             val taskNames = project.gradle.startParameter.taskNames
             val hasUpdateTask = hasUpdateTask(taskNames)
 
-            val updates = if (project.hasProperty(UPDATE_DEPENDENCIES)) parseUpdates(project.property(UPDATE_DEPENDENCIES) as String) else extension.updateDependencies.get()
+            // Use provider to allow gradle property to override extension property
+            val updates = project.providers.gradleProperty(UPDATE_DEPENDENCIES)
+                .map { parseUpdates(it) }
+                .orElse(extension.updateDependencies)
+                .get()
+            
+            // Resolve validation flags using Provider API
+            val validateCoordinates = project.providers.gradleProperty(VALIDATE_DEPENDENCY_COORDINATES)
+                .map { it.toBoolean() }
+                .orElse(extension.updateDependenciesFailOnInvalidCoordinates)
+                .get()
+            val validateSimultaneousTasks = project.providers.gradleProperty(VALIDATE_SIMULTANEOUS_TASKS)
+                .map { it.toBoolean() }
+                .orElse(extension.updateDependenciesFailOnSimultaneousTaskUsage)
+                .get()
+            val validateSpecifiedDependenciesToUpdate = project.providers.gradleProperty(VALIDATE_SPECIFIED_DEPENDENCIES_TO_UPDATE)
+                .map { it.toBoolean() }
+                .orElse(extension.updateDependenciesFailOnNonSpecifiedDependenciesToUpdate)
+                .get()
+            
             UpdateDependenciesValidator.validate(
                 updates, overrides, hasUpdateTask,
                 hasTask(taskNames, GENERATION_TASK_NAMES - UPDATE_TASK_NAMES),
-                project, extension
+                validateCoordinates,
+                validateSimultaneousTasks,
+                validateSpecifiedDependenciesToUpdate
             )
             val projectCoord = "${project.group}:${project.name}"
             if (hasUpdateTask && updates.any { it == projectCoord }) {
@@ -292,13 +317,19 @@ class DependencyLockPlugin @Inject constructor(val buildFeatures: BuildFeatures)
     }
 
     private fun applyOverrides(conf: Configuration, overrides: Map<*, *>) {
-        if (project.hasProperty(OVERRIDE_FILE)) {
-            LOGGER.info("Using override file ${project.property(OVERRIDE_FILE)} to lock dependencies")
-            reasons.add("com.netflix.nebula.dependency-lock using override file: ${project.property(OVERRIDE_FILE)}")
+        // Use providers to check for gradle properties
+        val overrideFileProvider = project.providers.gradleProperty(OVERRIDE_FILE)
+        if (overrideFileProvider.isPresent) {
+            val overrideFile = overrideFileProvider.get()
+            LOGGER.info("Using override file $overrideFile to lock dependencies")
+            reasons.add("com.netflix.nebula.dependency-lock using override file: $overrideFile")
         }
-        if (project.hasProperty(OVERRIDE)) {
-            LOGGER.info("Using command line overrides ${project.property(OVERRIDE)}")
-            reasons.add("com.netflix.nebula.dependency-lock using override: ${project.property(OVERRIDE)}")
+        
+        val overrideProvider = project.providers.gradleProperty(OVERRIDE)
+        if (overrideProvider.isPresent) {
+            val override = overrideProvider.get()
+            LOGGER.info("Using command line overrides $override")
+            reasons.add("com.netflix.nebula.dependency-lock using override: $override")
         }
 
         val overrideDeps = overrides.map {
diff --git a/src/main/kotlin/nebula/plugin/dependencylock/validation/UpdateDependenciesValidator.kt b/src/main/kotlin/nebula/plugin/dependencylock/validation/UpdateDependenciesValidator.kt
@@ -1,12 +1,8 @@
 package nebula.plugin.dependencylock.validation
 
-import nebula.plugin.dependencylock.DependencyLockExtension
 import nebula.plugin.dependencylock.DependencyLockPlugin.Companion.UPDATE_DEPENDENCIES
-import nebula.plugin.dependencylock.DependencyLockPlugin.Companion.VALIDATE_DEPENDENCY_COORDINATES
-import nebula.plugin.dependencylock.DependencyLockPlugin.Companion.VALIDATE_SIMULTANEOUS_TASKS
 import nebula.plugin.dependencylock.DependencyLockPlugin.Companion.VALIDATE_SPECIFIED_DEPENDENCIES_TO_UPDATE
 import nebula.plugin.dependencylock.exceptions.DependencyLockException
-import org.gradle.api.Project
 import org.gradle.api.logging.Logger
 import org.gradle.api.logging.Logging
 
@@ -18,22 +14,10 @@ class UpdateDependenciesValidator {
         fun validate(
             updateDependencies: Set<String>, overrides: Map<*, *>,
             hasUpdateTask: Boolean, hasGenerateTask: Boolean,
-            project: Project,
-            extension: DependencyLockExtension
+            validateCoordinates: Boolean,
+            validateSimultaneousTasks: Boolean,
+            validateSpecifiedDependenciesToUpdate: Boolean
         ) {
-            val validateCoordinates =
-                if (project.hasProperty(VALIDATE_DEPENDENCY_COORDINATES)) project.property(
-                    VALIDATE_DEPENDENCY_COORDINATES
-                ).toString().toBoolean() else extension.updateDependenciesFailOnInvalidCoordinates.get()
-            val validateSimultaneousTasks =
-                if (project.hasProperty(VALIDATE_SIMULTANEOUS_TASKS)) project.property(
-                    VALIDATE_SIMULTANEOUS_TASKS
-                ).toString().toBoolean() else extension.updateDependenciesFailOnSimultaneousTaskUsage.get()
-            val validateSpecifiedDependenciesToUpdate =
-                if (project.hasProperty(VALIDATE_SPECIFIED_DEPENDENCIES_TO_UPDATE)) project.property(
-                    VALIDATE_SPECIFIED_DEPENDENCIES_TO_UPDATE
-                ).toString().toBoolean() else extension.updateDependenciesFailOnNonSpecifiedDependenciesToUpdate.get()
-
             validateCoordinates(updateDependencies, validateCoordinates)
             validateSimultaneousTasks(hasUpdateTask, hasGenerateTask, validateSimultaneousTasks)
             validateSpecifiedDependenciesToUpdate(
diff --git a/src/main/kotlin/nebula/plugin/dependencyverifier/DependencyResolutionVerifier.kt b/src/main/kotlin/nebula/plugin/dependencyverifier/DependencyResolutionVerifier.kt
@@ -61,8 +61,10 @@ class DependencyResolutionVerifier {
         this.project = project
         this.extension = project.rootProject.extensions.findByType(DependencyResolutionVerifierExtension::class.java)!!
         this.configurationsToExcludeOverride = mutableSetOf()
-        if (project.hasProperty(CONFIGURATIONS_TO_EXCLUDE)) {
-            configurationsToExcludeOverride.addAll((project.property(CONFIGURATIONS_TO_EXCLUDE) as String).split(","))
+        // Use findProperty to check both gradle properties (-P) and project extras (ext)
+        val configurationsToExclude = project.findProperty(CONFIGURATIONS_TO_EXCLUDE)
+        if (configurationsToExclude != null) {
+            configurationsToExcludeOverride.addAll(configurationsToExclude.toString().split(","))
         }
         val uniqueProjectKey = uniqueProjectKey(project)
         failedDependenciesPerProjectForConfigurations[uniqueProjectKey] = mutableMapOf()
@@ -344,8 +346,10 @@ class DependencyResolutionVerifier {
     }
 
     private fun unresolvedDependenciesShouldFailTheBuild(): Boolean {
-        return if (project.hasProperty(UNRESOLVED_DEPENDENCIES_FAIL_THE_BUILD)) {
-            (project.property(UNRESOLVED_DEPENDENCIES_FAIL_THE_BUILD) as String).toBoolean()
+        // Use findProperty to check both gradle properties (-P) and project extras (ext)
+        val shouldFailProp = project.findProperty(UNRESOLVED_DEPENDENCIES_FAIL_THE_BUILD)
+        return if (shouldFailProp != null) {
+            shouldFailProp.toString().toBoolean()
         } else {
             extension.shouldFailTheBuild.get()
         }
diff --git a/src/test/groovy/nebula/plugin/dependencylock/validation/UpdateDependenciesValidatorSpec.groovy b/src/test/groovy/nebula/plugin/dependencylock/validation/UpdateDependenciesValidatorSpec.groovy
