import org.gradle.internal.HasInternalProtocol;

/**
 * Provides means to substitute a different dependency during resolution.
 *
 * @since 2.5
 */
@HasInternalProtocol
public interface DependencySubstitution {
    /**
     * The requested dependency, before it is resolved.
     * The requested dependency does not change even if there are multiple dependency substitution rules
     * that manipulate the dependency metadata.

     * <pre class='autoTested'>
     * configurations { main }
     * // add dependency substitution rules
     * configurations.main.resolutionStrategy.dependencySubstitution {
     *   // Use a rule to change the dependency module while leaving group + version intact
     *   all { DependencySubstitution dependency -&gt;
     *     if (dependency.requested instanceof ModuleComponentSelector &amp;&amp; dependency.requested.module == 'groovy-all') {

        }

        @Override
        public void execute(DependencySubstitution dependencySubstitution) {
            if (substituted.equals(dependencySubstitution.getRequested())) {
                super.execute(dependencySubstitution);
                ((DependencySubstitutionInternal) dependencySubstitution).useTarget(substitute, selectionReason);
            }
        }

    }

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.api.internal.artifacts.ivyservice.dependencysubstitution;

import org.gradle.api.Action;
import org.gradle.api.artifacts.DependencySubstitution;
import org.gradle.internal.Actions;

/**
 * A service that injects dependency substitution rules into the build.
 */
public interface DependencySubstitutionRules {

                }
            }
        }

        where:
        notation << [
            """dependencySubstitution {
                  substitute module('org:lib:1.0') using module('org:lib:1.0') withoutClassifier()
               }""",
            """dependencySubstitution.all { DependencySubstitution dependency ->

    }

    @Override
    public void registerSubstitution(Action<DependencySubstitution> substitutions) {
        substitutionRules.add(substitutions);
    }

    @Override
    public Action<DependencySubstitution> getRuleAction() {
        List<Action<DependencySubstitution>> allActions = new ArrayList<>();
        if (!availableModules.isEmpty()) {

            <tr>
                <td>forcedModules</td>
            </tr>
            <tr>
                <td>componentSelection</td>
            </tr>
            <tr>
                <td>dependencySubstitution</td>
            </tr>
            <tr>
                <td>capabilitiesResolution</td>
            </tr>
        </table>
    </section>
    <section>
        <title>Methods</title>
        <table>

    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

        }
    }

    @Override
    public void execute(DependencySubstitution sub) {
        DependencySubstitutionInternal dependencySubstitution = (DependencySubstitutionInternal) sub;
        // Use the result of previous rules as the input for dependency substitution
        ComponentSelector requested = dependencySubstitution.getTarget();
        if (requested instanceof ModuleComponentSelector) {

     * The action receives an instance of {@link DependencySubstitutions} which can be configured with substitution rules.
     * Project dependencies are resolved in the context of the included build.
     *
     * @see org.gradle.api.artifacts.ResolutionStrategy#dependencySubstitution(Action)
     * @see DependencySubstitutions
     */
    void dependencySubstitution(Action<? super DependencySubstitutions> action);