* 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
     */

    }

    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))
    }

        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.
 */

	pSrc int // pSrc points to the start of the currently scanned rune.

	// checkpoints safe to return in Transform, where nDst <= pDst and nSrc <= pSrc.
	nDst, nSrc int
	err        error

	sz   int  // size of current rune
	info info // case information of currently scanned rune

	// State preserved across calls to Transform.
	isMidWord bool // false if next cased letter needs to be title-cased.
}

func (c *context) Reset() {

            }
        };
    }

    /**
     * Returns a transform that rename the before element to {@code renamed-} followed by the original name.
     */
    protected static Transform rename(SourceFileElement beforeElement) {
        return rename(beforeElement, AbstractRenameTransform.DEFAULT_RENAME_PREFIX);
    }

    protected static Transform rename(SourceFileElement beforeElement, String renamePrefix) {

            import java.io.File
            import javax.inject.Inject;
            import groovy.transform.CompileStatic
            import org.gradle.api.provider.*
            import org.gradle.api.file.*
            import org.gradle.api.tasks.*
            import org.gradle.api.artifacts.transform.*
            import org.gradle.work.*

            abstract class MakeGreen implements TransformAction<Parameters> {

public interface ExceptionAnalyser {
    /**
     * Transforms the given build failure to add context where relevant and to remove unnecessary noise.
     *
     * <p>Note that the argument may be mutated as part of the transformation, for example its causes or stack trace may be changed.</p>
     */
    RuntimeException transform(Throwable failure);

    /**
     * Transforms and combines the given failures into a single build failure.
     *

        where:
        task << ["resolveCollection", "resolveProviders"]
    }

    def "reading a file in transform action with #task of buildSrc build does not create a build input"() {
        given:
        createDir("buildSrc") {
            getTransformFixture().tap {
                withTransformPlugin(dir("transform-plugin"))
                withJavaLibrarySubproject(dir("subproject"))
            }