Fix deprecated Gradle syntax and configuration features (FoundationDB#3358)

When running `./gradlew shadowJar compileTestJava --warning-mode=all` on
the current HEAD of `main` (68f805a), a number of warnings are
produced for deprecated usages of Gradle configuration features. Upon
fixing the trivial deprecations produced in the first pass, a second
round of issues is also produced. This pull request fixes all of those,
such that the command executes cleanly, without generating a Gradle
problem report.

Each class of issue is addressed in a separate commit (which contains
links to the Gradle documentation showing the fix mechanism to be the
recommended approach), but broadly speaking there are five categories:

1. Use of `destination` instead of `outputLocation` when configuring
JUnit report output location
([docs](https://docs.gradle.org/8.13/dsl/org.gradle.api.reporting.Report.html#org.gradle.api.reporting.Report:destination))
2. Consistent use of `key = value` assignment rather than "space
assignment" or `propertyName(value)` assignment
([docs](https://docs.gradle.org/8.13/userguide/upgrading_version_8.html#groovy_space_assignment_syntax))
3. Use of plugin blocks instead of conventions for the `Java` plugin
([docs](https://docs.gradle.org/8.13/userguide/upgrading_version_8.html#java_convention_deprecation))
4. Use of plugin blocks instead of conventions for the `Application`
plugin
([docs](https://docs.gradle.org/8.13/userguide/upgrading_version_8.html#application_convention_deprecation))
and applying the ensuing required cleanup from the Gradle 7 migration
([docs](https://docs.gradle.org/current/userguide/upgrading_version_7.html#javaapplication_api_cleanup))
5. Stopping the use of `Task.project` in Task actions
([docs](https://docs.gradle.org/8.13/userguide/upgrading_version_7.html#task_project)).

Other tasks which are not dependents of `shadowJar` or `compileTestJava`
likely still use deprecated syntax or conventions - I will follow up
with a second pull request to address those in future.

Author: jen20

build.gradle

@@ -100,19 +100,22 @@ allprojects {
 
     // Configure JUnit tests
     tasks.withType(Test) {
-        reports.junitXml.destination = project.file("${->project.buildDir}/test-results")
+        reports.junitXml.outputLocation = project.file("${->project.buildDir}/test-results")
     }
 
+    def projectName = it.name
+    def projectVersion = it.version
+
     // Configure JAR generation
     tasks.jar.configure {
         description = "Produces a Jar with the main classes in .out/."
         manifest {
             attributes "Built-JDK": System.getProperty("java.version"),
-                    "Specification-Title": project.name,
-                    "Specification-Version": "${-> project.version}",
+                    "Specification-Title": projectName,
+                    "Specification-Version": "${-> projectVersion}",
                     "Specification-Vendor": "Apple Inc.",
-                    "Implementation-Title": project.name,
-                    "Implementation-Version": "${-> project.version}",
+                    "Implementation-Title": projectName,
+                    "Implementation-Version": "${-> projectVersion}",
                     "Implementation-Vendor": "Apple Inc."
         }
         doFirst {
@@ -182,8 +185,10 @@ allprojects {
 subprojects {
     apply from: rootProject.file('gradle/testing.gradle')
 
-    sourceCompatibility = JavaVersion.VERSION_11
-    targetCompatibility = JavaVersion.VERSION_11
+    java {
+        sourceCompatibility = JavaVersion.VERSION_11
+        targetCompatibility = JavaVersion.VERSION_11
+    }
 
     def publishBuild = Boolean.parseBoolean(findProperty('publishBuild') ?: 'false')
     def autoServiceVersion = publishBuild ? libs.versions.autoService.asProvider().get() : libs.versions.autoService.development.get()

examples/examples.gradle

@@ -30,5 +30,7 @@ dependencies {
     runtimeOnly(libs.log4j.core) // library
 }
 
-mainClassName = 'com.apple.foundationdb.record.sample.Main'
-applicationDefaultJvmArgs = ["-Dlog4j.configurationFile=${projectDir}/src/main/resources/log4j2.properties"]
+application {
+    mainClass = 'com.apple.foundationdb.record.sample.Main'
+    applicationDefaultJvmArgs = ["-Dlog4j.configurationFile=${projectDir}/src/main/resources/log4j2.properties"]
+}

fdb-record-layer-core/src/main/java/com/apple/foundationdb/record/query/plan/cascades/values/translation/RegularTranslationMap.java

@@ -0,0 +1,255 @@
+/*
+ * TranslationMap.java
+ *
+ * This source file is part of the FoundationDB open source project
+ *
+ * Copyright 2015-2024 Apple Inc. and the FoundationDB project authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.apple.foundationdb.record.query.plan.cascades.values.translation;
+
+import com.apple.foundationdb.record.query.plan.cascades.AliasMap;
+import com.apple.foundationdb.record.query.plan.cascades.CorrelationIdentifier;
+import com.apple.foundationdb.record.query.plan.cascades.typing.Type;
+import com.apple.foundationdb.record.query.plan.cascades.values.LeafValue;
+import com.apple.foundationdb.record.query.plan.cascades.values.QuantifiedObjectValue;
+import com.apple.foundationdb.record.query.plan.cascades.values.QuantifiedValue;
+import com.apple.foundationdb.record.query.plan.cascades.values.Value;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Verify;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Maps;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+
+/**
+ * Map used to specify translations.
+ */
+public class TranslationMap {
+    @Nonnull
+    private static final TranslationMap EMPTY = new TranslationMap(ImmutableMap.of());
+
+    @Nonnull
+    private final Map<CorrelationIdentifier, TranslationTarget> aliasToTargetMap;
+
+    private TranslationMap(@Nonnull final Map<CorrelationIdentifier, TranslationTarget> aliasToTargetMap) {
+        this.aliasToTargetMap = ImmutableMap.copyOf(aliasToTargetMap);
+    }
+
+    @Nonnull
+    public Optional<AliasMap> getAliasMapMaybe() {
+        return Optional.empty();
+    }
+
+    public boolean definesOnlyIdentities() {
+        return getAliasMapMaybe().map(AliasMap::definesOnlyIdentities)
+                .orElseGet(aliasToTargetMap::isEmpty);
+    }
+
+    public boolean containsSourceAlias(@Nullable CorrelationIdentifier sourceAlias) {
+        return aliasToTargetMap.containsKey(sourceAlias);
+    }
+
+    @Nonnull
+    public Value applyTranslationFunction(@Nonnull final CorrelationIdentifier sourceAlias,
+                                          @Nonnull final LeafValue leafValue) {
+        final var translationTarget = Preconditions.checkNotNull(aliasToTargetMap.get(sourceAlias));
+        return translationTarget.translate(sourceAlias, leafValue);
+    }
+
+    @Nonnull
+    public Builder toBuilder() {
+        return new Builder(aliasToTargetMap);
+    }
+
+    @Nonnull
+    public static Builder builder() {
+        return new Builder();
+    }
+
+    @Nonnull
+    public static TranslationMap empty() {
+        return EMPTY;
+    }
+
+    @Nonnull
+    public static TranslationMap rebaseWithAliasMap(@Nonnull final AliasMap aliasMap) {
+        final var translationMapBuilder = ImmutableMap.<CorrelationIdentifier, TranslationTarget>builder();
+        for (final var entry : aliasMap.entrySet()) {
+            translationMapBuilder.put(entry.getKey(),
+                    new TranslationTarget(((sourceAlias, leafValue) -> leafValue.rebaseLeaf(entry.getValue()))));
+        }
+        return new AliasMapBasedTranslationMap(translationMapBuilder.build(), aliasMap);
+    }
+
+    @Nonnull
+    public static TranslationMap ofAliases(@Nonnull final CorrelationIdentifier source,
+                                           @Nonnull final CorrelationIdentifier target) {
+        return rebaseWithAliasMap(AliasMap.ofAliases(source, target));
+    }
+
+    @Nonnull
+    public static TranslationMap compose(@Nonnull final Iterable<TranslationMap> translationMaps) {
+        final var builder = TranslationMap.builder();
+        for (final var translationMap : translationMaps) {
+            builder.compose(translationMap);
+        }
+        return builder.build();
+    }
+
+    private static class AliasMapBasedTranslationMap extends TranslationMap {
+        @Nonnull
+        private final AliasMap aliasMap;
+
+        public AliasMapBasedTranslationMap(@Nonnull final Map<CorrelationIdentifier, TranslationTarget> aliasToTargetMap,
+                                           @Nonnull final AliasMap aliasMap) {
+            super(aliasToTargetMap);
+            this.aliasMap = aliasMap;
+        }
+
+        @Nonnull
+        @Override
+        public Optional<AliasMap> getAliasMapMaybe() {
+            return Optional.of(aliasMap);
+        }
+    }
+    
+    private static class TranslationTarget {
+        @Nonnull
+        private final TranslationFunction translationFunction;
+
+        public TranslationTarget(@Nonnull final TranslationFunction translationFunction) {
+            this.translationFunction = translationFunction;
+        }
+
+        @Nonnull
+        public Value translate(@Nonnull final CorrelationIdentifier sourceAlias,
+                               @Nonnull final LeafValue leafValue) {
+            return translationFunction.apply(sourceAlias, leafValue);
+        }
+    }
+
+    /**
+     * Functional interface to specify the translation to take place when a {@link QuantifiedValue} is encountered.
+     */
+    @FunctionalInterface
+    public interface TranslationFunction {
+        @Nonnull
+        Value apply(@Nonnull CorrelationIdentifier sourceAlias,
+                    @Nonnull LeafValue leafValue);
+
+        @Nonnull
+        static TranslationFunction adjustValueType(@Nonnull final Value translationTargetValue) {
+            final var translationTargetType = translationTargetValue.getResultType();
+            if (translationTargetValue instanceof QuantifiedObjectValue) {
+                if (translationTargetType instanceof Type.Erasable &&
+                        ((Type.Erasable)translationTargetType).isErased()) {
+                    return (source, quantifiedValue) -> QuantifiedObjectValue.of(((QuantifiedObjectValue)translationTargetValue).getAlias(),
+                            quantifiedValue.getResultType());
+                }
+            }
+            Verify.verify(!(translationTargetType instanceof Type.Erasable) ||
+                    !((Type.Erasable)translationTargetType).isErased());
+            return (ignored, ignored2) -> translationTargetValue;
+        }
+    }
+
+    /**
+     * Builder class for a translation map.
+     */
+    public static class Builder {
+        @Nonnull
+        private final Map<CorrelationIdentifier, TranslationTarget> aliasToTargetMap;
+
+        public Builder() {
+            this.aliasToTargetMap = Maps.newLinkedHashMap();
+        }
+
+        private Builder(@Nonnull final Map<CorrelationIdentifier, TranslationTarget> aliasToTargetMap) {
+            this.aliasToTargetMap = Maps.newLinkedHashMap(aliasToTargetMap);
+        }
+
+        @Nonnull
+        public TranslationMap build() {
+            if (aliasToTargetMap.isEmpty()) {
+                return TranslationMap.empty();
+            }
+            return new TranslationMap(aliasToTargetMap);
+        }
+
+        @Nonnull
+        public Builder.When when(@Nonnull final CorrelationIdentifier sourceAlias) {
+            return new When(sourceAlias);
+        }
+
+        @Nonnull
+        public Builder.WhenAny whenAny(@Nonnull final Iterable<CorrelationIdentifier> sourceAliases) {
+            return new WhenAny(sourceAliases);
+        }
+
+        @Nonnull
+        public Builder compose(@Nonnull final TranslationMap other) {
+            other.aliasToTargetMap
+                    .forEach((key, value) -> {
+                        Verify.verify(!aliasToTargetMap.containsKey(key));
+                        aliasToTargetMap.put(key, value);
+                    });
+            return this;
+        }
+
+        /**
+         * Class to provide fluent API, e.g. {@code .when(...).then(...)}
+         */
+        public class When {
+            @Nonnull
+            private final CorrelationIdentifier sourceAlias;
+
+            public When(@Nonnull final CorrelationIdentifier sourceAlias) {
+                this.sourceAlias = sourceAlias;
+            }
+
+            @Nonnull
+            public Builder then(@Nonnull final TranslationFunction translationFunction) {
+                aliasToTargetMap.put(sourceAlias, new TranslationTarget(translationFunction));
+                return Builder.this;
+            }
+        }
+
+        /**
+         * Class to provide fluent API, e.g. {@code .when(...).then(...)}
+         */
+        public class WhenAny {
+            @Nonnull
+            private final Set<CorrelationIdentifier> sourceAliases;
+
+            public WhenAny(@Nonnull final Iterable<CorrelationIdentifier> sourceAliases) {
+                this.sourceAliases = ImmutableSet.copyOf(sourceAliases);
+            }
+
+            @Nonnull
+            public Builder then(@Nonnull TranslationFunction translationFunction) {
+                for (final CorrelationIdentifier sourceAlias : sourceAliases) {
+                    aliasToTargetMap.put(sourceAlias, new TranslationTarget(translationFunction));
+                }
+                return Builder.this;
+            }
+        }
+    }
+}

fdb-relational-api/fdb-relational-api.gradle

@@ -30,16 +30,19 @@ task createVersionPropertiesFile()  {
     // Write a file of version and build info for the java processes to read
     // from their classpaths.
     def versionsFile = new File(projectDir, "src/gen/main/resources/version.properties")
+    def projectVersion = project.version
+    def rootProjectName = rootProject.name
     def gitDetails = versionDetails()
+
     outputs.file versionsFile
     doLast {
         println "Writing ${versionsFile}"
         versionsFile.text = """# Generated by fdb-relational-api build.
 # Returned by RelationalDatabaseMetaData#getDatabaseProductName()
-name=${rootProject.name}
+name=${rootProjectName}
 # Returned by RelationalDatabaseMetaData#getDatabaseProductVersion()
 # and by RelationalDatabaseMetaData#getDriverVersion()
-version=${project.version}
+version=${projectVersion}
 gitHash=${gitDetails.gitHashFull}
 branch=${gitDetails.branchName}
 # Returned as RelationalDatabaseMetaData#getUrl()

fdb-relational-cli/fdb-relational-cli.gradle

@@ -74,7 +74,7 @@ dependencies {
 }
 
 jar {
-    duplicatesStrategy "exclude"
+    duplicatesStrategy = "exclude"
     manifest {
         attributes(
                 'Main-Class': 'com.apple.foundationdb.relational.cli.sqlline.RelationalSQLLine',

fdb-relational-jdbc/fdb-relational-jdbc.gradle

@@ -52,7 +52,7 @@ serviceLoader {
 }
 
 jar {
-    duplicatesStrategy "exclude"
+    duplicatesStrategy = "exclude"
 }
 
 // Task to build a fat jar, one w/ all dependencies; good for handing out as the 'jdbc' jar.

fdb-relational-server/fdb-relational-server.gradle

@@ -56,7 +56,9 @@ jar {
 
 // Task to build a fat jar, one w/ all dependencies
 shadowJar {
-    mainClassName = mainServerClass
+    application {
+        mainClass = mainServerClass
+    }
     mergeServiceFiles()
 }
 

gradle/testing.gradle

@@ -40,7 +40,7 @@ task destructiveTest(type: Test) {
         maxParallelForks = 1
     }
     reports {
-        junitXml.destination = file("${buildDir}/test-results/destructive")
+        junitXml.outputLocation = file("${buildDir}/test-results/destructive")
     }
 }
 

yaml-tests/yaml-tests.gradle

@@ -33,7 +33,7 @@ project.tasks.named("processTestResources") {
 }
 
 tasks.named("sourcesJar") {
-    duplicatesStrategy('include')
+    duplicatesStrategy = 'include'
     // classifier('sources')
     from sourceSets.main.allSource
 }