// This file is a spike of what externally published rules for capabilities could look like.
//
// The idea is that such "rules" could be published, then applied by a plugin.
//
// Whenever two libraries provide the same capability, for example, "log4j" and "log4j-over-slfj4",
// it's illegal to have both of them on the classpath. Use this file to declare that they provide
// the same capability, and that we prefer to use slf4j in this case.
[

        StringBuilder sb = new StringBuilder("capabilit");
        if (capabilities.size() > 1) {
            sb.append("ies ");
            sb.append(describeCapabilities(targetComponentId, capabilities));
        } else {
            sb.append("y ").append(describeCapabilities(targetComponentId, capabilities));
        }
        return sb.toString();
    }

     */
    private static class VariantIdentity {
        private final ImmutableAttributes attributes;
        private final ImmutableCapabilities capabilities;

        private VariantIdentity(ImmutableAttributes attributes, ImmutableCapabilities capabilities) {
            this.attributes = attributes;
            this.capabilities = capabilities;
        }

                    outgoing {
                        // Force identical capabilities as the default
                        capability('org.gradle:sample:1.0')
                    }
                }
            }""".stripIndent()

        succeeds("outgoingVariants")
        expect:

    }

    @Override
    public void capability(Object notation) {
        if (canCreate) {
            if (capabilities == null) {
                capabilities = domainObjectCollectionFactory.newDomainObjectSet(Capability.class);
            }
            if (notation instanceof Provider) {
                capabilities.addLater(((Provider<?>) notation).map(capabilityNotationParser::parseNotation));
            } else {

--------------------------------------------------
My second custom configuration

Capabilities
    - :myLib:unspecified (default capability)
Attributes
    - org.gradle.category = documentation

--------------------------------------------------
Variant someConf
--------------------------------------------------
My first custom configuration

Capabilities
    - :myLib:unspecified (default capability)
Attributes

package org.gradle.api.artifacts;

import org.gradle.api.provider.Provider;
import org.gradle.internal.HasInternalProtocol;

/**
 * The capabilities requested for a dependency. This is used in variant-aware dependency
 * management, to select only variants which provide the requested capabilities. By
 * default, Gradle will only look for variants which provide the "implicit" capability,

     */
    private static boolean fastContainsImplicitCapability(ImmutableSet<ImmutableCapability> capabilities) {
        if (capabilities.isEmpty()) {
            return true;
        }

        return capabilities.size() == 1 && capabilities.iterator().next() instanceof ShadowedCapability;
    }

    private Capability unwrap(Capability capability) {

        this.name = name
        this.attributes = attributes
        this.dependencies = dependencies
        this.dependencyConstraints = dependencyConstraints
        this.artifacts = artifacts
        this.capabilities = capabilities
        this.availableAt = availableAt
    }

                    }
                    capabilities {
                        requireCapability('org.test:cap1')
                    }
                }
                conf('org:test:1.0') {
                    attributes {
                        attribute(CUSTOM2_ATTRIBUTE, 'c2')
                    }
                    capabilities {
                        requireCapability('org.test:cap2')