this.configurableRule = configurableRule;
        this.spec = spec;
    }

    public ConfigurableRule<ComponentMetadataContext> getConfigurableRule() {
        return configurableRule;
    }

    public Spec<ModuleVersionIdentifier> getSpec() {
        return spec;
    }

    }

    @Override
    public DisplayName getDisplayName() {
        return Describables.of(classRules.stream()
            .map(SpecConfigurableRule::getConfigurableRule)
            .map(ConfigurableRule::getRuleClass)
            .map(Class::getName)
            .collect(Collectors.joining(",")));
    }

        ruleWrapper.isClassBased()
        ruleWrapper.classRules.containsAll([rule1, rule2])
    }

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

            lastAdded.addClassRule(ruleAction);
        } else {
            lastAdded = new ClassBasedMetadataRuleWrapper(ruleAction);
            addRule();
        }
        rulesHash = 31 * rulesHash + ruleAction.getConfigurableRule().hashCode();
    }

    boolean isClassBasedRulesOnly() {
        return classBasedRulesOnly;
    }

    boolean isEmpty() {
        return rules.isEmpty();
    }

    @Override

        for (SpecConfigurableRule classBasedRule : rules) {
            if (classBasedRule.getSpec().isSatisfiedBy(id)) {
                collectedRules.add(classBasedRule.getConfigurableRule());
            }
        }
        return new InstantiatingAction<>(new DefaultConfigurableRules<>(collectedRules), instantiator, new ExceptionHandler());
    }