Pin Tooling-API client default to Gradle 8.14.3 (#7537)

* Revert JVM-based Gradle distribution picker, pin to 8.14.4

Replaces the per-JVM-version dispatch added in #7534 with a single
hardcoded Gradle distribution. Removes the now-unused helpers and
their test.

* Replace -b with rootProject.buildFileName for Gradle 9 support

Gradle 9 dropped -b. When the caller passes a build file at a
non-conventional location, write a temporary settings.gradle with
only rootProject.buildFileName, deleting it in the same finally
block as the init script.

* Skip settings.gradle existence check when build file is conventional

* Gate the settings.gradle path on Gradle 9+, keep -b for Gradle 8

Determine the Gradle version from the explicit useGradleVersion call
or from gradle-wrapper.properties when useBuildDistribution is in
play. Existing tests on Gradle 8 keep using -b. The settings.gradle
path now writes with CREATE_NEW so it can never overwrite a
user-supplied file, and the cleanup deletes only files we actually
wrote (settingsWritten flag).

* Inline settings.gradle write next to path determination

Move the Files.write call up into the same block that decides we
need a temporary settings file, and collapse the two nested
try/finally blocks into one outer finally that handles both init
and settings cleanup. settingsWritten still gates the delete so a
race-introduced or pre-existing user file is never touched.

* Simplify version selection and collapse outer try/finally

* Pin Tooling-API client default to Gradle 8.14.3

8.14.4 has a Kotlin DSL regression that breaks `plugins {}` blocks with
local `val` declarations (16 :rewrite-gradle:test failures); 8.14.3 has
no such regression and matches the pre-#7534 default for Java < 25.

Author: timtebeek

rewrite-gradle-tooling-model/model/src/main/java/org/openrewrite/gradle/toolingapi/OpenRewriteModelBuilder.java

@@ -29,6 +29,7 @@
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
+import java.nio.file.StandardOpenOption;
 import java.util.ArrayList;
 import java.util.List;
 
@@ -77,87 +78,112 @@ public static OpenRewriteModel forProjectDirectory(File projectDir, @Nullable Fi
      */
     public static OpenRewriteModel forProjectDirectory(File projectDir, @Nullable File buildFile, @Nullable String initScript) throws IOException {
         DefaultGradleConnector connector = (DefaultGradleConnector) GradleConnector.newConnector();
-        if (System.getProperty("org.openrewrite.test.gradleVersion") != null) {
-            connector.useGradleVersion(System.getProperty("org.openrewrite.test.gradleVersion"));
-        } else if (Files.exists(projectDir.toPath().resolve("gradle/wrapper/gradle-wrapper.properties"))) {
+        String gradleVersion;
+        if (Files.exists(projectDir.toPath().resolve("gradle/wrapper/gradle-wrapper.properties"))) {
+            gradleVersion = wrapperGradleVersion(projectDir.toPath().resolve("gradle/wrapper/gradle-wrapper.properties"));
             connector.useBuildDistribution();
         } else {
-            connector.useGradleVersion(defaultGradleVersion());
+            gradleVersion = System.getProperty("org.openrewrite.test.gradleVersion", "8.14.3");
+            connector.useGradleVersion(gradleVersion);
         }
         connector
                 // Uncomment to hit breakpoints inside OpenRewriteModelBuilder in unit tests
                 // Leaving commented out because the exact consequences of this internal API are unclear
                 // .embedded(true)
                 .forProjectDirectory(projectDir);
         List<String> arguments = new ArrayList<>();
-        if (buildFile != null && buildFile.exists()) {
-            arguments.add("-b");
-            arguments.add(buildFile.getAbsolutePath());
-        }
         arguments.add("--init-script");
         Path init = projectDir.toPath().resolve("openrewrite-tooling.gradle").toAbsolutePath();
         arguments.add(init.toString());
+        Path settings = null;
+        boolean settingsWritten = false;
+        if (buildFile != null && buildFile.exists()) {
+            if (isGradle9OrLater(gradleVersion)) {
+                // Gradle 9 dropped -b; for non-conventional build files write a temporary settings.gradle with rootProject.buildFileName.
+                File abs = buildFile.getAbsoluteFile();
+                boolean atConventionalLocation = abs.equals(new File(projectDir, "build.gradle").getAbsoluteFile()) ||
+                        abs.equals(new File(projectDir, "build.gradle.kts").getAbsoluteFile());
+                if (!atConventionalLocation) {
+                    Path projectPath = projectDir.toPath();
+                    if (!Files.exists(projectPath.resolve("settings.gradle")) &&
+                            !Files.exists(projectPath.resolve("settings.gradle.kts"))) {
+                        settings = projectPath.resolve("settings.gradle");
+                        Files.write(settings, ("rootProject.buildFileName = '" + buildFile.getName() + "'\n").getBytes(StandardCharsets.UTF_8), StandardOpenOption.CREATE_NEW);
+                        settingsWritten = true;
+                    }
+                }
+            } else {
+                arguments.add("-b");
+                arguments.add(buildFile.getAbsolutePath());
+            }
+        }
         try (ProjectConnection connection = connector.connect()) {
             ModelBuilder<OpenRewriteModelProxy> customModelBuilder = connection.model(OpenRewriteModelProxy.class);
-            try {
-                if (initScript == null) {
-                    if (System.getProperty("org.openrewrite.gradle.local.use-embedded-classpath") != null) {
-                        // code path only expected to be taken from within openrewrite/rewrite
-                        String generatedInitScript = generateInitScriptFromManifest();
-                        Files.write(init, generatedInitScript.getBytes(StandardCharsets.UTF_8));
-                    } else {
-                        // Use default init.gradle from resources
-                        try (InputStream is = OpenRewriteModel.class.getResourceAsStream("/init.gradle")) {
-                            if (is == null) {
-                                throw new IllegalStateException("Expected to find init.gradle on the classpath");
-                            }
-                            Files.copy(is, init);
+            if (initScript == null) {
+                if (System.getProperty("org.openrewrite.gradle.local.use-embedded-classpath") != null) {
+                    // code path only expected to be taken from within openrewrite/rewrite
+                    String generatedInitScript = generateInitScriptFromManifest();
+                    Files.write(init, generatedInitScript.getBytes(StandardCharsets.UTF_8));
+                } else {
+                    // Use default init.gradle from resources
+                    try (InputStream is = OpenRewriteModel.class.getResourceAsStream("/init.gradle")) {
+                        if (is == null) {
+                            throw new IllegalStateException("Expected to find init.gradle on the classpath");
                         }
+                        Files.copy(is, init);
                     }
-                } else {
-                    Files.write(init, initScript.getBytes());
                 }
-                customModelBuilder.withArguments(arguments);
-                return OpenRewriteModel.from(customModelBuilder.get());
-            } finally {
-                try {
-                    if (Files.exists(init)) {
-                        Files.delete(init);
-                    }
-                } catch (IOException e) {
-                    //noinspection ThrowFromFinallyBlock
-                    throw new UncheckedIOException(e);
+            } else {
+                Files.write(init, initScript.getBytes());
+            }
+            customModelBuilder.withArguments(arguments);
+            return OpenRewriteModel.from(customModelBuilder.get());
+        } finally {
+            try {
+                if (Files.exists(init)) {
+                    Files.delete(init);
+                }
+                if (settingsWritten) {
+                    Files.deleteIfExists(settings);
                 }
+            } catch (IOException e) {
+                //noinspection ThrowFromFinallyBlock
+                throw new UncheckedIOException(e);
             }
         }
     }
 
-    /**
-     * Pick a Gradle distribution compatible with the JVM running the Tooling API client.
-     * The daemon defaults to the same JVM as the client, so the chosen distribution must support that Java version.
-     * See <a href="https://docs.gradle.org/current/userguide/compatibility.html">Gradle compatibility matrix</a>.
-     */
-    static String defaultGradleVersion() {
-        return defaultGradleVersion(javaSpecificationVersion());
-    }
-
-    static String defaultGradleVersion(int javaFeatureVersion) {
-        if (javaFeatureVersion >= 25) {
-            return "9.1.0";
+    private static boolean isGradle9OrLater(@Nullable String version) {
+        if (version == null) {
+            return false;
+        }
+        int dot = version.indexOf('.');
+        try {
+            return Integer.parseInt(dot < 0 ? version : version.substring(0, dot)) >= 9;
+        } catch (NumberFormatException e) {
+            return false;
         }
-        return "8.14.3";
     }
 
-    private static int javaSpecificationVersion() {
-        String version = System.getProperty("java.specification.version", "8");
-        if (version.startsWith("1.")) {
-            version = version.substring(2);
-        }
+    private static @Nullable String wrapperGradleVersion(Path wrapperProperties) {
         try {
-            return Integer.parseInt(version);
-        } catch (NumberFormatException e) {
-            return 8;
+            for (String line : Files.readAllLines(wrapperProperties, StandardCharsets.UTF_8)) {
+                if (line.startsWith("distributionUrl=")) {
+                    int idx = line.lastIndexOf("gradle-");
+                    if (idx < 0) {
+                        return null;
+                    }
+                    int start = idx + "gradle-".length();
+                    int end = start;
+                    while (end < line.length() && (Character.isDigit(line.charAt(end)) || line.charAt(end) == '.')) {
+                        end++;
+                    }
+                    return end > start ? line.substring(start, end) : null;
+                }
+            }
+        } catch (IOException ignored) {
         }
+        return null;
     }
 
     /**