From aa35758cb0a47c679d5cb84578f75b9fa28f5ce0 Mon Sep 17 00:00:00 2001 From: Nitin Suresh Date: Sat, 20 Apr 2024 20:49:02 -0700 Subject: [PATCH 1/5] add test cases for v2 custom entrytype serialization --- .../exporter/MetaDataSerializerTest.java | 53 +++++++++++++++++++ 1 file changed, 53 insertions(+) diff --git a/src/test/java/org/jabref/logic/exporter/MetaDataSerializerTest.java b/src/test/java/org/jabref/logic/exporter/MetaDataSerializerTest.java index 0bdae1a7311..0da0d6c7815 100644 --- a/src/test/java/org/jabref/logic/exporter/MetaDataSerializerTest.java +++ b/src/test/java/org/jabref/logic/exporter/MetaDataSerializerTest.java @@ -17,6 +17,7 @@ import org.jabref.model.entry.BibEntryTypeBuilder; import org.jabref.model.entry.field.BibField; import org.jabref.model.entry.field.FieldPriority; +import org.jabref.model.entry.field.FieldProperty; import org.jabref.model.entry.field.OrFields; import org.jabref.model.entry.field.StandardField; import org.jabref.model.entry.field.UnknownField; @@ -140,4 +141,56 @@ public static Stream serializeCustomizedEntryType() { void serializeCustomizedEntryType(BibEntryTypeBuilder bibEntryTypeBuilder, String expected) { assertEquals(expected, MetaDataSerializer.serializeCustomEntryTypes(bibEntryTypeBuilder.build())); } + + public static Stream serializeCustomizedEntryTypeV2() { + return Stream.of( + Arguments.of( + new BibEntryTypeBuilder() + .withType(new UnknownEntryType("test")) + .withRequiredFields(StandardField.AUTHOR, StandardField.TITLE), + "jabref-entrytype-v2: test: req[author;title] opt[]" + ), + Arguments.of( + new BibEntryTypeBuilder() + .withType(new UnknownEntryType("test")) + .withRequiredFields(StandardField.AUTHOR) + .withImportantFields(StandardField.TITLE), + "jabref-entrytype-v2: test: req[author] opt[title]" + ), + Arguments.of( + new BibEntryTypeBuilder() + .withType(new UnknownEntryType("test")) + .withRequiredFields(UnknownField.fromDisplayName("Test1"), UnknownField.fromDisplayName("Test2")), + "jabref-entrytype-v2: test: req[Test1;Test2] opt[]" + ), + Arguments.of( + new BibEntryTypeBuilder() + .withType(new UnknownEntryType("test")) + .withRequiredFields(UnknownField.fromDisplayName("tEST"), UnknownField.fromDisplayName("tEsT2")), + "jabref-entrytype-v2: test: req[tEST;tEsT2] opt[]" + ), + Arguments.of( + new BibEntryTypeBuilder() + .withType(new UnknownEntryType("person")) + .withRequiredFields(new UnknownField("Name", FieldProperty.PERSON_NAMES)) + .withImportantFields( + new UnknownField("Googlescholar", FieldProperty.EXTERNAL), + new UnknownField("Orcid", FieldProperty.EXTERNAL) + ), + "jabref-entrytype-v2: person: req[Name|PERSON_NAMES] opt[Googlescholar|EXTERNAL;Orcid|EXTERNAL]" + ), + Arguments.of( + new BibEntryTypeBuilder() + .withType(new UnknownEntryType("test")) + .withRequiredFields(new UnknownField("comment", "comment", FieldProperty.COMMENT, FieldProperty.MULTILINE_TEXT)), + "jabref-entrytype-v2: test: req[comment|COMMENT,MULTILINE_TEXT] opt[]" + ) + ); + } + + @ParameterizedTest + @MethodSource + void serializeCustomizedEntryTypeV2(BibEntryTypeBuilder bibEntryTypeBuilder, String expected) { + assertEquals(expected, MetaDataSerializer.serializeCustomEntryTypes(bibEntryTypeBuilder.build())); + } } From fce24fb6ceb7b23c42146ed90884d3416038aca8 Mon Sep 17 00:00:00 2001 From: Nitin Suresh Date: Tue, 23 Apr 2024 21:09:20 -0700 Subject: [PATCH 2/5] add v2 serializer for custom entry types --- .../logic/exporter/MetaDataSerializer.java | 16 +++++++ .../model/entry/field/FieldFactory.java | 42 +++++++++++++++++++ .../org/jabref/model/metadata/MetaData.java | 1 + .../exporter/MetaDataSerializerTest.java | 8 ++-- 4 files changed, 63 insertions(+), 4 deletions(-) diff --git a/src/main/java/org/jabref/logic/exporter/MetaDataSerializer.java b/src/main/java/org/jabref/logic/exporter/MetaDataSerializer.java index de5d3304477..d635b1aeddb 100644 --- a/src/main/java/org/jabref/logic/exporter/MetaDataSerializer.java +++ b/src/main/java/org/jabref/logic/exporter/MetaDataSerializer.java @@ -168,4 +168,20 @@ public static String serializeCustomEntryTypes(BibEntryType entryType) { builder.append("]"); return builder.toString(); } + + public static String serializeCustomEntryTypesV2(BibEntryType entryType) { + StringBuilder builder = new StringBuilder(); + builder.append(MetaData.ENTRYTYPE_FLAG_V2); + builder.append(entryType.getType().getName()); + builder.append(": req["); + builder.append(FieldFactory.serializeOrFieldsListV2(entryType.getRequiredFields())); + builder.append("] opt["); + builder.append(FieldFactory.serializeFieldsListV2( + entryType.getOptionalFields() + .stream() + .map(BibField::field) + .collect(Collectors.toList()))); + builder.append("]"); + return builder.toString(); + } } diff --git a/src/main/java/org/jabref/model/entry/field/FieldFactory.java b/src/main/java/org/jabref/model/entry/field/FieldFactory.java index 5c0a9036d2b..0150af0b401 100644 --- a/src/main/java/org/jabref/model/entry/field/FieldFactory.java +++ b/src/main/java/org/jabref/model/entry/field/FieldFactory.java @@ -26,6 +26,8 @@ public class FieldFactory { */ private static final String FIELD_OR_SEPARATOR = "/"; private static final String DELIMITER = ";"; + private static final String FIELD_PROPERTY_SEPARATOR = ","; + private static final String FIELD_NAME_PROPERTY_SEPARATOR = "|"; public static String serializeOrFields(Field... fields) { return serializeOrFields(new OrFields(fields)); @@ -45,10 +47,37 @@ public static String serializeOrFields(OrFields fields) { .collect(Collectors.joining(FIELD_OR_SEPARATOR)); } + public static String serializeOrFieldsV2(OrFields fields) { + return fields.getFields().stream() + .map(field -> { + if (field instanceof UnknownField unknownField) { + return serializeUnknownField(unknownField); + } else { + // In all fields known to JabRef, the name is used - JabRef knows better than the user how to case the field + return field.getName(); + } + }) + .collect(Collectors.joining(FIELD_OR_SEPARATOR)); + } + + private static String serializeUnknownField(UnknownField unknownField) { + // In case a user has put a user-defined field, the casing of that field is kept + String displayName = unknownField.getDisplayName(); + String fieldProperties = unknownField.getProperties().stream() + .map(Enum::name) + .collect(Collectors.joining(FIELD_PROPERTY_SEPARATOR)); + + return displayName + FIELD_NAME_PROPERTY_SEPARATOR + fieldProperties; + } + public static String serializeOrFieldsList(Set fields) { return fields.stream().map(FieldFactory::serializeOrFields).collect(Collectors.joining(DELIMITER)); } + public static String serializeOrFieldsListV2(Set fields) { + return fields.stream().map(FieldFactory::serializeOrFieldsV2).collect(Collectors.joining(DELIMITER)); + } + public static List getNotTextFieldNames() { return Arrays.asList(StandardField.DOI, StandardField.FILE, StandardField.URL, StandardField.URI, StandardField.ISBN, StandardField.ISSN, StandardField.MONTH, StandardField.DATE, StandardField.YEAR); } @@ -93,6 +122,19 @@ public static String serializeFieldsList(Collection fields) { .collect(Collectors.joining(DELIMITER)); } + public static String serializeFieldsListV2(Collection fields) { + return fields.stream() + .map(field -> { + if (field instanceof UnknownField unknownField) { + return serializeUnknownField(unknownField); + } else { + // In all fields known to JabRef, the name is used - JabRef knows better than the user how to case the field + return field.getName(); + } + }) + .collect(Collectors.joining(DELIMITER)); + } + /** * Type T is an entry type and is used to direct the mapping to the Java field class. * This somehow acts as filter, BibLaTeX "APA" entry type has field "article", but we want to have StandardField (if not explicitly requested otherwise) diff --git a/src/main/java/org/jabref/model/metadata/MetaData.java b/src/main/java/org/jabref/model/metadata/MetaData.java index 207e151f740..5a21052e9d4 100644 --- a/src/main/java/org/jabref/model/metadata/MetaData.java +++ b/src/main/java/org/jabref/model/metadata/MetaData.java @@ -37,6 +37,7 @@ public class MetaData { public static final String META_FLAG = "jabref-meta: "; public static final String ENTRYTYPE_FLAG = "jabref-entrytype: "; + public static final String ENTRYTYPE_FLAG_V2 = "jabref-entrytype-v2: "; public static final String SAVE_ORDER_CONFIG = "saveOrderConfig"; // ToDo: Rename in next major version to saveOrder, adapt testbibs public static final String SAVE_ACTIONS = "saveActions"; public static final String PREFIX_KEYPATTERN = "keypattern_"; diff --git a/src/test/java/org/jabref/logic/exporter/MetaDataSerializerTest.java b/src/test/java/org/jabref/logic/exporter/MetaDataSerializerTest.java index 0da0d6c7815..604210f1591 100644 --- a/src/test/java/org/jabref/logic/exporter/MetaDataSerializerTest.java +++ b/src/test/java/org/jabref/logic/exporter/MetaDataSerializerTest.java @@ -161,13 +161,13 @@ public static Stream serializeCustomizedEntryTypeV2() { new BibEntryTypeBuilder() .withType(new UnknownEntryType("test")) .withRequiredFields(UnknownField.fromDisplayName("Test1"), UnknownField.fromDisplayName("Test2")), - "jabref-entrytype-v2: test: req[Test1;Test2] opt[]" + "jabref-entrytype-v2: test: req[Test1|CUSTOM_FIELD;Test2|CUSTOM_FIELD] opt[]" ), Arguments.of( new BibEntryTypeBuilder() .withType(new UnknownEntryType("test")) .withRequiredFields(UnknownField.fromDisplayName("tEST"), UnknownField.fromDisplayName("tEsT2")), - "jabref-entrytype-v2: test: req[tEST;tEsT2] opt[]" + "jabref-entrytype-v2: test: req[tEST|CUSTOM_FIELD;tEsT2|CUSTOM_FIELD] opt[]" ), Arguments.of( new BibEntryTypeBuilder() @@ -183,7 +183,7 @@ public static Stream serializeCustomizedEntryTypeV2() { new BibEntryTypeBuilder() .withType(new UnknownEntryType("test")) .withRequiredFields(new UnknownField("comment", "comment", FieldProperty.COMMENT, FieldProperty.MULTILINE_TEXT)), - "jabref-entrytype-v2: test: req[comment|COMMENT,MULTILINE_TEXT] opt[]" + "jabref-entrytype-v2: test: req[comment|MULTILINE_TEXT,COMMENT] opt[]" ) ); } @@ -191,6 +191,6 @@ public static Stream serializeCustomizedEntryTypeV2() { @ParameterizedTest @MethodSource void serializeCustomizedEntryTypeV2(BibEntryTypeBuilder bibEntryTypeBuilder, String expected) { - assertEquals(expected, MetaDataSerializer.serializeCustomEntryTypes(bibEntryTypeBuilder.build())); + assertEquals(expected, MetaDataSerializer.serializeCustomEntryTypesV2(bibEntryTypeBuilder.build())); } } From eb040b567844657c2c76b498123285b74b300cae Mon Sep 17 00:00:00 2001 From: Nitin Suresh Date: Thu, 25 Apr 2024 23:10:10 -0700 Subject: [PATCH 3/5] update custom entrytype parser to support v2 comments --- .../logic/importer/util/MetaDataParser.java | 3 ++ .../model/entry/field/FieldFactory.java | 29 +++++++++++ .../exporter/MetaDataSerializerTest.java | 14 ++++-- .../importer/util/MetaDataParserTest.java | 48 +++++++++++++++++++ 4 files changed, 90 insertions(+), 4 deletions(-) diff --git a/src/main/java/org/jabref/logic/importer/util/MetaDataParser.java b/src/main/java/org/jabref/logic/importer/util/MetaDataParser.java index 3ee870a9697..e966c1f1278 100644 --- a/src/main/java/org/jabref/logic/importer/util/MetaDataParser.java +++ b/src/main/java/org/jabref/logic/importer/util/MetaDataParser.java @@ -46,6 +46,9 @@ public MetaDataParser(FileUpdateMonitor fileMonitor) { public static Optional parseCustomEntryType(String comment) { String rest = comment.substring(MetaData.ENTRYTYPE_FLAG.length()); + if (comment.startsWith(MetaData.ENTRYTYPE_FLAG_V2)) { + rest = comment.substring(MetaData.ENTRYTYPE_FLAG_V2.length()); + } int indexEndOfName = rest.indexOf(':'); if (indexEndOfName < 0) { return Optional.empty(); diff --git a/src/main/java/org/jabref/model/entry/field/FieldFactory.java b/src/main/java/org/jabref/model/entry/field/FieldFactory.java index 0150af0b401..90956bd4cee 100644 --- a/src/main/java/org/jabref/model/entry/field/FieldFactory.java +++ b/src/main/java/org/jabref/model/entry/field/FieldFactory.java @@ -12,6 +12,7 @@ import java.util.Set; import java.util.TreeSet; import java.util.function.Predicate; +import java.util.regex.Pattern; import java.util.stream.Collectors; import org.jabref.model.entry.types.EntryType; @@ -64,9 +65,14 @@ private static String serializeUnknownField(UnknownField unknownField) { // In case a user has put a user-defined field, the casing of that field is kept String displayName = unknownField.getDisplayName(); String fieldProperties = unknownField.getProperties().stream() + .filter(e -> e != FieldProperty.CUSTOM_FIELD) .map(Enum::name) .collect(Collectors.joining(FIELD_PROPERTY_SEPARATOR)); + if (fieldProperties.isBlank()) { + return displayName; + } + return displayName + FIELD_NAME_PROPERTY_SEPARATOR + fieldProperties; } @@ -145,6 +151,29 @@ public static Field parseField(T type, String fieldName) { String username = fieldName.substring("comment-".length()); return new UserSpecificCommentField(username); } + + if (fieldName.contains(FIELD_NAME_PROPERTY_SEPARATOR)) { + String[] components = fieldName.split(Pattern.quote(FIELD_NAME_PROPERTY_SEPARATOR)); + + if (components.length == 2) { + String unknownFieldName = components[0]; + String[] fieldProperties = components[1].split(Pattern.quote(FIELD_PROPERTY_SEPARATOR)); + + if (fieldProperties.length == 0) { + return UnknownField.fromDisplayName(unknownFieldName); + } else if (fieldProperties.length == 1) { + return new UnknownField(unknownFieldName, unknownFieldName, FieldProperty.valueOf(fieldProperties[0])); + } else { + FieldProperty firstProperty = FieldProperty.valueOf(fieldProperties[0]); + FieldProperty[] restProperties = Arrays.stream(fieldProperties, 1, fieldProperties.length) + .map(FieldProperty::valueOf) + .toArray(FieldProperty[]::new); + + return new UnknownField(unknownFieldName, unknownFieldName, firstProperty, restProperties); + } + } + } + return OptionalUtil.orElse( OptionalUtil.orElse( OptionalUtil.orElse( diff --git a/src/test/java/org/jabref/logic/exporter/MetaDataSerializerTest.java b/src/test/java/org/jabref/logic/exporter/MetaDataSerializerTest.java index 604210f1591..c892f7fa1a1 100644 --- a/src/test/java/org/jabref/logic/exporter/MetaDataSerializerTest.java +++ b/src/test/java/org/jabref/logic/exporter/MetaDataSerializerTest.java @@ -161,13 +161,13 @@ public static Stream serializeCustomizedEntryTypeV2() { new BibEntryTypeBuilder() .withType(new UnknownEntryType("test")) .withRequiredFields(UnknownField.fromDisplayName("Test1"), UnknownField.fromDisplayName("Test2")), - "jabref-entrytype-v2: test: req[Test1|CUSTOM_FIELD;Test2|CUSTOM_FIELD] opt[]" + "jabref-entrytype-v2: test: req[Test1;Test2] opt[]" ), Arguments.of( new BibEntryTypeBuilder() .withType(new UnknownEntryType("test")) .withRequiredFields(UnknownField.fromDisplayName("tEST"), UnknownField.fromDisplayName("tEsT2")), - "jabref-entrytype-v2: test: req[tEST|CUSTOM_FIELD;tEsT2|CUSTOM_FIELD] opt[]" + "jabref-entrytype-v2: test: req[tEST;tEsT2] opt[]" ), Arguments.of( new BibEntryTypeBuilder() @@ -182,8 +182,14 @@ public static Stream serializeCustomizedEntryTypeV2() { Arguments.of( new BibEntryTypeBuilder() .withType(new UnknownEntryType("test")) - .withRequiredFields(new UnknownField("comment", "comment", FieldProperty.COMMENT, FieldProperty.MULTILINE_TEXT)), - "jabref-entrytype-v2: test: req[comment|MULTILINE_TEXT,COMMENT] opt[]" + .withRequiredFields(new UnknownField("custom1", "custom1", FieldProperty.MULTILINE_TEXT, FieldProperty.COMMENT, FieldProperty.EXTERNAL)), + "jabref-entrytype-v2: test: req[custom1|EXTERNAL,MULTILINE_TEXT,COMMENT] opt[]" + ), + Arguments.of( + new BibEntryTypeBuilder() + .withType(new UnknownEntryType("test")) + .withRequiredFields(new UnknownField("custom2", "custom2")), + "jabref-entrytype-v2: test: req[custom2] opt[]" ) ); } diff --git a/src/test/java/org/jabref/logic/importer/util/MetaDataParserTest.java b/src/test/java/org/jabref/logic/importer/util/MetaDataParserTest.java index d043c51fe79..31fe1cefcb0 100644 --- a/src/test/java/org/jabref/logic/importer/util/MetaDataParserTest.java +++ b/src/test/java/org/jabref/logic/importer/util/MetaDataParserTest.java @@ -10,6 +10,7 @@ import org.jabref.logic.exporter.MetaDataSerializerTest; import org.jabref.logic.formatter.casechanger.LowerCaseFormatter; import org.jabref.model.entry.BibEntryTypeBuilder; +import org.jabref.model.entry.field.FieldProperty; import org.jabref.model.entry.field.StandardField; import org.jabref.model.entry.field.UnknownField; import org.jabref.model.entry.types.UnknownEntryType; @@ -56,6 +57,53 @@ public static Stream parseCustomizedEntryType() { .withType(new UnknownEntryType("test")) .withRequiredFields(UnknownField.fromDisplayName("tEST"), UnknownField.fromDisplayName("tEsT2")), "jabref-entrytype: test: req[tEST;tEsT2] opt[]" + ), + Arguments.of( + new BibEntryTypeBuilder() + .withType(new UnknownEntryType("test")) + .withRequiredFields(StandardField.AUTHOR, StandardField.TITLE), + "jabref-entrytype-v2: test: req[author;title] opt[]" + ), + Arguments.of( + new BibEntryTypeBuilder() + .withType(new UnknownEntryType("test")) + .withRequiredFields(StandardField.AUTHOR) + .withImportantFields(StandardField.TITLE), + "jabref-entrytype-v2: test: req[author] opt[title]" + ), + Arguments.of( + new BibEntryTypeBuilder() + .withType(new UnknownEntryType("test")) + .withRequiredFields(UnknownField.fromDisplayName("Test1"), UnknownField.fromDisplayName("Test2")), + "jabref-entrytype-v2: test: req[Test1;Test2] opt[]" + ), + Arguments.of( + new BibEntryTypeBuilder() + .withType(new UnknownEntryType("test")) + .withRequiredFields(UnknownField.fromDisplayName("tEST"), UnknownField.fromDisplayName("tEsT2")), + "jabref-entrytype-v2: test: req[tEST;tEsT2] opt[]" + ), + Arguments.of( + new BibEntryTypeBuilder() + .withType(new UnknownEntryType("person")) + .withRequiredFields(new UnknownField("Name", FieldProperty.PERSON_NAMES)) + .withImportantFields( + new UnknownField("Googlescholar", FieldProperty.EXTERNAL), + new UnknownField("Orcid", FieldProperty.EXTERNAL) + ), + "jabref-entrytype-v2: person: req[Name|PERSON_NAMES] opt[Googlescholar|EXTERNAL;Orcid|EXTERNAL]" + ), + Arguments.of( + new BibEntryTypeBuilder() + .withType(new UnknownEntryType("test")) + .withRequiredFields(new UnknownField("custom1", "custom1", FieldProperty.MULTILINE_TEXT, FieldProperty.COMMENT, FieldProperty.EXTERNAL)), + "jabref-entrytype-v2: test: req[custom1|MULTILINE_TEXT,COMMENT,EXTERNAL] opt[]" + ), + Arguments.of( + new BibEntryTypeBuilder() + .withType(new UnknownEntryType("test")) + .withRequiredFields(new UnknownField("custom2", "custom2")), + "jabref-entrytype-v2: test: req[custom2] opt[]" ) ); } From c5167f3730792a9162889a748e2f38a190890756 Mon Sep 17 00:00:00 2001 From: Nitin Suresh Date: Sun, 26 May 2024 21:29:16 -0700 Subject: [PATCH 4/5] update v2 entrytype flag --- .../java/org/jabref/model/metadata/MetaData.java | 2 +- .../logic/exporter/MetaDataSerializerTest.java | 14 +++++++------- .../logic/importer/util/MetaDataParserTest.java | 14 +++++++------- 3 files changed, 15 insertions(+), 15 deletions(-) diff --git a/src/main/java/org/jabref/model/metadata/MetaData.java b/src/main/java/org/jabref/model/metadata/MetaData.java index 7c0c21a6822..c19c674db29 100644 --- a/src/main/java/org/jabref/model/metadata/MetaData.java +++ b/src/main/java/org/jabref/model/metadata/MetaData.java @@ -38,7 +38,7 @@ public class MetaData { public static final String META_FLAG = "jabref-meta: "; public static final String ENTRYTYPE_FLAG = "jabref-entrytype: "; - public static final String ENTRYTYPE_FLAG_V2 = "jabref-entrytype-v2: "; + public static final String ENTRYTYPE_FLAG_V2 = "v2-jabref-entrytype: "; public static final String SAVE_ORDER_CONFIG = "saveOrderConfig"; // ToDo: Rename in next major version to saveOrder, adapt testbibs public static final String SAVE_ACTIONS = "saveActions"; public static final String PREFIX_KEYPATTERN = "keypattern_"; diff --git a/src/test/java/org/jabref/logic/exporter/MetaDataSerializerTest.java b/src/test/java/org/jabref/logic/exporter/MetaDataSerializerTest.java index c2c0dfaaf8c..17e694157d9 100644 --- a/src/test/java/org/jabref/logic/exporter/MetaDataSerializerTest.java +++ b/src/test/java/org/jabref/logic/exporter/MetaDataSerializerTest.java @@ -148,26 +148,26 @@ public static Stream serializeCustomizedEntryTypeV2() { new BibEntryTypeBuilder() .withType(new UnknownEntryType("test")) .withRequiredFields(StandardField.AUTHOR, StandardField.TITLE), - "jabref-entrytype-v2: test: req[author;title] opt[]" + "v2-jabref-entrytype: test: req[author;title] opt[]" ), Arguments.of( new BibEntryTypeBuilder() .withType(new UnknownEntryType("test")) .withRequiredFields(StandardField.AUTHOR) .withImportantFields(StandardField.TITLE), - "jabref-entrytype-v2: test: req[author] opt[title]" + "v2-jabref-entrytype: test: req[author] opt[title]" ), Arguments.of( new BibEntryTypeBuilder() .withType(new UnknownEntryType("test")) .withRequiredFields(UnknownField.fromDisplayName("Test1"), UnknownField.fromDisplayName("Test2")), - "jabref-entrytype-v2: test: req[Test1;Test2] opt[]" + "v2-jabref-entrytype: test: req[Test1;Test2] opt[]" ), Arguments.of( new BibEntryTypeBuilder() .withType(new UnknownEntryType("test")) .withRequiredFields(UnknownField.fromDisplayName("tEST"), UnknownField.fromDisplayName("tEsT2")), - "jabref-entrytype-v2: test: req[tEST;tEsT2] opt[]" + "v2-jabref-entrytype: test: req[tEST;tEsT2] opt[]" ), Arguments.of( new BibEntryTypeBuilder() @@ -177,19 +177,19 @@ public static Stream serializeCustomizedEntryTypeV2() { new UnknownField("Googlescholar", FieldProperty.EXTERNAL), new UnknownField("Orcid", FieldProperty.EXTERNAL) ), - "jabref-entrytype-v2: person: req[Name|PERSON_NAMES] opt[Googlescholar|EXTERNAL;Orcid|EXTERNAL]" + "v2-jabref-entrytype: person: req[Name|PERSON_NAMES] opt[Googlescholar|EXTERNAL;Orcid|EXTERNAL]" ), Arguments.of( new BibEntryTypeBuilder() .withType(new UnknownEntryType("test")) .withRequiredFields(new UnknownField("custom1", "custom1", FieldProperty.MULTILINE_TEXT, FieldProperty.COMMENT, FieldProperty.EXTERNAL)), - "jabref-entrytype-v2: test: req[custom1|EXTERNAL,MULTILINE_TEXT,COMMENT] opt[]" + "v2-jabref-entrytype: test: req[custom1|EXTERNAL,MULTILINE_TEXT,COMMENT] opt[]" ), Arguments.of( new BibEntryTypeBuilder() .withType(new UnknownEntryType("test")) .withRequiredFields(new UnknownField("custom2", "custom2")), - "jabref-entrytype-v2: test: req[custom2] opt[]" + "v2-jabref-entrytype: test: req[custom2] opt[]" ) ); } diff --git a/src/test/java/org/jabref/logic/importer/util/MetaDataParserTest.java b/src/test/java/org/jabref/logic/importer/util/MetaDataParserTest.java index 31fe1cefcb0..2db887652b2 100644 --- a/src/test/java/org/jabref/logic/importer/util/MetaDataParserTest.java +++ b/src/test/java/org/jabref/logic/importer/util/MetaDataParserTest.java @@ -62,26 +62,26 @@ public static Stream parseCustomizedEntryType() { new BibEntryTypeBuilder() .withType(new UnknownEntryType("test")) .withRequiredFields(StandardField.AUTHOR, StandardField.TITLE), - "jabref-entrytype-v2: test: req[author;title] opt[]" + "v2-jabref-entrytype: test: req[author;title] opt[]" ), Arguments.of( new BibEntryTypeBuilder() .withType(new UnknownEntryType("test")) .withRequiredFields(StandardField.AUTHOR) .withImportantFields(StandardField.TITLE), - "jabref-entrytype-v2: test: req[author] opt[title]" + "v2-jabref-entrytype: test: req[author] opt[title]" ), Arguments.of( new BibEntryTypeBuilder() .withType(new UnknownEntryType("test")) .withRequiredFields(UnknownField.fromDisplayName("Test1"), UnknownField.fromDisplayName("Test2")), - "jabref-entrytype-v2: test: req[Test1;Test2] opt[]" + "v2-jabref-entrytype: test: req[Test1;Test2] opt[]" ), Arguments.of( new BibEntryTypeBuilder() .withType(new UnknownEntryType("test")) .withRequiredFields(UnknownField.fromDisplayName("tEST"), UnknownField.fromDisplayName("tEsT2")), - "jabref-entrytype-v2: test: req[tEST;tEsT2] opt[]" + "v2-jabref-entrytype: test: req[tEST;tEsT2] opt[]" ), Arguments.of( new BibEntryTypeBuilder() @@ -91,19 +91,19 @@ public static Stream parseCustomizedEntryType() { new UnknownField("Googlescholar", FieldProperty.EXTERNAL), new UnknownField("Orcid", FieldProperty.EXTERNAL) ), - "jabref-entrytype-v2: person: req[Name|PERSON_NAMES] opt[Googlescholar|EXTERNAL;Orcid|EXTERNAL]" + "v2-jabref-entrytype: person: req[Name|PERSON_NAMES] opt[Googlescholar|EXTERNAL;Orcid|EXTERNAL]" ), Arguments.of( new BibEntryTypeBuilder() .withType(new UnknownEntryType("test")) .withRequiredFields(new UnknownField("custom1", "custom1", FieldProperty.MULTILINE_TEXT, FieldProperty.COMMENT, FieldProperty.EXTERNAL)), - "jabref-entrytype-v2: test: req[custom1|MULTILINE_TEXT,COMMENT,EXTERNAL] opt[]" + "v2-jabref-entrytype: test: req[custom1|MULTILINE_TEXT,COMMENT,EXTERNAL] opt[]" ), Arguments.of( new BibEntryTypeBuilder() .withType(new UnknownEntryType("test")) .withRequiredFields(new UnknownField("custom2", "custom2")), - "jabref-entrytype-v2: test: req[custom2] opt[]" + "v2-jabref-entrytype: test: req[custom2] opt[]" ) ); } From 5c2fdf883ad11cd49e9c44540e5f1f4845ddcc6d Mon Sep 17 00:00:00 2001 From: Nitin Suresh Date: Tue, 10 Sep 2024 21:53:53 -0700 Subject: [PATCH 5/5] fix issues --- src/main/java/org/jabref/model/entry/field/FieldFactory.java | 1 - .../org/jabref/logic/exporter/MetaDataSerializerTest.java | 4 ++-- .../org/jabref/logic/importer/util/MetaDataParserTest.java | 4 ++-- 3 files changed, 4 insertions(+), 5 deletions(-) diff --git a/src/main/java/org/jabref/model/entry/field/FieldFactory.java b/src/main/java/org/jabref/model/entry/field/FieldFactory.java index 65a831f09d6..0e27e3e156e 100644 --- a/src/main/java/org/jabref/model/entry/field/FieldFactory.java +++ b/src/main/java/org/jabref/model/entry/field/FieldFactory.java @@ -66,7 +66,6 @@ private static String serializeUnknownField(UnknownField unknownField) { // In case a user has put a user-defined field, the casing of that field is kept String displayName = unknownField.getDisplayName(); String fieldProperties = unknownField.getProperties().stream() - .filter(e -> e != FieldProperty.CUSTOM_FIELD) .map(Enum::name) .collect(Collectors.joining(FIELD_PROPERTY_SEPARATOR)); diff --git a/src/test/java/org/jabref/logic/exporter/MetaDataSerializerTest.java b/src/test/java/org/jabref/logic/exporter/MetaDataSerializerTest.java index 182dd3509b9..5f193c5104c 100644 --- a/src/test/java/org/jabref/logic/exporter/MetaDataSerializerTest.java +++ b/src/test/java/org/jabref/logic/exporter/MetaDataSerializerTest.java @@ -182,8 +182,8 @@ public static Stream serializeCustomizedEntryTypeV2() { Arguments.of( new BibEntryTypeBuilder() .withType(new UnknownEntryType("test")) - .withRequiredFields(new UnknownField("custom1", "custom1", FieldProperty.MULTILINE_TEXT, FieldProperty.COMMENT, FieldProperty.EXTERNAL)), - "v2-jabref-entrytype: test: req[custom1|EXTERNAL,MULTILINE_TEXT,COMMENT] opt[]" + .withRequiredFields(new UnknownField("custom1", "custom1", FieldProperty.MULTILINE_TEXT, FieldProperty.EXTERNAL)), + "v2-jabref-entrytype: test: req[custom1|EXTERNAL,MULTILINE_TEXT] opt[]" ), Arguments.of( new BibEntryTypeBuilder() diff --git a/src/test/java/org/jabref/logic/importer/util/MetaDataParserTest.java b/src/test/java/org/jabref/logic/importer/util/MetaDataParserTest.java index 8d4225e9eca..a4a440a1fff 100644 --- a/src/test/java/org/jabref/logic/importer/util/MetaDataParserTest.java +++ b/src/test/java/org/jabref/logic/importer/util/MetaDataParserTest.java @@ -96,8 +96,8 @@ public static Stream parseCustomizedEntryType() { Arguments.of( new BibEntryTypeBuilder() .withType(new UnknownEntryType("test")) - .withRequiredFields(new UnknownField("custom1", "custom1", FieldProperty.MULTILINE_TEXT, FieldProperty.COMMENT, FieldProperty.EXTERNAL)), - "v2-jabref-entrytype: test: req[custom1|MULTILINE_TEXT,COMMENT,EXTERNAL] opt[]" + .withRequiredFields(new UnknownField("custom1", "custom1", FieldProperty.MULTILINE_TEXT, FieldProperty.EXTERNAL)), + "v2-jabref-entrytype: test: req[custom1|MULTILINE_TEXT,EXTERNAL] opt[]" ), Arguments.of( new BibEntryTypeBuilder()