org.gradle.api.file.Directory Java Examples

private String readVersion() {
        Directory orNull = platformDir.getOrNull();

        if (orNull == null) {
            return "NONE";
        }
        Path buildFile = orNull.file("build.number").getAsFile().toPath();
        Properties properties = new Properties();

        try (BufferedReader br = new BufferedReader(new FileReader(buildFile.toFile()))) {
            properties.load(br);
        } catch (IOException e) {
            LOG.debug("could not open build.number", e);
        }
        String bootstrappedVersion = properties.getProperty("version", "NONE");
//        LOG.lifecycle("found hybris platform version: {}", bootstrappedVersion);
        return bootstrappedVersion;
    }
 

private static void configureIntelliJ(final Project project) {
    project.getPlugins().withType(IdeaPlugin.class).configureEach(ideaPlugin -> {
        SourceSet mainSourceSet = getMainSourceSet(project);
        SourceSet testSourceSet = getTestSourceSet(project);
        IdeaModule module = ideaPlugin.getModel().getModule();
        module.setSourceDirs(new SetBuilder<File>()
            .addAll(module.getSourceDirs())
            .add(getAvroSourceDir(project, mainSourceSet))
            .add(getGeneratedOutputDir(project, mainSourceSet, JAVA_EXTENSION).map(Directory::getAsFile).get())
            .build());
        module.setTestSourceDirs(new SetBuilder<File>()
            .addAll(module.getTestSourceDirs())
            .add(getAvroSourceDir(project, testSourceSet))
            .add(getGeneratedOutputDir(project, testSourceSet, JAVA_EXTENSION).map(Directory::getAsFile).get())
            .build());
        // IntelliJ doesn't allow source directories beneath an excluded directory.
        // Thus, we remove the build directory exclude and add all non-generated sub-directories as excludes.
        SetBuilder<File> excludeDirs = new SetBuilder<>();
        excludeDirs.addAll(module.getExcludeDirs()).remove(project.getBuildDir());
        File buildDir = project.getBuildDir();
        if (buildDir.isDirectory()) {
            excludeDirs.addAll(project.getBuildDir().listFiles(new NonGeneratedDirectoryFileFilter()));
        }
        module.setExcludeDirs(excludeDirs.build());
    });
    project.getTasks().withType(GenerateIdeaModule.class).configureEach(generateIdeaModule ->
        generateIdeaModule.doFirst(task ->
            project.getTasks().withType(GenerateAvroJavaTask.class, generateAvroJavaTask ->
                project.mkdir(generateAvroJavaTask.getOutputDir().get()))));
}
 

private static TaskProvider<?> createExtractTask(
    String taskName,
    Project rootProject,
    boolean isWindows,
    Provider<Directory> extractPath,
    Supplier<File> jdkBundle) {
    if (isWindows) {
        Action<CopySpec> removeRootDir = copy -> {
            // remove extra unnecessary directory levels
            copy.eachFile(details -> {
                Path newPathSegments = trimArchiveExtractPath(details.getRelativePath().getPathString());
                String[] segments = StreamSupport.stream(newPathSegments.spliterator(), false)
                    .map(Path::toString)
                    .toArray(String[]::new);
                details.setRelativePath(new RelativePath(true, segments));
            });
            copy.setIncludeEmptyDirs(false);
        };

        return rootProject.getTasks().register(taskName, Copy.class, copyTask -> {
            copyTask.doFirst(t -> rootProject.delete(extractPath));
            copyTask.into(extractPath);
            Callable<FileTree> fileGetter = () -> rootProject.zipTree(jdkBundle.get());
            copyTask.from(fileGetter, removeRootDir);
        });
    } else {
        /*
         * Gradle TarFileTree does not resolve symlinks, so we have to manually
         * extract and preserve the symlinks. cf. https://github.com/gradle/gradle/issues/3982
         * and https://discuss.gradle.org/t/tar-and-untar-losing-symbolic-links/2039
         */
        return rootProject.getTasks().register(taskName, SymbolicLinkPreservingUntarTask.class, task -> {
            task.getTarFile().fileProvider(rootProject.provider(jdkBundle::get));
            task.getExtractPath().set(extractPath);
            task.setTransform(JdkDownloadPlugin::trimArchiveExtractPath);
        });
    }
}
 

public Provider<Directory> getPlatformHome() {
    return platformDir;
}
 

public Provider<Directory> getAntHome() {
    return antHome;
}
 

default Provider<Directory> getOutputDir(Project project, SourceDirectorySet sourceDirectorySet) {
    DirectoryProperty buildDir = project.getLayout().getBuildDirectory();
    return buildDir.dir(GENERATED_SOURCE_ROOT_DIR_PATH + "/" + sourceDirectorySet.getName());
}
 

private static Provider<Directory> getGeneratedOutputDir(Project project, SourceSet sourceSet, String extension) {
    String generatedOutputDirName = String.format("generated-%s-avro-%s", sourceSet.getName(), extension);
    return project.getLayout().getBuildDirectory().dir(generatedOutputDirName);
}
 

/**
 * Returns the directory to generate the parser source files into.
 *
 * @return The output directory.
 */
@OutputDirectory
public Property<Directory> getOutputDirectory() {
    return outputDirectory;
}
 

/**
 * Returns the output directory that processed JavaScript is written to.
 *
 * @return The output directory.
 */
@OutputDirectory
public Property<Directory> getDestinationDir() {
    return destinationDir;
}
 

/**
 * Returns the directory to generate the parser source files into.
 *
 * @return The output directory.
 */
@OutputDirectory
public Property<Directory> getOutputDirectory() {
    return outputDirectory;
}