}
            ModelRegistrations.Builder registration = ModelRegistrations.of(modelPath).descriptor(getRuleDefinition().getDescriptor());
            buildRegistration(context, registration);
            registration.hidden(hidden);

public interface ExtractedModelRule {
    void apply(MethodModelRuleApplicationContext context, MutableModelNode target);

    List<? extends Class<?>> getRuleDependencies();

    MethodRuleDefinition<?, ?> getRuleDefinition();

    public AbstractExtractedModelRule(MethodRuleDefinition<?, ?> ruleDefinition) {
        this.ruleDefinition = ruleDefinition;
    }

    @Override
    public MethodRuleDefinition<?, ?> getRuleDefinition() {
        return ruleDefinition;
    }

        }

        @Override
        public void apply(MethodModelRuleApplicationContext context, MutableModelNode target) {
            MethodRuleDefinition<?, S> ruleDefinition = Cast.uncheckedCast(getRuleDefinition());
            MethodBackedModelAction<S> ruleAction = new MethodBackedModelAction<S>(ruleDefinition.getDescriptor(), ruleDefinition.getSubjectReference(), ruleDefinition.getTailReferences());

        }

        private class TypeRegistrationAction extends AbstractMethodRuleAction<ComponentSpecFactory> {
            public TypeRegistrationAction() {
                super(registryRef, getRuleDefinition().getDescriptor());
            }

            @Override
            public List<? extends ModelReference<?>> getInputs() {
                return emptyList();
            }

            @Override

        }

        @Override
        protected void buildRegistration(MethodModelRuleApplicationContext context, ModelRegistrations.Builder registration) {
            MethodRuleDefinition<R, S> ruleDefinition = getRuleDefinition();
            ModelType<R> modelType = ruleDefinition.getReturnType();
            List<ModelReference<?>> inputs = ruleDefinition.getReferences();
            ModelRuleDescriptor descriptor = ruleDefinition.getDescriptor();

            ModelReference<C> subject = ModelReference.of(componentType);
            ComponentBinariesRule<S, C> componentBinariesRule = new ComponentBinariesRule<S, C>(subject, componentType, binaryType, getRuleDefinition());
            RuleExtractorUtils.configureRuleAction(context, RuleApplicationScope.DESCENDANTS, ModelActionRole.Finalize, componentBinariesRule);
        }

        @Override

        }

        @Override
        public void apply(final MethodModelRuleApplicationContext context, MutableModelNode target) {
            MethodRuleDefinition<?, ?> ruleDefinition = getRuleDefinition();
            ModelReference<?> targetReference = ruleDefinition.getReferences().get(1);
            List<ModelReference<?>> inputs = ruleDefinition.getReferences().subList(2, ruleDefinition.getReferences().size());

        }

        @Override
        protected void buildRegistration(MethodModelRuleApplicationContext context, ModelRegistrations.Builder registration) {
            MethodRuleDefinition<R, S> ruleDefinition = getRuleDefinition();
            List<ModelReference<?>> bindings = ruleDefinition.getReferences();
            List<ModelReference<?>> inputs = bindings.subList(1, bindings.size());

                List<? extends Class<?>> getRuleDependencies() {
                    return [ImperativePlugin]
                }

                @Override
                MethodRuleDefinition<?, ?> getRuleDefinition() {
                    return ruleDefinition
                }
            }
        }
    }

    def "cannot apply a scoped rule that has dependencies"() {
        registry.registerInstance("values", "foo")