Update task to sanity check links in release notes and samples + Cloudflare redirects (#31491)
diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index 5e693dd..9e40988 100644
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -1,6 +1,6 @@
distributionBase=GRADLE_USER_HOME
distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions-snapshots/gradle-8.12-20241126002544+0000-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.12-rc-1-bin.zip
networkTimeout=10000
validateDistributionUrl=true
zipStoreBase=GRADLE_USER_HOME
diff --git a/gradlew b/gradlew
index d95bf61..057afac 100755
--- a/gradlew
+++ b/gradlew
@@ -86,8 +86,7 @@
# shellcheck disable=SC2034
APP_BASE_NAME=${0##*/}
# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
-APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s
-' "$PWD" ) || exit
+APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s\n' "$PWD" ) || exit
# Use the maximum available, or set MAX_FD != -1 to use that value.
MAX_FD=maximum
diff --git a/platforms/core-configuration/model-core/src/main/java/org/gradle/api/internal/provider/AbstractCollectionProperty.java b/platforms/core-configuration/model-core/src/main/java/org/gradle/api/internal/provider/AbstractCollectionProperty.java
index 649524c..444ad2b 100644
--- a/platforms/core-configuration/model-core/src/main/java/org/gradle/api/internal/provider/AbstractCollectionProperty.java
+++ b/platforms/core-configuration/model-core/src/main/java/org/gradle/api/internal/provider/AbstractCollectionProperty.java
@@ -19,16 +19,20 @@
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableCollection;
import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Lists;
import org.gradle.api.Action;
+import org.gradle.api.Task;
import org.gradle.api.Transformer;
import org.gradle.api.internal.provider.Collectors.ElementFromProvider;
import org.gradle.api.internal.provider.Collectors.ElementsFromArray;
import org.gradle.api.internal.provider.Collectors.ElementsFromCollection;
import org.gradle.api.internal.provider.Collectors.ElementsFromCollectionProvider;
import org.gradle.api.internal.provider.Collectors.SingleElement;
+import org.gradle.api.internal.tasks.TaskDependencyResolveContext;
import org.gradle.api.provider.HasMultipleValues;
import org.gradle.api.provider.Provider;
import org.gradle.internal.Cast;
+import org.gradle.internal.Pair;
import org.gradle.internal.evaluation.EvaluationScopeContext;
import javax.annotation.Nonnull;
@@ -38,14 +42,18 @@
import java.util.List;
import java.util.Locale;
import java.util.function.Supplier;
+import java.util.stream.Stream;
+
+import static java.util.stream.Collectors.toCollection;
+import static java.util.stream.Collectors.toList;
/**
* The base class for collection properties.
* <p>
- * Value suppliers for collection properties are implementations of {@link CollectionSupplier}.
+ * Value suppliers for collection properties are implementations of {@link CollectionSupplier}.
* </p>
* <p>
- * Elements stored in collection property values are implemented via various implementations of {@link Collector}.
+ * Elements stored in collection property values are implemented via various implementations of {@link Collector}.
* </p>
* <h2>Collection suppliers</h2>
* The value of a collection property is represented at any time as an instance of an implementation of {@link CollectionSupplier}, namely:
@@ -70,8 +78,8 @@
* <li>{@link ElementsFromCollection} to represent a batch of elements added (or set wholesale) as an <code>Iterable</code>
* <li>{@link ElementsFromCollectionProvider} to represent a batch of elements added (or set wholesale) as a provider of <code>Iterable</code>
* </ul>
- * <p>Also, if a collection is built up via multiple additions, which is quite common, after each addition operation, its value will be represented via a new {@link PlusCollector} instance
- * that references the previous value as the {@link PlusCollector#left left side}, and the added element(s) as {@link PlusCollector#right right side} of the operation.
+ * <p>Also, if a collection is built up via multiple additions, which is quite common, after each addition operation, its value will be represented via a new {@link CollectionSupplier} instance.
+ * Each addition operation adds an individual collector to the shared underlying append-only list of collectors.
* </p>
*
* @param <T> the type of element this collection property can hold
@@ -210,14 +218,14 @@ public int size() {
*/
private void addExplicitCollector(Collector<T> collector, boolean ignoreAbsent) {
assertCanMutate();
- CollectionSupplier<T, C> explicitValue = getExplicitValue(defaultValue).absentIgnoringIfNeeded(ignoreAbsent);
- setSupplier(explicitValue.plus(collector.absentIgnoringIfNeeded(ignoreAbsent)));
+ CollectionSupplier<T, C> explicitValue = getExplicitValue(defaultValue);
+ setSupplier(explicitValue.plus(collector, ignoreAbsent));
}
- @Nullable
@Override
+ @Nonnull
public Class<C> getType() {
- return Cast.uncheckedCast(collectionType);
+ return Cast.uncheckedNonnullCast(collectionType);
}
@Override
@@ -234,8 +242,8 @@ public void fromState(ExecutionTimeValue<? extends C> value) {
} else if (value.hasFixedValue()) {
setSupplier(new FixedSupplier(value.getFixedValue(), Cast.uncheckedCast(value.getSideEffect())));
} else {
- CollectingProvider<T, C> asCollectingProvider = Cast.uncheckedNonnullCast(value.getChangingValue());
- setSupplier(new CollectingSupplier(new ElementsFromCollectionProvider<>(asCollectingProvider)));
+ CollectingSupplier<T, C> asSupplier = Cast.uncheckedNonnullCast(value.getChangingValue());
+ setSupplier(asSupplier);
}
}
@@ -256,7 +264,7 @@ public void set(@Nullable final Iterable<? extends T> elements) {
if (elements == null) {
unsetValueAndDefault();
} else {
- setSupplier(new CollectingSupplier(new ElementsFromCollection<>(elements)));
+ setSupplier(newSupplierOf(new ElementsFromCollection<>(elements)));
}
}
@@ -275,7 +283,7 @@ public void set(final Provider<? extends Iterable<? extends T>> provider) {
throw new IllegalArgumentException(String.format("Cannot set the value of a property of type %s with element type %s using a provider with element type %s.", collectionType.getName(), elementType.getName(), collectionProp.getElementType().getName()));
}
}
- setSupplier(new CollectingSupplier(new ElementsFromCollectionProvider<>(p)));
+ setSupplier(newSupplierOf(new ElementsFromCollectionProvider<>(p)));
}
private void unsetValueAndDefault() {
@@ -329,14 +337,14 @@ public HasMultipleValues<T> convention(@Nullable Iterable<? extends T> elements)
if (elements == null) {
unsetConvention();
} else {
- setConvention(new CollectingSupplier(new ElementsFromCollection<>(elements)));
+ setConvention(newSupplierOf(new ElementsFromCollection<>(elements)));
}
return this;
}
@Override
public HasMultipleValues<T> convention(Provider<? extends Iterable<? extends T>> provider) {
- setConvention(new CollectingSupplier(new ElementsFromCollectionProvider<>(Providers.internal(provider))));
+ setConvention(newSupplierOf(new ElementsFromCollectionProvider<>(Providers.internal(provider))));
return this;
}
@@ -355,11 +363,6 @@ public NoValueSupplier(Value<? extends C> value) {
}
@Override
- public CollectionSupplier<T, C> absentIgnoring() {
- return Cast.uncheckedCast(emptySupplier());
- }
-
- @Override
public boolean calculatePresence(ValueConsumer consumer) {
return false;
}
@@ -370,9 +373,9 @@ public Value<? extends C> calculateValue(ValueConsumer consumer) {
}
@Override
- public CollectionSupplier<T, C> plus(Collector<T> collector) {
- // No value + something = no value
- return this;
+ public CollectionSupplier<T, C> plus(Collector<T> collector, boolean ignoreAbsent) {
+ // No value + something = no value, unless we ignoreAbsent.
+ return ignoreAbsent ? newSupplierOf(ignoreAbsentIfNeeded(collector, ignoreAbsent)) : this;
}
@Override
@@ -404,14 +407,9 @@ public Value<? extends C> calculateValue(ValueConsumer consumer) {
}
@Override
- public CollectionSupplier<T, C> plus(Collector<T> collector) {
+ public CollectionSupplier<T, C> plus(Collector<T> collector, boolean ignoreAbsent) {
// empty + something = something
- return new CollectingSupplier(collector);
- }
-
- @Override
- public CollectionSupplier<T, C> absentIgnoring() {
- return this;
+ return newSupplierOf(ignoreAbsentIfNeeded(collector, ignoreAbsent));
}
@Override
@@ -440,11 +438,6 @@ public FixedSupplier(C value, @Nullable SideEffect<? super C> sideEffect) {
}
@Override
- public CollectionSupplier<T, C> absentIgnoring() {
- return this;
- }
-
- @Override
public boolean calculatePresence(ValueConsumer consumer) {
return true;
}
@@ -455,10 +448,8 @@ public Value<? extends C> calculateValue(ValueConsumer consumer) {
}
@Override
- public CollectionSupplier<T, C> plus(Collector<T> collector) {
- Collector<T> left = new FixedValueCollector<>(value, sideEffect);
- PlusCollector<T> newCollector = new PlusCollector<>(left, collector);
- return new CollectingSupplier(newCollector);
+ public CollectionSupplier<T, C> plus(Collector<T> collector, boolean ignoreAbsent) {
+ return newSupplierOf(new FixedValueCollector<>(value, sideEffect)).plus(collector, ignoreAbsent);
}
@Override
@@ -477,58 +468,128 @@ public String toString() {
}
}
- private class CollectingSupplier implements CollectionSupplier<T, C> {
- private final Collector<T> value;
- // TODO-RC: can we get rid of this? Can we only keep this in Collectors? Changing execution time value is the only case that needs this.
- private final boolean ignoreAbsent;
+ private CollectingSupplier<T, C> newSupplierOf(Collector<T> value) {
+ return new CollectingSupplier<>(getType(), collectionFactory, valueCollector, value);
+ }
- public CollectingSupplier(Collector<T> value, boolean ignoreAbsent) {
- this.value = value;
- this.ignoreAbsent = ignoreAbsent;
+ private static class CollectingSupplier<T, C extends Collection<T>> extends AbstractMinimalProvider<C> implements CollectionSupplier<T, C> {
+ private final Class<C> type;
+ private final Supplier<ImmutableCollection.Builder<T>> collectionFactory;
+ private final ValueCollector<T> valueCollector;
+ // This list is shared by the collectors produced by `plus`, so we don't have to copy the collectors every time.
+ // However, this also means that you can only call plus on a given collector once.
+ private final ArrayList<Collector<T>> collectors; // TODO - Replace with PersistentList? This may make value calculation inefficient because the PersistentList can only prepend to head.
+ private final int size;
+
+ public CollectingSupplier(Class<C> type, Supplier<ImmutableCollection.Builder<T>> collectionFactory, ValueCollector<T> valueCollector, Collector<T> value) {
+ this(type, collectionFactory, valueCollector, Lists.newArrayList(value), 1);
}
- public CollectingSupplier(Collector<T> value) {
- this(value, false);
+ // A constructor for sharing.
+ private CollectingSupplier(
+ Class<C> type,
+ Supplier<ImmutableCollection.Builder<T>> collectionFactory,
+ ValueCollector<T> valueCollector,
+ @SuppressWarnings("NonApiType") ArrayList<Collector<T>> collectors,
+ int size
+ ) {
+ this.type = type;
+ this.collectionFactory = collectionFactory;
+ this.valueCollector = valueCollector;
+ this.collectors = collectors;
+ this.size = size;
+ }
+
+ @Override
+ protected Value<? extends C> calculateOwnValue(ValueConsumer consumer) {
+ return calculateValue(consumer);
+ }
+
+ @Nullable
+ @Override
+ public Class<C> getType() {
+ return type;
}
@Override
public boolean calculatePresence(ValueConsumer consumer) {
- return value.calculatePresence(consumer);
+ // We're traversing the elements in reverse addition order.
+ // When determining the presence of the value, the last argument wins.
+ // See also #collectExecutionTimeValues().
+ for (Collector<T> collector : Lists.reverse(getCollectors())) {
+ if (!collector.calculatePresence(consumer)) {
+ // We've found an argument of add/addAll that is missing.
+ // It makes the property missing regardless of what has been added before.
+ // Because of the reverse processing order, anything that was added after it was just add/addAll that do not change the presence.
+ return false;
+ }
+ if (isAbsentIgnoring(collector)) {
+ // We've found an argument of append/appendAll, and everything added before it was present.
+ // append/appendAll recovers the value of a missing property, so the property is also definitely present.
+ return true;
+ }
+ }
+ // Nothing caused the property to become missing. There is at least one element by design, so the property is present.
+ assert size > 0;
+ return true;
}
@Override
public Value<C> calculateValue(ValueConsumer consumer) {
// TODO - don't make a copy when the collector already produces an immutable collection
ImmutableCollection.Builder<T> builder = collectionFactory.get();
- Value<Void> result = value.collectEntries(consumer, valueCollector, builder);
- if (result.isMissing()) {
- return result.asType();
+ Value<Void> compositeResult = Value.present();
+ for (Collector<T> collector : getCollectors()) {
+ if (compositeResult.isMissing() && !isAbsentIgnoring(collector)) {
+ // The property is missing so far and the argument is of add/addAll.
+ // The property is going to be missing regardless of its value.
+ continue;
+ }
+ Value<Void> result = collector.collectEntries(consumer, valueCollector, builder);
+ if (result.isMissing()) {
+ // This is the argument of add/addAll and it is missing. It "poisons" the property (it becomes missing).
+ // We discard all values and side effects gathered so far.
+ builder = collectionFactory.get();
+ compositeResult = result;
+ } else if (compositeResult.isMissing()) {
+ assert isAbsentIgnoring(collector);
+ // This is an argument of append/appendAll. It "recovers" the property from the "poisoned" state.
+ // Entries are already in the builder.
+ compositeResult = result;
+ } else {
+ assert !compositeResult.isMissing();
+ // Both the property so far and the current argument are present, just continue building the value.
+ // Entries are already in the builder.
+ compositeResult = compositeResult.withSideEffect(SideEffect.fixedFrom(result));
+ }
}
- return Value.of(Cast.<C>uncheckedNonnullCast(builder.build())).withSideEffect(SideEffect.fixedFrom(result));
+ if (compositeResult.isMissing()) {
+ return compositeResult.asType();
+ }
+ return Value.of(Cast.<C>uncheckedNonnullCast(builder.build())).withSideEffect(SideEffect.fixedFrom(compositeResult));
}
@Override
- public CollectionSupplier<T, C> plus(Collector<T> addedCollector) {
- Collector<T> left = value.absentIgnoringIfNeeded(ignoreAbsent);
- Collector<T> right = addedCollector;
- PlusCollector<T> newCollector = new PlusCollector<>(left, right);
- return new CollectingSupplier(newCollector);
- }
-
- @Override
- public CollectionSupplier<T, C> absentIgnoring() {
- return ignoreAbsent ? this : new CollectingSupplier(value, true);
+ public CollectionSupplier<T, C> plus(Collector<T> addedCollector, boolean ignoreAbsent) {
+ Preconditions.checkState(collectors.size() == size, "Something has been appended to this collector already");
+ collectors.add(ignoreAbsentIfNeeded(addedCollector, ignoreAbsent));
+ return new CollectingSupplier<>(type, collectionFactory, valueCollector, collectors, size + 1);
}
@Override
public ExecutionTimeValue<? extends C> calculateExecutionTimeValue() {
- List<ExecutionTimeValue<? extends Iterable<? extends T>>> values = collectExecutionTimeValues();
+ List<Pair<Collector<T>, ExecutionTimeValue<? extends Iterable<? extends T>>>> collectorsWithValues = collectExecutionTimeValues();
+ if (collectorsWithValues.isEmpty()) {
+ return ExecutionTimeValue.missing();
+ }
+ List<ExecutionTimeValue<? extends Iterable<? extends T>>> values = collectorsWithValues.stream().map(Pair::getRight).collect(toList());
+
boolean fixed = true;
boolean changingContent = false;
+
for (ExecutionTimeValue<? extends Iterable<? extends T>> value : values) {
- if (value.isMissing()) {
- return ExecutionTimeValue.missing();
- }
+ assert !value.isMissing();
+
if (value.isChangingValue()) {
fixed = false;
} else if (value.hasChangingContent()) {
@@ -540,20 +601,66 @@ public ExecutionTimeValue<? extends C> calculateExecutionTimeValue() {
return getFixedExecutionTimeValue(values, changingContent);
}
- // At least one of the values is a changing value
- List<ProviderInternal<? extends Iterable<? extends T>>> providers = new ArrayList<>(values.size());
- for (ExecutionTimeValue<? extends Iterable<? extends T>> value : values) {
- providers.add(value.toProvider());
- }
- // TODO - CollectionSupplier could be replaced with ProviderInternal, so this type and the collection provider can be merged
- return ExecutionTimeValue.changingValue(new CollectingProvider<>(AbstractCollectionProperty.this.getType(), providers, collectionFactory));
+ // At least one of the values is a changing value. Simplify the provider.
+ return ExecutionTimeValue.changingValue(
+ new CollectingSupplier<>(
+ type,
+ collectionFactory,
+ valueCollector,
+ collectorsWithValues.stream().map(pair -> {
+ Collector<T> elements = toCollector(pair.getRight());
+ return ignoreAbsentIfNeeded(elements, isAbsentIgnoring(pair.getLeft()));
+ }).collect(toCollection(ArrayList::new)),
+ collectorsWithValues.size()
+ )
+ );
}
- @Nonnull
- private List<ExecutionTimeValue<? extends Iterable<? extends T>>> collectExecutionTimeValues() {
- List<ExecutionTimeValue<? extends Iterable<? extends T>>> values = new ArrayList<>();
- value.calculateExecutionTimeValue(values::add);
- return values;
+ private Collector<T> toCollector(ExecutionTimeValue<? extends Iterable<? extends T>> value) {
+ Preconditions.checkArgument(!value.isMissing(), "Cannot get a collector for the missing value");
+ if (value.isChangingValue() || value.hasChangingContent() || value.getSideEffect() != null) {
+ return new ElementsFromCollectionProvider<>(value.toProvider());
+ }
+ return new ElementsFromCollection<>(value.getFixedValue());
+ }
+
+ private List<Collector<T>> getCollectors() {
+ return collectors.subList(0, size);
+ }
+
+ // Returns an empty list when the overall value is missing.
+ private List<Pair<Collector<T>, ExecutionTimeValue<? extends Iterable<? extends T>>>> collectExecutionTimeValues() {
+ // These are the values that are certainly part of the result, e.g. because of absent-ignoring append/appendAll argument.
+ List<Pair<Collector<T>, ExecutionTimeValue<? extends Iterable<? extends T>>>> executionTimeValues = new ArrayList<>();
+ // These are the values that may become part of the result if there is no missing value somewhere.
+ List<Pair<Collector<T>, ExecutionTimeValue<? extends Iterable<? extends T>>>> candidates = new ArrayList<>();
+
+ // We traverse the collectors backwards (in reverse addition order) to simplify the logic and avoid processing things that are going to be discarded.
+ // Because of that, values are collected in reverse order too.
+ // Se also #calculatePresence.
+ for (Collector<T> collector : Lists.reverse(getCollectors())) {
+ ExecutionTimeValue<? extends Iterable<? extends T>> result = collector.calculateExecutionTimeValue();
+ if (result.isMissing()) {
+ // This is an add/addAll argument, but it is a missing provider.
+ // Everything that was added before it isn't going to affect the result, so we stop the iteration.
+ // All add/addAll that happened after it (thus already processed) but before any append/appendAll - the contents of candidates - are also discarded.
+ return Lists.reverse(executionTimeValues);
+ }
+ if (isAbsentIgnoring(collector)) {
+ // This is an argument of append/appendAll. With it the property is going to be present (though maybe empty).
+ // As all add/addAll arguments we've processed (thus added after this one) so far weren't missing, we're sure they'll be part of the final property's value.
+ // Move them to the executionTimeValues.
+ executionTimeValues.addAll(candidates);
+ executionTimeValues.add(Pair.of(collector, result));
+ candidates.clear();
+ } else {
+ // This is an argument of add/addAll that isn't definitely missing. It might be part of the final value.
+ candidates.add(Pair.of(collector, result));
+ }
+ }
+ // No missing values found, so all the candidates are part of the final value.
+ executionTimeValues.addAll(candidates);
+ return Lists.reverse(executionTimeValues);
}
private ExecutionTimeValue<C> getFixedExecutionTimeValue(List<ExecutionTimeValue<? extends Iterable<? extends T>>> values, boolean changingContent) {
@@ -572,57 +679,45 @@ private ExecutionTimeValue<C> getFixedExecutionTimeValue(List<ExecutionTimeValue
return mergedValue.withSideEffect(sideEffectBuilder.build());
}
+ private Stream<ValueProducer> getProducers() {
+ return collectors.stream().map(ValueSupplier::getProducer);
+ }
+
@Override
public ValueProducer getProducer() {
- return value.getProducer();
- }
-
- @Override
- public String toString() {
- return value.toString();
- }
- }
-
- /**
- * A provider for a collection type whose elements are themselves providers.
- */
- private static class CollectingProvider<T, C extends Collection<? extends T>> extends AbstractMinimalProvider<C> {
- private final Class<C> type;
- private final List<ProviderInternal<? extends Iterable<? extends T>>> providers;
- private final Supplier<ImmutableCollection.Builder<T>> collectionFactory;
-
- public CollectingProvider(Class<C> type, List<ProviderInternal<? extends Iterable<? extends T>>> providers, Supplier<ImmutableCollection.Builder<T>> collectionFactory) {
- this.type = type;
- this.providers = providers;
- this.collectionFactory = collectionFactory;
- }
-
- @Nullable
- @Override
- public Class<C> getType() {
- return type;
- }
-
- @Override
- public ExecutionTimeValue<? extends C> calculateExecutionTimeValue() {
- return ExecutionTimeValue.changingValue(this);
- }
-
- @Override
- protected Value<? extends C> calculateOwnValue(ValueConsumer consumer) {
- ImmutableCollection.Builder<T> builder = collectionFactory.get();
- SideEffectBuilder<? super C> sideEffectBuilder = SideEffect.builder();
- for (ProviderInternal<? extends Iterable<? extends T>> provider : providers) {
- Value<? extends Iterable<? extends T>> value = provider.calculateValue(consumer);
- if (value.isMissing()) {
- return Value.missing();
+ return new ValueProducer() {
+ @Override
+ public void visitProducerTasks(Action<? super Task> visitor) {
+ getProducers().forEach(c -> c.visitProducerTasks(visitor));
}
- builder.addAll(value.getWithoutSideEffect());
- sideEffectBuilder.add(SideEffect.fixedFrom(value));
- }
- Value<? extends C> resultValue = Value.of(Cast.uncheckedNonnullCast(builder.build()));
- return resultValue.withSideEffect(sideEffectBuilder.build());
+ @Override
+ public boolean isKnown() {
+ return getProducers().anyMatch(ValueProducer::isKnown);
+ }
+
+ @Override
+ public void visitDependencies(TaskDependencyResolveContext context) {
+ getProducers().forEach(c -> c.visitDependencies(context));
+ }
+
+ @Override
+ public void visitContentProducerTasks(Action<? super Task> visitor) {
+ getProducers().forEach(c -> c.visitContentProducerTasks(visitor));
+ }
+ };
+ }
+
+ @Override
+ protected String toStringNoReentrance() {
+ StringBuilder sb = new StringBuilder();
+ getCollectors().forEach(collector -> {
+ if (sb.length() > 0) {
+ sb.append(" + ");
+ }
+ sb.append(collector.toString());
+ });
+ return sb.toString();
}
}
@@ -653,14 +748,8 @@ public int size() {
}
@Override
- public void calculateExecutionTimeValue(Action<? super ExecutionTimeValue<? extends Iterable<? extends T>>> visitor) {
- visitor.execute(ExecutionTimeValue.fixedValue(collection).withSideEffect(sideEffect));
- }
-
- @Override
- public Collector<T> absentIgnoring() {
- // always present
- return this;
+ public ExecutionTimeValue<? extends Iterable<? extends T>> calculateExecutionTimeValue() {
+ return ExecutionTimeValue.fixedValue(collection).withSideEffect(sideEffect);
}
@Override
@@ -679,79 +768,44 @@ public String toString() {
}
}
- private static abstract class AbstractPlusCollector<T> implements Collector<T> {
- protected final Collector<T> left;
- protected final Collector<T> right;
-
- private AbstractPlusCollector(Collector<T> left, Collector<T> right) {
- this.left = left;
- this.right = right;
- }
-
- @Override
- public int size() {
- return left.size() + right.size();
- }
-
- @Override
- public ValueProducer getProducer() {
- return left.getProducer().plus(right.getProducer());
- }
-
- @Override
- public String toString() {
- return left + " + " + right;
- }
-
+ private static boolean isAbsentIgnoring(Collector<?> collector) {
+ return collector instanceof AbsentIgnoringCollector<?>;
}
- private static class PlusCollector<T> extends AbstractPlusCollector<T> {
-
- public PlusCollector(Collector<T> left, Collector<T> right) {
- super(left, right);
+ private static <T> Collector<T> ignoreAbsentIfNeeded(Collector<T> collector, boolean ignoreAbsent) {
+ if (ignoreAbsent && !isAbsentIgnoring(collector)) {
+ return new AbsentIgnoringCollector<>(collector);
}
+ return collector;
+ }
- @Override
- public Collector<T> absentIgnoring() {
- return new AbsentIgnoringPlusCollector<>(left, right);
- }
+ private static class AbsentIgnoringCollector<T> implements Collector<T> {
+ private final Collector<T> delegate;
- @Override
- public boolean calculatePresence(ValueConsumer consumer) {
- return left.calculatePresence(consumer) && right.calculatePresence(consumer);
+ private AbsentIgnoringCollector(Collector<T> delegate) {
+ this.delegate = delegate;
}
@Override
public Value<Void> collectEntries(ValueConsumer consumer, ValueCollector<T> collector, ImmutableCollection.Builder<T> dest) {
- Value<Void> leftValue = left.collectEntries(consumer, collector, dest);
- if (leftValue.isMissing()) {
- return leftValue;
+ ImmutableList.Builder<T> candidateEntries = ImmutableList.builder();
+ Value<Void> value = delegate.collectEntries(consumer, collector, candidateEntries);
+ if (value.isMissing()) {
+ return Value.present();
}
- Value<Void> rightValue = right.collectEntries(consumer, collector, dest);
- if (rightValue.isMissing()) {
- return rightValue;
- }
-
- return Value.present()
- .withSideEffect(SideEffect.fixedFrom(leftValue))
- .withSideEffect(SideEffect.fixedFrom(rightValue));
+ dest.addAll(candidateEntries.build());
+ return Value.present().withSideEffect(SideEffect.fixedFrom(value));
}
@Override
- public void calculateExecutionTimeValue(Action<? super ExecutionTimeValue<? extends Iterable<? extends T>>> visitor) {
- left.calculateExecutionTimeValue(visitor);
- right.calculateExecutionTimeValue(visitor);
+ public int size() {
+ return delegate.size();
}
- }
- /**
- * A plus collector that either produces a composition of both of its left and right sides,
- * or Value.present() with empty content (if left or right side are missing).
- */
- private static class AbsentIgnoringPlusCollector<T> extends AbstractPlusCollector<T> {
-
- public AbsentIgnoringPlusCollector(Collector<T> left, Collector<T> right) {
- super(left, right);
+ @Override
+ public ExecutionTimeValue<? extends Iterable<? extends T>> calculateExecutionTimeValue() {
+ ExecutionTimeValue<? extends Iterable<? extends T>> executionTimeValue = delegate.calculateExecutionTimeValue();
+ return executionTimeValue.isMissing() ? ExecutionTimeValue.fixedValue(ImmutableList.of()) : executionTimeValue;
}
@Override
@@ -760,44 +814,8 @@ public boolean calculatePresence(ValueConsumer consumer) {
}
@Override
- public Collector<T> absentIgnoring() {
- return this;
- }
-
- @Override
- public Value<Void> collectEntries(ValueConsumer consumer, ValueCollector<T> collector, ImmutableCollection.Builder<T> dest) {
- ImmutableList.Builder<T> candidateEntries = ImmutableList.builder();
- // we cannot use dest directly because we don't want to emit any entries if either left or right are missing
- Value<Void> leftValue = left.collectEntries(consumer, collector, candidateEntries);
- if (leftValue.isMissing()) {
- return Value.present();
- }
- Value<Void> rightValue = right.collectEntries(consumer, collector, candidateEntries);
- if (rightValue.isMissing()) {
- return Value.present();
- }
- dest.addAll(candidateEntries.build());
- return Value.present()
- .withSideEffect(SideEffect.fixedFrom(leftValue))
- .withSideEffect(SideEffect.fixedFrom(rightValue));
- }
-
- @Override
- public void calculateExecutionTimeValue(Action<? super ExecutionTimeValue<? extends Iterable<? extends T>>> visitor) {
- boolean[] anyMissing = {false};
- ImmutableList.Builder<ExecutionTimeValue<? extends Iterable<? extends T>>> toVisit = ImmutableList.builder();
- Action<? super ExecutionTimeValue<? extends Iterable<? extends T>>> safeVisitor = value -> {
- if (value.isMissing()) {
- anyMissing[0] = true;
- } else {
- toVisit.add(value);
- }
- };
- left.calculateExecutionTimeValue(safeVisitor);
- right.calculateExecutionTimeValue(safeVisitor);
- if (!anyMissing[0]) {
- toVisit.build().forEach(it -> visitor.execute(it));
- }
+ public ValueProducer getProducer() {
+ return delegate.getProducer();
}
}
diff --git a/platforms/core-configuration/model-core/src/main/java/org/gradle/api/internal/provider/CollectionSupplier.java b/platforms/core-configuration/model-core/src/main/java/org/gradle/api/internal/provider/CollectionSupplier.java
index 2d93b16..2e5f95a1 100644
--- a/platforms/core-configuration/model-core/src/main/java/org/gradle/api/internal/provider/CollectionSupplier.java
+++ b/platforms/core-configuration/model-core/src/main/java/org/gradle/api/internal/provider/CollectionSupplier.java
@@ -37,24 +37,12 @@ interface CollectionSupplier<T, C extends Collection<? extends T>> extends Value
* elements supplied by the given collector.
*
* @param added a collector that represents an addition to the collection to be returned by this supplier
+ * @param ignoreAbsent if the resulting supplier should ignore absent value of this supplier or added one and fallback to empty collection
+ *
* @return a new supplier that produces a collection that contains the
* same elements as this supplier, plus the elements obtained via the given <code>added</code> collector
*/
- CollectionSupplier<T, C> plus(Collector<T> added);
+ CollectionSupplier<T, C> plus(Collector<T> added, boolean ignoreAbsent);
ExecutionTimeValue<? extends C> calculateExecutionTimeValue();
-
- /**
- * Returns a view of this supplier that will calculate its value as empty if it would be missing.
- * If this supplier already ignores absent results, returns this supplier.
- */
- CollectionSupplier<T, C> absentIgnoring();
-
- /**
- * Returns a view of this supplier that will calculate its value as empty if it would be missing,
- * if required. If not required, or this supplier already ignores absent results, returns this supplier.
- */
- default CollectionSupplier<T, C> absentIgnoringIfNeeded(boolean required) {
- return required ? absentIgnoring() : this;
- }
}
diff --git a/platforms/core-configuration/model-core/src/main/java/org/gradle/api/internal/provider/Collector.java b/platforms/core-configuration/model-core/src/main/java/org/gradle/api/internal/provider/Collector.java
index a3a3ca2..2be77f9 100644
--- a/platforms/core-configuration/model-core/src/main/java/org/gradle/api/internal/provider/Collector.java
+++ b/platforms/core-configuration/model-core/src/main/java/org/gradle/api/internal/provider/Collector.java
@@ -17,7 +17,6 @@
package org.gradle.api.internal.provider;
import com.google.common.collect.ImmutableCollection;
-import org.gradle.api.Action;
/**
@@ -31,18 +30,5 @@ public interface Collector<T> extends ValueSupplier {
int size();
- void calculateExecutionTimeValue(Action<? super ExecutionTimeValue<? extends Iterable<? extends T>>> visitor);
-
- /**
- * Returns a view of this collector that never returns a missing value.
- */
- Collector<T> absentIgnoring();
-
- /**
- * Convenience method that returns a view of this collector that never returns a missing value,
- * if that capability is required, or this very collector.
- */
- default Collector<T> absentIgnoringIfNeeded(boolean required) {
- return required ? absentIgnoring() : this;
- }
+ ExecutionTimeValue<? extends Iterable<? extends T>> calculateExecutionTimeValue();
}
diff --git a/platforms/core-configuration/model-core/src/main/java/org/gradle/api/internal/provider/Collectors.java b/platforms/core-configuration/model-core/src/main/java/org/gradle/api/internal/provider/Collectors.java
index 1539d83..8a58ad3 100644
--- a/platforms/core-configuration/model-core/src/main/java/org/gradle/api/internal/provider/Collectors.java
+++ b/platforms/core-configuration/model-core/src/main/java/org/gradle/api/internal/provider/Collectors.java
@@ -20,13 +20,9 @@
import com.google.common.collect.ImmutableCollection;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Iterables;
-import org.gradle.api.Action;
import org.gradle.api.provider.Provider;
-import org.gradle.internal.Cast;
-import javax.annotation.Nonnull;
import javax.annotation.Nullable;
-
import java.util.Arrays;
import static org.gradle.api.internal.lambdas.SerializableLambdas.transformer;
@@ -49,20 +45,14 @@ public boolean calculatePresence(ValueConsumer consumer) {
}
@Override
- public Collector<T> absentIgnoring() {
- // always present
- return this;
- }
-
- @Override
public Value<Void> collectEntries(ValueConsumer consumer, ValueCollector<T> collector, ImmutableCollection.Builder<T> collection) {
collector.add(element, collection);
return Value.present();
}
@Override
- public void calculateExecutionTimeValue(Action<? super ExecutionTimeValue<? extends Iterable<? extends T>>> visitor) {
- visitor.execute(ExecutionTimeValue.fixedValue(ImmutableList.of(element)));
+ public ExecutionTimeValue<? extends Iterable<? extends T>> calculateExecutionTimeValue() {
+ return ExecutionTimeValue.fixedValue(ImmutableList.of(element));
}
@Override
@@ -106,11 +96,6 @@ public ElementFromProvider(ProviderInternal<? extends T> provider) {
}
@Override
- public Collector<T> absentIgnoring() {
- return new ElementsFromCollectionProvider<>(provider.map(ImmutableList::of), true);
- }
-
- @Override
public boolean calculatePresence(ValueConsumer consumer) {
return provider.calculatePresence(consumer);
}
@@ -132,9 +117,9 @@ public boolean isProvidedBy(Provider<?> provider) {
}
@Override
- public void calculateExecutionTimeValue(Action<? super ExecutionTimeValue<? extends Iterable<? extends T>>> visitor) {
+ public ExecutionTimeValue<? extends Iterable<? extends T>> calculateExecutionTimeValue() {
ExecutionTimeValue<? extends T> value = provider.calculateExecutionTimeValue();
- visitValue(visitor, value);
+ return visitValue(value);
}
@Override
@@ -170,14 +155,14 @@ public String toString() {
}
}
- private static <T> void visitValue(Action<? super ValueSupplier.ExecutionTimeValue<? extends Iterable<? extends T>>> visitor, ValueSupplier.ExecutionTimeValue<? extends T> value) {
+ private static <T> ValueSupplier.ExecutionTimeValue<? extends Iterable<? extends T>> visitValue(ValueSupplier.ExecutionTimeValue<? extends T> value) {
if (value.isMissing()) {
- visitor.execute(ValueSupplier.ExecutionTimeValue.missing());
+ return ValueSupplier.ExecutionTimeValue.missing();
} else if (value.hasFixedValue()) {
// transform preserving side effects
- visitor.execute(ValueSupplier.ExecutionTimeValue.value(value.toValue().transform(ImmutableList::of)));
+ return ValueSupplier.ExecutionTimeValue.value(value.toValue().transform(ImmutableList::of));
} else {
- visitor.execute(ValueSupplier.ExecutionTimeValue.changingValue(value.getChangingValue().map(transformer(ImmutableList::of))));
+ return ValueSupplier.ExecutionTimeValue.changingValue(value.getChangingValue().map(transformer(ImmutableList::of)));
}
}
@@ -194,20 +179,14 @@ public boolean calculatePresence(ValueConsumer consumer) {
}
@Override
- public Collector<T> absentIgnoring() {
- // always present
- return this;
- }
-
- @Override
public Value<Void> collectEntries(ValueConsumer consumer, ValueCollector<T> collector, ImmutableCollection.Builder<T> collection) {
collector.addAll(value, collection);
return Value.present();
}
@Override
- public void calculateExecutionTimeValue(Action<? super ExecutionTimeValue<? extends Iterable<? extends T>>> visitor) {
- visitor.execute(ExecutionTimeValue.fixedValue(value));
+ public ExecutionTimeValue<? extends Iterable<? extends T>> calculateExecutionTimeValue() {
+ return ExecutionTimeValue.fixedValue(value);
}
@Override
@@ -249,30 +228,14 @@ public String toString() {
public static class ElementsFromCollectionProvider<T> implements ProvidedCollector<T> {
private final ProviderInternal<? extends Iterable<? extends T>> provider;
- private final boolean ignoreAbsent;
public ElementsFromCollectionProvider(ProviderInternal<? extends Iterable<? extends T>> provider) {
- this(provider, false);
- }
-
- private ElementsFromCollectionProvider(ProviderInternal<? extends Iterable<? extends T>> provider, boolean ignoreAbsent) {
- this.provider = ignoreAbsent ? neverMissing(Cast.uncheckedNonnullCast(provider)) : provider;
- this.ignoreAbsent = ignoreAbsent;
- }
-
- @Nonnull
- private static <T> ProviderInternal<? extends Iterable<? extends T>> neverMissing(ProviderInternal<Iterable<? extends T>> provider) {
- return Cast.uncheckedNonnullCast(provider.orElse(ImmutableList.of()));
- }
-
- @Override
- public Collector<T> absentIgnoring() {
- return ignoreAbsent ? this : new ElementsFromCollectionProvider<>(provider, true);
+ this.provider = provider;
}
@Override
public boolean calculatePresence(ValueConsumer consumer) {
- return ignoreAbsent || provider.calculatePresence(consumer);
+ return provider.calculatePresence(consumer);
}
@Override
@@ -283,7 +246,7 @@ public Value<Void> collectEntries(ValueConsumer consumer, ValueCollector<T> coll
private ValueSupplier.Value<Void> collectEntriesFromValue(ValueCollector<T> collector, ImmutableCollection.Builder<T> collection, ValueSupplier.Value<? extends Iterable<? extends T>> value) {
if (value.isMissing()) {
- return ignoreAbsent ? Value.present() : value.asType();
+ return value.asType();
}
collector.addAll(value.getWithoutSideEffect(), collection);
@@ -291,8 +254,8 @@ private ValueSupplier.Value<Void> collectEntriesFromValue(ValueCollector<T> coll
}
@Override
- public void calculateExecutionTimeValue(Action<? super ExecutionTimeValue<? extends Iterable<? extends T>>> visitor) {
- visitor.execute(provider.calculateExecutionTimeValue());
+ public ExecutionTimeValue<? extends Iterable<? extends T>> calculateExecutionTimeValue() {
+ return provider.calculateExecutionTimeValue();
}
@Override
@@ -350,12 +313,6 @@ public boolean calculatePresence(ValueConsumer consumer) {
}
@Override
- public Collector<T> absentIgnoring() {
- // always present
- return this;
- }
-
- @Override
public Value<Void> collectEntries(ValueConsumer consumer, ValueCollector<T> collector, ImmutableCollection.Builder<T> dest) {
for (T t : value) {
collector.add(t, dest);
@@ -364,8 +321,8 @@ public Value<Void> collectEntries(ValueConsumer consumer, ValueCollector<T> coll
}
@Override
- public void calculateExecutionTimeValue(Action<? super ExecutionTimeValue<? extends Iterable<? extends T>>> visitor) {
- visitor.execute(ExecutionTimeValue.fixedValue(ImmutableList.copyOf(value)));
+ public ExecutionTimeValue<? extends Iterable<? extends T>> calculateExecutionTimeValue() {
+ return ExecutionTimeValue.fixedValue(ImmutableList.copyOf(value));
}
@Override
@@ -401,11 +358,6 @@ public Class<? extends T> getType() {
}
@Override
- public Collector<T> absentIgnoring() {
- throw new UnsupportedOperationException();
- }
-
- @Override
public boolean calculatePresence(ValueConsumer consumer) {
return delegate.calculatePresence(consumer);
}
@@ -425,8 +377,8 @@ public boolean isProvidedBy(Provider<?> provider) {
}
@Override
- public void calculateExecutionTimeValue(Action<? super ExecutionTimeValue<? extends Iterable<? extends T>>> visitor) {
- delegate.calculateExecutionTimeValue(visitor);
+ public ExecutionTimeValue<? extends Iterable<? extends T>> calculateExecutionTimeValue() {
+ return delegate.calculateExecutionTimeValue();
}
@Override
diff --git a/platforms/core-configuration/model-core/src/main/java/org/gradle/api/internal/provider/DefaultMapProperty.java b/platforms/core-configuration/model-core/src/main/java/org/gradle/api/internal/provider/DefaultMapProperty.java
index 3e4a254..3bea175 100644
--- a/platforms/core-configuration/model-core/src/main/java/org/gradle/api/internal/provider/DefaultMapProperty.java
+++ b/platforms/core-configuration/model-core/src/main/java/org/gradle/api/internal/provider/DefaultMapProperty.java
@@ -18,37 +18,43 @@
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableCollection;
-import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Lists;
import org.gradle.api.Action;
+import org.gradle.api.Task;
import org.gradle.api.Transformer;
import org.gradle.api.internal.provider.MapCollectors.EntriesFromMap;
import org.gradle.api.internal.provider.MapCollectors.EntriesFromMapProvider;
import org.gradle.api.internal.provider.MapCollectors.EntryWithValueFromProvider;
import org.gradle.api.internal.provider.MapCollectors.SingleEntry;
+import org.gradle.api.internal.tasks.TaskDependencyResolveContext;
import org.gradle.api.provider.MapProperty;
import org.gradle.api.provider.Provider;
import org.gradle.internal.Cast;
+import org.gradle.internal.Pair;
import org.gradle.internal.evaluation.EvaluationScopeContext;
+import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
+import java.util.stream.Collectors;
+import static java.util.stream.Collectors.toList;
import static org.gradle.internal.Cast.uncheckedCast;
import static org.gradle.internal.Cast.uncheckedNonnullCast;
/**
* The implementation for {@link MapProperty}.
* <p>
- * Value suppliers for map properties are implementations of {@link MapSupplier}.
+ * Value suppliers for map properties are implementations of {@link MapSupplier}.
* </p>
* <p>
- * Increments to map property values are implementations of {@link MapCollector}.
+ * Increments to map property values are implementations of {@link MapCollector}.
* </p>
*
* This class mimics much of the behavior {@link AbstractCollectionProperty} provides for regular collections
@@ -162,13 +168,13 @@ public void set(@Nullable Map<? extends K, ? extends V> entries) {
if (entries == null) {
unsetValueAndDefault();
} else {
- setSupplier(new CollectingSupplier(new EntriesFromMap<>(entries), false));
+ setSupplier(newCollectingSupplierOf(new EntriesFromMap<>(entries)));
}
}
@Override
public void set(Provider<? extends Map<? extends K, ? extends V>> provider) {
- setSupplier(new CollectingSupplier(new MapCollectors.EntriesFromMapProvider<>(checkMapProvider(provider)), false));
+ setSupplier(newCollectingSupplierOf(new MapCollectors.EntriesFromMapProvider<>(checkMapProvider(provider))));
}
@Override
@@ -225,8 +231,8 @@ public void insertAll(Map<? extends K, ? extends V> entries) {
private void addExplicitCollector(MapCollector<K, V> collector, boolean ignoreAbsent) {
assertCanMutate();
- MapSupplier<K, V> explicitValue = getExplicitValue(defaultValue).absentIgnoringIfNeeded(ignoreAbsent);
- setSupplier(explicitValue.plus(collector.absentIgnoringIfNeeded(ignoreAbsent)));
+ MapSupplier<K, V> explicitValue = getExplicitValue(defaultValue);
+ setSupplier(explicitValue.plus(collector, ignoreAbsent));
}
private Configurer getConfigurer() {
@@ -278,14 +284,14 @@ public MapProperty<K, V> convention(@Nullable Map<? extends K, ? extends V> valu
if (value == null) {
setConvention(noValueSupplier());
} else {
- setConvention(new CollectingSupplier(new EntriesFromMap<>(value), false));
+ setConvention(newCollectingSupplierOf(new EntriesFromMap<>(value)));
}
return this;
}
@Override
public MapProperty<K, V> convention(Provider<? extends Map<? extends K, ? extends V>> valueProvider) {
- setConvention(new CollectingSupplier(new EntriesFromMapProvider<>(Providers.internal(valueProvider)), false));
+ setConvention(newCollectingSupplierOf(new EntriesFromMapProvider<>(Providers.internal(valueProvider))));
return this;
}
@@ -312,8 +318,8 @@ public void fromState(ExecutionTimeValue<? extends Map<? extends K, ? extends V>
} else if (value.hasFixedValue()) {
setSupplier(new FixedSupplier(uncheckedNonnullCast(value.getFixedValue()), uncheckedCast(value.getSideEffect())));
} else {
- CollectingProvider<K, V> asCollectingProvider = uncheckedNonnullCast(value.getChangingValue());
- setSupplier(new CollectingSupplier(new EntriesFromMapProvider<>(asCollectingProvider)));
+ CollectingSupplier<K, V> asCollectingProvider = uncheckedNonnullCast(value.getChangingValue());
+ setSupplier(asCollectingProvider);
}
}
@@ -408,11 +414,6 @@ public NoValueSupplier(Value<? extends Map<K, V>> value) {
}
@Override
- public MapSupplier<K, V> absentIgnoring() {
- return emptySupplier();
- }
-
- @Override
public boolean calculatePresence(ValueConsumer consumer) {
return false;
}
@@ -428,9 +429,9 @@ public Value<? extends Set<K>> calculateKeys(ValueConsumer consumer) {
}
@Override
- public MapSupplier<K, V> plus(MapCollector<K, V> collector) {
- // nothing + something = nothing
- return this;
+ public MapSupplier<K, V> plus(MapCollector<K, V> collector, boolean ignoreAbsent) {
+ // nothing + something = nothing, unless we ignoreAbsent.
+ return ignoreAbsent ? newCollectingSupplierOf(ignoreAbsentIfNeeded(collector, ignoreAbsent)) : this;
}
@Override
@@ -451,11 +452,6 @@ public String toString() {
private class EmptySupplier implements MapSupplier<K, V> {
@Override
- public MapSupplier<K, V> absentIgnoring() {
- return this;
- }
-
- @Override
public boolean calculatePresence(ValueConsumer consumer) {
return true;
}
@@ -471,9 +467,9 @@ public Value<? extends Set<K>> calculateKeys(ValueConsumer consumer) {
}
@Override
- public MapSupplier<K, V> plus(MapCollector<K, V> collector) {
+ public MapSupplier<K, V> plus(MapCollector<K, V> collector, boolean ignoreAbsent) {
// empty + something = something
- return new CollectingSupplier(collector);
+ return newCollectingSupplierOf(ignoreAbsentIfNeeded(collector, ignoreAbsent));
}
@Override
@@ -517,15 +513,8 @@ public Value<? extends Set<K>> calculateKeys(ValueConsumer consumer) {
}
@Override
- public MapSupplier<K, V> plus(MapCollector<K, V> collector) {
- MapCollector<K, V> left = new FixedValueCollector<>(entries, sideEffect);
- PlusCollector<K, V> newCollector = new PlusCollector<>(left, collector);
- return new CollectingSupplier(newCollector);
- }
-
- @Override
- public MapSupplier<K, V> absentIgnoring() {
- return this;
+ public MapSupplier<K, V> plus(MapCollector<K, V> collector, boolean ignoreAbsent) {
+ return newCollectingSupplierOf(new FixedValueCollector<>(entries, sideEffect)).plus(collector, ignoreAbsent);
}
@Override
@@ -544,39 +533,76 @@ public String toString() {
}
}
- private class CollectingSupplier implements MapSupplier<K, V> {
- private final MapCollector<K, V> collector;
- // TODO-RC: can we get rid of this? Can we only keep this in Collectors? Changing execution time value is the only case that needs this.
- private final boolean ignoreAbsent;
+ private CollectingSupplier<K, V> newCollectingSupplierOf(MapCollector<K, V> collector) {
+ return new CollectingSupplier<>(keyCollector, entryCollector, collector);
+ }
- public CollectingSupplier(MapCollector<K, V> collector, boolean ignoreAbsent) {
- this.collector = collector;
- this.ignoreAbsent = ignoreAbsent;
+ private static class CollectingSupplier<K, V> extends AbstractMinimalProvider<Map<K, V>> implements MapSupplier<K, V> {
+ private final ValueCollector<K> keyCollector;
+ private final MapEntryCollector<K, V> entryCollector;
+ private final List<MapCollector<K, V>> collectors;
+ private final int size;
+
+ public CollectingSupplier(ValueCollector<K> keyCollector, MapEntryCollector<K, V> entryCollector, MapCollector<K, V> collector) {
+ this(keyCollector, entryCollector, Lists.newArrayList(collector), 1);
}
- public CollectingSupplier(MapCollector<K, V> collector) {
- this(collector, false);
+ public CollectingSupplier(ValueCollector<K> keyCollector, MapEntryCollector<K, V> entryCollector, List<MapCollector<K, V>> collectors, int size) {
+ this.keyCollector = keyCollector;
+ this.entryCollector = entryCollector;
+ this.size = size;
+ this.collectors = collectors;
}
@Override
- public MapSupplier<K, V> absentIgnoring() {
- return ignoreAbsent ? this : new CollectingSupplier(collector, true);
+ protected Value<? extends Map<K, V>> calculateOwnValue(ValueConsumer consumer) {
+ return calculateValue(consumer);
}
@Override
public boolean calculatePresence(ValueConsumer consumer) {
- return collector.calculatePresence(consumer);
+ for (MapCollector<K, V> collector : Lists.reverse(getCollectors())) {
+ if (!collector.calculatePresence(consumer)) {
+ return false;
+ }
+ if (collector instanceof AbsentIgnoringCollector<?, ?>) {
+ return true;
+ }
+ }
+ return true;
+ }
+
+ @Nullable
+ @Override
+ @SuppressWarnings("unchecked")
+ public Class<Map<K, V>> getType() {
+ return (Class) Map.class;
}
@Override
public Value<? extends Set<K>> calculateKeys(ValueConsumer consumer) {
// TODO - don't make a copy when the collector already produces an immutable collection
ImmutableSet.Builder<K> builder = ImmutableSet.builder();
- Value<Void> result = collector.collectKeys(consumer, keyCollector, builder);
- if (result.isMissing()) {
- return result.asType();
+ Value<Void> compositeResult = Value.present();
+ for (MapCollector<K, V> collector : getCollectors()) {
+ Value<Void> result = collector.collectKeys(consumer, keyCollector, builder);
+ if (result.isMissing()) {
+ builder = ImmutableSet.builder();
+ compositeResult = result;
+ } else if (compositeResult.isMissing()) {
+ if (isAbsentIgnoring(collector)) {
+ compositeResult = result;
+ } else {
+ builder = ImmutableSet.builder();
+ }
+ } else {
+ compositeResult = compositeResult.withSideEffect(SideEffect.fixedFrom(result));
+ }
}
- return Value.of(ImmutableSet.copyOf(builder.build())).withSideEffect(SideEffect.fixedFrom(result));
+ if (compositeResult.isMissing()) {
+ return compositeResult.asType();
+ }
+ return Value.of(ImmutableSet.copyOf(builder.build())).withSideEffect(SideEffect.fixedFrom(compositeResult));
}
@Override
@@ -586,28 +612,66 @@ public Value<? extends Map<K, V>> calculateValue(ValueConsumer consumer) {
// for MapProperty allows a provider to override the entries of earlier providers and so there can be multiple entries
// with the same key
Map<K, V> entries = new LinkedHashMap<>();
- Value<Void> result = collector.collectEntries(consumer, entryCollector, entries);
- if (result.isMissing()) {
- return result.asType();
+ Value<Void> compositeResult = Value.present();
+ for (MapCollector<K, V> collector : getCollectors()) {
+ Value<Void> result = collector.collectEntries(consumer, entryCollector, entries);
+ if (result.isMissing()) {
+ entries.clear();
+ compositeResult = result;
+ } else if (compositeResult.isMissing()) {
+ if (isAbsentIgnoring(collector)) {
+ compositeResult = result;
+ } else {
+ entries.clear();
+ }
+ } else {
+ compositeResult = compositeResult.withSideEffect(SideEffect.fixedFrom(result));
+ }
}
- return Value.of(ImmutableMap.copyOf(entries)).withSideEffect(SideEffect.fixedFrom(result));
+ if (compositeResult.isMissing()) {
+ return compositeResult.asType();
+ }
+ return Value.of(ImmutableMap.copyOf(entries)).withSideEffect(SideEffect.fixedFrom(compositeResult));
}
@Override
- public MapSupplier<K, V> plus(MapCollector<K, V> addedCollector) {
- MapCollector<K, V> left = this.collector.absentIgnoringIfNeeded(ignoreAbsent);
- MapCollector<K, V> right = addedCollector;
- PlusCollector<K, V> newCollector = new PlusCollector<>(left, right);
- return new CollectingSupplier(newCollector);
+ public MapSupplier<K, V> plus(MapCollector<K, V> addedCollector, boolean ignoreAbsent) {
+ Preconditions.checkState(collectors.size() == size);
+ collectors.add(ignoreAbsentIfNeeded(addedCollector, ignoreAbsent));
+ return new CollectingSupplier<>(keyCollector, entryCollector, collectors, size + 1);
}
@Override
public ExecutionTimeValue<? extends Map<K, V>> calculateExecutionTimeValue() {
- List<ExecutionTimeValue<? extends Map<? extends K, ? extends V>>> execTimeValues = collectExecutionTimeValues();
- ExecutionTimeValue<Map<K, V>> fixedOrMissing = fixedOrMissingValueOf(execTimeValues);
- return fixedOrMissing != null
- ? fixedOrMissing
- : ExecutionTimeValue.changingValue(new CollectingProvider<>(execTimeValues));
+ List<Pair<MapCollector<K, V>, ExecutionTimeValue<? extends Map<? extends K, ? extends V>>>> collectorsWithValues = collectExecutionTimeValues();
+ if (collectorsWithValues.isEmpty()) {
+ return ExecutionTimeValue.missing();
+ }
+ List<ExecutionTimeValue<? extends Map<? extends K, ? extends V>>> executionTimeValues = collectorsWithValues.stream().map(Pair::getRight).collect(Collectors.toList());
+ ExecutionTimeValue<Map<K, V>> fixedOrMissing = fixedOrMissingValueOf(executionTimeValues);
+ if (fixedOrMissing != null) {
+ return fixedOrMissing;
+ }
+
+ return ExecutionTimeValue.changingValue(new CollectingSupplier<>(
+ keyCollector,
+ entryCollector,
+ collectorsWithValues.stream().map(pair -> {
+ MapCollector<K, V> elements = toCollector(pair.getRight());
+ return isAbsentIgnoring(pair.getLeft())
+ ? new AbsentIgnoringCollector<>(elements)
+ : elements;
+ }).collect(toList()),
+ collectorsWithValues.size())
+ );
+ }
+
+ private MapCollector<K, V> toCollector(ExecutionTimeValue<? extends Map<? extends K, ? extends V>> value) {
+ Preconditions.checkArgument(!value.isMissing(), "Cannot get a collector for the missing value");
+ if (value.isChangingValue() || value.hasChangingContent() || value.getSideEffect() != null) {
+ return new EntriesFromMapProvider<>(value.toProvider());
+ }
+ return new EntriesFromMap<>(value.getFixedValue());
}
/**
@@ -636,10 +700,26 @@ private ExecutionTimeValue<Map<K, V>> fixedOrMissingValueOf(List<ExecutionTimeVa
return null;
}
- private List<ExecutionTimeValue<? extends Map<? extends K, ? extends V>>> collectExecutionTimeValues() {
- List<ExecutionTimeValue<? extends Map<? extends K, ? extends V>>> values = new ArrayList<>();
- collector.calculateExecutionTimeValue(values::add);
- return values;
+ @Nonnull
+ private List<Pair<MapCollector<K, V>, ExecutionTimeValue<? extends Map<? extends K, ? extends V>>>> collectExecutionTimeValues() {
+ List<Pair<MapCollector<K, V>, ExecutionTimeValue<? extends Map<? extends K, ? extends V>>>> executionTimeValues = new ArrayList<>();
+ List<Pair<MapCollector<K, V>, ExecutionTimeValue<? extends Map<? extends K, ? extends V>>>> candidates = new ArrayList<>();
+
+ for (MapCollector<K, V> collector : Lists.reverse(getCollectors())) {
+ ExecutionTimeValue<? extends Map<? extends K, ? extends V>> result = collector.calculateExecutionTimeValue();
+ if (result.isMissing()) {
+ return Lists.reverse(executionTimeValues);
+ }
+ if (isAbsentIgnoring(collector)) {
+ executionTimeValues.addAll(candidates);
+ executionTimeValues.add(Pair.of(collector, result));
+ candidates.clear();
+ } else {
+ candidates.add(Pair.of(collector, result));
+ }
+ }
+ executionTimeValues.addAll(candidates);
+ return Lists.reverse(executionTimeValues);
}
private ImmutableMap<K, V> collectEntries(List<ExecutionTimeValue<? extends Map<? extends K, ? extends V>>> values, SideEffectBuilder<? super Map<K, V>> sideEffectBuilder) {
@@ -651,54 +731,108 @@ private ImmutableMap<K, V> collectEntries(List<ExecutionTimeValue<? extends Map<
return ImmutableMap.copyOf(entries);
}
+ private List<MapCollector<K, V>> getCollectors() {
+ return collectors.subList(0, size);
+ }
+
private ExecutionTimeValue<Map<K, V>> maybeChangingContent(ExecutionTimeValue<Map<K, V>> value, boolean changingContent) {
return changingContent ? value.withChangingContent() : value;
}
@Override
public ValueProducer getProducer() {
- return collector.getProducer();
+ List<ValueProducer> producers = getCollectors().stream().map(ValueSupplier::getProducer).collect(toList());
+ return new ValueProducer() {
+ @Override
+ public void visitProducerTasks(Action<? super Task> visitor) {
+ producers.forEach(c -> c.visitProducerTasks(visitor));
+ }
+
+ @Override
+ public boolean isKnown() {
+ return producers.stream().anyMatch(ValueProducer::isKnown);
+ }
+
+ @Override
+ public void visitDependencies(TaskDependencyResolveContext context) {
+ producers.forEach(c -> c.visitDependencies(context));
+ }
+
+ @Override
+ public void visitContentProducerTasks(Action<? super Task> visitor) {
+ producers.forEach(c -> c.visitContentProducerTasks(visitor));
+ }
+ };
}
@Override
- public String toString() {
- return collector.toString();
+ protected String toStringNoReentrance() {
+ StringBuilder sb = new StringBuilder();
+ getCollectors().forEach(collector -> {
+ if (sb.length() > 0) {
+ sb.append(" + ");
+ }
+ sb.append(collector.toString());
+ });
+ return sb.toString();
}
}
- private static class CollectingProvider<K, V> extends AbstractMinimalProvider<Map<K, V>> {
- private final List<ExecutionTimeValue<? extends Map<? extends K, ? extends V>>> values;
+ private static boolean isAbsentIgnoring(MapCollector<?, ?> collector) {
+ return collector instanceof AbsentIgnoringCollector<?, ?>;
+ }
- public CollectingProvider(List<ExecutionTimeValue<? extends Map<? extends K, ? extends V>>> values) {
- this.values = values;
+ private static <K, V> MapCollector<K, V> ignoreAbsentIfNeeded(MapCollector<K, V> collector, boolean ignoreAbsent) {
+ if (ignoreAbsent && !isAbsentIgnoring(collector)) {
+ return new AbsentIgnoringCollector<>(collector);
}
+ return collector;
+ }
- @Nullable
- @Override
- public Class<Map<K, V>> getType() {
- return uncheckedCast(Map.class);
+ private static class AbsentIgnoringCollector<K, V> implements MapCollector<K, V> {
+ private final MapCollector<K, V> delegate;
+
+ private AbsentIgnoringCollector(MapCollector<K, V> delegate) {
+ this.delegate = delegate;
}
@Override
- public ExecutionTimeValue<? extends Map<K, V>> calculateExecutionTimeValue() {
- return ExecutionTimeValue.changingValue(this);
- }
-
- @Override
- protected Value<? extends Map<K, V>> calculateOwnValue(ValueConsumer consumer) {
- Map<K, V> entries = new LinkedHashMap<>();
- SideEffectBuilder<? super Map<K, V>> sideEffectBuilder = SideEffect.builder();
- for (ExecutionTimeValue<? extends Map<? extends K, ? extends V>> executionTimeValue : values) {
- Value<? extends Map<? extends K, ? extends V>> value = executionTimeValue.toProvider().calculateValue(consumer);
- if (value.isMissing()) {
- return Value.missing();
- } else {
- entries.putAll(value.getWithoutSideEffect());
- sideEffectBuilder.add(SideEffect.fixedFrom(value));
- }
+ public Value<Void> collectEntries(ValueConsumer consumer, MapEntryCollector<K, V> collector, Map<K, V> dest) {
+ Map<K, V> candidates = new LinkedHashMap<>();
+ // we cannot use dest directly because we don't want to emit any entries if either left or right are missing
+ Value<Void> value = delegate.collectEntries(consumer, collector, candidates);
+ if (value.isMissing()) {
+ return Value.present();
}
+ dest.putAll(candidates);
+ return Value.present().withSideEffect(SideEffect.fixedFrom(value));
+ }
- return Value.of(ImmutableMap.copyOf(entries)).withSideEffect(sideEffectBuilder.build());
+ @Override
+ public Value<Void> collectKeys(ValueConsumer consumer, ValueCollector<K> collector, ImmutableCollection.Builder<K> dest) {
+ ImmutableSet.Builder<K> candidateKeys = ImmutableSet.builder();
+ Value<Void> value = delegate.collectKeys(consumer, collector, candidateKeys);
+ if (value.isMissing()) {
+ return Value.present();
+ }
+ dest.addAll(candidateKeys.build());
+ return value;
+ }
+
+ @Override
+ public ExecutionTimeValue<? extends Map<? extends K, ? extends V>> calculateExecutionTimeValue() {
+ ExecutionTimeValue<? extends Map<? extends K, ? extends V>> executionTimeValue = delegate.calculateExecutionTimeValue();
+ return executionTimeValue.isMissing() ? ExecutionTimeValue.fixedValue(ImmutableMap.of()) : executionTimeValue;
+ }
+
+ @Override
+ public ValueProducer getProducer() {
+ return delegate.getProducer();
+ }
+
+ @Override
+ public boolean calculatePresence(ValueConsumer consumer) {
+ return true;
}
}
@@ -767,14 +901,8 @@ public Value<Void> collectKeys(ValueConsumer consumer, ValueCollector<K> collect
}
@Override
- public void calculateExecutionTimeValue(Action<ExecutionTimeValue<? extends Map<? extends K, ? extends V>>> visitor) {
- visitor.execute(ExecutionTimeValue.fixedValue(entries).withSideEffect(sideEffect));
- }
-
- @Override
- public MapCollector<K, V> absentIgnoring() {
- // always present
- return this;
+ public ExecutionTimeValue<? extends Map<? extends K, ? extends V>> calculateExecutionTimeValue() {
+ return ExecutionTimeValue.fixedValue(entries).withSideEffect(sideEffect);
}
@Override
@@ -792,145 +920,4 @@ public String toString() {
return entries.toString();
}
}
-
- private static abstract class AbstractPlusCollector<K, V> implements MapCollector<K, V> {
-
- protected final MapCollector<K, V> left;
- protected final MapCollector<K, V> right;
-
- private AbstractPlusCollector(MapCollector<K, V> left, MapCollector<K, V> right) {
- this.left = left;
- this.right = right;
- }
-
- @Override
- public ValueProducer getProducer() {
- return left.getProducer().plus(right.getProducer());
- }
-
- @Override
- public String toString() {
- return left + " + " + right;
- }
- }
-
- private static class PlusCollector<K, V> extends AbstractPlusCollector<K, V> {
-
- public PlusCollector(MapCollector<K, V> left, MapCollector<K, V> right) {
- super(left, right);
- }
-
- @Override
- public MapCollector<K, V> absentIgnoring() {
- return new AbsentIgnoringPlusCollector<K, V>(left, right);
- }
-
- @Override
- public boolean calculatePresence(ValueConsumer consumer) {
- return left.calculatePresence(consumer) && right.calculatePresence(consumer);
- }
-
- @Override
- public Value<Void> collectEntries(ValueConsumer consumer, MapEntryCollector<K, V> collector, Map<K, V> dest) {
- Value<Void> leftValue = left.collectEntries(consumer, collector, dest);
- if (leftValue.isMissing()) {
- return leftValue;
- }
- Value<Void> rightValue = right.collectEntries(consumer, collector, dest);
- if (rightValue.isMissing()) {
- return rightValue;
- }
-
- return Value.present()
- .withSideEffect(SideEffect.fixedFrom(leftValue))
- .withSideEffect(SideEffect.fixedFrom(rightValue));
- }
-
- @Override
- public Value<Void> collectKeys(ValueConsumer consumer, ValueCollector<K> collector, ImmutableCollection.Builder<K> dest) {
- Value<Void> result = left.collectKeys(consumer, collector, dest);
- if (result.isMissing()) {
- return result;
- }
- return right.collectKeys(consumer, collector, dest);
- }
-
- @Override
- public void calculateExecutionTimeValue(Action<ExecutionTimeValue<? extends Map<? extends K, ? extends V>>> visitor) {
- left.calculateExecutionTimeValue(visitor);
- right.calculateExecutionTimeValue(visitor);
- }
- }
-
- /**
- * A plus collector that either produces a composition of both of its left and right sides,
- * or Value.present() with empty content (if left or right side are missing).
- */
- private static class AbsentIgnoringPlusCollector<K, V> extends AbstractPlusCollector<K, V> {
-
- private AbsentIgnoringPlusCollector(MapCollector<K, V> left, MapCollector<K, V> right) {
- super(left, right);
- }
-
- @Override
- public boolean calculatePresence(ValueConsumer consumer) {
- return true;
- }
-
- @Override
- public MapCollector<K, V> absentIgnoring() {
- return this;
- }
-
- @Override
- public Value<Void> collectEntries(ValueConsumer consumer, MapEntryCollector<K, V> collector, Map<K, V> dest) {
- Map<K, V> candidates = new LinkedHashMap<>();
- // we cannot use dest directly because we don't want to emit any entries if either left or right are missing
- Value<Void> leftValue = left.collectEntries(consumer, collector, candidates);
- if (leftValue.isMissing()) {
- return Value.present();
- }
- Value<Void> rightValue = right.collectEntries(consumer, collector, candidates);
- if (rightValue.isMissing()) {
- return Value.present();
- }
- dest.putAll(candidates);
- return Value.present()
- .withSideEffect(SideEffect.fixedFrom(leftValue))
- .withSideEffect(SideEffect.fixedFrom(rightValue));
- }
-
- @Override
- public Value<Void> collectKeys(ValueConsumer consumer, ValueCollector<K> collector, ImmutableCollection.Builder<K> dest) {
- ImmutableSet.Builder<K> candidateKeys = ImmutableSet.builder();
- Value<Void> leftResult = left.collectKeys(consumer, collector, candidateKeys);
- if (leftResult.isMissing()) {
- return Value.present();
- }
- Value<Void> rightResult = right.collectKeys(consumer, collector, candidateKeys);
- if (rightResult.isMissing()) {
- return Value.present();
- }
- dest.addAll(candidateKeys.build());
- return rightResult;
- }
-
- @Override
- public void calculateExecutionTimeValue(Action<ExecutionTimeValue<? extends Map<? extends K, ? extends V>>> visitor) {
- boolean[] anyMissing = {false};
- ImmutableList.Builder<ExecutionTimeValue<? extends Map<? extends K, ? extends V>>> toVisit = ImmutableList.builder();
- Action<ExecutionTimeValue<? extends Map<? extends K, ? extends V>>> safeVisitor = value -> {
- if (value.isMissing()) {
- anyMissing[0] = true;
- } else {
- toVisit.add(value);
- }
- };
- left.calculateExecutionTimeValue(safeVisitor);
- right.calculateExecutionTimeValue(safeVisitor);
- if (!anyMissing[0]) {
- toVisit.build().forEach(it -> visitor.execute(it));
- }
- }
- }
}
diff --git a/platforms/core-configuration/model-core/src/main/java/org/gradle/api/internal/provider/MapCollector.java b/platforms/core-configuration/model-core/src/main/java/org/gradle/api/internal/provider/MapCollector.java
index 09d5bfc..9414749 100644
--- a/platforms/core-configuration/model-core/src/main/java/org/gradle/api/internal/provider/MapCollector.java
+++ b/platforms/core-configuration/model-core/src/main/java/org/gradle/api/internal/provider/MapCollector.java
@@ -17,7 +17,6 @@
package org.gradle.api.internal.provider;
import com.google.common.collect.ImmutableCollection;
-import org.gradle.api.Action;
import java.util.Map;
@@ -25,7 +24,7 @@
* A supplier of zero or more mappings from value of type {@link K} to value of type {@link V}.
*
* <p>
- * A <code>MapCollector</code> is for {@link DefaultMapProperty} and {@link MapSupplier} what {@link Collector} is for {@link AbstractCollectionProperty} and {@link CollectionSupplier}.
+ * A <code>MapCollector</code> is for {@link DefaultMapProperty} and {@link MapSupplier} what {@link Collector} is for {@link AbstractCollectionProperty} and {@link CollectionSupplier}.
* </p>
*/
public interface MapCollector<K, V> extends ValueSupplier {
@@ -34,14 +33,5 @@ public interface MapCollector<K, V> extends ValueSupplier {
Value<Void> collectKeys(ValueConsumer consumer, ValueCollector<K> collector, ImmutableCollection.Builder<K> dest);
- void calculateExecutionTimeValue(Action<ExecutionTimeValue<? extends Map<? extends K, ? extends V>>> visitor);
-
- MapCollector<K, V> absentIgnoring();
-
- /**
- * Returns a collector that may never return a missing value.
- */
- default MapCollector<K, V> absentIgnoringIfNeeded(boolean ignoreAbsent) {
- return ignoreAbsent ? absentIgnoring() : this;
- }
+ ExecutionTimeValue<? extends Map<? extends K, ? extends V>> calculateExecutionTimeValue();
}
diff --git a/platforms/core-configuration/model-core/src/main/java/org/gradle/api/internal/provider/MapCollectors.java b/platforms/core-configuration/model-core/src/main/java/org/gradle/api/internal/provider/MapCollectors.java
index b560041..8ba0241 100644
--- a/platforms/core-configuration/model-core/src/main/java/org/gradle/api/internal/provider/MapCollectors.java
+++ b/platforms/core-configuration/model-core/src/main/java/org/gradle/api/internal/provider/MapCollectors.java
@@ -19,11 +19,8 @@
import com.google.common.base.Objects;
import com.google.common.collect.ImmutableCollection;
import com.google.common.collect.ImmutableMap;
-import org.gradle.api.Action;
import org.gradle.api.internal.lambdas.SerializableLambdas;
-import org.gradle.internal.Cast;
-import javax.annotation.Nonnull;
import java.util.Map;
public class MapCollectors {
@@ -44,12 +41,6 @@ public boolean calculatePresence(ValueConsumer consumer) {
}
@Override
- public MapCollector<K, V> absentIgnoring() {
- // always present
- return this;
- }
-
- @Override
public Value<Void> collectEntries(ValueConsumer consumer, MapEntryCollector<K, V> collector, Map<K, V> dest) {
collector.add(key, value, dest);
return Value.present();
@@ -62,8 +53,8 @@ public Value<Void> collectKeys(ValueConsumer consumer, ValueCollector<K> collect
}
@Override
- public void calculateExecutionTimeValue(Action<ExecutionTimeValue<? extends Map<? extends K, ? extends V>>> visitor) {
- visitor.execute(ExecutionTimeValue.fixedValue(ImmutableMap.of(key, value)));
+ public ExecutionTimeValue<? extends Map<? extends K, ? extends V>> calculateExecutionTimeValue() {
+ return ExecutionTimeValue.fixedValue(ImmutableMap.of(key, value));
}
@Override
@@ -104,11 +95,6 @@ public EntryWithValueFromProvider(K key, ProviderInternal<? extends V> providerO
}
@Override
- public MapCollector<K, V> absentIgnoring() {
- return new EntriesFromMapProvider<>(providerOfValue.map(value -> ImmutableMap.of(key, value)), true);
- }
-
- @Override
public boolean calculatePresence(ValueConsumer consumer) {
return providerOfValue.calculatePresence(consumer);
}
@@ -134,16 +120,16 @@ public Value<Void> collectKeys(ValueConsumer consumer, ValueCollector<K> collect
}
@Override
- public void calculateExecutionTimeValue(Action<ExecutionTimeValue<? extends Map<? extends K, ? extends V>>> visitor) {
+ public ExecutionTimeValue<? extends Map<? extends K, ? extends V>> calculateExecutionTimeValue() {
ExecutionTimeValue<? extends V> value = providerOfValue.calculateExecutionTimeValue();
if (value.isMissing()) {
- visitor.execute(ExecutionTimeValue.missing());
+ return ExecutionTimeValue.missing();
} else if (value.hasFixedValue()) {
// transform preserving side effects
- visitor.execute(ExecutionTimeValue.value(value.toValue().transform(v -> ImmutableMap.of(key, v))));
+ return ExecutionTimeValue.value(value.toValue().transform(v -> ImmutableMap.of(key, v)));
} else {
- visitor.execute(ExecutionTimeValue.changingValue(
- value.getChangingValue().map(SerializableLambdas.transformer(v -> ImmutableMap.of(key, v)))));
+ return ExecutionTimeValue.changingValue(
+ value.getChangingValue().map(SerializableLambdas.transformer(v -> ImmutableMap.of(key, v))));
}
}
@@ -172,12 +158,6 @@ public boolean calculatePresence(ValueConsumer consumer) {
}
@Override
- public MapCollector<K, V> absentIgnoring() {
- // always present
- return this;
- }
-
- @Override
public Value<Void> collectEntries(ValueConsumer consumer, MapEntryCollector<K, V> collector, Map<K, V> dest) {
collector.addAll(entries.entrySet(), dest);
return Value.present();
@@ -190,8 +170,8 @@ public Value<Void> collectKeys(ValueConsumer consumer, ValueCollector<K> collect
}
@Override
- public void calculateExecutionTimeValue(Action<ExecutionTimeValue<? extends Map<? extends K, ? extends V>>> sources) {
- sources.execute(ExecutionTimeValue.fixedValue(entries));
+ public ExecutionTimeValue<? extends Map<? extends K, ? extends V>> calculateExecutionTimeValue() {
+ return ExecutionTimeValue.fixedValue(entries);
}
@Override
@@ -208,37 +188,21 @@ public String toString() {
public static class EntriesFromMapProvider<K, V> implements MapCollector<K, V> {
private final ProviderInternal<? extends Map<? extends K, ? extends V>> providerOfEntries;
- private final boolean ignoreAbsent;
public EntriesFromMapProvider(ProviderInternal<? extends Map<? extends K, ? extends V>> providerOfEntries) {
- this(providerOfEntries, false);
- }
-
- private EntriesFromMapProvider(ProviderInternal<? extends Map<? extends K, ? extends V>> providerOfEntries, boolean ignoreAbsent) {
- this.providerOfEntries = ignoreAbsent ? neverMissing(Cast.uncheckedNonnullCast(providerOfEntries)) : providerOfEntries;
- this.ignoreAbsent = ignoreAbsent;
- }
-
- @Override
- public MapCollector<K, V> absentIgnoring() {
- return ignoreAbsent ? this : new EntriesFromMapProvider<>(providerOfEntries, true);
- }
-
- @Nonnull
- private static <K, V> ProviderInternal<? extends Map<? extends K, ? extends V>> neverMissing(ProviderInternal<Map<? extends K, ? extends V>> provider) {
- return Cast.uncheckedNonnullCast(provider.orElse(ImmutableMap.of()));
+ this.providerOfEntries = providerOfEntries;
}
@Override
public boolean calculatePresence(ValueConsumer consumer) {
- return ignoreAbsent || providerOfEntries.calculatePresence(consumer);
+ return providerOfEntries.calculatePresence(consumer);
}
@Override
public Value<Void> collectEntries(ValueConsumer consumer, MapEntryCollector<K, V> collector, Map<K, V> dest) {
Value<? extends Map<? extends K, ? extends V>> value = providerOfEntries.calculateValue(consumer);
if (value.isMissing()) {
- return ignoreAbsent ? Value.present() : value.asType();
+ return value.asType();
}
collector.addAll(value.getWithoutSideEffect().entrySet(), dest);
return Value.present().withSideEffect(SideEffect.fixedFrom(value));
@@ -255,8 +219,8 @@ public Value<Void> collectKeys(ValueConsumer consumer, ValueCollector<K> collect
}
@Override
- public void calculateExecutionTimeValue(Action<ExecutionTimeValue<? extends Map<? extends K, ? extends V>>> visitor) {
- visitor.execute(providerOfEntries.calculateExecutionTimeValue());
+ public ExecutionTimeValue<? extends Map<? extends K, ? extends V>> calculateExecutionTimeValue() {
+ return providerOfEntries.calculateExecutionTimeValue();
}
@Override
diff --git a/platforms/core-configuration/model-core/src/main/java/org/gradle/api/internal/provider/MapSupplier.java b/platforms/core-configuration/model-core/src/main/java/org/gradle/api/internal/provider/MapSupplier.java
index ce6c982..bd4ef626 100644
--- a/platforms/core-configuration/model-core/src/main/java/org/gradle/api/internal/provider/MapSupplier.java
+++ b/platforms/core-configuration/model-core/src/main/java/org/gradle/api/internal/provider/MapSupplier.java
@@ -30,16 +30,7 @@ interface MapSupplier<K, V> extends ValueSupplier {
Value<? extends Set<K>> calculateKeys(ValueConsumer consumer);
- MapSupplier<K, V> plus(MapCollector<K, V> collector);
-
- /**
- * Returns a view of this supplier that may calculate its value as empty if it would be missing.
- */
- MapSupplier<K, V> absentIgnoring();
-
- default MapSupplier<K, V> absentIgnoringIfNeeded(boolean required) {
- return required ? absentIgnoring() : this;
- }
+ MapSupplier<K, V> plus(MapCollector<K, V> collector, boolean ignoreAbsent);
ExecutionTimeValue<? extends Map<K, V>> calculateExecutionTimeValue();
}
diff --git a/platforms/core-configuration/model-core/src/test/groovy/org/gradle/api/internal/provider/CollectionPropertySpec.groovy b/platforms/core-configuration/model-core/src/test/groovy/org/gradle/api/internal/provider/CollectionPropertySpec.groovy
index a891904..4a7bddf 100644
--- a/platforms/core-configuration/model-core/src/test/groovy/org/gradle/api/internal/provider/CollectionPropertySpec.groovy
+++ b/platforms/core-configuration/model-core/src/test/groovy/org/gradle/api/internal/provider/CollectionPropertySpec.groovy
@@ -29,6 +29,7 @@
import java.util.function.Consumer
import static org.gradle.api.internal.provider.CircularEvaluationSpec.ProviderConsumer.GET_PRODUCER
+import static org.gradle.api.internal.provider.CircularEvaluationSpec.ProviderConsumer.TO_STRING
import static org.gradle.api.internal.provider.Providers.notDefined
abstract class CollectionPropertySpec<C extends Collection<String>> extends PropertySpec<C> {
@@ -1165,6 +1166,11 @@
static abstract class CollectionPropertyCircularChainEvaluationTest<T, C extends Collection<T>> extends PropertySpec.PropertyCircularChainEvaluationSpec<C> {
@Override
+ List<Consumer<ProviderInternal<?>>> safeConsumers() {
+ return [TO_STRING, GET_PRODUCER]
+ }
+
+ @Override
abstract AbstractCollectionProperty<T, C> property()
def "calling #consumer throws exception if added item provider references the property"(
@@ -1385,48 +1391,48 @@
}
when:
- operations.each {operation -> operation.call(property) }
+ operations.each { operation -> operation.call(property) }
then:
expected == null || property.getOrNull() == toImmutable(expected)
expected != null || !property.present
where:
- expected | explicit | convention | label | operations
- ["1"] | _ | _ | "add" | { it.add("1") }
- ["1"] | _ | _ | "append" | { it.append("1") }
- ["1"] | [] | _ | "add to empty" | { it.add("1") }
- ["1"] | [] | _ | "append to empty" | { it.append("1") }
- ["1"] | _ | [] | "add to empty convention" | { it.add("1") }
- ["1"] | _ | [] | "append to empty convention" | { it.append("1") }
- null | null | [] | "add to unset value w/ empty convention" | { it.add("1") }
- ["1"] | null | [] | "append to unset value w/ empty convention" | { it.append("1") }
- ["1"] | _ | ["0"] | "add to non-empty convention" | { it.add("1") }
- ["0", "1"] | _ | ["0"] | "append to non-empty convention" | { it.append("1") }
- null | null | ["0"] | "add to unset value w/ non-empty convention" | { it.add("1") }
- ["0", "1"] | null | ["0"] | "append to unset value w/ non-empty convention" | { it.append("1") }
- null | notDefined() | _ | "add to missing" | { it.add("1") }
- ["1"] | notDefined() | _ | "append to missing" | { it.append("1") }
- null | notDefined() | ["0"] | "add to missing w/ non-empty convention" | { it.add("1") }
- ["1"] | notDefined() | ["0"] | "append to missing w/ non-empty convention" | { it.append("1") }
- null | [] | _ | "add missing to empty value" | { it.add(notDefined()) }
- [] | [] | _ | "append missing to empty value" | { it.append(notDefined()) }
- null | _ | _ | "add missing" | { it.add(notDefined()) }
- [] | _ | _ | "append missing" | { it.append(notDefined()) }
- ["1"] | _ | _ | "add missing, then append" | { it.add(notDefined()) ; it.append("1") }
- ["1"] | _ | _ | "append missing, then add" | { it.append(notDefined()) ; it.add("1") }
- ["1"] | ["0"] | _ | "add missing to non-empty value, then append" | { it.add(notDefined()) ; it.append("1") }
- ["0", "1"] | ["0"] | _ | "append missing to non-empty value, then add" | { it.append(notDefined()) ; it.add("1") }
- ["1"] | _ | ["0"] | "add missing to non-empty convention, then append"| { it.add(notDefined()) ; it.append("1") }
- ["0", "1"] | _ | ["0"] | "append missing to non-empty convention, then add"| { it.append(notDefined()) ; it.add("1") }
- ["1"] | _ | _ | "add, then append missing" | { it.add("1") ; it.append(notDefined()) }
- null | _ | _ | "append, then add missing" | { it.append("1") ; it.add(notDefined()) }
- ["0", "1"] | ["0"] | _ | "add to non-empty value, then append missing" | { it.add("1") ; it.append(notDefined()) }
- null | ["0"] | _ | "append to non-empty value, then add missing" | { it.append("1") ; it.add(notDefined()) }
- ["1"] | _ | ["0"] | "add to non-empty convention, then append missing"| { it.add("1") ; it.append(notDefined()) }
- null | _ | ["0"] | "append to non-empty conventio, then add missing" | { it.append("1") ; it.add(notDefined()) }
- ["1"] | _ | _ | "add, then add missing, then append" | { it.add("0") ; it.add(notDefined()) ; it.append("1") }
- ["0", "1"] | _ | _ | "add, then append missing, then add" | { it.add("0") ; it.append(notDefined()) ; it.add("1") }
+ expected | explicit | convention | label | operations
+ ["1"] | _ | _ | "add" | { it.add("1") }
+ ["1"] | _ | _ | "append" | { it.append("1") }
+ ["1"] | [] | _ | "add to empty" | { it.add("1") }
+ ["1"] | [] | _ | "append to empty" | { it.append("1") }
+ ["1"] | _ | [] | "add to empty convention" | { it.add("1") }
+ ["1"] | _ | [] | "append to empty convention" | { it.append("1") }
+ null | null | [] | "add to unset value w/ empty convention" | { it.add("1") }
+ ["1"] | null | [] | "append to unset value w/ empty convention" | { it.append("1") }
+ ["1"] | _ | ["0"] | "add to non-empty convention" | { it.add("1") }
+ ["0", "1"] | _ | ["0"] | "append to non-empty convention" | { it.append("1") }
+ null | null | ["0"] | "add to unset value w/ non-empty convention" | { it.add("1") }
+ ["0", "1"] | null | ["0"] | "append to unset value w/ non-empty convention" | { it.append("1") }
+ null | notDefined() | _ | "add to missing" | { it.add("1") }
+ ["1"] | notDefined() | _ | "append to missing" | { it.append("1") }
+ null | notDefined() | ["0"] | "add to missing w/ non-empty convention" | { it.add("1") }
+ ["1"] | notDefined() | ["0"] | "append to missing w/ non-empty convention" | { it.append("1") }
+ null | [] | _ | "add missing to empty value" | { it.add(notDefined()) }
+ [] | [] | _ | "append missing to empty value" | { it.append(notDefined()) }
+ null | _ | _ | "add missing" | { it.add(notDefined()) }
+ [] | _ | _ | "append missing" | { it.append(notDefined()) }
+ ["1"] | _ | _ | "add missing, then append" | { it.add(notDefined()); it.append("1") }
+ ["1"] | _ | _ | "append missing, then add" | { it.append(notDefined()); it.add("1") }
+ ["1"] | ["0"] | _ | "add missing to non-empty value, then append" | { it.add(notDefined()); it.append("1") }
+ ["0", "1"] | ["0"] | _ | "append missing to non-empty value, then add" | { it.append(notDefined()); it.add("1") }
+ ["1"] | _ | ["0"] | "add missing to non-empty convention, then append" | { it.add(notDefined()); it.append("1") }
+ ["0", "1"] | _ | ["0"] | "append missing to non-empty convention, then add" | { it.append(notDefined()); it.add("1") }
+ ["1"] | _ | _ | "add, then append missing" | { it.add("1"); it.append(notDefined()) }
+ null | _ | _ | "append, then add missing" | { it.append("1"); it.add(notDefined()) }
+ ["0", "1"] | ["0"] | _ | "add to non-empty value, then append missing" | { it.add("1"); it.append(notDefined()) }
+ null | ["0"] | _ | "append to non-empty value, then add missing" | { it.append("1"); it.add(notDefined()) }
+ ["1"] | _ | ["0"] | "add to non-empty convention, then append missing" | { it.add("1"); it.append(notDefined()) }
+ null | _ | ["0"] | "append to non-empty convention, then add missing" | { it.append("1"); it.add(notDefined()) }
+ ["1"] | _ | _ | "add, then add missing, then append" | { it.add("0"); it.add(notDefined()); it.append("1") }
+ ["0", "1"] | _ | _ | "add, then append missing, then add" | { it.add("0"); it.append(notDefined()); it.add("1") }
}
def "execution time value is present if only undefined-safe operations are performed"() {
@@ -1445,7 +1451,7 @@
def execTimeValue = property.calculateExecutionTimeValue()
then:
- assertCollectionIs(toImmutable(['2', '3', '4']), execTimeValue.toValue().get())
+ assertCollectionIs(execTimeValue.toValue().get(), toImmutable(['2', '3', '4']),)
}
def "property restores undefined-safe items"() {
@@ -1468,13 +1474,53 @@
null | ["1", "3"]
}
+ def "property restores undefined-safe items that have #numProviders changing providers without values in front"() {
+ given:
+ numProviders.times {
+ property.add(Providers.changing { null as String })
+ }
+ property.append(Providers.changing { "1" })
+ property.add("2")
+
+ when:
+ def property2 = property()
+ property2.fromState(property.calculateExecutionTimeValue())
+
+ then:
+ assertValueIs(toImmutable(["1", "2"]), property2)
+
+ where:
+ // TODO(mlopatkin): Original implementation works only with numProviders == 1
+ numProviders << [1, 2]
+ }
+
+ def "#opName to empty property is undefined-safe"() {
+ given:
+ property.set(null as Iterable)
+
+ when:
+ op(property)
+
+ then:
+ assertValueIs(toImmutable(expected), property)
+
+ where:
+ opName | op | expected
+ "append(1)" | { it.append("1") } | ["1"]
+ "appendAll(1, 2)" | { it.appendAll(["1", "2"]) } | ["1", "2"]
+ "append(provider(1))" | { it.append(Providers.of("1")) } | ["1"]
+ "appendAll(provider(1, 2))" | { it.appendAll(Providers.of(["1", "2"])) } | ["1", "2"]
+ "append(notDefined())" | { it.append(notDefined()) } | []
+ "appendAll(notDefined())" | { it.appendAll(notDefined()) } | []
+ }
+
def "property remains undefined-safe after restored"() {
given:
property.append(notDefined())
property.add("2")
property.append(notDefined())
property.append(notDefined())
- property.addAll(supplierWithChangingExecutionTimeValues(['3'], ['3a'], ['3b'], ['3c'], ['3d']))
+ property.addAll(supplierWithChangingExecutionTimeValues(['3a'], ['3b'], ['3c'], ['3d']))
property.addAll(supplierWithValues(['4']))
property.append(notDefined())
@@ -1500,7 +1546,7 @@
property3.fromState(execTimeValue2)
then:
- assertValueIs(['2', '3d', '4', '5', '6'], property3)
+ assertValueIs(['2', '3c', '4', '5', '6'], property3)
}
def "can alternate append and add"() {
@@ -1599,4 +1645,15 @@
assertValueIs([])
!property.explicit
}
+
+ def "can add a lot of providers"() {
+ given:
+ (0..<100000).each {
+ property.addAll(supplierWithProducer(Mock(Task), toImmutable([it.toString()])))
+ }
+
+ expect:
+ property.get().size() == 100000
+ property.getProducer().visitProducerTasks {}
+ }
}
diff --git a/platforms/core-configuration/model-core/src/test/groovy/org/gradle/api/internal/provider/MapPropertySpec.groovy b/platforms/core-configuration/model-core/src/test/groovy/org/gradle/api/internal/provider/MapPropertySpec.groovy
index 9ca2066..d38716d 100644
--- a/platforms/core-configuration/model-core/src/test/groovy/org/gradle/api/internal/provider/MapPropertySpec.groovy
+++ b/platforms/core-configuration/model-core/src/test/groovy/org/gradle/api/internal/provider/MapPropertySpec.groovy
@@ -1536,7 +1536,7 @@
property.put("a", notDefined())
property.insert("b", "2")
// changing execution time values or else we would end up with fixed values
- property.putAll(supplierWithChangingExecutionTimeValues([c: '3'], [c: '3a'], [c: '3b'], [c: '3c'], [c: '3d'], [c: '3e']))
+ property.putAll(supplierWithChangingExecutionTimeValues([c: '3a'], [c: '3b'], [c: '3c'], [c: '3d'], [c: '3e']))
property.putAll(supplierWithValues([d: '4']))
property.insert("e", notDefined())
@@ -1562,7 +1562,7 @@
property3.fromState(execTimeValue2)
then:
- assertValueIs([b: '2', c: '3d', d: '4', f: '6', g: '7'], property3)
+ assertValueIs([b: '2', c: '3c', d: '4', f: '6', g: '7'], property3)
}
def "keySet provider has some values when property with no value is added via insert"() {
@@ -1975,4 +1975,15 @@
// The following case abuses Groovy lax type-checking to put an invalid value into the property.
"[k: (Object) provider {v}]" | { property().value(k: Providers.of("v")) } || "Map(String->String, {k=fixed(class ${String.name}, v)})"
}
+
+ def "can add a lot of providers"() {
+ given:
+ (0..<100000).each {
+ property.putAll(supplierWithProducer(Mock(Task), ImmutableMap.of(it.toString(), it.toString())))
+ }
+
+ expect:
+ property.get().size() == 100000
+ property.getProducer().visitProducerTasks {}
+ }
}
diff --git a/platforms/core-execution/persistent-cache/src/integTest/groovy/org/gradle/cache/internal/DefaultFileLockManagerContentionIntegrationTest.groovy b/platforms/core-execution/persistent-cache/src/integTest/groovy/org/gradle/cache/internal/DefaultFileLockManagerContentionIntegrationTest.groovy
index cf6403c..a840b80 100644
--- a/platforms/core-execution/persistent-cache/src/integTest/groovy/org/gradle/cache/internal/DefaultFileLockManagerContentionIntegrationTest.groovy
+++ b/platforms/core-execution/persistent-cache/src/integTest/groovy/org/gradle/cache/internal/DefaultFileLockManagerContentionIntegrationTest.groovy
@@ -28,7 +28,6 @@
import org.gradle.internal.concurrent.DefaultExecutorFactory
import org.gradle.internal.remote.internal.inet.InetAddressFactory
import org.gradle.internal.time.Time
-import org.gradle.test.fixtures.Flaky
import java.util.concurrent.Executors
import java.util.concurrent.TimeUnit
@@ -38,7 +37,6 @@
import static org.gradle.test.fixtures.ConcurrentTestUtil.poll
import static org.gradle.util.internal.TextUtil.escapeString
-@Flaky(because = "https://github.com/gradle/gradle-private/issues/4441")
class DefaultFileLockManagerContentionIntegrationTest extends AbstractIntegrationSpec {
def addressFactory = new InetAddressFactory()
@@ -90,13 +88,16 @@
when:
def build = executer.withTasks("lock").start()
def timer = Time.startTimer()
+
+ def pingCountInOutput = 0
poll(120) {
- assert (build.standardOutput =~ 'Pinged owner at port').count == 3
+ pingCountInOutput = (build.standardOutput =~ 'Pinged owner at port').count
+ assert pingCountInOutput >= 3
}
receivingLock.close()
then:
build.waitForFinish()
- pingRequestCount == 3 || pingRequestCount == 4
+ pingRequestCount in [pingCountInOutput, pingCountInOutput + 1]
timer.elapsedMillis > 3000 // See: DefaultFileLockContentionHandler.PING_DELAY
}
diff --git a/platforms/core-runtime/launcher/src/main/resources/release-features.txt b/platforms/core-runtime/launcher/src/main/resources/release-features.txt
index e69de29..abb8366 100644
--- a/platforms/core-runtime/launcher/src/main/resources/release-features.txt
+++ b/platforms/core-runtime/launcher/src/main/resources/release-features.txt
@@ -0,0 +1,3 @@
+ - Enhanced error and warning reporting with the Problems API
+ - File-system watching support on Alpine Linux
+ - Build and test Swift 6 libraries and apps
diff --git a/platforms/core-runtime/native/src/main/java/org/gradle/internal/nativeintegration/services/NativeServices.java b/platforms/core-runtime/native/src/main/java/org/gradle/internal/nativeintegration/services/NativeServices.java
index 629e6d4..3eb5309 100644
--- a/platforms/core-runtime/native/src/main/java/org/gradle/internal/nativeintegration/services/NativeServices.java
+++ b/platforms/core-runtime/native/src/main/java/org/gradle/internal/nativeintegration/services/NativeServices.java
@@ -99,6 +99,14 @@ public enum NativeFeatures {
@Override
public boolean initialize(File nativeBaseDir, boolean useNativeIntegrations) {
if (useNativeIntegrations) {
+ OperatingSystem operatingSystem = OperatingSystem.current();
+ if (operatingSystem.isMacOsX()) {
+ String version = operatingSystem.getVersion();
+ if (VersionNumber.parse(version).getMajor() < 12) {
+ LOGGER.info("Disabling file system watching on macOS {}, as it is only supported for macOS 12+", version);
+ return false;
+ }
+ }
try {
FileEvents.init(nativeBaseDir);
LOGGER.info("Initialized file system watching services in: {}", nativeBaseDir);
@@ -475,14 +483,6 @@ public boolean useNativeIntegrations() {
@Override
public boolean useFileSystemWatching() {
- OperatingSystem operatingSystem = OperatingSystem.current();
- if (operatingSystem.isMacOsX()) {
- String version = operatingSystem.getVersion();
- if (VersionNumber.parse(version).getMajor() < 12) {
- LOGGER.info("Disabling file system watching on macOS {}, as it is only supported for macOS 12+", version);
- return false;
- }
- }
return isFeatureEnabled(NativeFeatures.FILE_SYSTEM_WATCHING);
}
};
diff --git a/platforms/documentation/docs/src/docs/release/notes-template.md b/platforms/documentation/docs/src/docs/release/notes-template.md
index 6382a3a..9686095 100644
--- a/platforms/documentation/docs/src/docs/release/notes-template.md
+++ b/platforms/documentation/docs/src/docs/release/notes-template.md
@@ -1,3 +1,7 @@
+<meta property="og:image" content="" />
+<meta property="og:type" content="website" />
+<meta property="og:title" content="" />
+
The Gradle team is excited to announce Gradle @version@.
This release features [1](), [2](), ... [n](), and more.
@@ -96,6 +100,6 @@
## Reporting problems
If you find a problem with this release, please file a bug on [GitHub Issues](https://github.com/gradle/gradle/issues) adhering to our issue guidelines.
-If you're not sure you're encountering a bug, please use the [forum](https://discuss.gradle.org/c/help-discuss).
+If you're not sure if you're encountering a bug, please use the [forum](https://discuss.gradle.org/c/help-discuss).
We hope you will build happiness with Gradle, and we look forward to your feedback via [Twitter](https://twitter.com/gradle) or on [GitHub](https://github.com/gradle).
diff --git a/platforms/documentation/docs/src/docs/release/notes.md b/platforms/documentation/docs/src/docs/release/notes.md
index 98c3b20..2f93ef3 100644
--- a/platforms/documentation/docs/src/docs/release/notes.md
+++ b/platforms/documentation/docs/src/docs/release/notes.md
@@ -1,6 +1,14 @@
+<meta property="og:image" content="https://gradle.org/images/releases/gradle-8.12" />
+<meta property="og:type" content="website" />
+<meta property="og:title" content="Gradle 8.12 Release Notes" />
+
The Gradle team is excited to announce Gradle @version@.
-This release features [1](), [2](), ... [n](), and more.
+This release improves [error and warning reporting](#error-warning) by summarizing duplicate entries in the Problems API's generated problems report for better readability. The [console output](#build-authoring) is also enhanced when the Problems API is used to fail the build.
+
+Gradle @version@ introduces [platform enhancements](#platform), including file-system watching support on the Alpine Linux distribution and support for building and testing Swift 6 applications.
+
+Additionally, artifact transform ambiguities now produce a [deprecation warning](#error-warning) with clearer, more actionable information and [new methods](#build-authoring) are available in the DependencyConstraint API.
<!--
Include only their name, impactful features should be called out separately below.
@@ -10,6 +18,25 @@
-->
We would like to thank the following community members for their contributions to this release of Gradle:
+[Abhiraj Adhikary](https://github.com/abhirajadhikary06),
+[Ayush Saxena](https://github.com/Ayushcode10),
+[Björn Kautler](https://github.com/Vampire),
+[davidburstrom](https://github.com/davidburstrom),
+[Dominic Fellbaum](https://github.com/felldo),
+[Emmanuel Ferdman](https://github.com/emmanuel-ferdman),
+[Finn Petersen](https://github.com/fp7),
+[Johnny Lim](https://github.com/izeye),
+[Mahdi Hosseinzadeh](https://github.com/mahozad),
+[Martin Bonnin](https://github.com/martinbonnin),
+[Paint_Ninja](https://github.com/PaintNinja),
+[Petter Måhlén](https://github.com/pettermahlen),
+[Philip Wedemann](https://github.com/hfhbd),
+[stegeto22](https://github.com/stegeto22),
+[Tanish](https://github.com/Taz03),
+[TheGoesen](https://github.com/TheGoesen),
+[Tim Nielens](https://github.com/tnielens),
+[Trout Zhang](https://github.com/TroutZhang),
+[Victor Merkulov](https://github.com/urdak)
Be sure to check out the [public roadmap](https://blog.gradle.org/roadmap-announcement) for insight into what's planned for future releases.
@@ -25,11 +52,24 @@
## New features and usability improvements
+<a name="error-warning"></a>
### Error and warning reporting improvements
+Gradle provides a rich set of [error and warning messages](userguide/logging.html) to help you understand and resolve problems in your build.
+
+#### Summarization in the HTML report for problems
+
+The [Problems API](userguide/reporting_problems.html) provides structured feedback on build issues, helping developers and tools like IDEs identify and resolve warnings, errors, or deprecations during configuration or runtime.
+
+This release introduces a new problem summarization mechanism that reduces redundancy in the generated [HTML Problems Report](userguide/reporting_problems.html#sec:generated_html_report).
+
+The feature limits the number of identical problems reported and provides a summarized count of additional occurrences in the summary report:
+
+<img alt="HTML Problems report" src="data:image/png;base64,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">
+
#### Ambiguous Artifact Transformation chains are detected and reported
-Previously, when two or more equal-length chains of <<artifact_transforms.adoc#sec,artifact transforms>> produced compatible variants to satisfy a resolution request, Gradle would arbitrarily and silently select one.
+Previously, when two or more equal-length chains of [artifact transforms](userguide/artifact_transforms.html) produced compatible variants to satisfy a resolution request, Gradle would arbitrarily and silently select one.
Gradle now emits a warning for this case.
This deprecation warning is the same failure message that now appears when multiple equal-length chains are available, producing incompatible variants that could each satisfy a resolution request.
@@ -85,108 +125,91 @@
```
The formatting of this message has been improved to comprehensively display information about each complete chain of transformations that produces the candidates that would satisfy the request.
-This allows authors to better analyze and understand their builds, allowing them to remove the ambiguity.
+This allows authors to better analyze and understand their builds, allowing them to remove ambiguity.
-<!-- Do not add breaking changes or deprecations here! Add them to the upgrade guide instead. -->
+<a name="platform"></a>
+### Platform enhancements
+Gradle provides many features for specific platforms and languages.
-<a name="Problems API"></a>
+#### File-system watching and continuous mode support on Alpine Linux
-### Problems API improvements
+[File-system watching](userguide/file_system_watching.html) is now supported on [Alpine Linux](https://alpinelinux.org), a popular choice for container-based images and the default distribution for Docker.
-#### Enhanced Problem Summarization for Improved Usability
+The feature is enabled by default, as is the case with all other supported platforms.
-This release introduces a new problem summarization mechanism that reduces redundancy in problem reporting during builds. The feature limits the number of identical problems reported for each group (
-default threshold: 15) and provides a summarized count of additional occurrences at the end of the build.
+Additionally, it is now possible to [run builds in continuous mode](userguide/continuous_builds.html) on Alpine Linux.
-##### Key Improvements
+<a name="swift-support"></a>
+#### Swift 6 support
-- **Optimized Event Reporting**: Summarized problems minimize the data sent to clients, improving performance and reducing resource consumption.
-- **Simplified Developer Experience**: Cleaner problem reports with less noise, making it easier to identify and address critical issues.
-- **Enhanced Reporting**: Summarized problem details are reflected in the Messages, Group, and Locations tabs, maintaining clarity while reducing verbosity.
+Gradle’s [Swift support](userguide/building_swift_projects.html) allows you to build and test native Swift libraries and applications.
-This change ensures a smoother experience when using Gradle with repetitive problems.
-
-To learn more, check out our [sample project](samples/sample_problems_api_usage.html)
-<!--
-================== TEMPLATE ==============================
-
-<a name="FILL-IN-KEY-AREA"></a>
-### FILL-IN-KEY-AREA improvements
-
-<<<FILL IN CONTEXT FOR KEY AREA>>>
-Example:
-> The [configuration cache](userguide/configuration_cache.html) improves build performance by caching the result of
-> the configuration phase. Using the configuration cache, Gradle can skip the configuration phase entirely when
-> nothing that affects the build configuration has changed.
-
-#### FILL-IN-FEATURE
-> HIGHLIGHT the use case or existing problem the feature solves
-> EXPLAIN how the new release addresses that problem or use case
-> PROVIDE a screenshot or snippet illustrating the new feature, if applicable
-> LINK to the full documentation for more details
-
-================== END TEMPLATE ==========================
-
-
-==========================================================
-ADD RELEASE FEATURES BELOW
-vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv -->
+Gradle now supports [Swift 6](https://www.swift.org/blog/announcing-swift-6/), introduced with [Xcode 16.0](https://developer.apple.com/documentation/xcode-release-notes/xcode-16-release-notes), extending its capabilities to the latest major version of Swift.
<a name="build-authoring"></a>
### Build authoring improvements
-Gradle provides rich APIs for plugin authors and build engineers to develop custom build logic.
+Gradle provides [rich APIs](userguide/getting_started_dev.html) for plugin authors and build engineers to develop custom build logic.
+
+#### Richer console output for failures using the Problems API
+
+The [Problems API](userguide/reporting_problems.html) provides structured feedback on build issues, helping developers and tools like IDEs identify and resolve warnings, errors, or deprecations during configuration or runtime.
+
+With this release, problems that are the source of a build failure have all of their information displayed on the console output at the end of the build:
+
+```text
+FAILURE: Build failed with an exception.
+
+* What went wrong:
+Execution failed for task ':sample-project:myFailingTask'.
+> Message from runtime exception
+ This happened because ProblemReporter.throwing() was called
+ This is a demonstration of how to add
+ detailed information to a build failure
+
+* Try:
+> Remove the Problems.throwing() method call from the task action
+> Run with --scan to get full insights.
+
+BUILD FAILED in 10s
+```
+
+This example output was obtained by using the Problems API as shown below:
+
+```java
+public abstract class FailingTask extends DefaultTask {
+
+
+ @Inject public abstract Problems getProblems();
+
+
+ @TaskAction public void run() {
+ throw getProblems().getReporter().throwing(problemSpec -> {
+ problemSpec.contextualLabel("This happened because ProblemReporter.throwing() was called");
+ problemSpec.details("This is a demonstration of how to add\ndetailed information to a build failure");
+ problemSpec.withException(new RuntimeException("Message from runtime exception"));
+ problemSpec.solution("Remove the Problems.throwing() method call from the task action");
+ });
+ }
+}
+```
+
+Check out our [sample project](samples/sample_problems_api_usage.html) for the complete code.
+
+This will enable plugin authors to fully leverage the Problems API to enhance any error with additional details, documentation links, and possible resolution steps.
+
+See the [Problems API](userguide/reporting_problems.html#command_line_interface) for more information.
#### `DependencyConstraintHandler` now has `addProvider` methods
The [`DependencyConstraintHandler`](javadoc/org/gradle/api/artifacts/dsl/DependencyConstraintHandler.html) now has `addProvider` methods, similar to the
[`DependencyHandler`](javadoc/org/gradle/api/artifacts/dsl/DependencyHandler.html).
-```kotlin
-dependencies {
- constraints {
- // Existing API:
- add("implementation", provider { "org.foo:bar:1.0" })
- add("implementation", provider { "org.foo:bar:1.0" }) {
- because("newer versions have bugs")
- }
- // New methods:
- addProvider("implementation", provider { "org.foo:bar:1.0" })
- addProvider("implementation", provider { "org.foo:bar:1.0" }) {
- because("newer versions have bugs")
- }
- }
-}
-```
-
-This clarifies that adding a provider is possible, and that there is no immediately usable return value. The ability to pass a provider to `DependencyConstraintHandler.add` is unaffected.
-
-### Other improvements
-
-#### File-system watching and continuous mode support on Alpine Linux
-
-[File-system watching](userguide/file_system_watching.html) is now supported on Alpine Linux.
-The feature is enabled by default, as on all other supported platforms.
-
-It is now also possible to [run builds in continuous mode](userguide/continuous_builds.html) on Alpine.
-
-<a name="swift-support"></a>
-### Swift support
-
-Gradle’s [Swift support](userguide/building_swift_projects.html) allows building and testing native Swift libraries and applications.
-
-#### Basic Swift 6 support
-
-Gradle now supports [Swift 6](https://www.swift.org/blog/announcing-swift-6/), introduced with [Xcode 16.0](https://developer.apple.com/documentation/xcode-release-notes/xcode-16-release-notes), extending its capabilities to the latest major version of Swift.
-
-<!-- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-ADD RELEASE FEATURES ABOVE
-==========================================================
-
--->
+These are useful in plugin code to bring attention to where inputs should and should not be lazily evaluated by preventing eager results from being passed in.
## Promoted features
+
Promoted features are features that were incubating in previous versions of Gradle but are now supported and subject to backward compatibility.
See the User Manual section on the “[Feature Lifecycle](userguide/feature_lifecycle.html)” for more information.
@@ -194,8 +217,9 @@
### Service reference properties are now stable
-Service references are task properties meant for easier consumption of [shared build services](userguide/build_services.html#sec:service_references).
-[`ServiceReference`](/javadoc/org/gradle/api/services/ServiceReference.html) is now stable.
+Service references are task properties meant to facilitate the consumption of [shared build services](userguide/build_services.html#sec:service_references).
+
+[`ServiceReference`](javadoc/org/gradle/api/services/ServiceReference.html) is now stable.
## Fixed issues
@@ -218,6 +242,6 @@
## Reporting problems
If you find a problem with this release, please file a bug on [GitHub Issues](https://github.com/gradle/gradle/issues) adhering to our issue guidelines.
-If you're not sure you're encountering a bug, please use the [forum](https://discuss.gradle.org/c/help-discuss).
+If you're not sure if you're encountering a bug, please use the [forum](https://discuss.gradle.org/c/help-discuss).
We hope you will build happiness with Gradle, and we look forward to your feedback via [Twitter](https://twitter.com/gradle) or on [GitHub](https://github.com/gradle).
diff --git a/platforms/documentation/docs/src/docs/userguide/authoring-builds/plugins/reporting_problems.adoc b/platforms/documentation/docs/src/docs/userguide/authoring-builds/plugins/reporting_problems.adoc
index ee8ae75..be02ad8 100644
--- a/platforms/documentation/docs/src/docs/userguide/authoring-builds/plugins/reporting_problems.adoc
+++ b/platforms/documentation/docs/src/docs/userguide/authoring-builds/plugins/reporting_problems.adoc
@@ -95,3 +95,26 @@
In addition, there's a more convenient way to access the failure details.
If clients configure the project connection with `LongRunningOperation.withFailureDetails()`, the Tooling API implicitly subscribes to the `ROOT` operation type and provides failure details via the `GradleConnectionException.getFailures()` method.
+
+[[sec:generated_html_report]]
+=== Generated HTML report
+
+The output of the problems generated by the Problems API is also provided as a rich HTML report generated at the end of the build.
+This report serves as a central location for users to review problems that occurred during a build.
+
+Plugin authors can use the Problems API to log events specific to their plugins, adding to the Gradle-generated ones.
+
+The report is not generated if no issues have been reported.
+Also, if you do not want to generate this report, you can disable it with the `--no-problems-report` flag.
+The console output provides a link to this report, as shown below:
+
+[source,text]
+----
+[Incubating] Problem report is available at: <project-dir>/build/reports/problems/problems-report.html
+
+BUILD SUCCESSFUL in 1s
+----
+
+The rendered report link directs you to a detailed HTML view of the problems:
+
+image::problems-report-html.png[]
diff --git a/platforms/documentation/docs/src/docs/userguide/img/problems-report-html.png b/platforms/documentation/docs/src/docs/userguide/img/problems-report-html.png
new file mode 100644
index 0000000..68fecb6
--- /dev/null
+++ b/platforms/documentation/docs/src/docs/userguide/img/problems-report-html.png
Binary files differ
diff --git a/platforms/software/build-init/src/integTest/groovy/org/gradle/buildinit/plugins/KotlinApplicationInitIntegrationTest.groovy b/platforms/software/build-init/src/integTest/groovy/org/gradle/buildinit/plugins/KotlinApplicationInitIntegrationTest.groovy
index a0f6dc6..1ddb8dc 100644
--- a/platforms/software/build-init/src/integTest/groovy/org/gradle/buildinit/plugins/KotlinApplicationInitIntegrationTest.groovy
+++ b/platforms/software/build-init/src/integTest/groovy/org/gradle/buildinit/plugins/KotlinApplicationInitIntegrationTest.groovy
@@ -18,11 +18,13 @@
import org.gradle.api.JavaVersion
import org.gradle.buildinit.plugins.fixtures.ScriptDslFixture
+import org.gradle.integtests.fixtures.ToBeFixedForIsolatedProjects
import org.gradle.test.fixtures.file.LeaksFileHandles
import org.gradle.test.precondition.Requires
import org.gradle.test.preconditions.UnitTestPreconditions
import static org.gradle.buildinit.plugins.internal.modifiers.BuildInitDsl.KOTLIN
+import static org.gradle.integtests.fixtures.ToBeFixedForIsolatedProjects.Skip.FLAKY
import static org.hamcrest.CoreMatchers.containsString
@LeaksFileHandles
@@ -194,6 +196,7 @@
}
@Requires(value = UnitTestPreconditions.KotlinSupportedJdk.class)
+ @ToBeFixedForIsolatedProjects(skip = FLAKY, because = "KGP modifies service parameter properties concurrently")
def "initializes Kotlin application with JUnit Jupiter test framework with --split-project"() {
when:
run('init', '--type', 'kotlin-application', '--test-framework', 'junit-jupiter', "--split-project", '--java-version', JavaVersion.current().majorVersion)
diff --git a/platforms/software/build-init/src/integTest/groovy/org/gradle/buildinit/plugins/MultiProjectJvmApplicationInitIntegrationTest.groovy b/platforms/software/build-init/src/integTest/groovy/org/gradle/buildinit/plugins/MultiProjectJvmApplicationInitIntegrationTest.groovy
index 65b3234..5cdcd87 100644
--- a/platforms/software/build-init/src/integTest/groovy/org/gradle/buildinit/plugins/MultiProjectJvmApplicationInitIntegrationTest.groovy
+++ b/platforms/software/build-init/src/integTest/groovy/org/gradle/buildinit/plugins/MultiProjectJvmApplicationInitIntegrationTest.groovy
@@ -21,6 +21,7 @@
import org.gradle.buildinit.plugins.internal.modifiers.BuildInitDsl
import org.gradle.buildinit.plugins.internal.modifiers.Language
import org.gradle.integtests.fixtures.DefaultTestExecutionResult
+import org.gradle.integtests.fixtures.ToBeFixedForIsolatedProjects
import org.gradle.test.fixtures.file.TestFile
import org.gradle.test.precondition.Requires
import org.gradle.test.preconditions.UnitTestPreconditions
@@ -29,6 +30,7 @@
import static org.gradle.buildinit.plugins.internal.modifiers.Language.JAVA
import static org.gradle.buildinit.plugins.internal.modifiers.Language.KOTLIN
import static org.gradle.buildinit.plugins.internal.modifiers.Language.SCALA
+import static org.gradle.integtests.fixtures.ToBeFixedForIsolatedProjects.Skip.FLAKY
import static org.gradle.util.Matchers.containsLine
import static org.gradle.util.Matchers.containsText
import static org.hamcrest.core.AllOf.allOf
@@ -303,6 +305,7 @@
}
@Requires(value = UnitTestPreconditions.KotlinSupportedJdk.class)
+@ToBeFixedForIsolatedProjects(skip = FLAKY, because = "KGP modifies service parameter properties concurrently")
class GroovyDslMultiProjectKotlinApplicationInitIntegrationTest1 extends AbstractMultiProjectJvmApplicationInitIntegrationTest1 {
def setup() {
setupDslAndLanguage(BuildInitDsl.GROOVY, KOTLIN)
@@ -310,6 +313,7 @@
}
@Requires(value = UnitTestPreconditions.KotlinSupportedJdk.class)
+@ToBeFixedForIsolatedProjects(skip = FLAKY, because = "KGP modifies service parameter properties concurrently")
class GroovyDslMultiProjectKotlinApplicationInitIntegrationTest2 extends AbstractMultiProjectJvmApplicationInitIntegrationTest2 {
def setup() {
setupDslAndLanguage(BuildInitDsl.GROOVY, KOTLIN)
@@ -317,6 +321,7 @@
}
@Requires(value = UnitTestPreconditions.KotlinSupportedJdk.class)
+@ToBeFixedForIsolatedProjects(skip = FLAKY, because = "KGP modifies service parameter properties concurrently")
class GroovyDslMultiProjectKotlinApplicationInitIntegrationTest3 extends AbstractMultiProjectJvmApplicationInitIntegrationTest3 {
def setup() {
setupDslAndLanguage(BuildInitDsl.GROOVY, KOTLIN)
@@ -381,6 +386,7 @@
}
@Requires(value = UnitTestPreconditions.KotlinSupportedJdk.class)
+@ToBeFixedForIsolatedProjects(skip = FLAKY, because = "KGP modifies service parameter properties concurrently")
class KotlinDslMultiProjectKotlinApplicationInitIntegrationTest1 extends AbstractMultiProjectJvmApplicationInitIntegrationTest1 {
def setup() {
setupDslAndLanguage(BuildInitDsl.KOTLIN, KOTLIN)
@@ -388,6 +394,7 @@
}
@Requires(value = UnitTestPreconditions.KotlinSupportedJdk.class)
+@ToBeFixedForIsolatedProjects(skip = FLAKY, because = "KGP modifies service parameter properties concurrently")
class KotlinDslMultiProjectKotlinApplicationInitIntegrationTest2 extends AbstractMultiProjectJvmApplicationInitIntegrationTest2 {
def setup() {
setupDslAndLanguage(BuildInitDsl.KOTLIN, KOTLIN)
@@ -395,6 +402,7 @@
}
@Requires(value = UnitTestPreconditions.KotlinSupportedJdk.class)
+@ToBeFixedForIsolatedProjects(skip = FLAKY, because = "KGP modifies service parameter properties concurrently")
class KotlinDslMultiProjectKotlinApplicationInitIntegrationTest3 extends AbstractMultiProjectJvmApplicationInitIntegrationTest3 {
def setup() {
setupDslAndLanguage(BuildInitDsl.KOTLIN, KOTLIN)
diff --git a/subprojects/core/src/integTest/groovy/org/gradle/process/internal/CancellationIntegrationTest.groovy b/subprojects/core/src/integTest/groovy/org/gradle/process/internal/CancellationIntegrationTest.groovy
index 11f62ec..7dcfa35 100644
--- a/subprojects/core/src/integTest/groovy/org/gradle/process/internal/CancellationIntegrationTest.groovy
+++ b/subprojects/core/src/integTest/groovy/org/gradle/process/internal/CancellationIntegrationTest.groovy
@@ -45,7 +45,9 @@
task projectExecTask {
dependsOn 'compileJava'
doLast {
- def result = exec { commandLine '${fileToPath(Jvm.current().javaExecutable)}', '-cp', '${fileToPath(file('build/classes/java/main'))}', 'Block' }
+ def result = services.get(ExecOperations).exec {
+ commandLine '${fileToPath(Jvm.current().javaExecutable)}', '-cp', '${fileToPath(file('build/classes/java/main'))}', 'Block'
+ }
assert result.exitValue == 0
}
}
diff --git a/testing/internal-integ-testing/src/main/groovy/org/gradle/integtests/fixtures/ToBeFixedForIsolatedProjects.groovy b/testing/internal-integ-testing/src/main/groovy/org/gradle/integtests/fixtures/ToBeFixedForIsolatedProjects.groovy
index 0a3cdb1..b70de38 100644
--- a/testing/internal-integ-testing/src/main/groovy/org/gradle/integtests/fixtures/ToBeFixedForIsolatedProjects.groovy
+++ b/testing/internal-integ-testing/src/main/groovy/org/gradle/integtests/fixtures/ToBeFixedForIsolatedProjects.groovy
@@ -26,7 +26,33 @@
@Retention(RetentionPolicy.RUNTIME)
@Target([ElementType.METHOD, ElementType.TYPE])
@ExtensionAnnotation(ToBeFixedForIsolatedProjectsExtension.class)
-public @interface ToBeFixedForIsolatedProjects {
+@interface ToBeFixedForIsolatedProjects {
+ /**
+ * Set to some {@link Skip} to skip the annotated test.
+ */
+ Skip skip() default Skip.DO_NOT_SKIP;
String because() default "";
+
+ /**
+ * Reason for skipping a test with isolated projects.
+ */
+ enum Skip {
+
+ /**
+ * Do not skip this test, this is the default.
+ */
+ DO_NOT_SKIP {
+ @Override String getReason() { throw new UnsupportedOperationException("Must not be skipped") }
+ },
+
+ /**
+ * Use this reason on tests that intermittently fail with isolated projects.
+ */
+ FLAKY {
+ @Override String getReason() { "flaky" }
+ };
+
+ abstract String getReason();
+ }
}
diff --git a/testing/internal-integ-testing/src/main/groovy/org/gradle/integtests/fixtures/ToBeFixedForIsolatedProjectsExtension.groovy b/testing/internal-integ-testing/src/main/groovy/org/gradle/integtests/fixtures/ToBeFixedForIsolatedProjectsExtension.groovy
index 95d9a54..86f44d2 100644
--- a/testing/internal-integ-testing/src/main/groovy/org/gradle/integtests/fixtures/ToBeFixedForIsolatedProjectsExtension.groovy
+++ b/testing/internal-integ-testing/src/main/groovy/org/gradle/integtests/fixtures/ToBeFixedForIsolatedProjectsExtension.groovy
@@ -22,25 +22,32 @@
import org.spockframework.runtime.model.SpecElementInfo
import org.spockframework.runtime.model.SpecInfo
+import static org.gradle.integtests.fixtures.ToBeFixedForIsolatedProjects.Skip.DO_NOT_SKIP
+
class ToBeFixedForIsolatedProjectsExtension implements IAnnotationDrivenExtension<ToBeFixedForIsolatedProjects> {
private final ToBeFixedSpecInterceptor toBeFixedSpecInterceptor = new ToBeFixedSpecInterceptor("Isolated Projects")
@Override
void visitSpecAnnotation(ToBeFixedForIsolatedProjects annotation, SpecInfo spec) {
- visitAnnotation(spec)
+ visitAnnotation(annotation, spec)
}
@Override
void visitFeatureAnnotation(ToBeFixedForIsolatedProjects annotation, FeatureInfo feature) {
- visitAnnotation(feature)
+ visitAnnotation(annotation, feature)
}
- private void visitAnnotation(SpecElementInfo specElementInfo) {
+ private void visitAnnotation(ToBeFixedForIsolatedProjects annotation, SpecElementInfo specElementInfo) {
if (GradleContextualExecuter.isNotIsolatedProjects()) {
return
}
+ if (annotation.skip() != DO_NOT_SKIP) {
+ specElementInfo.skip(annotation.skip().reason)
+ return
+ }
+
toBeFixedSpecInterceptor.intercept(specElementInfo, new String[0])
}
}
