use of org.gradle.internal.deprecation.DeprecatableConfiguration in project gradle by gradle.
the class ScalaBasePlugin method configureConfigurations.
private void configureConfigurations(final Project project, final Usage incrementalAnalysisUsage, ScalaPluginExtension scalaPluginExtension) {
DependencyHandler dependencyHandler = project.getDependencies();
ConfigurationInternal plugins = (ConfigurationInternal) project.getConfigurations().create(SCALA_COMPILER_PLUGINS_CONFIGURATION_NAME);
plugins.setTransitive(false);
plugins.setCanBeConsumed(false);
jvmEcosystemUtilities.configureAsRuntimeClasspath(plugins);
Configuration zinc = project.getConfigurations().create(ZINC_CONFIGURATION_NAME);
zinc.setVisible(false);
zinc.setDescription("The Zinc incremental compiler to be used for this Scala project.");
((DeprecatableConfiguration) zinc).deprecateForConsumption(deprecation -> deprecation.willBecomeAnErrorInGradle8().withUpgradeGuideSection(7, "plugin_configuration_consumption"));
zinc.getResolutionStrategy().eachDependency(rule -> {
if (rule.getRequested().getGroup().equals("com.typesafe.zinc") && rule.getRequested().getName().equals("zinc")) {
rule.useTarget("org.scala-sbt:zinc_" + DEFAULT_SCALA_ZINC_VERSION + ":" + DEFAULT_ZINC_VERSION);
rule.because("Typesafe Zinc is no longer maintained.");
}
});
zinc.defaultDependencies(dependencies -> {
dependencies.add(dependencyHandler.create("org.scala-sbt:zinc_" + DEFAULT_SCALA_ZINC_VERSION + ":" + scalaPluginExtension.getZincVersion().get()));
// Add safeguard and clear error if the user changed the scala version when using default zinc
zinc.getIncoming().afterResolve(resolvableDependencies -> {
resolvableDependencies.getResolutionResult().allComponents(component -> {
if (component.getModuleVersion() != null && component.getModuleVersion().getName().equals("scala-library")) {
if (!component.getModuleVersion().getVersion().startsWith(DEFAULT_SCALA_ZINC_VERSION)) {
throw new InvalidUserCodeException("The version of 'scala-library' was changed while using the default Zinc version. " + "Version " + component.getModuleVersion().getVersion() + " is not compatible with org.scala-sbt:zinc_" + DEFAULT_SCALA_ZINC_VERSION + ":" + DEFAULT_ZINC_VERSION);
}
}
});
});
});
zinc.getDependencyConstraints().add(dependencyHandler.getConstraints().create(Log4jBannedVersion.LOG4J2_CORE_COORDINATES, constraint -> constraint.version(version -> {
version.require(Log4jBannedVersion.LOG4J2_CORE_REQUIRED_VERSION);
version.reject(Log4jBannedVersion.LOG4J2_CORE_VULNERABLE_VERSION_RANGE);
})));
final Configuration incrementalAnalysisElements = project.getConfigurations().create("incrementalScalaAnalysisElements");
incrementalAnalysisElements.setVisible(false);
incrementalAnalysisElements.setDescription("Incremental compilation analysis files");
incrementalAnalysisElements.setCanBeResolved(false);
incrementalAnalysisElements.setCanBeConsumed(true);
incrementalAnalysisElements.getAttributes().attribute(USAGE_ATTRIBUTE, incrementalAnalysisUsage);
AttributeMatchingStrategy<Usage> matchingStrategy = dependencyHandler.getAttributesSchema().attribute(USAGE_ATTRIBUTE);
matchingStrategy.getDisambiguationRules().add(UsageDisambiguationRules.class, actionConfiguration -> {
actionConfiguration.params(incrementalAnalysisUsage);
actionConfiguration.params(objectFactory.named(Usage.class, Usage.JAVA_API));
actionConfiguration.params(objectFactory.named(Usage.class, Usage.JAVA_RUNTIME));
});
}
use of org.gradle.internal.deprecation.DeprecatableConfiguration in project gradle by gradle.
the class AntlrPlugin method apply.
@SuppressWarnings("deprecation")
@Override
public void apply(final Project project) {
project.getPluginManager().apply(JavaLibraryPlugin.class);
// set up a configuration named 'antlr' for the user to specify the antlr libs to use in case
// they want a specific version etc.
final Configuration antlrConfiguration = project.getConfigurations().create(ANTLR_CONFIGURATION_NAME).setVisible(false).setDescription("The Antlr libraries to be used for this project.");
((DeprecatableConfiguration) antlrConfiguration).deprecateForConsumption(deprecation -> deprecation.willBecomeAnErrorInGradle8().withUpgradeGuideSection(7, "plugin_configuration_consumption"));
antlrConfiguration.defaultDependencies(dependencies -> dependencies.add(project.getDependencies().create("antlr:antlr:2.7.7@jar")));
Configuration apiConfiguration = project.getConfigurations().getByName(JavaPlugin.API_CONFIGURATION_NAME);
apiConfiguration.extendsFrom(antlrConfiguration);
// Wire the antlr configuration into all antlr tasks
project.getTasks().withType(AntlrTask.class).configureEach(antlrTask -> antlrTask.getConventionMapping().map("antlrClasspath", () -> project.getConfigurations().getByName(ANTLR_CONFIGURATION_NAME)));
project.getExtensions().getByType(JavaPluginExtension.class).getSourceSets().all(new Action<SourceSet>() {
@Override
public void execute(final SourceSet sourceSet) {
// for each source set we will:
// 1) Add a new 'antlr' virtual directory mapping
org.gradle.api.plugins.antlr.internal.AntlrSourceVirtualDirectoryImpl antlrDirectoryDelegate = new org.gradle.api.plugins.antlr.internal.AntlrSourceVirtualDirectoryImpl(((DefaultSourceSet) sourceSet).getDisplayName(), objectFactory);
new DslObject(sourceSet).getConvention().getPlugins().put(AntlrSourceVirtualDirectory.NAME, antlrDirectoryDelegate);
sourceSet.getExtensions().add(AntlrSourceDirectorySet.class, AntlrSourceVirtualDirectory.NAME, antlrDirectoryDelegate.getAntlr());
final String srcDir = "src/" + sourceSet.getName() + "/antlr";
antlrDirectoryDelegate.getAntlr().srcDir(srcDir);
sourceSet.getAllSource().source(antlrDirectoryDelegate.getAntlr());
// 2) create an AntlrTask for this sourceSet following the gradle
// naming conventions via call to sourceSet.getTaskName()
final String taskName = sourceSet.getTaskName("generate", "GrammarSource");
// 3) Set up the Antlr output directory (adding to javac inputs!)
final String outputDirectoryName = project.getBuildDir() + "/generated-src/antlr/" + sourceSet.getName();
final File outputDirectory = new File(outputDirectoryName);
sourceSet.getJava().srcDir(outputDirectory);
project.getTasks().register(taskName, AntlrTask.class, new Action<AntlrTask>() {
@Override
public void execute(AntlrTask antlrTask) {
antlrTask.setDescription("Processes the " + sourceSet.getName() + " Antlr grammars.");
// 4) set up convention mapping for default sources (allows user to not have to specify)
antlrTask.setSource(antlrDirectoryDelegate.getAntlr());
antlrTask.setOutputDirectory(outputDirectory);
}
});
// 5) register fact that antlr should be run before compiling
project.getTasks().named(sourceSet.getCompileJavaTaskName(), new Action<Task>() {
@Override
public void execute(Task task) {
task.dependsOn(taskName);
}
});
}
});
}
use of org.gradle.internal.deprecation.DeprecatableConfiguration in project gradle by gradle.
the class DefaultProjectDependency method findProjectConfiguration.
@Override
public Configuration findProjectConfiguration() {
ConfigurationContainer dependencyConfigurations = getDependencyProject().getConfigurations();
String declaredConfiguration = getTargetConfiguration();
Configuration selectedConfiguration = dependencyConfigurations.getByName(GUtil.elvis(declaredConfiguration, Dependency.DEFAULT_CONFIGURATION));
if (!selectedConfiguration.isCanBeConsumed()) {
throw new ConfigurationNotConsumableException(dependencyProject.getDisplayName(), selectedConfiguration.getName());
}
warnIfConfigurationIsDeprecated((DeprecatableConfiguration) selectedConfiguration);
return selectedConfiguration;
}
use of org.gradle.internal.deprecation.DeprecatableConfiguration in project curiostack by curioswitch.
the class CuriostackRootPlugin method setupJavaProject.
private static void setupJavaProject(Project project, Map<String, CheckSeverity> errorProneChecks) {
setupRepositories(project);
PluginContainer plugins = project.getPlugins();
plugins.apply(ErrorPronePlugin.class);
plugins.apply(IdeaPlugin.class);
plugins.apply(NullAwayPlugin.class);
plugins.apply(VersionsPlugin.class);
var java = project.getExtensions().getByType(JavaPluginExtension.class);
java.withJavadocJar();
java.withSourcesJar();
// Manage all dependencies by adding the bom as a platform.
Object bomDependency = isCuriostack(project) ? project.getDependencies().project(ImmutableMap.of("path", ":tools:curiostack-bom")) : "org.curioswitch.curiostack:curiostack-bom:" + ToolDependencies.getBomVersion(project);
var platformDependency = project.getDependencies().platform(bomDependency);
// Needs to be in afterEvaluate since there is no way to guarantee isCanBeResolved, etc
// are set otherwise.
project.getConfigurations().configureEach(configuration -> {
if (configuration instanceof DeprecatableConfiguration) {
if (((DeprecatableConfiguration) configuration).getDeclarationAlternatives() != null) {
return;
}
}
if (!configuration.getName().endsWith("Classpath") && !UNMANAGED_CONFIGURATIONS.contains(configuration.getName())) {
project.getDependencies().add(configuration.getName(), platformDependency);
}
});
project.afterEvaluate(unused -> {
plugins.withType(MavenPublishPlugin.class, unused2 -> {
var publishing = project.getExtensions().getByType(PublishingExtension.class);
publishing.getPublications().configureEach(publication -> {
if (!(publication instanceof MavenPublication)) {
return;
}
var mavenPublication = (MavenPublication) publication;
mavenPublication.versionMapping(mapping -> mapping.allVariants(VariantVersionMappingStrategy::fromResolutionResult));
mavenPublication.getPom().withXml(xml -> {
var root = xml.asNode();
findChild(root, "dependencyManagement").ifPresent(root::remove);
});
});
});
});
project.getTasks().withType(JavaCompile.class).configureEach(task -> {
task.getOptions().setIncremental(true);
ErrorProneOptions errorProne = ((ExtensionAware) task.getOptions()).getExtensions().findByType(ErrorProneOptions.class);
if (errorProne != null) {
errorProne.getDisableWarningsInGeneratedCode().set(true);
errorProne.getIgnoreUnknownCheckNames().set(true);
errorProne.getExcludedPaths().set("(.*/build/.*|.*/gen-src/.*)");
errorProne.getChecks().set(errorProneChecks);
var nullaway = ((ExtensionAware) errorProne).getExtensions().getByType(NullAwayOptions.class);
nullaway.getSeverity().set(WARN);
nullaway.getExcludedFieldAnnotations().addAll(MonotonicNonNull.class.getCanonicalName(), "org.mockito.Mock");
}
});
JavaPluginConvention javaPlugin = project.getConvention().getPlugin(JavaPluginConvention.class);
javaPlugin.setSourceCompatibility(JavaVersion.VERSION_16);
javaPlugin.setTargetCompatibility(JavaVersion.VERSION_16);
// Even for libraries that set source version to 8/11 for compatibility with older runtimes,
// we always use 15 for tests.
var testSourceSet = javaPlugin.getSourceSets().getByName(SourceSet.TEST_SOURCE_SET_NAME);
project.getConfigurations().getByName(testSourceSet.getCompileClasspathConfigurationName()).getAttributes().attribute(TargetJvmVersion.TARGET_JVM_VERSION_ATTRIBUTE, 16);
project.getConfigurations().getByName(testSourceSet.getRuntimeClasspathConfigurationName()).getAttributes().attribute(TargetJvmVersion.TARGET_JVM_VERSION_ATTRIBUTE, 16);
project.getTasks().withType(Test.class).named("test").configure(test -> {
if (project.getRootProject().hasProperty("updateSnapshots")) {
test.jvmArgs(ImmutableList.of("-Dorg.curioswitch.testing.updateSnapshots=true"));
}
test.useJUnitPlatform(platform -> platform.includeEngines("junit-jupiter", "junit-vintage"));
test.testLogging(logging -> {
logging.setShowStandardStreams(true);
logging.setExceptionFormat(TestExceptionFormat.FULL);
});
});
// 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().named("cleanIdea").configure(t -> t.doLast(unused -> project.file(project.getName() + ".iml").delete()));
});
// Pretty much all java code needs at least the Generated annotation.
project.getDependencies().add(JavaPlugin.IMPLEMENTATION_CONFIGURATION_NAME, "jakarta.annotation:jakarta.annotation-api");
project.getDependencies().add(JavaPlugin.COMPILE_ONLY_CONFIGURATION_NAME, "org.checkerframework:checker-qual");
project.getDependencies().add(ErrorPronePlugin.CONFIGURATION_NAME, "com.google.errorprone:error_prone_core");
project.getDependencies().add(ErrorPronePlugin.CONFIGURATION_NAME, "com.uber.nullaway:nullaway");
project.getDependencies().add(ErrorPronePlugin.CONFIGURATION_NAME, "com.google.auto.value:auto-value-annotations");
project.afterEvaluate(CuriostackRootPlugin::addStandardJavaTestDependencies);
project.getConfigurations().all(configuration -> {
configuration.resolutionStrategy(ResolutionStrategy::preferProjectModules);
configuration.exclude(ImmutableMap.of("group", "com.google.guava", "module", "guava-jdk5"));
});
var javadoc = project.getTasks().withType(Javadoc.class).named("javadoc");
javadoc.configure(t -> {
CoreJavadocOptions options = (CoreJavadocOptions) t.getOptions();
options.quiet();
options.addBooleanOption("Xdoclint:all,-missing", true);
});
project.getTasks().register("resolveDependencies", resolveDependencies -> resolveDependencies.doLast(unused -> {
project.getConfigurations().all(configuration -> {
if (configuration.isCanBeResolved()) {
configuration.resolve();
}
});
}));
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);
}
});
project.getPlugins().withType(JooqPlugin.class, unused -> project.getTasks().withType(JooqTask.class).configureEach(t -> {
for (String dependency : ImmutableList.of("javax.activation:activation", "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).configureEach(task -> System.getProperties().entrySet().stream().filter(entry -> !((String) entry.getKey()).startsWith("java.")).forEach(entry -> task.systemProperty((String) entry.getKey(), entry.getValue())));
}
Aggregations