Add support for automatic ICORE conference ranking lookup [#13476]

jablib/src/main/java/org/jabref/logic/database/DuplicateCheck.java

@@ -289,9 +289,10 @@ public static double correlateByWords(final String s1, final String s2) {
         final String[] w1 = s1.split("\\s");
         final String[] w2 = s2.split("\\s");
         final int n = Math.min(w1.length, w2.length);
+        final StringSimilarity match = new StringSimilarity();
         int misses = 0;
         for (int i = 0; i < n; i++) {
-            double corr = similarity(w1[i], w2[i]);
+            double corr = match.similarity(w1[i], w2[i]);
             if (corr < 0.75) {
                 misses++;
             }
@@ -300,33 +301,6 @@ public static double correlateByWords(final String s1, final String s2) {
         return 1 - missRate;
     }
 
-    /**
-     * Calculates the similarity (a number within 0 and 1) between two strings.
-     * http://stackoverflow.com/questions/955110/similarity-string-comparison-in-java
-     */
-    private static double similarity(final String first, final String second) {
-        final String longer;
-        final String shorter;
-
-        if (first.length() < second.length()) {
-            longer = second;
-            shorter = first;
-        } else {
-            longer = first;
-            shorter = second;
-        }
-
-        final int longerLength = longer.length();
-        // both strings are zero length
-        if (longerLength == 0) {
-            return 1.0;
-        }
-        final double distanceIgnoredCase = new StringSimilarity().editDistanceIgnoreCase(longer, shorter);
-        final double similarity = (longerLength - distanceIgnoredCase) / longerLength;
-        LOGGER.trace("Longer string: {} Shorter string: {} Similarity: {}", longer, shorter, similarity);
-        return similarity;
-    }
-
     /**
      * Checks if the two entries represent the same publication.
      */

jablib/src/main/java/org/jabref/logic/icore/ConferenceAcronymExtractor.java

@@ -0,0 +1,24 @@
+package org.jabref.logic.icore;
+
+import java.util.Optional;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class ConferenceAcronymExtractor {
+    // Regex that'll extract the string within the first deepest set of parentheses
+    // A slight modification of: https://stackoverflow.com/a/17759264
+    private static final Pattern PATTERN = Pattern.compile("\\(([^()]*)\\)");
+
+    public static Optional<String> extract(String input) {
+        Matcher matcher = PATTERN.matcher(input);
+
+        if (matcher.find()) {
+            String match = matcher.group(1).strip();
+            if (!match.isEmpty()) {
+                return Optional.of(match);
+            }
+        }
+
+        return Optional.empty();
+    }
+}

jablib/src/main/java/org/jabref/logic/icore/ConferenceRepository.java

@@ -0,0 +1,138 @@
+package org.jabref.logic.icore;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+
+import org.jabref.logic.JabRefException;
+import org.jabref.logic.util.strings.StringSimilarity;
+import org.jabref.model.icore.ConferenceEntry;
+
+import org.apache.commons.csv.CSVFormat;
+import org.apache.commons.csv.CSVRecord;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * A Repository that loads and stores the latest ICORE Conference Ranking Data and allows lookups using a conference's
+ * acronym or title.
+ * <p>
+ * The ranking data is sourced from <a href="https://portal.core.edu.au/conf-ranks/">the ICORE Conference Ranking Portal</a>.
+ * Since the website does not expose an API endpoint to fetch this data programmatically, it must be manually exported
+ * from the website and stored as a resource. This means that when new ranking data is released, the old data must be
+ * replaced and the <code>ICORE_RANK_DATA_FILE</code> variable must be modified to point to the new data file.
+ */
+public class ConferenceRepository {
+    private static final Logger LOGGER = LoggerFactory.getLogger(ConferenceRepository.class);
+    private static final String ICORE_RANK_DATA_FILE = "/icore/ICORE2023.csv";
+
+    private final Map<String, ConferenceEntry> acronymToConference = new HashMap<>();
+    private final Map<String, ConferenceEntry> titleToConference = new HashMap<>();
+
+    public ConferenceRepository() throws JabRefException {
+        InputStream inputStream = getClass().getResourceAsStream(ICORE_RANK_DATA_FILE);
+
+        if (inputStream == null) {
+            throw new JabRefException("ICORE rank data file not found in resources");
+        }
+
+        loadConferenceDataFromInputStream(inputStream);
+    }
+
+    // Constructor to allow loading in test data
+    public ConferenceRepository(InputStream testFileInputStream) throws JabRefException {
+        loadConferenceDataFromInputStream(testFileInputStream);
+    }
+
+    private void loadConferenceDataFromInputStream(InputStream inputStream) throws JabRefException {
+        BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
+
+        try (inputStream; reader) {
+            Iterable<CSVRecord> records = CSVFormat.DEFAULT.builder()
+                    .setHeader()
+                    .setSkipHeaderRecord(true)
+                    .get()
+                    .parse(reader);
+
+            for (CSVRecord record : records) {
+                String id = record.get("Id").strip();
+                String title = record.get("Title").strip().toLowerCase();
+                String acronym = record.get("Acronym").strip().toUpperCase();
+                String rank = record.get("Rank").strip();
+
+                if (id.isEmpty() || title.isEmpty() || acronym.isEmpty() || rank.isEmpty()) {
+                    LOGGER.warn("Missing fields in row in ICORE rank data: {}", record);
+                    continue;
+                }
+
+                ConferenceEntry conferenceEntry = new ConferenceEntry(id, title, acronym, rank);
+                acronymToConference.put(acronym, conferenceEntry);
+                titleToConference.put(title, conferenceEntry);
+            }
+        } catch (IOException e) {
+            throw new JabRefException("I/O Error while reading ICORE data from resource", e);
+        }
+    }
+
+    public Optional<ConferenceEntry> getConferenceFromAcronym(String acronym) {
+        String query = acronym.strip().toUpperCase();
+
+        ConferenceEntry conference = acronymToConference.get(query);
+
+        if (conference == null) {
+            return Optional.empty();
+        }
+
+        return Optional.of(conference);
+    }
+
+    public Optional<ConferenceEntry> getConferenceFromBookTitle(String bookTitle) {
+        String query = bookTitle.strip().toLowerCase();
+
+        // Lucky path
+        ConferenceEntry conference = titleToConference.get(query);
+        if (conference != null) {
+            return Optional.of(conference);
+        }
+
+        String bestMatch = fuzzySearchConferenceTitles(query);
+
+        if (bestMatch.isEmpty()) {
+            return Optional.empty();
+        }
+
+        conference = titleToConference.get(bestMatch);
+
+        return Optional.of(conference);
+    }
+
+    /**
+     * Searches all conference titles for the given query string using {@link StringSimilarity#similarity} as a matcher.
+     * <p>
+     * The threshold for matching is set at 0.9. This function will always return the conference title with the highest
+     * similarity rating.
+     *
+     * @param query The query string to be searched
+     * @return The conference title, if found. Otherwise, an empty string is returned.
+     */
+    private String fuzzySearchConferenceTitles(String query) {
+        String bestMatch = "";
+        double bestSimilarity = 0.0;
+        final double FUZZY_SEARCH_THRESHOLD = 0.9;
+        StringSimilarity matcher = new StringSimilarity();
+
+        for (String conferenceTitle : titleToConference.keySet()) {
+            double similarity = matcher.similarity(query, conferenceTitle);
+            if (similarity >= FUZZY_SEARCH_THRESHOLD && similarity > bestSimilarity) {
+                bestMatch = conferenceTitle;
+                bestSimilarity = similarity;
+            }
+        }
+
+        return bestMatch;
+    }
+}

jablib/src/main/java/org/jabref/logic/util/strings/StringSimilarity.java

@@ -3,8 +3,12 @@
 import java.util.Locale;
 
 import info.debatty.java.stringsimilarity.Levenshtein;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 public class StringSimilarity {
+    private static final Logger LOGGER = LoggerFactory.getLogger(StringSimilarity.class);
+
     private final Levenshtein METRIC_DISTANCE = new Levenshtein();
     // edit distance threshold for entry title comparison
     private final int METRIC_THRESHOLD = 4;
@@ -24,4 +28,31 @@ public double editDistanceIgnoreCase(String a, String b) {
         // TODO: Locale is dependent on the language of the strings. English is a good denominator.
         return METRIC_DISTANCE.distance(a.toLowerCase(Locale.ENGLISH), b.toLowerCase(Locale.ENGLISH));
     }
+
+    /**
+     * Calculates the similarity (a number within 0 and 1) between two strings.
+     * http://stackoverflow.com/questions/955110/similarity-string-comparison-in-java
+     */
+    public double similarity(final String first, final String second) {
+        final String longer;
+        final String shorter;
+
+        if (first.length() < second.length()) {
+            longer = second;
+            shorter = first;
+        } else {
+            longer = first;
+            shorter = second;
+        }
+
+        final int longerLength = longer.length();
+        // both strings are zero length
+        if (longerLength == 0) {
+            return 1.0;
+        }
+        final double distanceIgnoredCase = editDistanceIgnoreCase(longer, shorter);
+        final double similarity = (longerLength - distanceIgnoredCase) / longerLength;
+        LOGGER.trace("Longer string: {} Shorter string: {} Similarity: {}", longer, shorter, similarity);
+        return similarity;
+    }
 }

jablib/src/main/java/org/jabref/model/icore/ConferenceEntry.java

@@ -0,0 +1,17 @@
+package org.jabref.model.icore;
+
+/**
+ * A Conference Entry built from a subset of fields in the ICORE Ranking data
+ */
+public record ConferenceEntry(
+        String id,
+        String title,
+        String acronym,
+        String rank
+) {
+    private final static String URL_PREFIX = "https://portal.core.edu.au/conf-ranks/";
+
+    public String getICOREURL() {
+        return URL_PREFIX + id;
+    }
+}