registerTransform(ExplodeZipAndFindJars) {
        from.attribute(ARTIFACT_TYPE, 'zip')
        to.attribute(ARTIFACT_TYPE, 'gradle-libs-dir')
    }
    registerTransform(FindGradleClasspath) {
        from.attribute(ARTIFACT_TYPE, 'gradle-libs-dir')
        to.attribute(ARTIFACT_TYPE, 'gradle-classpath')
    }
    dependencies.registerTransform(FindGradleJars) {

        def out = outputs.file(color.toString())
        out.text = input.name
    }
}

dependencies {
    registerTransform(ToColor) {
        from.attribute(type, "jar")
        to.attribute(type, "red")
        parameters {
            color = Color.Red
        }
    }
    registerTransform(ToColor) {
        from.attribute(type, "jar")
        to.attribute(type, "blue")
        parameters {

import java.util.List;

public interface VariantTransformRegistry {

    /**
     * Register an artifact transform.
     *
     * @see TransformAction
     */
    <T extends TransformParameters> void registerTransform(Class<? extends TransformAction<T>> actionType, Action<? super TransformSpec<T>> registrationAction);

    List<TransformRegistration> getRegistrations();

        }
    }
}
// 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 {

/**
 * Provides classes, interfaces and annotations for registering and implementing artifact transforms.
 *
 * <p>
 *     To register an artifact transform, use {@link org.gradle.api.artifacts.dsl.DependencyHandler#registerTransform(java.lang.Class, org.gradle.api.Action)}.
 *     This allows you to register a {@link org.gradle.api.artifacts.transform.TransformAction} using {@link org.gradle.api.artifacts.transform.TransformSpec}.
 * </p>
 *

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)