From 230615d69985c65163d9f8c25e557465888b072e Mon Sep 17 00:00:00 2001 From: Callum Rogers Date: Fri, 6 May 2022 21:33:17 +0100 Subject: [PATCH 01/12] Map thing --- .../javaversions/LazyConfigurableMap.java | 63 +++++++++++++++++++ 1 file changed, 63 insertions(+) create mode 100644 gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/javaversions/LazyConfigurableMap.java diff --git a/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/javaversions/LazyConfigurableMap.java b/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/javaversions/LazyConfigurableMap.java new file mode 100644 index 000000000..4c6960055 --- /dev/null +++ b/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/javaversions/LazyConfigurableMap.java @@ -0,0 +1,63 @@ +/* + * (c) Copyright 2022 Palantir Technologies Inc. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.palantir.baseline.plugins.javaversions; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.function.Supplier; +import org.gradle.api.Action; + +final class LazyConfigurableMap { + private final Supplier valueFactory; + private final List> entries = new ArrayList<>(); + private final Map computedValues = new HashMap<>(); + + LazyConfigurableMap(Supplier valueFactory) { + this.valueFactory = valueFactory; + } + + public void put(K key, Action value) { + entries.add(0, requestedKey -> { + if (requestedKey.equals(key)) { + return Optional.of(value); + } + + return Optional.empty(); + }); + } + + public void put(LazyEntry lazyEntry) { + entries.add(0, lazyEntry); + } + + public V get(K key) { + return computedValues.computeIfAbsent(key, _ignored -> { + V value = valueFactory.get(); + entries.forEach(lazyEntry -> { + lazyEntry.blah(key).ifPresent(action -> action.execute(value)); + }); + return value; + }); + } + + interface LazyEntry { + Optional> blah(K key); + } +} From 423b53301d120823bbdb3dc5ad4d8239864a1914 Mon Sep 17 00:00:00 2001 From: Callum Rogers Date: Mon, 9 May 2022 18:15:01 +0100 Subject: [PATCH 02/12] save --- .../BaselineJavaVersionsExtension.java | 19 +++++ .../plugins/BaselineJavaVersions.java | 1 + .../javaversions/LazyConfigurableMap.java | 78 +++++++++++++++---- 3 files changed, 85 insertions(+), 13 deletions(-) diff --git a/gradle-baseline-java/src/main/groovy/com/palantir/baseline/extensions/BaselineJavaVersionsExtension.java b/gradle-baseline-java/src/main/groovy/com/palantir/baseline/extensions/BaselineJavaVersionsExtension.java index bdb4aca4b..4e1e78315 100644 --- a/gradle-baseline-java/src/main/groovy/com/palantir/baseline/extensions/BaselineJavaVersionsExtension.java +++ b/gradle-baseline-java/src/main/groovy/com/palantir/baseline/extensions/BaselineJavaVersionsExtension.java @@ -16,6 +16,9 @@ package com.palantir.baseline.extensions; +import com.palantir.baseline.plugins.javaversions.LazyConfigurableMap; +import java.util.Optional; +import java.util.concurrent.atomic.AtomicReference; import javax.inject.Inject; import org.gradle.api.Project; import org.gradle.api.provider.MapProperty; @@ -33,6 +36,9 @@ public class BaselineJavaVersionsExtension { private final Property runtime; private final MapProperty jdks; + private final LazyConfigurableMap> newJdks = + new LazyConfigurableMap<>(AtomicReference::new); + @Inject public BaselineJavaVersionsExtension(Project project) { this.libraryTarget = project.getObjects().property(JavaLanguageVersion.class); @@ -83,4 +89,17 @@ public final void setRuntime(int value) { public final MapProperty getJdks() { return jdks; } + + public final void jdk(JavaLanguageVersion javaLanguageVersion, JavaInstallationMetadata javaInstallationMetadata) { + newJdks.put(javaLanguageVersion, ref -> ref.set(javaInstallationMetadata)); + } + + public final void jdks(LazyJdks lazyJdks) { + newJdks.put(javaLanguageVersion -> lazyJdks.jdkFor(javaLanguageVersion) + .map(javaInstallationMetadata -> ref -> ref.set(javaInstallationMetadata))); + } + + public interface LazyJdks { + Optional jdkFor(JavaLanguageVersion javaLanguageVersion); + } } diff --git a/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/BaselineJavaVersions.java b/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/BaselineJavaVersions.java index cd5856afb..6c7273aad 100644 --- a/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/BaselineJavaVersions.java +++ b/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/BaselineJavaVersions.java @@ -55,6 +55,7 @@ public void apply(Project project) { throw new GradleException(String.format( "BaselineJavaVersions requires %s. %s is not supported", MIN_GRADLE_VERSION, currentGradleVersion)); } + BaselineJavaVersionsExtension rootExtension = project.getExtensions().create(EXTENSION_NAME, BaselineJavaVersionsExtension.class, project); project.allprojects(proj -> proj.getPluginManager().withPlugin("java", unused -> { diff --git a/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/javaversions/LazyConfigurableMap.java b/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/javaversions/LazyConfigurableMap.java index 4c6960055..3153ee535 100644 --- a/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/javaversions/LazyConfigurableMap.java +++ b/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/javaversions/LazyConfigurableMap.java @@ -21,20 +21,26 @@ import java.util.List; import java.util.Map; import java.util.Optional; +import java.util.concurrent.atomic.AtomicBoolean; import java.util.function.Supplier; import org.gradle.api.Action; +import org.gradle.api.provider.Provider; -final class LazyConfigurableMap { +public final class LazyConfigurableMap { private final Supplier valueFactory; - private final List> entries = new ArrayList<>(); - private final Map computedValues = new HashMap<>(); + private final List> values = new ArrayList<>(); + private final Map> computedValues = new HashMap<>(); - LazyConfigurableMap(Supplier valueFactory) { + public LazyConfigurableMap(Supplier valueFactory) { this.valueFactory = valueFactory; } + public void put(LazyValues lazyValues) { + values.add(lazyValues); + } + public void put(K key, Action value) { - entries.add(0, requestedKey -> { + put(requestedKey -> { if (requestedKey.equals(key)) { return Optional.of(value); } @@ -43,21 +49,67 @@ public void put(K key, Action value) { }); } - public void put(LazyEntry lazyEntry) { - entries.add(0, lazyEntry); + public void put(Provider>> map) { + put(key -> Optional.ofNullable(map.get().get(key))); } public V get(K key) { - return computedValues.computeIfAbsent(key, _ignored -> { - V value = valueFactory.get(); - entries.forEach(lazyEntry -> { - lazyEntry.blah(key).ifPresent(action -> action.execute(value)); + Optional> existing = Optional.ofNullable(computedValues.get(key)); + Lol lol = existing.orElseGet(() -> new Lol<>(0, valueFactory.get())); + AtomicBoolean exists = new AtomicBoolean(existing.isPresent()); + + values.stream().skip(lol.upTo).forEach(lazyValues -> { + lazyValues.blah(key).ifPresent(action -> { + exists.set(true); + action.execute(lol.value); }); - return value; }); + + if (exists.get()) { + lol.upTo = values.size(); + computedValues.put(key, lol); + return lol.value; + } + + throw new RuntimeException("can't find it"); + + // computedValues.computeIfAbsent(key, _ignored -> { + // V value = valueFactory.get(); + // values.forEach(lazyValues -> { + // lazyValues.blah(key).ifPresent(action -> { + // exists.set(true); + // action.execute(value); + // }); + // }); + // + // if (exists.get()) {} + // + // for (int i = values.size() - 1; i >= 0; i--) { + // values.get(i).blah(key).ifPresent(action -> action.execute(value)); + // } + // return value; + // }); + // + // return computedValues.computeIfAbsent(key, _ignored -> { + // V value = valueFactory.get(); + // for (int i = values.size() - 1; i >= 0; i--) { + // values.get(i).blah(key).ifPresent(action -> action.execute(value)); + // } + // return value; + // }); + } + + private static final class Lol { + private int upTo; + private final V value; + + Lol(int upTo, V value) { + this.upTo = upTo; + this.value = value; + } } - interface LazyEntry { + public interface LazyValues { Optional> blah(K key); } } From f7681824cc46270e2ba64f5656a4a6b64016d5de Mon Sep 17 00:00:00 2001 From: Callum Rogers Date: Tue, 10 May 2022 10:58:33 +0100 Subject: [PATCH 03/12] Better names --- .../BaselineJavaVersionsExtension.java | 6 +- .../javaversions/LazilyConfiguredMap.java | 89 ++++++++++++++ .../javaversions/LazyConfigurableMap.java | 115 ------------------ 3 files changed, 92 insertions(+), 118 deletions(-) create mode 100644 gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/javaversions/LazilyConfiguredMap.java delete mode 100644 gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/javaversions/LazyConfigurableMap.java diff --git a/gradle-baseline-java/src/main/groovy/com/palantir/baseline/extensions/BaselineJavaVersionsExtension.java b/gradle-baseline-java/src/main/groovy/com/palantir/baseline/extensions/BaselineJavaVersionsExtension.java index 4e1e78315..873286581 100644 --- a/gradle-baseline-java/src/main/groovy/com/palantir/baseline/extensions/BaselineJavaVersionsExtension.java +++ b/gradle-baseline-java/src/main/groovy/com/palantir/baseline/extensions/BaselineJavaVersionsExtension.java @@ -16,7 +16,7 @@ package com.palantir.baseline.extensions; -import com.palantir.baseline.plugins.javaversions.LazyConfigurableMap; +import com.palantir.baseline.plugins.javaversions.LazilyConfiguredMap; import java.util.Optional; import java.util.concurrent.atomic.AtomicReference; import javax.inject.Inject; @@ -36,8 +36,8 @@ public class BaselineJavaVersionsExtension { private final Property runtime; private final MapProperty jdks; - private final LazyConfigurableMap> newJdks = - new LazyConfigurableMap<>(AtomicReference::new); + private final LazilyConfiguredMap> newJdks = + new LazilyConfiguredMap<>(AtomicReference::new); @Inject public BaselineJavaVersionsExtension(Project project) { diff --git a/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/javaversions/LazilyConfiguredMap.java b/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/javaversions/LazilyConfiguredMap.java new file mode 100644 index 000000000..1c7e8e1ec --- /dev/null +++ b/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/javaversions/LazilyConfiguredMap.java @@ -0,0 +1,89 @@ +/* + * (c) Copyright 2022 Palantir Technologies Inc. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.palantir.baseline.plugins.javaversions; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.concurrent.atomic.AtomicBoolean; +import java.util.function.Supplier; +import org.gradle.api.Action; +import org.gradle.api.provider.Provider; + +public final class LazilyConfiguredMap { + private final Supplier valueFactory; + private final List> values = new ArrayList<>(); + private final Map> computedValues = new HashMap<>(); + + public LazilyConfiguredMap(Supplier valueFactory) { + this.valueFactory = valueFactory; + } + + public void put(LazyValues lazyValues) { + values.add(lazyValues); + } + + public void put(K key, Action value) { + put(requestedKey -> { + if (requestedKey.equals(key)) { + return Optional.of(value); + } + + return Optional.empty(); + }); + } + + public void put(Provider>> map) { + put(key -> Optional.ofNullable(map.get().get(key))); + } + + public V get(K key) { + Optional> maybeExistingTracking = Optional.ofNullable(computedValues.get(key)); + Tracking tracking = maybeExistingTracking.orElseGet(() -> new Tracking<>(valueFactory.get())); + AtomicBoolean exists = new AtomicBoolean(maybeExistingTracking.isPresent()); + + values.stream().skip(tracking.upTo).forEach(lazyValues -> { + lazyValues.compute(key).ifPresent(action -> { + exists.set(true); + action.execute(tracking.value); + }); + }); + + if (!exists.get()) { + throw new RuntimeException("can't find it"); + } + + tracking.upTo = values.size(); + computedValues.put(key, tracking); + return tracking.value; + } + + private static final class Tracking { + private int upTo = 0; + private final V value; + + Tracking(V value) { + this.value = value; + } + } + + public interface LazyValues { + Optional> compute(K key); + } +} diff --git a/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/javaversions/LazyConfigurableMap.java b/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/javaversions/LazyConfigurableMap.java deleted file mode 100644 index 3153ee535..000000000 --- a/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/javaversions/LazyConfigurableMap.java +++ /dev/null @@ -1,115 +0,0 @@ -/* - * (c) Copyright 2022 Palantir Technologies Inc. All rights reserved. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package com.palantir.baseline.plugins.javaversions; - -import java.util.ArrayList; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.Optional; -import java.util.concurrent.atomic.AtomicBoolean; -import java.util.function.Supplier; -import org.gradle.api.Action; -import org.gradle.api.provider.Provider; - -public final class LazyConfigurableMap { - private final Supplier valueFactory; - private final List> values = new ArrayList<>(); - private final Map> computedValues = new HashMap<>(); - - public LazyConfigurableMap(Supplier valueFactory) { - this.valueFactory = valueFactory; - } - - public void put(LazyValues lazyValues) { - values.add(lazyValues); - } - - public void put(K key, Action value) { - put(requestedKey -> { - if (requestedKey.equals(key)) { - return Optional.of(value); - } - - return Optional.empty(); - }); - } - - public void put(Provider>> map) { - put(key -> Optional.ofNullable(map.get().get(key))); - } - - public V get(K key) { - Optional> existing = Optional.ofNullable(computedValues.get(key)); - Lol lol = existing.orElseGet(() -> new Lol<>(0, valueFactory.get())); - AtomicBoolean exists = new AtomicBoolean(existing.isPresent()); - - values.stream().skip(lol.upTo).forEach(lazyValues -> { - lazyValues.blah(key).ifPresent(action -> { - exists.set(true); - action.execute(lol.value); - }); - }); - - if (exists.get()) { - lol.upTo = values.size(); - computedValues.put(key, lol); - return lol.value; - } - - throw new RuntimeException("can't find it"); - - // computedValues.computeIfAbsent(key, _ignored -> { - // V value = valueFactory.get(); - // values.forEach(lazyValues -> { - // lazyValues.blah(key).ifPresent(action -> { - // exists.set(true); - // action.execute(value); - // }); - // }); - // - // if (exists.get()) {} - // - // for (int i = values.size() - 1; i >= 0; i--) { - // values.get(i).blah(key).ifPresent(action -> action.execute(value)); - // } - // return value; - // }); - // - // return computedValues.computeIfAbsent(key, _ignored -> { - // V value = valueFactory.get(); - // for (int i = values.size() - 1; i >= 0; i--) { - // values.get(i).blah(key).ifPresent(action -> action.execute(value)); - // } - // return value; - // }); - } - - private static final class Lol { - private int upTo; - private final V value; - - Lol(int upTo, V value) { - this.upTo = upTo; - this.value = value; - } - } - - public interface LazyValues { - Optional> blah(K key); - } -} From 03b413962c0a5be3338515fd5c8490dd55027936 Mon Sep 17 00:00:00 2001 From: Callum Rogers Date: Tue, 10 May 2022 11:35:56 +0100 Subject: [PATCH 04/12] Write some tests --- .../BaselineJavaVersionsExtension.java | 6 +- ...dMap.java => LazilyConfiguredMapping.java} | 60 +++++------ .../LazilyConfiguredMappingTest.java | 102 ++++++++++++++++++ 3 files changed, 135 insertions(+), 33 deletions(-) rename gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/javaversions/{LazilyConfiguredMap.java => LazilyConfiguredMapping.java} (56%) create mode 100644 gradle-baseline-java/src/test/groovy/com/palantir/baseline/plugins/javaversions/LazilyConfiguredMappingTest.java diff --git a/gradle-baseline-java/src/main/groovy/com/palantir/baseline/extensions/BaselineJavaVersionsExtension.java b/gradle-baseline-java/src/main/groovy/com/palantir/baseline/extensions/BaselineJavaVersionsExtension.java index 873286581..bff9597dd 100644 --- a/gradle-baseline-java/src/main/groovy/com/palantir/baseline/extensions/BaselineJavaVersionsExtension.java +++ b/gradle-baseline-java/src/main/groovy/com/palantir/baseline/extensions/BaselineJavaVersionsExtension.java @@ -16,7 +16,7 @@ package com.palantir.baseline.extensions; -import com.palantir.baseline.plugins.javaversions.LazilyConfiguredMap; +import com.palantir.baseline.plugins.javaversions.LazilyConfiguredMapping; import java.util.Optional; import java.util.concurrent.atomic.AtomicReference; import javax.inject.Inject; @@ -36,8 +36,8 @@ public class BaselineJavaVersionsExtension { private final Property runtime; private final MapProperty jdks; - private final LazilyConfiguredMap> newJdks = - new LazilyConfiguredMap<>(AtomicReference::new); + private final LazilyConfiguredMapping> newJdks = + new LazilyConfiguredMapping<>(AtomicReference::new); @Inject public BaselineJavaVersionsExtension(Project project) { diff --git a/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/javaversions/LazilyConfiguredMap.java b/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/javaversions/LazilyConfiguredMapping.java similarity index 56% rename from gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/javaversions/LazilyConfiguredMap.java rename to gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/javaversions/LazilyConfiguredMapping.java index 1c7e8e1ec..94d3d207c 100644 --- a/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/javaversions/LazilyConfiguredMap.java +++ b/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/javaversions/LazilyConfiguredMapping.java @@ -24,22 +24,26 @@ import java.util.concurrent.atomic.AtomicBoolean; import java.util.function.Supplier; import org.gradle.api.Action; -import org.gradle.api.provider.Provider; -public final class LazilyConfiguredMap { +public final class LazilyConfiguredMapping { private final Supplier valueFactory; private final List> values = new ArrayList<>(); - private final Map> computedValues = new HashMap<>(); + private final Map> computedValues = new HashMap<>(); + private boolean finalized = false; - public LazilyConfiguredMap(Supplier valueFactory) { + public LazilyConfiguredMapping(Supplier valueFactory) { this.valueFactory = valueFactory; } public void put(LazyValues lazyValues) { + ensureNotFinalized(); + values.add(lazyValues); } public void put(K key, Action value) { + ensureNotFinalized(); + put(requestedKey -> { if (requestedKey.equals(key)) { return Optional.of(value); @@ -49,38 +53,34 @@ public void put(K key, Action value) { }); } - public void put(Provider>> map) { - put(key -> Optional.ofNullable(map.get().get(key))); + private void ensureNotFinalized() { + if (finalized) { + throw new IllegalStateException(String.format( + "This %s has already been finalized as get() hase been called. " + + "No further elements can be added to it", + LazilyConfiguredMapping.class.getSimpleName())); + } } - public V get(K key) { - Optional> maybeExistingTracking = Optional.ofNullable(computedValues.get(key)); - Tracking tracking = maybeExistingTracking.orElseGet(() -> new Tracking<>(valueFactory.get())); - AtomicBoolean exists = new AtomicBoolean(maybeExistingTracking.isPresent()); + public Optional get(K key) { + finalized = true; - values.stream().skip(tracking.upTo).forEach(lazyValues -> { - lazyValues.compute(key).ifPresent(action -> { - exists.set(true); - action.execute(tracking.value); + return computedValues.computeIfAbsent(key, _ignored -> { + V value = valueFactory.get(); + AtomicBoolean created = new AtomicBoolean(false); + values.forEach(lazyValues -> { + lazyValues.compute(key).ifPresent(action -> { + created.set(true); + action.execute(value); + }); }); - }); - if (!exists.get()) { - throw new RuntimeException("can't find it"); - } - - tracking.upTo = values.size(); - computedValues.put(key, tracking); - return tracking.value; - } - - private static final class Tracking { - private int upTo = 0; - private final V value; + if (created.get()) { + return Optional.of(value); + } - Tracking(V value) { - this.value = value; - } + return Optional.empty(); + }); } public interface LazyValues { diff --git a/gradle-baseline-java/src/test/groovy/com/palantir/baseline/plugins/javaversions/LazilyConfiguredMappingTest.java b/gradle-baseline-java/src/test/groovy/com/palantir/baseline/plugins/javaversions/LazilyConfiguredMappingTest.java new file mode 100644 index 000000000..cba93df51 --- /dev/null +++ b/gradle-baseline-java/src/test/groovy/com/palantir/baseline/plugins/javaversions/LazilyConfiguredMappingTest.java @@ -0,0 +1,102 @@ +/* + * (c) Copyright 2022 Palantir Technologies Inc. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.palantir.baseline.plugins.javaversions; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatExceptionOfType; + +import java.util.Optional; +import org.junit.jupiter.api.Test; + +class LazilyConfiguredMappingTest { + private final LazilyConfiguredMapping lazilyConfiguredMapping = + new LazilyConfiguredMapping<>(() -> new Extension(0)); + + @Test + void empty_mapping_returns_optional_empty() { + assertThat(lazilyConfiguredMapping.get("abc")).isEmpty(); + } + + @Test + void can_put_a_value_and_get_it_out_again() { + lazilyConfiguredMapping.put("foo", extension -> extension.number = 4); + + assertThat(lazilyConfiguredMapping.get("foo")).hasValue(new Extension(4)); + } + + @Test + void can_put_a_lazy_value_in_and_get_it_out_again() { + lazilyConfiguredMapping.put(key -> Optional.of(extension -> extension.number = Integer.parseInt(key))); + + assertThat(lazilyConfiguredMapping.get("3")).hasValue(new Extension(3)); + assertThat(lazilyConfiguredMapping.get("9")).hasValue(new Extension(9)); + } + + @Test + void lazy_values_are_able_to_not_return_values() { + lazilyConfiguredMapping.put(_key -> Optional.empty()); + + assertThat(lazilyConfiguredMapping.get("abc")).isEmpty(); + } + + @Test + void interspersing_putting_values_takes_the_last_set_value() { + lazilyConfiguredMapping.put("1", extension -> extension.number = 80); + lazilyConfiguredMapping.put(key -> Optional.of(extension -> extension.number = Integer.parseInt(key))); + lazilyConfiguredMapping.put("4", extension -> extension.number = 99); + + assertThat(lazilyConfiguredMapping.get("1")).hasValue(new Extension(1)); + assertThat(lazilyConfiguredMapping.get("3")).hasValue(new Extension(3)); + assertThat(lazilyConfiguredMapping.get("4")).hasValue(new Extension(99)); + } + + @Test + void throws_if_putting_values_after_being_finalized() { + lazilyConfiguredMapping.get("abc"); + + assertThatExceptionOfType(IllegalStateException.class).isThrownBy(() -> { + lazilyConfiguredMapping.put("foo", extension -> {}); + }); + + assertThatExceptionOfType(IllegalStateException.class).isThrownBy(() -> { + lazilyConfiguredMapping.put(key -> Optional.of(extension -> {})); + }); + } + + private static final class Extension { + public int number; + + Extension(int number) { + this.number = number; + } + + @Override + public boolean equals(Object obj) { + return number == ((Extension) obj).number; + } + + @Override + public int hashCode() { + return number; + } + + @Override + public String toString() { + return Integer.toString(number); + } + } +} From 3f0ee454f83fa7225d99b604bf16681dfcfdbb72 Mon Sep 17 00:00:00 2001 From: Callum Rogers Date: Tue, 10 May 2022 11:54:30 +0100 Subject: [PATCH 05/12] Remove old MapProperty --- .../BaselineJavaVersionsExtension.java | 16 +++++----------- .../plugins/javaversions/JavaToolchains.java | 19 ++++++++++--------- 2 files changed, 15 insertions(+), 20 deletions(-) diff --git a/gradle-baseline-java/src/main/groovy/com/palantir/baseline/extensions/BaselineJavaVersionsExtension.java b/gradle-baseline-java/src/main/groovy/com/palantir/baseline/extensions/BaselineJavaVersionsExtension.java index bff9597dd..3d33bea40 100644 --- a/gradle-baseline-java/src/main/groovy/com/palantir/baseline/extensions/BaselineJavaVersionsExtension.java +++ b/gradle-baseline-java/src/main/groovy/com/palantir/baseline/extensions/BaselineJavaVersionsExtension.java @@ -21,7 +21,6 @@ import java.util.concurrent.atomic.AtomicReference; import javax.inject.Inject; import org.gradle.api.Project; -import org.gradle.api.provider.MapProperty; import org.gradle.api.provider.Property; import org.gradle.jvm.toolchain.JavaInstallationMetadata; import org.gradle.jvm.toolchain.JavaLanguageVersion; @@ -34,9 +33,7 @@ public class BaselineJavaVersionsExtension { private final Property libraryTarget; private final Property distributionTarget; private final Property runtime; - private final MapProperty jdks; - - private final LazilyConfiguredMapping> newJdks = + private final LazilyConfiguredMapping> jdks = new LazilyConfiguredMapping<>(AtomicReference::new); @Inject @@ -51,9 +48,6 @@ public BaselineJavaVersionsExtension(Project project) { libraryTarget.finalizeValueOnRead(); distributionTarget.finalizeValueOnRead(); runtime.finalizeValueOnRead(); - - jdks = project.getObjects().mapProperty(JavaLanguageVersion.class, JavaInstallationMetadata.class); - jdks.finalizeValueOnRead(); } /** Target {@link JavaLanguageVersion} for compilation of libraries that are published. */ @@ -86,16 +80,16 @@ public final void setRuntime(int value) { runtime.set(JavaLanguageVersion.of(value)); } - public final MapProperty getJdks() { - return jdks; + public final Optional jdkMetadataFor(JavaLanguageVersion javaLanguageVersion) { + return jdks.get(javaLanguageVersion).map(AtomicReference::get); } public final void jdk(JavaLanguageVersion javaLanguageVersion, JavaInstallationMetadata javaInstallationMetadata) { - newJdks.put(javaLanguageVersion, ref -> ref.set(javaInstallationMetadata)); + jdks.put(javaLanguageVersion, ref -> ref.set(javaInstallationMetadata)); } public final void jdks(LazyJdks lazyJdks) { - newJdks.put(javaLanguageVersion -> lazyJdks.jdkFor(javaLanguageVersion) + jdks.put(javaLanguageVersion -> lazyJdks.jdkFor(javaLanguageVersion) .map(javaInstallationMetadata -> ref -> ref.set(javaInstallationMetadata))); } diff --git a/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/javaversions/JavaToolchains.java b/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/javaversions/JavaToolchains.java index 12f203539..67333a304 100644 --- a/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/javaversions/JavaToolchains.java +++ b/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/javaversions/JavaToolchains.java @@ -34,15 +34,16 @@ public JavaToolchains(Project project, BaselineJavaVersionsExtension baselineJav public Provider forVersion(Provider javaLanguageVersionProvider) { return javaLanguageVersionProvider.map(javaLanguageVersion -> { - Provider configuredJdkMetadata = baselineJavaVersionsExtension - .getJdks() - .getting(javaLanguageVersion) - .orElse(project.provider(() -> project.getExtensions() - .getByType(JavaToolchainService.class) - .launcherFor(javaToolchainSpec -> - javaToolchainSpec.getLanguageVersion().set(javaLanguageVersion)) - .get() - .getMetadata())); + Provider configuredJdkMetadata = + project.provider(() -> baselineJavaVersionsExtension + .jdkMetadataFor(javaLanguageVersion) + .orElseGet(() -> project.getExtensions() + .getByType(JavaToolchainService.class) + .launcherFor(javaToolchainSpec -> javaToolchainSpec + .getLanguageVersion() + .set(javaLanguageVersion)) + .get() + .getMetadata())); return new ConfiguredJavaToolchain( project.getObjects(), From e7c3c18be9401eab742f5e468589e522bab9b4d4 Mon Sep 17 00:00:00 2001 From: Callum Rogers Date: Tue, 10 May 2022 13:19:39 +0100 Subject: [PATCH 06/12] Undo accidental changes --- .../com/palantir/baseline/plugins/BaselineJavaVersions.java | 1 - 1 file changed, 1 deletion(-) diff --git a/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/BaselineJavaVersions.java b/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/BaselineJavaVersions.java index 6c7273aad..cd5856afb 100644 --- a/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/BaselineJavaVersions.java +++ b/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/BaselineJavaVersions.java @@ -55,7 +55,6 @@ public void apply(Project project) { throw new GradleException(String.format( "BaselineJavaVersions requires %s. %s is not supported", MIN_GRADLE_VERSION, currentGradleVersion)); } - BaselineJavaVersionsExtension rootExtension = project.getExtensions().create(EXTENSION_NAME, BaselineJavaVersionsExtension.class, project); project.allprojects(proj -> proj.getPluginManager().withPlugin("java", unused -> { From 3751c7028ff0a509e73db3db0568ce897bd33707 Mon Sep 17 00:00:00 2001 From: Callum Rogers Date: Tue, 10 May 2022 13:39:04 +0100 Subject: [PATCH 07/12] Fix test --- .../palantir/baseline/BaselineJavaVersionIntegrationTest.groovy | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/gradle-baseline-java/src/test/groovy/com/palantir/baseline/BaselineJavaVersionIntegrationTest.groovy b/gradle-baseline-java/src/test/groovy/com/palantir/baseline/BaselineJavaVersionIntegrationTest.groovy index 740ce2660..3b21868fe 100644 --- a/gradle-baseline-java/src/test/groovy/com/palantir/baseline/BaselineJavaVersionIntegrationTest.groovy +++ b/gradle-baseline-java/src/test/groovy/com/palantir/baseline/BaselineJavaVersionIntegrationTest.groovy @@ -302,7 +302,7 @@ class BaselineJavaVersionIntegrationTest extends IntegrationSpec { javaVersions { libraryTarget = 11 - jdks.put JavaLanguageVersion.of(11), new JavaInstallationMetadata() { + jdk JavaLanguageVersion.of(11), new JavaInstallationMetadata() { @Override JavaLanguageVersion getLanguageVersion() { return JavaLanguageVersion.of(11) From 482bdc1d8e48fdcce084558e79ebaca9b9ad71e9 Mon Sep 17 00:00:00 2001 From: svc-changelog Date: Tue, 10 May 2022 12:46:24 +0000 Subject: [PATCH 08/12] Add generated changelog entries --- changelog/@unreleased/pr-2263.v2.yml | 5 +++++ 1 file changed, 5 insertions(+) create mode 100644 changelog/@unreleased/pr-2263.v2.yml diff --git a/changelog/@unreleased/pr-2263.v2.yml b/changelog/@unreleased/pr-2263.v2.yml new file mode 100644 index 000000000..fdd0117ae --- /dev/null +++ b/changelog/@unreleased/pr-2263.v2.yml @@ -0,0 +1,5 @@ +type: fix +fix: + description: More lazily acquire JDK storage locations + links: + - https://github.com/palantir/gradle-baseline/pull/2263 From ae022f2ddd8a05cd63ebdbcbc8fd6db0c5666277 Mon Sep 17 00:00:00 2001 From: Callum Rogers Date: Wed, 11 May 2022 18:41:10 +0100 Subject: [PATCH 09/12] Add additional data so we can pas through project for resolution --- .../BaselineJavaVersionsExtension.java | 14 ++++--- .../baseline/plugins/BaselineJavaVersion.java | 40 +++++++++++++------ .../plugins/javaversions/JavaToolchains.java | 6 ++- .../javaversions/LazilyConfiguredMapping.java | 16 ++++---- .../CheckExplicitSourceCompatibilityTask.java | 2 +- .../LazilyConfiguredMappingTest.java | 32 ++++++++------- 6 files changed, 67 insertions(+), 43 deletions(-) diff --git a/gradle-baseline-java/src/main/groovy/com/palantir/baseline/extensions/BaselineJavaVersionsExtension.java b/gradle-baseline-java/src/main/groovy/com/palantir/baseline/extensions/BaselineJavaVersionsExtension.java index 3d33bea40..730bfaff7 100644 --- a/gradle-baseline-java/src/main/groovy/com/palantir/baseline/extensions/BaselineJavaVersionsExtension.java +++ b/gradle-baseline-java/src/main/groovy/com/palantir/baseline/extensions/BaselineJavaVersionsExtension.java @@ -21,6 +21,7 @@ import java.util.concurrent.atomic.AtomicReference; import javax.inject.Inject; import org.gradle.api.Project; +import org.gradle.api.Task; import org.gradle.api.provider.Property; import org.gradle.jvm.toolchain.JavaInstallationMetadata; import org.gradle.jvm.toolchain.JavaLanguageVersion; @@ -33,7 +34,7 @@ public class BaselineJavaVersionsExtension { private final Property libraryTarget; private final Property distributionTarget; private final Property runtime; - private final LazilyConfiguredMapping> jdks = + private final LazilyConfiguredMapping, Task> jdks = new LazilyConfiguredMapping<>(AtomicReference::new); @Inject @@ -80,8 +81,8 @@ public final void setRuntime(int value) { runtime.set(JavaLanguageVersion.of(value)); } - public final Optional jdkMetadataFor(JavaLanguageVersion javaLanguageVersion) { - return jdks.get(javaLanguageVersion).map(AtomicReference::get); + public final Optional jdkMetadataFor(JavaLanguageVersion javaLanguageVersion, Task task) { + return jdks.get(javaLanguageVersion, task).map(AtomicReference::get); } public final void jdk(JavaLanguageVersion javaLanguageVersion, JavaInstallationMetadata javaInstallationMetadata) { @@ -89,11 +90,14 @@ public final void jdk(JavaLanguageVersion javaLanguageVersion, JavaInstallationM } public final void jdks(LazyJdks lazyJdks) { - jdks.put(javaLanguageVersion -> lazyJdks.jdkFor(javaLanguageVersion) + jdks.put((javaLanguageVersion, task) -> lazyJdks.jdkFor(javaLanguageVersion, task) .map(javaInstallationMetadata -> ref -> ref.set(javaInstallationMetadata))); } public interface LazyJdks { - Optional jdkFor(JavaLanguageVersion javaLanguageVersion); + // We pass through Task here as it's an easy way to get the Project, so if something needs to resolve a + // configuration it can do so without resolving in a different Project, which is deprecated and will be + // banned come Gradle 8 + Optional jdkFor(JavaLanguageVersion javaLanguageVersion, Task task); } } diff --git a/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/BaselineJavaVersion.java b/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/BaselineJavaVersion.java index 30c47036c..b83e9d26e 100644 --- a/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/BaselineJavaVersion.java +++ b/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/BaselineJavaVersion.java @@ -68,11 +68,14 @@ public void execute(JavaToolchainSpec javaToolchainSpec) { JavaToolchains javaToolchains = new JavaToolchains( project, project.getRootProject().getExtensions().getByType(BaselineJavaVersionsExtension.class)); + JavaToolchainProvider blah = task -> javaToolchains.forVersion(extension.target(), task); + // Compilation tasks (using target version) - configureCompilationTasks(project, extension.target(), javaToolchains.forVersion(extension.target())); + configureCompilationTasks( + project, extension.target(), task -> javaToolchains.forVersion(extension.target(), task)); // Execution tasks (using the runtime version) - configureExecutionTasks(project, javaToolchains.forVersion(extension.runtime())); + configureExecutionTasks(project, task -> javaToolchains.forVersion(extension.runtime(), task)); // Validation project.getTasks() @@ -87,14 +90,18 @@ public void execute(CheckJavaVersionsTask task) { }); } + interface JavaToolchainProvider { + Provider forTask(Task task); + } + private static void configureCompilationTasks( - Project project, - Provider targetVersionProvider, - Provider javaToolchain) { + Project project, Provider targetVersionProvider, JavaToolchainProvider javaToolchain) { project.getTasks().withType(JavaCompile.class, new Action() { @Override public void execute(JavaCompile javaCompile) { - javaCompile.getJavaCompiler().set(javaToolchain.flatMap(BaselineJavaToolchain::javaCompiler)); + javaCompile + .getJavaCompiler() + .set(javaToolchain.forTask(javaCompile).flatMap(BaselineJavaToolchain::javaCompiler)); // Set sourceCompatibility to opt out of '-release', allowing opens/exports to be used. javaCompile.doFirst(new Action() { @Override @@ -110,14 +117,17 @@ public void execute(Task task) { project.getTasks().withType(Javadoc.class, new Action() { @Override public void execute(Javadoc javadoc) { - javadoc.getJavadocTool().set(javaToolchain.flatMap(BaselineJavaToolchain::javadocTool)); + javadoc.getJavadocTool() + .set(javaToolchain.forTask(javadoc).flatMap(BaselineJavaToolchain::javadocTool)); } }); project.getTasks().withType(GroovyCompile.class, new Action() { @Override public void execute(GroovyCompile groovyCompile) { - groovyCompile.getJavaLauncher().set(javaToolchain.flatMap(BaselineJavaToolchain::javaLauncher)); + groovyCompile + .getJavaLauncher() + .set(javaToolchain.forTask(groovyCompile).flatMap(BaselineJavaToolchain::javaLauncher)); // Set sourceCompatibility to opt out of '-release', allowing opens/exports to be used. groovyCompile.doFirst(new Action() { @Override @@ -133,7 +143,9 @@ public void execute(Task task) { project.getTasks().withType(ScalaCompile.class, new Action() { @Override public void execute(ScalaCompile scalaCompile) { - scalaCompile.getJavaLauncher().set(javaToolchain.flatMap(BaselineJavaToolchain::javaLauncher)); + scalaCompile + .getJavaLauncher() + .set(javaToolchain.forTask(scalaCompile).flatMap(BaselineJavaToolchain::javaLauncher)); // Set sourceCompatibility to opt out of '-release', allowing opens/exports to be used. scalaCompile.doFirst(new Action() { @Override @@ -149,23 +161,25 @@ public void execute(Task task) { project.getTasks().withType(ScalaDoc.class, new Action() { @Override public void execute(ScalaDoc scalaDoc) { - scalaDoc.getJavaLauncher().set(javaToolchain.flatMap(BaselineJavaToolchain::javaLauncher)); + scalaDoc.getJavaLauncher() + .set(javaToolchain.forTask(scalaDoc).flatMap(BaselineJavaToolchain::javaLauncher)); } }); } - private static void configureExecutionTasks(Project project, Provider javaToolchain) { + private static void configureExecutionTasks(Project project, JavaToolchainProvider javaToolchain) { project.getTasks().withType(JavaExec.class, new Action() { @Override public void execute(JavaExec javaExec) { - javaExec.getJavaLauncher().set(javaToolchain.flatMap(BaselineJavaToolchain::javaLauncher)); + javaExec.getJavaLauncher() + .set(javaToolchain.forTask(javaExec).flatMap(BaselineJavaToolchain::javaLauncher)); } }); project.getTasks().withType(Test.class, new Action() { @Override public void execute(Test test) { - test.getJavaLauncher().set(javaToolchain.flatMap(BaselineJavaToolchain::javaLauncher)); + test.getJavaLauncher().set(javaToolchain.forTask(test).flatMap(BaselineJavaToolchain::javaLauncher)); } }); } diff --git a/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/javaversions/JavaToolchains.java b/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/javaversions/JavaToolchains.java index 67333a304..0b289faa5 100644 --- a/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/javaversions/JavaToolchains.java +++ b/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/javaversions/JavaToolchains.java @@ -18,6 +18,7 @@ import com.palantir.baseline.extensions.BaselineJavaVersionsExtension; import org.gradle.api.Project; +import org.gradle.api.Task; import org.gradle.api.provider.Provider; import org.gradle.jvm.toolchain.JavaInstallationMetadata; import org.gradle.jvm.toolchain.JavaLanguageVersion; @@ -32,11 +33,12 @@ public JavaToolchains(Project project, BaselineJavaVersionsExtension baselineJav this.baselineJavaVersionsExtension = baselineJavaVersionsExtension; } - public Provider forVersion(Provider javaLanguageVersionProvider) { + public Provider forVersion( + Provider javaLanguageVersionProvider, Task task) { return javaLanguageVersionProvider.map(javaLanguageVersion -> { Provider configuredJdkMetadata = project.provider(() -> baselineJavaVersionsExtension - .jdkMetadataFor(javaLanguageVersion) + .jdkMetadataFor(javaLanguageVersion, task) .orElseGet(() -> project.getExtensions() .getByType(JavaToolchainService.class) .launcherFor(javaToolchainSpec -> javaToolchainSpec diff --git a/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/javaversions/LazilyConfiguredMapping.java b/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/javaversions/LazilyConfiguredMapping.java index 94d3d207c..84e90d238 100644 --- a/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/javaversions/LazilyConfiguredMapping.java +++ b/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/javaversions/LazilyConfiguredMapping.java @@ -25,9 +25,9 @@ import java.util.function.Supplier; import org.gradle.api.Action; -public final class LazilyConfiguredMapping { +public final class LazilyConfiguredMapping { private final Supplier valueFactory; - private final List> values = new ArrayList<>(); + private final List> values = new ArrayList<>(); private final Map> computedValues = new HashMap<>(); private boolean finalized = false; @@ -35,7 +35,7 @@ public LazilyConfiguredMapping(Supplier valueFactory) { this.valueFactory = valueFactory; } - public void put(LazyValues lazyValues) { + public void put(LazyValues lazyValues) { ensureNotFinalized(); values.add(lazyValues); @@ -44,7 +44,7 @@ public void put(LazyValues lazyValues) { public void put(K key, Action value) { ensureNotFinalized(); - put(requestedKey -> { + put((requestedKey, _ignored) -> { if (requestedKey.equals(key)) { return Optional.of(value); } @@ -62,14 +62,14 @@ private void ensureNotFinalized() { } } - public Optional get(K key) { + public Optional get(K key, A additionalData) { finalized = true; return computedValues.computeIfAbsent(key, _ignored -> { V value = valueFactory.get(); AtomicBoolean created = new AtomicBoolean(false); values.forEach(lazyValues -> { - lazyValues.compute(key).ifPresent(action -> { + lazyValues.compute(key, additionalData).ifPresent(action -> { created.set(true); action.execute(value); }); @@ -83,7 +83,7 @@ public Optional get(K key) { }); } - public interface LazyValues { - Optional> compute(K key); + public interface LazyValues { + Optional> compute(K key, A additionalData); } } diff --git a/gradle-baseline-java/src/main/groovy/com/palantir/baseline/tasks/CheckExplicitSourceCompatibilityTask.java b/gradle-baseline-java/src/main/groovy/com/palantir/baseline/tasks/CheckExplicitSourceCompatibilityTask.java index 688b9ae12..92206835c 100644 --- a/gradle-baseline-java/src/main/groovy/com/palantir/baseline/tasks/CheckExplicitSourceCompatibilityTask.java +++ b/gradle-baseline-java/src/main/groovy/com/palantir/baseline/tasks/CheckExplicitSourceCompatibilityTask.java @@ -43,7 +43,7 @@ /** * By default, Gradle will infer sourceCompat based on whatever JVM is currently being used to evaluate the * build.gradle files. This is bad for reproducibility because if we make an automated PR to upgrade the Java major - * version (e.g. 11 -> 15) then a library might unintentionally start publishing jars containing Java15 bytecode! + * version (e.g. 11 to 15) then a library might unintentionally start publishing jars containing Java15 bytecode! * * Better to just require everyone to specify sourceCompatibility explicitly! */ diff --git a/gradle-baseline-java/src/test/groovy/com/palantir/baseline/plugins/javaversions/LazilyConfiguredMappingTest.java b/gradle-baseline-java/src/test/groovy/com/palantir/baseline/plugins/javaversions/LazilyConfiguredMappingTest.java index cba93df51..82fa86c9a 100644 --- a/gradle-baseline-java/src/test/groovy/com/palantir/baseline/plugins/javaversions/LazilyConfiguredMappingTest.java +++ b/gradle-baseline-java/src/test/groovy/com/palantir/baseline/plugins/javaversions/LazilyConfiguredMappingTest.java @@ -23,57 +23,61 @@ import org.junit.jupiter.api.Test; class LazilyConfiguredMappingTest { - private final LazilyConfiguredMapping lazilyConfiguredMapping = + private final LazilyConfiguredMapping lazilyConfiguredMapping = new LazilyConfiguredMapping<>(() -> new Extension(0)); @Test void empty_mapping_returns_optional_empty() { - assertThat(lazilyConfiguredMapping.get("abc")).isEmpty(); + assertThat(lazilyConfiguredMapping.get("abc", 'a')).isEmpty(); } @Test void can_put_a_value_and_get_it_out_again() { lazilyConfiguredMapping.put("foo", extension -> extension.number = 4); - assertThat(lazilyConfiguredMapping.get("foo")).hasValue(new Extension(4)); + assertThat(lazilyConfiguredMapping.get("foo", 'a')).hasValue(new Extension(4)); } @Test void can_put_a_lazy_value_in_and_get_it_out_again() { - lazilyConfiguredMapping.put(key -> Optional.of(extension -> extension.number = Integer.parseInt(key))); + lazilyConfiguredMapping.put((key, additionalData) -> { + assertThat(additionalData).isEqualTo('b'); + return Optional.of(extension -> extension.number = Integer.parseInt(key)); + }); - assertThat(lazilyConfiguredMapping.get("3")).hasValue(new Extension(3)); - assertThat(lazilyConfiguredMapping.get("9")).hasValue(new Extension(9)); + assertThat(lazilyConfiguredMapping.get("3", 'b')).hasValue(new Extension(3)); + assertThat(lazilyConfiguredMapping.get("9", 'b')).hasValue(new Extension(9)); } @Test void lazy_values_are_able_to_not_return_values() { - lazilyConfiguredMapping.put(_key -> Optional.empty()); + lazilyConfiguredMapping.put((_key, _additionalData) -> Optional.empty()); - assertThat(lazilyConfiguredMapping.get("abc")).isEmpty(); + assertThat(lazilyConfiguredMapping.get("abc", 'a')).isEmpty(); } @Test void interspersing_putting_values_takes_the_last_set_value() { lazilyConfiguredMapping.put("1", extension -> extension.number = 80); - lazilyConfiguredMapping.put(key -> Optional.of(extension -> extension.number = Integer.parseInt(key))); + lazilyConfiguredMapping.put( + (key, _ignored) -> Optional.of(extension -> extension.number = Integer.parseInt(key))); lazilyConfiguredMapping.put("4", extension -> extension.number = 99); - assertThat(lazilyConfiguredMapping.get("1")).hasValue(new Extension(1)); - assertThat(lazilyConfiguredMapping.get("3")).hasValue(new Extension(3)); - assertThat(lazilyConfiguredMapping.get("4")).hasValue(new Extension(99)); + assertThat(lazilyConfiguredMapping.get("1", 'c')).hasValue(new Extension(1)); + assertThat(lazilyConfiguredMapping.get("3", 'c')).hasValue(new Extension(3)); + assertThat(lazilyConfiguredMapping.get("4", 'c')).hasValue(new Extension(99)); } @Test void throws_if_putting_values_after_being_finalized() { - lazilyConfiguredMapping.get("abc"); + lazilyConfiguredMapping.get("abc", 'c'); assertThatExceptionOfType(IllegalStateException.class).isThrownBy(() -> { lazilyConfiguredMapping.put("foo", extension -> {}); }); assertThatExceptionOfType(IllegalStateException.class).isThrownBy(() -> { - lazilyConfiguredMapping.put(key -> Optional.of(extension -> {})); + lazilyConfiguredMapping.put((_key, _additionalData) -> Optional.of(extension -> {})); }); } From 33a2bff97583322ec136343b5928e382beb89017 Mon Sep 17 00:00:00 2001 From: Callum Rogers Date: Wed, 11 May 2022 18:56:47 +0100 Subject: [PATCH 10/12] Use project instead as Task doesn't make sense --- .../BaselineJavaVersionsExtension.java | 14 +++---- .../baseline/plugins/BaselineJavaVersion.java | 39 +++++++------------ .../plugins/javaversions/JavaToolchains.java | 6 +-- 3 files changed, 20 insertions(+), 39 deletions(-) diff --git a/gradle-baseline-java/src/main/groovy/com/palantir/baseline/extensions/BaselineJavaVersionsExtension.java b/gradle-baseline-java/src/main/groovy/com/palantir/baseline/extensions/BaselineJavaVersionsExtension.java index 730bfaff7..3d33bea40 100644 --- a/gradle-baseline-java/src/main/groovy/com/palantir/baseline/extensions/BaselineJavaVersionsExtension.java +++ b/gradle-baseline-java/src/main/groovy/com/palantir/baseline/extensions/BaselineJavaVersionsExtension.java @@ -21,7 +21,6 @@ import java.util.concurrent.atomic.AtomicReference; import javax.inject.Inject; import org.gradle.api.Project; -import org.gradle.api.Task; import org.gradle.api.provider.Property; import org.gradle.jvm.toolchain.JavaInstallationMetadata; import org.gradle.jvm.toolchain.JavaLanguageVersion; @@ -34,7 +33,7 @@ public class BaselineJavaVersionsExtension { private final Property libraryTarget; private final Property distributionTarget; private final Property runtime; - private final LazilyConfiguredMapping, Task> jdks = + private final LazilyConfiguredMapping> jdks = new LazilyConfiguredMapping<>(AtomicReference::new); @Inject @@ -81,8 +80,8 @@ public final void setRuntime(int value) { runtime.set(JavaLanguageVersion.of(value)); } - public final Optional jdkMetadataFor(JavaLanguageVersion javaLanguageVersion, Task task) { - return jdks.get(javaLanguageVersion, task).map(AtomicReference::get); + public final Optional jdkMetadataFor(JavaLanguageVersion javaLanguageVersion) { + return jdks.get(javaLanguageVersion).map(AtomicReference::get); } public final void jdk(JavaLanguageVersion javaLanguageVersion, JavaInstallationMetadata javaInstallationMetadata) { @@ -90,14 +89,11 @@ public final void jdk(JavaLanguageVersion javaLanguageVersion, JavaInstallationM } public final void jdks(LazyJdks lazyJdks) { - jdks.put((javaLanguageVersion, task) -> lazyJdks.jdkFor(javaLanguageVersion, task) + jdks.put(javaLanguageVersion -> lazyJdks.jdkFor(javaLanguageVersion) .map(javaInstallationMetadata -> ref -> ref.set(javaInstallationMetadata))); } public interface LazyJdks { - // We pass through Task here as it's an easy way to get the Project, so if something needs to resolve a - // configuration it can do so without resolving in a different Project, which is deprecated and will be - // banned come Gradle 8 - Optional jdkFor(JavaLanguageVersion javaLanguageVersion, Task task); + Optional jdkFor(JavaLanguageVersion javaLanguageVersion); } } diff --git a/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/BaselineJavaVersion.java b/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/BaselineJavaVersion.java index b83e9d26e..14c0bfdb9 100644 --- a/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/BaselineJavaVersion.java +++ b/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/BaselineJavaVersion.java @@ -68,14 +68,12 @@ public void execute(JavaToolchainSpec javaToolchainSpec) { JavaToolchains javaToolchains = new JavaToolchains( project, project.getRootProject().getExtensions().getByType(BaselineJavaVersionsExtension.class)); - JavaToolchainProvider blah = task -> javaToolchains.forVersion(extension.target(), task); - // Compilation tasks (using target version) configureCompilationTasks( - project, extension.target(), task -> javaToolchains.forVersion(extension.target(), task)); + project, extension.target(), javaToolchains.forVersion(extension.target(), project)); // Execution tasks (using the runtime version) - configureExecutionTasks(project, task -> javaToolchains.forVersion(extension.runtime(), task)); + configureExecutionTasks(project, javaToolchains.forVersion(extension.runtime(), project)); // Validation project.getTasks() @@ -90,18 +88,14 @@ public void execute(CheckJavaVersionsTask task) { }); } - interface JavaToolchainProvider { - Provider forTask(Task task); - } - private static void configureCompilationTasks( - Project project, Provider targetVersionProvider, JavaToolchainProvider javaToolchain) { + Project project, + Provider targetVersionProvider, + Provider javaToolchain) { project.getTasks().withType(JavaCompile.class, new Action() { @Override public void execute(JavaCompile javaCompile) { - javaCompile - .getJavaCompiler() - .set(javaToolchain.forTask(javaCompile).flatMap(BaselineJavaToolchain::javaCompiler)); + javaCompile.getJavaCompiler().set(javaToolchain.flatMap(BaselineJavaToolchain::javaCompiler)); // Set sourceCompatibility to opt out of '-release', allowing opens/exports to be used. javaCompile.doFirst(new Action() { @Override @@ -117,17 +111,14 @@ public void execute(Task task) { project.getTasks().withType(Javadoc.class, new Action() { @Override public void execute(Javadoc javadoc) { - javadoc.getJavadocTool() - .set(javaToolchain.forTask(javadoc).flatMap(BaselineJavaToolchain::javadocTool)); + javadoc.getJavadocTool().set(javaToolchain.flatMap(BaselineJavaToolchain::javadocTool)); } }); project.getTasks().withType(GroovyCompile.class, new Action() { @Override public void execute(GroovyCompile groovyCompile) { - groovyCompile - .getJavaLauncher() - .set(javaToolchain.forTask(groovyCompile).flatMap(BaselineJavaToolchain::javaLauncher)); + groovyCompile.getJavaLauncher().set(javaToolchain.flatMap(BaselineJavaToolchain::javaLauncher)); // Set sourceCompatibility to opt out of '-release', allowing opens/exports to be used. groovyCompile.doFirst(new Action() { @Override @@ -143,9 +134,7 @@ public void execute(Task task) { project.getTasks().withType(ScalaCompile.class, new Action() { @Override public void execute(ScalaCompile scalaCompile) { - scalaCompile - .getJavaLauncher() - .set(javaToolchain.forTask(scalaCompile).flatMap(BaselineJavaToolchain::javaLauncher)); + scalaCompile.getJavaLauncher().set(javaToolchain.flatMap(BaselineJavaToolchain::javaLauncher)); // Set sourceCompatibility to opt out of '-release', allowing opens/exports to be used. scalaCompile.doFirst(new Action() { @Override @@ -161,25 +150,23 @@ public void execute(Task task) { project.getTasks().withType(ScalaDoc.class, new Action() { @Override public void execute(ScalaDoc scalaDoc) { - scalaDoc.getJavaLauncher() - .set(javaToolchain.forTask(scalaDoc).flatMap(BaselineJavaToolchain::javaLauncher)); + scalaDoc.getJavaLauncher().set(javaToolchain.flatMap(BaselineJavaToolchain::javaLauncher)); } }); } - private static void configureExecutionTasks(Project project, JavaToolchainProvider javaToolchain) { + private static void configureExecutionTasks(Project project, Provider javaToolchain) { project.getTasks().withType(JavaExec.class, new Action() { @Override public void execute(JavaExec javaExec) { - javaExec.getJavaLauncher() - .set(javaToolchain.forTask(javaExec).flatMap(BaselineJavaToolchain::javaLauncher)); + javaExec.getJavaLauncher().set(javaToolchain.flatMap(BaselineJavaToolchain::javaLauncher)); } }); project.getTasks().withType(Test.class, new Action() { @Override public void execute(Test test) { - test.getJavaLauncher().set(javaToolchain.forTask(test).flatMap(BaselineJavaToolchain::javaLauncher)); + test.getJavaLauncher().set(javaToolchain.flatMap(BaselineJavaToolchain::javaLauncher)); } }); } diff --git a/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/javaversions/JavaToolchains.java b/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/javaversions/JavaToolchains.java index 0b289faa5..5ddb4ce94 100644 --- a/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/javaversions/JavaToolchains.java +++ b/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/javaversions/JavaToolchains.java @@ -18,7 +18,6 @@ import com.palantir.baseline.extensions.BaselineJavaVersionsExtension; import org.gradle.api.Project; -import org.gradle.api.Task; import org.gradle.api.provider.Provider; import org.gradle.jvm.toolchain.JavaInstallationMetadata; import org.gradle.jvm.toolchain.JavaLanguageVersion; @@ -33,12 +32,11 @@ public JavaToolchains(Project project, BaselineJavaVersionsExtension baselineJav this.baselineJavaVersionsExtension = baselineJavaVersionsExtension; } - public Provider forVersion( - Provider javaLanguageVersionProvider, Task task) { + public Provider forVersion(Provider javaLanguageVersionProvider) { return javaLanguageVersionProvider.map(javaLanguageVersion -> { Provider configuredJdkMetadata = project.provider(() -> baselineJavaVersionsExtension - .jdkMetadataFor(javaLanguageVersion, task) + .jdkMetadataFor(javaLanguageVersion, project) .orElseGet(() -> project.getExtensions() .getByType(JavaToolchainService.class) .launcherFor(javaToolchainSpec -> javaToolchainSpec From 965e6cef89355c8a9dd8a1bdb2c980265d171b29 Mon Sep 17 00:00:00 2001 From: Callum Rogers Date: Wed, 11 May 2022 18:58:34 +0100 Subject: [PATCH 11/12] I done goofed at git --- .../extensions/BaselineJavaVersionsExtension.java | 13 +++++++------ .../baseline/plugins/BaselineJavaVersion.java | 5 ++--- 2 files changed, 9 insertions(+), 9 deletions(-) diff --git a/gradle-baseline-java/src/main/groovy/com/palantir/baseline/extensions/BaselineJavaVersionsExtension.java b/gradle-baseline-java/src/main/groovy/com/palantir/baseline/extensions/BaselineJavaVersionsExtension.java index 3d33bea40..5d6fdc2f8 100644 --- a/gradle-baseline-java/src/main/groovy/com/palantir/baseline/extensions/BaselineJavaVersionsExtension.java +++ b/gradle-baseline-java/src/main/groovy/com/palantir/baseline/extensions/BaselineJavaVersionsExtension.java @@ -33,8 +33,8 @@ public class BaselineJavaVersionsExtension { private final Property libraryTarget; private final Property distributionTarget; private final Property runtime; - private final LazilyConfiguredMapping> jdks = - new LazilyConfiguredMapping<>(AtomicReference::new); + private final LazilyConfiguredMapping, Project> + jdks = new LazilyConfiguredMapping<>(AtomicReference::new); @Inject public BaselineJavaVersionsExtension(Project project) { @@ -80,8 +80,9 @@ public final void setRuntime(int value) { runtime.set(JavaLanguageVersion.of(value)); } - public final Optional jdkMetadataFor(JavaLanguageVersion javaLanguageVersion) { - return jdks.get(javaLanguageVersion).map(AtomicReference::get); + public final Optional jdkMetadataFor( + JavaLanguageVersion javaLanguageVersion, Project project) { + return jdks.get(javaLanguageVersion, project).map(AtomicReference::get); } public final void jdk(JavaLanguageVersion javaLanguageVersion, JavaInstallationMetadata javaInstallationMetadata) { @@ -89,11 +90,11 @@ public final void jdk(JavaLanguageVersion javaLanguageVersion, JavaInstallationM } public final void jdks(LazyJdks lazyJdks) { - jdks.put(javaLanguageVersion -> lazyJdks.jdkFor(javaLanguageVersion) + jdks.put((javaLanguageVersion, project) -> lazyJdks.jdkFor(javaLanguageVersion, project) .map(javaInstallationMetadata -> ref -> ref.set(javaInstallationMetadata))); } public interface LazyJdks { - Optional jdkFor(JavaLanguageVersion javaLanguageVersion); + Optional jdkFor(JavaLanguageVersion javaLanguageVersion, Project project); } } diff --git a/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/BaselineJavaVersion.java b/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/BaselineJavaVersion.java index 14c0bfdb9..30c47036c 100644 --- a/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/BaselineJavaVersion.java +++ b/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/BaselineJavaVersion.java @@ -69,11 +69,10 @@ public void execute(JavaToolchainSpec javaToolchainSpec) { project, project.getRootProject().getExtensions().getByType(BaselineJavaVersionsExtension.class)); // Compilation tasks (using target version) - configureCompilationTasks( - project, extension.target(), javaToolchains.forVersion(extension.target(), project)); + configureCompilationTasks(project, extension.target(), javaToolchains.forVersion(extension.target())); // Execution tasks (using the runtime version) - configureExecutionTasks(project, javaToolchains.forVersion(extension.runtime(), project)); + configureExecutionTasks(project, javaToolchains.forVersion(extension.runtime())); // Validation project.getTasks() From af3cbe94815d65f7a1b8c4c5e9184917f904fea6 Mon Sep 17 00:00:00 2001 From: Callum Rogers Date: Thu, 12 May 2022 11:47:00 +0100 Subject: [PATCH 12/12] Move everything to it's own pacakge --- .../com/palantir/baseline/plugins/BaselineIdea.groovy | 4 ++-- .../palantir/baseline/plugins/BaselineModuleJvmArgs.java | 1 + .../baseline/plugins/BaselineReleaseCompatibility.java | 1 + .../plugins/{ => javaversions}/BaselineJavaVersion.java | 8 ++------ .../javaversions}/BaselineJavaVersionExtension.java | 4 ++-- .../plugins/{ => javaversions}/BaselineJavaVersions.java | 6 ++---- .../javaversions}/BaselineJavaVersionsExtension.java | 5 ++--- .../baseline/plugins/javaversions/JavaToolchains.java | 1 - .../plugins/javaversions/LazilyConfiguredMapping.java | 4 ++-- .../tasks/CheckExplicitSourceCompatibilityTask.java | 2 +- .../com.palantir.baseline-java-version.properties | 2 +- .../com.palantir.baseline-java-versions.properties | 2 +- 12 files changed, 17 insertions(+), 23 deletions(-) rename gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/{ => javaversions}/BaselineJavaVersion.java (96%) rename gradle-baseline-java/src/main/groovy/com/palantir/baseline/{extensions => plugins/javaversions}/BaselineJavaVersionExtension.java (95%) rename gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/{ => javaversions}/BaselineJavaVersions.java (96%) rename gradle-baseline-java/src/main/groovy/com/palantir/baseline/{extensions => plugins/javaversions}/BaselineJavaVersionsExtension.java (95%) diff --git a/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/BaselineIdea.groovy b/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/BaselineIdea.groovy index 62933c5c1..e4a56ed04 100644 --- a/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/BaselineIdea.groovy +++ b/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/BaselineIdea.groovy @@ -18,8 +18,8 @@ package com.palantir.baseline.plugins import com.google.common.collect.ImmutableMap import com.palantir.baseline.IntellijSupport -import com.palantir.baseline.extensions.BaselineJavaVersionExtension -import com.palantir.baseline.extensions.BaselineJavaVersionsExtension +import com.palantir.baseline.plugins.javaversions.BaselineJavaVersionExtension +import com.palantir.baseline.plugins.javaversions.BaselineJavaVersionsExtension import com.palantir.baseline.util.GitUtils import groovy.transform.CompileStatic import groovy.xml.XmlUtil diff --git a/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/BaselineModuleJvmArgs.java b/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/BaselineModuleJvmArgs.java index 0c1d53d6b..cc81e784a 100644 --- a/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/BaselineModuleJvmArgs.java +++ b/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/BaselineModuleJvmArgs.java @@ -21,6 +21,7 @@ import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableMap; import com.palantir.baseline.extensions.BaselineModuleJvmArgsExtension; +import com.palantir.baseline.plugins.javaversions.BaselineJavaVersion; import java.io.IOException; import java.util.List; import java.util.Objects; diff --git a/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/BaselineReleaseCompatibility.java b/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/BaselineReleaseCompatibility.java index 58c55c323..a62b1c9a8 100644 --- a/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/BaselineReleaseCompatibility.java +++ b/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/BaselineReleaseCompatibility.java @@ -17,6 +17,7 @@ package com.palantir.baseline.plugins; import com.google.common.collect.ImmutableList; +import com.palantir.baseline.plugins.javaversions.BaselineJavaVersion; import java.util.Collections; import java.util.Optional; import org.gradle.api.JavaVersion; diff --git a/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/BaselineJavaVersion.java b/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/javaversions/BaselineJavaVersion.java similarity index 96% rename from gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/BaselineJavaVersion.java rename to gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/javaversions/BaselineJavaVersion.java index 30c47036c..e17974e7e 100644 --- a/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/BaselineJavaVersion.java +++ b/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/javaversions/BaselineJavaVersion.java @@ -1,5 +1,5 @@ /* - * (c) Copyright 2021 Palantir Technologies Inc. All rights reserved. + * (c) Copyright 2022 Palantir Technologies Inc. All rights reserved. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -14,12 +14,8 @@ * limitations under the License. */ -package com.palantir.baseline.plugins; +package com.palantir.baseline.plugins.javaversions; -import com.palantir.baseline.extensions.BaselineJavaVersionExtension; -import com.palantir.baseline.extensions.BaselineJavaVersionsExtension; -import com.palantir.baseline.plugins.javaversions.BaselineJavaToolchain; -import com.palantir.baseline.plugins.javaversions.JavaToolchains; import javax.inject.Inject; import org.gradle.api.Action; import org.gradle.api.DefaultTask; diff --git a/gradle-baseline-java/src/main/groovy/com/palantir/baseline/extensions/BaselineJavaVersionExtension.java b/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/javaversions/BaselineJavaVersionExtension.java similarity index 95% rename from gradle-baseline-java/src/main/groovy/com/palantir/baseline/extensions/BaselineJavaVersionExtension.java rename to gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/javaversions/BaselineJavaVersionExtension.java index 82393cbbe..162b17cfd 100644 --- a/gradle-baseline-java/src/main/groovy/com/palantir/baseline/extensions/BaselineJavaVersionExtension.java +++ b/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/javaversions/BaselineJavaVersionExtension.java @@ -1,5 +1,5 @@ /* - * (c) Copyright 2019 Palantir Technologies Inc. All rights reserved. + * (c) Copyright 2022 Palantir Technologies Inc. All rights reserved. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -14,7 +14,7 @@ * limitations under the License. */ -package com.palantir.baseline.extensions; +package com.palantir.baseline.plugins.javaversions; import javax.inject.Inject; import org.gradle.api.Project; diff --git a/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/BaselineJavaVersions.java b/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/javaversions/BaselineJavaVersions.java similarity index 96% rename from gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/BaselineJavaVersions.java rename to gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/javaversions/BaselineJavaVersions.java index cd5856afb..a46edd039 100644 --- a/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/BaselineJavaVersions.java +++ b/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/javaversions/BaselineJavaVersions.java @@ -1,5 +1,5 @@ /* - * (c) Copyright 2021 Palantir Technologies Inc. All rights reserved. + * (c) Copyright 2022 Palantir Technologies Inc. All rights reserved. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -14,12 +14,10 @@ * limitations under the License. */ -package com.palantir.baseline.plugins; +package com.palantir.baseline.plugins.javaversions; import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableSet; -import com.palantir.baseline.extensions.BaselineJavaVersionExtension; -import com.palantir.baseline.extensions.BaselineJavaVersionsExtension; import java.util.Objects; import org.gradle.api.GradleException; import org.gradle.api.Named; diff --git a/gradle-baseline-java/src/main/groovy/com/palantir/baseline/extensions/BaselineJavaVersionsExtension.java b/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/javaversions/BaselineJavaVersionsExtension.java similarity index 95% rename from gradle-baseline-java/src/main/groovy/com/palantir/baseline/extensions/BaselineJavaVersionsExtension.java rename to gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/javaversions/BaselineJavaVersionsExtension.java index 5d6fdc2f8..f893893c7 100644 --- a/gradle-baseline-java/src/main/groovy/com/palantir/baseline/extensions/BaselineJavaVersionsExtension.java +++ b/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/javaversions/BaselineJavaVersionsExtension.java @@ -1,5 +1,5 @@ /* - * (c) Copyright 2019 Palantir Technologies Inc. All rights reserved. + * (c) Copyright 2022 Palantir Technologies Inc. All rights reserved. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -14,9 +14,8 @@ * limitations under the License. */ -package com.palantir.baseline.extensions; +package com.palantir.baseline.plugins.javaversions; -import com.palantir.baseline.plugins.javaversions.LazilyConfiguredMapping; import java.util.Optional; import java.util.concurrent.atomic.AtomicReference; import javax.inject.Inject; diff --git a/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/javaversions/JavaToolchains.java b/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/javaversions/JavaToolchains.java index 5ddb4ce94..4afcf46cc 100644 --- a/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/javaversions/JavaToolchains.java +++ b/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/javaversions/JavaToolchains.java @@ -16,7 +16,6 @@ package com.palantir.baseline.plugins.javaversions; -import com.palantir.baseline.extensions.BaselineJavaVersionsExtension; import org.gradle.api.Project; import org.gradle.api.provider.Provider; import org.gradle.jvm.toolchain.JavaInstallationMetadata; diff --git a/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/javaversions/LazilyConfiguredMapping.java b/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/javaversions/LazilyConfiguredMapping.java index 84e90d238..647932cc4 100644 --- a/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/javaversions/LazilyConfiguredMapping.java +++ b/gradle-baseline-java/src/main/groovy/com/palantir/baseline/plugins/javaversions/LazilyConfiguredMapping.java @@ -25,13 +25,13 @@ import java.util.function.Supplier; import org.gradle.api.Action; -public final class LazilyConfiguredMapping { +final class LazilyConfiguredMapping { private final Supplier valueFactory; private final List> values = new ArrayList<>(); private final Map> computedValues = new HashMap<>(); private boolean finalized = false; - public LazilyConfiguredMapping(Supplier valueFactory) { + LazilyConfiguredMapping(Supplier valueFactory) { this.valueFactory = valueFactory; } diff --git a/gradle-baseline-java/src/main/groovy/com/palantir/baseline/tasks/CheckExplicitSourceCompatibilityTask.java b/gradle-baseline-java/src/main/groovy/com/palantir/baseline/tasks/CheckExplicitSourceCompatibilityTask.java index 92206835c..38a6384e1 100644 --- a/gradle-baseline-java/src/main/groovy/com/palantir/baseline/tasks/CheckExplicitSourceCompatibilityTask.java +++ b/gradle-baseline-java/src/main/groovy/com/palantir/baseline/tasks/CheckExplicitSourceCompatibilityTask.java @@ -16,7 +16,7 @@ package com.palantir.baseline.tasks; -import com.palantir.baseline.plugins.BaselineJavaVersion; +import com.palantir.baseline.plugins.javaversions.BaselineJavaVersion; import java.io.IOException; import java.lang.reflect.Method; import java.nio.charset.StandardCharsets; diff --git a/gradle-baseline-java/src/main/resources/META-INF/gradle-plugins/com.palantir.baseline-java-version.properties b/gradle-baseline-java/src/main/resources/META-INF/gradle-plugins/com.palantir.baseline-java-version.properties index bda4d2359..fd6b289da 100644 --- a/gradle-baseline-java/src/main/resources/META-INF/gradle-plugins/com.palantir.baseline-java-version.properties +++ b/gradle-baseline-java/src/main/resources/META-INF/gradle-plugins/com.palantir.baseline-java-version.properties @@ -1 +1 @@ -implementation-class=com.palantir.baseline.plugins.BaselineJavaVersion +implementation-class=com.palantir.baseline.plugins.javaversions.BaselineJavaVersion diff --git a/gradle-baseline-java/src/main/resources/META-INF/gradle-plugins/com.palantir.baseline-java-versions.properties b/gradle-baseline-java/src/main/resources/META-INF/gradle-plugins/com.palantir.baseline-java-versions.properties index 8d4e15fbe..daf189e5a 100644 --- a/gradle-baseline-java/src/main/resources/META-INF/gradle-plugins/com.palantir.baseline-java-versions.properties +++ b/gradle-baseline-java/src/main/resources/META-INF/gradle-plugins/com.palantir.baseline-java-versions.properties @@ -1 +1 @@ -implementation-class=com.palantir.baseline.plugins.BaselineJavaVersions +implementation-class=com.palantir.baseline.plugins.javaversions.BaselineJavaVersions