}
    }

    private final ModelSchemaStore schemaStore;
    private final ModelReference<ComponentSpecFactory> registryRef;

    public ComponentTypeModelRuleExtractor(ModelSchemaStore schemaStore) {
        this.schemaStore = schemaStore;
        this.registryRef = COMPONENT_SPEC_FACTORY_MODEL_REFERENCE;
    }

    @Nullable
    @Override

                return extract(key.publicType, key.viewTypes, key.delegateType);
            }
        });

    private final ModelSchemaStore schemaStore;

    public DefaultStructBindingsStore(ModelSchemaStore schemaStore) {
        this.schemaStore = schemaStore;
    }

    @Override
    public <T> StructBindings<T> getBindings(ModelType<T> publicType) {

    private final ModelSchemaStore schemaStore;
    private final StructBindingsStore structBindingsStore;

    public ModelRuleExtractor(Iterable<MethodModelRuleExtractor> handlers, ManagedProxyFactory proxyFactory, ModelSchemaStore schemaStore, StructBindingsStore structBindingsStore) {
        this.handlers = handlers;
        this.proxyFactory = proxyFactory;
        this.schemaStore = schemaStore;

        return new DefaultModelSchemaStore(modelSchemaExtractor);
    }

    @Provides
    protected StructBindingsStore createStructBindingsStore(ModelSchemaStore schemaStore) {
        return new DefaultStructBindingsStore(schemaStore);
    }

    @Provides
    protected ModelRuleSourceDetector createModelRuleSourceDetector() {
        return new ModelRuleSourceDetector();
    }

    @Provides

    @Override
    protected NodeInitializerRegistry createNodeInitializerRegistry(ModelSchemaStore schemaStore, StructBindingsStore structBindingsStore) {
        // Not shared across tests as test may add constructible types only applying to that particular test
        return new DefaultNodeInitializerRegistry(schemaStore, structBindingsStore)
    }

    def "should fail with a contextual exception for managed collections properties"() {

    final static ModelType<ComponentSpecFactory> FACTORY_REGISTRY_TYPE = ModelType.of(ComponentSpecFactory)
    ComponentTypeModelRuleExtractor ruleHandler = new ComponentTypeModelRuleExtractor(schemaStore)

    @Override
    Class<? extends Annotation> getAnnotation() { return ComponentType }

    Class<?> ruleClass = Rules

    def "applies ComponentModelBasePlugin and creates component type rule"() {

import static org.junit.Assume.assumeTrue

class DefaultStructBindingsStoreTest extends Specification {
    def schemaStore = new DefaultModelSchemaStore(DefaultModelSchemaExtractor.withDefaultStrategies())
    def bindingStore = new DefaultStructBindingsStore(schemaStore)

    def "extracts empty"() {
        def bindings = extract(Object)
        expect:

import static org.gradle.model.ModelTypeTesting.fullyQualifiedNameOf

class ModelRuleExtractorTest extends ProjectRegistrySpec {
    def extractor = new ModelRuleExtractor(MethodModelRuleExtractors.coreExtractors(SCHEMA_STORE), MANAGED_PROXY_FACTORY, SCHEMA_STORE, STRUCT_BINDINGS_STORE)
    ModelRegistry registry = new DefaultModelRegistry(extractor, null)

    static class ModelThing {
        final String name

        ModelThing(String name) {

        def key = [backingStateType, managedType, delegateType]
        Class<?> generatedClass = generated[key] as Class<? extends T>
        if (generatedClass == null) {
            def managedSchema = (StructSchema) schemaStore.getSchema(managedType)
            def bindings = structBindingsStore.getBindings(ModelType.of(managedType), [], delegateType == null ? null : ModelType.of(delegateType))