Name the native image without palantir's platform library

open-java-format-native put com.palantir.gradle.utils:platform on its
buildscript classpath for two things: the <os>_<arch> part of the image
name, and whether a collected binary is a Windows .exe. The new buildSrc
plugin open-java-format.native-platform works out the first with the
same names (macos, windows, linux-glibc or linux-musl from ldd --version;
x86-64, aarch64, x86) and sets it as nativePlatform. The extension now
comes from the .exe suffix the file name pattern already matched.

The image here is still open-java-format-macos_aarch64, and six dummy
binaries passed in with -PnativeImages get the classifiers and
extensions already published on Maven Central.

Author: abashev

buildSrc/src/main/groovy/open-java-format.native-platform.gradle

@@ -0,0 +1,45 @@
+// The platform this build runs on, as `nativePlatform`: <os>_<arch>, the names open-java-format-native's
+// classifiers carry (nativeImage-<os>_<arch>) and the Gradle plugin resolves (NativeImageFormatProviderPlugin).
+def osName = providers.systemProperty('os.name').get().toLowerCase(Locale.ROOT)
+def osArch = providers.systemProperty('os.arch').get().toLowerCase(Locale.ROOT)
+
+String os
+if (osName.startsWith('mac')) {
+    os = 'macos'
+} else if (osName.startsWith('windows')) {
+    os = 'windows'
+} else if (osName.startsWith('linux')) {
+    // A glibc image does not run on musl. glibc's ldd prints its version to stdout; musl's prints it
+    // to stderr and exits with 1.
+    def ldd = providers.exec {
+        commandLine 'ldd', '--version'
+        ignoreExitValue = true
+    }
+    def libc = (ldd.standardOutput.asText.get() + ldd.standardError.asText.get()).toLowerCase(Locale.ROOT)
+    if (libc.contains('glibc') || libc.contains('gnu libc')) {
+        os = 'linux-glibc'
+    } else if (libc.contains('musl')) {
+        os = 'linux-musl'
+    } else {
+        throw new GradleException("Cannot tell glibc from musl: ldd --version printed ${libc}")
+    }
+} else {
+    throw new GradleException("No native image name for the operating system ${osName}")
+}
+
+String arch
+switch (osArch) {
+    case ['x86_64', 'x64', 'amd64']:
+        arch = 'x86-64'
+        break
+    case ['arm', 'arm64', 'aarch64']:
+        arch = 'aarch64'
+        break
+    case ['x86', 'i686']:
+        arch = 'x86'
+        break
+    default:
+        throw new GradleException("No native image name for the architecture ${osArch}")
+}
+
+ext.nativePlatform = "${os}_${arch}".toString()

open-java-format-native/build.gradle

@@ -10,27 +10,22 @@ buildscript {
     }
     dependencies {
         classpath 'org.graalvm.buildtools:native-gradle-plugin:1.1.14'
-        classpath 'com.palantir.gradle.utils:platform:0.29.0'
     }
 }
 
 
 apply plugin: 'java-library'
 apply plugin: 'org.graalvm.buildtools.native'
 apply plugin: 'open-java-format.publishing-conventions'
+// nativePlatform: the <os>_<arch> of this machine, as the image name and its classifier spell it.
+apply plugin: 'open-java-format.native-platform'
 
 description = 'open-java-format compiled to a native executable with GraalVM, one classifier per platform'
 
 dependencies {
     implementation project(':open-java-format')
 }
 
-import com.palantir.platform.OperatingSystem
-import com.palantir.platform.Architecture
-
-def operatingSystem = OperatingSystem.get()
-def architecture = Architecture.get()
-
 def exports = [
         'jdk.compiler/com.sun.tools.javac.file',
         'jdk.compiler/com.sun.tools.javac.main',
@@ -59,7 +54,7 @@ graalvmNative {
             it.languageVersion.set(JavaLanguageVersion.of(25))
             it.vendor.set(JvmVendorSpec.GRAAL_VM)
         })
-        it.imageName.set(String.format('open-java-format-%s_%s', operatingSystem.uiName(), architecture.uiName()))
+        it.imageName.set("open-java-format-${nativePlatform}".toString())
         it.mainClass.set('com.palantir.javaformat.java.Main')
         it.fallback.set(false)
         it.sharedLibrary.set(false)
@@ -126,8 +121,7 @@ private static String getExtension(File file) {
     Pattern pattern = Pattern.compile("open-java-format-(.*)_(.*?)(\\.exe)?\$");
     Matcher matcher = pattern.matcher(file.name)
     if (matcher.find()) {
-        return OperatingSystem.fromStringThrowing(matcher.group(1))
-                == OperatingSystem.WINDOWS ? "exe" : "bin"
+        return matcher.group(3) == null ? "bin" : "exe"
     }
     throw new GradleException("Could not determine OS name from file name: ${file.name}")
 }