}
    }
}
// end::artifact-transform-countloc[]

val usage = Attribute.of("usage", String::class.java)
val artifactType = Attribute.of("artifactType", String::class.java)

dependencies {
    registerTransform(CountLoc::class) {
        from.attribute(artifactType, "java")
        to.attribute(artifactType, "loc")
    }
}

dependencies {
    attributesSchema {
        attribute(usage)
    }
}

                registerTransform(CountRecorder) {
                    from.attribute(artifactType, 'jar')
                    to.attribute(artifactType, 'secondCount')
                    parameters {
                        counter = buildScriptCounter
                    }
                }
                registerTransform(CountRecorder) {

            }
        }
    }
}
// end::artifact-transform-countloc[]

def usage = Attribute.of('usage', String)
def artifactType = Attribute.of('artifactType', String)

dependencies {
    registerTransform(CountLoc) {
        from.attribute(artifactType, 'java')
        to.attribute(artifactType, 'loc')
    }
}

dependencies {
    attributesSchema {
        attribute(usage)
    }
}

    }
}
// end::artifact-transform-unzip[]

def usage = Attribute.of('usage', String)
// tag::artifact-transform-registration[]
def artifactType = Attribute.of('artifactType', String)

dependencies {
    registerTransform(Unzip) {
        from.attribute(artifactType, 'jar')
        to.attribute(artifactType, 'java-classes-directory')
    }
}
// end::artifact-transform-registration[]

dependencies {
    attributesSchema {

val usage = Attribute.of("usage", String::class.java)
// tag::artifact-transform-registration[]
val artifactType = Attribute.of("artifactType", String::class.java)

dependencies {
    registerTransform(Unzip::class) {
        from.attribute(artifactType, "jar")
        to.attribute(artifactType, "java-classes-directory")
    }
}
// end::artifact-transform-registration[]

dependencies {

import org.gradle.api.internal.GradleInternal

/**
 * A plugin that configures tasks and transforms to generate metadata that is needed for code instrumentation.
 */
dependencies {
    registerTransform(InstrumentationMetadataTransform::class) {
        from.attribute(ArtifactTypeDefinition.ARTIFACT_TYPE_ATTRIBUTE, ArtifactTypeDefinition.JVM_CLASS_DIRECTORY)

}
// end::artifact-transform-relocate[]

configurations.create("externalClasspath")

def usage = Attribute.of('usage', String)
def artifactType = Attribute.of('artifactType', String)

dependencies {
    registerTransform(ClassRelocator) {
        from.attribute(artifactType, "jar")
        to.attribute(artifactType, "relocated-classes")
        parameters {
            externalClasspath.from(configurations.externalClasspath)

        // register the transform for Jars and "javaModule=false -> javaModule=true"; the plugin extension object fills the input parameter
        project.getDependencies().registerTransform(ExtraModuleInfoTransform.class, t -> {
            t.parameters(p -> {
                p.setModuleInfo(extension.getModuleInfo());
                p.setAutomaticModules(extension.getAutomaticModules());
            });

        if (parameters.broken.get()) {
            Runtime.runtime.halt(1)
        }
        def two = outputs.file("two")
        two.text = "two"
    }
}

dependencies {
    registerTransform(ToColor) {
        from.attribute(type, "jar")
        to.attribute(type, "red")
        parameters {
            color = Color.Red
            broken = providers.systemProperty("crash").map { true }.orElse(false)

configurations.create("externalClasspath")

val usage = Attribute.of("usage", String::class.java)
val artifactType = Attribute.of("artifactType", String::class.java)

dependencies {
    registerTransform(ClassRelocator::class) {
        from.attribute(artifactType, "jar")
        to.attribute(artifactType, "relocated-classes")
        parameters {