apply plugin: "idea"
}

project(":project2") {
    dependencies {
        implementation group: "junit", name: "junit", version: "4.7"
    }

    configurations.all {
        resolutionStrategy.dependencySubstitution {
            substitute module("junit:junit:4.7") using project(":project1")
        }
    }
}
""")

        def dependencies = parseIml("project2/project2.iml").dependencies

            }

            project(':b') {
                $common
                dependencies {
                    conf project(':a')
                }
                configurations.conf.resolutionStrategy {
                    eachDependency {
                        assert it.requested.toString() == 'org.gradle.test:a:1.2'
                        assert it.target.toString() == 'org.gradle.test:a:1.2'

import org.gradle.api.internal.artifacts.ivyservice.dependencysubstitution.DependencySubstitutionsInternal;
import org.gradle.api.internal.artifacts.ivyservice.resolutionstrategy.CapabilitiesResolutionInternal;
import org.gradle.internal.ImmutableActionSet;

public interface ResolutionStrategyInternal extends ResolutionStrategy {
    /**
     * Discard any configuration state that is not required after graph resolution has been attempted.
     */

// Need to have at least one configuration declared, otherwise the rules are never evaluated
configurations {
    conf
}

// tag::module_to_project_substitution[]
configurations.all {
    resolutionStrategy.dependencySubstitution {
        substitute module("org.utils:api") using project(":api") because "we work with the unreleased development version"
        substitute module("org.utils:util:2.5") using project(":util")
    }
}

    }
}

dependencies {
    myPlugin "org.apache.commons:commons-lang3:3.3.1"
}

// tag::disabling-one-configuration[]
configurations {
    myPluginClasspath {
        resolutionStrategy {
            disableDependencyVerification()
        }
    }
}
// end::disabling-one-configuration[]

tasks.register("checkDependencies") {
    FileCollection classpath = configurations.myPluginClasspath

    isCanBeConsumed = false
}

dependencies {
    myPlugin("org.apache.commons:commons-lang3:3.3.1")
}

// tag::disabling-one-configuration[]
configurations {
    "myPluginClasspath" {
        resolutionStrategy {
            disableDependencyVerification()
        }
    }
}
// end::disabling-one-configuration[]

tasks.register("checkDependencies") {
    val classpath: FileCollection = myPluginClasspath

// tag::substitution_rule[]
configurations.all {
    resolutionStrategy.dependencySubstitution {
        substitute(platform(module("com.google.guava:guava:28.2-jre")))
            .using(module("com.google.guava:guava:28.2-jre"))
    }
}
// end::substitution_rule[]

// tag::substitution_rule_alternative[]
configurations.all {
    resolutionStrategy.dependencySubstitution {

        Assume.assumeTrue(GradleContextualExecuter.embedded)
        repoSpec.metaClass.platform = this.&platform.curry(repoSpec)
    }

    def "can force a virtual platform version by forcing one of its leaves through resolutionStrategy.force"() {
        repository {
            ['2.7.9', '2.9.4', '2.9.4.1'].each {
                path "databind:$it -> core:$it"
                path "databind:$it -> annotations:$it"

    // We use log4j over slf4j
    implementation("org.slf4j:log4j-over-slf4j:1.7.10")
}
// end::dependencies[]

// tag::use_highest_asm[]
configurations.all {
    resolutionStrategy.capabilitiesResolution.withCapability("org.ow2.asm:asm") {
        selectHighestVersion()
    }
}
// end::use_highest_asm[]

// tag::declare_capability[]
dependencies {

        buildFile << """
            dependencies {
                conf "org.utils:api:${selector}"
            }

            configurations.all {
                resolutionStrategy {
                    componentSelection {
                        all ${rules[rule]}
                    }
                }
            }

            checkDeps.doLast {