import org.gradle.api.specs.Spec;
import org.gradle.internal.action.ConfigurableRule;

class SpecConfigurableRule {

    private final ConfigurableRule<ComponentMetadataContext> configurableRule;
    private final Spec<ModuleVersionIdentifier> spec;

    SpecConfigurableRule(ConfigurableRule<ComponentMetadataContext> configurableRule, Spec<ModuleVersionIdentifier> spec) {

    private final List<SpecConfigurableRule> classRules = Lists.newArrayListWithExpectedSize(5);

    ClassBasedMetadataRuleWrapper(SpecConfigurableRule classRule) {
        this.classRules.add(classRule);
    }

    @Override
    public boolean isClassBased() {
        return true;
    }

    @Override
    public Collection<SpecConfigurableRule> getClassRules() {
        return classRules;
    }

        def ruleWrapper = iterator.next()
        ruleWrapper.isClassBased()
        ruleWrapper.classRules.containsAll([rule1, rule2])
    }

    private SpecConfigurableRule configurableRule() {
        Mock(SpecConfigurableRule) {
            getConfigurableRule() >> Stub(ConfigurableRule)
        }
    }

import java.util.Collection;

interface MetadataRuleWrapper {
    DisplayName getDisplayName();

    boolean isClassBased();

    Collection<SpecConfigurableRule> getClassRules();

    SpecRuleAction<? super ComponentMetadataDetails> getRule();

    void addClassRule(SpecConfigurableRule ruleAction);

    public boolean isClassBased() {
        return false;
    }

    @Override
    public Collection<SpecConfigurableRule> getClassRules() {
        throw new UnsupportedOperationException("This operation is not supported by this implementation");
    }

    @Override
    public void addClassRule(SpecConfigurableRule ruleAction) {
        throw new UnsupportedOperationException("This operation is not supported by this implementation");

    }

    private SpecConfigurableRule addRuleForModule(String notation) {
        metadataRuleContainer.addClassRule(new SpecConfigurableRule(DefaultConfigurableRule.of(TestComponentMetadataRule), new DefaultComponentMetadataHandler.ModuleVersionIdentifierSpec(moduleIdentifierNotationParser.parseNotation(notation))))
    }

    private SpecConfigurableRule addRuleForModuleWithParams(String notation, Object... params) {

        Spec<ModuleVersionIdentifier> spec = new ModuleVersionIdentifierSpec(moduleIdentifier);
        return new SpecConfigurableRule(instantiatingAction, spec);
    }

    private SpecConfigurableRule createAllSpecConfigurableRule(ConfigurableRule<ComponentMetadataContext> instantiatingAction) {
        return new SpecConfigurableRule(instantiatingAction, Specs.satisfyAll());
    }

    @Override

    }

    private void addRule() {
        if (onAdd != null) {
            onAdd.accept(lastAdded.getDisplayName());
        }
        rules.add(lastAdded);
    }

    void addClassRule(SpecConfigurableRule ruleAction) {
        if (lastAdded != null && lastAdded.isClassBased()) {
            lastAdded.addClassRule(ruleAction);
        } else {
            lastAdded = new ClassBasedMetadataRuleWrapper(ruleAction);

    private Action<ComponentMetadataContext> collectRulesAndCreateAction(Collection<SpecConfigurableRule> rules, ModuleVersionIdentifier id, Instantiator instantiator) {
        if (rules.isEmpty()) {
            return Actions.doNothing();
        }
        ArrayList<ConfigurableRule<ComponentMetadataContext>> collectedRules = new ArrayList<>();
        for (SpecConfigurableRule classBasedRule : rules) {

            metadata.addVariant("variant$it", ImmutableAttributes.EMPTY)
        }

        and: "a rule that adds a variant to all components"
        metadataRuleContainer.addClassRule(
            new SpecConfigurableRule(
                DefaultConfigurableRule.of(TestAddVariantComponentMetadataRule),
                Specs.satisfyAll()
            )
        )