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,9 @@
 package org.jabref.gui.journals;
 
+import java.util.ArrayList;
 import java.util.List;
+import java.util.Map;
+import java.util.Optional;
 import java.util.function.Supplier;
 
 import javax.swing.undo.UndoManager;
@@ -12,13 +15,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,9 +42,12 @@ 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;
+
+    private JournalAbbreviationPreferences lastUsedPreferences;
+    private JournalAbbreviationRepository cachedRepository;
 
     private AbbreviationType abbreviationType;
 
@@ -47,15 +56,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;
 
@@ -75,8 +82,18 @@ public AbbreviateAction(StandardActions action,
         this.executable.bind(ActionHelper.needsEntriesSelected(stateManager));
     }
 
+    /**
+     * Executes the abbreviation or unabbreviation action on selected entries.
+     * For unabbreviation, checks if any journal source is enabled first.
+     * For abbreviation, handles different abbreviation types (default, dotless, shortest unique, LTWA).
+     */
     @Override
     public void execute() {
+        if (action == StandardActions.UNABBREVIATE && !journalAbbreviationPreferences.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 +115,8 @@ public void execute() {
     }
 
     private String abbreviate(BibDatabaseContext databaseContext, List<BibEntry> entries) {
+        abbreviationRepository = getRepository();
+
         UndoableAbbreviator undoableAbbreviator = new UndoableAbbreviator(
                 abbreviationRepository,
                 abbreviationType,
@@ -119,13 +138,46 @@ 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 = getRepository();
+
+        for (BibEntry entry : entries) {
+            boolean includeEntry = true;
+
+            for (Field journalField : FieldFactory.getJournalNameFields()) {
+                if (!entry.hasField(journalField)) {
+                    continue;
+                }
+
+                String text = entry.getFieldLatexFree(journalField).orElse("");
+
+                if (freshRepository.isAbbreviatedName(text)) {
+                    Optional<Abbreviation> abbreviation = freshRepository.getForUnabbreviation(text);
+
+                    if (abbreviation.isEmpty()) {
+                        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 +187,80 @@ private String unabbreviate(BibDatabaseContext databaseContext, List<BibEntry> e
         tabSupplier.get().markBaseChanged();
         return Localization.lang("Unabbreviated %0 journal names.", String.valueOf(count));
     }
+
+    /**
+     * Gets a repository instance, using cached version if preferences haven't changed.
+     * This provides efficient repository creation without using static/singleton patterns.
+     * 
+     *
+     * @return A repository configured with current preferences
+     */
+    private JournalAbbreviationRepository getRepository() {
+        if (cachedRepository != null && !preferencesChanged()) {
+            return cachedRepository;
+        }
+
+        cachedRepository = JournalAbbreviationLoader.loadRepository(journalAbbreviationPreferences);
+        lastUsedPreferences = clonePreferences();
+        return cachedRepository;
+    }
+
+    /**
+     * Checks if preferences have changed since last repository creation
+     * 
+     *
+     * @return true if preferences have changed, false otherwise
+     */
+    private boolean preferencesChanged() {
+        if (lastUsedPreferences == null) {
+            return true;
+        }
+
+        if (lastUsedPreferences.shouldUseFJournalField() != journalAbbreviationPreferences.shouldUseFJournalField()) {
+            return true;
+        }
+
+        List<String> oldLists = lastUsedPreferences.getExternalJournalLists();
+        List<String> newLists = journalAbbreviationPreferences.getExternalJournalLists();
+
+        if (oldLists.size() != newLists.size()) {
+            return true;
+        }
+
+        for (int i = 0; i < oldLists.size(); i++) {
+            if (!oldLists.get(i).equals(newLists.get(i))) {
+                return true;
+            }
+        }
+
+        Map<String, Boolean> oldEnabled = lastUsedPreferences.getEnabledExternalLists();
+        Map<String, Boolean> newEnabled = journalAbbreviationPreferences.getEnabledExternalLists();
+
+        if (oldEnabled.size() != newEnabled.size()) {
+            return true;
+        }
+
+        for (Map.Entry<String, Boolean> entry : newEnabled.entrySet()) {
+            Boolean oldValue = oldEnabled.get(entry.getKey());
+            if (!java.util.Objects.equals(oldValue, entry.getValue())) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Creates a clone of the current preferences for comparison
+     * 
+     *
+     * @return A new preferences instance with the same settings
+     */
+    private JournalAbbreviationPreferences clonePreferences() {
+        return new JournalAbbreviationPreferences(
+                journalAbbreviationPreferences.getExternalJournalLists(),
+                journalAbbreviationPreferences.shouldUseFJournalField(),
+                journalAbbreviationPreferences.getEnabledExternalLists()
+        );
+    }
 }

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

@@ -27,6 +27,8 @@ public UndoableAbbreviator(JournalAbbreviationRepository journalAbbreviationRepo
 
     /**
      * Abbreviate the journal name of the given entry.
+     * This method respects the enabled/disabled state of journal abbreviation sources.
+     * If a journal name comes from a disabled source, it will not be abbreviated.
      *
      * @param database  The database the entry belongs to, or null if no database.
      * @param entry     The entry to be treated.
@@ -42,7 +44,7 @@ public boolean abbreviate(BibDatabase database, BibEntry entry, Field fieldName,
         String origText = entry.getField(fieldName).get();
         String text = database != null ? database.resolveForStrings(origText) : origText;
 
-        Optional<Abbreviation> foundAbbreviation = journalAbbreviationRepository.get(text);
+        Optional<Abbreviation> foundAbbreviation = journalAbbreviationRepository.getForAbbreviation(text);
 
         if (foundAbbreviation.isEmpty() && abbreviationType != AbbreviationType.LTWA) {
             return false; // Unknown, cannot abbreviate anything.

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.getForUnabbreviation(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));