use of org.gradle.api.plugins.internal.JavaConfigurationVariantMapping in project gradle by gradle.
the class DefaultJvmVariantBuilder method configureDocumentationVariantWithArtifact.
public void configureDocumentationVariantWithArtifact(String variantName, @Nullable String name, @Nullable String displayName, String docsType, String jarTaskName, Object artifactSource, @Nullable AdhocComponentWithVariants component) {
Configuration variant = configurations.maybeCreate(variantName);
variant.setVisible(false);
variant.setDescription(docsType + " elements for " + (displayName == null ? "main" : displayName) + ".");
variant.setCanBeResolved(false);
variant.setCanBeConsumed(true);
jvmPluginServices.configureAttributes(variant, attributes -> attributes.documentation(docsType).runtimeUsage().withExternalDependencies());
capabilities.forEach(variant.getOutgoing()::capability);
if (!tasks.getNames().contains(jarTaskName)) {
TaskProvider<Jar> jarTask = tasks.register(jarTaskName, Jar.class, jar -> {
jar.setDescription("Assembles a jar archive containing the " + (displayName == null ? "main " + docsType + "." : (docsType + " of the '" + displayName + "'.")));
jar.setGroup(BasePlugin.BUILD_GROUP);
jar.from(artifactSource);
jar.getArchiveClassifier().set(TextUtil.camelToKebabCase(name == null ? docsType : (name + "-" + docsType)));
});
if (tasks.getNames().contains(LifecycleBasePlugin.ASSEMBLE_TASK_NAME)) {
tasks.named(LifecycleBasePlugin.ASSEMBLE_TASK_NAME).configure(task -> task.dependsOn(jarTask));
}
}
TaskProvider<Task> jar = tasks.named(jarTaskName);
variant.getOutgoing().artifact(new LazyPublishArtifact(jar, project.getFileResolver()));
if (published && component != null) {
component.addVariantsFromConfiguration(variant, new JavaConfigurationVariantMapping("runtime", true));
}
}
use of org.gradle.api.plugins.internal.JavaConfigurationVariantMapping 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.plugins.internal.JavaConfigurationVariantMapping 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.plugins.internal.JavaConfigurationVariantMapping 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.plugins.internal.JavaConfigurationVariantMapping 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