Search in sources :

Example 6 with DeprecatableConfiguration

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));
    });
}
Also used : ProjectComponentIdentifier(org.gradle.api.artifacts.component.ProjectComponentIdentifier) BiFunction(java.util.function.BiFunction) InvalidUserCodeException(org.gradle.api.InvalidUserCodeException) Task(org.gradle.api.Task) Provider(org.gradle.api.provider.Provider) JavaBasePlugin(org.gradle.api.plugins.JavaBasePlugin) MultipleCandidatesDetails(org.gradle.api.attributes.MultipleCandidatesDetails) TaskProvider(org.gradle.api.tasks.TaskProvider) Log4jBannedVersion(org.gradle.internal.logging.util.Log4jBannedVersion) ConfigurationInternal(org.gradle.api.internal.artifacts.configurations.ConfigurationInternal) ExtensionAware(org.gradle.api.plugins.ExtensionAware) Transformer(org.gradle.api.Transformer) ScalaRuntime(org.gradle.api.tasks.ScalaRuntime) CompileOptions(org.gradle.api.tasks.compile.CompileOptions) DefaultScalaPluginExtension(org.gradle.api.internal.tasks.scala.DefaultScalaPluginExtension) ImmutableSet(com.google.common.collect.ImmutableSet) Project(org.gradle.api.Project) SourceDirectorySet(org.gradle.api.file.SourceDirectorySet) ArtifactView(org.gradle.api.artifacts.ArtifactView) JvmEcosystemUtilities(org.gradle.api.plugins.jvm.internal.JvmEcosystemUtilities) AttributeDisambiguationRule(org.gradle.api.attributes.AttributeDisambiguationRule) Spec(org.gradle.api.specs.Spec) AttributeMatchingStrategy(org.gradle.api.attributes.AttributeMatchingStrategy) SerializableLambdas.spec(org.gradle.api.internal.lambdas.SerializableLambdas.spec) JavaPluginExtension(org.gradle.api.plugins.JavaPluginExtension) DeprecatableConfiguration(org.gradle.internal.deprecation.DeprecatableConfiguration) JavaToolchainService(org.gradle.jvm.toolchain.JavaToolchainService) Callable(java.util.concurrent.Callable) FileCollection(org.gradle.api.file.FileCollection) ComponentIdentifier(org.gradle.api.artifacts.component.ComponentIdentifier) SourceSet(org.gradle.api.tasks.SourceSet) Inject(javax.inject.Inject) Configuration(org.gradle.api.artifacts.Configuration) ScalaDoc(org.gradle.api.tasks.scala.ScalaDoc) DependencyHandler(org.gradle.api.artifacts.dsl.DependencyHandler) ScalaSourceDirectorySet(org.gradle.api.tasks.ScalaSourceDirectorySet) ScalaCompile(org.gradle.api.tasks.scala.ScalaCompile) Usage(org.gradle.api.attributes.Usage) InvokerHelper(org.codehaus.groovy.runtime.InvokerHelper) Action(org.gradle.api.Action) ReportingExtension(org.gradle.api.reporting.ReportingExtension) Jar(org.gradle.jvm.tasks.Jar) JvmPluginsHelper(org.gradle.api.plugins.internal.JvmPluginsHelper) JavaToolchainSpec(org.gradle.jvm.toolchain.JavaToolchainSpec) File(java.io.File) USAGE_ATTRIBUTE(org.gradle.api.attributes.Usage.USAGE_ATTRIBUTE) ObjectFactory(org.gradle.api.model.ObjectFactory) Convention(org.gradle.api.plugins.Convention) VisibleForTesting(com.google.common.annotations.VisibleForTesting) Plugin(org.gradle.api.Plugin) IncrementalCompileOptions(org.gradle.api.tasks.scala.IncrementalCompileOptions) DependencyHandler(org.gradle.api.artifacts.dsl.DependencyHandler) Usage(org.gradle.api.attributes.Usage) DeprecatableConfiguration(org.gradle.internal.deprecation.DeprecatableConfiguration) Configuration(org.gradle.api.artifacts.Configuration) InvalidUserCodeException(org.gradle.api.InvalidUserCodeException) DeprecatableConfiguration(org.gradle.internal.deprecation.DeprecatableConfiguration) ConfigurationInternal(org.gradle.api.internal.artifacts.configurations.ConfigurationInternal)

Example 7 with DeprecatableConfiguration

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);
                }
            });
        }
    });
}
Also used : Action(org.gradle.api.Action) Task(org.gradle.api.Task) Configuration(org.gradle.api.artifacts.Configuration) DeprecatableConfiguration(org.gradle.internal.deprecation.DeprecatableConfiguration) DslObject(org.gradle.api.internal.plugins.DslObject) DeprecatableConfiguration(org.gradle.internal.deprecation.DeprecatableConfiguration) DefaultSourceSet(org.gradle.api.internal.tasks.DefaultSourceSet) SourceSet(org.gradle.api.tasks.SourceSet) DefaultSourceSet(org.gradle.api.internal.tasks.DefaultSourceSet) File(java.io.File)

Example 8 with DeprecatableConfiguration

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;
}
Also used : ConfigurationNotConsumableException(org.gradle.internal.exceptions.ConfigurationNotConsumableException) Configuration(org.gradle.api.artifacts.Configuration) DeprecatableConfiguration(org.gradle.internal.deprecation.DeprecatableConfiguration) ConfigurationContainer(org.gradle.api.artifacts.ConfigurationContainer)

Example 9 with DeprecatableConfiguration

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())));
}
Also used : ErrorProneOptions(net.ltgt.gradle.errorprone.ErrorProneOptions) AwsSetupPlugin(org.curioswitch.gradle.plugins.aws.AwsSetupPlugin) MavenPublishPlugin(org.gradle.api.publish.maven.plugins.MavenPublishPlugin) CondaPlugin(org.curioswitch.gradle.conda.CondaPlugin) JavaPlugin(org.gradle.api.plugins.JavaPlugin) IdeaPlugin(org.gradle.plugins.ide.idea.IdeaPlugin) MonotonicNonNull(org.checkerframework.checker.nullness.qual.MonotonicNonNull) NodePlugin(org.curioswitch.gradle.plugins.nodejs.NodePlugin) Wrapper(org.gradle.api.tasks.wrapper.Wrapper) PublishingExtension(org.gradle.api.publish.PublishingExtension) Javadoc(org.gradle.api.tasks.javadoc.Javadoc) JibTask(org.curioswitch.gradle.golang.tasks.JibTask) GolangPlugin(org.curioswitch.gradle.golang.GolangPlugin) Locale(java.util.Locale) Map(java.util.Map) ExtensionAware(org.gradle.api.plugins.ExtensionAware) TestExceptionFormat(org.gradle.api.tasks.testing.logging.TestExceptionFormat) IdeaModule(org.gradle.plugins.ide.idea.model.IdeaModule) ImmutableSet(com.google.common.collect.ImmutableSet) ImmutableMap(com.google.common.collect.ImmutableMap) ReleasePlugin(org.curioswitch.gradle.release.ReleasePlugin) Project(org.gradle.api.Project) VariantVersionMappingStrategy(org.gradle.api.publish.VariantVersionMappingStrategy) Predicate(java.util.function.Predicate) CheckSeverity(net.ltgt.gradle.errorprone.CheckSeverity) ImmutableList.toImmutableList(com.google.common.collect.ImmutableList.toImmutableList) SetupGitHooks(org.curioswitch.gradle.plugins.curiostack.tasks.SetupGitHooks) DistributionType(org.gradle.api.tasks.wrapper.Wrapper.DistributionType) Set(java.util.Set) UpdateProjectSettingsTask(org.curioswitch.gradle.plugins.curiostack.tasks.UpdateProjectSettingsTask) SpotlessExtension(com.diffplug.gradle.spotless.SpotlessExtension) XmlParser(groovy.util.XmlParser) Collectors(java.util.stream.Collectors) JavaVersion(org.gradle.api.JavaVersion) StandardCharsets(java.nio.charset.StandardCharsets) NullAwayPlugin(net.ltgt.gradle.nullaway.NullAwayPlugin) UncheckedIOException(java.io.UncheckedIOException) CondaBuildEnvPlugin(org.curioswitch.gradle.conda.CondaBuildEnvPlugin) List(java.util.List) ToolDownloaderPlugin(org.curioswitch.gradle.tooldownloader.ToolDownloaderPlugin) CoreJavadocOptions(org.gradle.external.javadoc.CoreJavadocOptions) VersionsPlugin(com.github.benmanes.gradle.versions.VersionsPlugin) JavaPluginExtension(org.gradle.api.plugins.JavaPluginExtension) SAXException(org.xml.sax.SAXException) DependencyUpdatesTask(com.github.benmanes.gradle.versions.updates.DependencyUpdatesTask) Optional(java.util.Optional) PluginContainer(org.gradle.api.plugins.PluginContainer) XmlProvider(org.gradle.api.XmlProvider) Pattern(java.util.regex.Pattern) JooqPlugin(nu.studer.gradle.jooq.JooqPlugin) QName(groovy.xml.QName) GenerateApiServerTask(org.curioswitch.gradle.plugins.curiostack.tasks.GenerateApiServerTask) DeprecatableConfiguration(org.gradle.internal.deprecation.DeprecatableConfiguration) ERROR(net.ltgt.gradle.errorprone.CheckSeverity.ERROR) CurioGenericCiPlugin(org.curioswitch.gradle.plugins.ci.CurioGenericCiPlugin) ErrorPronePlugin(net.ltgt.gradle.errorprone.ErrorPronePlugin) CondaExtension(org.curioswitch.gradle.conda.CondaExtension) HashMap(java.util.HashMap) GolangExtension(org.curioswitch.gradle.golang.GolangExtension) BasePlugin(org.gradle.api.plugins.BasePlugin) MavenPublication(org.gradle.api.publish.maven.MavenPublication) DownloadToolUtil(org.curioswitch.gradle.tooldownloader.util.DownloadToolUtil) SourceSet(org.gradle.api.tasks.SourceSet) Configuration(org.gradle.api.artifacts.Configuration) TargetJvmVersion(org.gradle.api.attributes.java.TargetJvmVersion) JMHPluginExtension(me.champeau.gradle.JMHPluginExtension) ImmutableList(com.google.common.collect.ImmutableList) DependencyHandler(org.gradle.api.artifacts.dsl.DependencyHandler) JooqTask(nu.studer.gradle.jooq.JooqTask) DownloadedToolManager(org.curioswitch.gradle.tooldownloader.DownloadedToolManager) UpdateGradleWrapperTask(org.curioswitch.gradle.plugins.curiostack.tasks.UpdateGradleWrapperTask) CreateShellConfigTask(org.curioswitch.gradle.plugins.curiostack.tasks.CreateShellConfigTask) NodeUtil(org.curioswitch.gradle.plugins.nodejs.util.NodeUtil) Test(org.gradle.api.tasks.testing.Test) OFF(net.ltgt.gradle.errorprone.CheckSeverity.OFF) JavaCompile(org.gradle.api.tasks.compile.JavaCompile) Resources(com.google.common.io.Resources) Files(java.nio.file.Files) JavaPluginConvention(org.gradle.api.plugins.JavaPluginConvention) JacocoPlugin(org.gradle.testing.jacoco.plugins.JacocoPlugin) JMHPlugin(me.champeau.gradle.JMHPlugin) UpdateIntelliJSdksTask(org.curioswitch.gradle.plugins.curiostack.tasks.UpdateIntelliJSdksTask) IOException(java.io.IOException) Node(groovy.util.Node) GcloudPlugin(org.curioswitch.gradle.plugins.gcloud.GcloudPlugin) GolangSetupPlugin(org.curioswitch.gradle.golang.GolangSetupPlugin) SpotlessPlugin(com.diffplug.gradle.spotless.SpotlessPlugin) ResolutionStrategy(org.gradle.api.artifacts.ResolutionStrategy) TerraformSetupPlugin(org.curioswitch.gradle.plugins.terraform.TerraformSetupPlugin) ParserConfigurationException(javax.xml.parsers.ParserConfigurationException) NullAwayOptions(net.ltgt.gradle.nullaway.NullAwayOptions) JavaExec(org.gradle.api.tasks.JavaExec) WARN(net.ltgt.gradle.errorprone.CheckSeverity.WARN) Plugin(org.gradle.api.Plugin) Copy(org.gradle.api.tasks.Copy) PluginContainer(org.gradle.api.plugins.PluginContainer) ErrorProneOptions(net.ltgt.gradle.errorprone.ErrorProneOptions) MavenPublication(org.gradle.api.publish.maven.MavenPublication) Javadoc(org.gradle.api.tasks.javadoc.Javadoc) DeprecatableConfiguration(org.gradle.internal.deprecation.DeprecatableConfiguration) ResolutionStrategy(org.gradle.api.artifacts.ResolutionStrategy) Project(org.gradle.api.Project) CoreJavadocOptions(org.gradle.external.javadoc.CoreJavadocOptions) IdeaModule(org.gradle.plugins.ide.idea.model.IdeaModule) JavaPluginConvention(org.gradle.api.plugins.JavaPluginConvention) JavaExec(org.gradle.api.tasks.JavaExec) MonotonicNonNull(org.checkerframework.checker.nullness.qual.MonotonicNonNull) JMHPluginExtension(me.champeau.gradle.JMHPluginExtension) JavaCompile(org.gradle.api.tasks.compile.JavaCompile)

Aggregations

DeprecatableConfiguration (org.gradle.internal.deprecation.DeprecatableConfiguration)9 Configuration (org.gradle.api.artifacts.Configuration)7 SourceSet (org.gradle.api.tasks.SourceSet)5 File (java.io.File)3 Plugin (org.gradle.api.Plugin)3 Project (org.gradle.api.Project)3 Task (org.gradle.api.Task)3 ImmutableSet (com.google.common.collect.ImmutableSet)2 Inject (javax.inject.Inject)2 Action (org.gradle.api.Action)2 ConfigurationContainer (org.gradle.api.artifacts.ConfigurationContainer)2 DependencyHandler (org.gradle.api.artifacts.dsl.DependencyHandler)2 DefaultArtifactPublicationSet (org.gradle.api.internal.plugins.DefaultArtifactPublicationSet)2 ExtensionAware (org.gradle.api.plugins.ExtensionAware)2 JavaPluginExtension (org.gradle.api.plugins.JavaPluginExtension)2 SpotlessExtension (com.diffplug.gradle.spotless.SpotlessExtension)1 SpotlessPlugin (com.diffplug.gradle.spotless.SpotlessPlugin)1 VersionsPlugin (com.github.benmanes.gradle.versions.VersionsPlugin)1 DependencyUpdatesTask (com.github.benmanes.gradle.versions.updates.DependencyUpdatesTask)1 VisibleForTesting (com.google.common.annotations.VisibleForTesting)1