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

            type == "artifact-type"
            classifier == "artifact-classifier"
            scope == "runtime"
            excludeRules != [excludeRule] as Set
            excludeRules.size() == 1
            excludeRules[0].group == '*'
            excludeRules[0].module == '*'
        }
    }

    def 'adopts platform in #scope declaration from added components'() {
        given:

        when:
        dependency.exclude(excludeArgs1)
        dependency.exclude(excludeArgs2)

        then:
        dependency.excludeRules.size() == 2
        dependency.excludeRules.contains(new DefaultExcludeRule("aGroup", null))
        dependency.excludeRules.contains(new DefaultExcludeRule(null, "aModule"))
    }

    void "can add artifacts"() {
        def artifact1 = Mock(DependencyArtifact)

        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 writeExcludes(Set<ExcludeRule> excludeRules) throws IOException {
        if (excludeRules.isEmpty()) {
            return;
        }
        writeArray("excludes", () -> {
            for (ExcludeRule excludeRule : excludeRules) {
                writeObject(() -> {
                    write("group", elvis(excludeRule.getGroup(), "*"));

        def exclude = Mock(ExcludeRule)

        when:
        moduleDependency.group >> "org"
        moduleDependency.name >> "name"
        moduleDependency.version >> "version"
        moduleDependency.targetConfiguration >> "dep-configuration"
        moduleDependency.artifacts >> [artifact]
        moduleDependency.excludeRules >> [exclude]