registerTransforms()

val shadedJarTask = addShadedJarTask()

addInstallShadedJarTask(shadedJarTask)
addShadedJarVariant(shadedJarTask)
configureShadedSourcesJarVariant()

fun registerTransforms() {
    dependencies {
        registerTransform(ShadeClasses::class) {
            from.attribute(Attributes.artifactType, "jar")

        createSourceRepository()
        registerTransforms()
        transientConfigurationForSourcesDownload().files
    }

    private
    fun registerTransforms() {
        registerTransform<UnzipDistribution> {
            from.attribute(artifactType, zipType)
            to.attribute(artifactType, unzippedDistributionType)
        }
        registerTransform<FindGradleSources> {

        this.buildServiceRegistry = buildServiceRegistry;
        this.contextIdGenerator = new LongIdGenerator();
        this.agentStatus = agentStatus;
    }

    public ScriptClassPathResolutionContext registerTransforms(DependencyHandler dependencyHandler) {
        long contextId = contextIdGenerator.generateId();

            .attribute(INSTRUMENTED_ATTRIBUTE, NOT_INSTRUMENTED.value);

        // Register instrumentation pipelines
        return instrumentationTransformRegisterer.registerTransforms(dependencyHandler);
    }

    @Override
    public void prepareClassPath(Configuration configuration, ScriptClassPathResolutionContext resolutionContext) {

 *
 * @see org.gradle.api.artifacts.dsl.DependencyHandler#registerTransform(Class, Action)
 * @param <T> The transform specific parameter type.
 * @since 5.3
 */
public interface TransformSpec<T extends TransformParameters> {
    /**
     * Attributes that match the variant that is consumed.
     *
     * @see org.gradle.api.artifacts.dsl.DependencyHandler#registerTransform(Class, Action)
     */
    AttributeContainer getFrom();

        e.cause == failure
    }

    def "fails when no from attributes are provided for registerTransform"() {
        when:
        registry.registerTransform(TestTransform) {
            it.to.attribute(TEST_ATTRIBUTE, "to")
        }

        then:
        def e = thrown(VariantTransformConfigurationException)

        given:
        buildFile << """
            $fileSizer
            $fileNamer
            project(":app") {
                ${registerTransform('FileSizer', 'jar', 'size')}
                ${registerTransform('FileNamer', 'size', 'name')}
                ${createResolveTask('name')}
            }
        """

        when:
        runBuild("resolve")

        then:

        attribute(buildType)
    }

    compile files(jar1)

    registerTransform(AarRelease) {
        from.attribute(artifactType, 'jar')
        to.attribute(artifactType, 'aar')

        from.attribute(buildType, 'default')
        to.attribute(buildType, 'release')
    }

    registerTransform(AarDebug) {
        from.attribute(artifactType, 'jar')
        to.attribute(artifactType, 'aar')

    }

    private <T extends TransformParameters> TransformStep registerTransform(Class<? extends TransformAction<T>> actionType) {
        def variantTransformRegistry = project.services.get(VariantTransformRegistry)
        int currentRegisteredTransforms = variantTransformRegistry.registrations.size()
        project.dependencies.registerTransform(actionType) {
            it.from.attribute(artifactType, 'jar')

                dependencies {
                    compile project(':lib')

                    registerTransform(MakeBlueToGreenThings) {
                        from.attribute(Attribute.of('color', String), "blue")
                        to.attribute(Attribute.of('color', String), "green")
                    }
                    registerTransform(MakeGreenToRedThings) {
                        from.attribute(Attribute.of('color', String), "green")