Examples with ModuleSetExclude org.gradle.api.internal.artifacts.ivyservice.resolveengine.excludes.specs.ModuleSetExclude used on opensource projects

Example 1 with ModuleSetExclude

use of org.gradle.api.internal.artifacts.ivyservice.resolveengine.excludes.specs.ModuleSetExclude in project gradle by gradle.

the class Intersections method intersectModuleSet.

private ExcludeSpec intersectModuleSet(ModuleSetExclude left, ExcludeSpec right) {
    if (right instanceof ModuleSetExclude) {
        ModuleSetExclude msr = (ModuleSetExclude) right;
        Set<String> modules = Sets.newHashSet(left.getModules());
        modules.retainAll(msr.getModules());
        if (modules.isEmpty()) {
            return factory.nothing();
        }
        if (modules.size() == 1) {
            return factory.module(modules.iterator().next());
        }
        return factory.moduleSet(modules);
    }
    return null;
}

Example 2 with ModuleSetExclude

use of org.gradle.api.internal.artifacts.ivyservice.resolveengine.excludes.specs.ModuleSetExclude in project gradle by gradle.

the class NormalizingExcludeFactory method doUnion.

private ExcludeSpec doUnion(Set<ExcludeSpec> specs) {
    specs = simplifySet(ExcludeAllOf.class, specs);
    FlattenOperationResult flattened = flatten(ExcludeAnyOf.class, specs, ExcludeEverything.class::isInstance, ExcludeNothing.class::isInstance);
    if (flattened.fastExit) {
        return everything();
    }
    if (flattened.result.isEmpty()) {
        return nothing();
    }
    Map<UnionOf, List<ExcludeSpec>> byType = flattened.result.stream().collect(Collectors.groupingBy(UnionOf::typeOf));
    List<ModuleIdExclude> moduleIdExcludes = UnionOf.MODULEID.fromMap(byType);
    List<ModuleIdSetExclude> moduleIdSetsExcludes = UnionOf.MODULEID_SET.fromMap(byType);
    List<GroupExclude> groupExcludes = UnionOf.GROUP.fromMap(byType);
    List<GroupSetExclude> groupSetExcludes = UnionOf.GROUP_SET.fromMap(byType);
    List<ModuleExclude> moduleExcludes = UnionOf.MODULE.fromMap(byType);
    List<ModuleSetExclude> moduleSetExcludes = UnionOf.MODULE_SET.fromMap(byType);
    List<ExcludeSpec> other = UnionOf.NOT_JOINABLE.fromMap(byType);
    if (!moduleIdExcludes.isEmpty()) {
        // If there's more than one module id, merge them into a module id set
        if (moduleIdExcludes.size() > 1 || !moduleIdSetsExcludes.isEmpty()) {
            ModuleIdSetExclude excludeSpec = delegate.moduleIdSet(moduleIdExcludes.stream().map(ModuleIdExclude::getModuleId).collect(toSet()));
            if (moduleIdSetsExcludes.isEmpty()) {
                moduleIdSetsExcludes = ImmutableList.of(excludeSpec);
            } else {
                moduleIdSetsExcludes.add(excludeSpec);
            }
            moduleIdExcludes = Collections.emptyList();
        }
    }
    if (!groupExcludes.isEmpty()) {
        // If there's more than group, merge them into a group set
        if (groupExcludes.size() > 1 || !groupSetExcludes.isEmpty()) {
            GroupSetExclude excludeSpec = delegate.groupSet(groupExcludes.stream().map(GroupExclude::getGroup).collect(toSet()));
            if (groupSetExcludes.isEmpty()) {
                groupSetExcludes = ImmutableList.of(excludeSpec);
            } else {
                groupSetExcludes.add(excludeSpec);
            }
            groupExcludes = Collections.emptyList();
        }
    }
    if (!moduleExcludes.isEmpty()) {
        // If there's more than one module, merge them into a module set
        if (moduleExcludes.size() > 1 || !moduleSetExcludes.isEmpty()) {
            ModuleSetExclude excludeSpec = delegate.moduleSet(moduleExcludes.stream().map(ModuleExclude::getModule).collect(toSet()));
            if (moduleSetExcludes.isEmpty()) {
                moduleSetExcludes = ImmutableList.of(excludeSpec);
            } else {
                moduleSetExcludes.add(excludeSpec);
            }
            moduleExcludes = Collections.emptyList();
        }
    }
    if (moduleIdSetsExcludes.size() > 1) {
        moduleIdSetsExcludes = ImmutableList.of(delegate.moduleIdSet(moduleIdSetsExcludes.stream().flatMap(e -> e.getModuleIds().stream()).collect(toSet())));
    }
    if (groupSetExcludes.size() > 1) {
        groupSetExcludes = ImmutableList.of(delegate.groupSet(groupSetExcludes.stream().flatMap(e -> e.getGroups().stream()).collect(toSet())));
    }
    if (moduleSetExcludes.size() > 1) {
        moduleSetExcludes = ImmutableList.of(delegate.moduleSet(moduleSetExcludes.stream().flatMap(e -> e.getModules().stream()).collect(toSet())));
    }
    ImmutableSet.Builder<ExcludeSpec> builder = ImmutableSet.builderWithExpectedSize(moduleIdExcludes.size() + groupExcludes.size() + moduleExcludes.size() + moduleIdSetsExcludes.size() + groupSetExcludes.size() + moduleSetExcludes.size() + other.size());
    builder.addAll(moduleIdExcludes);
    builder.addAll(groupExcludes);
    builder.addAll(moduleExcludes);
    builder.addAll(moduleIdSetsExcludes);
    builder.addAll(groupSetExcludes);
    builder.addAll(moduleSetExcludes);
    builder.addAll(other);
    Set<ExcludeSpec> elements = builder.build();
    if (elements.size() > 1) {
        // try simplify
        ExcludeSpec[] asArray = elements.toArray(new ExcludeSpec[0]);
        boolean simplified = false;
        for (int i = 0; i < asArray.length; i++) {
            ExcludeSpec left = asArray[i];
            if (left != null) {
                for (int j = 0; j < asArray.length; j++) {
                    ExcludeSpec right = asArray[j];
                    if (right != null && i != j) {
                        ExcludeSpec merged = unions.tryUnion(left, right);
                        if (merged != null) {
                            if (merged instanceof ExcludeEverything) {
                                return merged;
                            }
                            left = merged;
                            asArray[i] = merged;
                            asArray[j] = null;
                            simplified = true;
                        }
                    }
                }
            }
        }
        if (simplified) {
            elements = Arrays.stream(asArray).filter(Objects::nonNull).collect(toSet());
        }
    }
    if (elements.size() == 2) {
        // Corner case to handle one of the two elements being an anyOf
        Iterator<ExcludeSpec> specIterator = elements.iterator();
        ExcludeSpec first = specIterator.next();
        ExcludeSpec second = specIterator.next();
        if (first instanceof ExcludeAnyOf || second instanceof ExcludeAnyOf) {
            ImmutableSet.Builder<ExcludeSpec> newBuilder = ImmutableSet.builder();
            if (first instanceof ExcludeAnyOf) {
                newBuilder.addAll(((ExcludeAnyOf) first).getComponents());
            } else {
                builder.add(first);
            }
            if (second instanceof ExcludeAnyOf) {
                newBuilder.addAll(((ExcludeAnyOf) second).getComponents());
            } else {
                builder.add(second);
            }
            elements = builder.build();
        }
    }
    return Optimizations.optimizeCollection(this, elements, delegate::anyOf);
}

Example 3 with ModuleSetExclude

use of org.gradle.api.internal.artifacts.ivyservice.resolveengine.excludes.specs.ModuleSetExclude in project gradle by gradle.

the class Unions method tryModuleSetUnion.

private ExcludeSpec tryModuleSetUnion(ModuleSetExclude left, ExcludeSpec right) {
    Set<String> leftModules = left.getModules();
    if (right instanceof ModuleIdExclude) {
        ModuleIdExclude mie = (ModuleIdExclude) right;
        if (leftModules.contains(mie.getModuleId().getName())) {
            return left;
        }
    }
    if (right instanceof ModuleIdSetExclude) {
        ModuleIdSetExclude ids = (ModuleIdSetExclude) right;
        Set<ModuleIdentifier> items = ids.getModuleIds().stream().filter(id -> !leftModules.contains(id.getName())).collect(Collectors.toSet());
        if (items.size() == 1) {
            return factory.anyOf(left, factory.moduleId(items.iterator().next()));
        }
        if (items.isEmpty()) {
            return left;
        }
        if (items.size() != ids.getModuleIds().size()) {
            return factory.anyOf(left, factory.moduleIdSet(items));
        }
    }
    return null;
}