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 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);

            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()
            )
        )