Merge remote-tracking branch 'upstream/master'

* upstream/master:
  Reorder CHANGELOG for 4.0-beta release
  Add test that 3.8.2 should not be updated to 4.0-beta
  Fix test according to new behavior
  Sauliusg fix 2700 null pointer exception on get fulltext (#2751)
  Fix selecting all entries with shortcut (#2683)
  Incoporate feedback. Make it work for one comma (and not for two)
  Revert "allow search for words without diacritics in contain-based mode". I did not know that the push is considered in my push request
  allow search for words without diacritics in contain-based mode
  Update CHANGELOG.md
  corrected issue #2652

src/main/java/org/jabref/gui/entryeditor/EntryEditor.java

@@ -694,7 +694,10 @@ public void updateSource() {
 
                 // Set the current Entry to be selected.
                 // Fixes the bug of losing selection after, e.g. an autogeneration of a BibTeX key.
-                panel.highlightEntry(entry);
+                // This is also important for the "select all"-action (else it will always select the first entry except it is already)
+                SwingUtilities.invokeLater(() -> {
+                    panel.getMainTable().ensureVisible(entry);
+                });
             } catch (IOException ex) {
                 source.setText(ex.getMessage() + "\n\n" +
                         Localization.lang("Correct the entry, and reopen editor to display/edit source."));
@@ -1368,8 +1371,11 @@ public void actionPerformed(ActionEvent event) {
 
             // Make sure we scroll to the entry if it moved in the table.
             // Should only be done if this editor is currently showing:
+            // don't select the current entry again (eg use BasePanel#highlightEntry} in case another entry was selected)
             if (!movingAway && isShowing()) {
-                panel.highlightEntry(entry);
+                SwingUtilities.invokeLater(() -> {
+                    panel.getMainTable().ensureVisible(entry);
+                });
             }
         }
     }

src/main/java/org/jabref/gui/maintable/MainTable.java

@@ -605,6 +605,23 @@ public void ensureVisible(int row) {
         }
     }
 
+    /**
+     * Ensures that the given entry is shown in the maintable.
+     * It also selects the given entry
+     * The execution is executed directly. Be sure that it happens in the EDT.
+     *
+     * @param entry the BibEntry to be shown
+     */
+    public void ensureVisible(BibEntry entry) {
+        final int row = this.findEntry(entry);
+        if (row >= 0) {
+            if (this.getSelectedRowCount() == 0) {
+                this.setRowSelectionInterval(row, row);
+            }
+            this.ensureVisible(row);
+        }
+    }
+
     public void scrollToCenter(int rowIndex, int vColIndex) {
         if (!(this.getParent() instanceof JViewport)) {
             return;

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

@@ -30,15 +30,15 @@
  * <li> every comma separates tokens, while sequences of other separators are
  * equivalent to a single separator; for example: "a - b" consists of 2 tokens
  * ("a" and "b"), while "a,-,b" consists of 3 tokens ("a", "", and "b")
- * <li> anything enclosed in braces belonges to a single token; for example:
+ * <li> anything enclosed in braces belongs to a single token; for example:
  * "abc x{a,b,-~ c}x" consists of 2 tokens, while "abc xa,b,-~ cx" consists of 4
  * tokens ("abc", "xa","b", and "cx");
  * <li> a token followed immediately by a dash is "dash-terminated" token, and
  * all other tokens are "space-terminated" tokens; for example: in "a-b- c - d"
  * tokens "a" and "b" are dash-terminated and "c" and "d" are space-terminated;
  * <li> for the purposes of splitting of 'author name' into parts and
  * construction of abbreviation of first name, one needs definitions of first
- * latter of a token, case of a token, and abbreviation of a token:
+ * letter of a token, case of a token, and abbreviation of a token:
  * <ul>
  * <li> 'first letter' of a token is the first letter character (<CODE>Character.isLetter(c)==true</CODE>)
  * that does not belong to a sequence of letters that immediately follows "\"
@@ -49,7 +49,7 @@
  * "{\noopsort{\"o}}xyz" 'first letter' is "o", in "{\AE}x" 'first letter' is
  * "A", in "\aex\ijk\Oe\j" 'first letter' is "j"; if there is no letter
  * satisfying the above rule, 'first letter' is undefined;
- * <li> token is "lower-case" token, if its first letter id defined and is
+ * <li> token is "lower-case" token if its first letter is defined and is
  * lower-case (<CODE>Character.isLowerCase(c)==true</CODE>), and token is
  * "upper-case" token otherwise;
  * <li> 'abbreviation' of a token is the shortest prefix of the token that (a)
@@ -63,19 +63,19 @@
  * as "{\noopsort{A}}.", while BiBTeX produces "j."; fixing this problem,
  * however, requires processing of the preabmle;
  * </ul>
- * <li> 'author name's in 'author field' are subsequences of tokens separated by
+ * <li> 'author names' in 'author field' are subsequences of tokens separated by
  * token "and" ("and" is case-insensitive); if 'author name' is an empty
  * sequence of tokens, it is ignored; for examle, both "John Smith and Peter
  * Black" and "and and John Smith and and Peter Black" consists of 2 'author
  * name's "Johm Smith" and "Peter Black" (in erroneous situations, this is a bit
  * different from BiBTeX behavior);
  * <li> 'author name' consists of 'first-part', 'von-part', 'last-part', and
  * 'junior-part', each of which is a sequence of tokens; how a sequence of
- * tokens has to be splitted into these parts, depends the number of commas:
+ * tokens has to be split into these parts, depends the number of commas:
  * <ul>
  * <li> no commas, all tokens are upper-case: 'junior-part' and 'von-part' are
  * empty, 'last-part' consist of the last token, 'first-part' consists of all
- * other tokens ('first-part' is empty, if 'author name' consists of a single
+ * other tokens ('first-part' is empty if 'author name' consists of a single
  * token); for example, in "John James Smith", 'last-part'="Smith" and
  * 'first-part'="John James";
  * <li> no commas, there exists lower-case token: 'junior-part' is empty,
@@ -100,7 +100,7 @@
  * <li> two or more commas (any comma after the second one is ignored; it merely
  * separates tokens): 'junior-part' consists of all tokens between first and
  * second commas, 'first-part' consists of all tokens after the second comma,
- * tokens before the first comma are splitted into 'von-part' and 'last-part'
+ * tokens before the first comma are split into 'von-part' and 'last-part'
  * similarly to the case of one comma; for example: in "de la Vall{\'e}e
  * Poussin, Jr., Charles Louis Xavier Joseph", 'first-part'="Charles Louis
  * Xavier Joseph", 'von-part'="de la", 'last-part'="Vall{\'e}e la Poussin", and
@@ -167,7 +167,11 @@ public static AuthorList parse(String authors) {
 
         // Handle case names in order lastname, firstname and separated by ","
         // E.g., Ali Babar, M., Dingsøyr, T., Lago, P., van der Vliet, H.
-        if (!authors.toUpperCase(Locale.ENGLISH).contains(" AND ") && !authors.contains("{") && !authors.contains(";")) {
+        final boolean authorsContainAND = authors.toUpperCase(Locale.ENGLISH).contains(" AND ");
+        final boolean authorsContainOpeningBrace = authors.contains("{");
+        final boolean authorsContainSemicolon = authors.contains(";");
+        final boolean authorsContainTwoOrMoreCommas = (authors.length() - authors.replace(",", "").length()) >= 2;
+        if (!authorsContainAND && !authorsContainOpeningBrace && !authorsContainSemicolon && authorsContainTwoOrMoreCommas) {
             List<String> arrayNameList = Arrays.asList(authors.split(","));
 
             // Delete spaces for correct case identification

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

@@ -309,14 +309,14 @@ private String concatTokens(List<Object> tokens, int start, int end, int offset,
      * additional information is given in global variables <CODE>token_start</CODE>,
      * <CODE>token_end</CODE>, <CODE>token_abbr</CODE>, <CODE>token_term</CODE>,
      * and <CODE>token_case</CODE>; namely: <CODE>orig.substring(token_start,token_end)</CODE>
-     * is the thext of the token, <CODE>orig.substring(token_start,token_abbr)</CODE>
+     * is the text of the token, <CODE>orig.substring(token_start,token_abbr)</CODE>
      * is the token abbreviation, <CODE>token_term</CODE> contains token
      * terminator (space or dash), and <CODE>token_case</CODE> is <CODE>true</CODE>,
      * if token is upper-case and <CODE>false</CODE> if token is lower-case.
      *
      * @return <CODE>TOKEN_EOF</CODE> -- no more tokens, <CODE>TOKEN_COMMA</CODE> --
      * token is comma, <CODE>TOKEN_AND</CODE> -- token is the word
-     * "and" (or "And", or "aND", etc.) or a colon, <CODE>TOKEN_WORD</CODE> --
+     * "and" (or "And", or "aND", etc.) or a semicolon, <CODE>TOKEN_WORD</CODE> --
      * token is a word; additional information is given in global
      * variables <CODE>token_start</CODE>, <CODE>token_end</CODE>,
      * <CODE>token_abbr</CODE>, <CODE>token_term</CODE>, and
@@ -339,7 +339,7 @@ private int getToken() {
             tokenEnd++;
             return TOKEN_COMMA;
         }
-        // Colon is considered to separate names like "and"
+        // Semicolon is considered to separate names like "and"
         if (original.charAt(tokenStart) == ';') {
             tokenEnd++;
             return TOKEN_AND;

src/test/java/org/jabref/logic/formatter/bibtexfields/NormalizeNamesFormatterTest.java

@@ -156,9 +156,14 @@ public void testPreposition() {
         assertEquals("von Zimmer, Hans and van Oberbergern, Michael and zu Berger, Kevin", formatter.format("Hans von Zimmer, Michael van Oberbergern, Kevin zu Berger"));
     }
 
+    @Test
+    public void testOneCommaUntouched() {
+        assertEquals("Canon der Barbar, Alexander der Große", formatter.format("Canon der Barbar, Alexander der Große"));
+    }
+
     @Test
     public void testAvoidNameAffixes() {
-        assertEquals("der Barbar, Canon and der Große, Alexander", formatter.format("Canon der Barbar, Alexander der Große"));
+        assertEquals("der Barbar, Canon and der Große, Alexander and der Alexander, Peter", formatter.format("Canon der Barbar, Alexander der Große, Peter der Alexander"));
     }
 
     @Test

src/test/java/org/jabref/logic/util/VersionTest.java

@@ -269,6 +269,13 @@ public void stableShouldNotBeUpdatedToAlpha() {
         assertFalse(stable.shouldBeUpdatedTo(alpha));
     }
 
+    @Test
+    public void stableShouldNotBeUpdatedToBeta() {
+        Version stable = Version.parse("3.8.2");
+        Version beta = Version.parse("4.0-beta");
+        assertFalse(stable.shouldBeUpdatedTo(beta));
+    }
+
     @Test
     public void alphaShouldBeUpdatedToStables() {
         Version alpha = Version.parse("2.8-alpha");

src/test/java/org/jabref/model/entry/AuthorListTest.java

@@ -5,11 +5,6 @@
 import org.junit.Assert;
 import org.junit.Test;
 
-/**
- * @author Christopher Oezbek <oezi@oezi.de>
- * @version 0.1 - Still fails for stuff in AuthorList that is ambiguous
- * @see AuthorList Class tested.
- */
 public class AuthorListTest {
 
     @SuppressWarnings("unused")
@@ -646,4 +641,22 @@ public void parseNameWithBraces() throws Exception {
         Assert.assertEquals(new AuthorList(expected), AuthorList.parse("H{e}lene Fiaux"));
     }
 
+    /**
+     * This tests the issue described at https://github.com/JabRef/jabref/pull/2669#issuecomment-288519458
+     */
+    @Test
+    public void correctNamesWithOneComma() throws Exception {
+        Author expected = new Author("Alexander der Große", "A. d. G.", null, "Canon der Barbar", null);
+        Assert.assertEquals(new AuthorList(expected), AuthorList.parse("Canon der Barbar, Alexander der Große"));
+
+        expected = new Author("Alexander H. G.", "A. H. G.", null, "Rinnooy Kan", null);
+        Assert.assertEquals(new AuthorList(expected), AuthorList.parse("Rinnooy Kan, Alexander H. G."));
+
+        expected = new Author("Alexander Hendrik George", "A. H. G.", null, "Rinnooy Kan", null);
+        Assert.assertEquals(new AuthorList(expected), AuthorList.parse("Rinnooy Kan, Alexander Hendrik George"));
+
+        expected = new Author("José María", "J. M.", null, "Rodriguez Fernandez", null);
+        Assert.assertEquals(new AuthorList(expected), AuthorList.parse("Rodriguez Fernandez, José María"));
+    }
+
 }