implementation(enforcedPlatform("com.fasterxml.jackson:jackson-virtual-platform:2.8.9"))
}
// end::enforced_platform[]
}

// tag::bom-alignment-rule[]
abstract class JacksonBomAlignmentRule: ComponentMetadataRule {
    override fun execute(ctx: ComponentMetadataContext) {
        ctx.details.run {
            if (id.group.startsWith("com.fasterxml.jackson")) {

import org.gradle.api.artifacts.CacheableRule;
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) {

 */

package org.gradle.api.internal.artifacts.dsl;

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

public class TestComponentMetadataRule implements ComponentMetadataRule {

    static int instanceCount = 0;

    public TestComponentMetadataRule() {
        instanceCount++;
    }

    @Override

    implementation enforcedPlatform('com.fasterxml.jackson:jackson-virtual-platform:2.8.9')
}
// end::enforced_platform[]
}

// tag::bom-alignment-rule[]
abstract class JacksonBomAlignmentRule implements ComponentMetadataRule {
    void execute(ComponentMetadataContext ctx) {
        ctx.details.with {
            if (id.group.startsWith("com.fasterxml.jackson")) {

        buildFile << """
            dependencies {
                components.all(InferModuleSetFromGroupAndVersion)
            }
            
            class InferModuleSetFromGroupAndVersion implements ComponentMetadataRule {
                void execute(ComponentMetadataContext ctx) {
                    ctx.details.with {
                        belongsTo("\${id.group}:platform:\${id.version}", ${virtual})
                    }

// tag::declare_capability[]
dependencies {
    // Activate the "LoggingCapability" rule
    components.all(LoggingCapability)
}

@CompileStatic
class LoggingCapability implements ComponentMetadataRule {
    final static Set<String> LOGGING_MODULES = ["log4j", "log4j-over-slf4j"] as Set<String>

    void execute(ComponentMetadataContext context) {
        context.details.with {

}
// end::use_highest_asm[]

// tag::declare_capability[]
dependencies {
    // Activate the "LoggingCapability" rule
    components.all(LoggingCapability::class.java)
}

class LoggingCapability : ComponentMetadataRule {
    val loggingModules = setOf("log4j", "log4j-over-slf4j")

    override
    fun execute(context: ComponentMetadataContext) = context.details.run {
        if (loggingModules.contains(id.name)) {

            }

            class NonCachedRule implements ComponentMetadataRule {
                @Override
                void execute(ComponentMetadataContext context) {
                    println("Applying rule on \$context.details.id")
                }
            }

            @CacheableRule
            class CachedRule implements ComponentMetadataRule {
                @Override

        file("buildSrc/src/main/java/AddVariantRule.java") << """
            package com.example;

            import org.gradle.api.artifacts.ComponentMetadataContext;
            import org.gradle.api.artifacts.ComponentMetadataRule;
            import org.gradle.api.artifacts.ModuleVersionIdentifier;
            import org.gradle.api.attributes.Category;
            import org.gradle.api.attributes.DocsType;

        given:
        buildFile << """
repositories {
    ivy {
        url "${ivyRepo.uri}"
    }
}

class StatusRule implements ComponentMetadataRule {
    public void execute(ComponentMetadataContext context) {
        context.details.statusScheme = ["bronze", "silver", "gold", "platin"]
    }
}

configurations { compile }
dependencies {