Added option to import CFF files

CHANGELOG.md

@@ -11,6 +11,7 @@ Note that this project **does not** adhere to [Semantic Versioning](http://semve
 
 ### Added
 
+- We added import support for CFF files. [#7945](https://github.com/JabRef/jabref/issues/7945)
 - We added the option to copy the DOI of an entry directly from the context menu copy submenu. [#7826](https://github.com/JabRef/jabref/issues/7826)
 - We added a fulltext search feature. [#2838](https://github.com/JabRef/jabref/pull/2838)
 - We improved the deduction of bib-entries from imported fulltext pdfs. [#7947](https://github.com/JabRef/jabref/pull/7947)

src/main/java/org/jabref/logic/importer/ImportFormatReader.java

@@ -12,6 +12,7 @@
 import org.jabref.logic.importer.fileformat.BibTeXMLImporter;
 import org.jabref.logic.importer.fileformat.BiblioscapeImporter;
 import org.jabref.logic.importer.fileformat.BibtexImporter;
+import org.jabref.logic.importer.fileformat.CffImporter;
 import org.jabref.logic.importer.fileformat.CopacImporter;
 import org.jabref.logic.importer.fileformat.EndnoteImporter;
 import org.jabref.logic.importer.fileformat.EndnoteXmlImporter;
@@ -79,6 +80,7 @@ public void resetImportFormats(ImportSettingsPreferences importSettingsPreferenc
  formats.add(new RepecNepImporter(importFormatPreferences));
  formats.add(new RisImporter());
  formats.add(new SilverPlatterImporter());
+ formats.add(new CffImporter());
  formats.add(new BiblioscapeImporter());
  formats.add(new BibtexImporter(importFormatPreferences, fileMonitor));
 

src/main/java/org/jabref/logic/importer/fileformat/CffImporter.java

@@ -0,0 +1,201 @@
+package org.jabref.logic.importer.fileformat;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+import org.jabref.logic.importer.Importer;
+import org.jabref.logic.importer.ParserResult;
+import org.jabref.logic.util.StandardFileType;
+import org.jabref.model.entry.Author;
+import org.jabref.model.entry.AuthorList;
+import org.jabref.model.entry.BibEntry;
+import org.jabref.model.entry.field.Field;
+import org.jabref.model.entry.field.StandardField;
+import org.jabref.model.entry.field.UnknownField;
+import org.jabref.model.entry.types.StandardEntryType;
+
+import com.fasterxml.jackson.annotation.JsonAnySetter;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.dataformat.yaml.YAMLFactory;
+
+public class CffImporter extends Importer {
+
+ @Override
+ public String getName() {
+ return "CFF";
+ }
+
+ @Override
+ public StandardFileType getFileType() {
+ return StandardFileType.CFF;
+ }
+
+ @Override
+ public String getId() {
+ return "cff";
+ }
+
+ @Override
+ public String getDescription() {
+ return "Importer for the CFF format. Is only used to cite software, one entry per file.";
+ }
+
+ // POJO classes for yaml data
+ private static class CffFormat {
+ private final HashMap<String, String> values = new HashMap<>();
+
+ @JsonProperty("authors")
+ private List<CffAuthor> authors;
+
+ @JsonProperty("identifiers")
+ private List<CffIdentifier> ids;
+
+ public CffFormat() {
+ }
+
+ @JsonAnySetter
+ private void setValues(String key, String value) {
+ values.put(key, value);
+ }
+ }
+
+ private static class CffAuthor {
+ private final HashMap<String, String> values = new HashMap<>();
+
+ public CffAuthor() {
+ }
+
+ @JsonAnySetter
+ private void setValues(String key, String value) {
+ values.put(key, value);
+ }
+
+ }
+
+ private static class CffIdentifier {
+ @JsonProperty("type")
+ private String type;
+ @JsonProperty("value")
+ private String value;
+
+ public CffIdentifier() {
+ }
+ }
+
+ @Override
+ public ParserResult importDatabase(BufferedReader reader) throws IOException {
+ ObjectMapper mapper = new ObjectMapper(new YAMLFactory());
+ CffFormat citation = mapper.readValue(reader, CffFormat.class);
+ HashMap<Field, String> entryMap = new HashMap<>();
+ StandardEntryType entryType = StandardEntryType.Software;
+
+ // Map CFF fields to JabRef Fields
+ HashMap<String, StandardField> fieldMap = getFieldMappings();
+ for (Map.Entry<String, String> property : citation.values.entrySet()) {
+ if (fieldMap.containsKey(property.getKey())) {
+ entryMap.put(fieldMap.get(property.getKey()), property.getValue());
+ } else if (property.getKey().equals("type")) {
+ if (property.getValue().equals("dataset")) {
+ entryType = StandardEntryType.Dataset;
+ }
+ } else if (getUnmappedFields().contains(property.getKey())) {
+ entryMap.put(new UnknownField(property.getKey()), property.getValue());
+ }
+ }
+
+ // Translate CFF author format to JabRef author format
+ String authorStr = citation.authors.stream()
+ .map((author) -> author.values)
+ .map((vals) -> vals.get("name") != null ?
+ new Author(vals.get("name"), "", "", "", "") :
+ new Author(vals.get("given-names"), null, vals.get("name-particle"),
+ vals.get("family-names"), vals.get("name-suffix")))
+ .collect(AuthorList.collect())
+ .getAsFirstLastNamesWithAnd();
+ entryMap.put(StandardField.AUTHOR, authorStr);
+
+ // Select DOI to keep
+ if (entryMap.get(StandardField.DOI) == null && citation.ids != null) {
+ List<CffIdentifier> doiIds = citation.ids.stream()
+ .filter(id -> id.type.equals("doi"))
+ .collect(Collectors.toList());
+ if (doiIds.size() == 1) {
+ entryMap.put(StandardField.DOI, doiIds.get(0).value);
+ }
+ }
+
+ // Select SWHID to keep
+ if (citation.ids != null) {
+ List<String> swhIds = citation.ids.stream()
+ .filter(id -> id.type.equals("swh"))
+ .map(id -> id.value)
+ .collect(Collectors.toList());
+
+ if (swhIds.size() == 1) {
+ entryMap.put(StandardField.SWHID, swhIds.get(0));
+ } else if (swhIds.size() > 1) {
+ List<String> relSwhIds = swhIds.stream()
+ .filter(id -> id.split(":").length > 3) // quick filter for invalid swhids
+ .filter(id -> id.split(":")[2].equals("rel"))
+ .collect(Collectors.toList());
+ if (relSwhIds.size() == 1) {
+ entryMap.put(StandardField.SWHID, relSwhIds.get(0));
+ }
+ }
+ }
+
+ BibEntry entry = new BibEntry(entryType);
+ entry.setField(entryMap);
+
+ List<BibEntry> entriesList = new ArrayList<>();
+ entriesList.add(entry);
+
+ return new ParserResult(entriesList);
+ }
+
+ @Override
+ public boolean isRecognizedFormat(BufferedReader reader) throws IOException {
+
+ ObjectMapper mapper = new ObjectMapper(new YAMLFactory());
+ CffFormat citation;
+
+ try {
+ citation = mapper.readValue(reader, CffFormat.class);
+ return citation != null && citation.values.get("title") != null;
+ } catch (IOException e) {
+ return false;
+ }
+ }
+
+ private HashMap<String, StandardField> getFieldMappings() {
+ HashMap<String, StandardField> fieldMappings = new HashMap<>();
+ fieldMappings.put("title", StandardField.TITLE);
+ fieldMappings.put("version", StandardField.VERSION);
+ fieldMappings.put("doi", StandardField.DOI);
+ fieldMappings.put("license", StandardField.LICENSE);
+ fieldMappings.put("repository", StandardField.REPOSITORY);
+ fieldMappings.put("url", StandardField.URL);
+ fieldMappings.put("abstract", StandardField.ABSTRACT);
+ fieldMappings.put("message", StandardField.COMMENT);
+ fieldMappings.put("date-released", StandardField.DATE);
+ fieldMappings.put("keywords", StandardField.KEYWORDS);
+ return fieldMappings;
+ }
+
+ private List<String> getUnmappedFields() {
+ List<String> fields = new ArrayList<>();
+
+ fields.add("commit");
+ fields.add("license-url");
+ fields.add("repository-code");
+ fields.add("repository-artifact");
+
+ return fields;
+ }
+}

src/main/java/org/jabref/logic/util/StandardFileType.java

@@ -42,6 +42,7 @@ public enum StandardFileType implements FileType {
  ZIP("Zip Archive", "zip"),
  CSS("CSS Styleshet", "css"),
  YAML("YAML Markup", "yaml"),
+ CFF("CFF", "cff"),
  ANY_FILE("Any", "*");
 
  private final List<String> extensions;

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

@@ -0,0 +1,165 @@
+package org.jabref.logic.importer.fileformat;
+
+import java.io.IOException;
+import java.net.URISyntaxException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Path;
+import java.util.Arrays;
+import java.util.List;
+
+import org.jabref.logic.util.StandardFileType;
+import org.jabref.model.entry.BibEntry;
+import org.jabref.model.entry.field.StandardField;
+import org.jabref.model.entry.field.UnknownField;
+import org.jabref.model.entry.types.StandardEntryType;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+public class CffImporterTest {
+
+ private CffImporter importer;
+
+ @BeforeEach
+ public void setUp() {
+ importer = new CffImporter();
+ }
+
+ @Test
+ public void testGetFormatName() {
+ assertEquals("CFF", importer.getName());
+ }
+
+ @Test
+ public void testGetCLIId() {
+ assertEquals("cff", importer.getId());
+ }
+
+ @Test
+ public void testsGetExtensions() {
+ assertEquals(StandardFileType.CFF, importer.getFileType());
+ }
+
+ @Test
+ public void testGetDescription() {
+ assertEquals("Importer for the CFF format. Is only used to cite software, one entry per file.",
+ importer.getDescription());
+ }
+
+ @Test
+ public void testIsRecognizedFormat() throws IOException, URISyntaxException {
+ Path file = Path.of(CffImporterTest.class.getResource("CffImporterTestValid.cff").toURI());
+ assertTrue(importer.isRecognizedFormat(file, StandardCharsets.UTF_8));
+ }
+
+ @Test
+ public void testIsRecognizedFormatReject() throws IOException, URISyntaxException {
+ List<String> list = Arrays.asList("CffImporterTestInvalid1.cff", "CffImporterTestInvalid2.cff");
+
+ for (String string : list) {
+ Path file = Path.of(CffImporterTest.class.getResource(string).toURI());
+ assertFalse(importer.isRecognizedFormat(file, StandardCharsets.UTF_8));
+ }
+ }
+
+ @Test
+ public void testImportEntriesBasic() throws IOException, URISyntaxException {
+ Path file = Path.of(CffImporterTest.class.getResource("CffImporterTestValid.cff").toURI());
+ List<BibEntry> bibEntries = importer.importDatabase(file, StandardCharsets.UTF_8).getDatabase().getEntries();
+ BibEntry entry = bibEntries.get(0);
+
+ BibEntry expected = getPopulatedEntry().withField(StandardField.AUTHOR, "Joe van Smith");
+
+ assertEquals(entry, expected);
+ }
+
+ @Test
+ public void testImportEntriesMultipleAuthors() throws IOException, URISyntaxException {
+ Path file = Path.of(CffImporterTest.class.getResource("CffImporterTestValidMultAuthors.cff").toURI());
+ List<BibEntry> bibEntries = importer.importDatabase(file, StandardCharsets.UTF_8).getDatabase().getEntries();
+ BibEntry entry = bibEntries.get(0);
+
+ BibEntry expected = getPopulatedEntry();
+
+ assertEquals(entry, expected);
+
+ }
+
+ @Test
+ public void testImportEntriesSwhIdSelect1() throws IOException, URISyntaxException {
+ Path file = Path.of(CffImporterTest.class.getResource("CffImporterTestValidSwhIdSelect1.cff").toURI());
+ List<BibEntry> bibEntries = importer.importDatabase(file, StandardCharsets.UTF_8).getDatabase().getEntries();
+ BibEntry entry = bibEntries.get(0);
+
+ BibEntry expected = getPopulatedEntry().withField(StandardField.SWHID, "swh:1:rel:22ece559cc7cc2364edc5e5593d63ae8bd229f9f");
+
+ assertEquals(entry, expected);
+ }
+
+ @Test
+ public void testImportEntriesSwhIdSelect2() throws IOException, URISyntaxException {
+ Path file = Path.of(CffImporterTest.class.getResource("CffImporterTestValidSwhIdSelect2.cff").toURI());
+ List<BibEntry> bibEntries = importer.importDatabase(file, StandardCharsets.UTF_8).getDatabase().getEntries();
+ BibEntry entry = bibEntries.get(0);
+
+ BibEntry expected = getPopulatedEntry().withField(StandardField.SWHID, "swh:1:cnt:94a9ed024d3859793618152ea559a168bbcbb5e2");
+
+ assertEquals(entry, expected);
+ }
+
+ @Test
+ public void testImportEntriesDataset() throws IOException, URISyntaxException {
+ Path file = Path.of(CffImporterTest.class.getResource("CffImporterTestDataset.cff").toURI());
+ List<BibEntry> bibEntries = importer.importDatabase(file, StandardCharsets.UTF_8).getDatabase().getEntries();
+ BibEntry entry = bibEntries.get(0);
+
+ BibEntry expected = getPopulatedEntry();
+ expected.setType(StandardEntryType.Dataset);
+
+ assertEquals(entry, expected);
+ }
+
+ @Test
+ public void testImportEntriesDoiSelect() throws IOException, URISyntaxException {
+ Path file = Path.of(CffImporterTest.class.getResource("CffImporterTestDoiSelect.cff").toURI());
+ List<BibEntry> bibEntries = importer.importDatabase(file, StandardCharsets.UTF_8).getDatabase().getEntries();
+ BibEntry entry = bibEntries.get(0);
+
+ BibEntry expected = getPopulatedEntry();
+
+ assertEquals(entry, expected);
+ }
+
+ @Test
+ public void testImportEntriesUnknownFields() throws IOException, URISyntaxException {
+ Path file = Path.of(CffImporterTest.class.getResource("CffImporterTestUnknownFields.cff").toURI());
+ List<BibEntry> bibEntries = importer.importDatabase(file, StandardCharsets.UTF_8).getDatabase().getEntries();
+ BibEntry entry = bibEntries.get(0);
+
+ BibEntry expected = getPopulatedEntry().withField(new UnknownField("commit"), "10ad");
+
+ assertEquals(entry, expected);
+ }
+
+ public BibEntry getPopulatedEntry() {
+ BibEntry entry = new BibEntry();
+ entry.setType(StandardEntryType.Software);
+
+ entry.setField(StandardField.AUTHOR, "Joe van Smith and Bob Jones, Jr.");
+ entry.setField(StandardField.TITLE, "Test");
+ entry.setField(StandardField.URL, "www.google.com");
+ entry.setField(StandardField.REPOSITORY, "www.github.com");
+ entry.setField(StandardField.DOI, "10.0000/TEST");
+ entry.setField(StandardField.DATE, "2000-07-02");
+ entry.setField(StandardField.COMMENT, "Test entry.");
+ entry.setField(StandardField.ABSTRACT, "Test abstract.");
+ entry.setField(StandardField.LICENSE, "MIT");
+ entry.setField(StandardField.VERSION, "1.0");
+
+ return entry;
+ }
+}