private final Map<String, AttributeContainerInternal> variantAttributes = new ConcurrentHashMap<>();

    public VariantMetadataRules(ImmutableAttributesFactory attributesFactory, ModuleVersionIdentifier moduleVersionId) {
        this(attributesFactory, moduleVersionId, attributesFactory.mutable());
    }

    private final VariantMetadataRules variantMetadataRules;

    private List<? extends ModuleDependencyMetadata> calculatedDependencies;

    LazyVariantBackedConfigurationMetadata(ModuleComponentIdentifier componentId, ComponentVariant variant, ImmutableAttributes componentLevelAttributes, ImmutableAttributesFactory attributesFactory, VariantMetadataRules variantMetadataRules) {

        ImmutableAttributes attributes = variantMetadataRules.applyVariantAttributeRules(variant, variant.getAttributes());
        ImmutableCapabilities capabilities = variantMetadataRules.applyCapabilitiesRules(variant, variant.getCapabilities());

                                               VariantMetadataRules variantMetadataRules,
                                               ImmutableList<ExcludeMetadata> excludes,
                                               boolean externalVariant) {
        this.name = name;
        this.base = base;
        this.componentId = componentId;
        this.variantMetadataRules = variantMetadataRules;
        this.attributesFactory = attributesFactory;

        if (variants.isEmpty()) {
            addVariantsFromRules(metadata, configurations, variantMetadataRules);
        }

        return new RealisedIvyModuleResolveMetadata(metadata, variants, configurations);
    }

    private static Map<String, ModuleConfigurationMetadata> realiseConfigurations(DefaultIvyModuleResolveMetadata metadata, VariantMetadataRules variantMetadataRules) {

    public static RealisedMavenModuleResolveMetadata transform(DefaultMavenModuleResolveMetadata metadata) {
        VariantMetadataRules variantMetadataRules = metadata.getVariantMetadataRules();
        ImmutableList<? extends ComponentVariant> variants = LazyToRealisedModuleComponentResolveMetadataHelper.realiseVariants(metadata, variantMetadataRules, metadata.getVariants());

 */
public abstract class AbstractLazyModuleComponentResolveMetadata extends AbstractModuleComponentResolveMetadata {
    private final VariantMetadataRules variantMetadataRules;
    private final ImmutableMap<String, Configuration> configurationDefinitions;

    // Configurations are built on-demand, but only once.
    private final Map<String, ModuleConfigurationMetadata> configurations = new HashMap<>();

    private final ImmutableAttributesFactory attributesFactory;
    private final List<VariantMetadataRules.VariantAction<? super AttributeContainer>> actions = new LinkedList<>();

    public VariantAttributesRules(ImmutableAttributesFactory attributesFactory) {
        this.attributesFactory = attributesFactory;
    }

    public void addAttributesAction(VariantMetadataRules.VariantAction<? super AttributeContainer> action) {
        actions.add(action);

        given:
        def rule = Mock(Action)

        when:
        metadata.variantMetadataRules.addVariant('new-variant', 'runtime', false)
        metadata.variantMetadataRules.addVariantFilesAction(new VariantMetadataRules.VariantAction<MutableVariantFilesMetadata>(null, rule))
        def newVariant =  metadata.asImmutable().variantsForGraphTraversal.find { it.name == 'new-variant' }

    }

    @Override
    public void withDependencyConstraints(Action<? super DependencyConstraintsMetadata> action) {
        metadata.getVariantMetadataRules().addDependencyConstraintAction(instantiator, dependencyMetadataNotationParser, dependencyConstraintMetadataNotationParser, new VariantMetadataRules.VariantAction<>(variantName, action));
    }