org.gradle.api.internaltransform.TransformationStep Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of gradle-api Show documentation
Show all versions of gradle-api Show documentation
Gradle 6.8 API redistribution.
/*
* Copyright 2017 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.gradle.api.internal.artifacts.transform;
import com.google.common.base.Equivalence;
import com.google.common.collect.ImmutableList;
import org.gradle.api.Action;
import org.gradle.api.internal.DomainObjectContext;
import org.gradle.api.internal.attributes.ImmutableAttributes;
import org.gradle.api.internal.project.ProjectInternal;
import org.gradle.api.internal.tasks.NodeExecutionContext;
import org.gradle.api.internal.tasks.TaskDependencyContainer;
import org.gradle.api.internal.tasks.TaskDependencyResolveContext;
import org.gradle.internal.Try;
import org.gradle.internal.fingerprint.FileCollectionFingerprinterRegistry;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.annotation.Nullable;
import java.io.File;
/**
* A single transformation step.
*
* Transforms a subject by invoking a transformer on each of the subjects files.
*/
public class TransformationStep implements Transformation, TaskDependencyContainer {
private static final Logger LOGGER = LoggerFactory.getLogger(TransformationStep.class);
public static final Equivalence FOR_SCHEDULING = Equivalence.identity();
private final Transformer transformer;
private final TransformerInvocationFactory transformerInvocationFactory;
private final ProjectInternal owningProject;
private final FileCollectionFingerprinterRegistry globalFingerprinterRegistry;
public TransformationStep(Transformer transformer, TransformerInvocationFactory transformerInvocationFactory, DomainObjectContext owner, FileCollectionFingerprinterRegistry globalFingerprinterRegistry) {
this.transformer = transformer;
this.transformerInvocationFactory = transformerInvocationFactory;
this.globalFingerprinterRegistry = globalFingerprinterRegistry;
this.owningProject = owner.getProject();
}
public Transformer getTransformer() {
return transformer;
}
@Nullable
public ProjectInternal getOwningProject() {
return owningProject;
}
@Override
public boolean endsWith(Transformation otherTransform) {
return this == otherTransform;
}
@Override
public int stepsCount() {
return 1;
}
public CacheableInvocation createInvocation(TransformationSubject subjectToTransform, TransformUpstreamDependencies upstreamDependencies, @Nullable NodeExecutionContext context) {
if (LOGGER.isInfoEnabled()) {
LOGGER.info("Transforming {} with {}", subjectToTransform.getDisplayName(), transformer.getDisplayName());
}
FileCollectionFingerprinterRegistry fingerprinterRegistry = context != null ? context.getService(FileCollectionFingerprinterRegistry.class) : globalFingerprinterRegistry;
Try resolvedDependencies = upstreamDependencies.computeArtifacts();
return resolvedDependencies
.map(dependencies -> {
ImmutableList inputArtifacts = subjectToTransform.getFiles();
if (inputArtifacts.isEmpty()) {
return CacheableInvocation.cached(Try.successful(subjectToTransform.createSubjectFromResult(ImmutableList.of())));
} else if (inputArtifacts.size() > 1) {
return CacheableInvocation.nonCached(() ->
doTransform(subjectToTransform, fingerprinterRegistry, dependencies, inputArtifacts)
);
} else {
File inputArtifact = inputArtifacts.get(0);
return transformerInvocationFactory.createInvocation(transformer, inputArtifact, dependencies, subjectToTransform, fingerprinterRegistry)
.map(subjectToTransform::createSubjectFromResult);
}
})
.getOrMapFailure(failure -> CacheableInvocation.cached(Try.failure(failure)));
}
private Try doTransform(TransformationSubject subjectToTransform, FileCollectionFingerprinterRegistry fingerprinterRegistry, ArtifactTransformDependencies dependencies, ImmutableList inputArtifacts) {
ImmutableList.Builder builder = ImmutableList.builder();
for (File inputArtifact : inputArtifacts) {
Try> result = transformerInvocationFactory.createInvocation(transformer, inputArtifact, dependencies, subjectToTransform, fingerprinterRegistry).invoke();
if (result.getFailure().isPresent()) {
return Try.failure(result.getFailure().get());
}
builder.addAll(result.get());
}
return Try.successful(subjectToTransform.createSubjectFromResult(builder.build()));
}
public void isolateParametersIfNotAlready() {
transformer.isolateParametersIfNotAlready();
}
@Override
public boolean requiresDependencies() {
return transformer.requiresDependencies();
}
@Override
public String getDisplayName() {
return transformer.getDisplayName();
}
@Override
public void visitTransformationSteps(Action action) {
action.execute(this);
}
public ImmutableAttributes getFromAttributes() {
return transformer.getFromAttributes();
}
@Override
public String toString() {
return transformer.getDisplayName();
}
@Override
public void visitDependencies(TaskDependencyResolveContext context) {
transformer.visitDependencies(context);
}
}