Add toggle functionality for journal abbreviation lists

CHANGELOG.md

@@ -36,6 +36,7 @@ Note that this project **does not** adhere to [Semantic Versioning](https://semv
 - We added a "LTWA" abbreviation feature in the "Quality > Abbreviate journal names > LTWA" menu [#12273](https://github.com/JabRef/jabref/issues/12273/)
 - We added path validation to file directories in library properties dialog. [#11840](https://github.com/JabRef/jabref/issues/11840)
 - We now support usage of custom CSL styles in the Open/LibreOffice integration. [#12337](https://github.com/JabRef/jabref/issues/12337)
+- We added ability to toggle journal abbreviation lists (including built-in and external CSV files) on/off in preferences. [#12468](https://github.com/JabRef/jabref/pull/12468)
 - We added support for citation-only CSL styles which don't specify bibliography formatting. [#12996](https://github.com/JabRef/jabref/pull/12996)
 
 ### Changed

src/main/java/org/jabref/gui/frame/MainMenu.java

@@ -267,12 +267,12 @@ private void createMenu() {
                 new SeparatorMenuItem(),
 
                 factory.createSubMenu(StandardActions.ABBREVIATE,
-                        factory.createMenuItem(StandardActions.ABBREVIATE_DEFAULT, new AbbreviateAction(StandardActions.ABBREVIATE_DEFAULT, frame::getCurrentLibraryTab, dialogService, stateManager, preferences.getJournalAbbreviationPreferences(), abbreviationRepository, taskExecutor, undoManager)),
-                        factory.createMenuItem(StandardActions.ABBREVIATE_DOTLESS, new AbbreviateAction(StandardActions.ABBREVIATE_DOTLESS, frame::getCurrentLibraryTab, dialogService, stateManager, preferences.getJournalAbbreviationPreferences(), abbreviationRepository, taskExecutor, undoManager)),
-                        factory.createMenuItem(StandardActions.ABBREVIATE_SHORTEST_UNIQUE, new AbbreviateAction(StandardActions.ABBREVIATE_SHORTEST_UNIQUE, frame::getCurrentLibraryTab, dialogService, stateManager, preferences.getJournalAbbreviationPreferences(), abbreviationRepository, taskExecutor, undoManager)),
-                        factory.createMenuItem(StandardActions.ABBREVIATE_LTWA, new AbbreviateAction(StandardActions.ABBREVIATE_LTWA, frame::getCurrentLibraryTab, dialogService, stateManager, preferences.getJournalAbbreviationPreferences(), abbreviationRepository, taskExecutor, undoManager))),
+                        factory.createMenuItem(StandardActions.ABBREVIATE_DEFAULT, new AbbreviateAction(StandardActions.ABBREVIATE_DEFAULT, frame::getCurrentLibraryTab, dialogService, stateManager, preferences.getJournalAbbreviationPreferences(), taskExecutor, undoManager)),
+                        factory.createMenuItem(StandardActions.ABBREVIATE_DOTLESS, new AbbreviateAction(StandardActions.ABBREVIATE_DOTLESS, frame::getCurrentLibraryTab, dialogService, stateManager, preferences.getJournalAbbreviationPreferences(), taskExecutor, undoManager)),
+                        factory.createMenuItem(StandardActions.ABBREVIATE_SHORTEST_UNIQUE, new AbbreviateAction(StandardActions.ABBREVIATE_SHORTEST_UNIQUE, frame::getCurrentLibraryTab, dialogService, stateManager, preferences.getJournalAbbreviationPreferences(), taskExecutor, undoManager)),
+                        factory.createMenuItem(StandardActions.ABBREVIATE_LTWA, new AbbreviateAction(StandardActions.ABBREVIATE_LTWA, frame::getCurrentLibraryTab, dialogService, stateManager, preferences.getJournalAbbreviationPreferences(), taskExecutor, undoManager))),
 
-                factory.createMenuItem(StandardActions.UNABBREVIATE, new AbbreviateAction(StandardActions.UNABBREVIATE, frame::getCurrentLibraryTab, dialogService, stateManager, preferences.getJournalAbbreviationPreferences(), abbreviationRepository, taskExecutor, undoManager))
+                factory.createMenuItem(StandardActions.UNABBREVIATE, new AbbreviateAction(StandardActions.UNABBREVIATE, frame::getCurrentLibraryTab, dialogService, stateManager, preferences.getJournalAbbreviationPreferences(), taskExecutor, undoManager))
         );
 
         Menu lookupIdentifiers = factory.createSubMenu(StandardActions.LOOKUP_DOC_IDENTIFIER);

src/main/java/org/jabref/gui/journals/AbbreviateAction.java

@@ -1,6 +1,10 @@
 package org.jabref.gui.journals;
 
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 import java.util.function.Supplier;
 
 import javax.swing.undo.UndoManager;
@@ -12,13 +16,16 @@
 import org.jabref.gui.actions.SimpleCommand;
 import org.jabref.gui.actions.StandardActions;
 import org.jabref.gui.undo.NamedCompound;
+import org.jabref.logic.journals.Abbreviation;
+import org.jabref.logic.journals.JournalAbbreviationLoader;
 import org.jabref.logic.journals.JournalAbbreviationPreferences;
 import org.jabref.logic.journals.JournalAbbreviationRepository;
 import org.jabref.logic.l10n.Localization;
 import org.jabref.logic.util.BackgroundTask;
 import org.jabref.logic.util.TaskExecutor;
 import org.jabref.model.database.BibDatabaseContext;
 import org.jabref.model.entry.BibEntry;
+import org.jabref.model.entry.field.Field;
 import org.jabref.model.entry.field.FieldFactory;
 
 import org.slf4j.Logger;
@@ -36,7 +43,7 @@ public class AbbreviateAction extends SimpleCommand {
     private final DialogService dialogService;
     private final StateManager stateManager;
     private final JournalAbbreviationPreferences journalAbbreviationPreferences;
-    private final JournalAbbreviationRepository abbreviationRepository;
+    private JournalAbbreviationRepository abbreviationRepository;
     private final TaskExecutor taskExecutor;
     private final UndoManager undoManager;
 
@@ -47,15 +54,13 @@ public AbbreviateAction(StandardActions action,
                             DialogService dialogService,
                             StateManager stateManager,
                             JournalAbbreviationPreferences abbreviationPreferences,
-                            JournalAbbreviationRepository abbreviationRepository,
                             TaskExecutor taskExecutor,
                             UndoManager undoManager) {
         this.action = action;
         this.tabSupplier = tabSupplier;
         this.dialogService = dialogService;
         this.stateManager = stateManager;
         this.journalAbbreviationPreferences = abbreviationPreferences;
-        this.abbreviationRepository = abbreviationRepository;
         this.taskExecutor = taskExecutor;
         this.undoManager = undoManager;
 
@@ -77,6 +82,11 @@ public AbbreviateAction(StandardActions action,
 
     @Override
     public void execute() {
+        if (action == StandardActions.UNABBREVIATE && !areAnyJournalSourcesEnabled()) {
+            dialogService.notify(Localization.lang("Cannot unabbreviate: all journal lists are disabled."));
+            return;
+        }
+
         if ((action == StandardActions.ABBREVIATE_DEFAULT)
                 || (action == StandardActions.ABBREVIATE_DOTLESS)
                 || (action == StandardActions.ABBREVIATE_SHORTEST_UNIQUE)
@@ -98,6 +108,9 @@ public void execute() {
     }
 
     private String abbreviate(BibDatabaseContext databaseContext, List<BibEntry> entries) {
+        // Reload repository to ensure latest preferences are used
+        abbreviationRepository = JournalAbbreviationLoader.loadRepository(journalAbbreviationPreferences);
+
         UndoableAbbreviator undoableAbbreviator = new UndoableAbbreviator(
                 abbreviationRepository,
                 abbreviationType,
@@ -119,13 +132,77 @@ private String abbreviate(BibDatabaseContext databaseContext, List<BibEntry> ent
         return Localization.lang("Abbreviated %0 journal names.", String.valueOf(count));
     }
 
+    /**
+     * Unabbreviate journal names in entries, respecting the enabled/disabled state of sources.
+     * Only unabbreviates entries from enabled sources.
+     */
     private String unabbreviate(BibDatabaseContext databaseContext, List<BibEntry> entries) {
-        UndoableUnabbreviator undoableAbbreviator = new UndoableUnabbreviator(abbreviationRepository);
-
+        List<BibEntry> filteredEntries = new ArrayList<>();
+
+        JournalAbbreviationRepository freshRepository = JournalAbbreviationLoader.loadRepository(journalAbbreviationPreferences);
+
+        Map<String, Boolean> sourceEnabledStates = new HashMap<>();
+        String builtInId = JournalAbbreviationRepository.BUILTIN_LIST_ID;
+        sourceEnabledStates.put(builtInId, journalAbbreviationPreferences.isSourceEnabled(builtInId));
+
+        for (String listPath : journalAbbreviationPreferences.getExternalJournalLists()) {
+            if (listPath != null && !listPath.isBlank()) {
+                String fileName = Path.of(listPath).getFileName().toString();
+                sourceEnabledStates.put(fileName, journalAbbreviationPreferences.isSourceEnabled(fileName));
+            }
+        }
+
+        var allAbbreviationsWithSources = freshRepository.getAllAbbreviationsWithSources();
+        Map<String, List<JournalAbbreviationRepository.AbbreviationWithSource>> textToSourceMap = new HashMap<>();
+
+        for (var abbrWithSource : allAbbreviationsWithSources) {
+            Abbreviation abbr = abbrWithSource.getAbbreviation();
+            addToMap(textToSourceMap, abbr.getName(), abbrWithSource);
+            addToMap(textToSourceMap, abbr.getAbbreviation(), abbrWithSource);
+            addToMap(textToSourceMap, abbr.getDotlessAbbreviation(), abbrWithSource);
+            addToMap(textToSourceMap, abbr.getShortestUniqueAbbreviation(), abbrWithSource);
+        }
+
+        for (BibEntry entry : entries) {
+            boolean includeEntry = true;
+
+            for (Field journalField : FieldFactory.getJournalNameFields()) {
+                if (!entry.hasField(journalField)) {
+                    continue;
+                }
+
+                String text = entry.getFieldLatexFree(journalField).orElse("");
+                List<JournalAbbreviationRepository.AbbreviationWithSource> possibleSources = 
+                    textToSourceMap.getOrDefault(text, List.of());
+
+                if (!possibleSources.isEmpty()) {
+                    boolean allSourcesDisabled = true;
+                    for (var abbrWithSource : possibleSources) {
+                        String source = abbrWithSource.getSource();
+                        if (sourceEnabledStates.getOrDefault(source, true)) {
+                            allSourcesDisabled = false;
+                            break;
+                        }
+                    }
+
+                    if (allSourcesDisabled) {
+                        includeEntry = false;
+                        break;
+                    }
+                }
+            }
+
+            if (includeEntry) {
+                filteredEntries.add(entry);
+            }
+        }
+
+        UndoableUnabbreviator undoableAbbreviator = new UndoableUnabbreviator(freshRepository);
         NamedCompound ce = new NamedCompound(Localization.lang("Unabbreviate journal names"));
-        int count = entries.stream().mapToInt(entry ->
+        int count = filteredEntries.stream().mapToInt(entry ->
                 (int) FieldFactory.getJournalNameFields().stream().filter(journalField ->
                         undoableAbbreviator.unabbreviate(databaseContext.getDatabase(), entry, journalField, ce)).count()).sum();
+
         if (count == 0) {
             return Localization.lang("No journal names could be unabbreviated.");
         }
@@ -135,4 +212,46 @@ private String unabbreviate(BibDatabaseContext databaseContext, List<BibEntry> e
         tabSupplier.get().markBaseChanged();
         return Localization.lang("Unabbreviated %0 journal names.", String.valueOf(count));
     }
+
+    /**
+     * Helper method to add an abbreviation to the text-to-source map
+     *
+     * @param map The map to add to
+     * @param text The text to use as key
+     * @param abbrWithSource The abbreviation with source to add
+     */
+    private void addToMap(Map<String, List<JournalAbbreviationRepository.AbbreviationWithSource>> map, 
+                          String text, 
+                          JournalAbbreviationRepository.AbbreviationWithSource abbrWithSource) {
+        if (text == null || text.isBlank()) {
+            return;
+        }
+
+        map.computeIfAbsent(text, k -> new ArrayList<>()).add(abbrWithSource);
+    }
+
+    /**
+     * Checks if any journal abbreviation source is enabled in the preferences.
+     * This includes both the built-in list and any external journal lists.
+     *
+     * @return true if at least one source is enabled, false if all sources are disabled
+     */
+    private boolean areAnyJournalSourcesEnabled() {
+        boolean anySourceEnabled = journalAbbreviationPreferences.isSourceEnabled(JournalAbbreviationRepository.BUILTIN_LIST_ID);
+
+        if (!anySourceEnabled) {
+            for (String listPath : journalAbbreviationPreferences.getExternalJournalLists()) {
+                if (listPath != null && !listPath.isBlank()) {
+                    // Just check the filename since that's what's used as the source key
+                    String fileName = Path.of(listPath).getFileName().toString();
+                    if (journalAbbreviationPreferences.isSourceEnabled(fileName)) {
+                        anySourceEnabled = true;
+                        break;
+                    }
+                }
+            }
+        }
+
+        return anySourceEnabled;
+    }
 }

src/main/java/org/jabref/gui/journals/UndoableUnabbreviator.java

@@ -21,6 +21,8 @@ public UndoableUnabbreviator(JournalAbbreviationRepository journalAbbreviationRe
 
     /**
      * Unabbreviate the journal name of the given entry.
+     * This method respects the enabled/disabled state of journal abbreviation sources.
+     * If an abbreviation comes from a disabled source, it will not be unabbreviated.
      *
      * @param entry The entry to be treated.
      * @param field The field
@@ -41,16 +43,17 @@ public boolean unabbreviate(BibDatabase database, BibEntry entry, Field field, C
         if (database != null) {
             text = database.resolveForStrings(text);
         }
-
-        if (!journalAbbreviationRepository.isKnownName(text)) {
-            return false; // Cannot do anything if it is not known.
-        }
-
+
         if (!journalAbbreviationRepository.isAbbreviatedName(text)) {
             return false; // Cannot unabbreviate unabbreviated name.
         }
+
+        var abbreviationOpt = journalAbbreviationRepository.get(text);
+        if (abbreviationOpt.isEmpty()) {
+            return false;
+        }
 
-        Abbreviation abbreviation = journalAbbreviationRepository.get(text).get();
+        Abbreviation abbreviation = abbreviationOpt.get();
         String newText = abbreviation.getName();
         entry.setField(field, newText);
         ce.addEdit(new UndoableFieldChange(entry, field, origText, newText));