String leftModule = left.getModule();
        if (right instanceof ModuleIdExclude) {
            ModuleIdExclude mie = (ModuleIdExclude) right;
            if (mie.getModuleId().getName().equals(leftModule)) {
                return left;
            }
        }
        if (right instanceof ModuleIdSetExclude) {
            ModuleIdSetExclude ids = (ModuleIdSetExclude) right;

        when:
        Exclude exclude = new DefaultExcludeRuleConverter(moduleIdentifierFactory).convertExcludeRule(new DefaultExcludeRule(group, module))

        then:
        exclude.getModuleId().getGroup() == group
        exclude.getModuleId().getName() == module
        exclude.getArtifact() == null
        exclude.getMatcher() == null

        where:
        configurationName | configurations

 * The module identifier will always be non-null. If what you want to express
 * is that a module cannot be found in a repository, independently of its version,
 * then it's enough to just look at the module id using {@link #getModuleId()}.
 * <p></p>
 * However, if you have to differentiate depending on the version number (for example,
 * some versions of a module are found in one repository, others in a different repository),

 */
package org.gradle.api.internal.artifacts.ivyservice.resolveengine.excludes.specs;

import org.gradle.api.artifacts.ModuleIdentifier;

public interface ModuleIdExclude extends ExcludeSpec {
    ModuleIdentifier getModuleId();

 */
public interface ExcludeMetadata {
    /**
     * The coordinates of the module to be excluded.
     * A '*' value for group or name indicates a wildcard match.
     */
    ModuleIdentifier getModuleId();

    /**
     * The attributes of the artifact to be excluded. A '*' value for any attribute indicates a wildcard match.
     * NOTE: only supported for exclude rules sourced from an Ivy module descriptor (ivy.xml).

        ArtifactId id = excludeRule.getId();
        IvyArtifactName artifactExclusion = artifactForIvyExclude(id);
        return new DefaultExclude(
            moduleIdentifierFactory.module(id.getModuleId().getOrganisation(), id.getModuleId().getName()), artifactExclusion, excludeRule.getConfigurations(), excludeRule.getMatcher().getName());
    }

    private IvyArtifactName artifactForIvyExclude(ArtifactId id) {

            if (!PatternMatchers.isExactMatcher(rule.getMatcher())) {
                return factory.ivyPatternExclude(rule.getModuleId(), rule.getArtifact(), rule.getMatcher());
            }

            ModuleIdentifier moduleId = rule.getModuleId();
            IvyArtifactName artifact = rule.getArtifact();
            boolean anyOrganisation = isWildcard(moduleId.getGroup());

    }

    private DefaultModuleIdExclude(ModuleIdentifier moduleId) {
        this.moduleId = moduleId;
        this.hashCode = moduleId.hashCode();
    }

    @Override
    public ModuleIdentifier getModuleId() {
        return moduleId;
    }

    @Override
    public boolean excludes(ModuleIdentifier module) {
        return moduleId.equals(module);
    }

    @Override

        }

        @Override
        public ExcludeSpec doIntersect(GroupExclude left, ModuleIdExclude right, ExcludeFactory factory) {
            String group = left.getGroup();
            if (right.getModuleId().getGroup().equals(group)) {
                return right;
            } else {
                return factory.nothing();
            }
        }
    }

    @NonNullApi

    }

    @Override
    public String toString() {
        return "{exclude moduleId: " + moduleId + ", artifact: " + artifact + "}";
    }

    @Override
    public ModuleIdentifier getModuleId() {
        return moduleId;
    }

    @Override
    public IvyArtifactName getArtifact() {
        return artifact;
    }

    @Override
    public Set<String> getConfigurations() {