Set<Bundling> candidateValues = details.getCandidateValues();
            if (candidateValues.contains(consumerValue)) {
                details.closestMatch(consumerValue);
                return;
            }
            if (consumerValue == null) {
                Bundling embedded = null;
                for (Bundling candidateValue : candidateValues) {

        Set<Object> candidateValues = getCandidateValues(compatible, c -> getCandidateValue(c, a));
        if (candidateValues.size() <= 1) {
            return;
        }

        Set<Object> matches = schema.disambiguate(requestedAttributes.get(a), requestedAttributeValues[a], candidateValues);
        if (matches != null && matches.size() < candidateValues.size()) {

                void execute(MultipleCandidatesDetails<Flavor> details) {
                    assert details.candidateValues*.name as Set == ['ONE', 'TWO'] as Set
                    details.candidateValues.each { producerValue ->
                        if (producerValue.name == 'TWO') {
                            details.closestMatch(producerValue)
                        }

            }

            class CategorySelectionRule implements AttributeDisambiguationRule<String> {
                void execute(MultipleCandidatesDetails<String> details) {
                    if (details.candidateValues.contains('chocolate')) {
                        details.closestMatch('chocolate')
                    }
                }
            }

            dependencies.attributesSchema {

            details.compatible()
        }
    }
}
class FlavorSelectionRule implements AttributeDisambiguationRule<String> {
    void execute(MultipleCandidatesDetails<String> details) {
        if (details.candidateValues.contains('tasty')) {
            details.closestMatch('tasty')
        }
    }
}

dependencies.attributesSchema {
    attribute(buildType) {
        compatibilityRules.add(BuildTypeCompatibilityRule)

    static class CustomSelectionRule implements AttributeDisambiguationRule<Flavor> {
        @Override
        void execute(MultipleCandidatesDetails<Flavor> details) {
            details.closestMatch(details.candidateValues.first())
        }
    }

    def "compatibility rules can mark values as compatible"() {
        def attr = Attribute.of(Flavor)

        given:

            }

            class DisRule implements AttributeDisambiguationRule<Thing> {
                void execute(MultipleCandidatesDetails<Thing> details) {
                    for (Thing t: details.candidateValues) {
                        if (t.name == 'blue') {
                            details.closestMatch(t)
                            return
                        }
                    }
                }

            @Override
            void execute(MultipleCandidatesDetails details) {
                if (details.consumerValue == "requested") {
                    assert details.candidateValues == ["best", "compatible"] as Set
                    details.closestMatch("best")
                }
            }
        }
        schema.attribute(usage)
        schema.accept(usage, "requested", "best")

            discarded.add(candidate);
        }

        @Override
        public <T extends HasAttributes> void candidateAttributeDoesNotMatch(T candidate, Attribute<?> attribute, Object requestedValue, AttributeValue<?> candidateValue) {
            recordDiscardedCandidate(candidate);
        }
    }