Remove additional configuration

Author: alpar-t

buildSrc/src/main/groovy/org/elasticsearch/gradle/precommit/PrecommitTasks.groovy

@@ -76,30 +76,18 @@ class PrecommitTasks {
     }
 
     private static Task configureForbiddenApisCli(Project project) {
-        project.configurations.create("forbiddenApisCliJar")
-        project.dependencies {
-            forbiddenApisCliJar ('de.thetaphi:forbiddenapis:2.5') {
-                // FIXME
-                transitive = false
-            }
-        }
         Task forbiddenApisCli = project.tasks.create('forbiddenApis')
-
         project.sourceSets.forEach { sourceSet ->
             forbiddenApisCli.dependsOn(
                 project.tasks.create(sourceSet.getTaskName('forbiddenApis', null), ForbiddenApisCliTask) {
                     ExportElasticsearchBuildResourcesTask buildResources = project.tasks.getByName('buildResources')
                     dependsOn(buildResources)
                     execAction = { spec ->
-                        spec.classpath = project.files(
-                                project.configurations.forbiddenApisCliJar,
-                                sourceSet.compileClasspath,
-                                sourceSet.runtimeClasspath
-                        )
+                        spec.classpath(sourceSet.compileClasspath)
+                        spec.classpath(sourceSet.runtimeClasspath)
                         spec.executable = "${project.runtimeJavaHome}/bin/java"
                     }
-
-                    targetCompatibility = JavaVersion.VERSION_1_8 // FIXME
+                    targetCompatibility = JavaVersion.VERSION_1_8 // FIXME: change to min(compilerVersion, 10)
                     bundledSignatures = [
                        "jdk-unsafe", "jdk-deprecated", "jdk-non-portable", "jdk-system-out"
                     ]

buildSrc/src/main/java/org/elasticsearch/gradle/ClassPathUtils.java

@@ -0,0 +1,48 @@
+/*
+ * Licensed to Elasticsearch under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.elasticsearch.gradle;
+
+import java.net.URISyntaxException;
+import java.net.URL;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+
+public class ClassPathUtils {
+
+    public static Path getJar(Class<?> theClass) {
+        URL location = theClass.getProtectionDomain().getCodeSource().getLocation();
+        if (location.getProtocol().equals("file") == false) {
+            throw new IllegalArgumentException(
+                "Unexpected location for " + theClass.getName() + ": "+ location
+            );
+        }
+        final Path path;
+        try {
+            path = Paths.get(location.toURI());
+        } catch (URISyntaxException e) {
+            throw new AssertionError(e);
+        }
+        if (Files.exists(path) == false) {
+            throw new AssertionError("Bath to class source does not exist: " + path);
+        }
+        return path;
+    }
+
+}

buildSrc/src/main/java/org/elasticsearch/gradle/precommit/ForbiddenApisCliTask.java

@@ -19,6 +19,7 @@
 package org.elasticsearch.gradle.precommit;
 
 import de.thetaphi.forbiddenapis.cli.CliMain;
+import org.elasticsearch.gradle.ClassPathUtils;
 import org.gradle.api.Action;
 import org.gradle.api.DefaultTask;
 import org.gradle.api.JavaVersion;
@@ -32,12 +33,16 @@
 
 import java.io.File;
 import java.io.IOException;
+import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Set;
+import java.util.stream.Collectors;
 
 public class ForbiddenApisCliTask extends DefaultTask {
 
@@ -69,7 +74,7 @@ public void setExecAction(Action<JavaExecSpec> execAction) {
     @OutputFile
     public File getMarkerFile() {
         return new File(
-            new File(getProject().getBuildDir(), "precommit"),
+            new File(getProject().getBuildDir(), this.getClass().getSimpleName()),
             getName()
         );
     }
@@ -121,12 +126,25 @@ public void setSuppressAnnotations(Set<String> suppressAnnotations) {
     }
 
     @TaskAction
-    public void writeMarker() throws IOException {
+    public void runCheck() throws IOException {
+        Path inlineSignatures = Paths.get(
+            getProject().getBuildDir().getAbsolutePath(),
+            this.getClass().getSimpleName(),
+            getName() + ".inline.sig"
+        );
+        Files.write(
+            inlineSignatures,
+            signatures.stream().collect(Collectors.joining("\n")).getBytes(StandardCharsets.UTF_8)
+        );
+
         getProject().javaexec((JavaExecSpec spec) -> {
             execAction.execute(spec);
+            // This works because forbidden apis has no transitive dependencies.
+            spec.classpath(ClassPathUtils.getJar(CliMain.class));
             spec.setMain(CliMain.class.getName());
             // build the command line
             getSignaturesFiles().forEach(file -> spec.args("-f", file.getAbsolutePath()));
+            spec.args("-f", inlineSignatures.toAbsolutePath());
             getSuppressAnnotations().forEach(annotation -> spec.args("--suppressannotation", annotation));
             getBundledSignatures().forEach(bundled -> {
                     // there's no option for target compatibility so we have to interpret it

buildSrc/src/main/java/org/elasticsearch/gradle/precommit/NamingConventionsTask.java

@@ -1,6 +1,7 @@
 package org.elasticsearch.gradle.precommit;
 
 import groovy.lang.Closure;
+import org.elasticsearch.gradle.ClassPathUtils;
 import org.elasticsearch.gradle.LoggedExec;
 import org.elasticsearch.test.NamingConventionsCheck;
 import org.gradle.api.GradleException;
@@ -16,8 +17,6 @@
 import java.io.File;
 import java.io.FileWriter;
 import java.io.IOException;
-import java.net.URISyntaxException;
-import java.net.URL;
 import java.util.Objects;
 
 /**
@@ -33,24 +32,17 @@ public NamingConventionsTask() {
 
         SourceSetContainer sourceSets = getJavaSourceSets();
         final FileCollection classpath;
-        try {
-            URL location = NamingConventionsCheck.class.getProtectionDomain().getCodeSource().getLocation();
-            if (location.getProtocol().equals("file") == false) {
-                throw new GradleException("Unexpected location for NamingConventionCheck class: "+ location);
-            }
-            classpath = project.files(
-                    // This works because the class only depends on one class from junit that will be available from the
-                    // tests compile classpath. It's the most straight forward way of telling Java where to find the main
-                    // class.
-                    location.toURI().getPath(),
-                    // the tests to be loaded
-                    checkForTestsInMain ? sourceSets.getByName("main").getRuntimeClasspath() : project.files(),
-                    sourceSets.getByName("test").getCompileClasspath(),
-                    sourceSets.getByName("test").getOutput()
-            );
-        } catch (URISyntaxException e) {
-            throw new AssertionError(e);
-        }
+        classpath = project.files(
+                // This works because the class only depends on one class from junit that will be available from the
+                // tests compile classpath. It's the most straight forward way of telling Java where to find the main
+                // class.
+                ClassPathUtils.getJar(NamingConventionsCheck.class).toFile(),
+                // the tests to be loaded
+                checkForTestsInMain ? sourceSets.getByName("main").getRuntimeClasspath() : project.files(),
+                sourceSets.getByName("test").getCompileClasspath(),
+                sourceSets.getByName("test").getOutput()
+        );
+
         dependsOn(project.getTasks().matching(it -> "testCompileClasspath".equals(it.getName())));
         getInputs().files(classpath);