fix(gui): correct java pluginId mapping and reduce saveAllChanges NPath

Three issues surfaced by the GUI module build:

1. SourceWriteBackSupportTest failures
   (findPatcher_javaFile_returnsJvmPatcher,
    supportedLanguagesLabel_listsJavaAndCSharp)

   SourceWriteBackSupport.LANGUAGE_LABELS used the key "jvm" but
   JavaSourcePatcher.pluginId() actually returns "java". The
   getOrDefault fallback uppercased the unmapped key, so
   supportedLanguagesLabel() returned "JAVA, C#" instead of
   "Java, C#" and the case-sensitive contains("Java") assertion
   failed. Fix: change the key to "java" and document the contract
   (LANGUAGE_LABELS keys must match the patchers' pluginId()
   return values).

   The test that asserted patcher.pluginId() == "jvm" is renamed to
   findPatcher_javaFile_returnsJavaPatcher and switched to
   assertEquals so the actual vs. expected value is reported on
   failure.

2. MainWindow.saveAllChanges NPath 289 (threshold 260)

   Extracted the body into five single-responsibility helpers:
     - groupStagedByFile     — bucket entries per source file
     - ensureWriteBackSupport — lazy SourceWriteBackSupport init
     - patchSingleFile       — per-file SourcePatcher invocation
                                + audit-entry build-up
     - writeAuditEvidence    — .methodatlas/ audit log + warning
                                dialog on failure
     - reportSaveResult      — status-bar message / error dialog

   saveAllChanges itself is now a short orchestrator. Semantics
   are unchanged; the public behaviour (which files get patched,
   which audit entries are written, which dialogs are shown) is
   bit-identical.

3. UnnecessaryWarningSuppression on
   SourceWriteBackSupport constructor and on patchSingleFile

   Removed @SuppressWarnings("PMD.AvoidInstantiatingObjectsInLoops")
   from both — PMD does not actually emit the suppressed finding for
   these methods, so the annotation was flagged as unnecessary. The
   suppression on groupStagedByFile is kept because PMD does flag
   the `new ArrayList<>()` lambda inside computeIfAbsent there.

Confirmed by the user: PMD passes and all tests pass.

Author: leogalambos

methodatlas-gui/src/main/java/org/egothor/methodatlas/gui/MainWindow.java

@@ -319,102 +319,164 @@ private void refreshProfileCombo() {
 
     // ── Save All Changes ──────────────────────────────────────────────────
 
-    @SuppressWarnings("PMD.AvoidInstantiatingObjectsInLoops")
+    /**
+     * Persists every staged {@link MethodEntry} to disk by routing each
+     * source file through its matching {@link SourcePatcher}. Files in a
+     * language with no patcher (TypeScript, Go, Python, …) are collected
+     * as per-file errors so the user gets an explicit message instead of
+     * a silent skip.
+     *
+     * <p>The actual work is delegated to small single-responsibility
+     * helpers ({@link #groupStagedByFile}, {@link #ensureWriteBackSupport},
+     * {@link #patchSingleFile}, {@link #writeAuditEvidence},
+     * {@link #reportSaveResult}) to keep the method's NPath complexity
+     * within the project PMD threshold.</p>
+     */
     private void saveAllChanges() {
         List<MethodEntry> staged = model.getStagedEntries();
-        if (staged.isEmpty()) { return; }
-
-        // Group staged entries by source file
-        Map<Path, List<MethodEntry>> byFile = new LinkedHashMap<>();
-        for (MethodEntry entry : staged) {
-            Path fp = entry.discovered().filePath();
-            if (fp != null) { byFile.computeIfAbsent(fp, k -> new ArrayList<>()).add(entry); }
+        if (staged.isEmpty()) {
+            return;
         }
 
-        // Reuse (or lazily build) the SourceWriteBackSupport that gates the
-        // tag editor. This guarantees the same configured patchers are used
-        // for both UI gating and on-disk write-back.
-        if (writeBackSupport == null) {
-            TestDiscoveryConfig config = new TestDiscoveryConfig(
-                    TagEditorPanel.buildFlatSuffixes(settings),
-                    Set.copyOf(settings.getTestAnnotations()),
-                    Map.of());
-            writeBackSupport = new SourceWriteBackSupport(config);
-            tagEditorPanel.setWriteBackSupport(writeBackSupport);
-        }
+        Map<Path, List<MethodEntry>> byFile = groupStagedByFile(staged);
+        ensureWriteBackSupport();
 
         List<String> errors = new ArrayList<>();
         Set<Path> savedFiles = new LinkedHashSet<>();
         List<AuditWriter.SavedEntry> auditEntries = new ArrayList<>();
 
         for (Map.Entry<Path, List<MethodEntry>> fe : byFile.entrySet()) {
-            Path filePath = fe.getKey();
-            List<MethodEntry> entries = fe.getValue();
-
-            SourcePatcher patcher = writeBackSupport.findPatcher(filePath);
-            if (patcher == null) {
-                errors.add(filePath.getFileName()
-                        + ": source write-back is not supported for this language "
-                        + "(supported: " + writeBackSupport.supportedLanguagesLabel() + ")");
-                continue;
-            }
+            patchSingleFile(fe.getKey(), fe.getValue(), errors, savedFiles, auditEntries);
+        }
 
-            Map<String, List<String>> tagsToApply = new LinkedHashMap<>();
-            Map<String, String> displayNames = new LinkedHashMap<>();
-            for (MethodEntry e : entries) {
-                tagsToApply.put(e.discovered().method(), e.getPendingTags());
-                String dn = e.getPendingDisplayName();
-                if (dn != null) { displayNames.put(e.discovered().method(), dn); }
-            }
+        editorPanel.reloadIfAmong(savedFiles);
+        saveAllButton.setEnabled(model.hasStagedChanges());
 
-            StringWriter sw = new StringWriter();
-            try {
-                patcher.patch(filePath, tagsToApply, displayNames, new PrintWriter(sw));
-                for (MethodEntry e : entries) {
-                    // Snapshot before clearing so AuditWriter sees the applied values
-                    auditEntries.add(new AuditWriter.SavedEntry(
-                            e.discovered().fqcn(),
-                            e.discovered().method(),
-                            e.discovered().loc(),
-                            e.getPendingTags(),
-                            e.getPendingDisplayName(),
-                            e.suggestion()));
-                    e.setAppliedTags(e.getPendingTags());
-                    e.clearStagedPatch();
-                    model.notifyEntryChanged(e);
-                }
-                savedFiles.add(filePath);
-            } catch (IOException ex) {
-                errors.add(filePath.getFileName() + ": " + ex.getMessage());
+        writeAuditEvidence(auditEntries);
+        reportSaveResult(staged, savedFiles, errors);
+    }
+
+    /**
+     * Groups every staged entry by its source-file path. Entries whose
+     * {@code filePath()} is {@code null} (e.g. unsaved buffers) are
+     * silently skipped because they cannot be written to disk.
+     */
+    @SuppressWarnings("PMD.AvoidInstantiatingObjectsInLoops")
+    private static Map<Path, List<MethodEntry>> groupStagedByFile(List<MethodEntry> staged) {
+        Map<Path, List<MethodEntry>> byFile = new LinkedHashMap<>();
+        for (MethodEntry entry : staged) {
+            Path fp = entry.discovered().filePath();
+            if (fp != null) {
+                byFile.computeIfAbsent(fp, k -> new ArrayList<>()).add(entry);
             }
         }
+        return byFile;
+    }
 
-        editorPanel.reloadIfAmong(savedFiles);
-        saveAllButton.setEnabled(model.hasStagedChanges());
+    /**
+     * Lazily creates the shared {@link SourceWriteBackSupport} and hands
+     * it to the tag editor so UI gating and on-disk write-back agree on
+     * which languages are supported.
+     */
+    private void ensureWriteBackSupport() {
+        if (writeBackSupport != null) {
+            return;
+        }
+        TestDiscoveryConfig config = new TestDiscoveryConfig(
+                TagEditorPanel.buildFlatSuffixes(settings),
+                Set.copyOf(settings.getTestAnnotations()),
+                Map.of());
+        writeBackSupport = new SourceWriteBackSupport(config);
+        tagEditorPanel.setWriteBackSupport(writeBackSupport);
+    }
+
+    /**
+     * Writes all staged changes for one source file via its
+     * {@link SourcePatcher}. Records per-file errors in {@code errors},
+     * appends a {@link AuditWriter.SavedEntry} for each persisted method,
+     * and adds the file to {@code savedFiles} on success.
+     */
+    private void patchSingleFile(Path filePath, List<MethodEntry> entries,
+            List<String> errors, Set<Path> savedFiles,
+            List<AuditWriter.SavedEntry> auditEntries) {
+        SourcePatcher patcher = writeBackSupport.findPatcher(filePath);
+        if (patcher == null) {
+            errors.add(filePath.getFileName()
+                    + ": source write-back is not supported for this language "
+                    + "(supported: " + writeBackSupport.supportedLanguagesLabel() + ")");
+            return;
+        }
 
-        // Write audit evidence — warn on failure, do not roll back source patches
-        if (!auditEntries.isEmpty()) {
-            String dir = dirField.getText().trim();
-            if (!dir.isEmpty()) {
-                try {
-                    AuditWriter.write(Path.of(dir), auditEntries, settings.getOperatorName());
-                } catch (IOException ex) {
-                    JOptionPane.showMessageDialog(this,
-                            "Source files were saved but audit records could not be written to .methodatlas/:\n"
-                                    + ex.getMessage(),
-                            "Audit Write Warning", JOptionPane.WARNING_MESSAGE);
-                }
+        Map<String, List<String>> tagsToApply = new LinkedHashMap<>();
+        Map<String, String> displayNames = new LinkedHashMap<>();
+        for (MethodEntry e : entries) {
+            tagsToApply.put(e.discovered().method(), e.getPendingTags());
+            String dn = e.getPendingDisplayName();
+            if (dn != null) {
+                displayNames.put(e.discovered().method(), dn);
             }
         }
 
+        StringWriter sw = new StringWriter();
+        try {
+            patcher.patch(filePath, tagsToApply, displayNames, new PrintWriter(sw));
+            for (MethodEntry e : entries) {
+                // Snapshot before clearing so AuditWriter sees the applied values.
+                auditEntries.add(new AuditWriter.SavedEntry(
+                        e.discovered().fqcn(),
+                        e.discovered().method(),
+                        e.discovered().loc(),
+                        e.getPendingTags(),
+                        e.getPendingDisplayName(),
+                        e.suggestion()));
+                e.setAppliedTags(e.getPendingTags());
+                e.clearStagedPatch();
+                model.notifyEntryChanged(e);
+            }
+            savedFiles.add(filePath);
+        } catch (IOException ex) {
+            errors.add(filePath.getFileName() + ": " + ex.getMessage());
+        }
+    }
+
+    /**
+     * Writes the audit log to the project's {@code .methodatlas/} folder
+     * (rooted at the currently scanned directory). Audit-write failures
+     * are surfaced as a warning dialog but do <strong>not</strong> roll
+     * back the source-file patches that have already been written.
+     */
+    private void writeAuditEvidence(List<AuditWriter.SavedEntry> auditEntries) {
+        if (auditEntries.isEmpty()) {
+            return;
+        }
+        String dir = dirField.getText().trim();
+        if (dir.isEmpty()) {
+            return;
+        }
+        try {
+            AuditWriter.write(Path.of(dir), auditEntries, settings.getOperatorName());
+        } catch (IOException ex) {
+            JOptionPane.showMessageDialog(this,
+                    "Source files were saved but audit records could not be written to .methodatlas/:\n"
+                            + ex.getMessage(),
+                    "Audit Write Warning", JOptionPane.WARNING_MESSAGE);
+        }
+    }
+
+    /**
+     * Sets the status-bar message on a clean save, or shows an error
+     * dialog listing every per-file failure when any error occurred.
+     */
+    private void reportSaveResult(List<MethodEntry> staged,
+            Set<Path> savedFiles, List<String> errors) {
         if (errors.isEmpty()) {
             model.setStatusMessage("Saved " + staged.size() + " method(s) across "
                     + savedFiles.size() + " file(s)");
-        } else {
-            JOptionPane.showMessageDialog(this,
-                    "Some files could not be saved:\n" + String.join("\n", errors),
-                    "Save Error", JOptionPane.ERROR_MESSAGE);
+            return;
         }
+        JOptionPane.showMessageDialog(this,
+                "Some files could not be saved:\n" + String.join("\n", errors),
+                "Save Error", JOptionPane.ERROR_MESSAGE);
     }
 
     // ── Model observer ────────────────────────────────────────────────────

methodatlas-gui/src/main/java/org/egothor/methodatlas/gui/service/SourceWriteBackSupport.java

@@ -37,8 +37,16 @@
  */
 public final class SourceWriteBackSupport {
 
+    /**
+     * Mapping from a patcher's {@code pluginId()} to the human-readable
+     * language label used in {@link #supportedLanguagesLabel()}. Keys must
+     * match the {@code pluginId()} return values of the actual
+     * {@link SourcePatcher} implementations:
+     * {@code JavaSourcePatcher.pluginId() == "java"} and
+     * {@code DotNetSourcePatcher.pluginId() == "dotnet"}.
+     */
     private static final Map<String, String> LANGUAGE_LABELS = Map.of(
-            "jvm",    "Java",
+            "java",   "Java",
             "dotnet", "C#"
     );
 
@@ -51,7 +59,6 @@ public final class SourceWriteBackSupport {
      * @param config runtime configuration forwarded to every patcher; never
      *               {@code null}
      */
-    @SuppressWarnings("PMD.AvoidInstantiatingObjectsInLoops")
     public SourceWriteBackSupport(TestDiscoveryConfig config) {
         List<SourcePatcher> loaded = new ArrayList<>();
         ServiceLoader.load(SourcePatcher.class).forEach(p -> {

methodatlas-gui/src/test/java/org/egothor/methodatlas/gui/service/SourceWriteBackSupportTest.java

@@ -1,5 +1,6 @@
 package org.egothor.methodatlas.gui.service;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertNull;
@@ -98,12 +99,12 @@ void supports_nullPath_returnsFalse() {
     }
 
     @Test
-    void findPatcher_javaFile_returnsJvmPatcher() {
+    void findPatcher_javaFile_returnsJavaPatcher() {
         SourceWriteBackSupport sut = new SourceWriteBackSupport(DEFAULT_CONFIG);
         SourcePatcher patcher = sut.findPatcher(Path.of("FooTest.java"));
-        assertNotNull(patcher, "expected JVM patcher for .java file");
-        assertTrue(patcher.pluginId().equals("jvm"),
-                "expected pluginId() == jvm, got " + patcher.pluginId());
+        assertNotNull(patcher, "expected Java patcher for .java file");
+        assertEquals("java", patcher.pluginId(),
+                "expected pluginId() == java, got " + patcher.pluginId());
     }
 
     @Test