use of org.gradle.api.tasks.Delete in project gradle by gradle.
the class IdePlugin method addWorker.
public void addWorker(Task worker, boolean includeInClean) {
lifecycleTask.dependsOn(worker);
Delete cleanWorker = project.getTasks().create(cleanName(worker.getName()), Delete.class);
cleanWorker.delete(worker.getOutputs().getFiles());
if (includeInClean) {
cleanTask.dependsOn(cleanWorker);
}
}
use of org.gradle.api.tasks.Delete in project curiostack by curioswitch.
the class CuriostackPlugin method setupJavaProject.
private static void setupJavaProject(Project project) {
PluginContainer plugins = project.getPlugins();
plugins.apply(AptPlugin.class);
plugins.apply(AptIdeaPlugin.class);
plugins.apply(BaselineIdea.class);
plugins.apply(DependencyManagementPlugin.class);
plugins.apply(ErrorPronePlugin.class);
plugins.apply(LicensePlugin.class);
plugins.apply(SpotlessPlugin.class);
plugins.apply(VersionsPlugin.class);
project.getTasks().withType(JavaCompile.class, task -> {
task.getOptions().setIncremental(true);
task.getOptions().getCompilerArgs().addAll(ImmutableList.of("-XepDisableWarningsInGeneratedCode", "-XepExcludedPaths:(.*/build/.*|.*/gen-src/.*)", "-Xep:AutoFactoryAtInject:ERROR", "-Xep:ClassName:ERROR", "-Xep:ComparisonContractViolated:ERROR", "-Xep:DepAnn:ERROR", "-Xep:DivZero:ERROR", "-Xep:EmptyIf:ERROR", "-Xep:FuzzyEqualsShouldNotBeUsedInEqualsMethod:ERROR", "-Xep:InjectInvalidTargetingOnScopingAnnotation:ERROR", "-Xep:InjectScopeAnnotationOnInterfaceOrAbstractClass:ERROR", "-Xep:InsecureCryptoUsage:ERROR", "-Xep:IterablePathParameter:ERROR", "-Xep:LongLiteralLowerCaseSuffix:ERROR", "-Xep:NumericEquality:ERROR", "-Xep:ParameterPackage:ERROR", "-Xep:ProtoStringFieldReferenceEquality:ERROR", "-Xep:AssistedInjectAndInjectOnConstructors:ERROR", "-Xep:BigDecimalLiteralDouble:ERROR", "-Xep:ConstructorLeaksThis:ERROR", "-Xep:InconsistentOverloads:ERROR", "-Xep:MissingDefault:ERROR", "-Xep:PrimitiveArrayPassedToVarargsMethod:ERROR", "-Xep:RedundantThrows:ERROR", "-Xep:StaticQualifiedUsingExpression:ERROR", "-Xep:StringEquality:ERROR", "-Xep:TestExceptionChecker:ERROR", "-Xep:FieldMissingNullable:ERROR", "-Xep:LambdaFunctionalInterface:ERROR", "-Xep:MethodCanBeStatic:ERROR", "-Xep:MixedArrayDimensions:ERROR", "-Xep:MultiVariableDeclaration:ERROR", "-Xep:MultipleTopLevelClasses:ERROR", "-Xep:MultipleUnaryOperatorsInMethodCall:ERROR", "-Xep:PackageLocation:ERROR", "-Xep:ParameterComment:ERROR", "-Xep:ParameterNotNullable:ERROR", "-Xep:PrivateConstructorForUtilityClass:ERROR", "-Xep:RemoveUnusedImports:ERROR", "-Xep:ReturnMissingNullable:ERROR", "-Xep:SwitchDefault:ERROR", "-Xep:ThrowsUncheckedException:ERROR", "-Xep:UngroupedOverloads:ERROR", "-Xep:UnnecessaryStaticImport:ERROR", "-Xep:UseBinds:ERROR", "-Xep:WildcardImport:ERROR"));
project.getTasks().withType(SpotlessTask.class, spotlessTask -> spotlessTask.dependsOn(task));
});
JavaPluginConvention javaPlugin = project.getConvention().getPlugin(JavaPluginConvention.class);
javaPlugin.setSourceCompatibility(JavaVersion.VERSION_1_9);
javaPlugin.setTargetCompatibility(JavaVersion.VERSION_1_9);
Test test = project.getTasks().withType(Test.class).getByName("test");
if (project.getRootProject().hasProperty("updateSnapshots")) {
test.jvmArgs(ImmutableList.of("-Dorg.curioswitch.testing.updateSnapshots=true"));
}
test.useJUnitPlatform(platform -> platform.includeEngines("junit-jupiter", "junit-vintage"));
// While Gradle attempts to generate a unique module name automatically,
// it doesn't seem to always work properly, so we just always use unique
// module names.
project.getPlugins().withType(IdeaPlugin.class, plugin -> {
IdeaModule module = plugin.getModel().getModule();
String moduleName = project.getName();
Project ancestor = project.getParent();
while (ancestor != null && ancestor != project.getRootProject()) {
moduleName = ancestor.getName() + "-" + moduleName;
ancestor = ancestor.getParent();
}
module.setName(moduleName);
project.getTasks().getByName("clean").doLast(unused -> project.file(project.getName() + ".iml").delete());
new DslObject(module).getConvention().getPlugin(ModuleAptConvention.class).getApt().setAddAptDependencies(false);
});
DependencyManagementExtension dependencyManagement = project.getExtensions().getByType(DependencyManagementExtension.class);
dependencyManagement.dependencies(dependencies -> {
for (DependencySet set : StandardDependencies.DEPENDENCY_SETS) {
dependencies.dependencySet(ImmutableMap.of("group", set.group(), "version", set.version()), dependencySet -> set.modules().forEach(dependencySet::entry));
}
StandardDependencies.DEPENDENCIES.forEach(dependencies::dependency);
});
// Pretty much all java code needs at least the Generated annotation.
project.getDependencies().add(JavaPlugin.IMPLEMENTATION_CONFIGURATION_NAME, "javax.annotation:javax.annotation-api");
project.afterEvaluate(CuriostackPlugin::addStandardJavaTestDependencies);
project.getConfigurations().all(configuration -> configuration.exclude(ImmutableMap.of("group", "com.google.guava", "module", "guava-jdk5")));
Javadoc javadoc = (Javadoc) project.getTasks().getByName("javadoc");
CoreJavadocOptions options = (CoreJavadocOptions) javadoc.getOptions();
options.quiet();
options.addBooleanOption("Xdoclint:all,-missing", true);
project.getTasks().create("javadocJar", Jar.class, javadocJar -> {
javadocJar.dependsOn(javadoc);
javadocJar.setClassifier("javadoc");
javadocJar.from(javadoc.getDestinationDir());
});
SourceSetContainer sourceSets = javaPlugin.getSourceSets();
project.getTasks().create("sourceJar", Jar.class, sourceJar -> {
sourceJar.setClassifier("sources");
sourceJar.from(sourceSets.getByName(SourceSet.MAIN_SOURCE_SET_NAME).getAllSource());
});
SpotlessExtension spotless = project.getExtensions().getByType(SpotlessExtension.class);
spotless.java((extension) -> extension.googleJavaFormat(GOOGLE_JAVA_FORMAT_VERSION));
project.getTasks().create("resolveDependencies", resolveDependencies -> resolveDependencies.doLast(unused -> {
project.getConfigurations().all(configuration -> {
if (configuration.isCanBeResolved()) {
configuration.resolve();
}
});
}));
// Protobuf plugin doesn't add proto sourceset to allSource, which seems like an omission.
// We add it to make sure license plugin picks up the files.
project.getPlugins().withType(ProtobufPlugin.class, unused -> {
for (SourceSet sourceSet : sourceSets) {
sourceSet.getAllSource().source(((ExtensionAware) sourceSet).getExtensions().getByType(ProtobufSourceDirectorySet.class));
}
});
project.getPlugins().withType(JMHPlugin.class, unused -> {
JMHPluginExtension jmh = project.getExtensions().getByType(JMHPluginExtension.class);
// Benchmarks are usually very small and converge quickly. If this stops being the
// case
// these numbers can be adjusted.
jmh.setFork(2);
jmh.setIterations(5);
jmh.setProfilers(ImmutableList.of("hs_comp"));
jmh.setJmhVersion("1.19");
Object jmhRegex = project.getRootProject().findProperty("jmhRegex");
if (jmhRegex != null) {
jmh.setInclude((String) jmhRegex);
}
// We will use the jmhManaged for any dependencies that should only be applied to JMH
// but should be resolved by our managed dependencies. We need a separate
// configuration
// to be able to provide the resolution workaround described below.
Configuration jmhManaged = project.getConfigurations().create("jmhManaged");
Configuration jmhConfiguration = project.getConfigurations().getByName("jmh");
jmhConfiguration.extendsFrom(jmhManaged);
// JMH plugin uses a detached configuration to build an uber-jar, which
// dependencyManagement
// doesn't know about. Work around this by forcing parent configurations to be
// resolved and
// added directly to the jmh configuration, which overwrites the otherwise
// unresolvable
// dependency.
project.afterEvaluate(p -> {
jmhConfiguration.getExtendsFrom().forEach(parent -> {
parent.getResolvedConfiguration().getFirstLevelModuleDependencies().forEach(dep -> {
project.getDependencies().add("jmh", dep.getModule().toString());
});
});
});
});
project.getPlugins().withType(JooqPlugin.class, unused -> {
project.getTasks().withType(JooqTask.class, t -> {
for (String dependency : ImmutableList.of("javax.activation:activation", "javax.xml.bind:jaxb-api", "com.sun.xml.bind:jaxb-core", "com.sun.xml.bind:jaxb-impl", "mysql:mysql-connector-java", // Not sure why this isn't automatically added.
"com.google.guava:guava", "com.google.cloud.sql:mysql-socket-factory")) {
project.getDependencies().add("jooqRuntime", dependency);
}
});
});
// It is very common to want to pass in command line system properties to the binary, so just
// always forward properties. It won't affect production since no one runs binaries via Gradle
// in production.
project.getTasks().withType(JavaExec.class, task -> System.getProperties().entrySet().stream().filter(entry -> !entry.getKey().equals("java.endorsed.dirs")).forEach(entry -> task.systemProperty((String) entry.getKey(), entry.getValue())));
}
use of org.gradle.api.tasks.Delete in project gradle by gradle.
the class VisualStudioPlugin method configureCleanTask.
private void configureCleanTask() {
final Delete cleanTask = (Delete) getCleanTask();
project.getTasks().withType(GenerateSolutionFileTask.class).all(new Action<GenerateSolutionFileTask>() {
@Override
public void execute(GenerateSolutionFileTask task) {
cleanTask.delete(task.getOutputs().getFiles());
}
});
project.getTasks().withType(GenerateFiltersFileTask.class).all(new Action<GenerateFiltersFileTask>() {
@Override
public void execute(GenerateFiltersFileTask task) {
cleanTask.delete(task.getOutputs().getFiles());
}
});
project.getTasks().withType(GenerateProjectFileTask.class).all(new Action<GenerateProjectFileTask>() {
@Override
public void execute(GenerateProjectFileTask task) {
cleanTask.delete(task.getOutputs().getFiles());
}
});
}
use of org.gradle.api.tasks.Delete in project gradle-apt-plugin by tbroyer.
the class AptEclipsePlugin method configureEclipse.
/**
* Inspired by
* https://github.com/mkarneim/pojobuilder/wiki/Enabling-PojoBuilder-for-Eclipse-Using-Gradle
*/
private void configureEclipse(final Project project, final SourceSet mainSourceSet, final SourceSet testSourceSet) {
final EclipseModel eclipseModel = project.getExtensions().getByType(EclipseModel.class);
project.afterEvaluate(new Action<Project>() {
@Override
public void execute(final Project project) {
eclipseModel.getClasspath().getPlusConfigurations().addAll(Arrays.asList(project.getConfigurations().getByName(new DslObject(mainSourceSet).getConvention().getPlugin(AptPlugin.AptSourceSetConvention.class).getCompileOnlyConfigurationName()), project.getConfigurations().getByName(new DslObject(testSourceSet).getConvention().getPlugin(AptPlugin.AptSourceSetConvention.class).getCompileOnlyConfigurationName())));
}
});
if (project.getTasks().findByName("eclipseJdtApt") == null) {
GenerateEclipseJdtApt task = project.getTasks().create("eclipseJdtApt", GenerateEclipseJdtApt.class, new Action<GenerateEclipseJdtApt>() {
@Override
public void execute(GenerateEclipseJdtApt generateEclipseJdtApt) {
generateEclipseJdtApt.setDescription("Generates the Eclipse JDT APT settings file.");
generateEclipseJdtApt.setInputFile(project.file(".settings/org.eclipse.jdt.apt.core.prefs"));
generateEclipseJdtApt.setOutputFile(project.file(".settings/org.eclipse.jdt.apt.core.prefs"));
final EclipseJdtApt jdtApt = generateEclipseJdtApt.getJdtApt();
new DslObject(eclipseModel.getJdt()).getConvention().getPlugins().put("net.ltgt.apt-eclipse", new JdtAptConvention(jdtApt));
ConventionMapping conventionMapping = new DslObject(jdtApt).getConventionMapping();
conventionMapping.map("aptEnabled", new Callable<Boolean>() {
@Override
public Boolean call() throws Exception {
return project.getTasks().findByName(mainSourceSet.getCompileJavaTaskName()).getConvention().getPlugin(AptPlugin.AptConvention.class).getAptOptions().isAnnotationProcessing();
}
});
conventionMapping.map("genSrcDir", new Callable<File>() {
@Override
public File call() throws Exception {
return project.file(".apt_generated");
}
});
conventionMapping.map("processorOptions", new Callable<Map<String, ?>>() {
@Override
public Map<String, ?> call() throws Exception {
return project.getTasks().findByName(mainSourceSet.getCompileJavaTaskName()).getConvention().getPlugin(AptPlugin.AptConvention.class).getAptOptions().getProcessorArgs();
}
});
eclipseModel.getJdt().getFile().withProperties(// withProperties(Action) overload was added in Gradle 2.14
new MethodClosure(new Action<Properties>() {
@Override
public void execute(Properties properties) {
properties.setProperty("org.eclipse.jdt.core.compiler.processAnnotations", jdtApt.isAptEnabled() ? "enabled" : "disabled");
}
}, "execute"));
}
});
project.getTasks().getByName("eclipse").dependsOn(task);
Delete cleanTask = project.getTasks().create("cleanEclipseJdtApt", Delete.class);
cleanTask.delete(getOutputs(task));
project.getTasks().getByName("cleanEclipse").dependsOn(cleanTask);
}
if (project.getTasks().findByName("eclipseFactorypath") == null) {
GenerateEclipseFactorypath task = project.getTasks().create("eclipseFactorypath", GenerateEclipseFactorypath.class, new Action<GenerateEclipseFactorypath>() {
@Override
public void execute(GenerateEclipseFactorypath generateEclipseFactorypath) {
generateEclipseFactorypath.setDescription("Generates the Eclipse factorypath file.");
generateEclipseFactorypath.setInputFile(project.file(".factorypath"));
generateEclipseFactorypath.setOutputFile(project.file(".factorypath"));
EclipseFactorypath factorypath = generateEclipseFactorypath.getFactorypath();
new DslObject(eclipseModel).getConvention().getPlugins().put("net.ltgt.apt-eclipse", new FactorypathConvention(factorypath));
factorypath.setPlusConfigurations(new ArrayList<>(Arrays.asList(project.getConfigurations().getByName(new DslObject(mainSourceSet).getConvention().getPlugin(AptPlugin.AptSourceSetConvention.class).getAnnotationProcessorConfigurationName()), project.getConfigurations().getByName(new DslObject(testSourceSet).getConvention().getPlugin(AptPlugin.AptSourceSetConvention.class).getAnnotationProcessorConfigurationName()))));
generateEclipseFactorypath.dependsOn(factorypath.getPlusConfigurations().toArray());
}
});
project.getTasks().getByName("eclipse").dependsOn(task);
Delete cleanTask = project.getTasks().create("cleanEclipseFactorypath", Delete.class);
cleanTask.delete(getOutputs(task));
project.getTasks().getByName("cleanEclipse").dependsOn(cleanTask);
}
}
use of org.gradle.api.tasks.Delete in project rest.li by linkedin.
the class PegasusPlugin method configureDataTemplateGeneration.
@SuppressWarnings("deprecation")
protected GenerateDataTemplateTask configureDataTemplateGeneration(Project project, SourceSet sourceSet) {
File dataSchemaDir = project.file(getDataSchemaPath(project, sourceSet));
File generatedDataTemplateDir = project.file(getGeneratedDirPath(project, sourceSet, DATA_TEMPLATE_GEN_TYPE) + File.separatorChar + "java");
File publishableSchemasBuildDir = project.file(project.getBuildDir().getAbsolutePath() + File.separatorChar + sourceSet.getName() + "Schemas");
File publishableLegacySchemasBuildDir = project.file(project.getBuildDir().getAbsolutePath() + File.separatorChar + sourceSet.getName() + "LegacySchemas");
File publishableExtensionSchemasBuildDir = project.file(project.getBuildDir().getAbsolutePath() + File.separatorChar + sourceSet.getName() + "ExtensionSchemas");
// generate data template source files from data schema
GenerateDataTemplateTask generateDataTemplatesTask = project.getTasks().create(sourceSet.getTaskName("generate", "dataTemplate"), GenerateDataTemplateTask.class, task -> {
task.setInputDir(dataSchemaDir);
task.setDestinationDir(generatedDataTemplateDir);
task.setResolverPath(getDataModelConfig(project, sourceSet));
task.setCodegenClasspath(project.getConfigurations().getByName(PEGASUS_PLUGIN_CONFIGURATION));
if (isPropertyTrue(project, ENABLE_ARG_FILE)) {
task.setEnableArgFile(true);
}
if (isPropertyTrue(project, CODE_GEN_PATH_CASE_SENSITIVE)) {
task.setGenerateLowercasePath(false);
}
task.onlyIf(t -> {
if (task.getInputDir().exists()) {
@SuppressWarnings("unchecked") Map<String, PegasusOptions> pegasusOptions = (Map<String, PegasusOptions>) project.getExtensions().getExtraProperties().get("pegasus");
return pegasusOptions.get(sourceSet.getName()).hasGenerationMode(PegasusOptions.GenerationMode.PEGASUS);
}
return false;
});
task.doFirst(new CacheableAction<>(t -> deleteGeneratedDir(project, sourceSet, DATA_TEMPLATE_GEN_TYPE)));
});
// TODO: Tighten the types so that _generateSourcesJarTask must be of type Jar.
((Jar) _generateSourcesJarTask).from(generateDataTemplatesTask.getDestinationDir());
_generateSourcesJarTask.dependsOn(generateDataTemplatesTask);
_generateJavadocTask.source(generateDataTemplatesTask.getDestinationDir());
_generateJavadocTask.setClasspath(_generateJavadocTask.getClasspath().plus(project.getConfigurations().getByName("dataTemplateCompile")).plus(generateDataTemplatesTask.getResolverPath()));
_generateJavadocTask.dependsOn(generateDataTemplatesTask);
// Add extra dependencies for data model compilation
project.getDependencies().add("dataTemplateCompile", "com.google.code.findbugs:jsr305:3.0.2");
// create new source set for generated java source and class files
String targetSourceSetName = getGeneratedSourceSetName(sourceSet, DATA_TEMPLATE_GEN_TYPE);
SourceSetContainer sourceSets = project.getConvention().getPlugin(JavaPluginConvention.class).getSourceSets();
SourceSet targetSourceSet = sourceSets.create(targetSourceSetName, ss -> {
ss.java(sourceDirectorySet -> sourceDirectorySet.srcDir(generatedDataTemplateDir));
ss.setCompileClasspath(getDataModelConfig(project, sourceSet).plus(project.getConfigurations().getByName("dataTemplateCompile")));
});
// idea plugin needs to know about new generated java source directory and its dependencies
addGeneratedDir(project, targetSourceSet, Arrays.asList(getDataModelConfig(project, sourceSet), project.getConfigurations().getByName("dataTemplateCompile")));
// Set source compatibility to 1.8 as the data-templates now generate code with Java 8 features.
JavaCompile compileTask = project.getTasks().withType(JavaCompile.class).getByName(targetSourceSet.getCompileJavaTaskName());
compileTask.doFirst(new CacheableAction<>(task -> {
((JavaCompile) task).setSourceCompatibility("1.8");
((JavaCompile) task).setTargetCompatibility("1.8");
}));
// make sure that java source files have been generated before compiling them
compileTask.dependsOn(generateDataTemplatesTask);
// Dummy task to maintain backward compatibility
// TODO: Delete this task once use cases have had time to reference the new task
Task destroyStaleFiles = project.getTasks().create(sourceSet.getName() + "DestroyStaleFiles", Delete.class);
destroyStaleFiles.onlyIf(task -> {
project.getLogger().lifecycle("{} task is a NO-OP task.", task.getPath());
return false;
});
// Dummy task to maintain backward compatibility, as this task was replaced by CopySchemas
// TODO: Delete this task once use cases have had time to reference the new task
Task copyPdscSchemasTask = project.getTasks().create(sourceSet.getName() + "CopyPdscSchemas", Copy.class);
copyPdscSchemasTask.dependsOn(destroyStaleFiles);
copyPdscSchemasTask.onlyIf(task -> {
project.getLogger().lifecycle("{} task is a NO-OP task.", task.getPath());
return false;
});
// Prepare schema files for publication by syncing schema folders.
Task prepareSchemasForPublishTask = project.getTasks().create(sourceSet.getName() + "CopySchemas", Sync.class, task -> {
task.from(dataSchemaDir, syncSpec -> DATA_TEMPLATE_FILE_SUFFIXES.forEach(suffix -> syncSpec.include("**/*" + suffix)));
task.into(publishableSchemasBuildDir);
});
prepareSchemasForPublishTask.dependsOn(copyPdscSchemasTask);
Collection<Task> dataTemplateJarDepends = new ArrayList<>();
dataTemplateJarDepends.add(compileTask);
dataTemplateJarDepends.add(prepareSchemasForPublishTask);
// Convert all PDL files back to PDSC for publication
// TODO: Remove this conversion permanently once translated PDSCs are no longer needed.
Task prepareLegacySchemasForPublishTask = project.getTasks().create(sourceSet.getName() + "TranslateSchemas", TranslateSchemasTask.class, task -> {
task.setInputDir(dataSchemaDir);
task.setDestinationDir(publishableLegacySchemasBuildDir);
task.setResolverPath(getDataModelConfig(project, sourceSet));
task.setCodegenClasspath(project.getConfigurations().getByName(PEGASUS_PLUGIN_CONFIGURATION));
task.setSourceFormat(SchemaFileType.PDL);
task.setDestinationFormat(SchemaFileType.PDSC);
task.setKeepOriginal(true);
task.setSkipVerification(true);
if (isPropertyTrue(project, ENABLE_ARG_FILE)) {
task.setEnableArgFile(true);
}
});
prepareLegacySchemasForPublishTask.dependsOn(destroyStaleFiles);
dataTemplateJarDepends.add(prepareLegacySchemasForPublishTask);
// extension schema directory
File extensionSchemaDir = project.file(getExtensionSchemaPath(project, sourceSet));
if (!SharedFileUtils.getSuffixedFiles(project, extensionSchemaDir, PDL_FILE_SUFFIX).isEmpty()) {
// Validate extension schemas if extension schemas are provided.
ValidateExtensionSchemaTask validateExtensionSchemaTask = project.getTasks().create(sourceSet.getTaskName("validate", "ExtensionSchemas"), ValidateExtensionSchemaTask.class, task -> {
task.setInputDir(extensionSchemaDir);
task.setResolverPath(getDataModelConfig(project, sourceSet).plus(project.files(getDataSchemaPath(project, sourceSet))));
task.setClassPath(project.getConfigurations().getByName(PEGASUS_PLUGIN_CONFIGURATION));
if (isPropertyTrue(project, ENABLE_ARG_FILE)) {
task.setEnableArgFile(true);
}
});
Task prepareExtensionSchemasForPublishTask = project.getTasks().create(sourceSet.getName() + "CopyExtensionSchemas", Sync.class, task -> {
task.from(extensionSchemaDir, syncSpec -> syncSpec.include("**/*" + PDL_FILE_SUFFIX));
task.into(publishableExtensionSchemasBuildDir);
});
prepareExtensionSchemasForPublishTask.dependsOn(validateExtensionSchemaTask);
prepareExtensionSchemasForPublishTask.dependsOn(copyPdscSchemasTask);
dataTemplateJarDepends.add(prepareExtensionSchemasForPublishTask);
}
// include pegasus files in the output of this SourceSet
project.getTasks().withType(ProcessResources.class).getByName(targetSourceSet.getProcessResourcesTaskName(), it -> {
it.from(prepareSchemasForPublishTask, copy -> copy.into("pegasus"));
// TODO: Remove this permanently once translated PDSCs are no longer needed.
it.from(prepareLegacySchemasForPublishTask, copy -> copy.into(TRANSLATED_SCHEMAS_DIR));
Sync copyExtensionSchemasTask = project.getTasks().withType(Sync.class).findByName(sourceSet.getName() + "CopyExtensionSchemas");
if (copyExtensionSchemasTask != null) {
it.from(copyExtensionSchemasTask, copy -> copy.into("extensions"));
}
});
// create data template jar file
Jar dataTemplateJarTask = project.getTasks().create(sourceSet.getName() + "DataTemplateJar", Jar.class, task -> {
task.dependsOn(dataTemplateJarDepends);
task.from(targetSourceSet.getOutput());
// FIXME change to #getArchiveAppendix().set(...); breaks backwards-compatibility before 5.1
task.setAppendix(getAppendix(sourceSet, "data-template"));
task.setDescription("Generate a data template jar");
});
// add the data model and date template jars to the list of project artifacts.
if (!isTestSourceSet(sourceSet)) {
project.getArtifacts().add("dataTemplate", dataTemplateJarTask);
} else {
project.getArtifacts().add("testDataTemplate", dataTemplateJarTask);
}
// include additional dependencies into the appropriate configuration used to compile the input source set
// must include the generated data template classes and their dependencies the configuration
String compileConfigName = isTestSourceSet(sourceSet) ? "testCompile" : "compile";
Configuration compileConfig = project.getConfigurations().maybeCreate(compileConfigName);
compileConfig.extendsFrom(getDataModelConfig(project, sourceSet), project.getConfigurations().getByName("dataTemplateCompile"));
// FIXME change to #getArchiveFile(); breaks backwards-compatibility before 5.1
project.getDependencies().add(compileConfigName, project.files(dataTemplateJarTask.getArchivePath()));
// The below Action is only applied when the 'ivy-publish' is applied by the consumer.
// If the consumer does not use ivy-publish, this is a noop.
// this Action prepares the project applying the pegasus plugin to publish artifacts using these steps:
// 1. Registers "feature variants" for pegasus-specific artifacts;
// see https://docs.gradle.org/6.1/userguide/feature_variants.html
// 2. Wires legacy configurations like `dataTemplateCompile` to auto-generated feature variant *Api and
// *Implementation configurations for backwards compatibility.
// 3. Configures the Ivy Publication to include auto-generated feature variant *Api and *Implementation
// configurations and their dependencies.
project.getPlugins().withType(IvyPublishPlugin.class, ivyPublish -> {
if (!isAtLeastGradle61()) {
throw new GradleException("Using the ivy-publish plugin with the pegasus plugin requires Gradle 6.1 or higher " + "at build time. Please upgrade.");
}
JavaPluginExtension java = project.getExtensions().getByType(JavaPluginExtension.class);
// create new capabilities per source set; automatically creates api and implementation configurations
String featureName = mapSourceSetToFeatureName(targetSourceSet);
try {
/*
reflection is required to preserve compatibility with Gradle 5.2.1 and below
TODO once Gradle 5.3+ is required, remove reflection and replace with:
java.registerFeature(featureName, featureSpec -> {
featureSpec.usingSourceSet(targetSourceSet);
});
*/
Method registerFeature = JavaPluginExtension.class.getDeclaredMethod("registerFeature", String.class, Action.class);
Action<?> /*<org.gradle.api.plugins.FeatureSpec>*/
featureSpecAction = createFeatureVariantFromSourceSet(targetSourceSet);
registerFeature.invoke(java, featureName, featureSpecAction);
} catch (ReflectiveOperationException e) {
throw new GradleException("Unable to register new feature variant", e);
}
// expose transitive dependencies to consumers via variant configurations
Configuration featureConfiguration = project.getConfigurations().getByName(featureName);
Configuration mainGeneratedDataTemplateApi = project.getConfigurations().getByName(targetSourceSet.getApiConfigurationName());
featureConfiguration.extendsFrom(mainGeneratedDataTemplateApi);
mainGeneratedDataTemplateApi.extendsFrom(getDataModelConfig(project, targetSourceSet), project.getConfigurations().getByName("dataTemplateCompile"));
// Configure the existing IvyPublication
// For backwards-compatibility, make the legacy dataTemplate/testDataTemplate configurations extend
// their replacements, auto-created when we registered the new feature variant
project.afterEvaluate(p -> {
PublishingExtension publishing = p.getExtensions().getByType(PublishingExtension.class);
// When configuring a Gradle Publication, use this value to find the name of the publication to configure. Defaults to "ivy".
String publicationName = p.getExtensions().getExtraProperties().getProperties().getOrDefault("PegasusPublicationName", "ivy").toString();
IvyPublication ivyPublication = publishing.getPublications().withType(IvyPublication.class).getByName(publicationName);
ivyPublication.configurations(configurations -> configurations.create(featureName, legacyConfiguration -> {
legacyConfiguration.extend(p.getConfigurations().getByName(targetSourceSet.getApiElementsConfigurationName()).getName());
legacyConfiguration.extend(p.getConfigurations().getByName(targetSourceSet.getRuntimeElementsConfigurationName()).getName());
}));
});
});
if (debug) {
System.out.println("configureDataTemplateGeneration sourceSet " + sourceSet.getName());
System.out.println(compileConfigName + ".allDependencies : " + project.getConfigurations().getByName(compileConfigName).getAllDependencies());
System.out.println(compileConfigName + ".extendsFrom: " + project.getConfigurations().getByName(compileConfigName).getExtendsFrom());
System.out.println(compileConfigName + ".transitive: " + project.getConfigurations().getByName(compileConfigName).isTransitive());
}
project.getTasks().getByName(sourceSet.getCompileJavaTaskName()).dependsOn(dataTemplateJarTask);
return generateDataTemplatesTask;
}
Aggregations