org.gradle.api.specs.Specs Java Examples

/**
 * Recursive, includes unsuccessfully resolved artifacts
 *
 * @param dependencySpec dependency spec
 */
public Set<ResolvedArtifact> getAllArtifacts(Spec<? super Dependency> dependencySpec) {
    //this is not very nice might be good enough until we get rid of ResolvedConfiguration and friends
    //avoid traversing the graph causing the full ResolvedDependency graph to be loaded for the most typical scenario
    if (dependencySpec == Specs.SATISFIES_ALL) {
        return results.getArtifacts();
    }

    CachingDirectedGraphWalker<ResolvedDependency, ResolvedArtifact> walker
            = new CachingDirectedGraphWalker<ResolvedDependency, ResolvedArtifact>(new ResolvedDependencyArtifactsGraph());

    Set<ResolvedDependency> firstLevelModuleDependencies = getFirstLevelModuleDependencies(dependencySpec);

    Set<ResolvedArtifact> artifacts = new LinkedHashSet<ResolvedArtifact>();

    for (ResolvedDependency resolvedDependency : firstLevelModuleDependencies) {
        artifacts.addAll(resolvedDependency.getParentArtifacts(results.more().getRoot()));
        walker.add(resolvedDependency);
    }

    artifacts.addAll(walker.findValues());
    return artifacts;
}
 

private ClassPath resolvePluginDependencies(final PluginUseMetaData metadata) {
    DependencyResolutionServices resolution = dependencyResolutionServicesFactory.create();

    RepositoryHandler repositories = resolution.getResolveRepositoryHandler();
    final String repoUrl = metadata.implementation.get("repo");
    repositories.maven(new Action<MavenArtifactRepository>() {
        public void execute(MavenArtifactRepository mavenArtifactRepository) {
            mavenArtifactRepository.setUrl(repoUrl);
        }
    });

    Dependency dependency = resolution.getDependencyHandler().create(metadata.implementation.get("gav"));

    ConfigurationContainerInternal configurations = (ConfigurationContainerInternal) resolution.getConfigurationContainer();
    ConfigurationInternal configuration = configurations.detachedConfiguration(dependency);

    try {
        Set<File> files = configuration.getResolvedConfiguration().getFiles(Specs.satisfyAll());
        return new DefaultClassPath(files);
    } catch (ResolveException e) {
        throw new DependencyResolutionException("Failed to resolve all plugin dependencies from " + repoUrl, e.getCause());
    }
}
 

/**
 * Recursive, includes unsuccessfully resolved artifacts
 *
 * @param dependencySpec dependency spec
 */
public Set<ResolvedArtifact> getAllArtifacts(Spec<? super Dependency> dependencySpec) {
    //this is not very nice might be good enough until we get rid of ResolvedConfiguration and friends
    //avoid traversing the graph causing the full ResolvedDependency graph to be loaded for the most typical scenario
    if (dependencySpec == Specs.SATISFIES_ALL) {
        return results.getArtifacts();
    }

    CachingDirectedGraphWalker<ResolvedDependency, ResolvedArtifact> walker
            = new CachingDirectedGraphWalker<ResolvedDependency, ResolvedArtifact>(new ResolvedDependencyArtifactsGraph());

    Set<ResolvedDependency> firstLevelModuleDependencies = getFirstLevelModuleDependencies(dependencySpec);

    Set<ResolvedArtifact> artifacts = new LinkedHashSet<ResolvedArtifact>();

    for (ResolvedDependency resolvedDependency : firstLevelModuleDependencies) {
        artifacts.addAll(resolvedDependency.getParentArtifacts(results.more().getRoot()));
        walker.add(resolvedDependency);
    }

    artifacts.addAll(walker.findValues());
    return artifacts;
}
 

/**
 * Recursive, includes unsuccessfully resolved artifacts
 *
 * @param dependencySpec dependency spec
 */
public Set<ResolvedArtifact> getAllArtifacts(Spec<? super Dependency> dependencySpec) {
    //this is not very nice might be good enough until we get rid of ResolvedConfiguration and friends
    //avoid traversing the graph causing the full ResolvedDependency graph to be loaded for the most typical scenario
    if (dependencySpec == Specs.SATISFIES_ALL) {
        return results.getArtifacts();
    }

    CachingDirectedGraphWalker<ResolvedDependency, ResolvedArtifact> walker
            = new CachingDirectedGraphWalker<ResolvedDependency, ResolvedArtifact>(new ResolvedDependencyArtifactsGraph());

    Set<ResolvedDependency> firstLevelModuleDependencies = getFirstLevelModuleDependencies(dependencySpec);

    Set<ResolvedArtifact> artifacts = new LinkedHashSet<ResolvedArtifact>();

    for (ResolvedDependency resolvedDependency : firstLevelModuleDependencies) {
        artifacts.addAll(resolvedDependency.getParentArtifacts(results.more().getRoot()));
        walker.add(resolvedDependency);
    }

    artifacts.addAll(walker.findValues());
    return artifacts;
}
 

/**
 * Recursive, includes unsuccessfully resolved artifacts
 *
 * @param dependencySpec dependency spec
 */
public Set<ResolvedArtifact> getAllArtifacts(Spec<? super Dependency> dependencySpec) {
    //this is not very nice might be good enough until we get rid of ResolvedConfiguration and friends
    //avoid traversing the graph causing the full ResolvedDependency graph to be loaded for the most typical scenario
    if (dependencySpec == Specs.SATISFIES_ALL) {
        return results.getArtifacts();
    }

    CachingDirectedGraphWalker<ResolvedDependency, ResolvedArtifact> walker
            = new CachingDirectedGraphWalker<ResolvedDependency, ResolvedArtifact>(new ResolvedDependencyArtifactsGraph());

    Set<ResolvedDependency> firstLevelModuleDependencies = getFirstLevelModuleDependencies(dependencySpec);

    Set<ResolvedArtifact> artifacts = new LinkedHashSet<ResolvedArtifact>();

    for (ResolvedDependency resolvedDependency : firstLevelModuleDependencies) {
        artifacts.addAll(resolvedDependency.getParentArtifacts(results.more().getRoot()));
        walker.add(resolvedDependency);
    }

    artifacts.addAll(walker.findValues());
    return artifacts;
}
 

@Inject
public GenerateIvyDescriptor(FileResolver fileResolver) {
    this.fileResolver = fileResolver;

    // Never up to date; we don't understand the data structures.
    getOutputs().upToDateWhen(Specs.satisfyNone());
}
 

@Inject
public GenerateIvyDescriptor(FileResolver fileResolver) {
    this.fileResolver = fileResolver;

    // Never up to date; we don't understand the data structures.
    getOutputs().upToDateWhen(Specs.satisfyNone());
}
 

public void configure(BuildExecutionContext context) {
    GradleInternal gradle = context.getGradle();
    Set<String> excludedTaskNames = gradle.getStartParameter().getExcludedTaskNames();
    if (!excludedTaskNames.isEmpty()) {
        final Set<Spec<Task>> filters = new HashSet<Spec<Task>>();
        for (String taskName : excludedTaskNames) {
            filters.add(taskSelector.getFilter(taskName));
        }
        gradle.getTaskGraph().useFilter(Specs.and(filters));
    }

    context.proceed();
}
 

private void collectArtifacts(Configuration configuration,
                              Map<ModuleVersionIdentifier, List<ResolvedArtifact>> artifacts) {


    Set<ResolvedArtifact> allArtifacts;
    if (configuration.getState().equals(Configuration.State.UNRESOLVED) && !configuration.getName().equals(AtlasPlugin.BUNDLE_COMPILE)) {
        configuration.setCanBeResolved(true);
    }
    if (!extraModelInfo.getMode().equals(STANDARD)) {
        allArtifacts = configuration.getResolvedConfiguration().getLenientConfiguration().getArtifacts(
            Specs.satisfyAll());
    } else {
        allArtifacts = configuration.getResolvedConfiguration().getResolvedArtifacts();
    }
    for (ResolvedArtifact artifact : allArtifacts) {
        ModuleVersionIdentifier id = artifact.getModuleVersion().getId();
        List<ResolvedArtifact> moduleArtifacts = artifacts.get(id);

        if (moduleArtifacts == null) {
            moduleArtifacts = Lists.newArrayList();
            artifacts.put(id, moduleArtifacts);
        }

        if (!moduleArtifacts.contains(artifact)) {
            moduleArtifacts.add(artifact);
        }
    }
}
 

private void collectArtifacts(
        Configuration configuration,
        Map<ModuleVersionIdentifier,
                List<ResolvedArtifact>> artifacts) {

    Set<ResolvedArtifact> allArtifacts;
    if (extraModelInfo.getMode() != STANDARD) {
        allArtifacts = configuration.getResolvedConfiguration().getLenientConfiguration().getArtifacts(
                Specs.satisfyAll());
    } else {
        allArtifacts = configuration.getResolvedConfiguration().getResolvedArtifacts();
    }

    for (ResolvedArtifact artifact : allArtifacts) {
        ModuleVersionIdentifier id = artifact.getModuleVersion().getId();
        List<ResolvedArtifact> moduleArtifacts = artifacts.get(id);

        if (moduleArtifacts == null) {
            moduleArtifacts = Lists.newArrayList();
            artifacts.put(id, moduleArtifacts);
        }

        if (!moduleArtifacts.contains(artifact)) {
            moduleArtifacts.add(artifact);
        }
    }
}
 

@Inject
public GenerateMavenPom(FileResolver fileResolver) {
    this.fileResolver = fileResolver;

    // Never up to date; we don't understand the data structures.
    getOutputs().upToDateWhen(Specs.satisfyNone());
}
 

public void configure(BuildExecutionContext context) {
    GradleInternal gradle = context.getGradle();
    Set<String> excludedTaskNames = gradle.getStartParameter().getExcludedTaskNames();
    if (!excludedTaskNames.isEmpty()) {
        final Set<Spec<Task>> filters = new HashSet<Spec<Task>>();
        for (String taskName : excludedTaskNames) {
            filters.add(taskSelector.getFilter(taskName));
        }
        gradle.getTaskGraph().useFilter(Specs.and(filters));
    }

    context.proceed();
}
 

protected <S extends Collection<? super T>> S findAll(Closure cl, S matches) {
    for (T t : filteredStore(createFilter(Specs.<Object>convertClosureToSpec(cl)))) {
        matches.add(t);
    }
    return matches;
}
 

public DomainObjectCollection<T> matching(Closure spec) {
    return matching(Specs.<T>convertClosureToSpec(spec));
}
 

@Override
public NamedDomainObjectList<T> matching(Closure spec) {
    return matching(Specs.<T>convertClosureToSpec(spec));
}
 

public <K extends S> CollectionEventRegister<K> filtered(CollectionFilter<K> filter) {
    return super.filtered(new CollectionFilter<K>(filter.getType(), Specs.<K>and(filter, this.filter)));
}
 

public FileCollection filter(Closure filterClosure) {
    return filter(Specs.convertClosureToSpec(filterClosure));
}
 

private <K, V extends Response<?>> V maybeFetch(String operationName, final PersistentIndexedCache<K, V> cache, final K key, Factory<V> factory) {
    return maybeFetch(operationName, cache, key, factory, Specs.SATISFIES_NONE);
}
 

public SingleIncludePatternFileTree(File baseDir, String includePattern) {
    this(baseDir, includePattern, Specs.<FileTreeElement>satisfyNone());
}
 

public Transformer invert() {
    return new Inverse("no_" + StatementExtractingScriptTransformer.this.getId(), Specs.not(transformer.getSpec()));
}
 

public GenerateMavenPom() {
    // Never up to date; we don't understand the data structures.
    getOutputs().upToDateWhen(Specs.satisfyNone());
}
 

public Configuration copyRecursive(Closure dependencySpec) {
    return copyRecursive(Specs.<Dependency>convertClosureToSpec(dependencySpec));
}
 

public Transformer invert() {
    return new Inverse("no_" + StatementExtractingScriptTransformer.this.getId(), Specs.not(transformer.getSpec()));
}
 

public PluginCollection<T> matching(Closure spec) {
    return matching(Specs.<T>convertClosureToSpec(spec));
}
 

@Override
public NamedDomainObjectList<T> matching(Closure spec) {
    return matching(Specs.<T>convertClosureToSpec(spec));
}
 

public FileCollection filter(Closure filterClosure) {
    return filter(Specs.convertClosureToSpec(filterClosure));
}
 

public SingleIncludePatternFileTree(File baseDir, String includePattern) {
    this(baseDir, includePattern, Specs.<FileTreeElement>satisfyNone());
}
 

public CollectionFilter(Class<T> type) {
    this(type, Specs.<T>satisfyAll());
}
 

public <K extends S> CollectionEventRegister<K> filtered(CollectionFilter<K> filter) {
    return super.filtered(new CollectionFilter<K>(filter.getType(), Specs.<K>and(filter, this.filter)));
}
 

public Transformer invert() {
    return new Inverse("no_" + StatementExtractingScriptTransformer.this.getId(), Specs.not(transformer.getSpec()));
}