private val moduleToRemove: Set<String>
) : ComponentMetadataRule {
    override fun execute(context: ComponentMetadataContext) {
        context.details.allVariants {
            withDependencies {
                removeAll { moduleToRemove.contains(it.name) }
            }
        }
    }
}


abstract class DependencyRemovalByGroupRule @Inject constructor(

// tag::configuration-with-dependencies[]
configurations {
    create("implementation") {
        withDependencies {
            val dep = this.find { it.name == "to-modify" } as ExternalModuleDependency
            dep.version {
                strictly("1.2")
            }
        }
    }
}

// tag::configuration-with-dependencies[]
configurations {
    implementation {
        withDependencies { DependencySet dependencies ->
            ExternalModuleDependency dep = dependencies.find { it.name == 'to-modify' } as ExternalModuleDependency
            dep.version {
                strictly "1.2"
            }
        }
    }
}

        then:
        output.contains("[foo-1.0.jar]\n[foo-1.0.jar]")
    }

    @Issue("https://github.com/gradle/gradle/issues/24234")
    def "configuration extensions can be changed in withDependencies during resolution"() {
        given:
        mavenRepo.module("org", "foo").publish()
        buildFile << """
            def attr = Attribute.of('org.example.attr', String)

            repositories {

    /**
     * Register a rule that modifies the dependencies of this variant.
     *
     * @param action the action that performs the dependencies adjustment
     */
    void withDependencies(Action<? super DirectDependenciesMetadata> action);

    /**
     * Register a rule that modifies the dependency constraints of this variant.
     *

                void execute(ComponentMetadataContext context) {
                    ["compile", "runtime"].each { base ->
                        context.details.withVariant(base) {
                            withDependencies {
                                dependencies.each {
                                    add(it)
                                }
                            }
                        }
                    }

                return dependency.withRequested(newSelector);
        });
        return this.withDependencies(transformed);
    }

    private IvyModuleResolveMetadata withDependencies(List<IvyDependencyDescriptor> transformed) {
        return new DefaultIvyModuleResolveMetadata(this, transformed);
    }

    @Override

    }

    @Override
    public List<? extends ModuleDependencyMetadata> getDependencies() {
        return getConfigDependencies();
    }

    public RealisedConfigurationMetadata withDependencies(ImmutableList<ModuleDependencyMetadata> dependencies) {
        return new RealisedConfigurationMetadata(
            getComponentId(),
            getName(),
            isTransitive(),
            isVisible(),

        this.dependencyMetadataNotationParser = dependencyMetadataNotationParser;
        this.dependencyConstraintMetadataNotationParser = dependencyConstraintMetadataNotationParser;
    }

    @Override
    public void withDependencies(Action<? super DirectDependenciesMetadata> action) {

        publishTestPlugin("1.2", "from 1.2")
        useCustomRepository()

        buildFile << """
            buildscript {
                configurations.classpath {
                    withDependencies { dependencies ->
                       dependencies.configureEach { dep ->
                            dep.attributes {