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

                    outputFile.text = "green"
                }
            }
        """

        buildFile << """
            allprojects { p ->
                dependencies {
                    registerTransform(MakeGreen) {
                        from.attribute(color, 'blue')
                        to.attribute(color, 'green')
                        parameters {

configurations.all {
    afterEvaluate {
        if (canBeResolved) {
            attributes.attribute(minified, true) // <3>
        }
    }
}
// tag::artifact-transform-registration[]

dependencies {
    registerTransform(Minify) {
        from.attribute(minified, false).attribute(artifactType, "jar")
        to.attribute(minified, true).attribute(artifactType, "jar")
// end::artifact-transform-attribute-setup[]

        parameters {

     *
     * <p>
     *     Do not implement this method in your subclass.
     *     Gradle provides the implementation when registering the transform action via {@link org.gradle.api.artifacts.dsl.DependencyHandler#registerTransform(Class, Action)}.
     * </p>
     */
    @Inject
    T getParameters();

    /**
     * Executes the transform.
     *
     * <p>This method must be implemented in the subclass.</p>
     *

                }
            }

            dependencies {
                registerTransform(SomeTransform) {
                    from.attribute(minified, false).attribute(artifactType, "jar")
                    to.attribute(minified, true).attribute(artifactType, "jar")
                }
                registerTransform(SomeTransform) {

                    println "Executing unzip transform..."
                    super.transform(outputs)
                }
            }

            dependencies {
                registerTransform(TestUnzipTransform) {
                    from.attribute(artifactType, "zip").attribute(compressed, true)
                    to.attribute(artifactType, "directory").attribute(compressed, false)
                }

            }
            configurations {
                compile
            }
            dependencies {
                compile files(producer.output)

                registerTransform(MakeSize) {
                    from.attribute(artifactType, 'directory')
                    to.attribute(artifactType, 'size')
                }
            }