println "apply defaults"
              }

              @Mutate void customPeople(ModelSet<Person> people) {
                println "configure"
              }

              @Finalize void finalPeople(ModelSet<Person> people) {
                println "finalize"
              }
            }

            apply type: Rules

            model {

import org.gradle.language.base.LanguageSourceSet

@UnsupportedWithConfigurationCache(because = "software model")
class RuleSourceAppliedByRuleMethodIntegrationTest extends AbstractIntegrationSpec {
    def "@Rule method can apply rules to a particular target"() {
        buildFile << '''
            @Managed
            interface Thing {
                String getName()
                void setName(String name)
            }

                }
            }

            apply type: RulePlugin
        '''

        then:
        succeeds "echo"

        and:
        output.contains("person: Person 'someone'")
        output.contains("name: someone")
        output.contains("display-name: Person 'someone'")
    }

    def "rule method can apply defaults to a managed model element"() {
        when:

                void apply(Project target) {
                    target.tasks.register('fails', Fails)  {
                        color = flowProviders.buildWorkResult.map {
                            it.failure.present ? 'red' : 'green'
                        }
                    }
                }
            }

            apply type: FailsPlugin
        '''

        when:

                    List<String> strings() {
                      []
                    }
                }
            }

            apply type: MyPlugin
        """

        then:
        fails "tasks"

        and:
        failure.assertHasCause("Failed to apply plugin class 'MyPlugin'")
        failure.assertHasCause('''Type MyPlugin.Rules is not a valid rule source:

                        it.doLast {
                            println "value: $thing.unmanaged.value"
                        }
                    }
                }
            }

            apply type: RulePlugin
        '''

        then:
        succeeds "echo"

        and:
        output.contains('value: foo')
    }

    def "unmanaged property of managed type can be targeted by rules"() {

                fixture.newGroovyExecJavaexecSnippets(method, groovySpecFactory.apply(fixture))
            }
        }

        @Override
        SnippetsFactory getKotlin() {
            return makeFactory(method) { fixture ->
                fixture.newKotlinExecJavaexecSnippets(method, kotlinSpecFactory.apply(fixture))
            }
        }

        @Override
        SnippetsFactory getJava() {

                    "fizz"
                }

                @Mutate
                void connectTasksToFirst(ModelMap<Task> tasks, @Path("first") String first) {
                }
            }

            apply type: Rules

            model {
                second {
                    $.third
                }
            }
        '''

        then:
        fails "tasks"

        and:

        pluginDir.file("src/main/kotlin/SomePlugin.kt") << """
            import ${Project.name}
            import ${Plugin.name}

            class SomePlugin: Plugin<Project> {
                override fun apply(project: Project) {
                    project.tasks.register("producer", ProducerTask::class.java) {
                        outFile.set(project.layout.buildDirectory.file("intermediate.txt"))
                    }

                        it.doLast {
                            println "name: $parent.child.parent.name"
                        }
                    }
                }
            }

            apply type: RulePlugin
        '''

        then:
        succeeds "echo"

        and:
        output.contains("name: parent")
    }