*/
package org.apache.maven.model.building;

import java.nio.file.Path;

import org.apache.maven.model.Model;

/**
 * The ModelSourceTransformer is a way to transform the local pom while streaming the input.
 *
 * The {@link #transform(Path, TransformerContext, Model)} method uses a Path on purpose, to ensure the
 * local pom is the original source.
 *
 * @since 4.0.0
 */
public interface ModelSourceTransformer {

        where:
        type << TESTED_CONSOLE_TYPES
    }

    def "progress display name is 'Transforming' for top level transforms"() {
        // Build scan plugin filters artifact transform logging by the name of the progress display name
        // since that is the only way it currently can distinguish transforms.
        // When it has a better way, then this test can be removed.
        consoleType = ConsoleOutput.Rich

// tag::artifact-transform-countloc[]
abstract class CountLoc : TransformAction<TransformParameters.None> {

    @get:Inject                                                         // <1>
    abstract val inputChanges: InputChanges

    @get:PathSensitive(PathSensitivity.RELATIVE)
    @get:InputArtifact
    abstract val input: Provider<FileSystemLocation>

    override

    def "converts relative path"() {
        expect:
        resolver.transform("some-file") == baseDir.file("some-file")
        resolver.transform("../other-file") == baseDir.file("../other-file")
        resolver.transform(".") == baseDir
    }

    def "converts absolute path"() {
        def target = tmpDir.file("some-file")

        expect:
        resolver.transform(target.absolutePath) == target
    }

 * under the License.
 */
package org.apache.maven.artifact.transform;

import javax.inject.Inject;

import java.util.List;

import org.apache.maven.repository.legacy.resolver.transform.ArtifactTransformation;
import org.apache.maven.repository.legacy.resolver.transform.ArtifactTransformationManager;
import org.apache.maven.repository.legacy.resolver.transform.LatestArtifactTransformation;

import org.codehaus.groovy.reflection.CachedClass;

/**
 * Potentially transforms arguments to call a method with.
 */
public interface MethodArgumentsTransformer {

    /**
     * Transforms an argument list to call a method with.
     *
     * May return {@code args} if no transform is necessary.
     */
    Object[] transform(CachedClass[] types, Object[] args);

    /*

 */

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

import com.google.common.io.Files;
import org.apache.commons.io.IOUtils;
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;

                    return "Transformer with $provider"
                }
            }
            transform.provider = new FlatMapProvider(Providers.of("value"), transform)
            return transform.provider
        }
    }

    static class FlatMapProviderCircularChainEvaluationTest extends CircularChainEvaluationSpec<String> implements UsesStringProperty {
        @Override

// license that can be found in the LICENSE file.

package cases

import "golang.org/x/text/transform"

type caseFolder struct{ transform.NopResetter }

// caseFolder implements the Transformer interface for doing case folding.
func (t *caseFolder) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
	c := context{dst: dst, src: src, atEOF: atEOF}
	for c.next() {
		foldFull(&c)

     *
     * @param problem the problem to transform
     * @param id the operation id associated with the problem
     * @return the transformed problem
     */
    Problem transform(Problem problem, OperationIdentifier id);