* to find out. It doesn't matter if the module is eventually not found, as Gradle would handle
 * this appropriately by looking at the next repository: the consequence is just a remote call.
 *
 */
public interface ArtifactResolutionDetails {
    /**
     * The identifier of the module being looked for in this repository
     * @return the module identifier
     */
    ModuleIdentifier getModuleId();

    /**

        snapshots = true;
        releases = false;
    }

    @Override
    public Action<? super ArtifactResolutionDetails> toContentFilter() {
        Action<? super ArtifactResolutionDetails> filter = super.toContentFilter();
        if (!snapshots || !releases) {
            Action<? super ArtifactResolutionDetails> action = details -> {
                if (!details.isVersionListing()) {

import org.gradle.api.artifacts.component.ModuleComponentIdentifier;
import org.gradle.api.internal.artifacts.ivyservice.ivyresolve.strategy.VersionSelector;
import org.gradle.api.internal.artifacts.repositories.ArtifactResolutionDetails;
import org.gradle.internal.resolve.ModuleVersionResolveException;
import org.gradle.internal.resolve.RejectedByAttributesVersion;
import org.gradle.internal.resolve.RejectedByRuleVersion;

    private final Action<? super ArtifactResolutionDetails> filterAction;

    public FilteredModuleComponentRepository(ModuleComponentRepository<ModuleComponentGraphResolveState> delegate, Action<? super ArtifactResolutionDetails> filterAction) {
        this.delegate = delegate;
        this.filterAction = filterAction;
    }

    public Action<? super ArtifactResolutionDetails> getFilterAction() {
        return filterAction;

    }

    def "can exclude or include whole groups using #method(#expr)"() {
        def fooMod = DefaultModuleIdentifier.newId(group, module)
        def details = Mock(ArtifactResolutionDetails)
        def descriptor = new DefaultRepositoryContentDescriptor({ "my-repo" }, new VersionParser())

        given:
        descriptor."exclude$method"(expr)

        when:

import org.gradle.api.internal.artifacts.ivyservice.ivyresolve.strategy.VersionParser;
import org.gradle.api.internal.artifacts.ivyservice.ivyresolve.strategy.VersionSelector;
import org.gradle.api.internal.artifacts.repositories.ArtifactResolutionDetails;
import org.gradle.api.internal.attributes.AttributeContainerInternal;
import org.gradle.api.internal.attributes.AttributesSchemaInternal;
import org.gradle.api.internal.attributes.ImmutableAttributes;

import org.gradle.api.internal.artifacts.ivyservice.ivyresolve.strategy.VersionParser;
import org.gradle.api.internal.artifacts.repositories.ArtifactRepositoryInternal;
import org.gradle.api.internal.artifacts.repositories.ArtifactResolutionDetails;
import org.gradle.api.internal.artifacts.repositories.ContentFilteringRepository;
import org.gradle.api.internal.artifacts.repositories.RepositoryContentDescriptorInternal;

import org.gradle.api.attributes.Attribute;

import javax.annotation.Nullable;
import java.util.Map;
import java.util.Set;

public interface ContentFilteringRepository {

    Action<? super ArtifactResolutionDetails> getContentFilter();

    /**
     * @see RepositoryContentDescriptorInternal#getIncludedConfigurations()
     */
    @Nullable
    Set<String> getIncludedConfigurations();

    /**

import javax.annotation.Nullable;
import java.util.Map;
import java.util.Set;

public interface RepositoryContentDescriptorInternal extends RepositoryContentDescriptor {
    Action<? super ArtifactResolutionDetails> toContentFilter();
    RepositoryContentDescriptorInternal asMutableCopy();

    /**
     * Returns values added by {@link #onlyForConfigurations}.
     */
    @Nullable

    private Set<ContentSpec> includeSpecs;
    private Set<ContentSpec> excludeSpecs;
    private Map<Attribute<Object>, Set<Object>> requiredAttributes;
    private boolean locked;

    private Action<? super ArtifactResolutionDetails> cachedAction;
    private final Supplier<String> repositoryNameSupplier;
    private final VersionSelectorScheme versionSelectorScheme;