* in some situations it might be better to publish the resolved versions, or both
 * when the metadata format supports it.
 *
 * @since 5.2
 */
@HasInternalProtocol
public interface VersionMappingStrategy {
    /**
     * Configures the version mapping strategy for all variants
     * @param action the configuration action
     */
    void allVariants(Action<? super VariantVersionMappingStrategy> action);

        given:
        def variant = nonResolutionBacked()
        def versionMappingStrategy = versionMappingStrategy(false)

        expect:
        with(factory.createCoordinateResolvers(variant, versionMappingStrategy).get()) {
            componentResolver instanceof DefaultDependencyCoordinateResolverFactory.ProjectOnlyComponentDependencyResolver

 */
package org.gradle.api.publish.internal.versionmapping;

import org.gradle.api.internal.attributes.ImmutableAttributes;
import org.gradle.api.publish.VersionMappingStrategy;

public interface VersionMappingStrategyInternal extends VersionMappingStrategy {
    void defaultResolutionConfiguration(String usage, String defaultConfiguration);

        VersionMappingStrategyInternal versionMappingStrategy,
        TaskDependencyFactory taskDependencyFactory,
        ProviderFactory providerFactory
    ) {
        this.name = name;
        this.publicationCoordinates = publicationCoordinates;
        this.immutableAttributesFactory = immutableAttributesFactory;
        this.versionMappingStrategy = versionMappingStrategy;

        VersionMappingStrategyInternal versionMappingStrategy,
        TaskDependencyFactory taskDependencyFactory,
        ProviderFactory providerFactory,
        Project project
    ) {
        this.name = name;
        this.immutableAttributesFactory = immutableAttributesFactory;
        this.versionMappingStrategy = versionMappingStrategy;
        this.taskDependencyFactory = taskDependencyFactory;

    /**
     * Create coordinate resolvers for the given variant.
     */
    Provider<DependencyResolvers> createCoordinateResolvers(SoftwareComponentVariant variant, VersionMappingStrategyInternal versionMappingStrategy);

    /**
     * Contains the variant and component coordinate resolver for a given variant.
     */
    class DependencyResolvers {

        private final VariantDependencyResolver variantResolver;

            VersionMappingStrategyInternal versionMappingStrategy = objectFactory.newInstance(DefaultVersionMappingStrategy.class);

            return objectFactory.newInstance(DefaultIvyPublication.class, name, publicationIdentity, notationParser, versionMappingStrategy);
        }
    }

        this.attributeDesugaring = attributeDesugaring;
    }

    @Override
    public Provider<DependencyResolvers> createCoordinateResolvers(SoftwareComponentVariant variant, VersionMappingStrategyInternal versionMappingStrategy) {
        Configuration configuration = null;
        if (variant instanceof ResolutionBackedVariant) {
            ResolutionBackedVariant resolutionBackedVariant = (ResolutionBackedVariant) variant;

            VersionMappingStrategyInternal versionMappingStrategy = objectFactory.newInstance(DefaultVersionMappingStrategy.class);
            return objectFactory.newInstance(
                    DefaultMavenPublication.class,
                    name,
                    dependencyMetaDataProvider,
                    artifactNotationParser,
                    versionMappingStrategy
            );
        }
    }

        }.get(ObjectFactory)

        def versionMappingStrategy = Mock(VersionMappingStrategyInternal) {
            findStrategyForVariant(_) >> Mock(VariantVersionMappingStrategyInternal)
        }
        def publication = objectFactory.newInstance(DefaultIvyPublication,
            "pub-name",
            coordinates,
            notationParser,
            versionMappingStrategy
        )