Search in sources :

Example 1 with TaskProvider

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;
}
Also used : LazyPublishArtifact(org.gradle.api.internal.artifacts.dsl.LazyPublishArtifact) Action(org.gradle.api.Action) Project(org.gradle.api.Project) Callable(java.util.concurrent.Callable) WarPlugin(org.gradle.api.plugins.WarPlugin) BootWar(org.springframework.boot.gradle.tasks.bundling.BootWar) BasePlugin(org.gradle.api.plugins.BasePlugin) FileCollection(org.gradle.api.file.FileCollection) SourceSet(org.gradle.api.tasks.SourceSet) BootBuildImage(org.springframework.boot.gradle.tasks.bundling.BootBuildImage) Configuration(org.gradle.api.artifacts.Configuration) Provider(org.gradle.api.provider.Provider) War(org.gradle.api.tasks.bundling.War) ConfigurationContainer(org.gradle.api.artifacts.ConfigurationContainer) TaskProvider(org.gradle.api.tasks.TaskProvider) SourceSetContainer(org.gradle.api.tasks.SourceSetContainer) Plugin(org.gradle.api.Plugin) BootWar(org.springframework.boot.gradle.tasks.bundling.BootWar) Configuration(org.gradle.api.artifacts.Configuration) FileCollection(org.gradle.api.file.FileCollection) SourceSetContainer(org.gradle.api.tasks.SourceSetContainer)

Example 2 with TaskProvider

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);
    }
}
Also used : Action(org.gradle.api.Action) Project(org.gradle.api.Project) Jar(org.gradle.jvm.tasks.Jar) BuildInfo(org.springframework.boot.gradle.tasks.buildinfo.BuildInfo) JavaPlugin(org.gradle.api.plugins.JavaPlugin) BasePlugin(org.gradle.api.plugins.BasePlugin) File(java.io.File) SourceSet(org.gradle.api.tasks.SourceSet) TaskContainer(org.gradle.api.tasks.TaskContainer) TaskProvider(org.gradle.api.tasks.TaskProvider) JavaPluginExtension(org.gradle.api.plugins.JavaPluginExtension) Property(org.gradle.api.provider.Property) BuildInfoProperties(org.springframework.boot.gradle.tasks.buildinfo.BuildInfoProperties) TaskContainer(org.gradle.api.tasks.TaskContainer) BuildInfo(org.springframework.boot.gradle.tasks.buildinfo.BuildInfo) BuildInfoProperties(org.springframework.boot.gradle.tasks.buildinfo.BuildInfoProperties)

Example 3 with TaskProvider

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);
    });
}
Also used : HashMap(java.util.HashMap) ArrayList(java.util.ArrayList) Collections.singletonList(java.util.Collections.singletonList) LifecycleBasePlugin(org.gradle.language.base.plugins.LifecycleBasePlugin) Provider(org.gradle.api.provider.Provider) RelativePath(org.gradle.api.file.RelativePath) Sync(org.gradle.api.tasks.Sync) AsciidoctorTask(org.asciidoctor.gradle.jvm.AsciidoctorTask) TaskProvider(org.gradle.api.tasks.TaskProvider) DirectoryProperty(org.gradle.api.file.DirectoryProperty) SourceSetContainer(org.gradle.api.tasks.SourceSetContainer) Arrays.asList(java.util.Arrays.asList) PathSensitivity(org.gradle.api.tasks.PathSensitivity) Map(java.util.Map) DuplicatesStrategy(org.gradle.api.file.DuplicatesStrategy) Collections.singletonMap(java.util.Collections.singletonMap) Directory(org.gradle.api.file.Directory) TaskInputs(org.gradle.api.tasks.TaskInputs) Project(org.gradle.api.Project) List(java.util.List) ProjectLayout(org.gradle.api.file.ProjectLayout) TaskContainer(org.gradle.api.tasks.TaskContainer) GenerateApiMapping(gradlebuild.docs.dsl.source.GenerateApiMapping) GenerateDefaultImports(gradlebuild.docs.dsl.source.GenerateDefaultImports) Plugin(org.gradle.api.Plugin) HashMap(java.util.HashMap) TaskInputs(org.gradle.api.tasks.TaskInputs) DirectoryProperty(org.gradle.api.file.DirectoryProperty) Sync(org.gradle.api.tasks.Sync) AsciidoctorTask(org.asciidoctor.gradle.jvm.AsciidoctorTask) Directory(org.gradle.api.file.Directory)

Example 4 with TaskProvider

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);
}
Also used : HashMap(java.util.HashMap) ArrayList(java.util.ArrayList) Collections.singletonList(java.util.Collections.singletonList) LifecycleBasePlugin(org.gradle.language.base.plugins.LifecycleBasePlugin) Provider(org.gradle.api.provider.Provider) RelativePath(org.gradle.api.file.RelativePath) Sync(org.gradle.api.tasks.Sync) AsciidoctorTask(org.asciidoctor.gradle.jvm.AsciidoctorTask) TaskProvider(org.gradle.api.tasks.TaskProvider) DirectoryProperty(org.gradle.api.file.DirectoryProperty) SourceSetContainer(org.gradle.api.tasks.SourceSetContainer) Arrays.asList(java.util.Arrays.asList) PathSensitivity(org.gradle.api.tasks.PathSensitivity) Map(java.util.Map) DuplicatesStrategy(org.gradle.api.file.DuplicatesStrategy) Collections.singletonMap(java.util.Collections.singletonMap) Directory(org.gradle.api.file.Directory) TaskInputs(org.gradle.api.tasks.TaskInputs) Project(org.gradle.api.Project) List(java.util.List) ProjectLayout(org.gradle.api.file.ProjectLayout) TaskContainer(org.gradle.api.tasks.TaskContainer) GenerateApiMapping(gradlebuild.docs.dsl.source.GenerateApiMapping) GenerateDefaultImports(gradlebuild.docs.dsl.source.GenerateDefaultImports) Plugin(org.gradle.api.Plugin) GenerateDefaultImports(gradlebuild.docs.dsl.source.GenerateDefaultImports) GenerateApiMapping(gradlebuild.docs.dsl.source.GenerateApiMapping) SourceSetContainer(org.gradle.api.tasks.SourceSetContainer) Directory(org.gradle.api.file.Directory)

Example 5 with TaskProvider

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);
    });
}
Also used : Configuration(org.gradle.api.artifacts.Configuration) ProjectLayout(org.gradle.api.file.ProjectLayout) TaskContainer(org.gradle.api.tasks.TaskContainer) Charset(java.nio.charset.Charset) Project(org.gradle.api.Project) MapProperty(org.gradle.api.provider.MapProperty) TaskProvider(org.gradle.api.tasks.TaskProvider) ModuleIdentityExtension(gradlebuild.identity.extension.ModuleIdentityExtension) Plugin(org.gradle.api.Plugin) GradleVersion(org.gradle.util.GradleVersion) Configuration(org.gradle.api.artifacts.Configuration) ModuleIdentityExtension(gradlebuild.identity.extension.ModuleIdentityExtension)

Aggregations

TaskProvider (org.gradle.api.tasks.TaskProvider)28 Project (org.gradle.api.Project)25 Plugin (org.gradle.api.Plugin)23 TaskContainer (org.gradle.api.tasks.TaskContainer)18 Inject (javax.inject.Inject)17 ObjectFactory (org.gradle.api.model.ObjectFactory)14 Provider (org.gradle.api.provider.Provider)12 LifecycleBasePlugin (org.gradle.language.base.plugins.LifecycleBasePlugin)12 Task (org.gradle.api.Task)11 DirectoryProperty (org.gradle.api.file.DirectoryProperty)11 File (java.io.File)10 Configuration (org.gradle.api.artifacts.Configuration)10 Callable (java.util.concurrent.Callable)9 ProjectInternal (org.gradle.api.internal.project.ProjectInternal)9 List (java.util.List)8 Action (org.gradle.api.Action)8 SourceSet (org.gradle.api.tasks.SourceSet)8 Names (org.gradle.language.nativeplatform.internal.Names)8 SourceSetContainer (org.gradle.api.tasks.SourceSetContainer)7 Set (java.util.Set)6