* 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";

    /**

        this.addedRules = new HashSet<ExcludeRule>(addedRules);
    }

    @Override
    public void add(Map<String, String> args) {
        maybeAdd(args);
    }

    public boolean maybeAdd(Map<String, String> args) {
        if (addedRules == null) {
            addedRules = new HashSet<ExcludeRule>();
        }

package org.gradle.api.publish.ivy.internal.dependency;

import org.gradle.api.artifacts.ExcludeRule;

public class DefaultIvyExcludeRule implements IvyExcludeRule {

    private final ExcludeRule excludeRule;
    private final String ivyConfiguration;

    public DefaultIvyExcludeRule(ExcludeRule excludeRule, String ivyConfiguration) {
        this.excludeRule = excludeRule;
        this.ivyConfiguration = ivyConfiguration;
    }

    @Override

import javax.annotation.Nullable;

public class ExcludeRuleNotationConverter extends MapNotationConverter<ExcludeRule> {

    private static final NotationParser<Object, ExcludeRule> PARSER =
            NotationParserBuilder.toType(ExcludeRule.class).converter(new ExcludeRuleNotationConverter()).toComposite();

    public static NotationParser<Object, ExcludeRule> parser() {
        return PARSER;
    }

    @Override

    }

    private boolean matchingExcludeRule(ExcludeRule excludeRule, Map excludeRuleArg) {
        final DefaultExcludeRule expectedExcludeRule = new DefaultExcludeRule((String) excludeRuleArg.get(ExcludeRule.GROUP_KEY), (String) excludeRuleArg.get(ExcludeRule.MODULE_KEY));
        return excludeRule.equals(expectedExcludeRule);
    }

import org.gradle.api.InvalidUserDataException
import org.gradle.api.artifacts.ExcludeRule
import org.gradle.internal.typeconversion.NotationParserBuilder
import org.gradle.util.internal.WrapUtil
import spock.lang.Specification

class ExcludeRuleNotationConverterTest extends Specification {
    def parser = NotationParserBuilder.toType(ExcludeRule).converter(new ExcludeRuleNotationConverter()).toComposite()

    def "with group"() {

    private final Set<DependencyArtifact> artifacts;
    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;

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

                }
                for (ExcludeRule excludeRule : dependency.getExcludeRules()) {
                    writeDependencyExclude(excludeRule, xmlWriter);
                }
                xmlWriter.endElement();
            }
            for (IvyExcludeRule excludeRule : model.globalExcludes) {
                writeGlobalExclude(excludeRule, xmlWriter);
            }
            xmlWriter.endElement();

            getType() >> "artifact-type"
        }
        def excludeRule = Mock(ExcludeRule)

        when:
        moduleDependency.group >> "dep-group"
        moduleDependency.name >> "dep-name"
        moduleDependency.version >> "dep-version"
        moduleDependency.artifacts >> [artifact]
        moduleDependency.excludeRules >> [excludeRule]
        moduleDependency.transitive >> true