plugins {
    java
}

repositories {
    mavenCentral()
}

// tag::lock-mode[]
dependencyLocking {
    lockMode = LockMode.STRICT
}
// end::lock-mode[]

configurations.compileClasspath {
    resolutionStrategy.activateDependencyLocking()
}

dependencies {
    implementation("org.springframework:spring-beans:[5.0,6.0)")

plugins {
    id 'java'
}

// tag::locking-all[]
dependencyLocking {
    lockAllConfigurations()
}
// end::locking-all[]

// tag::resolve-all[]
tasks.register('resolveAndLockAll') {
    notCompatibleWithConfigurationCache("Filters configurations at execution time")
    doFirst {
        assert gradle.startParameter.writeDependencyLocks : "$path must be run from the command line with the `--write-locks` flag"
    }
    doLast {

plugins {
    java
}

// tag::locking-all[]
dependencyLocking {
    lockAllConfigurations()
}
// end::locking-all[]

// tag::resolve-all[]
tasks.register("resolveAndLockAll") {
    notCompatibleWithConfigurationCache("Filters configurations at execution time")
    doFirst {
        require(gradle.startParameter.isWriteDependencyLocks) { "$path must be run from the command line with the `--write-locks` flag" }
    }
    doLast {

    /**
     * Configures dependency locking
     *
     * @param configureClosure the configuration action
     * @since 6.1
     */
    void dependencyLocking(Closure configureClosure);

    /**
     * Provides access to configuring dependency locking
     *
     * @return the {@link DependencyLockingHandler}
     *
     * @since 6.1
     */

            buildLogicBuilder.prepareClassPath(classpathConfiguration, resolutionContext);
        }
    }

    @Override
    public void dependencyLocking(Closure configureClosure) {
        ConfigureUtil.configure(configureClosure, getDependencyLocking());
    }

    @Override
    public DependencyLockingHandler getDependencyLocking() {

            new DocumentationRegistry().getDocumentationRecommendationFor("information on generating lock state", "dependency_locking", "generating_and_updating_dependency_locks"));
    }
    public MissingLockStateException(DisplayName displayName) {

include::dependency_verification.adoc[leveloffset=+1]

= Declaring Versions
include::single_versions.adoc[leveloffset=+1]
include::rich_versions.adoc[leveloffset=+1]
include::dynamic_versions.adoc[leveloffset=+1]
include::dependency_locking.adoc[leveloffset=+1]

= Controlling Transitive Dependencies
include::dependency_constraints.adoc[leveloffset=+1]
include::dependency_downgrade_and_exclude.adoc[leveloffset=+1]
include::platforms.adoc[leveloffset=+1]

import java.util.List;
import java.util.Map;
import java.util.Set;

public class ResolutionResultGraphBuilder implements ResolvedComponentVisitor {
    private static final DefaultComponentSelectionDescriptor DEPENDENCY_LOCKING = new DefaultComponentSelectionDescriptor(ComponentSelectionCause.CONSTRAINT, Describables.of("Dependency locking"));
    private final Long2ObjectMap<DefaultResolvedComponentResult> components = new Long2ObjectOpenHashMap<>();

Overwrites versions from transitive dependencies. +
🔒
|===

Lines annotated with a lock (🔒) indicate that leveraging <<dependency_locking.adoc#dependency-locking,dependency locking>> makes sense in this context.

== DECLARING VERSIONS

include::single_versions.adoc[leveloffset=+2]
include::rich_versions.adoc[leveloffset=+2]
include::dynamic_versions.adoc[leveloffset=+2]
include::dependency_locking.adoc[leveloffset=+2]

== CONTROLLING TRANSITIVES

include::dependency_constraints.adoc[leveloffset=+2]
include::dependency_downgrade_and_exclude.adoc[leveloffset=+2]
include::platforms.adoc[leveloffset=+2]