From 097227f0dd1e48dba8f6135a634fe02bea2defd3 Mon Sep 17 00:00:00 2001 From: Carl Christian Snethlage Date: Thu, 16 Apr 2020 14:08:35 +0200 Subject: [PATCH 1/5] Changed variable names, added migration and tests --- .../migrations/PreferencesMigrations.java | 21 ++++++++ .../jabref/preferences/JabRefPreferences.java | 12 +++-- .../migrations/PreferencesMigrationsTest.java | 49 +++++++++++++++++++ 3 files changed, 78 insertions(+), 4 deletions(-) diff --git a/src/main/java/org/jabref/migrations/PreferencesMigrations.java b/src/main/java/org/jabref/migrations/PreferencesMigrations.java index e12dacfa316..208dab88e55 100644 --- a/src/main/java/org/jabref/migrations/PreferencesMigrations.java +++ b/src/main/java/org/jabref/migrations/PreferencesMigrations.java @@ -48,6 +48,10 @@ public static void runMigrations() { upgradeKeyBindingsToJavaFX(Globals.prefs); addCrossRefRelatedFieldsForAutoComplete(Globals.prefs); upgradePreviewStyleFromReviewToComment(Globals.prefs); + // changeColumnVariableNamesFor51 needs to be run before upgradeColumnPre50Preferences to ensure + // backwardcompatibility, as it copies the old values to new variable names and keeps th old sored with the old + // variable names. However, the variables from 5.0 need to be copied to the new variable name too. + changeColumnVariableNamesFor51(Globals.prefs); upgradeColumnPreferences(Globals.prefs); upgradePreviewStyleAllowMarkdown(Globals.prefs); } @@ -308,6 +312,18 @@ static void upgradePreviewStyleAllowMarkdown(JabRefPreferences prefs) { prefs.setPreviewStyle(migratedStyle); } + static void changeColumnVariableNamesFor51(JabRefPreferences preferences) { + // The variable names have to be hardcoded, because they have changed between 5.0 and 5.1 + List oldColumnNames = preferences.getStringList("columnNames"); + List columnNames = preferences.getStringList(JabRefPreferences.COLUMN_NAMES); + if (!oldColumnNames.isEmpty() && columnNames.isEmpty()) { + preferences.putStringList(JabRefPreferences.COLUMN_NAMES, preferences.getStringList("columnNames")); + preferences.putStringList(JabRefPreferences.COLUMN_WIDTHS, preferences.getStringList("columnWidths")); + preferences.putStringList(JabRefPreferences.COLUMN_SORT_TYPES, preferences.getStringList("mainTableColumnSortTypes")); + preferences.putStringList(JabRefPreferences.COLUMN_SORT_ORDER, preferences.getStringList("mainTableColumnSortOrder")); + } + } + /** * The former preferences default of columns was a simple list of strings ("author;title;year;..."). Since 5.0 * the preferences store the type of the column too, so that the formerly hardwired columns like the graphic groups @@ -316,8 +332,13 @@ static void upgradePreviewStyleAllowMarkdown(JabRefPreferences prefs) { * * Simple strings are by default parsed as a FieldColumn, so there is nothing to do there, but the formerly hard * wired columns need to be added. + * + * In 5.1 variable names in JabRefPreferences have changed to offer backward compatibility with pre 5.0 releases + * Pre 5.1: columnNames, columnWidths, columnSortTypes, columnSortOrder + * Since 5.1: mainTableColumnNames, mainTableColumnWidths, mainTableColumnSortTypes, mainTableColumnSortOrder */ static void upgradeColumnPreferences(JabRefPreferences preferences) { + // Variable names have to be hardcoded here, since they are already changed in JabRefPreferences List columnNames = preferences.getStringList(JabRefPreferences.COLUMN_NAMES); List columnWidths = preferences.getStringList(JabRefPreferences.COLUMN_WIDTHS) .stream() diff --git a/src/main/java/org/jabref/preferences/JabRefPreferences.java b/src/main/java/org/jabref/preferences/JabRefPreferences.java index 9af9a2a81c1..b41ce31f7bd 100644 --- a/src/main/java/org/jabref/preferences/JabRefPreferences.java +++ b/src/main/java/org/jabref/preferences/JabRefPreferences.java @@ -147,10 +147,14 @@ public class JabRefPreferences implements PreferencesService { public static final String EXPORT_TERTIARY_SORT_FIELD = "exportTerSort"; public static final String EXPORT_TERTIARY_SORT_DESCENDING = "exportTerDescending"; public static final String NEWLINE = "newline"; - public static final String COLUMN_NAMES = "columnNames"; - public static final String COLUMN_WIDTHS = "columnWidths"; - public static final String COLUMN_SORT_TYPES = "columnSortTypes"; - public static final String COLUMN_SORT_ORDER = "columnSortOrder"; + + // Variable names have changed to ensure backward compatibility with pre 5.0 releases of JabRef + // Pre 5.1: columnNames, columnWidths, columnSortTypes, columnSortOrder + public static final String COLUMN_NAMES = "mainTableColumnNames"; + public static final String COLUMN_WIDTHS = "mainTableColumnWidths"; + public static final String COLUMN_SORT_TYPES = "mainTableColumnSortTypes"; + public static final String COLUMN_SORT_ORDER = "mainTableColumnSortOrder"; + public static final String SIDE_PANE_COMPONENT_PREFERRED_POSITIONS = "sidePaneComponentPreferredPositions"; public static final String SIDE_PANE_COMPONENT_NAMES = "sidePaneComponentNames"; public static final String XMP_PRIVACY_FILTERS = "xmpPrivacyFilters"; diff --git a/src/test/java/org/jabref/migrations/PreferencesMigrationsTest.java b/src/test/java/org/jabref/migrations/PreferencesMigrationsTest.java index 140aa4d3cae..1377c17bcd2 100644 --- a/src/test/java/org/jabref/migrations/PreferencesMigrationsTest.java +++ b/src/test/java/org/jabref/migrations/PreferencesMigrationsTest.java @@ -1,6 +1,7 @@ package org.jabref.migrations; import java.util.Arrays; +import java.util.Collections; import java.util.List; import java.util.prefs.Preferences; @@ -219,4 +220,52 @@ void testUpgradeColumnPreferencesFromWithoutTypes() { verify(prefs).putStringList(JabRefPreferences.COLUMN_WIDTHS, updatedWidths); verify(prefs).putStringList(JabRefPreferences.COLUMN_SORT_TYPES, newSortTypes); } + + @Test + void testChangeColumnPreferencesVariableNamesFor51() { + List columnNames = Arrays.asList("entrytype", "author/editor", "title", "year", "journal/booktitle", "bibtexkey", "printed"); + List columnWidths = Arrays.asList("75", "300", "470", "60", "130", "100", "30"); + + // The variable names have to be hardcoded, because they have changed between 5.0 and 5.1 + when(prefs.getStringList("columnNames")).thenReturn(columnNames); + when(prefs.getStringList("columnWidths")).thenReturn(columnWidths); + when(prefs.getStringList("mainTableColumnSortTypes")).thenReturn(columnNames); + when(prefs.getStringList("mainTableColumnSortOrder")).thenReturn(columnWidths); + + when(prefs.getStringList(JabRefPreferences.COLUMN_NAMES)).thenReturn(Collections.emptyList()); + when(prefs.getStringList(JabRefPreferences.COLUMN_WIDTHS)).thenReturn(Collections.emptyList()); + when(prefs.getStringList(JabRefPreferences.COLUMN_SORT_TYPES)).thenReturn(Collections.emptyList()); + when(prefs.getStringList(JabRefPreferences.COLUMN_SORT_ORDER)).thenReturn(Collections.emptyList()); + + PreferencesMigrations.changeColumnVariableNamesFor51(prefs); + + verify(prefs).putStringList(JabRefPreferences.COLUMN_NAMES, columnNames); + verify(prefs).putStringList(JabRefPreferences.COLUMN_WIDTHS, columnWidths); + verify(prefs).putStringList(JabRefPreferences.COLUMN_NAMES, columnNames); + verify(prefs).putStringList(JabRefPreferences.COLUMN_WIDTHS, columnWidths); + } + + @Test + void testChangeColumnPreferencesVariableNamesBackwardsCompatibility() { + List columnNames = Arrays.asList("entrytype", "author/editor", "title", "year", "journal/booktitle", "bibtexkey", "printed"); + List columnWidths = Arrays.asList("75", "300", "470", "60", "130", "100", "30"); + + // The variable names have to be hardcoded, because they have changed between 5.0 and 5.1 + when(prefs.getStringList("columnNames")).thenReturn(columnNames); + when(prefs.getStringList("columnWidths")).thenReturn(columnWidths); + when(prefs.getStringList("mainTableColumnSortTypes")).thenReturn(columnNames); + when(prefs.getStringList("mainTableColumnSortOrder")).thenReturn(columnWidths); + + when(prefs.getStringList(JabRefPreferences.COLUMN_NAMES)).thenReturn(Collections.emptyList()); + when(prefs.getStringList(JabRefPreferences.COLUMN_WIDTHS)).thenReturn(Collections.emptyList()); + when(prefs.getStringList(JabRefPreferences.COLUMN_SORT_TYPES)).thenReturn(Collections.emptyList()); + when(prefs.getStringList(JabRefPreferences.COLUMN_SORT_ORDER)).thenReturn(Collections.emptyList()); + + PreferencesMigrations.upgradeColumnPreferences(prefs); + + verify(prefs, never()).put("columnNames", "anyString"); + verify(prefs, never()).put("columnWidths", "anyString"); + verify(prefs, never()).put("mainTableColumnSortTypes", "anyString"); + verify(prefs, never()).put("mainTableColumnSortOrder", "anyString"); + } } From 4bdfe8dbc27d45288258e417eb0fa723ad18e247 Mon Sep 17 00:00:00 2001 From: Carl Christian Snethlage Date: Thu, 16 Apr 2020 14:48:26 +0200 Subject: [PATCH 2/5] Changed variable names, added migration and tests --- JabRef-downgrade-regpatch.reg | Bin 0 -> 356 bytes 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 JabRef-downgrade-regpatch.reg diff --git a/JabRef-downgrade-regpatch.reg b/JabRef-downgrade-regpatch.reg new file mode 100644 index 0000000000000000000000000000000000000000..284394cfc8bd62671ac9bf91489ab638970776eb GIT binary patch literal 356 zcmaiw-%A2f5QV?zp#MR9S9|fXrwGD8Wlba62yIv0C^yz$>_4A=dsTW7<1*YibI#0} zdw0LjWGqO?*|MZYM9R$Ck`)D|m3!Gtl#6SO Date: Sat, 18 Apr 2020 19:08:42 +0200 Subject: [PATCH 3/5] Added restoration of deprecated variable names --- .../migrations/PreferencesMigrations.java | 58 +++++++++++++++---- .../migrations/PreferencesMigrationsTest.java | 16 +++++ 2 files changed, 62 insertions(+), 12 deletions(-) diff --git a/src/main/java/org/jabref/migrations/PreferencesMigrations.java b/src/main/java/org/jabref/migrations/PreferencesMigrations.java index 208dab88e55..b85a7d9fa19 100644 --- a/src/main/java/org/jabref/migrations/PreferencesMigrations.java +++ b/src/main/java/org/jabref/migrations/PreferencesMigrations.java @@ -1,6 +1,7 @@ package org.jabref.migrations; import java.util.ArrayList; +import java.util.Collections; import java.util.HashMap; import java.util.LinkedHashSet; import java.util.List; @@ -53,6 +54,7 @@ public static void runMigrations() { // variable names. However, the variables from 5.0 need to be copied to the new variable name too. changeColumnVariableNamesFor51(Globals.prefs); upgradeColumnPreferences(Globals.prefs); + restoreColumnVariablesForBackwardCompatibility(Globals.prefs); upgradePreviewStyleAllowMarkdown(Globals.prefs); } @@ -312,18 +314,6 @@ static void upgradePreviewStyleAllowMarkdown(JabRefPreferences prefs) { prefs.setPreviewStyle(migratedStyle); } - static void changeColumnVariableNamesFor51(JabRefPreferences preferences) { - // The variable names have to be hardcoded, because they have changed between 5.0 and 5.1 - List oldColumnNames = preferences.getStringList("columnNames"); - List columnNames = preferences.getStringList(JabRefPreferences.COLUMN_NAMES); - if (!oldColumnNames.isEmpty() && columnNames.isEmpty()) { - preferences.putStringList(JabRefPreferences.COLUMN_NAMES, preferences.getStringList("columnNames")); - preferences.putStringList(JabRefPreferences.COLUMN_WIDTHS, preferences.getStringList("columnWidths")); - preferences.putStringList(JabRefPreferences.COLUMN_SORT_TYPES, preferences.getStringList("mainTableColumnSortTypes")); - preferences.putStringList(JabRefPreferences.COLUMN_SORT_ORDER, preferences.getStringList("mainTableColumnSortOrder")); - } - } - /** * The former preferences default of columns was a simple list of strings ("author;title;year;..."). Since 5.0 * the preferences store the type of the column too, so that the formerly hardwired columns like the graphic groups @@ -392,4 +382,48 @@ static void upgradeColumnPreferences(JabRefPreferences preferences) { .collect(Collectors.toList())); } } + + static void changeColumnVariableNamesFor51(JabRefPreferences preferences) { + // The variable names have to be hardcoded, because they have changed between 5.0 and 5.1 + List oldColumnNames = preferences.getStringList("columnNames"); + List columnNames = preferences.getStringList(JabRefPreferences.COLUMN_NAMES); + if (!oldColumnNames.isEmpty() && columnNames.isEmpty()) { + preferences.putStringList(JabRefPreferences.COLUMN_NAMES, preferences.getStringList("columnNames")); + preferences.putStringList(JabRefPreferences.COLUMN_WIDTHS, preferences.getStringList("columnWidths")); + preferences.putStringList(JabRefPreferences.COLUMN_SORT_TYPES, preferences.getStringList("columnSortTypes")); + preferences.putStringList(JabRefPreferences.COLUMN_SORT_ORDER, preferences.getStringList("columnSortOrder")); + } + } + + /** + * In 5.0 the format of column names have changed. That made newer versions of JabRef preferences incompatible with + * earlier versions of JabRef. As some complains came up, we decided to change the variable names and to clear the + * variable contents if they are unreadable, so former versions of JabRef would automatically create preferences + * they can deal with. + */ + static void restoreColumnVariablesForBackwardCompatibility(JabRefPreferences preferences) { + List oldColumnNames = preferences.getStringList(JabRefPreferences.COLUMN_NAMES); + List fieldColumnNames = oldColumnNames.stream() + .filter(columnName -> columnName.startsWith("field:") || columnName.startsWith("special:")) + .map(columnName -> { + if (columnName.startsWith("field:")) { + return columnName.substring(6); + } else { // special + return columnName.substring(8); + } + }).collect(Collectors.toList()); + + if (!fieldColumnNames.isEmpty()) { + preferences.putStringList("columnNames", fieldColumnNames); + + List fieldColumnWidths = new ArrayList<>(Collections.emptyList()); + for (int i = 0; i < fieldColumnNames.size(); i++) { + fieldColumnWidths.add("100"); + } + preferences.putStringList("columnWidths", fieldColumnWidths); + + preferences.put("columnSortTypes", ""); + preferences.put("columnSortOrder", ""); + } + } } diff --git a/src/test/java/org/jabref/migrations/PreferencesMigrationsTest.java b/src/test/java/org/jabref/migrations/PreferencesMigrationsTest.java index 1377c17bcd2..83635f31bd7 100644 --- a/src/test/java/org/jabref/migrations/PreferencesMigrationsTest.java +++ b/src/test/java/org/jabref/migrations/PreferencesMigrationsTest.java @@ -268,4 +268,20 @@ void testChangeColumnPreferencesVariableNamesBackwardsCompatibility() { verify(prefs, never()).put("mainTableColumnSortTypes", "anyString"); verify(prefs, never()).put("mainTableColumnSortOrder", "anyString"); } + + @Test + void testRestoreColumnVariablesForBackwardCompatibility() { + List updatedNames = Arrays.asList("groups", "files", "linked_id", "field:entrytype", "field:author/editor", "field:title", "field:year", "field:journal/booktitle", "field:bibtexkey", "special:printed"); + List columnNames = Arrays.asList("entrytype", "author/editor", "title", "year", "journal/booktitle", "bibtexkey", "printed"); + List columnWidths = Arrays.asList("100", "100", "100", "100", "100", "100", "100"); + + when(prefs.getStringList(JabRefPreferences.COLUMN_NAMES)).thenReturn(updatedNames); + + PreferencesMigrations.restoreColumnVariablesForBackwardCompatibility(prefs); + + verify(prefs).putStringList("columnNames", columnNames); + verify(prefs).putStringList("columnWidths", columnWidths); + verify(prefs).put("columnSortTypes", ""); + verify(prefs).put("columnSortOrder", ""); + } } From 5b5f6b7308f7f01b1a1bb7e459ec34648e231fde Mon Sep 17 00:00:00 2001 From: Carl Christian Snethlage Date: Wed, 22 Apr 2020 18:10:39 +0200 Subject: [PATCH 4/5] Added restoration of font size --- .../java/org/jabref/migrations/PreferencesMigrations.java | 8 ++++++-- .../org/jabref/migrations/PreferencesMigrationsTest.java | 6 +++++- 2 files changed, 11 insertions(+), 3 deletions(-) diff --git a/src/main/java/org/jabref/migrations/PreferencesMigrations.java b/src/main/java/org/jabref/migrations/PreferencesMigrations.java index b85a7d9fa19..7db294f4659 100644 --- a/src/main/java/org/jabref/migrations/PreferencesMigrations.java +++ b/src/main/java/org/jabref/migrations/PreferencesMigrations.java @@ -54,7 +54,7 @@ public static void runMigrations() { // variable names. However, the variables from 5.0 need to be copied to the new variable name too. changeColumnVariableNamesFor51(Globals.prefs); upgradeColumnPreferences(Globals.prefs); - restoreColumnVariablesForBackwardCompatibility(Globals.prefs); + restoreVariablesForBackwardCompatibility(Globals.prefs); upgradePreviewStyleAllowMarkdown(Globals.prefs); } @@ -401,7 +401,7 @@ static void changeColumnVariableNamesFor51(JabRefPreferences preferences) { * variable contents if they are unreadable, so former versions of JabRef would automatically create preferences * they can deal with. */ - static void restoreColumnVariablesForBackwardCompatibility(JabRefPreferences preferences) { + static void restoreVariablesForBackwardCompatibility(JabRefPreferences preferences) { List oldColumnNames = preferences.getStringList(JabRefPreferences.COLUMN_NAMES); List fieldColumnNames = oldColumnNames.stream() .filter(columnName -> columnName.startsWith("field:") || columnName.startsWith("special:")) @@ -425,5 +425,9 @@ static void restoreColumnVariablesForBackwardCompatibility(JabRefPreferences pre preferences.put("columnSortTypes", ""); preferences.put("columnSortOrder", ""); } + + // Ensure font size is a parsable int variable + preferences.putInt(JabRefPreferences.MAIN_FONT_SIZE, + (int) Math.round(Double.parseDouble(preferences.get(JabRefPreferences.MAIN_FONT_SIZE)))); } } diff --git a/src/test/java/org/jabref/migrations/PreferencesMigrationsTest.java b/src/test/java/org/jabref/migrations/PreferencesMigrationsTest.java index 83635f31bd7..78d3fc37a6b 100644 --- a/src/test/java/org/jabref/migrations/PreferencesMigrationsTest.java +++ b/src/test/java/org/jabref/migrations/PreferencesMigrationsTest.java @@ -277,11 +277,15 @@ void testRestoreColumnVariablesForBackwardCompatibility() { when(prefs.getStringList(JabRefPreferences.COLUMN_NAMES)).thenReturn(updatedNames); - PreferencesMigrations.restoreColumnVariablesForBackwardCompatibility(prefs); + when(prefs.get(JabRefPreferences.MAIN_FONT_SIZE)).thenReturn("11.2"); + + PreferencesMigrations.restoreVariablesForBackwardCompatibility(prefs); verify(prefs).putStringList("columnNames", columnNames); verify(prefs).putStringList("columnWidths", columnWidths); verify(prefs).put("columnSortTypes", ""); verify(prefs).put("columnSortOrder", ""); + + verify(prefs).putInt(JabRefPreferences.MAIN_FONT_SIZE, 11); } } From 7c260f5cc9ac315658d8e0f0aa22be56085a16ab Mon Sep 17 00:00:00 2001 From: Oliver Kopp Date: Wed, 22 Apr 2020 21:57:49 +0200 Subject: [PATCH 5/5] Fix loading of JabRef 5.0 font preferences --- .../org/jabref/migrations/PreferencesMigrations.java | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) diff --git a/src/main/java/org/jabref/migrations/PreferencesMigrations.java b/src/main/java/org/jabref/migrations/PreferencesMigrations.java index 7db294f4659..fccef2f05b8 100644 --- a/src/main/java/org/jabref/migrations/PreferencesMigrations.java +++ b/src/main/java/org/jabref/migrations/PreferencesMigrations.java @@ -427,7 +427,14 @@ static void restoreVariablesForBackwardCompatibility(JabRefPreferences preferenc } // Ensure font size is a parsable int variable - preferences.putInt(JabRefPreferences.MAIN_FONT_SIZE, - (int) Math.round(Double.parseDouble(preferences.get(JabRefPreferences.MAIN_FONT_SIZE)))); + try { + // some versions stored the font size as double to the **same** key + // since the preference store is type-safe, we need to add this workaround + String fontSizeAsString = preferences.get(JabRefPreferences.MAIN_FONT_SIZE); + int fontSizeAsInt = (int) Math.round(Double.parseDouble(fontSizeAsString)); + preferences.putInt(JabRefPreferences.MAIN_FONT_SIZE, fontSizeAsInt); + } catch (ClassCastException e) { + // already an integer + } } }