/**
* Parses BibtexEntries from the given string and returns the collection of all entries found.
*
* @param bibtexString
* @return Returns returns an empty collection if no entries where found or if an error occurred.
*/
public static List<BibEntry> fromString(String bibtexString) {
StringReader reader = new StringReader(bibtexString);
BibtexParser parser = new BibtexParser(reader);
try {
return parser.parse().getDatabase().getEntries();
} catch (Exception e) {
LOGGER.warn("BibtexParser.fromString(String): " + e.getMessage(), e);
return Collections.emptyList();
}
}
@Test
public void monthFieldSpecialSyntax() throws IOException {
// @formatter:off
String bibtexEntry =
"@Article{test,"
+ OS.NEWLINE
+ " Author = {Foo Bar},"
+ OS.NEWLINE
+ " Month = mar,"
+ OS.NEWLINE
+ " Number = {1}"
+ OS.NEWLINE
+ "}";
// @formatter:on
// read in bibtex string
ParserResult result = BibtexParser.parse(new StringReader(bibtexEntry));
Collection<BibEntry> entries = result.getDatabase().getEntries();
BibEntry entry = entries.iterator().next();
// modify month field
Set<String> fields = entry.getFieldNames();
assertTrue(fields.contains("month"));
assertEquals("#mar#", entry.getFieldOptional("month").get());
// write out bibtex string
StringWriter stringWriter = new StringWriter();
writer.write(entry, stringWriter, BibDatabaseMode.BIBTEX);
String actual = stringWriter.toString();
assertEquals(bibtexEntry, actual);
}
@Test
public void roundTripWithAppendedNewlines() throws IOException {
// @formatter:off
String bibtexEntry =
"@Article{test,"
+ OS.NEWLINE
+ " Author = {Foo Bar},"
+ OS.NEWLINE
+ " Journal = {International Journal of Something},"
+ OS.NEWLINE
+ " Note = {some note},"
+ OS.NEWLINE
+ " Number = {1}"
+ OS.NEWLINE
+ "}\n\n";
// @formatter:on
// read in bibtex string
ParserResult result = BibtexParser.parse(new StringReader(bibtexEntry));
Collection<BibEntry> entries = result.getDatabase().getEntries();
BibEntry entry = entries.iterator().next();
// write out bibtex string
StringWriter stringWriter = new StringWriter();
writer.write(entry, stringWriter, BibDatabaseMode.BIBTEX);
String actual = stringWriter.toString();
// Only one appending newline is written by the writer, the rest by FileActions. So, these
// should be removed here.
assertEquals(bibtexEntry.substring(0, bibtexEntry.length() - 1), actual);
}
/**
* Parses BibtexEntries from the given string and returns one entry found (or null if none found)
*
* <p>It is undetermined which entry is returned, so use this in case you know there is only one
* entry in the string.
*
* @param bibtexString
* @return The BibEntry or null if non was found or an error occurred.
*/
public static BibEntry singleFromString(String bibtexString) {
Collection<BibEntry> entries = BibtexParser.fromString(bibtexString);
if ((entries == null) || entries.isEmpty()) {
return null;
}
return entries.iterator().next();
}
@Test
@Ignore
public void testAddEntrysFromFiles() throws Exception {
ParserResult result =
BibtexParser.parse(new FileReader(ImportDataTest.UNLINKED_FILES_TEST_BIB));
BibtexDatabase database = result.getDatabase();
List<File> files = new ArrayList<File>();
files.add(ImportDataTest.FILE_NOT_IN_DATABASE);
files.add(ImportDataTest.NOT_EXISTING_PDF);
EntryFromFileCreatorManager manager = new EntryFromFileCreatorManager();
List<String> errors = manager.addEntrysFromFiles(files, database, null, true);
/** One file doesn't exist, so adding it as an entry should lead to an error message. */
Assert.assertEquals(1, errors.size());
boolean file1Found = false;
boolean file2Found = false;
for (BibtexEntry entry : database.getEntries()) {
String filesInfo = entry.getField("file");
if (filesInfo.contains(files.get(0).getName())) {
file1Found = true;
}
if (filesInfo.contains(files.get(1).getName())) {
file2Found = true;
}
}
Assert.assertTrue(file1Found);
Assert.assertFalse(file2Found);
}
@Test
public void roundTripTest() throws IOException {
// @formatter:off
String bibtexEntry =
"@Article{test,"
+ OS.NEWLINE
+ " Author = {Foo Bar},"
+ OS.NEWLINE
+ " Journal = {International Journal of Something},"
+ OS.NEWLINE
+ " Note = {some note},"
+ OS.NEWLINE
+ " Number = {1}"
+ OS.NEWLINE
+ "}";
// @formatter:on
// read in bibtex string
ParserResult result = BibtexParser.parse(new StringReader(bibtexEntry));
Collection<BibEntry> entries = result.getDatabase().getEntries();
BibEntry entry = entries.iterator().next();
// write out bibtex string
StringWriter stringWriter = new StringWriter();
writer.write(entry, stringWriter, BibDatabaseMode.BIBTEX);
String actual = stringWriter.toString();
assertEquals(bibtexEntry, actual);
}
private static BibEntry downloadEntryBibTeX(String id, boolean downloadAbstract) {
try {
URL url =
new URL(
ACMPortalFetcher.START_URL
+ ACMPortalFetcher.BIBTEX_URL
+ id
+ ACMPortalFetcher.BIBTEX_URL_END);
URLConnection connection = url.openConnection();
// set user-agent to avoid being blocked as a crawler
connection.addRequestProperty(
"User-Agent", "Mozilla/5.0 (Windows NT 5.1; rv:31.0) Gecko/20100101 Firefox/31.0");
Collection<BibEntry> items = null;
try (BufferedReader in =
new BufferedReader(new InputStreamReader(connection.getInputStream()))) {
items = BibtexParser.parse(in).getDatabase().getEntries();
} catch (IOException e) {
LOGGER.info("Download of BibTeX information from ACM Portal failed.", e);
}
if ((items == null) || items.isEmpty()) {
return null;
}
BibEntry entry = items.iterator().next();
Thread.sleep(
ACMPortalFetcher.WAIT_TIME); // wait between requests or you will be blocked by ACM
// get abstract
if (downloadAbstract) {
url = new URL(ACMPortalFetcher.START_URL + ACMPortalFetcher.ABSTRACT_URL + id);
String page = Util.getResults(url);
Matcher absM = ACMPortalFetcher.ABSTRACT_PATTERN.matcher(page);
if (absM.find()) {
entry.setField("abstract", absM.group(1).trim());
}
Thread.sleep(
ACMPortalFetcher.WAIT_TIME); // wait between requests or you will be blocked by ACM
}
return entry;
} catch (NoSuchElementException e) {
LOGGER.info(
"Bad Bibtex record read at: "
+ ACMPortalFetcher.BIBTEX_URL
+ id
+ ACMPortalFetcher.BIBTEX_URL_END,
e);
return null;
} catch (MalformedURLException e) {
LOGGER.info("Malformed URL.", e);
return null;
} catch (IOException e) {
LOGGER.info("Cannot connect.", e);
return null;
} catch (InterruptedException ignored) {
return null;
}
}
@Test
public void testEntryTypeChange() throws IOException {
// @formatter:off
String expected =
OS.NEWLINE
+ "@Article{test,"
+ OS.NEWLINE
+ " author = {BlaBla},"
+ OS.NEWLINE
+ " journal = {International Journal of Something},"
+ OS.NEWLINE
+ " number = {1},"
+ OS.NEWLINE
+ " note = {some note},"
+ OS.NEWLINE
+ " howpublished = {asdf},"
+ OS.NEWLINE
+ "}"
+ OS.NEWLINE;
// @formatter:on
// read in bibtex string
ParserResult result = BibtexParser.parse(new StringReader(expected));
Collection<BibEntry> entries = result.getDatabase().getEntries();
BibEntry entry = entries.iterator().next();
// modify entry
entry.setType("inproceedings");
// write out bibtex string
StringWriter stringWriter = new StringWriter();
writer.write(entry, stringWriter, BibDatabaseMode.BIBTEX);
String actual = stringWriter.toString();
// @formatter:off
String expectedNewEntry =
OS.NEWLINE
+ "@InProceedings{test,"
+ OS.NEWLINE
+ " author = {BlaBla},"
+ OS.NEWLINE
+ " number = {1},"
+ OS.NEWLINE
+ " note = {some note},"
+ OS.NEWLINE
+ " howpublished = {asdf},"
+ OS.NEWLINE
+ " journal = {International Journal of Something},"
+ OS.NEWLINE
+ "}"
+ OS.NEWLINE;
// @formatter:on
assertEquals(expectedNewEntry, actual);
}
@Test
public void roundTripWithCamelCasingInTheOriginalEntryAndResultInLowerCase() throws IOException {
// @formatter:off
String bibtexEntry =
OS.NEWLINE
+ "@Article{test,"
+ OS.NEWLINE
+ " Author = {Foo Bar},"
+ OS.NEWLINE
+ " Journal = {International Journal of Something},"
+ OS.NEWLINE
+ " Note = {some note},"
+ OS.NEWLINE
+ " Number = {1},"
+ OS.NEWLINE
+ " HowPublished = {asdf},"
+ OS.NEWLINE
+ "}";
// @formatter:on
// read in bibtex string
ParserResult result = BibtexParser.parse(new StringReader(bibtexEntry));
Collection<BibEntry> entries = result.getDatabase().getEntries();
BibEntry entry = entries.iterator().next();
// modify entry
entry.setField("author", "BlaBla");
// write out bibtex string
StringWriter stringWriter = new StringWriter();
writer.write(entry, stringWriter, BibDatabaseMode.BIBTEX);
String actual = stringWriter.toString();
// @formatter:off
String expected =
OS.NEWLINE
+ "@Article{test,"
+ OS.NEWLINE
+ " author = {BlaBla},"
+ OS.NEWLINE
+ " journal = {International Journal of Something},"
+ OS.NEWLINE
+ " number = {1},"
+ OS.NEWLINE
+ " note = {some note},"
+ OS.NEWLINE
+ " howpublished = {asdf},"
+ OS.NEWLINE
+ "}"
+ OS.NEWLINE;
// @formatter:on
assertEquals(expected, actual);
}
@Test
public void testGetPublicationDate() {
Assert.assertEquals(
"2003-02",
(BibtexParser.singleFromString("@ARTICLE{HipKro03, year = {2003}, month = #FEB# }"))
.getPublicationDate());
Assert.assertEquals(
"2003-03",
(BibtexParser.singleFromString("@ARTICLE{HipKro03, year = {2003}, month = 3 }"))
.getPublicationDate());
Assert.assertEquals(
"2003",
(BibtexParser.singleFromString("@ARTICLE{HipKro03, year = {2003}}")).getPublicationDate());
Assert.assertEquals(
null,
(BibtexParser.singleFromString("@ARTICLE{HipKro03, month = 3 }")).getPublicationDate());
Assert.assertEquals(
null,
(BibtexParser.singleFromString("@ARTICLE{HipKro03, author={bla}}")).getPublicationDate());
Assert.assertEquals(
"2003-12",
(BibtexParser.singleFromString("@ARTICLE{HipKro03, year = {03}, month = #DEC# }"))
.getPublicationDate());
}
@Test
public void roundTripWithPrecedingCommentAndModificationTest() throws IOException {
// @formatter:off
String bibtexEntry =
"% Some random comment that should stay here"
+ OS.NEWLINE
+ "@Article{test,"
+ OS.NEWLINE
+ " Author = {Foo Bar},"
+ OS.NEWLINE
+ " Journal = {International Journal of Something},"
+ OS.NEWLINE
+ " Note = {some note},"
+ OS.NEWLINE
+ " Number = {1}"
+ OS.NEWLINE
+ "}";
// @formatter:on
// read in bibtex string
ParserResult result = BibtexParser.parse(new StringReader(bibtexEntry));
Collection<BibEntry> entries = result.getDatabase().getEntries();
BibEntry entry = entries.iterator().next();
// change the entry
entry.setField("author", "John Doe");
// write out bibtex string
StringWriter stringWriter = new StringWriter();
writer.write(entry, stringWriter, BibDatabaseMode.BIBTEX);
String actual = stringWriter.toString();
// @formatter:off
String expected =
"% Some random comment that should stay here"
+ OS.NEWLINE
+ OS.NEWLINE
+ "@Article{test,"
+ OS.NEWLINE
+ " author = {John Doe},"
+ OS.NEWLINE
+ " journal = {International Journal of Something},"
+ OS.NEWLINE
+ " number = {1},"
+ OS.NEWLINE
+ " note = {some note},"
+ OS.NEWLINE
+ "}"
+ OS.NEWLINE;
// @formatter:on
assertEquals(expected, actual);
}
private String testSingleWrite(String bibtexEntry) throws IOException {
// read in bibtex string
ParserResult result = BibtexParser.parse(new StringReader(bibtexEntry));
Collection<BibEntry> entries = result.getDatabase().getEntries();
BibEntry entry = entries.iterator().next();
// write out bibtex string
StringWriter stringWriter = new StringWriter();
writer.write(entry, stringWriter, BibDatabaseMode.BIBTEX);
String actual = stringWriter.toString();
assertEquals(bibtexEntry, actual);
return actual;
}
@Test
public void testKeywordMethods() {
BibEntry be = BibtexParser.singleFromString("@ARTICLE{Key15, keywords = {Foo, Bar}}");
String[] expected = {"Foo", "Bar"};
Assert.assertArrayEquals(expected, be.getSeparatedKeywords().toArray());
List<String> kw = be.getSeparatedKeywords();
be.addKeyword("FooBar");
String[] expected2 = {"Foo", "Bar", "FooBar"};
Assert.assertArrayEquals(expected2, be.getSeparatedKeywords().toArray());
be.addKeyword("FooBar");
Assert.assertArrayEquals(expected2, be.getSeparatedKeywords().toArray());
be.addKeyword("FOO");
Assert.assertArrayEquals(expected2, be.getSeparatedKeywords().toArray());
be.addKeyword("");
Assert.assertArrayEquals(expected2, be.getSeparatedKeywords().toArray());
try {
be.addKeyword(null);
Assert.fail();
} catch (NullPointerException asExpected) {
}
BibEntry be2 = new BibEntry();
Assert.assertTrue(be2.getSeparatedKeywords().isEmpty());
be2.addKeyword("");
Assert.assertTrue(be2.getSeparatedKeywords().isEmpty());
be2.addKeywords(be.getSeparatedKeywords());
Assert.assertArrayEquals(expected2, be2.getSeparatedKeywords().toArray());
be2.putKeywords(kw);
Assert.assertArrayEquals(expected, be2.getSeparatedKeywords().toArray());
}
/**
* Shortcut usage to create a Parser and read the input.
*
* @param in the Reader to read from
* @throws IOException
*/
public static ParserResult parse(Reader in) throws IOException {
BibtexParser parser = new BibtexParser(in);
return parser.parse();
}
@Override
public boolean processQuery(String query, ImportInspector inspector, OutputPrinter status) {
String q;
try {
q = URLEncoder.encode(query, StandardCharsets.UTF_8.name());
} catch (UnsupportedEncodingException e) {
// this should never happen
status.setStatus(Localization.lang("Error"));
LOGGER.warn("Encoding issues", e);
return false;
}
String urlString = String.format(DiVAtoBibTeXFetcher.URL_PATTERN, q);
// Send the request
URL url;
try {
url = new URL(urlString);
} catch (MalformedURLException e) {
LOGGER.warn("Bad URL", e);
return false;
}
String bibtexString;
try {
URLDownload dl = new URLDownload(url);
bibtexString = dl.downloadToString(StandardCharsets.UTF_8);
} catch (FileNotFoundException e) {
status.showMessage(
Localization.lang("Unknown DiVA entry: '%0'.", query),
Localization.lang("Get BibTeX entry from DiVA"),
JOptionPane.INFORMATION_MESSAGE);
return false;
} catch (IOException e) {
LOGGER.warn("Communication problems", e);
return false;
}
BibEntry entry = BibtexParser.singleFromString(bibtexString);
if (entry != null) {
// Optionally add curly brackets around key words to keep the case
entry
.getFieldOptional(FieldName.TITLE)
.ifPresent(
title -> {
// Unit formatting
if (Globals.prefs.getBoolean(JabRefPreferences.USE_UNIT_FORMATTER_ON_SEARCH)) {
title = unitsToLatexFormatter.format(title);
}
// Case keeping
if (Globals.prefs.getBoolean(JabRefPreferences.USE_CASE_KEEPER_ON_SEARCH)) {
title = protectTermsFormatter.format(title);
}
entry.setField(FieldName.TITLE, title);
});
entry
.getFieldOptional("institution")
.ifPresent(
institution ->
entry.setField("institution", new UnicodeToLatexFormatter().format(institution)));
// Do not use the provided key
// entry.clearField(InternalBibtexFields.KEY_FIELD);
inspector.addEntry(entry);
return true;
}
return false;
}
@Override
public boolean processQuery(String query, ImportInspector inspector, OutputPrinter status) {
String q;
try {
q = URLEncoder.encode(query, StandardCharsets.UTF_8.name());
} catch (UnsupportedEncodingException e) {
// this should never happen
status.setStatus(Localization.lang("Error"));
e.printStackTrace();
return false;
}
String urlString = String.format(ISBNtoBibTeXFetcher.URL_PATTERN, q);
// Send the request
URL url;
try {
url = new URL(urlString);
} catch (MalformedURLException e) {
e.printStackTrace();
return false;
}
try (InputStream source = url.openStream()) {
String bibtexString;
try (Scanner scan = new Scanner(source)) {
bibtexString = scan.useDelimiter("\\A").next();
}
BibEntry entry = BibtexParser.singleFromString(bibtexString);
if (entry != null) {
// Optionally add curly brackets around key words to keep the case
String title = entry.getField("title");
if (title != null) {
// Unit formatting
if (Globals.prefs.getBoolean(JabRefPreferences.USE_UNIT_FORMATTER_ON_SEARCH)) {
title = unitFormatter.format(title);
}
// Case keeping
if (Globals.prefs.getBoolean(JabRefPreferences.USE_CASE_KEEPER_ON_SEARCH)) {
title = caseKeeper.format(title);
}
entry.setField("title", title);
}
inspector.addEntry(entry);
return true;
}
return false;
} catch (FileNotFoundException e) {
// invalid ISBN --> 404--> FileNotFoundException
status.showMessage(Localization.lang("Invalid ISBN"));
return false;
} catch (java.net.UnknownHostException e) {
// It is very unlikely that ebook.de is an unknown host
// It is more likely that we don't have an internet connection
status.showMessage(Localization.lang("No_Internet_Connection."));
return false;
} catch (Exception e) {
status.showMessage(e.toString());
return false;
}
}
private static BibtexEntry bibtexString2BibtexEntry(String s) throws IOException {
ParserResult result = BibtexParser.parse(new StringReader(s));
Collection<BibtexEntry> c = result.getDatabase().getEntries();
Assert.assertEquals(1, c.size());
return c.iterator().next();
}
