Show the active formatter as the settings page stands, under Tools

The page moves from Other Settings to Tools. Use native binary and
everything under it shows only while open-java-format is enabled.

Plugin version and Implementation version are gone: neither told the
user anything to act on. Formatter type is now Active formatter, below
a separator, and it follows the page as it changes rather than the
settings as last applied: Java-based formatter without the native
binary, the path typed in Binary as it is typed, else the embedded
binary's path, else that the plugin's version needs downloading from
Maven Central. It is chosen by FormatterSelection, as FormatterProvider
chooses what runs, so FormatterSelection no longer describes itself.

Author: abashev

open-java-format-idea-plugin/src/main/java/com/palantir/javaformat/intellij/FormatterSelection.java

@@ -19,8 +19,8 @@
 import java.util.function.Supplier;
 
 /**
- * Which formatter a project's settings run. FormatterProvider starts it, and the settings page shows it as the
- * formatter type, so the page cannot claim one formatter while another runs.
+ * Which formatter a project's settings run. FormatterProvider starts it, and the settings page shows it as the active
+ * formatter, so the page cannot claim one formatter while another runs.
  */
 sealed interface FormatterSelection {
 
@@ -39,22 +39,8 @@ static FormatterSelection of(PalantirJavaFormatSettings settings, Supplier<Optio
                 .orElseGet(() -> new JavaBased(true));
     }
 
-    String describe();
-
-    record NativeImage(Path path, boolean embedded) implements FormatterSelection {
-        @Override
-        public String describe() {
-            return "Native binary, " + (embedded ? "embedded" : "custom") + ": " + path;
-        }
-    }
+    record NativeImage(Path path, boolean embedded) implements FormatterSelection {}
 
     /** nativeImageMissing: the native formatter is switched on, but there is no binary to run. */
-    record JavaBased(boolean nativeImageMissing) implements FormatterSelection {
-        @Override
-        public String describe() {
-            return nativeImageMissing
-                    ? "Java-based formatter: the native binary is not downloaded"
-                    : "Java-based formatter";
-        }
-    }
+    record JavaBased(boolean nativeImageMissing) implements FormatterSelection {}
 }

open-java-format-idea-plugin/src/main/java/com/palantir/javaformat/intellij/PalantirJavaFormatConfigurable.java

@@ -25,6 +25,7 @@
 import com.intellij.openapi.ui.TextBrowseFolderListener;
 import com.intellij.openapi.ui.TextFieldWithBrowseButton;
 import com.intellij.openapi.util.Disposer;
+import com.intellij.ui.DocumentAdapter;
 import com.intellij.ui.components.ActionLink;
 import com.intellij.ui.components.JBTextArea;
 import com.intellij.ui.components.JBTextField;
@@ -47,6 +48,7 @@
 import javax.swing.JLabel;
 import javax.swing.JPanel;
 import javax.swing.JTextArea;
+import javax.swing.event.DocumentEvent;
 import org.jetbrains.annotations.Nls;
 import org.jetbrains.annotations.NotNull;
 
@@ -61,9 +63,8 @@ class PalantirJavaFormatConfigurable extends BaseConfigurable implements Searcha
     private final JLabel embeddedStatus;
     private final ActionLink embeddedAction;
     private final TextFieldWithBrowseButton nativeImagePath;
-    private final JTextArea formatterType;
-    private final JLabel formatterVersion;
-    private final JLabel pluginVersion;
+    private final JPanel activeFormatterRow;
+    private final JTextArea activeFormatter;
 
     // Lives from createComponent() to disposeUIResources(): the download reports its progress to the page.
     @Nullable
@@ -88,9 +89,7 @@ public PalantirJavaFormatConfigurable(Project project) {
         this.nativeImagePath = new TextFieldWithBrowseButton(pathField);
         nativeImagePath.addBrowseFolderListener(new TextBrowseFolderListener(
                 FileChooserDescriptorFactory.createSingleFileNoJarsDescriptor().withTitle("Native Binary"), project));
-        this.pluginVersion = new JLabel();
-        this.formatterVersion = new JLabel();
-        this.formatterType = selectableText();
+        this.activeFormatter = selectableText();
 
         var statusRow = new JPanel(new FlowLayout(FlowLayout.LEADING, 0, 0));
         statusRow.add(embeddedStatus);
@@ -101,7 +100,22 @@ public PalantirJavaFormatConfigurable(Project project) {
                 .addComponent(statusRow)
                 .addLabeledComponent("Binary", nativeImagePath)
                 .getPanel();
-        useNativeImage.addItemListener(event -> nativeImageOptions.setVisible(useNativeImage.isSelected()));
+        // Filling its own form vertically: only then does the form put the label above the text, rather than beside
+        // the middle of a wrapped path.
+        this.activeFormatterRow = FormBuilder.createFormBuilder()
+                .addSeparator()
+                .addLabeledComponentFillVertically("Active formatter", activeFormatter)
+                .getPanel();
+
+        // The page shows what runs once it is applied, so it follows every box and the path as they change.
+        enable.addItemListener(event -> showPage());
+        useNativeImage.addItemListener(event -> showPage());
+        nativeImagePath.getTextField().getDocument().addDocumentListener(new DocumentAdapter() {
+            @Override
+            protected void textChanged(DocumentEvent event) {
+                showActiveFormatter();
+            }
+        });
 
         // Laid out here rather than by the IntelliJ GUI designer. A .form is woven into the class at build
         // time, and this build does not instrument bytecode (see build.gradle), which left every field
@@ -110,11 +124,9 @@ public PalantirJavaFormatConfigurable(Project project) {
                 .addComponent(enable)
                 .addComponent(useNativeImage)
                 .addComponent(nativeImageOptions)
-                .addLabeledComponent("Plugin version", pluginVersion)
-                .addLabeledComponent("Implementation version", formatterVersion)
-                // Last, and filling the rest of the page: only then does the form put the label at the text's first
-                // line rather than in the middle of a wrapped path.
-                .addLabeledComponentFillVertically("Formatter type", formatterType)
+                .addComponent(activeFormatterRow)
+                // Takes the rest of the page, so the rows stay at the top whichever of them are hidden.
+                .addComponentFillVertically(new JPanel(), 0)
                 .getPanel();
     }
 
@@ -167,7 +179,6 @@ public void apply() throws ConfigurationException {
         settings.setEnabled(enable.isSelected() ? EnabledState.ENABLED : getDisabledState());
         settings.setUseNativeImage(useNativeImage.isSelected());
         settings.setNativeImagePath(path);
-        showEmbeddedNativeImage();
     }
 
     private EnabledState getDisabledState() {
@@ -182,12 +193,9 @@ public void reset() {
         PalantirJavaFormatSettings settings = PalantirJavaFormatSettings.getInstance(project);
         enable.setSelected(settings.isEnabled());
         useNativeImage.setSelected(settings.useNativeImage());
-        nativeImageOptions.setVisible(settings.useNativeImage());
         nativeImagePath.setText(
                 settings.getNativeImagePath().map(Path::toString).orElse(""));
-        pluginVersion.setText(settings.getImplementationVersion().orElse("unknown"));
-        formatterVersion.setText(getFormatterVersionText(settings));
-        showEmbeddedNativeImage();
+        showPage();
     }
 
     @Override
@@ -236,15 +244,47 @@ static StatusLine statusLine(Status status) {
         };
     }
 
+    private void showPage() {
+        useNativeImage.setVisible(enable.isSelected());
+        nativeImageOptions.setVisible(enable.isSelected() && useNativeImage.isSelected());
+        activeFormatterRow.setVisible(enable.isSelected());
+        showEmbeddedNativeImage();
+    }
+
     private void showEmbeddedNativeImage() {
         var line = statusLine(embeddedNativeImage.status(pluginVersion()));
         embeddedStatus.setText(line.text());
         embeddedAction.setText(line.action().orElse(""));
         embeddedAction.setVisible(line.action().isPresent());
-        // What runs with the settings as applied: the embedded binary can arrive while the page is open.
-        formatterType.setText(FormatterSelection.of(
-                        PalantirJavaFormatSettings.getInstance(project), embeddedNativeImage::installedPath)
-                .describe());
+        // The embedded binary can arrive while the page is open.
+        showActiveFormatter();
+    }
+
+    /**
+     * The formatter the page would run once applied, chosen as FormatterProvider chooses it: the path typed in Binary,
+     * else the embedded binary, else the Java-based formatter.
+     */
+    private void showActiveFormatter() {
+        var pending = new PalantirJavaFormatSettings();
+        pending.setUseNativeImage(useNativeImage.isSelected());
+        try {
+            pending.setNativeImagePath(enteredNativeImagePath());
+        } catch (ConfigurationException e) {
+            // Not a path at all: shown as typed, and Apply says what is wrong with it.
+            activeFormatter.setText(nativeImagePath.getText().strip());
+            return;
+        }
+        activeFormatter.setText(
+                switch (FormatterSelection.of(pending, embeddedNativeImage::installedPath)) {
+                    case FormatterSelection.NativeImage nativeImage ->
+                        nativeImage.path().toString();
+                    case FormatterSelection.JavaBased javaBased
+                    when !javaBased.nativeImageMissing() -> "Java-based formatter";
+                    case FormatterSelection.JavaBased missing ->
+                        embeddedNativeImage.status(pluginVersion()) instanceof Status.NoImageForPlatform
+                                ? "Choose a native binary: none is published for this platform"
+                                : "Need to download version " + pluginVersion() + " from Maven Central";
+                });
     }
 
     private String pluginVersion() {
@@ -266,9 +306,9 @@ private Optional<Path> enteredNativeImagePath() throws ConfigurationException {
     }
 
     /**
-     * Read-only text that wraps at the page's width and can be selected and copied: the formatter type names the
-     * binary that runs, and the embedded one's path, deep in the IDE's system directory, would otherwise widen the
-     * page past the dialog.
+     * Read-only text that wraps at the page's width and can be selected and copied: the active formatter is often a
+     * path, and the embedded binary's, deep in the IDE's system directory, would otherwise widen the page past the
+     * dialog.
      */
     private static JTextArea selectableText() {
         var text = new JBTextArea() {
@@ -296,8 +336,4 @@ public void componentResized(ComponentEvent event) {
         return text;
     }
 
-    private static String getFormatterVersionText(PalantirJavaFormatSettings settings) {
-        String suffix = settings.injectedVersionIsOutdated() ? " (using bundled)" : " (using injected)";
-        return settings.computeFormatterVersion().orElse("(bundled)") + suffix;
-    }
 }

open-java-format-idea-plugin/src/main/resources/META-INF/plugin.xml

@@ -22,7 +22,8 @@
   <extensions defaultExtensionNs="com.intellij">
     <formattingService
             implementation="com.palantir.javaformat.intellij.PalantirJavaFormatFormattingService"/>
-    <projectConfigurable instance="com.palantir.javaformat.intellij.PalantirJavaFormatConfigurable"
+    <projectConfigurable parentId="tools"
+                         instance="com.palantir.javaformat.intellij.PalantirJavaFormatConfigurable"
                          id="open-java-format.settings"
                          displayName="open-java-format Settings"
                          nonDefaultProject="true"/>

open-java-format-idea-plugin/src/test/java/com/palantir/javaformat/intellij/FormatterSelectionTest.java

@@ -73,13 +73,4 @@ void looksForTheEmbeddedBinaryOnlyWhenItWouldRun() {
         settings.setUseNativeImage(true);
         assertThat(FormatterSelection.of(settings, unasked)).isEqualTo(new NativeImage(CUSTOM, false));
     }
-
-    @Test
-    void describesWhatRunsForTheSettingsPage() {
-        assertThat(new NativeImage(CUSTOM, false).describe()).isEqualTo("Native binary, custom: " + CUSTOM);
-        assertThat(new NativeImage(EMBEDDED, true).describe()).isEqualTo("Native binary, embedded: " + EMBEDDED);
-        assertThat(new JavaBased(false).describe()).isEqualTo("Java-based formatter");
-        assertThat(new JavaBased(true).describe())
-                .isEqualTo("Java-based formatter: the native binary is not downloaded");
-    }
 }

open-java-format-idea-plugin/src/test/java/com/palantir/javaformat/intellij/PalantirJavaFormatConfigurableTest.java

@@ -16,8 +16,10 @@
 
 import static java.util.Objects.requireNonNull;
 import static org.assertj.core.api.Assertions.assertThat;
+import static com.google.common.collect.MoreCollectors.onlyElement;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
+import com.intellij.openapi.options.Configurable;
 import com.intellij.openapi.options.ConfigurationException;
 import com.intellij.openapi.ui.ComboBox;
 import com.intellij.openapi.ui.TextFieldWithBrowseButton;
@@ -73,6 +75,7 @@ void setUp() throws Exception {
         fixture.setUp();
         settings = PalantirJavaFormatSettings.getInstance(fixture.getProject());
         settings.loadState(new State());
+        settings.setEnabled(true);
         // Nothing downloaded, and nowhere to download from.
         var embedded = new EmbeddedNativeImage(
                 dir.resolve("native"), Optional.of(new NativePlatform("macos", "aarch64")), "http://127.0.0.1:1");
@@ -120,11 +123,86 @@ void readsAndWritesTheEnabledSetting() throws Throwable {
         assertThat(settings.isEnabled()).isTrue();
     }
 
+    @Test
+    void sitsUnderTools() {
+        var page = Configurable.PROJECT_CONFIGURABLE.getExtensions(fixture.getProject()).stream()
+                .filter(extension -> "open-java-format.settings".equals(extension.id))
+                .findFirst()
+                .orElseThrow();
+
+        assertThat(page.parentId).isEqualTo("tools");
+    }
+
+    @Test
+    void hasNoRowsOfVersions() {
+        // The plugin's version and the formatter's told the user nothing to act on.
+        assertThat(findAll(component, JLabel.class))
+                .extracting(JLabel::getText)
+                .doesNotContain("Plugin version", "Implementation version");
+    }
+
+    @Test
+    void showsTheNativeBinaryOnlyWhileOpenJavaFormatIsOn() throws Throwable {
+        EdtTestUtil.runInEdtAndWait(() -> {
+            var enable = findCheckBox("Enable open-java-format");
+            var useNativeImage = findCheckBox("Use native binary");
+            var path = findAll(component, TextFieldWithBrowseButton.class).get(0);
+            settings.setUseNativeImage(true);
+            configurable.reset();
+            assertThat(isDisplayed(useNativeImage)).isTrue();
+            assertThat(isDisplayed(path)).isTrue();
+
+            enable.setSelected(false);
+            assertThat(isDisplayed(useNativeImage)).isFalse();
+            assertThat(isDisplayed(path)).isFalse();
+            assertThat(isDisplayed(activeFormatter())).isFalse();
+
+            enable.setSelected(true);
+            assertThat(isDisplayed(useNativeImage)).isTrue();
+            assertThat(isDisplayed(path)).isTrue();
+        });
+    }
+
+    @Test
+    void showsTheActiveFormatterAsThePageStands() throws Throwable {
+        // What runs once the page is applied, so it follows the boxes and the path as they change.
+        var pluginVersion = settings.getImplementationVersion().orElseThrow();
+
+        EdtTestUtil.runInEdtAndWait(() -> {
+            var useNativeImage = findCheckBox("Use native binary");
+            var path = findAll(component, TextFieldWithBrowseButton.class).get(0);
+            configurable.reset();
+            assertThat(activeFormatter().getText()).isEqualTo("Java-based formatter");
+
+            useNativeImage.setSelected(true);
+            assertThat(activeFormatter().getText())
+                    .isEqualTo("Need to download version " + pluginVersion + " from Maven Central");
+
+            path.setText("/opt/open-java-format");
+            assertThat(activeFormatter().getText()).isEqualTo("/opt/open-java-format");
+
+            useNativeImage.setSelected(false);
+            assertThat(activeFormatter().getText()).isEqualTo("Java-based formatter");
+        });
+    }
+
+    @Test
+    void showsTheEmbeddedBinaryOnceItIsThere() throws Throwable {
+        var binary = installByHand("21.0.1");
+        settings.setUseNativeImage(true);
+
+        EdtTestUtil.runInEdtAndWait(() -> {
+            configurable.reset();
+
+            assertThat(activeFormatter().getText()).isEqualTo(binary.toString());
+        });
+    }
+
     @Test
     void showsTheVersionOfThePlugin() {
-        // The "Plugin version" row: the version the platform read from the plugin's own descriptor, not "unknown".
-        // Whatever the build stamped: CI checks out without tags, so there it is a commit hash rather than a
-        // release-like version.
+        // The version the plugin downloads the native binary of: the one the platform read from the plugin's own
+        // descriptor, not "unknown". Whatever the build stamped: CI checks out without tags, so there it is a commit
+        // hash rather than a release-like version.
         assertThat(settings.getImplementationVersion())
                 .hasValueSatisfying(version -> assertThat(version).isNotBlank());
     }
@@ -210,7 +288,7 @@ void offersADownloadBeforeTheFirstOne() throws Throwable {
     }
 
     @Test
-    void wrapsTheFormatterTypeAndLetsItsPathBeCopied() throws Throwable {
+    void wrapsTheActiveFormatterAndLetsItsPathBeCopied() throws Throwable {
         // The embedded binary lives deep in the IDE's system directory: on one line its path made the page wider than
         // the dialog, and a label would not let anyone copy it. A long path of one's own in Binary must not either.
         var path = Path.of("/Users/someone/Library/Caches/JetBrains/IntelliJIdea2026.2/open-java-format/native/"
@@ -221,10 +299,8 @@ void wrapsTheFormatterTypeAndLetsItsPathBeCopied() throws Throwable {
         EdtTestUtil.runInEdtAndWait(() -> {
             configurable.reset();
 
-            var formatterType = findAll(component, JTextArea.class).stream()
-                    .filter(text -> text.getText().contains(path.toString()))
-                    .findFirst()
-                    .orElseThrow();
+            var formatterType = activeFormatter();
+            assertThat(formatterType.getText()).isEqualTo(path.toString());
             assertThat(formatterType.isEditable()).isFalse();
             assertThat(formatterType.getLineWrap()).isTrue();
             assertThat(component.getPreferredSize().width).isLessThan(1000);
@@ -276,6 +352,19 @@ private boolean isDisplayed(Component target) {
         return true;
     }
 
+    /** The text under Active formatter: the page's one text area. */
+    private JTextArea activeFormatter() {
+        return findAll(component, JTextArea.class).stream().collect(onlyElement());
+    }
+
+    private Path installByHand(String version) throws IOException {
+        var binary = Files.createDirectories(dir.resolve("native").resolve(version))
+                .resolve("open-java-format-macos_aarch64");
+        Files.writeString(binary, "#!/bin/sh\n");
+        assertThat(binary.toFile().setExecutable(true)).isTrue();
+        return binary;
+    }
+
     private Path executable(String name) throws IOException {
         var binary = Files.writeString(dir.resolve(name), "#!/bin/sh\n");
         assertThat(binary.toFile().setExecutable(true)).isTrue();