org.gradle.api.file.ConfigurableFileCollection Java Examples

private Stream<Configuration> findConfigurations(FileCollection classpath) {
    if (classpath instanceof Configuration) {
        return Stream.of((Configuration) classpath);
    }
    else if (classpath instanceof UnionFileCollection) {
        return ((UnionFileCollection) classpath).getSources()
                .stream()
                .flatMap(this::findConfigurations);
    }
    else if (classpath instanceof ConfigurableFileCollection) {
        return ((ConfigurableFileCollection) classpath).getFrom()
                .stream()
                .flatMap(this::findConfigurations);

    }
    return Stream.empty();
}
 

private void initClassPath() {
    RuntimeClassLoaderFactory classLoaderFactory = new RuntimeClassLoaderFactory(getProject(), module);

    Set<File> classpath = new HashSet<>();
    classpath.addAll(classLoaderFactory.getProjectLibraries());
    try {
        for (URL pluginUrl : classLoaderFactory.getPluginUrls()) {
            classpath.add(Paths.get(pluginUrl.toURI()).toFile());
        }
    } catch (URISyntaxException e) {
        throw new IllegalStateException(e);
    }

    Project project = getProject();
    ConfigurableFileCollection files = project.files(classpath.toArray());
    setClasspath(files);
}
 

private Stream<Configuration> findConfigurations(FileCollection classpath) {
    if (classpath instanceof Configuration) {
        return Stream.of((Configuration) classpath);
    }
    else if (classpath instanceof UnionFileCollection) {
        return ((UnionFileCollection) classpath).getSources()
                .stream()
                .flatMap(this::findConfigurations);
    }
    else if (classpath instanceof ConfigurableFileCollection) {
        return ((ConfigurableFileCollection) classpath).getFrom()
                .stream()
                .flatMap(this::findConfigurations);

    }
    return Stream.empty();
}
 

private void configureOverlay(WarOverlay overlay, Callable<FileTree> warTree) {
    War warTask = overlay.getWarTask();

    String capitalizedWarTaskName = StringGroovyMethods.capitalize((CharSequence) warTask.getName());
    String capitalizedOverlayName = StringGroovyMethods.capitalize((CharSequence) overlay.getName());

    File destinationDir = new File(project.getBuildDir(), String.format("overlays/%s/%s", warTask.getName(), overlay.getName()));
    Action<CopySpec> extractOverlay = copySpec -> {
        copySpec.into(destinationDir);
        copySpec.from(warTree);
    };

    Sync extractOverlayTask = project.getTasks().create(String.format("extract%s%sOverlay", capitalizedOverlayName, capitalizedWarTaskName), Sync.class, extractOverlay);

    overlay.getWarCopySpec().from(extractOverlayTask);

    if (overlay.isEnableCompilation()) {

        if (!destinationDir.exists() || isEmpty(destinationDir)) {
            project.sync(extractOverlay);
        }

        project.getTasks().getByName(CLEAN_TASK_NAME).finalizedBy(extractOverlayTask);

        ConfigurableFileCollection classes = project.files(new File(destinationDir, "WEB-INF/classes"))
                .builtBy(extractOverlayTask);

        project.getDependencies().add(getClasspathConfigurationName(overlay), classes);

        FileTree libs = project.files(extractOverlayTask).builtBy(extractOverlayTask).getAsFileTree()
                .matching(patternFilterable -> patternFilterable.include("WEB-INF/lib/**"));

        project.getDependencies().add(getClasspathConfigurationName(overlay), libs);
    }
}
 

public ConfigurableFileCollection files(Object... paths) {
    return fileOperations.files(paths);
}
 

@InputFiles
public ConfigurableFileCollection getIncludeDirs() {
    return includeDirs;
}
 

public ConfigurableFileCollection files(Object paths, Closure closure) {
    return ConfigureUtil.configure(closure, getFileOperations().files(paths));
}
 

public ConfigurableFileCollection files(Object paths, Closure closure) {
    return fileOperations.files(paths, closure);
}
 

public ConfigurableFileCollection files(Object... paths) {
    return fileOperations.files(paths);
}
 

public ConfigurableFileCollection files(Object paths, Closure configureClosure) {
    return ConfigureUtil.configure(configureClosure, fileOperations.files(paths));
}
 

@Classpath
ConfigurableFileCollection getLombokClasspath();
 

public ConfigurableFileCollection setBuiltBy(Iterable<?> tasks) {
    buildDependency.setValues(tasks);
    return this;
}
 

public ConfigurableFileCollection builtBy(Object... tasks) {
    buildDependency.add(tasks);
    return this;
}
 

public ConfigurableFileCollection from(Object... paths) {
    GUtil.addToCollection(files, Arrays.asList(paths));
    return this;
}
 

@Classpath
public ConfigurableFileCollection getClasspath() {
  return classpath;
}
 

@Override
public void apply(Project project) {

    aggregateJavadoc = project.getTasks().register("aggregateJavadoc", Javadoc.class, aggregateJavadoc -> {
        aggregateJavadoc.setGroup(JavaBasePlugin.DOCUMENTATION_GROUP);
        aggregateJavadoc.getConventionMapping().map("destinationDir", new Callable<Object>() {
            @Override
            public Object call() {
                File docsDir = Optional.ofNullable(project.getConvention().findPlugin(JavaPluginConvention.class))
                        .map(JavaPluginConvention::getDocsDir)
                        .orElse(new File(project.getBuildDir(), "docs"));
                return new File(docsDir, "aggregateJavadoc");
            }
        });
    });

    project.allprojects(p ->
            p.getPlugins().withType(JavaPlugin.class, jp ->
                    aggregateJavadoc.configure(aj -> {
                        TaskProvider<Javadoc> javadoc = p.getTasks().named(JavaPlugin.JAVADOC_TASK_NAME, Javadoc.class);

                        aj.source(javadoc.map(Javadoc::getSource));

                        if (aj.getClasspath() instanceof ConfigurableFileCollection) {
                            ((ConfigurableFileCollection) aj.getClasspath()).from(javadoc.map(Javadoc::getClasspath));
                        }
                        else {
                            ConfigurableFileCollection classpath = project.files();
                            classpath.from(aj.getClasspath());
                            classpath.from(javadoc.map(Javadoc::getClasspath));
                            aj.setClasspath(classpath);
                        }

                        StandardJavadocDocletOptions options = (StandardJavadocDocletOptions) javadoc.get().getOptions();
                        StandardJavadocDocletOptions aggregateOptions = (StandardJavadocDocletOptions) aj.getOptions();

                        options.getLinks().forEach(link -> {
                            if (!aggregateOptions.getLinks().contains(link)) {
                                aggregateOptions.getLinks().add(link);
                            }
                        });
                        options.getLinksOffline().forEach(link -> {
                            if (!aggregateOptions.getLinksOffline().contains(link)) {
                                aggregateOptions.getLinksOffline().add(link);
                            }
                        });
                        options.getJFlags().forEach(jFlag -> {
                            if (!aggregateOptions.getJFlags().contains(jFlag)) {
                                aggregateOptions.getJFlags().add(jFlag);
                            }
                        });
                    })
            )
    );
}
 

@Classpath
ConfigurableFileCollection getLombokClasspath();
 

@InputFiles
public final ConfigurableFileCollection getMakeFiles() {
    return makeFiles;
}
 

@InputFiles
public ConfigurableFileCollection getIncludeDirs() {
    return includeDirs;
}
 

@InputFiles
public final ConfigurableFileCollection getMakeFiles() {
    return makeFiles;
}
 

@InputFiles
public ConfigurableFileCollection getLinkFiles() {
    return linkFiles;
}
 

@InputFiles
public ConfigurableFileCollection getIncludeDirs() {
    return includeDirs;
}
 

@InputFiles
public final ConfigurableFileCollection getMakeFiles() {
    return makeFiles;
}
 

@InputFiles
public ConfigurableFileCollection getLinkFiles() {
    return linkFiles;
}
 

@InputFiles
public ConfigurableFileCollection getIncludeDirs() {
    return includeDirs;
}
 

@Internal
public ConfigurableFileCollection getSourceRoots() {
  return sourceRoots;
}
 

@Classpath
public ConfigurableFileCollection getClasspath() {
  return classpath;
}
 

@Internal
public ConfigurableFileCollection getSourceRoots() {
  return sourceRoots;
}
 

@Classpath
public ConfigurableFileCollection getClasspath() {
  return classpath;
}
 

@Internal
public ConfigurableFileCollection getSourceRoots() {
  return sourceRoots;
}