Avoid calling eager methods on configurations container

src/docs/asciidoc/parts/detection.adoc

@@ -67,7 +67,7 @@ This is best done in the place where you applied this plugin (e.g. one of your c
 
 [source,groovy]
 ----
-configurations.all {
+configurations.configureEach {
   resolutionStrategy.capabilitiesResolution {
     withCapability("javax.mail:mail") {        // Capability for which to make the decision
       select("com.sun.mail:jakarta.mail:0")    // The component to select

src/main/java/org/gradlex/jvm/dependency/conflict/resolution/ConflictResolution.java

@@ -75,14 +75,14 @@ private void selectLenient(String capability, String module) {
     }
 
     private void doSelectHighestVersion(String capability) {
-        getConfigurations().all(conf -> conf.getResolutionStrategy().getCapabilitiesResolution().withCapability(capability,
+        getConfigurations().configureEach(conf -> conf.getResolutionStrategy().getCapabilitiesResolution().withCapability(capability,
                 CapabilityResolutionDetails::selectHighestVersion));
     }
 
     private void doSelect(String capability, String module, boolean lenient) {
         String group = module.split(":")[0];
         String name = module.split(":")[1];
-        getConfigurations().all(conf -> conf.getResolutionStrategy().getCapabilitiesResolution().withCapability(capability, c -> {
+        getConfigurations().configureEach(conf -> conf.getResolutionStrategy().getCapabilitiesResolution().withCapability(capability, c -> {
             for (ComponentVariantIdentifier candidate : c.getCandidates()) {
                 ComponentIdentifier id = candidate.getId();
                 if (id instanceof ModuleComponentIdentifier

src/main/java/org/gradlex/jvm/dependency/conflict/resolution/ConsistentResolution.java

@@ -16,6 +16,7 @@
 
 package org.gradlex.jvm.dependency.conflict.resolution;
 
+import org.gradle.api.NamedDomainObjectProvider;
 import org.gradle.api.artifacts.Configuration;
 import org.gradle.api.artifacts.ConfigurationContainer;
 import org.gradle.api.artifacts.Dependency;
@@ -56,8 +57,8 @@ public ConsistentResolution(SourceSetContainer sourceSets) {
     /**
      * The runtime classpath of the given project always respected in version conflict detection and resolution.
      */
-    public Configuration providesVersions(String versionProvidingProject) {
-        Configuration mainRuntimeClasspath = maybeCreateMainRuntimeClasspathConfiguration();
+    public NamedDomainObjectProvider<Configuration> providesVersions(String versionProvidingProject) {
+        NamedDomainObjectProvider<Configuration> mainRuntimeClasspath = maybeCreateMainRuntimeClasspathConfiguration();
         getDependencies().add(mainRuntimeClasspath.getName(), createDependency(versionProvidingProject));
         return mainRuntimeClasspath;
     }
@@ -68,31 +69,31 @@ public Configuration providesVersions(String versionProvidingProject) {
      * Useful if additional dependencies are needed only for tests.
      */
     public void platform(String platform) {
-        Configuration internal = maybeCreateInternalConfiguration();
-        internal.withDependencies(d -> {
+        NamedDomainObjectProvider<Configuration> internal = maybeCreateInternalConfiguration();
+        internal.configure(conf -> conf.withDependencies(d -> {
             Dependency platformDependency = getDependencies().platform(createDependency(platform));
             d.add(platformDependency);
-        });
+        }));
 
         sourceSets.configureEach(sourceSet -> {
             ConfigurationContainer configurations = getConfigurations();
-            configurations.getByName(sourceSet.getRuntimeClasspathConfigurationName()).extendsFrom(internal);
-            configurations.getByName(sourceSet.getCompileClasspathConfigurationName()).extendsFrom(internal);
-            configurations.getByName(sourceSet.getAnnotationProcessorConfigurationName()).extendsFrom(internal);
+            configurations.named(sourceSet.getRuntimeClasspathConfigurationName(), c -> c.extendsFrom(internal.get()));
+            configurations.named(sourceSet.getCompileClasspathConfigurationName(), c -> c.extendsFrom(internal.get()));
+            configurations.named(sourceSet.getAnnotationProcessorConfigurationName(), c -> c.extendsFrom(internal.get()));
         });
     }
 
-    private Configuration maybeCreateMainRuntimeClasspathConfiguration() {
-        Configuration existing = getConfigurations().findByName(MAIN_RUNTIME_CLASSPATH_CONFIGURATION_NAME);
-        if (existing != null) {
-            return existing;
+    private NamedDomainObjectProvider<Configuration> maybeCreateMainRuntimeClasspathConfiguration() {
+        if (getConfigurations().getNames().contains(MAIN_RUNTIME_CLASSPATH_CONFIGURATION_NAME)) {
+            return getConfigurations().named(MAIN_RUNTIME_CLASSPATH_CONFIGURATION_NAME);
         }
 
-        Configuration mainRuntimeClasspath = getConfigurations().create(MAIN_RUNTIME_CLASSPATH_CONFIGURATION_NAME, c -> {
+        NamedDomainObjectProvider<Configuration> internal = maybeCreateInternalConfiguration();
+        NamedDomainObjectProvider<Configuration> mainRuntimeClasspath = getConfigurations().register(MAIN_RUNTIME_CLASSPATH_CONFIGURATION_NAME, c -> {
             ObjectFactory objects = getObjects();
             c.setCanBeResolved(true);
             c.setCanBeConsumed(false);
-            c.extendsFrom(maybeCreateInternalConfiguration());
+            c.extendsFrom(internal.get());
             c.getAttributes().attribute(Usage.USAGE_ATTRIBUTE, objects.named(Usage.class, Usage.JAVA_RUNTIME));
             c.getAttributes().attribute(Category.CATEGORY_ATTRIBUTE, objects.named(Category.class, Category.LIBRARY));
             c.getAttributes().attribute(LibraryElements.LIBRARY_ELEMENTS_ATTRIBUTE, objects.named(LibraryElements.class, LibraryElements.JAR));
@@ -104,22 +105,21 @@ private Configuration maybeCreateMainRuntimeClasspathConfiguration() {
         });
         sourceSets.configureEach(sourceSet -> {
             ConfigurationContainer configurations = getConfigurations();
-            Configuration runtime = configurations.getByName(sourceSet.getRuntimeClasspathConfigurationName());
-            Configuration compile = configurations.getByName(sourceSet.getCompileClasspathConfigurationName());
-            Configuration processor = configurations.getByName(sourceSet.getAnnotationProcessorConfigurationName());
-            runtime.shouldResolveConsistentlyWith(mainRuntimeClasspath);
-            compile.shouldResolveConsistentlyWith(runtime);
-            processor.shouldResolveConsistentlyWith(runtime);
+            NamedDomainObjectProvider<Configuration> runtime = configurations.named(sourceSet.getRuntimeClasspathConfigurationName(),c ->
+                    c.shouldResolveConsistentlyWith(mainRuntimeClasspath.get()));
+            configurations.named(sourceSet.getCompileClasspathConfigurationName(), c ->
+                    c.shouldResolveConsistentlyWith(runtime.get()));
+            configurations.named(sourceSet.getAnnotationProcessorConfigurationName(), c ->
+                    c.shouldResolveConsistentlyWith(runtime.get()));
         });
         return mainRuntimeClasspath;
     }
 
-    private Configuration maybeCreateInternalConfiguration() {
-        Configuration internal = getConfigurations().findByName(INTERNAL_CONFIGURATION_NAME);
-        if (internal != null) {
-            return internal;
+    private NamedDomainObjectProvider<Configuration> maybeCreateInternalConfiguration() {
+        if (getConfigurations().getNames().contains(INTERNAL_CONFIGURATION_NAME)) {
+            return getConfigurations().named(INTERNAL_CONFIGURATION_NAME);
         }
-        return getConfigurations().create(INTERNAL_CONFIGURATION_NAME, c -> {
+        return getConfigurations().register(INTERNAL_CONFIGURATION_NAME, c -> {
             c.setCanBeResolved(false);
             c.setCanBeConsumed(false);
         });

src/main/java/org/gradlex/jvm/dependency/conflict/resolution/JvmDependencyConflictResolutionPlugin.java

@@ -54,7 +54,7 @@ public void apply(Project project) {
     }
 
     private void configureResolutionStrategies(ConfigurationContainer configurations, JvmDependencyConflictsExtension jvmDependencyConflicts) {
-        configurations.all(configuration -> {
+        configurations.configureEach(configuration -> {
             for (CapabilityDefinition definition : CapabilityDefinition.values()) {
                 defineStrategy(definition, configuration, jvmDependencyConflicts);
             }

src/main/java/org/gradlex/jvm/dependency/conflict/resolution/Logging.java

@@ -420,7 +420,7 @@ private void enforceSlf4JImplementation() {
         selectSlf4JLog4J2Interaction(LoggingModuleIdentifiers.LOG4J_TO_SLF4J.moduleId);
         selectLog4J2Implementation(LoggingModuleIdentifiers.LOG4J_TO_SLF4J.moduleId);
 
-        getConfigurations().all(new Slf4JEnforcementSubstitutionsUsing());
+        getConfigurations().configureEach(new Slf4JEnforcementSubstitutionsUsing());
     }
 
     private void enforceSlf4JImplementation(String configurationName) {
@@ -430,7 +430,7 @@ private void enforceSlf4JImplementation(String configurationName) {
         selectSlf4JLog4J2Interaction(configurationName, LoggingModuleIdentifiers.LOG4J_TO_SLF4J.moduleId);
         selectLog4J2Implementation(configurationName, LoggingModuleIdentifiers.LOG4J_TO_SLF4J.moduleId);
 
-        getConfigurations().matching(conf -> conf.getName().equals(configurationName)).all(new Slf4JEnforcementSubstitutionsUsing());
+        getConfigurations().configureEach(new Slf4JEnforcementSubstitutionsUsing(configurationName));
     }
 
     private ExternalDependency validateNotation(Object dependencyNotation) {
@@ -443,11 +443,15 @@ private ExternalDependency validateNotation(Object dependencyNotation) {
     }
 
     private void selectCapabilityConflict(String configuration, String capabilityId, ExternalDependency target, String because) {
-        getConfigurations().matching(conf -> conf.getName().equals(configuration)).all(conf -> conf.getResolutionStrategy().capabilitiesResolution(getCapabilitiesResolutionAction(capabilityId, target, because)));
+        getConfigurations().configureEach(conf -> {
+            if (conf.getName().equals(configuration)) {
+                conf.getResolutionStrategy().capabilitiesResolution(getCapabilitiesResolutionAction(capabilityId, target, because));
+            }
+        });
     }
 
     private void selectCapabilityConflict(String capabilityId, ExternalDependency target, String because) {
-        getConfigurations().all(conf -> conf.getResolutionStrategy().capabilitiesResolution(getCapabilitiesResolutionAction(capabilityId, target, because)));
+        getConfigurations().configureEach(conf -> conf.getResolutionStrategy().capabilitiesResolution(getCapabilitiesResolutionAction(capabilityId, target, because)));
     }
 
     private Action<CapabilitiesResolution> getCapabilitiesResolutionAction(String capabilityId, ExternalDependency target, String because) {

src/main/java/org/gradlex/jvm/dependency/conflict/resolution/Slf4JEnforcementSubstitutionsUsing.java

@@ -22,8 +22,22 @@
 import org.gradlex.jvm.dependency.conflict.detection.rules.logging.LoggingModuleIdentifiers;
 
 class Slf4JEnforcementSubstitutionsUsing implements Action<Configuration> {
+
+    private final String onlyApplyTo;
+
+    public Slf4JEnforcementSubstitutionsUsing() {
+        this.onlyApplyTo = null;
+    }
+
+    public Slf4JEnforcementSubstitutionsUsing(String onlyApplyTo) {
+        this.onlyApplyTo = onlyApplyTo;
+    }
+
     @Override
     public void execute(Configuration configuration) {
+        if (onlyApplyTo != null && !configuration.getName().equals(onlyApplyTo)) {
+            return;
+        }
         configuration.getResolutionStrategy().dependencySubstitution(substitution -> {
             ComponentSelector log4JOverSlf4J = substitution.module(LoggingModuleIdentifiers.LOG4J_OVER_SLF4J.asFirstVersion());
             substitution.substitute(substitution.module(LoggingModuleIdentifiers.LOG4J.moduleId)).using(log4JOverSlf4J);