import org.gradle.api.artifacts.ComponentMetadata;
import org.gradle.api.artifacts.ivy.IvyModuleDescriptor;

import javax.annotation.Nullable;

public interface MetadataProvider {
    @Nullable
    ComponentMetadata getComponentMetadata();

    @Nullable
    IvyModuleDescriptor getIvyModuleDescriptor();

    boolean isUsable();

import org.gradle.api.internal.artifacts.ivyservice.ivyresolve.MetadataProvider
import spock.lang.Specification

class DefaultComponentSelectionTest extends Specification {
    DefaultComponentSelection selection
    MetadataProvider metadataProvider = Mock()

    def setup() {
        selection = new DefaultComponentSelection(Stub(ModuleComponentIdentifier), metadataProvider)
    }

    def "accepted by default"() {
        expect:

        }

        and:
        apply(metadataProvider)

        then:
        !componentSelection.rejected
        // rules are called in order
        closureCalled == 0..3
    }

    def "all non-rejecting targeted rules are evaluated"() {
        metadataProvider.isUsable() >> true
        metadataProvider.getComponentMetadata() >> Mock(ComponentMetadata)

        return isRejectedByRule(candidateIdentifier, componentSelectionRules.getRules(), metadataProvider);
    }

    @Nullable
    private RejectedByRuleVersion isRejectedByRule(ModuleComponentIdentifier candidateIdentifier, Collection<SpecRuleAction<? super ComponentSelection>> rules, MetadataProvider metadataProvider) {

    void apply(ComponentSelectionInternal selection, Collection<SpecRuleAction<? super ComponentSelection>> specRuleActions, MetadataProvider metadataProvider) {
        if (processRules(specRuleActions, withNoInputs, selection, metadataProvider)) {
            processRules(specRuleActions, withInputs, selection, metadataProvider);
        }
    }

        this.candidate = candidate;
        this.metadataProvider = metadataProvider;
    }

    @Override
    public ModuleComponentIdentifier getCandidate() {
        return candidate;
    }

    @Override
    public ComponentMetadata getMetadata() {
        if (metadataProvider.isUsable()) {
            return metadataProvider.getComponentMetadata();

        resolveState.attributesFactory >> AttributeTestUtil.attributesFactory()
    }

    def "caches metadata result"() {
        when:
        metadataProvider.componentMetadata
        metadataProvider.componentMetadata

        then:
        1 * resolveState.resolve() >> {
            def result = new DefaultBuildableModuleComponentMetaDataResolveResult()

        def binary = new File("any")
        when:
        def metadata = metadataProvider(compiler).getCompilerMetaData([]) { it.executable(binary) }

        then:
        interaction compilerShouldBeExecuted

        when:
        def newMetadata = metadataProvider(compiler).getCompilerMetaData([]) { it.executable(binary) }

        then:
        0 * _
        newMetadata.is(metadata)

            DependencyMetaDataProvider metaDataProvider,
            ComponentIdentifierFactory componentIdentifierFactory,
            ImmutableModuleIdentifierFactory moduleIdentifierFactory,
            ProjectStateRegistry projectStateRegistry,
            LocalComponentGraphResolveStateFactory localResolveStateFactory
        ) {
            this.metaDataProvider = metaDataProvider;

    private final Instantiator instantiator;
    private final DependencyMetaDataProvider metaDataProvider;
    private final FileResolver fileResolver;
    private final TaskDependencyFactory taskDependencyFactory;

    public PublishArtifactNotationParserFactory(Instantiator instantiator, DependencyMetaDataProvider metaDataProvider, FileResolver fileResolver, TaskDependencyFactory taskDependencyFactory) {