== Artifact transform selection and execution

As described above, when Gradle resolves a configuration and a dependency in the configuration does not have a variant with the requested attributes, Gradle tries to find a chain of artifact transforms to create the variant.
The process of finding a matching chain of artifact transforms is called _artifact transform selection_.

     * Returns grouped output for the given transformer type and transform subject.
     */
    public GroupedTransformOutputFixture transform(String transformer, String subject) {
        List<GroupedTransformOutputFixture> foundTransforms = transforms.values().stream()
            .filter(transform -> transform.getTransformer().equals(transformer) && transform.getSubject().equals(subject))
            .collect(Collectors.toList());

		</postConstruct>
	</component>

	<component name="fessFileTransformer" class="org.codelibs.fess.crawler.transformer.FessFileTransformer" instance="singleton">
		<property name="name">"fessFileTransformer"</property>
	</component>

	<component name="fessStandardTransformer" class="org.codelibs.fess.crawler.transformer.FessStandardTransformer" instance="singleton">
		<property name="name">"fessStandardTransformer"</property>
	</component>

        return doTransform(original);
    }

    /**
     * Transforms a properties object and write them out to a stream.
     * This will modify the original properties.
     * @param original the properties to transform
     * @param destination the stream to write the properties to
     */
    public void transform(Properties original, OutputStream destination) {
        try {

     * values for some of which have been changed by the transform.
     */
    Map<String, String> getTargetAttributes();

    /**
     * Capabilities of the variant of the transformed artifact.
     * <p>
     * Artifact transforms can only change attributes, so the capabilities remain unchanged throughout the transform chain.
     */
    List<? extends Capability> getCapabilities();

    /**

        createFile(new File(cachesDir, "8.7-rc-4/transforms/first/transformed/instrumented/file"))
        createFile(new File(cachesDir, "8.7-rc-4/transforms/second/transformed/original/file"))
        createFile(new File(cachesDir, "8.8/transforms/first/transformed/instrumented/file"))
        createFile(new File(cachesDir, "8.8/transforms/first/transformed/original/file"))

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.gradle.groovy.scripts;

import org.codehaus.groovy.control.CompilationUnit;

public interface Transformer {

    void register(CompilationUnit compilationUnit);

        Transformer<String, String> transformerA = Mock()
        Transformer<String, String> transformerB = Mock()

        transformerA.transform('original') >> 'a'
        transformerB.transform('a') >> 'b'

        transformer.add(transformerA)
        transformer.add(transformerB)

        expect:
        transformer.transform('original') == 'b'

    }

    def 'can use a Closure as a Transformer'() {
        when:

        when:
        fails ":resolve"

        then:
        failure.assertHasCause("Failed to transform bad-b.jar to match attributes {artifactType=size}")
        failure.assertHasCause("Failed to transform bad-c.jar to match attributes {artifactType=size}")
    }

    def "only one transformer execution per workspace"() {

        createDirs("lib", "app1", "app2")
        settingsFile << """

            configHashFor(classpathElementTransformFactory, transform, gradleCoreInstrumentationTypeRegistry),
            classpathFileHasher);
        this.classpathElementTransformFactory = classpathElementTransformFactory;
        this.transform = transform;
    }