import org.apache.commons.io.FileUtils
import org.gradle.api.tasks.TaskDependencyMatchers
import org.gradle.language.assembler.AssemblerSourceSet
import org.gradle.language.assembler.tasks.Assemble
import org.gradle.model.ModelMap
import org.gradle.nativeplatform.NativeBinary
import org.gradle.nativeplatform.NativeExecutableBinarySpec
import org.gradle.nativeplatform.NativeExecutableSpec
import org.gradle.nativeplatform.NativeLibrarySpec

 * limitations under the License.
 */

package org.gradle.model.internal.manage.schema;

import org.gradle.model.internal.type.ModelType;

/**
 * The schema for a {@link org.gradle.model.ModelMap} element.
 */
public class ModelMapSchema<T, E> extends CollectionSchema<T, E> implements CompositeSchema<T> {
    public ModelMapSchema(ModelType<T> type, ModelType<E> elementType) {
        super(type, elementType);
    }

                c.items.add new Widget()
                c.widgets.add new Widget()
                c.rawWidgets.add new Widget()
            }

            @Mutate
            void addCheckTask(ModelMap<Task> tasks, Container c) {
                tasks.create('check') {
                    assert c.items.size() == 1
                    assert c.widgets.size() == 1
                    assert c.rawWidgets.size() == 1

            include ":used", ":unused"
        """

        file("unused/build.gradle") << """
            class Rules extends RuleSource {
                @Mutate
                void unbound(ModelMap<Task> tasks, String unbound) {
                }
            }

            apply type: Rules
        """

        then:
        succeeds ":used:tasks"
    }

 *     void register(TypeBuilder<SampleBinary> builder) {
 *         builder.defaultImplementation(DefaultSampleBinary)
 *     }
 *
 *     {@literal @}ComponentBinaries
 *     void createBinariesForSampleLibrary(ModelMap<SampleBinary> binaries, SampleComponent component) {
 *         binaries.create("${component.name}Binary", SampleBinary)
 *     }
 * }
 * </pre>
 */
@Retention(RetentionPolicy.RUNTIME)

    def setup() {
        buildFile << '''
@Managed
interface Thing {
    String getValue()
    void setValue(String v)
}

class MyPlugin extends RuleSource {
    @Model
    void things(ModelMap<Thing> things) { }
}

apply plugin: MyPlugin
'''
    }

    def "nested create rule is executed only as required"() {
        buildFile << '''
model {
    tasks {
        show(Task) {

    void setFirstName(String n)

    String getLastName()
    void setLastName(String n)

    Address getAddress()
}

class PersonRules extends RuleSource {
    @Model
    void people(ModelMap<Person> people) {
    }
}

apply plugin: PersonRules

// tag::configure-rule[]
// tag::create-rule[]
// tag::rule-inputs[]
// tag::create-rule-no-config[]
// tag::managed-type-nested-config-rule[]

        given:
        buildFile << '''
class Thing { }

class Rules extends RuleSource {
    @Model
    Thing thing() {
        return new Thing()
    }

    @Mutate
    void tasks(ModelMap<Task> tasks, @Path("thing") ModelElement thing) {
        tasks.create("show") {
            doLast {
                println "thing: $thing"
                println "name: $thing.name"

    def store = new DefaultModelSchemaStore(DefaultModelSchemaExtractor.withDefaultStrategies())

    def "assembles schema for model map"() {
        expect:
        def schema = store.getSchema(ModelTypes.modelMap(String))
        schema instanceof ModelMapSchema
        schema instanceof ManagedImplSchema
        schema instanceof CompositeSchema
        !(schema instanceof StructSchema)

            @ComponentType
            void register(TypeBuilder<SampleComponent> builder) {
            }

            @Mutate
            void createSampleComponentComponents(ModelMap<SampleComponent> componentSpecs) {
                componentSpecs.create("main")
            }
        }

        apply plugin:CustomComponentPlugin

        model {
            components {