Merge pull request #292 from nebula-plugins/modernization

Modernization, Phase 4: Configuration avoidance (lazy APIs)

Author: OdysseusLives

src/main/groovy/nebula/plugin/dependencylock/tasks/GenerateLockTask.groovy

@@ -131,7 +131,8 @@ abstract class GenerateLockTask extends AbstractLockTask {
                 lockableConfigurations.addAll project.configurations.asList()
             }
         } else {
-            lockableConfigurations.addAll configurationNames.collect { project.configurations.getByName(it) }
+            // Use named() for lazy lookup (though we resolve with .get() since we need the actual Configuration)
+            lockableConfigurations.addAll configurationNames.collect { project.configurations.named(it).get() }
         }
 
         lockableConfigurations.removeAll {

src/main/groovy/nebula/plugin/dependencylock/utils/CoreLockingHelper.groovy

@@ -95,11 +95,12 @@ class CoreLockingHelper {
 
     private void findAndLockAdditionalConfigurations(Set<String> configurationNames, Closure closure) {
         def additionalConfigNames = gatherAdditionalConfigurationsToLock()
+        // Use configureEach for lazy configuration (avoids configuring unused configurations)
         project.configurations.matching { // returns a live collection
             additionalConfigNames.findAll { additionalConfigName ->
                 it.name == additionalConfigName
             }
-        }.all { it ->
+        }.configureEach { it ->
             runClosureOnConfigurations(configurationNames, closure, additionalConfigNames)
         }
     }
@@ -142,14 +143,15 @@ class CoreLockingHelper {
 
     void disableCachingWhenUpdatingDependencies() {
         if (isUpdatingDependencies) {
-            project.configurations.all({ Configuration configuration ->
+            // Use configureEach for lazy configuration (avoids configuring unused configurations)
+            project.configurations.configureEach { Configuration configuration ->
                 if (configuration.state == Configuration.State.UNRESOLVED) {
                     configuration.resolutionStrategy {
                         cacheDynamicVersionsFor(0, 'seconds')
                         cacheChangingModulesFor(0, 'seconds')
                     }
                 }
-            })
+            }
         }
     }
 

src/main/kotlin/nebula/plugin/dependencylock/DependencyLockPlugin.kt

@@ -161,28 +161,30 @@ class DependencyLockPlugin @Inject constructor(val buildFeatures: BuildFeatures)
                 disableCachingForGenerateLock()
             }
 
-            project.configurations.all({ conf ->
+            // Use configureEach for lazy configuration (avoids configuring unused configurations)
+            project.configurations.configureEach { conf ->
                 if (lockAfterEvaluating) {
                     conf.onResolve {
                         maybeApplyLock(conf, extension, overrides, globalLockFilename, lockFilename)
                     }
                 } else {
                     maybeApplyLock(conf, extension, overrides, globalLockFilename, lockFilename)
                 }
-            })
+            }
         }
     }
 
     private fun disableCachingForGenerateLock() {
         if (hasGenerationTask(project.gradle.startParameter.taskNames)) {
-            project.configurations.all({ configuration ->
+            // Use configureEach for lazy configuration (avoids configuring unused configurations)
+            project.configurations.configureEach { configuration ->
                 if (configuration.state == Configuration.State.UNRESOLVED) {
                     with(configuration.resolutionStrategy) {
                         cacheDynamicVersionsFor(0, "seconds")
                         cacheChangingModulesFor(0, "seconds")
                     }
                 }
-            })
+            }
         }
     }
 

src/main/kotlin/nebula/plugin/dependencylock/diff/PathAwareDiffReportGenerator.kt

@@ -55,7 +55,8 @@ class PathAwareDiffReportGenerator : DiffReportGenerator {
 
         //build paths for all dependencies
         val pathStack: Deque<DependencyPathElement> = LinkedList()
-        val root = DependencyPathElement(project.configurations.getByName(configurationName).incoming.resolutionResult.root, null, null)
+        // Use named() for lazy lookup (though we resolve with .get() since we need the actual Configuration)
+        val root = DependencyPathElement(project.configurations.named(configurationName).get().incoming.resolutionResult.root, null, null)
         pathStack.add(root)
         val visited = mutableSetOf<ResolvedDependencyResult>()
         while (!pathStack.isEmpty()) {

src/main/kotlin/nebula/plugin/dependencyverifier/DependencyResolutionVerifier.kt

@@ -165,9 +165,10 @@ class DependencyResolutionVerifier {
         val lockedDepsOutOfDate = lockedDepsOutOfDatePerProject[uniqueProjectKey(project)]
         val configurationsToExclude = if (configurationsToExcludeOverride.isNotEmpty()) configurationsToExcludeOverride else extension.configurationsToExclude.get()
 
+        // Use configureEach for lazy configuration (avoids configuring unused configurations)
         task.project.configurations.matching { // returns a live collection
             configurationIsResolvedAndMatches(it, configurationsToExclude)
-        }.all { conf ->
+        }.configureEach { conf ->
             logger.debug("$conf in ${project.name} has state ${conf.state}. Starting dependency resolution verification after task '${task.name}'.")
             try {
                 conf.resolvedConfiguration.rethrowFailure()
@@ -187,10 +188,10 @@ class DependencyResolutionVerifier {
                         }
                     }
                 }
-                return@all
+                return@configureEach
             } catch (e : Exception) {
                 logger.warn("Received an unhandled exception: {}", e.message)
-                return@all
+                return@configureEach
             }
 
             validateThatResolvedVersionIsLockedVersion(conf)