Rewrite Bibtexml exporter (JabRef#2017)

* rewrite exporter with jaxb parser

* add test

* fix codacy and some code refactorings

* delete old layout files

* adress comments

src/main/java/net/sf/jabref/logic/exporter/BibTeXMLExportFormat.java

@@ -0,0 +1,246 @@
+package net.sf.jabref.logic.exporter;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.math.BigInteger;
+import java.nio.charset.Charset;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+import javax.xml.bind.JAXBContext;
+import javax.xml.bind.JAXBElement;
+import javax.xml.bind.JAXBException;
+import javax.xml.bind.Marshaller;
+import javax.xml.datatype.DatatypeConfigurationException;
+import javax.xml.datatype.DatatypeFactory;
+import javax.xml.datatype.XMLGregorianCalendar;
+import javax.xml.namespace.QName;
+
+import net.sf.jabref.logic.importer.fileformat.bibtexml.Article;
+import net.sf.jabref.logic.importer.fileformat.bibtexml.Book;
+import net.sf.jabref.logic.importer.fileformat.bibtexml.Booklet;
+import net.sf.jabref.logic.importer.fileformat.bibtexml.Conference;
+import net.sf.jabref.logic.importer.fileformat.bibtexml.Entry;
+import net.sf.jabref.logic.importer.fileformat.bibtexml.File;
+import net.sf.jabref.logic.importer.fileformat.bibtexml.Inbook;
+import net.sf.jabref.logic.importer.fileformat.bibtexml.Incollection;
+import net.sf.jabref.logic.importer.fileformat.bibtexml.Inproceedings;
+import net.sf.jabref.logic.importer.fileformat.bibtexml.Manual;
+import net.sf.jabref.logic.importer.fileformat.bibtexml.Mastersthesis;
+import net.sf.jabref.logic.importer.fileformat.bibtexml.Misc;
+import net.sf.jabref.logic.importer.fileformat.bibtexml.Phdthesis;
+import net.sf.jabref.logic.importer.fileformat.bibtexml.Proceedings;
+import net.sf.jabref.logic.importer.fileformat.bibtexml.Techreport;
+import net.sf.jabref.logic.importer.fileformat.bibtexml.Unpublished;
+import net.sf.jabref.model.database.BibDatabaseContext;
+import net.sf.jabref.model.entry.BibEntry;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+/**
+ * Export format for the BibTeXML format.
+ */
+public class BibTeXMLExportFormat extends ExportFormat {
+
+ private static final String BIBTEXML_NAMESPACE_URI = "http://bibtexml.sf.net/";
+ private static final Locale ENGLISH = Locale.ENGLISH;
+ private static final Log LOGGER = LogFactory.getLog(BibTeXMLExportFormat.class);
+ private JAXBContext context;
+
+
+ public BibTeXMLExportFormat() {
+ super("BibTeXML", "bibtexml", null, null, ".xml");
+ }
+
+ @Override
+ public void performExport(final BibDatabaseContext databaseContext, final String resultFile, final Charset encoding,
+ List<BibEntry> entries) throws SaveException {
+ Objects.requireNonNull(databaseContext);
+ Objects.requireNonNull(entries);
+ if (entries.isEmpty()) { // Only export if entries exist
+ return;
+ }
+
+ File file = new File();
+ for (BibEntry bibEntry : entries) {
+ Entry entry = new Entry();
+
+ bibEntry.getCiteKeyOptional().ifPresent(citeKey -> entry.setId(citeKey));
+
+ String type = bibEntry.getType().toLowerCase(ENGLISH);
+ switch (type) {
+ case "article":
+ parse(new Article(), bibEntry, entry);
+ break;
+ case "book":
+ parse(new Book(), bibEntry, entry);
+ break;
+ case "booklet":
+ parse(new Booklet(), bibEntry, entry);
+ break;
+ case "conference":
+ parse(new Conference(), bibEntry, entry);
+ break;
+ case "inbook":
+ parseInbook(new Inbook(), bibEntry, entry);
+ break;
+ case "incollection":
+ parse(new Incollection(), bibEntry, entry);
+ break;
+ case "inproceedings":
+ parse(new Inproceedings(), bibEntry, entry);
+ break;
+ case "mastersthesis":
+ parse(new Mastersthesis(), bibEntry, entry);
+ break;
+ case "manual":
+ parse(new Manual(), bibEntry, entry);
+ break;
+ case "misc":
+ parse(new Misc(), bibEntry, entry);
+ break;
+ case "phdthesis":
+ parse(new Phdthesis(), bibEntry, entry);
+ break;
+ case "proceedings":
+ parse(new Proceedings(), bibEntry, entry);
+ break;
+ case "techreport":
+ parse(new Techreport(), bibEntry, entry);
+ break;
+ case "unpublished":
+ parse(new Unpublished(), bibEntry, entry);
+ break;
+ default:
+ LOGGER.warn("unexpected type appeared");
+ break;
+ }
+ file.getEntry().add(entry);
+ }
+ createMarshallerAndWriteToFile(file, resultFile);
+ }
+
+ private void createMarshallerAndWriteToFile(File file, String resultFile) throws SaveException {
+ try {
+ if (context == null) {
+ context = JAXBContext.newInstance(File.class);
+ }
+ Marshaller marshaller = context.createMarshaller();
+ marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);
+
+ marshaller.marshal(file, new java.io.File(resultFile));
+ } catch (JAXBException e) {
+ throw new SaveException(e);
+ }
+ }
+
+ /**
+ * Contains same logic as the {@link parse()} method, but inbook needs a special treatment, because
+ * the contents of inbook are stored in a List of JAXBElements. So we first need to create
+ * a JAXBElement for every field and then add it to the content list.
+ */
+ private void parseInbook(Inbook inbook, BibEntry bibEntry, Entry entry) {
+ Map<String, String> fieldMap = bibEntry.getFieldMap();
+ for (Map.Entry<String, String> entryField : fieldMap.entrySet()) {
+ String value = entryField.getValue();
+ String key = entryField.getKey();
+ if ("year".equals(key)) {
+ XMLGregorianCalendar calendar;
+ try {
+ calendar = DatatypeFactory.newInstance().newXMLGregorianCalendar(value);
+
+ JAXBElement<XMLGregorianCalendar> year = new JAXBElement<>(
+ new QName(BIBTEXML_NAMESPACE_URI, "year"), XMLGregorianCalendar.class, calendar);
+ inbook.getContent().add(year);
+ } catch (DatatypeConfigurationException e) {
+ LOGGER.error("A configuration error occured");
+ }
+ } else if ("number".equals(key)) {
+ JAXBElement<BigInteger> number = new JAXBElement<>(new QName(BIBTEXML_NAMESPACE_URI, "number"),
+ BigInteger.class, new BigInteger(value));
+ inbook.getContent().add(number);
+ } else {
+ JAXBElement<String> element = new JAXBElement<>(new QName(BIBTEXML_NAMESPACE_URI, key), String.class,
+ value);
+ inbook.getContent().add(element);
+ }
+ }
+
+ //set the entryType to the entry
+ entry.setInbook(inbook);
+ }
+
+ /**
+ * Generic method that gets an instance of an entry type (article, book, booklet ...). It also
+ * gets one bibEntry. Then the method checks all fields of the entry and then for all fields the method
+ * uses the set method of the entry type with the fieldname. So for example if a bib entry has the field
+ * author and the value for it is "Max Mustermann" and the given type is an article, then this method
+ * will invoke <Code>article.setAuthor("Max Mustermann")</Code>. <br>
+ * <br>
+ * The second part of this method is that the entry type will be set to the entry. So e.g., if the type is
+ * article then <Code>entry.setArticle(article)</Code> will be invoked.
+ *
+ * @param entryType The type parameterized type of the entry.
+ * @param bibEntry The bib entry, which fields will be set to the entryType.
+ * @param entry The bibtexml entry. The entryType will be set to this entry.
+ */
+ private <T> void parse(T entryType, BibEntry bibEntry, Entry entry) {
+ List<Method> declaredSetMethods = getListOfSetMethods(entryType);
+ Map<String, String> fieldMap = bibEntry.getFieldMap();
+ for (Map.Entry<String, String> entryField : fieldMap.entrySet()) {
+ String value = entryField.getValue();
+ String key = entryField.getKey();
+ for (Method method : declaredSetMethods) {
+ String methodNameWithoutSet = method.getName().replace("set", "").toLowerCase(ENGLISH);
+ try {
+
+ if ("year".equals(key) && key.equals(methodNameWithoutSet)) {
+ try {
+
+ XMLGregorianCalendar calendar = DatatypeFactory.newInstance()
+ .newXMLGregorianCalendar(value);
+ method.invoke(entryType, calendar);
+ } catch (DatatypeConfigurationException e) {
+ LOGGER.error("A configuration error occured");
+ }
+ break;
+ } else if ("number".equals(key) && key.equals(methodNameWithoutSet)) {
+ method.invoke(entryType, new BigInteger(value));
+ break;
+ } else if (key.equals(methodNameWithoutSet)) {
+ method.invoke(entryType, value);
+ break;
+ }
+ } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
+ LOGGER.error("Could not invoke method", e);
+ }
+ }
+
+ //set the entryType to the entry
+ List<Method> entryMethods = getListOfSetMethods(entry);
+ for (Method method : entryMethods) {
+ String methodWithoutSet = method.getName().replace("set", "");
+ String simpleClassName = entryType.getClass().getSimpleName();
+
+ if (methodWithoutSet.equals(simpleClassName)) {
+ try {
+ method.invoke(entry, entryType);
+ } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
+ LOGGER.warn("Could not set the type to the entry");
+ }
+ }
+ }
+ }
+ }
+
+ private <T> List<Method> getListOfSetMethods(T entryType) {
+ return Arrays.asList(entryType.getClass().getDeclaredMethods()).stream()
+ .filter(method -> method.getName().startsWith("set")).collect(Collectors.toList());
+ }
+
+}

src/main/java/net/sf/jabref/logic/exporter/ExportFormats.java

@@ -30,8 +30,6 @@ public static void initAllExports(Map<String, ExportFormat> customFormats,
  savePreferences));
  ExportFormats.putFormat(new ExportFormat("DIN 1505", "din1505", "din1505winword", "din1505", ".rtf",
  layoutPreferences, savePreferences));
- ExportFormats.putFormat(
- new ExportFormat("BibTeXML", "bibtexml", "bibtexml", null, ".xml", layoutPreferences, savePreferences));
  ExportFormats.putFormat(
  new ExportFormat("BibO RDF", "bibordf", "bibordf", null, ".rdf", layoutPreferences, savePreferences));
  ExportFormats.putFormat(new ExportFormat(Localization.lang("HTML table"), "tablerefs", "tablerefs", "tablerefs",
@@ -56,6 +54,7 @@ public static void initAllExports(Map<String, ExportFormat> customFormats,
  ExportFormats.putFormat(
  new ExportFormat("MIS Quarterly", "misq", "misq", "misq", ".rtf", layoutPreferences, savePreferences));
 
+ ExportFormats.putFormat(new BibTeXMLExportFormat());
  ExportFormats.putFormat(new OpenOfficeDocumentCreator());
  ExportFormats.putFormat(new OpenDocumentSpreadsheetCreator());
  ExportFormats.putFormat(new MSBibExportFormat());

src/test/java/net/sf/jabref/logic/exporter/BibTeXMLExporterTestFiles.java

@@ -0,0 +1,89 @@
+package net.sf.jabref.logic.exporter;
+
+import java.io.File;
+import java.io.IOException;
+import java.net.URISyntaxException;
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Collection;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import net.sf.jabref.logic.importer.fileformat.BibtexImporter;
+import net.sf.jabref.model.database.BibDatabaseContext;
+import net.sf.jabref.model.entry.BibEntry;
+import net.sf.jabref.preferences.JabRefPreferences;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+import org.xmlunit.builder.Input;
+import org.xmlunit.builder.Input.Builder;
+import org.xmlunit.diff.DefaultNodeMatcher;
+import org.xmlunit.diff.ElementSelectors;
+import org.xmlunit.matchers.CompareMatcher;
+
+
+@RunWith(Parameterized.class)
+public class BibTeXMLExporterTestFiles {
+
+ public BibDatabaseContext databaseContext;
+ public Charset charset;
+ public File tempFile;
+ public BibTeXMLExportFormat bibtexmlExportFormat;
+ public BibtexImporter testImporter;
+
+ @Parameter
+ public String filename;
+ public Path resourceDir;
+
+ @Rule
+ public TemporaryFolder testFolder = new TemporaryFolder();
+
+
+ @Parameters(name = "{0}")
+ public static Collection<String> fileNames() throws IOException, URISyntaxException {
+ try (Stream<Path> stream = Files.list(Paths.get(BibTeXMLExporterTestFiles.class.getResource("").toURI()))) {
+ return stream.map(n -> n.getFileName().toString()).filter(n -> n.endsWith(".bib"))
+ .filter(n -> n.startsWith("BibTeXML")).collect(Collectors.toList());
+ }
+ }
+
+ @Before
+ public void setUp() throws Exception {
+ resourceDir = Paths.get(BibTeXMLExporterTestFiles.class.getResource("").toURI());
+ databaseContext = new BibDatabaseContext();
+ charset = StandardCharsets.UTF_8;
+ bibtexmlExportFormat = new BibTeXMLExportFormat();
+ tempFile = testFolder.newFile();
+ testImporter = new BibtexImporter(JabRefPreferences.getInstance().getImportFormatPreferences());
+ }
+
+ @Test
+ public final void testPerformExport() throws IOException, SaveException {
+ String xmlFileName = filename.replace(".bib", ".xml");
+ Path importFile = resourceDir.resolve(filename);
+ String tempFilename = tempFile.getCanonicalPath();
+
+ List<BibEntry> entries = testImporter.importDatabase(importFile, StandardCharsets.UTF_8).getDatabase()
+ .getEntries();
+
+ bibtexmlExportFormat.performExport(databaseContext, tempFile.getPath(), charset, entries);
+
+ Builder control = Input.from(Files.newInputStream(resourceDir.resolve(xmlFileName)));
+ Builder test = Input.from(Files.newInputStream(Paths.get(tempFilename)));
+
+ Assert.assertThat(test, CompareMatcher.isSimilarTo(control)
+ .withNodeMatcher(new DefaultNodeMatcher(ElementSelectors.byNameAndText)).throwComparisonFailure());
+ }
+}