Serializer<ModuleComponentResolveMetadata> serializer
    InstantiatingAction<ComponentMetadataContext> rule
    Transformer<ModuleComponentResolveMetadata, ComponentMetadataContext> detailsToResult
    Transformer<ComponentMetadataContext, ModuleVersionIdentifier> onCacheMiss
    CachePolicy cachePolicy

    ModuleComponentResolveMetadata result

    def setup() {

import org.gradle.api.artifacts.ComponentMetadataContext;
import org.gradle.api.artifacts.ComponentMetadataRule;
import org.gradle.api.attributes.Attribute;

@CacheableRule
public class TestAddVariantComponentMetadataRule implements ComponentMetadataRule {
    @Override
    public void execute(ComponentMetadataContext componentMetadataContext) {
        componentMetadataContext.getDetails().addVariant("test", variantMetadata -> {

                @Override
                public void execute(ComponentMetadataContext componentMetadataContext) {
                    Category category = objectFactory.named(Category.class, Category.DOCUMENTATION);
                    DocsType docsType = objectFactory.named(DocsType.class, "my-classifier");

                    ModuleVersionIdentifier id = componentMetadataContext.getDetails().getId();

// Set up the status scheme so that "experimental" is a valid status for "org.sample" artifacts

class StatusRule implements ComponentMetadataRule {

    @Override
    void execute(ComponentMetadataContext componentMetadataContext) {
        def details = componentMetadataContext.details
        if (details.id.group == "org.sample") {
            details.statusScheme = ["experimental", "integration", "milestone", "release"]
        }
    }
}

    }
}

// Set up the status scheme so that "experimental" is a valid status for "org.sample" artifacts

class StatusRule : ComponentMetadataRule {

    override fun execute(componentMetadataContext: ComponentMetadataContext) {
        val details = componentMetadataContext.details
        if (details.id.group == "org.sample") {
            details.statusScheme = listOf("experimental", "integration", "milestone", "release")
        }
    }
}

abstract class CapabilityRule @Inject constructor(
    val name: String,
    val version: String
) : ComponentMetadataRule {
    override fun execute(context: ComponentMetadataContext) {
        context.details.allVariants {
            withCapabilities {
                addCapability("org.gradle.internal.capability", name, version)
            }
        }
    }
}

                @javax.inject.Inject
                public AttributeRule(Attribute attribute) {
                    targetAttribute = attribute
                }

                public void execute(ComponentMetadataContext context) {
                    context.details.attributes {
                        attribute targetAttribute, ${fixApplied ? '"qa"' : '"canary"'}
                    }
                }
            }

                @javax.inject.Inject
                ModifyDependencyRule(Attribute attribute) {
                    this.attribute = attribute
                }

                void execute(ComponentMetadataContext context) {
                    context.details.allVariants {
                        withDependencies {
                            it.each {
                               it.attributes {

In this example, the rule is also further configured through an link:{javadocPath}/org/gradle/api/ActionConfiguration.html[ActionConfiguration].

    get() = the<GroovySourceDirectorySet>()

abstract class CodeNarcRule @Inject constructor(
    private val groovyVersion: String
) : ComponentMetadataRule {
    override fun execute(context: ComponentMetadataContext) {
        context.details.allVariants {
            withDependencies {
                val isAtLeastGroovy4 = VersionNumber.parse(groovyVersion).major >= 4