Examples with ConfigurationInternal org.gradle.api.internal.artifacts.configurations.ConfigurationInternal used on opensource projects

Example 6 with ConfigurationInternal

use of org.gradle.api.internal.artifacts.configurations.ConfigurationInternal in project gradle by gradle.

the class IvyBackedArtifactPublisher method publish.

public void publish(final Iterable<? extends PublicationAwareRepository> repositories, final Module module, final Configuration configuration, final File descriptor) throws PublishException {
    Set<ConfigurationInternal> allConfigurations = Cast.uncheckedCast(configuration.getAll());
    Set<ConfigurationInternal> configurationsToPublish = Cast.uncheckedCast(configuration.getHierarchy());
    if (descriptor != null) {
        // Convert once, in order to write the Ivy descriptor with _all_ configurations
        IvyModulePublishMetadata publishMetaData = toPublishMetaData(module, allConfigurations);
        validatePublishMetaData(publishMetaData);
        ivyModuleDescriptorWriter.write(publishMetaData, descriptor);
    }
    // Convert a second time with only the published configurations: this ensures that the correct artifacts are included
    BuildableIvyModulePublishMetadata publishMetaData = toPublishMetaData(module, configurationsToPublish);
    if (descriptor != null) {
        IvyArtifactName artifact = new DefaultIvyArtifactName("ivy", "ivy", "xml");
        publishMetaData.addArtifact(artifact, descriptor);
    }
    List<ModuleVersionPublisher> publishResolvers = new ArrayList<ModuleVersionPublisher>();
    for (PublicationAwareRepository repository : repositories) {
        ModuleVersionPublisher publisher = repository.createPublisher();
        publishResolvers.add(publisher);
    }
    dependencyPublisher.publish(publishResolvers, publishMetaData);
}

Example 7 with ConfigurationInternal

use of org.gradle.api.internal.artifacts.configurations.ConfigurationInternal in project gradle by gradle.

the class PluginResolutionServiceResolver method resolvePluginDependencies.

private ClassPath resolvePluginDependencies(final PluginUseMetaData metadata) {
    DependencyResolutionServices resolution = dependencyResolutionServicesFactory.create();
    RepositoryHandler repositories = resolution.getResolveRepositoryHandler();
    final String repoUrl = metadata.implementation.get("repo");
    repositories.maven(new Action<MavenArtifactRepository>() {

        public void execute(MavenArtifactRepository mavenArtifactRepository) {
            mavenArtifactRepository.setUrl(repoUrl);
        }
    });
    Dependency dependency = resolution.getDependencyHandler().create(metadata.implementation.get("gav"));
    ConfigurationContainerInternal configurations = (ConfigurationContainerInternal) resolution.getConfigurationContainer();
    ConfigurationInternal configuration = configurations.detachedConfiguration(dependency);
    try {
        Set<File> files = configuration.getResolvedConfiguration().getFiles(Specs.satisfyAll());
        return new DefaultClassPath(files);
    } catch (ResolveException e) {
        throw new DependencyResolutionException("Failed to resolve all plugin dependencies from " + repoUrl, e.getCause());
    }
}

Example 8 with ConfigurationInternal

use of org.gradle.api.internal.artifacts.configurations.ConfigurationInternal 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));
    });
}

Example 9 with ConfigurationInternal

use of org.gradle.api.internal.artifacts.configurations.ConfigurationInternal in project gradle by gradle.

the class Upload method upload.

@TaskAction
protected void upload() {
    getLogger().info("Publishing configuration: {}", configuration);
    DeprecationLogger.deprecateTaskType(Upload.class, getPath()).willBeRemovedInGradle8().withUpgradeGuideSection(7, "upload_task_deprecation").nagUser();
    Module module = ((ConfigurationInternal) configuration).getModule();
    ArtifactPublisher artifactPublisher = getPublicationServices().createArtifactPublisher();
    File descriptorDestination = isUploadDescriptor() ? getDescriptorDestination() : null;
    List<PublicationAwareRepository> publishRepositories = collect(getRepositories(), Transformers.cast(PublicationAwareRepository.class));
    try {
        artifactPublisher.publish(publishRepositories, module, configuration, descriptorDestination);
    } catch (Exception e) {
        throw new PublishException(String.format("Could not publish configuration '%s'", configuration.getName()), e);
    }
}

Example 10 with ConfigurationInternal

use of org.gradle.api.internal.artifacts.configurations.ConfigurationInternal in project gradle by gradle.

the class DefaultProjectLocalComponentProvider method getLocalComponentMetadata.

private LocalComponentMetadata getLocalComponentMetadata(ProjectState projectState, ProjectInternal project) {
    Module module = project.getDependencyMetaDataProvider().getModule();
    ModuleVersionIdentifier moduleVersionIdentifier = moduleIdentifierFactory.moduleWithVersion(module.getGroup(), module.getName(), module.getVersion());
    ProjectComponentIdentifier componentIdentifier = projectState.getComponentIdentifier();
    DefaultLocalComponentMetadata metaData = new DefaultLocalComponentMetadata(moduleVersionIdentifier, componentIdentifier, module.getStatus(), (AttributesSchemaInternal) project.getDependencies().getAttributesSchema());
    for (ConfigurationInternal configuration : project.getConfigurations().withType(ConfigurationInternal.class)) {
        metadataBuilder.addConfiguration(metaData, configuration);
    }
    return metaData;
}