use of org.gradle.api.component.AdhocComponentWithVariants in project spring-boot by spring-projects.
the class MavenPublishingConventions method addMavenOptionalFeature.
/**
* Add a feature that allows maven plugins to declare optional dependencies that
* appear in the POM. This is required to make m2e in Eclipse happy.
* @param project the project to add the feature to
*/
private void addMavenOptionalFeature(Project project) {
JavaPluginExtension extension = project.getExtensions().getByType(JavaPluginExtension.class);
extension.registerFeature("mavenOptional", (feature) -> feature.usingSourceSet(extension.getSourceSets().getByName("main")));
AdhocComponentWithVariants javaComponent = (AdhocComponentWithVariants) project.getComponents().findByName("java");
javaComponent.addVariantsFromConfiguration(project.getConfigurations().findByName("mavenOptionalRuntimeElements"), ConfigurationVariantDetails::mapToOptional);
}
use of org.gradle.api.component.AdhocComponentWithVariants in project gradle by gradle.
the class VersionCatalogPlugin method createPublication.
private void createPublication(Project project, TaskProvider<TomlFileGenerator> generator) {
Configuration exported = project.getConfigurations().create(VERSION_CATALOG_ELEMENTS, cnf -> {
cnf.setDescription("Artifacts for the version catalog");
cnf.setCanBeConsumed(true);
cnf.setCanBeResolved(false);
cnf.getOutgoing().artifact(generator);
cnf.attributes(attrs -> {
attrs.attribute(Category.CATEGORY_ATTRIBUTE, project.getObjects().named(Category.class, Category.REGULAR_PLATFORM));
attrs.attribute(Usage.USAGE_ATTRIBUTE, project.getObjects().named(Usage.class, Usage.VERSION_CATALOG));
});
});
AdhocComponentWithVariants versionCatalog = softwareComponentFactory.adhoc("versionCatalog");
project.getComponents().add(versionCatalog);
versionCatalog.addVariantsFromConfiguration(exported, new JavaConfigurationVariantMapping("compile", true));
}
use of org.gradle.api.component.AdhocComponentWithVariants in project gradle by gradle.
the class JavaPlatformPlugin method createSoftwareComponent.
private void createSoftwareComponent(Project project, Configuration apiElements, Configuration runtimeElements) {
AdhocComponentWithVariants component = softwareComponentFactory.adhoc("javaPlatform");
project.getComponents().add(component);
component.addVariantsFromConfiguration(apiElements, new JavaConfigurationVariantMapping("compile", false));
component.addVariantsFromConfiguration(runtimeElements, new JavaConfigurationVariantMapping("runtime", false));
}
use of org.gradle.api.component.AdhocComponentWithVariants in project gradle by gradle.
the class JavaPlugin method registerSoftwareComponents.
private void registerSoftwareComponents(Project project) {
ConfigurationContainer configurations = project.getConfigurations();
// the main "Java" component
AdhocComponentWithVariants java = softwareComponentFactory.adhoc("java");
java.addVariantsFromConfiguration(configurations.getByName(API_ELEMENTS_CONFIGURATION_NAME), new JavaConfigurationVariantMapping("compile", false));
java.addVariantsFromConfiguration(configurations.getByName(RUNTIME_ELEMENTS_CONFIGURATION_NAME), new JavaConfigurationVariantMapping("runtime", false));
project.getComponents().add(java);
}
use of org.gradle.api.component.AdhocComponentWithVariants in project gradle by gradle.
the class DefaultJvmVariantBuilder method build.
void build() {
SourceSet sourceSet = this.sourceSet == null ? sourceSets.maybeCreate(name) : this.sourceSet;
boolean mainSourceSet = SourceSet.isMain(sourceSet);
String apiConfigurationName;
String implementationConfigurationName;
String apiElementsConfigurationName;
String runtimeElementsConfigurationName;
String compileOnlyConfigurationName;
String compileOnlyApiConfigurationName;
String runtimeOnlyConfigurationName;
if (mainSourceSet) {
apiConfigurationName = name + "Api";
implementationConfigurationName = name + "Implementation";
apiElementsConfigurationName = apiConfigurationName + "Elements";
runtimeElementsConfigurationName = name + "RuntimeElements";
compileOnlyConfigurationName = name + "CompileOnly";
compileOnlyApiConfigurationName = name + "CompileOnlyApi";
runtimeOnlyConfigurationName = name + "RuntimeOnly";
} else {
apiConfigurationName = sourceSet.getApiConfigurationName();
implementationConfigurationName = sourceSet.getImplementationConfigurationName();
apiElementsConfigurationName = sourceSet.getApiElementsConfigurationName();
runtimeElementsConfigurationName = sourceSet.getRuntimeElementsConfigurationName();
compileOnlyConfigurationName = sourceSet.getCompileOnlyConfigurationName();
compileOnlyApiConfigurationName = sourceSet.getCompileOnlyApiConfigurationName();
runtimeOnlyConfigurationName = sourceSet.getRuntimeOnlyConfigurationName();
}
String displayName = this.displayName == null ? name : this.displayName;
// In the general case, the following configurations are already created
// but if we're using the "main" source set, it means that the component we're creating shares
// the same source set (main) but declares its dependencies in its own buckets, so we need
// to create them
Configuration implementation = bucket("Implementation", implementationConfigurationName, displayName);
Configuration compileOnly = bucket("Compile-Only", compileOnlyConfigurationName, displayName);
Configuration compileOnlyApi = bucket("Compile-Only API", compileOnlyApiConfigurationName, displayName);
Configuration runtimeOnly = bucket("Runtime-Only", runtimeOnlyConfigurationName, displayName);
TaskProvider<Task> jarTask = registerOrGetJarTask(sourceSet, displayName);
Configuration api = exposeApi ? bucket("API", apiConfigurationName, displayName) : null;
Configuration apiElements = exposeApi ? jvmPluginServices.createOutgoingElements(apiElementsConfigurationName, builder -> {
builder.fromSourceSet(sourceSet).providesApi().withDescription("API elements for " + displayName).extendsFrom(api, compileOnlyApi).withCapabilities(capabilities).withClassDirectoryVariant().artifact(jarTask);
}) : null;
if (exposeApi) {
implementation.extendsFrom(api);
}
Configuration runtimeElements = jvmPluginServices.createOutgoingElements(runtimeElementsConfigurationName, builder -> {
builder.fromSourceSet(sourceSet).providesRuntime().withDescription("Runtime elements for " + displayName).extendsFrom(implementation, runtimeOnly).withCapabilities(capabilities).artifact(jarTask);
});
if (mainSourceSet) {
// we need to wire the compile only and runtime only to the classpath configurations
configurations.getByName(sourceSet.getCompileClasspathConfigurationName()).extendsFrom(implementation, compileOnly);
configurations.getByName(sourceSet.getRuntimeClasspathConfigurationName()).extendsFrom(implementation, runtimeOnly);
// and we also want the feature dependencies to be available on the test classpath
configurations.getByName(JavaPlugin.TEST_COMPILE_CLASSPATH_CONFIGURATION_NAME).extendsFrom(implementation, compileOnlyApi);
configurations.getByName(JavaPlugin.TEST_RUNTIME_CLASSPATH_CONFIGURATION_NAME).extendsFrom(implementation, runtimeOnly);
}
final AdhocComponentWithVariants component = findJavaComponent();
JavaPluginExtension javaPluginExtension = project.getExtensions().findByType(JavaPluginExtension.class);
configureJavaDocTask(name, sourceSet, tasks, javaPluginExtension);
if (javadocJar) {
configureDocumentationVariantWithArtifact(sourceSet.getJavadocElementsConfigurationName(), mainSourceSet ? null : name, displayName, JAVADOC, sourceSet.getJavadocJarTaskName(), tasks.named(sourceSet.getJavadocTaskName()), component);
}
if (sourcesJar) {
configureDocumentationVariantWithArtifact(sourceSet.getSourcesElementsConfigurationName(), mainSourceSet ? null : name, displayName, SOURCES, sourceSet.getSourcesJarTaskName(), sourceSet.getAllSource(), component);
}
if (published && component != null) {
if (apiElements != null) {
component.addVariantsFromConfiguration(apiElements, new JavaConfigurationVariantMapping("compile", true));
}
component.addVariantsFromConfiguration(runtimeElements, new JavaConfigurationVariantMapping("runtime", true));
}
}
Aggregations