Add tests for month issue and strings (and some minor code impr…

src/main/java/org/jabref/logic/shared/DBMSProcessor.java

@@ -473,7 +473,10 @@ public List<BibEntry> getSharedEntries(List<Integer> sharedIDs) {
                     lastId = selectEntryResultSet.getInt("SHARED_ID");
                 }
 
-                bibEntry.setField(FieldFactory.parseField(selectEntryResultSet.getString("NAME")), Optional.ofNullable(selectEntryResultSet.getString("VALUE")), EntryEventSource.SHARED);
+                String value = selectEntryResultSet.getString("VALUE");
+                if (value != null) {
+                    bibEntry.setField(FieldFactory.parseField(selectEntryResultSet.getString("NAME")), value, EntryEventSource.SHARED);
+                }
             }
         } catch (SQLException e) {
             LOGGER.error("SQL Error", e);

src/main/java/org/jabref/logic/shared/DBMSSynchronizer.java

@@ -192,7 +192,10 @@ public void synchronizeLocalDatabase() {
                             localEntry.getSharedBibEntryData()
                                       .setVersion(sharedEntry.get().getSharedBibEntryData().getVersion());
                             for (Field field : sharedEntry.get().getFields()) {
-                                localEntry.setField(field, sharedEntry.get().getField(field), EntryEventSource.SHARED);
+                                Optional<String> sharedFieldValue = sharedEntry.get().getField(field);
+                                if (sharedFieldValue.isPresent()) {
+                                    localEntry.setField(field, sharedFieldValue.get(), EntryEventSource.SHARED);
+                                }
                             }
 
                             Set<Field> redundantLocalEntryFields = localEntry.getFields();

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

@@ -63,13 +63,44 @@ public class BibEntry implements Cloneable {
     private ObservableMap<Field, String> fields = FXCollections.observableMap(new ConcurrentHashMap<>());
     private String parsedSerialization = "";
     private String commentsBeforeEntry = "";
+
     /**
      * Marks whether the complete serialization, which was read from file, should be used.
      *
      * Is set to false, if parts of the entry change. This causes the entry to be serialized based on the internal state (and not based on the old serialization)
      */
     private boolean changed;
 
+    /**
+     * A simple builder to enable quick creation of BibEntry instances.
+     *
+     * Builder pattern as described in Item 2 of the book "Effective Java".
+     */
+    public static class Builder {
+
+        private BibEntry bibEntry;
+
+        public Builder(EntryType type) {
+            Objects.requireNonNull(type);
+            bibEntry = new BibEntry(type);
+        }
+
+        public Builder citeKey(String citeKey) {
+            bibEntry.setCiteKey(citeKey);
+            return this;
+        }
+
+        public Builder field(Field field, String value) {
+            bibEntry.setField(field, value);
+            return this;
+        }
+
+        public BibEntry build() {
+            return bibEntry;
+        }
+
+    }
+
     /**
      * Constructs a new BibEntry. The internal ID is set to IdGenerator.next()
      */
@@ -266,8 +297,9 @@ public String getId() {
     }
 
     /**
-     * Sets this entry's ID, provided the database containing it
-     * doesn't veto the change.
+     * Sets this entry's identifier (ID). It is used internally  to distinguish different BibTeX entries. It is <emph>not</emph> the BibTeX key. The BibTexKey is the {@link InternalField.KEY_FIELD}.
+     *
+     * The entry is also updated in the shared database - provided the database containing it doesn't veto the change.
      *
      * @param id The ID to be used
      */
@@ -523,13 +555,6 @@ public Optional<FieldChange> setField(Field field, String value, EntryEventSourc
         return Optional.of(change);
     }
 
-    public Optional<FieldChange> setField(Field field, Optional<String> value, EntryEventSource eventSource) {
-        if (value.isPresent()) {
-            return setField(field, value.get(), eventSource);
-        }
-        return Optional.empty();
-    }
-
     /**
      * Set a field, and notify listeners about the change.
      *

src/main/java/org/jabref/model/entry/field/InternalField.java

@@ -10,16 +10,17 @@
  * JabRef internal fields
  */
 public enum InternalField implements Field {
-    INTERNAL_ALL_FIELD("all"),
-    INTERNAL_ALL_TEXT_FIELDS_FIELD("all-text-fields"),
-    MARKED_INTERNAL("__markedentry"),
+    MARKED_INTERNAL("__markedentry"), // used in old versions of JabRef. Currently used for conversion only
     OWNER("owner"),
     TIMESTAMP("timestamp", FieldProperty.DATE),
     GROUPS("groups"),
     KEY_FIELD("bibtexkey"),
     TYPE_HEADER("entrytype"),
     OBSOLETE_TYPE_HEADER("bibtextype"),
-    BIBTEX_STRING("__string"),
+    // all field names starting with "Jabref-internal-" are not appearing in .bib files
+    BIBTEX_STRING("JabRef-internal-bibtex-string"), // marker that the content is just a BibTeX string
+    INTERNAL_ALL_FIELD("JabRef-internal-all"), // virtual field to denote "all fields"
+    INTERNAL_ALL_TEXT_FIELDS_FIELD("JabRef-internal-all-text-fields"), // virtual field to denote "all text fields"
     INTERNAL_ID_FIELD("JabRef-internal-id");
 
     private final String name;

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

@@ -289,7 +289,56 @@ void writeEntryWithCustomizedTypeAlsoWritesTypeDeclaration() throws Exception {
     }
 
     @Test
-    void roundtrip() throws Exception {
+    void writeEntryWithConstantMonthApril() throws Exception {
+        BibEntry entry = new BibEntry.Builder(StandardEntryType.Misc)
+                .field(StandardField.MONTH, "#apr#")
+                .build();
+        database.insertEntry(entry);
+
+        databaseWriter.savePartOfDatabase(bibtexContext, Collections.singletonList(entry));
+
+        assertEquals(OS.NEWLINE +
+                "@Misc{," + OS.NEWLINE +
+                "  month = apr," + OS.NEWLINE +
+                "}" + OS.NEWLINE + OS.NEWLINE +
+                "@Comment{jabref-meta: databaseType:bibtex;}" + OS.NEWLINE, stringWriter.toString());
+    }
+
+    @Test
+    void writeEntryWithMonthApril() throws Exception {
+        BibEntry entry = new BibEntry.Builder(StandardEntryType.Misc)
+                .field(StandardField.MONTH, "apr")
+                .build();
+        database.insertEntry(entry);
+
+        databaseWriter.savePartOfDatabase(bibtexContext, Collections.singletonList(entry));
+
+        assertEquals(OS.NEWLINE +
+                "@Misc{," + OS.NEWLINE +
+                "  month = {apr}," + OS.NEWLINE +
+                "}" + OS.NEWLINE + OS.NEWLINE +
+                "@Comment{jabref-meta: databaseType:bibtex;}" + OS.NEWLINE, stringWriter.toString());
+    }
+
+    @Test
+    void roundtripWithArticleMonths() throws Exception {
+        Path testBibtexFile = Paths.get("src/test/resources/testbib/articleWithMonths.bib");
+        Charset encoding = StandardCharsets.UTF_8;
+        ParserResult result = new BibtexParser(importFormatPreferences, fileMonitor).parse(Importer.getReader(testBibtexFile, encoding));
+
+        when(preferences.getEncoding()).thenReturn(encoding);
+        when(preferences.isSaveInOriginalOrder()).thenReturn(true);
+        BibDatabaseContext context = new BibDatabaseContext(result.getDatabase(), result.getMetaData(),
+                new Defaults(BibDatabaseMode.BIBTEX));
+
+        databaseWriter.savePartOfDatabase(context, result.getDatabase().getEntries());
+        try (Scanner scanner = new Scanner(testBibtexFile, encoding.name())) {
+            assertEquals(scanner.useDelimiter("\\A").next(), stringWriter.toString());
+        }
+    }
+
+    @Test
+    void roundtripWithComplexBib() throws Exception {
         Path testBibtexFile = Paths.get("src/test/resources/testbib/complex.bib");
         Charset encoding = StandardCharsets.UTF_8;
         ParserResult result = new BibtexParser(importFormatPreferences, fileMonitor).parse(Importer.getReader(testBibtexFile, encoding));

src/test/java/org/jabref/logic/importer/fileformat/BibtexParserTest.java

@@ -26,6 +26,7 @@
 import org.jabref.model.entry.BibEntryType;
 import org.jabref.model.entry.BibtexString;
 import org.jabref.model.entry.Date;
+import org.jabref.model.entry.Month;
 import org.jabref.model.entry.field.BibField;
 import org.jabref.model.entry.field.FieldPriority;
 import org.jabref.model.entry.field.InternalField;
@@ -1711,4 +1712,78 @@ void parseYear() throws Exception {
 
         assertEquals(new Date(2003), result.get().getPublicationDate().get());
     }
+
+    @Test
+    void parseEntryUsingStringConstantsForTwoAuthorsWithEtAsStringConstant() throws ParseException {
+        // source of the example: /~https://github.com/JabRef/help.jabref.org/blob/gh-pages/en/Strings.md
+        Collection<BibEntry> parsed = parser
+                .parseEntries("@String { kopp = \"Kopp, Oliver\" }" +
+                        "@String { kubovy = \"Kubovy, Jan\" }" +
+                        "@String { et = \" and \" }" +
+                        "@Misc{m1, author = kopp # et # kubovy }" );
+
+        BibEntry expectedEntry = new BibEntry.Builder(StandardEntryType.Misc)
+                .citeKey("m1")
+                .field(StandardField.AUTHOR, "#kopp##et##kubovy#")
+                .build();
+
+        assertEquals(List.of(expectedEntry), parsed);
+    }
+
+    @Test
+    void parseStringConstantsForTwoAuthorsHasCorrectBibTeXEntry() throws ParseException {
+        // source of the example: /~https://github.com/JabRef/help.jabref.org/blob/gh-pages/en/Strings.md
+        Collection<BibEntry> parsed = parser
+                .parseEntries("@String { kopp = \"Kopp, Oliver\" }" +
+                        "@String { kubovy = \"Kubovy, Jan\" }" +
+                        "@String { et = \" and \" }" +
+                        "@Misc{m2, author = kopp # \" and \" # kubovy }" );
+
+        BibEntry expectedEntry = new BibEntry.Builder(StandardEntryType.Misc)
+                .citeKey("m2")
+                .field(StandardField.AUTHOR, "#kopp# and #kubovy#")
+                .build();
+
+        assertEquals(List.of(expectedEntry), parsed);
+    }
+
+    @Test
+    void parseStringConstantsForTwoAuthors() throws ParseException {
+        // source of the example: /~https://github.com/JabRef/help.jabref.org/blob/gh-pages/en/Strings.md
+        Collection<BibEntry> parsed = parser
+                .parseEntries("@String { kopp = \"Kopp, Oliver\" }" +
+                        "@String { kubovy = \"Kubovy, Jan\" }" +
+                        "@String { et = \" and \" }" +
+                        "@Misc{m2, author = kopp # \" and \" # kubovy }" );
+
+        assertEquals("#kopp# and #kubovy#", parsed.iterator().next().getField(StandardField.AUTHOR).get());
+    }
+
+    @Test
+    void textAprilIsParsedAsMonthApril() throws ParseException {
+        Optional<BibEntry> result = parser.parseSingleEntry("@Misc{m, month = \"apr\" }" );
+
+        assertEquals(Month.APRIL, result.get().getMonth().get());
+    }
+
+    @Test
+    void textAprilIsDisplayedAsConstant() throws ParseException {
+        Optional<BibEntry> result = parser.parseSingleEntry("@Misc{m, month = \"apr\" }" );
+
+        assertEquals("apr", result.get().getField(StandardField.MONTH).get());
+    }
+
+    @Test
+    void bibTeXConstantAprilIsParsedAsMonthApril() throws ParseException {
+        Optional<BibEntry> result = parser.parseSingleEntry("@Misc{m, month = apr }" );
+
+        assertEquals(Month.APRIL, result.get().getMonth().get());
+    }
+
+    @Test
+    void bibTeXConstantAprilIsDisplayedAsConstant() throws ParseException {
+        Optional<BibEntry> result = parser.parseSingleEntry("@Misc{m, month = apr }" );
+
+        assertEquals("#apr#", result.get().getField(StandardField.MONTH).get());
+    }
 }

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

@@ -9,35 +9,117 @@
 public class BibtexStringTest {
 
     @Test
-    public void test() {
+    public void initalizationWorksCorrectly() {
         // Instantiate
         BibtexString bs = new BibtexString("AAA", "An alternative action");
-        bs.setId("ID");
-        assertEquals("ID", bs.getId());
         assertEquals("AAA", bs.getName());
         assertEquals("An alternative action", bs.getContent());
         assertEquals(BibtexString.Type.OTHER, bs.getType());
+    }
+
+    @Test
+    public void idIsUpdatedAtSetId() {
+        // Instantiate
+        BibtexString bs = new BibtexString("AAA", "An alternative action");
+        bs.setId("ID");
+        assertEquals("ID", bs.getId());
+    }
+
+    @Test
+    public void cloningDoesNotChangeContents() {
+        BibtexString bs = new BibtexString("AAA", "An alternative action");
+        bs.setId("ID");
 
-        // Clone
         BibtexString bs2 = (BibtexString) bs.clone();
+
         assertEquals(bs.getId(), bs2.getId());
         assertEquals(bs.getName(), bs2.getName());
         assertEquals(bs.getContent(), bs2.getContent());
         assertEquals(bs.getType(), bs2.getType());
+    }
+
+    @Test
+    public void clonedBibtexStringEqualsOriginalString() {
+        BibtexString bibtexString = new BibtexString("AAA", "An alternative action");
+        bibtexString.setId("ID");
+
+        BibtexString clone = (BibtexString) bibtexString.clone();
+
+        assertEquals(bibtexString, clone);
+    }
 
-        // Change cloned BibtexString
+    @Test
+    public void usingTheIdGeneratorDoesNotHitTheOriginalId() {
+        // Instantiate
+        BibtexString bs = new BibtexString("AAA", "An alternative action");
+        bs.setId("ID");
+        BibtexString bs2 = (BibtexString) bs.clone();
         bs2.setId(IdGenerator.next());
         assertNotEquals(bs.getId(), bs2.getId());
+    }
+
+    @Test
+    public void settingFieldsInACloneWorks() {
+        // Instantiate
+        BibtexString bs = new BibtexString("AAA", "An alternative action");
+        bs.setId("ID");
+        BibtexString bs2 = (BibtexString) bs.clone();
+
+        bs2.setId(IdGenerator.next());
         bs2.setName("aOG");
         assertEquals(BibtexString.Type.AUTHOR, bs2.getType());
+
         bs2.setContent("Oscar Gustafsson");
         assertEquals("aOG", bs2.getName());
         assertEquals("Oscar Gustafsson", bs2.getContent());
     }
 
+    @Test
+    public void modifyingACloneDoesNotModifyTheOriginalEntry() {
+        // Instantiate
+        BibtexString original = new BibtexString("AAA", "An alternative action");
+        original.setId("ID");
+
+        BibtexString clone = (BibtexString) original.clone();
+        clone.setId(IdGenerator.next());
+        clone.setName("aOG");
+        clone.setContent("Oscar Gustafsson");
+
+        assertEquals("AAA", original.getName());
+        assertEquals("An alternative action", original.getContent());
+    }
+
     @Test
     public void getContentNeverReturnsNull() {
         BibtexString bs = new BibtexString("SomeName", null);
         assertNotNull(bs.getContent());
     }
+
+    @Test
+    public void authorTypeCorrectlyDetermined() {
+        // Source of the example: https://help.jabref.org/en/Strings
+        BibtexString bibtexString = new BibtexString("aKopp", "KoppOliver");
+        assertEquals(BibtexString.Type.AUTHOR, bibtexString.getType());
+    }
+
+    @Test
+    public void institutionTypeCorrectlyDetermined() {
+        // Source of the example: https://help.jabref.org/en/Strings
+        BibtexString bibtexString = new BibtexString("iMIT", "{Massachusetts Institute of Technology ({MIT})}");
+        assertEquals(BibtexString.Type.INSTITUTION, bibtexString.getType());
+    }
+
+    @Test
+    public void otherTypeCorrectlyDeterminedForLowerCase() {
+        // Source of the example: https://help.jabref.org/en/Strings
+        BibtexString bibtexString = new BibtexString("anct", "Anecdote");
+        assertEquals(BibtexString.Type.OTHER, bibtexString.getType());
+    }
+
+    @Test
+    public void otherTypeCorrectlyDeterminedForUpperCase() {
+        // Source of the example: https://help.jabref.org/en/Strings
+        BibtexString bibtexString = new BibtexString("lTOSCA", "Topology and Orchestration Specification for Cloud Applications");
+        assertEquals(BibtexString.Type.OTHER, bibtexString.getType());
+    }
 }

src/test/resources/testbib/articleWithMonths.bib

@@ -0,0 +1,10 @@
+% Encoding: UTF-8
+@Article{constant,
+	month = apr
+}
+
+@Article{text,
+	month = {apr}
+}
+
+@Comment{jabref-meta: databaseType:bibtex;}