private final Set<ExcludeRule> excludeRules;

    public DefaultIvyDependency(
        String organisation,
        String module,
        String revision,
        String confMapping,
        boolean transitive,
        @Nullable String revConstraint,
        Set<DependencyArtifact> artifacts,
        Set<ExcludeRule> excludeRules
    ) {
        this.organisation = organisation;

    private final String scope;
    private final Set<ExcludeRule> excludeRules;
    private final boolean optional;

    public DefaultMavenDependency(
        String groupId,
        String artifactId,
        @Nullable String version,
        @Nullable String type,
        @Nullable String classifier,
        @Nullable String scope,
        Set<ExcludeRule> excludeRules,
        boolean optional
    ) {

        }
        return capabilities;
    }

    @Override
    public Set<ExcludeRule> getGlobalExcludes() {
        if (excludeRules == null) {
            this.excludeRules = ImmutableSet.copyOf(((ConfigurationInternal) configuration).getAllExcludeRules());
        }
        return excludeRules;
    }

        return artifact.getExtension() != null ? artifact.getExtension() : artifact.getType();
    }

    protected List<ExcludeMetadata> convertExcludeRules(Set<ExcludeRule> excludeRules) {
        return CollectionUtils.collect((Iterable<ExcludeRule>) excludeRules, excludeRuleConverter::convertExcludeRule);
    }

    protected List<IvyArtifactName> convertArtifacts(Set<DependencyArtifact> dependencyArtifacts) {

        final Set<ExcludeRule> excludeRules;
        final List<Attribute> attributes;
        final List<Capability> requestedCapabilities;
        final boolean endorseStrictVersions;
        final String reason;
        final ArtifactSelector artifactSelector;

        public Dependency(
            DependencyCoordinates coordinates,
            Set<ExcludeRule> excludeRules,

            </tr>
            <tr>
                <td>artifacts</td>
            </tr>
            <tr>
                <td>allArtifacts</td>
            </tr>
            <tr>
                <td>excludeRules</td>
            </tr>
            <tr>
                <td>resolutionStrategy</td>
            </tr>
        </table>
    </section>
    <section>
        <title>Methods</title>
        <table>

    }

    private void assertExcludeRuleContainerHasCorrectExcludeRules(Set<ExcludeRule> excludeRules, Map... excludeRuleArgs) {
        List<Map> foundRules = new ArrayList<Map>();
        for (ExcludeRule excludeRule : excludeRules) {
            for (Map excludeRuleArg : excludeRuleArgs) {
                if (matchingExcludeRule(excludeRule, excludeRuleArg)) {
                    foundRules.add(excludeRuleArg);

        def excludeRule = Mock(ExcludeRule)
        ExcludeMetadata ivyExcludeRule = Mock(Exclude)

        when:
        def metaData = create()

        then:
        1 * configuration.runDependencyActions()

        when:
        def excludes = metaData.excludes

        then:
        1 * configuration.excludeRules >> ([excludeRule] as Set)

        delegate.addDependency(dependency)

    override fun getName(): String =
        delegate.name

    override fun getExcludeRules(): MutableSet<ExcludeRule> =
        delegate.excludeRules

    override fun addArtifact(artifact: DependencyArtifact): ModuleDependency =
        delegate.addArtifact(artifact)

    override fun artifact(configureClosure: Closure<Any>): DependencyArtifact =

 * limitations under the License.
 */
package org.gradle.api.artifacts;

/**
 * An {@code ExcludeRule} is used to describe transitive dependencies that should be excluded when resolving
 * dependencies.
 */
public interface ExcludeRule {
    String GROUP_KEY = "group";
    String MODULE_KEY = "module";

    /**