}

            @Managed
            interface OperatingSystem {
                String getName()
                void setName(String name)
            }

            class RulePlugin extends RuleSource {
                @Model
                void platform(Platform platform) {
                    platform.operatingSystem.name = "windows"
                }

                @Mutate

                                }
                            }
                        }
                    }
                }
            }
            class DeclarationRules extends RuleSource {
                @Mutate
                void mutateMyComponent(@Path("components.myComponent") $componentType component) {
                    component.data = "my component"
                }
                @Mutate

''')
    }

    def "method rule sources have simple type names and correct order"() {
        given:
        buildFile << """
${managedNumbers()}

class NumberRules extends RuleSource {
    @Model("myNumbers")
    void createRule(Numbers n) {
       n.setValue(5)
       n.setThreshold(0.8)
    }
    @Defaults void defaultsRule(Numbers n) {}
    @Mutate void mutateRule(Numbers n) {}

        ]
    }

    def "dollar method is only detected with no explicit receiver - #code"() {
        when:
        buildScript """
            class MyPlugin {
              static class Rules extends RuleSource {
                @Model
                String foo() {
                  "foo"
                }
              }
            }

            apply type: MyPlugin

            model {

    }

    @Override
    public void named(String name, Class<? extends RuleSource> ruleSource) {
        viewState.assertCanMutate();
        ModelRuleDescriptor descriptor = sourceDescriptor.append("named(%s, %s)", name, ruleSource.getName());
        ModelReference<T> subject = ModelReference.of(modelNode.getPath().child(name), elementType);

  - ${fullyQualifiedNameOf(itemClass)} (or assignment compatible type thereof)
  - ${ModelElement.name} (or assignment compatible type thereof)"""
    }

    static class NamedRules extends RuleSource {}

    def "named(String, RuleSource) fails when named element requested in chain filtered collection with incompatible type"() {
        when:

        }
    }

    private <T> StructSchema<T> getSchema(Class<T> source, RuleSourceValidationProblemCollector problems) {
        if (!RuleSource.class.isAssignableFrom(source) || !source.getSuperclass().equals(RuleSource.class)) {
            problems.add("Rule source classes must directly extend " + RuleSource.class.getName());
        }

        ModelSchema<T> schema = schemaStore.getSchema(source);

    }

    def "add rule source rule that applies to all components"() {
        def ruleSource = new Object()

        when:
        mockedHandler.all(ruleSource)

        then:
        1 * adapter.createFromRuleSource(ComponentMetadataDetails, ruleSource) >> ruleAction

        and:
        !mockedHandler.metadataRuleContainer.isEmpty()

        output.contains 'prop theThing     : NOT_A_TOASTER'
    }

    void 'scalar conversion works from a Groovy RuleSource'() {
        when:
        buildFile << CLASSES
        buildFile << '''
            class ConvertRules extends RuleSource {
                @Mutate
                void change(Props p) {
                    p.theBoolean = 'true'
                    p.thelong = '123'

            components(h -> h.all(rule));
            return this;
        }

        @Override
        public ComponentMetadataHandler all(Object ruleSource) {
            components(h -> h.all(ruleSource));
            return this;
        }

        @Override
        public ComponentMetadataHandler all(Class<? extends ComponentMetadataRule> rule) {