Remove empty customization warning (#5525)

Remove empty customization warning

CHANGELOG.md

@@ -26,6 +26,7 @@ We refer to [GitHub issues](https://github.com/JabRef/jabref/issues) by using `#
 - We fixed an issue where it was no longer possible to connect to LibreOffice. [#5261](https://github.com/JabRef/jabref/issues/5261)
 - The "All entries group" is no longer shown when no library is open.
 - We fixed an exception which occurred when closing JabRef. [#5348](https://github.com/JabRef/jabref/issues/5348)
+- We fixed an issue where JabRef reports incorrectly about customized entry types. [#5332](https://github.com/JabRef/jabref/issues/5332) 
 - We fixed a few problems that prevented JabFox to communicate with JabRef. [#4737](https://github.com/JabRef/jabref/issues/4737) [#4303](https://github.com/JabRef/jabref/issues/4303)
 - We fixed an error where the groups containing an entry loose their highlight color when scrolling. [#5022](https://github.com/JabRef/jabref/issues/5022) 
 - We fixed an error where scrollbars were not shown. [#5374](https://github.com/JabRef/jabref/issues/5374)

src/main/java/org/jabref/JabRefMain.java

@@ -85,13 +85,13 @@ public void start(Stage mainStage) throws Exception {
             Platform.exit();
         }
     }
-  
+
     @Override
     public void stop() {
         Globals.stopBackgroundTasks();
         Globals.shutdownThreadPools();
     }
-  
+
     /**
      * Tests if we are running an acceptable Java and terminates JabRef when we are sure the version is not supported.
      * This test uses the requirements for the Java version as specified in <code>gradle.build</code>. It is possible to
@@ -166,7 +166,7 @@ private static void applyPreferences(JabRefPreferences preferences) {
         // Build list of Import and Export formats
         Globals.IMPORT_FORMAT_READER.resetImportFormats(Globals.prefs.getImportFormatPreferences(),
                                                         Globals.prefs.getXMPPreferences(), Globals.getFileUpdateMonitor());
-        Globals.entryTypesManager.addCustomizedEntryTypes(preferences.loadBibEntryTypes(BibDatabaseMode.BIBTEX),
+        Globals.entryTypesManager.addCustomOrModifiedTypes(preferences.loadBibEntryTypes(BibDatabaseMode.BIBTEX),
                 preferences.loadBibEntryTypes(BibDatabaseMode.BIBLATEX));
         Globals.exportFactory = Globals.prefs.getExporterFactory(Globals.journalAbbreviationLoader);
 

src/main/java/org/jabref/cli/ArgumentProcessor.java

@@ -458,7 +458,7 @@ private void exportFile(List<ParserResult> loaded, String[] data) {
     private void importPreferences() {
         try {
             Globals.prefs.importPreferences(cli.getPreferencesImport());
-            Globals.entryTypesManager.addCustomizedEntryTypes(Globals.prefs.loadBibEntryTypes(BibDatabaseMode.BIBTEX),
+            Globals.entryTypesManager.addCustomOrModifiedTypes(Globals.prefs.loadBibEntryTypes(BibDatabaseMode.BIBTEX),
                     Globals.prefs.loadBibEntryTypes(BibDatabaseMode.BIBLATEX));
             List<TemplateExporter> customExporters = Globals.prefs.getCustomExportFormats(Globals.journalAbbreviationLoader);
             LayoutFormatterPreferences layoutPreferences = Globals.prefs

src/main/java/org/jabref/gui/importer/ImportCustomEntryTypesDialog.fxml

@@ -9,7 +9,7 @@
             xmlns="http://javafx.com/javafx/8.0.171"
             fx:controller="org.jabref.gui.importer.ImportCustomEntryTypesDialog">
    <content>
-      <VBox minHeight="-Infinity" prefHeight="113.0" prefWidth="571.0" spacing="1.0">
+       <VBox spacing="1.0">
          <children>
             <Label text="%Custom entry types found in file" />
             <Label text="%Select all customized types to be stored in local preferences:" />

src/main/java/org/jabref/gui/importer/ImportCustomEntryTypesDialog.java

@@ -45,13 +45,13 @@ public ImportCustomEntryTypesDialog(BibDatabaseMode mode, List<BibEntryType> cus
         });
 
         setTitle(Localization.lang("Custom entry types"));
-
     }
 
     @FXML
     public void initialize() {
         viewModel = new ImportCustomEntryTypesDialogViewModel(mode, customEntryTypes, preferencesService);
 
+        boxDifferentCustomization.visibleProperty().bind(Bindings.isNotEmpty(viewModel.differentCustomizations()));
         boxDifferentCustomization.managedProperty().bind(Bindings.isNotEmpty(viewModel.differentCustomizations()));
         unknownEntryTypesCheckList.setItems(viewModel.newTypes());
         differentCustomizationCheckList.setItems(viewModel.differentCustomizations());

src/main/java/org/jabref/gui/importer/ImportCustomEntryTypesDialogViewModel.java

@@ -26,7 +26,7 @@ public ImportCustomEntryTypesDialogViewModel(BibDatabaseMode mode, List<BibEntry
 
         for (BibEntryType customType : entryTypes) {
             Optional<BibEntryType> currentlyStoredType = Globals.entryTypesManager.enrich(customType.getType(), mode);
-            if (!currentlyStoredType.isPresent()) {
+            if (currentlyStoredType.isEmpty()) {
                 newTypes.add(customType);
             } else {
                 if (!EntryTypeFactory.isEqualNameAndFieldBased(customType, currentlyStoredType.get())) {
@@ -47,11 +47,11 @@ public ObservableList<BibEntryType> differentCustomizations() {
 
     public void importBibEntryTypes(List<BibEntryType> checkedUnknownEntryTypes, List<BibEntryType> checkedDifferentEntryTypes) {
         if (!checkedUnknownEntryTypes.isEmpty()) {
-            checkedUnknownEntryTypes.forEach(type -> Globals.entryTypesManager.addCustomizedEntryType(type, mode));
+            checkedUnknownEntryTypes.forEach(type -> Globals.entryTypesManager.addCustomOrModifiedType(type, mode));
             preferencesService.saveCustomEntryTypes();
         }
         if (!checkedDifferentEntryTypes.isEmpty()) {
-            checkedUnknownEntryTypes.forEach(type -> Globals.entryTypesManager.addCustomizedEntryType(type, mode));
+            checkedUnknownEntryTypes.forEach(type -> Globals.entryTypesManager.addCustomOrModifiedType(type, mode));
             preferencesService.saveCustomEntryTypes();
         }
 

src/main/java/org/jabref/gui/importer/actions/CheckForNewEntryTypesAction.java

@@ -27,15 +27,14 @@ public void performAction(BasePanel panel, ParserResult parserResult) {
 
         ImportCustomEntryTypesDialog importBibEntryTypesDialog = new ImportCustomEntryTypesDialog(mode, getListOfUnknownAndUnequalCustomizations(parserResult));
         importBibEntryTypesDialog.showAndWait();
-
     }
 
     private List<BibEntryType> getListOfUnknownAndUnequalCustomizations(ParserResult parserResult) {
         BibDatabaseMode mode = getBibDatabaseModeFromParserResult(parserResult);
 
         return parserResult.getEntryTypes()
                            .stream()
-                           .filter(type -> Globals.entryTypesManager.isCustomizedType(type, mode))
+                           .filter(type -> Globals.entryTypesManager.isDifferentCustomOrModifiedType(type, mode))
                            .collect(Collectors.toList());
     }
 

src/main/java/org/jabref/migrations/CustomEntryTypePreferenceMigration.java

@@ -32,7 +32,7 @@ static void upgradeStoredBibEntryTypes(BibDatabaseMode defaultBibDatabaseMode) {
         int number = 0;
         Optional<BibEntryType> type;
         while ((type = getBibEntryType(number)).isPresent()) {
-            Globals.entryTypesManager.addCustomizedEntryType(type.get(), defaultBibDatabaseMode);
+            Globals.entryTypesManager.addCustomOrModifiedType(type.get(), defaultBibDatabaseMode);
             storedOldTypes.add(type.get());
             number++;
         }

src/main/java/org/jabref/model/entry/BibEntryTypesManager.java

@@ -71,16 +71,16 @@ public static String serialize(BibEntryType entryType) {
     /**
      * Returns true if the type is a custom type, or if it is a standard type which has customized fields
      */
-    public boolean isCustomizedType(BibEntryType type, BibDatabaseMode mode) {
-        return mode == BibDatabaseMode.BIBLATEX ? BIBLATEX.isCustomizedType(type) : BIBTEX.isCustomizedType(type);
+    public boolean isCustomOrModifiedType(BibEntryType type, BibDatabaseMode mode) {
+        return mode == BibDatabaseMode.BIBLATEX ? BIBLATEX.isCustomOrModifiedType(type) : BIBTEX.isCustomOrModifiedType(type);
     }
 
     /**
      * Sets the given custom entry types for BibTeX and biblatex mode
      */
-    public void addCustomizedEntryTypes(List<BibEntryType> customBibtexEntryTypes, List<BibEntryType> customBiblatexEntryTypes) {
-        customBibtexEntryTypes.forEach(type -> addCustomizedEntryType(type, BibDatabaseMode.BIBTEX));
-        customBiblatexEntryTypes.forEach(type -> addCustomizedEntryType(type, BibDatabaseMode.BIBLATEX));
+    public void addCustomOrModifiedTypes(List<BibEntryType> customizedBibtexEntryTypes, List<BibEntryType> customizedBiblatexEntryTypes) {
+        customizedBibtexEntryTypes.forEach(type -> addCustomOrModifiedType(type, BibDatabaseMode.BIBTEX));
+        customizedBiblatexEntryTypes.forEach(type -> addCustomOrModifiedType(type, BibDatabaseMode.BIBLATEX));
     }
 
     /**
@@ -104,11 +104,11 @@ public List<BibEntryType> getAllCustomTypes(BibDatabaseMode mode) {
         }
     }
 
-    public void addCustomizedEntryType(BibEntryType entryType, BibDatabaseMode mode) {
+    public void addCustomOrModifiedType(BibEntryType entryType, BibDatabaseMode mode) {
         if (BibDatabaseMode.BIBLATEX == mode) {
-            BIBLATEX.addCustomizedType(entryType);
+            BIBLATEX.addCustomOrModifiedType(entryType);
         } else if (BibDatabaseMode.BIBTEX == mode) {
-            BIBTEX.addCustomizedType(entryType);
+            BIBTEX.addCustomOrModifiedType(entryType);
         }
     }
 
@@ -127,11 +127,22 @@ public Optional<BibEntryType> enrich(EntryType type, BibDatabaseMode mode) {
         return mode == BibDatabaseMode.BIBLATEX ? BIBLATEX.enrich(type) : BIBTEX.enrich(type);
     }
 
+    public boolean isDifferentCustomOrModifiedType(BibEntryType type, BibDatabaseMode mode) {
+        Optional<BibEntryType> currentlyStoredType = enrich(type.getType(), mode);
+        if (currentlyStoredType.isEmpty()) {
+            // new customization
+            return true;
+        } else {
+            // different customization
+            return !EntryTypeFactory.isEqualNameAndFieldBased(type, currentlyStoredType.get());
+        }
+    }
+
     /**
      * This class is used to specify entry types for either BIBTEX and BIBLATEX.
      */
     static class InternalEntryTypes {
-        private final SortedSet<BibEntryType> customizedTypes = new TreeSet<>();
+        private final SortedSet<BibEntryType> customOrModifiedType = new TreeSet<>();
         private final SortedSet<BibEntryType> standardTypes;
 
         public InternalEntryTypes(List<BibEntryType> standardTypes) {
@@ -143,9 +154,9 @@ public InternalEntryTypes(List<BibEntryType> standardTypes) {
          * or null if it does not exist.
          */
         public Optional<BibEntryType> enrich(EntryType type) {
-            Optional<BibEntryType> enrichedType = customizedTypes.stream()
-                                                                 .filter(customizedType -> customizedType.getType().equals(type))
-                                                                 .findFirst();
+            Optional<BibEntryType> enrichedType = customOrModifiedType.stream()
+                                                                      .filter(customizedType -> customizedType.getType().equals(type))
+                                                                      .findFirst();
             if (enrichedType.isPresent()) {
                 return enrichedType;
             } else {
@@ -155,19 +166,20 @@ public Optional<BibEntryType> enrich(EntryType type) {
             }
         }
 
-        private void addCustomizedType(BibEntryType type) {
-            customizedTypes.remove(type);
-            customizedTypes.add(type);
+        private void addCustomOrModifiedType(BibEntryType type) {
+            customOrModifiedType.remove(type);
+            customOrModifiedType.add(type);
         }
 
         public SortedSet<BibEntryType> getAllTypes() {
-            SortedSet<BibEntryType> allTypes = new TreeSet<>(customizedTypes);
+            SortedSet<BibEntryType> allTypes = new TreeSet<>(customOrModifiedType);
             allTypes.addAll(standardTypes);
             return allTypes;
         }
 
-        public boolean isCustomizedType(BibEntryType entryType) {
-            return customizedTypes.stream().anyMatch(customizedType -> customizedType.getType().equals(entryType.getType()));
+        public boolean isCustomOrModifiedType(BibEntryType entryType) {
+            return customOrModifiedType.stream()
+                                       .anyMatch(customizedType -> customizedType.getType().equals(entryType.getType()));
         }
     }
 }

src/test/java/org/jabref/logic/exporter/BibtexDatabaseWriterTest.java

@@ -273,7 +273,7 @@ void writeEntryWithCustomizedTypeAlsoWritesTypeDeclaration() throws Exception {
                         new OrFields(StandardField.TITLE),
                         new OrFields(StandardField.AUTHOR),
                         new OrFields(StandardField.DATE)));
-        entryTypesManager.addCustomizedEntryType(customizedBibType, BibDatabaseMode.BIBTEX);
+        entryTypesManager.addCustomOrModifiedType(customizedBibType, BibDatabaseMode.BIBTEX);
         BibEntry entry = new BibEntry(customizedType);
         database.insertEntry(entry);
 

src/test/java/org/jabref/model/BibEntryTypeFactoryTest.java → src/test/java/org/jabref/model/entry/BibEntryTypesManagerTest.java

@@ -1,13 +1,11 @@
-package org.jabref.model;
+package org.jabref.model.entry;
 
 import java.util.Collections;
 import java.util.Optional;
 import java.util.TreeSet;
 import java.util.stream.Stream;
 
 import org.jabref.model.database.BibDatabaseMode;
-import org.jabref.model.entry.BibEntryType;
-import org.jabref.model.entry.BibEntryTypesManager;
 import org.jabref.model.entry.field.BibField;
 import org.jabref.model.entry.field.FieldPriority;
 import org.jabref.model.entry.field.StandardField;
@@ -25,8 +23,9 @@
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
-class BibEntryTypeFactoryTest {
+class BibEntryTypesManagerTest {
 
     private static final EntryType UNKNOWN_TYPE = new UnknownEntryType("unknownType");
     private static final EntryType CUSTOM_TYPE = new UnknownEntryType("customType");
@@ -51,6 +50,13 @@ void setUp() {
         entryTypesManager = new BibEntryTypesManager();
     }
 
+    @ParameterizedTest
+    @MethodSource("mode")
+    void isCustomOrModifiedTypeReturnsTrueForModifiedStandardEntryType(BibDatabaseMode mode) {
+        entryTypesManager.addCustomOrModifiedType(overwrittenStandardType, mode);
+        assertTrue(entryTypesManager.isCustomOrModifiedType(overwrittenStandardType, mode));
+    }
+
     @Test
     void allTypesBibtexAreCorrect() {
         TreeSet<BibEntryType> defaultTypes = new TreeSet<>(BibtexEntryTypeDefinitions.ALL);
@@ -75,53 +81,53 @@ void unknownTypeIsNotFound(BibDatabaseMode mode) {
     @ParameterizedTest
     @MethodSource("mode")
     void newCustomEntryTypeFound(BibDatabaseMode mode) {
-        entryTypesManager.addCustomizedEntryType(newCustomType, mode);
+        entryTypesManager.addCustomOrModifiedType(newCustomType, mode);
         assertEquals(Optional.of(newCustomType), entryTypesManager.enrich(CUSTOM_TYPE, mode));
     }
 
     @ParameterizedTest
     @MethodSource("mode")
     void registeredBibEntryTypeIsContainedInListOfCustomizedEntryTypes(BibDatabaseMode mode) {
-        entryTypesManager.addCustomizedEntryType(newCustomType, mode);
+        entryTypesManager.addCustomOrModifiedType(newCustomType, mode);
         assertEquals(Collections.singletonList(newCustomType), entryTypesManager.getAllCustomTypes(mode));
     }
 
     @Test
     void registerBibEntryTypeDoesNotAffectOtherMode() {
-        entryTypesManager.addCustomizedEntryType(newCustomType, BibDatabaseMode.BIBTEX);
+        entryTypesManager.addCustomOrModifiedType(newCustomType, BibDatabaseMode.BIBTEX);
         assertFalse(entryTypesManager.getAllTypes(BibDatabaseMode.BIBLATEX).contains(newCustomType));
     }
 
     @ParameterizedTest
     @MethodSource("mode")
     void overwriteBibEntryTypeFields(BibDatabaseMode mode) {
-        entryTypesManager.addCustomizedEntryType(newCustomType, mode);
+        entryTypesManager.addCustomOrModifiedType(newCustomType, mode);
         BibEntryType newBibEntryTypeTitle = new BibEntryType(
                 CUSTOM_TYPE,
                 Collections.singleton(new BibField(StandardField.TITLE, FieldPriority.IMPORTANT)),
                 Collections.emptySet());
-        entryTypesManager.addCustomizedEntryType(newBibEntryTypeTitle, mode);
+        entryTypesManager.addCustomOrModifiedType(newBibEntryTypeTitle, mode);
         assertEquals(Optional.of(newBibEntryTypeTitle), entryTypesManager.enrich(CUSTOM_TYPE, mode));
     }
 
     @ParameterizedTest
     @MethodSource("mode")
     void overwriteStandardTypeRequiredFields(BibDatabaseMode mode) {
-        entryTypesManager.addCustomizedEntryType(overwrittenStandardType, mode);
+        entryTypesManager.addCustomOrModifiedType(overwrittenStandardType, mode);
         assertEquals(Optional.of(overwrittenStandardType), entryTypesManager.enrich(overwrittenStandardType.getType(), mode));
     }
 
     @ParameterizedTest
     @MethodSource("mode")
     void registeredCustomizedStandardEntryTypeIsNotContainedInListOfCustomEntryTypes(BibDatabaseMode mode) {
-        entryTypesManager.addCustomizedEntryType(overwrittenStandardType, mode);
+        entryTypesManager.addCustomOrModifiedType(overwrittenStandardType, mode);
         assertEquals(Collections.emptyList(), entryTypesManager.getAllCustomTypes(mode));
     }
 
     @ParameterizedTest
     @MethodSource("mode")
     void standardTypeIsStillAccessibleIfOverwritten(BibDatabaseMode mode) {
-        entryTypesManager.addCustomizedEntryType(overwrittenStandardType, mode);
+        entryTypesManager.addCustomOrModifiedType(overwrittenStandardType, mode);
         assertFalse(entryTypesManager.isCustomType(overwrittenStandardType.getType(), mode));
     }
 }