下面列出了怎么用org.gradle.api.tasks.SourceSetContainer的API类实例代码及写法，或者点击链接到github查看源代码。
private void configureCompileTestJavaTask(final Project project) {
final JavaCompile compileTestJava = (JavaCompile) project.getTasks()
.findByName(JavaPlugin.COMPILE_TEST_JAVA_TASK_NAME);
final SourceSet test = ((SourceSetContainer) project.getProperties().get("sourceSets")).getByName("test");
final JavaModule module = (JavaModule) project.getExtensions().getByName(EXTENSION_NAME);
compileTestJava.getInputs().property("moduleName", module.geName());
compileTestJava.doFirst(new Action<Task>() {
@Override
public void execute(Task task) {
List<String> args = new ArrayList<>();
args.add("--module-path");
args.add(compileTestJava.getClasspath().getAsPath());
args.add("--add-modules");
args.add("junit");
args.add("--add-reads");
args.add(module.geName() + "=junit");
args.add("--patch-module");
args.add(module.geName() + "=" + test.getJava().getSourceDirectories().getAsPath());
compileTestJava.getOptions().setCompilerArgs(args);
compileTestJava.setClasspath(project.files());
}
});
}
private void configureTestTask(final Project project) {
final Test testTask = (Test) project.getTasks().findByName(JavaPlugin.TEST_TASK_NAME);
final SourceSet test = ((SourceSetContainer) project.getProperties().get("sourceSets")).getByName("test");
final JavaModule module = (JavaModule) project.getExtensions().getByName(EXTENSION_NAME);
testTask.getInputs().property("moduleName", module.geName());
testTask.doFirst(new Action<Task>() {
@Override
public void execute(Task task) {
List<String> args = new ArrayList<>();
args.add("--module-path");
args.add(testTask.getClasspath().getAsPath());
args.add("--add-modules");
args.add("ALL-MODULE-PATH");
args.add("--add-reads");
args.add(module.geName() + "=junit");
args.add("--patch-module");
args.add(module.geName() + "=" + test.getJava().getOutputDir());
testTask.setJvmArgs(args);
testTask.setClasspath(project.files());
}
});
}
@Override
public void apply(final Project project) {
Configuration config = project.getConfigurations().create("crnkJavaDocToXml");
project.getDependencies().add("crnkJavaDocToXml", "com.github.markusbernhardt:xml-doclet:1.0.5");
Javadoc task = project.getTasks().create(TASK_NAME, Javadoc.class);
task.setTitle(null);
task.setDestinationDir(new File(project.getBuildDir(), "crnk-xml-docs"));
MinimalJavadocOptions options = task.getOptions();
options.setDoclet("com.github.markusbernhardt.xmldoclet.XmlDoclet");
options.setMemberLevel(JavadocMemberLevel.PRIVATE);
options.setDocletpath(new ArrayList<>(config.getFiles()));
SourceSetContainer sourceSets = (SourceSetContainer) project.getProperties().get("sourceSets");
SourceSet mainSourceSet = sourceSets.getByName("main");
task.source(mainSourceSet.getAllJava());
task.setClasspath(mainSourceSet.getCompileClasspath());
}
@Override
public void apply(Project project) {
GeneratePluginExtension generatePluginExtension = project.getExtensions().create(EXTENSION_NAME,
GeneratePluginExtension.class, project);
GenerateTask generateTask = project.getTasks().create(TASK_NAME, GenerateTask.class);
generateTask.setGroup(BasePlugin.BUILD_GROUP);
generateTask.setDescription("Generates DDL scripts based on JPA model.");
generateTask.setExtension(generatePluginExtension);
generateTask.dependsOn(JavaBasePlugin.BUILD_TASK_NAME);
project.afterEvaluate(evaluatedProject -> {
fillDefaults(evaluatedProject, generatePluginExtension);
SourceSetContainer sourceSets = (SourceSetContainer) project.getProperties().get("sourceSets");
Set<File> paths;
if (sourceSets != null) {
UnionFileCollection mainClasspath = (UnionFileCollection) sourceSets.getByName(SourceSet.MAIN_SOURCE_SET_NAME).getRuntimeClasspath();
paths = mainClasspath.getFiles();
} else {
paths = new HashSet<>();
}
generateTask.setOutputClassesDirs(paths);
});
}
public MavenProjectWrapper(Project project, File pomFile) throws IOException, XmlPullParserException {
this.project = project;
this.pomFile = pomFile;
MavenXpp3Reader reader = new MavenXpp3Reader();
Model model = reader.read(new FileReader(pomFile));
setModel(model);
getBuild().setDirectory(project.getBuildDir().getAbsolutePath());
SourceSetContainer sourceSets = project.getConvention().getPlugin(JavaPluginConvention.class).getSourceSets();
SourceSet main = sourceSets.getByName(SourceSet.MAIN_SOURCE_SET_NAME);
getBuild().setSourceDirectory(main.getJava().getSrcDirs().iterator().next().getAbsolutePath());
getBuild().setOutputDirectory(main.getJava().getOutputDir().getAbsolutePath());
SourceSet test = sourceSets.getByName(SourceSet.TEST_SOURCE_SET_NAME);
getBuild().setTestSourceDirectory(test.getJava().getSrcDirs().iterator().next().getAbsolutePath());
getBuild().setTestOutputDirectory(test.getJava().getOutputDir().getAbsolutePath());
setArtifact(new ProjectArtifact(this));
}
public MavenProjectWrapper(Project project, File pomFile) throws IOException, XmlPullParserException {
this.project = project;
this.pomFile = pomFile;
MavenXpp3Reader reader = new MavenXpp3Reader();
Model model = reader.read(new FileReader(pomFile));
setModel(model);
getBuild().setDirectory(project.getBuildDir().getAbsolutePath());
SourceSetContainer sourceSets = project.getConvention().getPlugin(JavaPluginConvention.class).getSourceSets();
SourceSet main = sourceSets.getByName(SourceSet.MAIN_SOURCE_SET_NAME);
getBuild().setSourceDirectory(main.getJava().getSrcDirs().iterator().next().getAbsolutePath());
getBuild().setOutputDirectory(main.getJava().getOutputDir().getAbsolutePath());
SourceSet test = sourceSets.getByName(SourceSet.TEST_SOURCE_SET_NAME);
getBuild().setTestSourceDirectory(test.getJava().getSrcDirs().iterator().next().getAbsolutePath());
getBuild().setTestOutputDirectory(test.getJava().getOutputDir().getAbsolutePath());
setArtifact(new ProjectArtifact(this));
}
@Override
public void apply(Project project) {
Configuration optional = project.getConfigurations().create(OPTIONAL_CONFIGURATION_NAME);
optional.attributes((attributes) -> attributes.attribute(Usage.USAGE_ATTRIBUTE,
project.getObjects().named(Usage.class, Usage.JAVA_RUNTIME)));
project.getPlugins().withType(JavaPlugin.class, (javaPlugin) -> {
SourceSetContainer sourceSets = project.getConvention().getPlugin(JavaPluginConvention.class)
.getSourceSets();
sourceSets.all((sourceSet) -> {
sourceSet.setCompileClasspath(sourceSet.getCompileClasspath().plus(optional));
sourceSet.setRuntimeClasspath(sourceSet.getRuntimeClasspath().plus(optional));
});
project.getTasks().withType(Javadoc.class)
.all((javadoc) -> javadoc.setClasspath(javadoc.getClasspath().plus(optional)));
});
project.getPlugins().withType(EclipsePlugin.class,
(eclipsePlugin) -> project.getExtensions().getByType(EclipseModel.class)
.classpath((classpath) -> classpath.getPlusConfigurations().add(optional)));
}
private List<Path> getClassPathFromSourceSets() {
List<Path> classPath = Collections.emptyList();
SourceSetContainer sourceSetContainer = (SourceSetContainer) project.getProperties().get("sourceSets");
SourceSet mainSourceSet = sourceSetContainer.findByName("main");
if (mainSourceSet != null) {
classPath = mainSourceSet.getRuntimeClasspath().getFiles().stream()
.filter(File::exists)
.map(File::toPath).collect(Collectors.toList());
}
return classPath;
}
public void apply(final Project target) {
target.getPluginManager().apply(JavaPlugin.class);
target.getPluginManager().apply(SolidityPlugin.class);
target.getExtensions().create(Web3jExtension.NAME, Web3jExtension.class, target);
target.getDependencies().add("implementation", "org.web3j:core:" + getProjectVersion());
final SourceSetContainer sourceSets =
target.getConvention().getPlugin(JavaPluginConvention.class).getSourceSets();
target.afterEvaluate(p -> sourceSets.all(sourceSet -> configure(target, sourceSet)));
}
public QuarkusTestNative() {
setDescription("Runs native image tests");
setGroup("verification");
JavaPluginConvention javaPlugin = getProject().getConvention().getPlugin(JavaPluginConvention.class);
SourceSetContainer sourceSets = javaPlugin.getSourceSets();
SourceSet sourceSet = sourceSets.findByName(QuarkusPlugin.NATIVE_TEST_SOURCE_SET_NAME);
setTestClassesDirs(sourceSet.getOutput().getClassesDirs());
setClasspath(sourceSet.getRuntimeClasspath());
}
public Set<File> getProjectLibraries() {
Set<File> classpath = new HashSet<>();
SourceSetContainer sourceSets = (SourceSetContainer) project.getProperties().get("sourceSets");
if (sourceSets != null) {
SortedSet<String> availableSourceSetNames = sourceSets.getNames();
for (String sourceSetName : Arrays.asList("main", "test", "integrationTest")) {
if (availableSourceSetNames.contains(sourceSetName)) {
SourceSet sourceSet = sourceSets.getByName(sourceSetName);
classpath.addAll(sourceSet.getOutput().getClassesDirs().getFiles());
classpath.add(sourceSet.getOutput().getResourcesDir());
}
}
}
// add dependencies from configured gradle configuration to url (usually test or integrationTest)
GeneratorConfig generatorConfiguration = project.getExtensions().getByType(GeneratorExtension.class);
String configurationName = generatorConfiguration.getRuntime().getConfiguration();
ConfigurationContainer configurations = project.getConfigurations();
Configuration runtimeConfiguration = configurations.findByName(configurationName + "Runtime");
if (runtimeConfiguration == null) {
runtimeConfiguration = configurations.getByName(configurationName);
}
classpath.addAll(runtimeConfiguration.getFiles());
for (File file : classpath) {
LOGGER.debug("classpath entry: {}", file);
}
return classpath;
}
private void configureSourceSetDefaults(Project project, ClojureScriptExtension extension) {
project.getExtensions().getByType(SourceSetContainer.class).all((SourceSet sourceSet) -> {
ClojureScriptSourceSet clojurescriptSourceSet = new DefaultClojureScriptSourceSet("clojurescript", objects);
new DslObject(sourceSet).getConvention().getPlugins().put("clojurescript", clojurescriptSourceSet);
clojurescriptSourceSet.getClojureScript().srcDir(String.format("src/%s/clojurescript", sourceSet.getName()));
// in case the clojure source overlaps with the resources source
sourceSet.getResources().getFilter().exclude(element -> clojurescriptSourceSet.getClojureScript().contains(element.getFile()));
sourceSet.getAllSource().source(clojurescriptSourceSet.getClojureScript());
ClojureScriptBuild build = extension.getBuilds().create(sourceSet.getName());
build.getSourceSet().set(sourceSet);
project.getTasks().named(sourceSet.getClassesTaskName(), task -> {
task.dependsOn(build.getTaskName("compile"));
});
Provider<FileCollection> output = project.provider(() -> {
if (build.isCompilerConfigured()) {
return project.files(build.getOutputDir());
} else {
return clojurescriptSourceSet.getClojureScript().getSourceDirectories();
}
});
((DefaultSourceSetOutput) sourceSet.getOutput()).getClassesDirs().from(output);
project.getTasks().getByName(sourceSet.getClassesTaskName()).dependsOn(build.getTaskName("compile"));
});
}
@Override
public void apply(Project project) {
project.getPlugins().apply(ClojureScriptBasePlugin.class);
project.getPlugins().apply(ClojureCommonPlugin.class);
SourceSetContainer sourceSets = project.getExtensions().getByType(SourceSetContainer.class);
ClojureCommonPlugin.configureDevSource(sourceSets, sourceSet -> {
ClojureScriptSourceSet src = (ClojureScriptSourceSet) new DslObject(sourceSet).getConvention().getPlugins().get("clojurescript");
return src.getClojureScript();
});
}
@Override
public void apply(Project project) {
project.getPlugins().apply(ClojureBasePlugin.class);
project.getPlugins().apply(JavaPlugin.class);
SourceSetContainer sourceSets = project.getExtensions().getByType(SourceSetContainer.class);
configureDev(project, sourceSets);
configureDependencyConstraints(project);
configureDevSource(sourceSets, SourceSet::getResources);
}
public static void configureDevSource(SourceSetContainer sourceSets, Function<SourceSet, SourceDirectorySet> languageMapper) {
SourceSet main = sourceSets.getByName(SourceSet.MAIN_SOURCE_SET_NAME);
SourceSet test = sourceSets.getByName(SourceSet.TEST_SOURCE_SET_NAME);
SourceSet dev = sourceSets.getByName(DEV_SOURCE_SET_NAME);
languageMapper.apply(dev).source(languageMapper.apply(test));
languageMapper.apply(dev).source(languageMapper.apply(main));
}
@Override
public void apply(Project project) {
project.getPluginManager().apply(JavaBasePlugin.class);
SourceSetContainer sourceSets = project.getExtensions().getByType(SourceSetContainer.class);
configureSourceSets(project, sourceSets);
configureToolsConfigurations(project);
}
private void configureToolsConfigurations(Project project) {
Configuration tools = project.getConfigurations().create(TOOLS_CONFIGURATION_NAME);
tools.defaultDependencies(deps -> {
deps.add(project.getDependencies().create("dev.clojurephant:clojurephant-tools:" + getVersion()));
});
// TODO does this JAR get included via shadow or application plugins?
project.getExtensions().getByType(SourceSetContainer.class).all(sourceSet -> {
project.getConfigurations().getByName(sourceSet.getCompileClasspathConfigurationName()).extendsFrom(tools);
project.getConfigurations().getByName(sourceSet.getRuntimeClasspathConfigurationName()).extendsFrom(tools);
});
}
private void configureSourceSetDefaults(Project project, ClojureExtension extension) {
project.getExtensions().getByType(SourceSetContainer.class).all(sourceSet -> {
ClojureSourceSet clojureSourceSet = new DefaultClojureSourceSet("clojure", objects);
new DslObject(sourceSet).getConvention().getPlugins().put("clojure", clojureSourceSet);
clojureSourceSet.getClojure().srcDir(String.format("src/%s/clojure", sourceSet.getName()));
// in case the clojure source overlaps with the resources source
sourceSet.getResources().getFilter().exclude(element -> clojureSourceSet.getClojure().contains(element.getFile()));
sourceSet.getAllSource().source(clojureSourceSet.getClojure());
ClojureBuild build = extension.getBuilds().create(sourceSet.getName());
build.getSourceSet().set(sourceSet);
project.getTasks().named(sourceSet.getClassesTaskName(), task -> {
task.dependsOn(build.getTaskName("compile"));
task.dependsOn(build.getTaskName("check"));
});
Provider<FileCollection> output = project.provider(() -> {
if (build.isCompilerConfigured()) {
return project.files(build.getOutputDir());
} else {
return clojureSourceSet.getClojure().getSourceDirectories();
}
});
((DefaultSourceSetOutput) sourceSet.getOutput()).getClassesDirs().from(output);
project.getTasks().getByName(sourceSet.getClassesTaskName()).dependsOn(build.getTaskName("compile"));
project.getTasks().getByName(sourceSet.getClassesTaskName()).dependsOn(build.getTaskName("check"));
});
}
@Override
public void apply(Project project) {
project.getPlugins().apply(ClojureBasePlugin.class);
project.getPlugins().apply(ClojureCommonPlugin.class);
ClojureExtension extension = project.getExtensions().getByType(ClojureExtension.class);
configureBuilds(project, extension);
SourceSetContainer sourceSets = project.getExtensions().getByType(SourceSetContainer.class);
ClojureCommonPlugin.configureDevSource(sourceSets, sourceSet -> {
ClojureSourceSet src = (ClojureSourceSet) new DslObject(sourceSet).getConvention().getPlugins().get("clojure");
return src.getClojure();
});
}
@Override
public void apply(Project project) {
project.getPlugins().apply(JacocoPlugin.class);
project.getTasks().register("aggregateJacocoReport", JacocoReport.class, reportTask -> {
reportTask.setGroup(LifecycleBasePlugin.VERIFICATION_GROUP);
reportTask.setDescription(String.format("Generates aggregated code coverage report for the %s project.", project.getPath()));
project.allprojects(subproject -> {
subproject.getPlugins().withType(JavaPlugin.class, javaPlugin -> {
SourceSetContainer sourceSets = subproject.getConvention().getPlugin(JavaPluginConvention.class).getSourceSets();
SourceSet main = sourceSets.getByName(SourceSet.MAIN_SOURCE_SET_NAME);
reportTask.sourceSets(main);
});
subproject.getTasks()
.withType(Test.class)
.forEach(reportTask::executionData);
});
JacocoPluginExtension reportingExtension = project.getExtensions().getByType(JacocoPluginExtension.class);
reportTask.getReports().getHtml().setEnabled(true);
reportTask.getReports().all(report -> {
if (report.getOutputType().equals(Report.OutputType.DIRECTORY)) {
report.setDestination(project.provider(() -> new File(reportingExtension.getReportsDir(), reportTask.getName() + "/" + report.getName())));
}
else {
report.setDestination(project.provider(() -> new File(reportingExtension.getReportsDir(), reportTask.getName() + "/" + reportTask.getName() + "." + report.getName())));
}
});
});
}
@Override
public void apply(Project project) {
project.getPlugins().apply(JacocoPlugin.class);
project.getTasks().register("aggregateJacocoReport", JacocoReport.class, reportTask -> {
reportTask.setGroup(LifecycleBasePlugin.VERIFICATION_GROUP);
reportTask.setDescription(String.format("Generates aggregated code coverage report for the %s project.", project.getPath()));
project.allprojects(subproject -> {
subproject.getPlugins().withType(JavaPlugin.class, javaPlugin -> {
SourceSetContainer sourceSets = subproject.getConvention().getPlugin(JavaPluginConvention.class).getSourceSets();
SourceSet main = sourceSets.getByName(SourceSet.MAIN_SOURCE_SET_NAME);
reportTask.sourceSets(main);
});
subproject.getTasks()
.withType(Test.class)
.forEach(reportTask::executionData);
});
JacocoPluginExtension reportingExtension = project.getExtensions().getByType(JacocoPluginExtension.class);
reportTask.getReports().getHtml().setEnabled(true);
reportTask.getReports().all(report -> {
if (report.getOutputType().equals(Report.OutputType.DIRECTORY)) {
report.setDestination(project.provider(() -> new File(reportingExtension.getReportsDir(), reportTask.getName() + "/" + report.getName())));
}
else {
report.setDestination(project.provider(() -> new File(reportingExtension.getReportsDir(), reportTask.getName() + "/" + reportTask.getName() + "." + report.getName())));
}
});
});
}
@Override
public List<String> getSrcDirs() {
SourceSetContainer sourceSets = javaConvention.getSourceSets();
SourceSet mainSourceSet = sourceSets.getByName(SourceSet.MAIN_SOURCE_SET_NAME);
return mainSourceSet.getAllSource().getSrcDirs().stream().map(f -> {
try {
return f.getCanonicalPath();
} catch (IOException e) {
return "";
}
}).collect(Collectors.toList());
}
@Override
public List<String> getSrcDirs() {
SourceSetContainer sourceSets = javaConvention.getSourceSets();
SourceSet mainSourceSet = sourceSets.getByName(SourceSet.TEST_SOURCE_SET_NAME);
return mainSourceSet.getAllSource().getSrcDirs().stream().map(f -> {
try {
return f.getCanonicalPath();
} catch (IOException e) {
return "";
}
}).collect(Collectors.toList());
}
public SourceSet getSourceSet(SourceType sourceType) {
JavaPluginConvention javaPluginConvention;
try {
javaPluginConvention = project.getConvention().getPlugin(JavaPluginConvention.class);
} catch (IllegalStateException e) {
throw new RuntimeException("Gradle project apparently isn't a Java project--it doesn't use the Java plugin");
}
SourceSetContainer sourceSets = javaPluginConvention.getSourceSets();
return sourceSets.getByName(getSourceSetName(sourceType));
}
public void createBundleJar(File manifestFile) {
Jar jarTask = (Jar) project.getTasks().findByName(JAR_TASK_NAME);
if (jarTask == null)
throw new GradleException("Unable to find the gradle task: " + JAR_TASK_NAME);
jarTask.manifest((Manifest mf) -> mf.from(manifestFile));
SourceSetContainer sourceSets = project.getExtensions().getByType(SourceSetContainer.class);
jarTask.from(sourceSets.getByName(JAVA_MAIN_SOURCE_SET_NAME).getOutput());
jarTask.into(
JAR_LIB_DESTINATION,
(CopySpec cs) -> cs.from(project.getConfigurations().getByName(RELEASE_CONFIG_NAME)));
}
public SourceSetContainer sourceSets() {
return extension(SourceSetContainer.class);
}
private void addLocalProject(Project project, DevModeContext context, Set<AppArtifactKey> addeDeps, boolean root) {
final AppArtifactKey key = new AppArtifactKey(project.getGroup().toString(), project.getName());
if (addeDeps.contains(key)) {
return;
}
final JavaPluginConvention javaConvention = project.getConvention().findPlugin(JavaPluginConvention.class);
if (javaConvention == null) {
return;
}
SourceSetContainer sourceSets = javaConvention.getSourceSets();
SourceSet mainSourceSet = sourceSets.getByName(SourceSet.MAIN_SOURCE_SET_NAME);
Set<String> sourcePaths = new HashSet<>();
for (File sourceDir : mainSourceSet.getAllJava().getSrcDirs()) {
if (sourceDir.exists()) {
sourcePaths.add(sourceDir.getAbsolutePath());
}
}
//TODO: multiple resource directories
final File resourcesSrcDir = mainSourceSet.getResources().getSourceDirectories().getSingleFile();
if (sourcePaths.isEmpty() && !resourcesSrcDir.exists()) {
return;
}
String classesDir = QuarkusGradleUtils.getClassesDir(mainSourceSet, project.getBuildDir());
final String resourcesOutputPath;
if (resourcesSrcDir.exists()) {
resourcesOutputPath = mainSourceSet.getOutput().getResourcesDir().getAbsolutePath();
if (!Files.exists(Paths.get(classesDir))) {
// currently classesDir can't be null and is expected to exist
classesDir = resourcesOutputPath;
}
} else {
// currently resources dir should exist
resourcesOutputPath = classesDir;
}
DevModeContext.ModuleInfo wsModuleInfo = new DevModeContext.ModuleInfo(key,
project.getName(),
project.getProjectDir().getAbsolutePath(),
sourcePaths,
classesDir,
resourcesSrcDir.getAbsolutePath(),
resourcesOutputPath);
if (root) {
context.setApplicationRoot(wsModuleInfo);
} else {
context.getAdditionalModules().add(wsModuleInfo);
}
addeDeps.add(key);
}
@SuppressWarnings("Convert2Lambda")
private void registerTasks(Project project, QuarkusPluginExtension quarkusExt) {
TaskContainer tasks = project.getTasks();
tasks.create(LIST_EXTENSIONS_TASK_NAME, QuarkusListExtensions.class);
tasks.create(ADD_EXTENSION_TASK_NAME, QuarkusAddExtension.class);
tasks.create(REMOVE_EXTENSION_TASK_NAME, QuarkusRemoveExtension.class);
tasks.create(GENERATE_CONFIG_TASK_NAME, QuarkusGenerateConfig.class);
Task quarkusBuild = tasks.create(QUARKUS_BUILD_TASK_NAME, QuarkusBuild.class);
Task quarkusDev = tasks.create(QUARKUS_DEV_TASK_NAME, QuarkusDev.class);
Task quarkusRemoteDev = tasks.create(QUARKUS_REMOTE_DEV_TASK_NAME, QuarkusRemoteDev.class);
tasks.create(QUARKUS_TEST_CONFIG_TASK_NAME, QuarkusTestConfig.class);
Task buildNative = tasks.create(BUILD_NATIVE_TASK_NAME, DefaultTask.class);
buildNative.finalizedBy(quarkusBuild);
buildNative.doFirst(t -> project.getLogger()
.warn("The 'buildNative' task has been deprecated in favor of 'build -Dquarkus.package.type=native'"));
configureBuildNativeTask(project);
final Consumer<Test> configureTestTask = t -> {
// Quarkus test configuration action which should be executed before any Quarkus test
// Use anonymous classes in order to leverage task avoidance.
t.doFirst(new Action<Task>() {
@Override
public void execute(Task test) {
quarkusExt.beforeTest(t);
}
});
// also make each task use the JUnit platform since it's the only supported test environment
t.useJUnitPlatform();
// quarkusBuild is expected to run after the project has passed the tests
quarkusBuild.shouldRunAfter(t);
};
project.getPlugins().withType(
BasePlugin.class,
basePlugin -> tasks.getByName(BasePlugin.ASSEMBLE_TASK_NAME).dependsOn(quarkusBuild));
project.getPlugins().withType(
JavaPlugin.class,
javaPlugin -> {
project.afterEvaluate(this::afterEvaluate);
Task classesTask = tasks.getByName(JavaPlugin.CLASSES_TASK_NAME);
Task resourcesTask = tasks.getByName(JavaPlugin.PROCESS_RESOURCES_TASK_NAME);
quarkusDev.dependsOn(classesTask, resourcesTask);
quarkusRemoteDev.dependsOn(classesTask, resourcesTask);
quarkusBuild.dependsOn(classesTask, resourcesTask, tasks.getByName(JavaPlugin.JAR_TASK_NAME));
SourceSetContainer sourceSets = project.getConvention().getPlugin(JavaPluginConvention.class)
.getSourceSets();
SourceSet nativeTestSourceSet = sourceSets.create(NATIVE_TEST_SOURCE_SET_NAME);
SourceSet mainSourceSet = sourceSets.getByName(SourceSet.MAIN_SOURCE_SET_NAME);
SourceSet testSourceSet = sourceSets.getByName(SourceSet.TEST_SOURCE_SET_NAME);
nativeTestSourceSet.setCompileClasspath(
nativeTestSourceSet.getCompileClasspath()
.plus(mainSourceSet.getOutput())
.plus(testSourceSet.getOutput()));
nativeTestSourceSet.setRuntimeClasspath(
nativeTestSourceSet.getRuntimeClasspath()
.plus(mainSourceSet.getOutput())
.plus(testSourceSet.getOutput()));
// create a custom configuration to be used for the dependencies of the testNative task
ConfigurationContainer configurations = project.getConfigurations();
configurations.maybeCreate(NATIVE_TEST_IMPLEMENTATION_CONFIGURATION_NAME)
.extendsFrom(configurations.findByName(JavaPlugin.TEST_IMPLEMENTATION_CONFIGURATION_NAME));
configurations.maybeCreate(NATIVE_TEST_RUNTIME_ONLY_CONFIGURATION_NAME)
.extendsFrom(configurations.findByName(JavaPlugin.TEST_RUNTIME_ONLY_CONFIGURATION_NAME));
Task testNative = tasks.create(TEST_NATIVE_TASK_NAME, QuarkusTestNative.class);
testNative.dependsOn(quarkusBuild);
testNative.setShouldRunAfter(Collections.singletonList(tasks.findByName(JavaPlugin.TEST_TASK_NAME)));
tasks.withType(Test.class).forEach(configureTestTask);
tasks.withType(Test.class).whenTaskAdded(configureTestTask::accept);
});
}
private void configureDev(Project project, SourceSetContainer sourceSets) {
SourceSet main = sourceSets.getByName(SourceSet.MAIN_SOURCE_SET_NAME);
SourceSet test = sourceSets.getByName(SourceSet.TEST_SOURCE_SET_NAME);
SourceSet dev = sourceSets.create(DEV_SOURCE_SET_NAME);
Configuration nrepl = project.getConfigurations().create(NREPL_CONFIGURATION_NAME);
project.getDependencies().add(NREPL_CONFIGURATION_NAME, "nrepl:nrepl:0.6.0");
project.getConfigurations().getByName(dev.getCompileClasspathConfigurationName()).extendsFrom(nrepl);
project.getConfigurations().getByName(dev.getRuntimeClasspathConfigurationName()).extendsFrom(nrepl);
Function<SourceSet, FileCollection> nonClojureOutput = sourceSet -> {
FileCollection allOutput = sourceSet.getOutput();
return allOutput.filter((File file) -> {
return project.getTasks().stream()
.filter(task -> task instanceof ClojureCompile || task instanceof ClojureScriptCompile || task instanceof ProcessResources)
.allMatch(task -> !task.getOutputs().getFiles().contains(file));
});
};
dev.setCompileClasspath(project.files(
test.getOutput(),
main.getOutput(),
project.getConfigurations().getByName(dev.getCompileClasspathConfigurationName())));
dev.setRuntimeClasspath(project.files(
dev.getAllSource().getSourceDirectories(),
nonClojureOutput.apply(dev),
nonClojureOutput.apply(test),
nonClojureOutput.apply(main),
project.getConfigurations().getByName(dev.getRuntimeClasspathConfigurationName())));
Consumer<Function<SourceSet, String>> devExtendsTest = getConfName -> {
Configuration devConf = project.getConfigurations().getByName(getConfName.apply(dev));
Configuration testConf = project.getConfigurations().getByName(getConfName.apply(test));
devConf.extendsFrom(testConf);
};
devExtendsTest.accept(SourceSet::getImplementationConfigurationName);
devExtendsTest.accept(SourceSet::getRuntimeOnlyConfigurationName);
TaskProvider<ClojureNRepl> repl = project.getTasks().register(NREPL_TASK_NAME, ClojureNRepl.class, task -> {
task.setGroup("run");
task.setDescription("Starts an nREPL server.");
task.setClasspath(dev.getRuntimeClasspath());
});
// if you only ask for the REPL task, don't pre-compile/check the Clojure code (besides the dev one
// for the user namespace)
project.getGradle().getTaskGraph().whenReady(graph -> {
// using this string concat approach to avoid realizing the task provider, if it's not needed
if (!graph.hasTask(project.getPath() + NREPL_TASK_NAME)) {
return;
}
Set<Task> selectedTasks = new HashSet<>(graph.getAllTasks());
Queue<Task> toProcess = new LinkedList<>();
toProcess.add(repl.get());
Set<Task> toDisable = new HashSet<>();
while (!toProcess.isEmpty()) {
Task next = toProcess.remove();
selectedTasks.remove(next);
if (next instanceof ClojureCompile || next instanceof ClojureScriptCompile) {
toDisable.add(next);
} else if (next instanceof ClojureCheck && !"checkDevClojure".equals(next.getName())) {
toDisable.add(next);
}
graph.getDependencies(next).forEach(toProcess::add);
}
// if empty, only the REPL was requested to run, so we can optimize for that use case
if (selectedTasks.isEmpty()) {
toDisable.forEach(task -> task.setEnabled(false));
}
});
}
private void configureSourceSets(Project project, SourceSetContainer sourceSets) {
sourceSets.all(sourceSet -> {
sourceSet.getResources().exclude("**/.keep");
});
}