Fix #12271: Integrity checker for year, location, and page numbers in booktitle (#15465)

* Fix #12271: Detect year, country, and page numbers in booktitle

Enhance BooktitleChecker to flag booktitle values that contain:
- A 4-digit year (e.g. 2015)
- A country name (e.g. Norway, Austria, Singapore)
- Explicit page-number patterns (e.g. "pp. 1–10", "pages 3-7")

Add Countries.java with a hard-coded set of all UN-recognised country
names used for the country-presence check.  The set is built as a single
pre-compiled regex alternation so the pattern is compiled only once.

Update BooktitleCheckerTest with parameterised tests covering all three
new integrity rules and the blank-value / valid-value edge cases.

Closes #12271

* Fix Countries.java javadoc to use /// style

* Add missing localization keys for booktitle integrity checks

* Address code review: split BooktitleChecker into focused checkers

- Extract year, country, and page-number checks into separate
  ValueChecker classes (BooktitleContainsYearChecker,
  BooktitleContainsCountryChecker, BooktitleContainsPagesChecker)
  so all three issues in one booktitle are reported independently
- Fix word-boundary regex in country checker: replace [a-z]
  lookarounds with \p{Alnum} so tokens like USA2015 are not
  mis-flagged as locations
- Register all three new checkers in FieldCheckers for BOOKTITLE
- Strengthen tests: use assertEquals with exact expected message
  instead of assertNotEquals(Optional.empty()); add regression
  test for alphanumeric token false-positive

* Fix Checkstyle: use Pattern instead of Predicate<String> for compiled regexes

* Fix Checkstyle: put Pattern.compile on same line as static final declaration

* Retrigger CI

* refactor: use Locale API for country names, add region markers to tests

- Replace hard-coded country list in Countries.java with
  Locale.getISOCountries() + getDisplayCountry() so no manual
  maintenance is needed
- Use //region and //endregion in BooktitleCheckerTest for
  better test organization

* fix: align stream chain to match IntelliJ formatter style

* fix: add space after // in region comments for Checkstyle

* refactor: inline country names into checker, remove Countries class

- Remove separate Countries.java utility class; inline the
  Locale-derived country set directly into
  BooktitleContainsCountryChecker
- Use Locale.of() instead of Locale.Builder (matches existing
  JabRef convention in Language.java)
- Remove javadoc from new checkers to match existing checker
  style (BracketChecker, TitleChecker, YearChecker have none)

* chore: retrigger CI after rebase

* chore: retrigger CI

* fix: use alphanumeric boundary for booktitle year regex

Previously the year regex used digit-only lookarounds, so tokens like
ICML2015 matched the 2015 and triggered a false positive. Switching the
boundary to \p{Alnum} mirrors the country checker and prevents matching
years that are embedded inside larger alphanumeric tokens.

Also adds a regression test and a CHANGELOG entry under [Unreleased].

---------

Co-authored-by: Subhramit Basu <subhramit.bb@live.in>

Author: Chiragsd13

CHANGELOG.md

@@ -28,6 +28,7 @@ Note that this project **does not** adhere to [Semantic Versioning](https://semv
 - We now support refreshing existing CSL citations with respect to their in-text nature in the LibreOffice integration. [#15369](https://github.com/JabRef/jabref/pull/15369)
 - Added context menu entry "Sort tabs alphabetically" to the library tabs. [#15425](https://github.com/JabRef/jabref/pull/15425)
 - We added a "Merge" action in the File menu to compare the current library with a selected BibTeX file and review changes. [#15401](https://github.com/JabRef/jabref/issues/15401)
+- We added integrity checks that warn when the `booktitle` field contains a year, a country/location, or page numbers that should live in dedicated fields. [#12271](https://github.com/JabRef/jabref/issues/12271)
 
 ### Changed
 

jablib/src/main/java/org/jabref/logic/integrity/BooktitleContainsCountryChecker.java

@@ -0,0 +1,37 @@
+package org.jabref.logic.integrity;
+
+import java.util.Arrays;
+import java.util.Locale;
+import java.util.Optional;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+
+import org.jabref.logic.l10n.Localization;
+import org.jabref.logic.util.strings.StringUtil;
+
+public class BooktitleContainsCountryChecker implements ValueChecker {
+
+    private static final Pattern CONTAINS_COUNTRY;
+
+    static {
+        String alternation = Arrays.stream(Locale.getISOCountries())
+                                   .map(code -> Locale.of("", code).getDisplayCountry(Locale.ENGLISH))
+                                   .filter(name -> !name.isEmpty())
+                                   .map(name -> name.toLowerCase(Locale.ENGLISH))
+                                   .map(Pattern::quote)
+                                   .collect(Collectors.joining("|"));
+        CONTAINS_COUNTRY = Pattern.compile(
+                "(?i)(?<!\\p{Alnum})(" + alternation + ")(?!\\p{Alnum})");
+    }
+
+    @Override
+    public Optional<String> checkValue(String value) {
+        if (StringUtil.isBlank(value)) {
+            return Optional.empty();
+        }
+        if (CONTAINS_COUNTRY.matcher(value).find()) {
+            return Optional.of(Localization.lang("booktitle should not contain a location"));
+        }
+        return Optional.empty();
+    }
+}

jablib/src/main/java/org/jabref/logic/integrity/BooktitleContainsPagesChecker.java

@@ -0,0 +1,23 @@
+package org.jabref.logic.integrity;
+
+import java.util.Optional;
+import java.util.regex.Pattern;
+
+import org.jabref.logic.l10n.Localization;
+import org.jabref.logic.util.strings.StringUtil;
+
+public class BooktitleContainsPagesChecker implements ValueChecker {
+
+    private static final Pattern CONTAINS_PAGES = Pattern.compile("(?i)\\b(pp?\\.?|pages?)\\s*[0-9]+");
+
+    @Override
+    public Optional<String> checkValue(String value) {
+        if (StringUtil.isBlank(value)) {
+            return Optional.empty();
+        }
+        if (CONTAINS_PAGES.matcher(value).find()) {
+            return Optional.of(Localization.lang("booktitle should not contain page numbers"));
+        }
+        return Optional.empty();
+    }
+}

jablib/src/main/java/org/jabref/logic/integrity/BooktitleContainsYearChecker.java

@@ -0,0 +1,23 @@
+package org.jabref.logic.integrity;
+
+import java.util.Optional;
+import java.util.regex.Pattern;
+
+import org.jabref.logic.l10n.Localization;
+import org.jabref.logic.util.strings.StringUtil;
+
+public class BooktitleContainsYearChecker implements ValueChecker {
+
+    private static final Pattern CONTAINS_YEAR = Pattern.compile("(?<!\\p{Alnum})[12][0-9]{3}(?!\\p{Alnum})");
+
+    @Override
+    public Optional<String> checkValue(String value) {
+        if (StringUtil.isBlank(value)) {
+            return Optional.empty();
+        }
+        if (CONTAINS_YEAR.matcher(value).find()) {
+            return Optional.of(Localization.lang("booktitle should not contain a year"));
+        }
+        return Optional.empty();
+    }
+}

jablib/src/main/java/org/jabref/logic/integrity/FieldCheckers.java

@@ -31,6 +31,9 @@ private static Multimap<Field, ValueChecker> getAllMap(BibDatabaseContext databa
             fieldCheckers.put(field, new PersonNamesChecker(databaseContext));
         }
         fieldCheckers.put(StandardField.BOOKTITLE, new BooktitleChecker());
+        fieldCheckers.put(StandardField.BOOKTITLE, new BooktitleContainsYearChecker());
+        fieldCheckers.put(StandardField.BOOKTITLE, new BooktitleContainsCountryChecker());
+        fieldCheckers.put(StandardField.BOOKTITLE, new BooktitleContainsPagesChecker());
         fieldCheckers.put(StandardField.TITLE, new BracketChecker());
         fieldCheckers.put(StandardField.TITLE, new TitleChecker(databaseContext));
         fieldCheckers.put(StandardField.DOI, new DoiValidityChecker());

jablib/src/main/resources/l10n/JabRef_en.properties

@@ -1658,6 +1658,9 @@ JabRef\ would\ not\ have\ been\ possible\ without\ the\ help\ of\ our\ contribut
 
 HTML\ encoded\ character\ found=HTML encoded character found
 booktitle\ ends\ with\ 'conference\ on'=booktitle ends with 'conference on'
+booktitle\ should\ not\ contain\ a\ location=booktitle should not contain a location
+booktitle\ should\ not\ contain\ a\ year=booktitle should not contain a year
+booktitle\ should\ not\ contain\ page\ numbers=booktitle should not contain page numbers
 contains\ a\ URL=contains a URL
 
 incorrect\ control\ digit=incorrect control digit

jablib/src/test/java/org/jabref/logic/integrity/BooktitleCheckerTest.java

@@ -6,25 +6,135 @@
 import org.junit.jupiter.api.parallel.ResourceLock;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertNotEquals;
 
 @ResourceLock("Localization.lang")
 class BooktitleCheckerTest {
 
     private final BooktitleChecker checker = new BooktitleChecker();
+    private final BooktitleContainsYearChecker yearChecker = new BooktitleContainsYearChecker();
+    private final BooktitleContainsCountryChecker countryChecker = new BooktitleContainsCountryChecker();
+    private final BooktitleContainsPagesChecker pagesChecker = new BooktitleContainsPagesChecker();
+
+    // region "ends with conference on" checks
 
     @Test
     void booktitleAcceptsIfItDoesNotEndWithConferenceOn() {
-        assertEquals(Optional.empty(), checker.checkValue("2014 Fourth International Conference on Digital Information and Communication Technology and it's Applications (DICTAP)"));
+        assertEquals(Optional.empty(), checker.checkValue("Fourth International Conference on Digital Information and Communication Technology and its Applications (DICTAP)"));
     }
 
     @Test
-    void booktitleDoesNotAcceptsIfItEndsWithConferenceOn() {
-        assertNotEquals(Optional.empty(), checker.checkValue("Digital Information and Communication Technology and it's Applications (DICTAP), 2014 Fourth International Conference on"));
+    void booktitleDoesNotAcceptIfItEndsWithConferenceOn() {
+        assertEquals(Optional.of("booktitle ends with 'conference on'"),
+                checker.checkValue("Digital Information and Communication Technology and its Applications (DICTAP), Fourth International Conference on"));
     }
 
     @Test
     void booktitleIsBlank() {
         assertEquals(Optional.empty(), checker.checkValue(" "));
     }
+
+    // endregion
+
+    // region Year detection
+
+    @Test
+    void booktitleFlagsYearInMiddle() {
+        assertEquals(Optional.of("booktitle should not contain a year"),
+                yearChecker.checkValue("European Conference on Circuit Theory and Design, {ECCTD} 2015, Trondheim, Norway"));
+    }
+
+    @Test
+    void booktitleFlagsYearAtStart() {
+        assertEquals(Optional.of("booktitle should not contain a year"),
+                yearChecker.checkValue("2015 {IEEE} International Conference on Digital Signal Processing"));
+    }
+
+    @Test
+    void booktitleAcceptsWhenNoYear() {
+        assertEquals(Optional.empty(), yearChecker.checkValue("International Conference on Software Engineering"));
+    }
+
+    @Test
+    void booktitleYearNotFlaggedInsideAlphanumericToken() {
+        // "ICML2015" should NOT be flagged — the digits are part of a larger token
+        assertEquals(Optional.empty(), yearChecker.checkValue("Proceedings ICML2015"));
+    }
+
+    @Test
+    void booktitleYearCheckerIsBlank() {
+        assertEquals(Optional.empty(), yearChecker.checkValue(" "));
+    }
+
+    // endregion
+
+    // region Location (country) detection
+
+    @Test
+    void booktitleFlagsCountryName() {
+        assertEquals(Optional.of("booktitle should not contain a location"),
+                countryChecker.checkValue("Service-Oriented Computing, Fifth International Conference, Vienna, Austria, Proceedings"));
+    }
+
+    @Test
+    void booktitleFlagsCountryNameSingapore() {
+        assertEquals(Optional.of("booktitle should not contain a location"),
+                countryChecker.checkValue("{IEEE} International Conference on Digital Signal Processing, Singapore, Proceedings"));
+    }
+
+    @Test
+    void booktitleAcceptsWhenNoCountry() {
+        assertEquals(Optional.empty(), countryChecker.checkValue("International Conference on Machine Learning Proceedings"));
+    }
+
+    @Test
+    void booktitleCountryNotFlaggedInsideAlphanumericToken() {
+        // "USA2015" should NOT be flagged — the abbreviation is part of a larger token
+        assertEquals(Optional.empty(), countryChecker.checkValue("Proceedings USA2015"));
+    }
+
+    @Test
+    void booktitleCountryCheckerIsBlank() {
+        assertEquals(Optional.empty(), countryChecker.checkValue(" "));
+    }
+
+    // endregion
+
+    // region Page-number detection
+
+    @Test
+    void booktitleFlagsPagesPattern() {
+        assertEquals(Optional.of("booktitle should not contain page numbers"),
+                pagesChecker.checkValue("Advances in Neural Information Processing Systems, pp. 1234-1242"));
+    }
+
+    @Test
+    void booktitleFlagsPagesKeyword() {
+        assertEquals(Optional.of("booktitle should not contain page numbers"),
+                pagesChecker.checkValue("Advances in Neural Information Processing Systems, pages 1234-1242"));
+    }
+
+    @Test
+    void booktitleAcceptsWhenNoPageNumbers() {
+        assertEquals(Optional.empty(), pagesChecker.checkValue("Advances in Neural Information Processing Systems"));
+    }
+
+    @Test
+    void booktitlePagesCheckerIsBlank() {
+        assertEquals(Optional.empty(), pagesChecker.checkValue(" "));
+    }
+
+    // endregion
+
+    // region Multiple issues in one booktitle
+
+    @Test
+    void booktitleWithYearAndCountryFlagsBoth() {
+        // Year checker and country checker are separate — both fire independently
+        assertEquals(Optional.of("booktitle should not contain a year"),
+                yearChecker.checkValue("2015 IEEE Conference, Singapore"));
+        assertEquals(Optional.of("booktitle should not contain a location"),
+                countryChecker.checkValue("2015 IEEE Conference, Singapore"));
+    }
+
+    // endregion
 }