working transforms

gradle-palantir-java-format/src/main/java/com/palantir/javaformat/gradle/ExecutableTransform.java

@@ -0,0 +1,71 @@
+/*
+ * (c) Copyright 2025 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.javaformat.gradle;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.attribute.PosixFilePermission;
+import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import org.gradle.api.artifacts.transform.InputArtifact;
+import org.gradle.api.artifacts.transform.TransformAction;
+import org.gradle.api.artifacts.transform.TransformOutputs;
+import org.gradle.api.artifacts.transform.TransformParameters;
+import org.gradle.api.file.FileSystemLocation;
+import org.gradle.api.logging.Logger;
+import org.gradle.api.logging.Logging;
+import org.gradle.api.provider.Provider;
+
+public abstract class ExecutableTransform implements TransformAction<TransformParameters.None> {
+
+    private static Logger logger = Logging.getLogger(ExecutableTransform.class);
+
+    @InputArtifact
+    public abstract Provider<FileSystemLocation> getInputArtifact();
+
+    @Override
+    public void transform(TransformOutputs outputs) {
+        File inputFile = getInputArtifact().get().getAsFile();
+        makeFileExecutable(inputFile.toPath());
+        logger.info("Output is the input file: {}", inputFile);
+        outputs.file(inputFile);
+        logger.info("Output is the input file: {}", outputs);
+    }
+
+    private static void makeFileExecutable(Path pathToExe) {
+        try {
+            Set<PosixFilePermission> existingPermissions = Files.getPosixFilePermissions(pathToExe);
+            Files.setPosixFilePermissions(
+                    pathToExe,
+                    Stream.concat(
+                                    existingPermissions.stream(),
+                                    Stream.of(
+                                            PosixFilePermission.OWNER_EXECUTE,
+                                            PosixFilePermission.GROUP_EXECUTE,
+                                            PosixFilePermission.OTHERS_EXECUTE))
+                            .collect(Collectors.toSet()));
+            logger.info("Marking is the input file as executable: {}", pathToExe);
+        } catch (IOException e) {
+            throw new RuntimeException("Failed to set execute permissions on native-image", e);
+        }
+    }
+
+    interface Parameters extends TransformParameters {}
+}

gradle-palantir-java-format/src/main/java/com/palantir/javaformat/gradle/PalantirJavaFormatProviderPlugin.java

@@ -18,27 +18,33 @@
 
 import com.google.common.base.Preconditions;
 import com.google.common.collect.ImmutableMap;
+import java.util.Optional;
 import org.gradle.api.Plugin;
 import org.gradle.api.Project;
 import org.gradle.api.artifacts.Configuration;
+import org.gradle.api.artifacts.type.ArtifactTypeDefinition;
 
 public final class PalantirJavaFormatProviderPlugin implements Plugin<Project> {
 
     static final String CONFIGURATION_NAME = "palantirJavaFormat";
-    static final String CONFIGURATION_NAME_NATIVE = "palantirJavaFormatNative";
 
     @Override
     public void apply(Project rootProject) {
         Preconditions.checkState(
                 rootProject == rootProject.getRootProject(),
                 "May only apply com.palantir.java-format-provider to the root project");
+        Boolean legacyFormatter = Optional.ofNullable(rootProject.findProperty("palantir.legacy.formatter"))
+                .map(value -> Boolean.getBoolean((String) value))
+                .orElse(false);
 
-        Configuration _configuration = rootProject.getConfigurations().create(CONFIGURATION_NAME, conf -> {
-            conf.setDescription("Internal configuration for resolving the palantir-java-format implementation");
-            conf.setVisible(false);
-            conf.setCanBeConsumed(false);
+        Configuration configuration = rootProject.getConfigurations().create(CONFIGURATION_NAME);
+        configuration.setDescription("Internal configuration for resolving the palantir-java-format implementation");
+        configuration.setVisible(false);
+        configuration.setCanBeConsumed(false);
+        configuration.setCanBeResolved(true);
 
-            conf.defaultDependencies(deps -> {
+        if (legacyFormatter) {
+            configuration.defaultDependencies(deps -> {
                 deps.add(rootProject
                         .getDependencies()
                         .create(ImmutableMap.of(
@@ -49,15 +55,8 @@ public void apply(Project rootProject) {
                                 "version",
                                 JavaFormatExtension.class.getPackage().getImplementationVersion())));
             });
-        });
-
-        Configuration configuration2 = rootProject.getConfigurations().create(CONFIGURATION_NAME_NATIVE, conf -> {
-            conf.setDescription("Internal configuration for resolving the palantir-java-format-native implementation");
-            conf.setVisible(false);
-            conf.setCanBeConsumed(false);
-            conf.setCanBeResolved(true);
-
-            conf.defaultDependencies(deps -> {
+        } else {
+            configuration.defaultDependencies(deps -> {
                 deps.add(rootProject
                         .getDependencies()
                         .create(ImmutableMap.of(
@@ -72,8 +71,17 @@ public void apply(Project rootProject) {
                                 "ext",
                                 "sh")));
             });
-        });
+            configuration
+                    .getAttributes()
+                    .attribute(ArtifactTypeDefinition.ARTIFACT_TYPE_ATTRIBUTE, "executable-nativeImage");
+            rootProject.getDependencies().registerTransform(ExecutableTransform.class, transformSpec -> {
+                transformSpec.getFrom().attribute(ArtifactTypeDefinition.ARTIFACT_TYPE_ATTRIBUTE, "sh");
+                transformSpec
+                        .getTo()
+                        .attribute(ArtifactTypeDefinition.ARTIFACT_TYPE_ATTRIBUTE, "executable-nativeImage");
+            });
+        }
 
-        rootProject.getExtensions().create("palantirJavaFormat", JavaFormatExtension.class, configuration2);
+        rootProject.getExtensions().create("palantirJavaFormat", JavaFormatExtension.class, configuration);
     }
 }

gradle-palantir-java-format/src/main/java/com/palantir/javaformat/gradle/SpotlessInterop.java

@@ -31,7 +31,8 @@
 final class SpotlessInterop {
     private static Logger logger = Logging.getLogger(SpotlessInterop.class);
 
-    private SpotlessInterop() {}
+    private SpotlessInterop() {
+    }
 
     static void addSpotlessJavaStep(Project project, String configurationName) {
         SpotlessExtension spotlessExtension = project.getExtensions().getByType(SpotlessExtension.class);
@@ -50,7 +51,7 @@ static FormatterStep addSpotlessJavaFormatStep(Project project, String configura
         } else {
             logger.info("Using the native-image palantir-java-formatter");
             return NativePalantirJavaFormatStep.create(
-                    project.getRootProject().getConfigurations().getByName("palantirJavaFormatNative"));
+                    project.getRootProject().getConfigurations().getByName(configurationName));
         }
     }
 }

gradle-palantir-java-format/src/main/java/com/palantir/javaformat/gradle/spotless/NativePalantirJavaFormatStep.java

@@ -24,22 +24,15 @@
 import java.io.IOException;
 import java.io.Serializable;
 import java.nio.charset.StandardCharsets;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.nio.file.attribute.PosixFilePermission;
 import java.util.List;
-import java.util.Set;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
 import org.gradle.api.artifacts.Configuration;
 import org.gradle.api.logging.Logger;
 import org.gradle.api.logging.Logging;
 
 public class NativePalantirJavaFormatStep {
     private static Logger logger = Logging.getLogger(NativePalantirJavaFormatStep.class);
 
-    private NativePalantirJavaFormatStep() {
-    }
+    private NativePalantirJavaFormatStep() {}
 
     private static final String NAME = "palantir-java-format";
 
@@ -50,7 +43,6 @@ public static FormatterStep create(Configuration configuration) {
                 () -> {
                     File execFile = configuration.getSingleFile();
                     logger.info("Using native-image at {}", configuration.getSingleFile());
-                    makeFileExecutable(execFile.toPath());
                     return new State(FileSignature.signAsSet(execFile));
                 },
                 State::createFormat);
@@ -77,22 +69,4 @@ FormatterFunc.Closeable createFormat() {
             return FormatterFunc.Closeable.of(runner, this::format);
         }
     }
-
-    private static void makeFileExecutable(Path pathToExe) {
-        try {
-            Set<PosixFilePermission> existingPermissions =
-                    Files.getPosixFilePermissions(pathToExe);
-            Files.setPosixFilePermissions(
-                    pathToExe,
-                    Stream.concat(
-                                    existingPermissions.stream(),
-                                    Stream.of(
-                                            PosixFilePermission.OWNER_EXECUTE,
-                                            PosixFilePermission.GROUP_EXECUTE,
-                                            PosixFilePermission.OTHERS_EXECUTE))
-                            .collect(Collectors.toSet()));
-        } catch (IOException e) {
-            throw new RuntimeException("Failed to set execute permissions on native-image", e);
-        }
-    }
 }

palantir-java-format/build.gradle

@@ -166,9 +166,7 @@ publishing {
                 extension="sh"
             }
             artifactId = 'palantir-java-format-native'
+
         }
     }
 }
-
-
-