* <pre class='autoTested'>
 * import org.gradle.api.artifacts.transform.TransformParameters;
 *
 * public abstract class MyTransform implements TransformAction&lt;TransformParameters.None&gt; {
 *
 *     {@literal @}InputArtifact
 *     public abstract Provider&lt;FileSystemLocation&gt; getInputArtifact();
 *     {@literal @}Override
 *     public void transform(TransformOutputs outputs) {
 *         File input = getInputArtifact().get().getAsFile();

        boolean disableCachingByProperty
    ) {
        this.transform = transform;
        this.inputArtifact = inputArtifact;
        this.dependencies = dependencies;
        this.inputArtifactProvider = Providers.of(new DefaultFileSystemLocation(inputArtifact));
        this.subject = subject;
        this.transformExecutionListener = transformExecutionListener;

        private final File inputArtifact;
        private final File outputDir;
        private final String inputArtifactPrefix;
        private final String outputDirPrefix;
        private final Builder delegate = TransformExecutionResult.builder();

        public OutputTypeInferringBuilder(File inputArtifact, File outputDir) {
            this.inputArtifact = inputArtifact;
            this.outputDir = outputDir;

        assertCanWriteAndReadResult(
            inputArtifact.file("inside"),
            inputArtifact,
            inputArtifact
        )
    }

    def "resolves files in input artifact relative to input artifact"() {
        def newInputArtifact = file("newInputArtifact").createDir()

        ImmutableList<File> resultFiles = ImmutableList.of(
            inputArtifact.file("inside"),
            inputArtifact,

    private final PathToFileResolver resolver;
    private final File inputArtifact;
    private final File outputDir;

    public DefaultTransformOutputs(File inputArtifact, File outputDir, FileLookup fileLookup) {
        this.resolver = fileLookup.getPathToFileResolver(outputDir);
        this.inputArtifact = inputArtifact;
        this.outputDir = outputDir;

     *     The path must to point to the {@link InputArtifact}, or point inside the input artifact if it is a directory.
     *     Example:
     * </p>
     * <pre class='autoTested'>
     * import org.gradle.api.artifacts.transform.TransformParameters;
     *
     * public abstract class MyTransform implements TransformAction&lt;TransformParameters.None&gt; {
     *     {@literal @}InputArtifact

        transform.isolateParametersIfNotAlready()
        def invocationFactory = project.services.get(TransformInvocationFactory)
        def inputFingerprinter = project.services.get(InputFingerprinter)
        def artifact = Stub(ResolvableArtifact) {
            getId() >> new OpaqueComponentArtifactIdentifier(inputArtifact)
        }

            outputPropertyNames == ['outputDirectory', 'resultsFile']
            inputFileProperties.keySet() ==~ ['inputArtifact', 'inputArtifactDependencies']
            with(inputFileProperties.inputArtifact) {
                hash != null
                attributes == ['DIRECTORY_SENSITIVITY_DEFAULT', 'FINGERPRINTING_STRATEGY_RELATIVE_PATH', 'LINE_ENDING_SENSITIVITY_NORMALIZE_LINE_ENDINGS']

// tag::artifact-transform-minify[]

    }

    @get:PathSensitive(PathSensitivity.NAME_ONLY)
    @get:InputArtifact
    abstract val inputArtifact: Provider<FileSystemLocation>

    override
    fun transform(outputs: TransformOutputs) {
        val fileName = inputArtifact.get().asFile.name
        for (entry in parameters.keepClassesByArtifact) {      // <3>
            if (fileName.startsWith(entry.key)) {

abstract class CopyPublicApiClassesTransform : TransformAction<TransformParameters.None> {

    @get:InputArtifact
    @get:Classpath
    abstract val inputArtifact: Provider<FileSystemLocation>

    override fun transform(outputs: TransformOutputs) {
        val jarFile = inputArtifact.get().asFile
        val zipFile = ZipFile(jarFile)
        val outputRoot = outputs.dir("public-api")
        zipFile.stream().forEach { entry ->