* limitations under the License.
 */
package gradlebuild.docs;

import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.stream.StreamResult;
import javax.xml.transform.stream.StreamSource;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

import org.gradle.api.Action;
import org.gradle.api.artifacts.transform.TransformAction;
import org.gradle.api.artifacts.transform.TransformParameters;
import org.gradle.api.artifacts.transform.TransformSpec;

import java.util.List;

public interface VariantTransformRegistry {

    /**
     * Register an artifact transform.
     *
     * @see TransformAction
     */

        @Override
        public O transform(I input) {
            return Cast.cast(outputType, input);
        }
    }

    public static <T> InternalTransformer<String, T> asString() {
        return new ToStringTransformer<T>();
    }

    private static class ToStringTransformer<T> implements InternalTransformer<String, T> {
        @Override
        public String transform(T original) {

    }

    String transform(File from, File to) {
        return normaliseFileSeparators(RelativeFileNameTransformer.forDirectory(rootDir, from).transform(to))
    }

    String pathToDescendant(File parent, File to) {
        assert parent.exists()
        assert to.exists()
        return normaliseFileSeparators(RelativeFileNameTransformer.from(parent).transform(to))
    }

    /**
     * @return The transform chain which transforms the root variant to this variant.
     */
    TransformChain getTransformChain();

    /**
     * The single transform step which transforms the previous variant to this variant.
     */
    TransformStep getTransformStep();

    /**
     * @return The previous variant in the transform chain. If null, this variant uses the producer variant as its root.

        outputContains("processing c.jar using [tool-a.jar]")
        outputContains("result = [b.jar.green, c.jar.green]")
    }

    def "transform can receive a file collection containing transform outputs as parameter"() {
        createDirs("a", "b", "c", "d", "e")
        settingsFile << """
                include 'a', 'b', 'c', 'd', 'e'
            """

import gradlebuild.basics.classanalysis.addJarEntry
import org.gradle.api.artifacts.transform.CacheableTransform
import org.gradle.api.artifacts.transform.InputArtifact
import org.gradle.api.artifacts.transform.TransformAction
import org.gradle.api.artifacts.transform.TransformOutputs
import org.gradle.api.artifacts.transform.TransformParameters
import org.gradle.api.file.FileSystemLocation
import org.gradle.api.provider.Provider

        buildA.buildFile << """
            import org.gradle.api.artifacts.transform.TransformParameters

            abstract class XForm implements TransformAction<TransformParameters.None> {
                @InputArtifact
                abstract Provider<FileSystemLocation> getInputArtifact()

                void transform(TransformOutputs outputs) {
                    def input = inputArtifact.get().asFile

 * limitations under the License.
 */

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

/**
 * A transform step with all of its parameters bound to their providers.
 * <p>
 * A transform step may take parameters from a parameters object specified when the transform is registered
 * and may also take the upstream dependencies of the source artifact as a parameter.
 */

     * @param original the property list to transform
     * @return the transformed property list
     */
    @Override
    public T transform(T original) {
        return doTransform(original);
    }

    /**
     * Transforms a property list object and write them out to a stream.
     * This will modify the original property list.
     * @param original the property list to transform