Examples with Project org.gradle.api.Project used on opensource projects

Example 91 with Project

use of org.gradle.api.Project in project rest.li by linkedin.

the class PegasusPlugin method configureAvroSchemaGeneration.

@SuppressWarnings("deprecation")
protected void configureAvroSchemaGeneration(Project project, SourceSet sourceSet) {
    File dataSchemaDir = project.file(getDataSchemaPath(project, sourceSet));
    File avroDir = project.file(getGeneratedDirPath(project, sourceSet, AVRO_SCHEMA_GEN_TYPE) + File.separatorChar + "avro");
    // generate avro schema files from data schema
    Task generateAvroSchemaTask = project.getTasks().create(sourceSet.getTaskName("generate", "avroSchema"), GenerateAvroSchemaTask.class, task -> {
        task.setInputDir(dataSchemaDir);
        task.setDestinationDir(avroDir);
        task.setResolverPath(getDataModelConfig(project, sourceSet));
        task.setCodegenClasspath(project.getConfigurations().getByName(PEGASUS_PLUGIN_CONFIGURATION));
        if (isPropertyTrue(project, ENABLE_ARG_FILE)) {
            task.setEnableArgFile(true);
        }
        task.onlyIf(t -> {
            if (task.getInputDir().exists()) {
                @SuppressWarnings("unchecked") Map<String, PegasusOptions> pegasusOptions = (Map<String, PegasusOptions>) project.getExtensions().getExtraProperties().get("pegasus");
                if (pegasusOptions.get(sourceSet.getName()).hasGenerationMode(PegasusOptions.GenerationMode.AVRO)) {
                    return true;
                }
            }
            return !project.getConfigurations().getByName("avroSchemaGenerator").isEmpty();
        });
        task.doFirst(new CacheableAction<>(t -> deleteGeneratedDir(project, sourceSet, AVRO_SCHEMA_GEN_TYPE)));
    });
    project.getTasks().getByName(sourceSet.getCompileJavaTaskName()).dependsOn(generateAvroSchemaTask);
    // create avro schema jar file
    Task avroSchemaJarTask = project.getTasks().create(sourceSet.getName() + "AvroSchemaJar", Jar.class, task -> {
        // add path prefix to each file in the data schema directory
        task.from(avroDir, copySpec -> copySpec.eachFile(fileCopyDetails -> fileCopyDetails.setPath("avro" + File.separatorChar + fileCopyDetails.getPath())));
        // FIXME change to #getArchiveAppendix().set(...); breaks backwards-compatibility before 5.1
        task.setAppendix(getAppendix(sourceSet, "avro-schema"));
        task.setDescription("Generate an avro schema jar");
    });
    if (!isTestSourceSet(sourceSet)) {
        project.getArtifacts().add("avroSchema", avroSchemaJarTask);
    } else {
        project.getArtifacts().add("testAvroSchema", avroSchemaJarTask);
    }
}

Example 92 with Project

use of org.gradle.api.Project in project rest.li by linkedin.

the class PegasusPlugin method configureConversionUtilities.

protected void configureConversionUtilities(Project project, SourceSet sourceSet) {
    File dataSchemaDir = project.file(getDataSchemaPath(project, sourceSet));
    boolean reverse = isPropertyTrue(project, CONVERT_TO_PDL_REVERSE);
    boolean keepOriginal = isPropertyTrue(project, CONVERT_TO_PDL_KEEP_ORIGINAL);
    boolean skipVerification = isPropertyTrue(project, CONVERT_TO_PDL_SKIP_VERIFICATION);
    String preserveSourceCmd = getNonEmptyProperty(project, CONVERT_TO_PDL_PRESERVE_SOURCE_CMD);
    // Utility task for migrating between PDSC and PDL.
    project.getTasks().create(sourceSet.getTaskName("convert", "ToPdl"), TranslateSchemasTask.class, task -> {
        task.setInputDir(dataSchemaDir);
        task.setDestinationDir(dataSchemaDir);
        task.setResolverPath(getDataModelConfig(project, sourceSet));
        task.setCodegenClasspath(project.getConfigurations().getByName(PEGASUS_PLUGIN_CONFIGURATION));
        task.setPreserveSourceCmd(preserveSourceCmd);
        if (reverse) {
            task.setSourceFormat(SchemaFileType.PDL);
            task.setDestinationFormat(SchemaFileType.PDSC);
        } else {
            task.setSourceFormat(SchemaFileType.PDSC);
            task.setDestinationFormat(SchemaFileType.PDL);
        }
        task.setKeepOriginal(keepOriginal);
        task.setSkipVerification(skipVerification);
        if (isPropertyTrue(project, ENABLE_ARG_FILE)) {
            task.setEnableArgFile(true);
        }
        task.onlyIf(t -> task.getInputDir().exists());
        task.doLast(new CacheableAction<>(t -> {
            project.getLogger().lifecycle("Pegasus schema conversion complete.");
            project.getLogger().lifecycle("All pegasus schema files in " + dataSchemaDir + " have been converted");
            project.getLogger().lifecycle("You can use '-PconvertToPdl.reverse=true|false' to change the direction of conversion.");
        }));
    });
    // Helper task for reformatting existing PDL schemas by generating them again.
    project.getTasks().create(sourceSet.getTaskName("reformat", "Pdl"), TranslateSchemasTask.class, task -> {
        task.setInputDir(dataSchemaDir);
        task.setDestinationDir(dataSchemaDir);
        task.setResolverPath(getDataModelConfig(project, sourceSet));
        task.setCodegenClasspath(project.getConfigurations().getByName(PEGASUS_PLUGIN_CONFIGURATION));
        task.setSourceFormat(SchemaFileType.PDL);
        task.setDestinationFormat(SchemaFileType.PDL);
        task.setKeepOriginal(true);
        task.setSkipVerification(true);
        if (isPropertyTrue(project, ENABLE_ARG_FILE)) {
            task.setEnableArgFile(true);
        }
        task.onlyIf(t -> task.getInputDir().exists());
        task.doLast(new CacheableAction<>(t -> project.getLogger().lifecycle("PDL reformat complete.")));
    });
}

Example 93 with Project

use of org.gradle.api.Project in project rest.li by linkedin.

the class TestPegasusPlugin method test.

@Test
public void test() {
    Project project = ProjectBuilder.builder().build();
    project.getPlugins().apply(PegasusPlugin.class);
    assertTrue(project.getPlugins().hasPlugin(JavaPlugin.class));
    // if any configuration is resolved in configuration phase, user script that tries to exclude certain dependencies will fail
    for (Configuration configuration : project.getConfigurations()) {
        assertSame(configuration.getState(), Configuration.State.UNRESOLVED);
    }
    assertNotNull(project.getConfigurations().findByName("dataTemplate"));
    assertNotNull(project.getConfigurations().findByName("restClient"));
    assertTrue(project.getExtensions().getExtraProperties().get("PegasusGenerationMode") instanceof Map);
    @SuppressWarnings("unchecked") Map<String, PegasusOptions> pegasusOptions = (Map<String, PegasusOptions>) project.getExtensions().getExtraProperties().get("pegasus");
    assertFalse(pegasusOptions.get("main").hasGenerationMode(PegasusOptions.GenerationMode.AVRO));
    assertTrue(pegasusOptions.get("main").hasGenerationMode(PegasusOptions.GenerationMode.PEGASUS));
}

Example 94 with Project

use of org.gradle.api.Project in project gradle by gradle.

the class GradleUserManualPlugin method generateUserManual.

private void generateUserManual(Project project, TaskContainer tasks, ProjectLayout layout, GradleDocumentationExtension extension) {
    tasks.withType(AsciidoctorTask.class).configureEach(task -> {
        if (task.getName().equals("asciidoctor")) {
            // ignore this task
            task.setEnabled(false);
            return;
        }
        task.outputOptions(options -> {
            options.setSeparateOutputDirs(false);
            options.setBackends(singletonList("html5"));
        });
        // TODO: Break the paths assumed here
        TaskInputs inputs = task.getInputs();
        inputs.files(extension.getCssFiles()).withPropertyName("manual").withPathSensitivity(PathSensitivity.RELATIVE);
        inputs.dir("src/main/resources").withPropertyName("resources").withPathSensitivity(PathSensitivity.RELATIVE);
        inputs.dir(extension.getUserManual().getSnippets()).withPropertyName("snippets").withPathSensitivity(PathSensitivity.RELATIVE);
        inputs.dir(extension.getUserManual().getSamples()).withPropertyName("samples").withPathSensitivity(PathSensitivity.RELATIVE);
        Provider<Directory> stylesDir = extension.getUserManual().getStagedDocumentation().dir("css");
        inputs.dir(stylesDir).withPropertyName("stylesdir").withPathSensitivity(PathSensitivity.RELATIVE);
        // TODO: Break the paths assumed here
        Map<String, Object> attributes = new HashMap<>();
        // TODO: This breaks the provider
        attributes.put("stylesdir", stylesDir.get().getAsFile().getAbsolutePath());
        attributes.put("stylesheet", "manual.css");
        attributes.put("doctype", "book");
        attributes.put("imagesdir", "img");
        attributes.put("nofooter", true);
        attributes.put("sectanchors", true);
        attributes.put("sectlinks", true);
        attributes.put("linkattrs", true);
        attributes.put("reproducible", "");
        attributes.put("docinfo", "");
        attributes.put("lang", "en-US");
        attributes.put("encoding", "utf-8");
        attributes.put("idprefix", "");
        attributes.put("website", "https://gradle.org");
        // TODO: This breaks the provider
        attributes.put("javaApi", extension.getJavadocs().getJavaApi().get().toString());
        attributes.put("jdkDownloadUrl", "https://jdk.java.net/");
        // TODO: This is coupled to extension.getJavadocs().getJavaApi()
        attributes.put("javadocReferenceUrl", "https://docs.oracle.com/javase/8/docs/technotes/tools/windows/javadoc.html");
        // TODO: This is coupled to extension.getJavadocs().getJavaApi()
        attributes.put("minJdkVersion", "8");
        attributes.put("antManual", "https://ant.apache.org/manual");
        attributes.put("docsUrl", "https://docs.gradle.org");
        // TODO: This breaks if the version is changed later.
        attributes.put("gradleVersion", project.getVersion().toString());
        attributes.put("snippetsPath", "snippets");
        // Make sure the 'raw' location of the samples is available in all AsciidoctorTasks to access files with expected outputs in the 'tests' folder for inclusion in READMEs
        attributes.put("samplesPath", extension.getUserManual().getStagingRoot().dir("raw/samples").get().getAsFile());
        task.attributes(attributes);
    });
    TaskProvider<GenerateDocInfo> generateDocinfo = tasks.register("generateDocInfo", GenerateDocInfo.class, task -> {
        task.getDocumentationFiles().from(extension.getUserManual().getRoot());
        task.getDocumentationRoot().convention(extension.getUserManual().getRoot());
        task.getDestinationDirectory().convention(layout.getBuildDirectory().dir("tmp/" + task.getName()));
    });
    TaskProvider<Sync> userguideFlattenSources = tasks.register("stageUserguideSource", Sync.class, task -> {
        task.setDuplicatesStrategy(DuplicatesStrategy.FAIL);
        // TODO: This doesn't allow adoc files to be generated?
        task.from(extension.getUserManual().getRoot(), sub -> {
            sub.include("**/*.adoc");
            // Flatten adocs into a single directory
            sub.eachFile(fcd -> fcd.setRelativePath(RelativePath.parse(true, fcd.getName())));
        });
        // From the snippets and the samples, filter out files generated if the build contained was ever executed
        task.from(extension.getUserManual().getSnippets(), sub -> {
            sub.into("snippets");
            sub.exclude("**/.gradle/**");
            sub.exclude("**/build/**");
            sub.setIncludeEmptyDirs(false);
        });
        task.from(extension.getUserManual().getSamples(), sub -> {
            sub.into("samples");
            sub.exclude("**/*.adoc");
            sub.exclude("**/.gradle/**");
            sub.exclude("**/build/**");
            sub.setIncludeEmptyDirs(false);
        });
        task.from(extension.getCssFiles(), sub -> sub.into("css"));
        task.from(extension.getUserManual().getRoot().dir("img"), sub -> {
            sub.include("**/*.png", "**/*.gif", "**/*.jpg", "**/*.svg");
            sub.into("img");
        });
        task.from(extension.getUserManual().getResources());
        task.from(generateDocinfo);
        // TODO: This should be available on a Copy task.
        DirectoryProperty flattenedAsciidocDirectory = project.getObjects().directoryProperty();
        flattenedAsciidocDirectory.set(extension.getUserManual().getStagingRoot().dir("raw"));
        task.getOutputs().dir(flattenedAsciidocDirectory);
        task.getExtensions().getExtraProperties().set("destinationDirectory", flattenedAsciidocDirectory);
        task.into(flattenedAsciidocDirectory);
    });
    TaskProvider<AsciidoctorTask> userguideSinglePageHtml = tasks.register("userguideSinglePageHtml", AsciidoctorTask.class, task -> {
        task.setDescription("Generates HTML single-page user manual.");
        configureForUserGuideSinglePage(task, extension, project);
        task.outputOptions(options -> options.setBackends(singletonList("html5")));
        // TODO: This breaks the provider
        task.setOutputDir(extension.getUserManual().getStagingRoot().dir("render-single-html").get().getAsFile());
    });
    TaskProvider<AsciidoctorTask> userguideSinglePagePdf = tasks.register("userguideSinglePagePdf", AsciidoctorTask.class, task -> {
        task.setDescription("Generates PDF single-page user manual.");
        configureForUserGuideSinglePage(task, extension, project);
        task.outputOptions(options -> options.setBackends(singletonList("pdf")));
        // TODO: This breaks the provider
        task.setOutputDir(extension.getUserManual().getStagingRoot().dir("render-single-pdf").get().getAsFile());
    });
    TaskProvider<AsciidoctorTask> userguideMultiPage = tasks.register("userguideMultiPage", AsciidoctorTask.class, task -> {
        task.setGroup("documentation");
        task.setDescription("Generates multi-page user manual.");
        task.dependsOn(extension.getUserManual().getStagedDocumentation());
        task.sources(patternSet -> {
            patternSet.include("**/*.adoc");
            patternSet.exclude("javaProject*Layout.adoc");
            patternSet.exclude("userguide_single.adoc");
            patternSet.exclude("snippets/**/*.adoc");
        });
        // TODO: This breaks the provider
        task.setSourceDir(extension.getUserManual().getStagedDocumentation().get().getAsFile());
        // TODO: This breaks the provider
        task.setOutputDir(extension.getUserManual().getStagingRoot().dir("render-multi").get().getAsFile());
        Map<String, Object> attributes = new HashMap<>();
        attributes.put("icons", "font");
        attributes.put("source-highlighter", "prettify");
        attributes.put("toc", "auto");
        attributes.put("toclevels", 1);
        attributes.put("toc-title", "Contents");
        attributes.put("groovyDslPath", "../dsl");
        attributes.put("javadocPath", "../javadoc");
        attributes.put("kotlinDslPath", "https://gradle.github.io/kotlin-dsl-docs/api");
        // Used by SampleIncludeProcessor from `gradle/dotorg-docs`
        // TODO: This breaks the provider
        // TODO:
        attributes.put("samples-dir", extension.getUserManual().getStagedDocumentation().get().getAsFile());
        task.attributes(attributes);
    });
    // Avoid overlapping outputs by copying exactly what we want from other intermediate tasks
    TaskProvider<Sync> userguide = tasks.register("userguide", Sync.class, task -> {
        task.setGroup("documentation");
        task.setDescription("Stages rendered user manual documentation.");
        task.from(userguideSinglePageHtml);
        task.from(userguideSinglePagePdf);
        task.from(userguideMultiPage);
        task.into(extension.getUserManual().getStagingRoot().dir("final"));
        // TODO: Eliminate this duplication with the flatten task
        task.from(extension.getUserManual().getRoot().dir("img"), sub -> {
            sub.include("**/*.png", "**/*.gif", "**/*.jpg", "**/*.svg");
            sub.into("img");
        });
        task.rename("userguide_single.pdf", "userguide.pdf");
    });
    extension.userManual(userManual -> {
        userManual.getRoot().convention(extension.getSourceRoot().dir("userguide"));
        userManual.getStagingRoot().convention(extension.getStagingRoot().dir("usermanual"));
        // TODO: These should be generated too
        userManual.getSnippets().convention(layout.getProjectDirectory().dir("src/snippets"));
        userManual.getSamples().convention(layout.getProjectDirectory().dir("src/samples"));
        userManual.getStagedDocumentation().convention(userguideFlattenSources.flatMap(task -> (DirectoryProperty) task.getExtensions().getExtraProperties().get("destinationDirectory")));
        userManual.getRenderedDocumentation().from(userguide);
    });
}

Example 95 with Project

use of org.gradle.api.Project in project gradle by gradle.

the class GradleUserManualPlugin method generateDefaultImports.

// TODO: This doesn't really make sense to be part of the user manual generation, but it's so tied up into it
// it's left here for a future project.
private void generateDefaultImports(Project project, TaskContainer tasks, GradleDocumentationExtension extension) {
    List<String> excludedPackages = getDefaultExcludedPackages();
    Provider<Directory> generatedDirectory = extension.getUserManual().getStagingRoot().dir("generated");
    TaskProvider<GenerateApiMapping> apiMapping = tasks.register("apiMapping", GenerateApiMapping.class, task -> {
        task.getMetaDataFile().convention(extension.getDslReference().getGeneratedMetaDataFile());
        task.getMappingDestFile().convention(generatedDirectory.map(dir -> dir.file("api-mapping.txt")));
        task.getExcludedPackages().convention(excludedPackages);
    });
    TaskProvider<GenerateDefaultImports> defaultImports = tasks.register("defaultImports", GenerateDefaultImports.class, task -> {
        task.getMetaDataFile().convention(extension.getDslReference().getGeneratedMetaDataFile());
        task.getImportsDestFile().convention(generatedDirectory.map(dir -> dir.file("default-imports.txt")));
        task.getExcludedPackages().convention(excludedPackages);
    });
    SourceSetContainer sourceSets = project.getExtensions().getByType(SourceSetContainer.class);
    sourceSets.getByName("main", main -> main.getOutput().dir(singletonMap("builtBy", asList(apiMapping, defaultImports)), generatedDirectory));
    extension.getUserManual().getResources().from(apiMapping);
    extension.getUserManual().getResources().from(defaultImports);
}