use of org.gradle.api.tasks.TaskProvider in project spring-boot by spring-projects.
the class WarPluginAction method configureBootWarTask.
private TaskProvider<BootWar> configureBootWarTask(Project project) {
Configuration developmentOnly = project.getConfigurations().getByName(SpringBootPlugin.DEVELOPMENT_ONLY_CONFIGURATION_NAME);
Configuration productionRuntimeClasspath = project.getConfigurations().getByName(SpringBootPlugin.PRODUCTION_RUNTIME_CLASSPATH_CONFIGURATION_NAME);
Callable<FileCollection> classpath = () -> project.getExtensions().getByType(SourceSetContainer.class).getByName(SourceSet.MAIN_SOURCE_SET_NAME).getRuntimeClasspath().minus(providedRuntimeConfiguration(project)).minus((developmentOnly.minus(productionRuntimeClasspath))).filter(new JarTypeFileSpec());
TaskProvider<ResolveMainClassName> resolveMainClassName = ResolveMainClassName.registerForTask(SpringBootPlugin.BOOT_WAR_TASK_NAME, project, classpath);
TaskProvider<BootWar> bootWarProvider = project.getTasks().register(SpringBootPlugin.BOOT_WAR_TASK_NAME, BootWar.class, (bootWar) -> {
bootWar.setGroup(BasePlugin.BUILD_GROUP);
bootWar.setDescription("Assembles an executable war archive containing webapp" + " content, and the main classes and their dependencies.");
bootWar.providedClasspath(providedRuntimeConfiguration(project));
bootWar.setClasspath(classpath);
Provider<String> manifestStartClass = project.provider(() -> (String) bootWar.getManifest().getAttributes().get("Start-Class"));
bootWar.getMainClass().convention(resolveMainClassName.flatMap((resolver) -> manifestStartClass.isPresent() ? manifestStartClass : resolveMainClassName.get().readMainClassName()));
});
bootWarProvider.map((bootWar) -> bootWar.getClasspath());
return bootWarProvider;
}
use of org.gradle.api.tasks.TaskProvider in project spring-boot by spring-projects.
the class SpringBootExtension method buildInfo.
/**
* Creates a new {@link BuildInfo} task named {@code bootBuildInfo} and configures the
* Java plugin's {@code classes} task to depend upon it. The task is passed to the
* given {@code configurer} for further configuration.
* <p>
* By default, the task's destination dir will be a directory named {@code META-INF}
* beneath the main source set's resources output directory, and the task's project
* artifact will be the base name of the {@code bootWar} or {@code bootJar} task.
* @param configurer the task configurer
*/
public void buildInfo(Action<BuildInfo> configurer) {
TaskContainer tasks = this.project.getTasks();
TaskProvider<BuildInfo> bootBuildInfo = tasks.register("bootBuildInfo", BuildInfo.class, this::configureBuildInfoTask);
this.project.getPlugins().withType(JavaPlugin.class, (plugin) -> {
tasks.named(JavaPlugin.CLASSES_TASK_NAME).configure((task) -> task.dependsOn(bootBuildInfo));
this.project.afterEvaluate((evaluated) -> bootBuildInfo.configure((buildInfo) -> {
BuildInfoProperties properties = buildInfo.getProperties();
if (properties.getArtifact() == null) {
properties.setArtifact(determineArtifactBaseName());
}
}));
});
if (configurer != null) {
bootBuildInfo.configure(configurer);
}
}
use of org.gradle.api.tasks.TaskProvider 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);
});
}
use of org.gradle.api.tasks.TaskProvider 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);
}
use of org.gradle.api.tasks.TaskProvider in project gradle by gradle.
the class GradleReleaseNotesPlugin method generateReleaseNotes.
private void generateReleaseNotes(Project project, ProjectLayout layout, TaskContainer tasks, GradleDocumentationExtension extension) {
TaskProvider<RenderMarkdown> releaseNotesMarkdown = tasks.register("releaseNotesMarkdown", RenderMarkdown.class, task -> {
task.setGroup("release notes");
task.setDescription("Generate release notes HTML page from Markdown.");
task.getInputEncoding().convention(Charset.defaultCharset().name());
task.getOutputEncoding().convention(Charset.defaultCharset().name());
task.getMarkdownFile().convention(extension.getReleaseNotes().getMarkdownFile());
task.getDestinationFile().convention(extension.getStagingRoot().file("release-notes/raw.html"));
});
TaskProvider<DecorateReleaseNotes> releaseNotesPostProcess = tasks.register("releaseNotes", DecorateReleaseNotes.class, task -> {
task.setGroup("release notes");
task.setDescription("Transforms generated release notes.");
task.getHtmlFile().convention(releaseNotesMarkdown.flatMap(RenderMarkdown::getDestinationFile));
task.getBaseCssFile().convention(extension.getReleaseNotes().getBaseCssFile());
task.getReleaseNotesCssFile().convention(extension.getReleaseNotes().getReleaseNotesCssFile());
task.getReleaseNotesJavascriptFile().convention(extension.getReleaseNotes().getReleaseNotesJsFile());
task.getJquery().from(extension.getReleaseNotes().getJquery());
ModuleIdentityExtension moduleIdentity = project.getExtensions().getByType(ModuleIdentityExtension.class);
MapProperty<String, String> replacementTokens = task.getReplacementTokens();
replacementTokens.put("version", moduleIdentity.getVersion().map(GradleVersion::getVersion));
replacementTokens.put("baseVersion", moduleIdentity.getVersion().map(v -> v.getBaseVersion().getVersion()));
task.getDestinationFile().convention(extension.getStagingRoot().file("release-notes/release-notes.html"));
});
Configuration jquery = project.getConfigurations().create("jquery", conf -> {
conf.setDescription("JQuery dependencies embedded by release notes.");
});
extension.releaseNotes(releaseNotes -> {
releaseNotes.getMarkdownFile().convention(extension.getSourceRoot().file("release/notes.md"));
releaseNotes.getRenderedDocumentation().convention(releaseNotesPostProcess.flatMap(DecorateReleaseNotes::getDestinationFile));
releaseNotes.getBaseCssFile().convention(extension.getSourceRoot().file("css/base.css"));
releaseNotes.getReleaseNotesCssFile().convention(extension.getSourceRoot().file("css/release-notes.css"));
releaseNotes.getReleaseNotesJsFile().convention(extension.getSourceRoot().file("release/content/script.js"));
releaseNotes.getJquery().from(jquery);
});
}
Aggregations