@Test
public void testIsValidNavigonUrl() throws IOException {
ParserResult result = read(TEST_PATH + "from-nmn.txt");
assertEquals(NmnUrlFormat.class, result.getFormat().getClass());
ParserResult plainResult = read(TEST_PATH + "from-nmn-plain.txt");
assertEquals(NmnUrlFormat.class, plainResult.getFormat().getClass());
}
/**
* Import an entry from an OAI2 archive. The BibtexEntry provided has to have the field
* OAI2_IDENTIFIER_FIELD set to the search string.
*
* @param key The OAI2 key to fetch from ArXiv.
* @return The imnported BibtexEntry or null if none.
*/
private BibtexDatabase importInspireEntries(String key, OutputPrinter frame) {
String url = constructUrl(key);
try {
HttpURLConnection conn = (HttpURLConnection) new URL(url).openConnection();
conn.setRequestProperty("User-Agent", "Jabref");
InputStream inputStream = conn.getInputStream();
INSPIREBibtexFilterReader reader =
new INSPIREBibtexFilterReader(new InputStreamReader(inputStream));
ParserResult pr = BibtexParser.parse(reader);
return pr.getDatabase();
} catch (IOException e) {
frame.showMessage(
Localization.lang("An Exception ocurred while accessing '%0'", url) + "\n\n" + e,
Localization.lang(getKeyName()),
JOptionPane.ERROR_MESSAGE);
} catch (RuntimeException e) {
frame.showMessage(
Localization.lang(
"An Error occurred while fetching from INSPIRE source (%0):", new String[] {url})
+ "\n\n"
+ e.getMessage(),
Localization.lang(getKeyName()),
JOptionPane.ERROR_MESSAGE);
}
return null;
}
@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);
}
/**
* After a JabRef version number has been parsed and put into _pr, parse the version number to
* determine the JabRef major and minor version number
*/
private void setMajorMinorVersions() {
String v = _pr.getJabrefVersion();
Pattern p = Pattern.compile("([0-9]+)\\.([0-9]+).*");
Matcher m = p.matcher(v);
if (!m.matches()) return;
if (m.groupCount() >= 2) {
_pr.setJabrefMajorVersion(Integer.parseInt(m.group(1)));
_pr.setJabrefMinorVersion(Integer.parseInt(m.group(2)));
}
}
/* (non-Javadoc)
* @see junit.framework.TestCase#setUp()
*/
@Before
public void setUp() throws Exception {
ParserResult result =
BibtexParser.parse(new FileReader(ImportDataTest.UNLINKED_FILES_TEST_BIB));
database = result.getDatabase();
entries = database.getEntries();
entry1 = database.getEntryByKey("entry1");
entry2 = database.getEntryByKey("entry2");
}
private BibtexDatabase parseBibtexDatabase(List<String> id, boolean abs) throws IOException {
if (id.isEmpty()) {
return null;
}
URLConnection conn;
try {
conn = new URL(IEEEXploreFetcher.IMPORT_URL).openConnection();
} catch (MalformedURLException e) {
e.printStackTrace();
return null;
}
conn.setDoInput(true);
conn.setDoOutput(true);
conn.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
conn.setRequestProperty("Referer", searchUrl);
PrintWriter out = new PrintWriter(conn.getOutputStream());
String recordIds = "";
for (String anId : id) {
recordIds += anId + " ";
}
recordIds = recordIds.trim();
String citation = abs ? "citation-abstract" : "citation-only";
String content =
"recordIds="
+ recordIds.replaceAll(" ", "%20")
+ "&fromPageName=&citations-format="
+ citation
+ "&download-format=download-bibtex";
System.out.println(content);
out.write(content);
out.flush();
out.close();
BufferedReader bufr = new BufferedReader(new InputStreamReader(conn.getInputStream()));
StringBuilder sb = new StringBuilder();
char[] buffer = new char[256];
while (true) {
int bytesRead = bufr.read(buffer);
if (bytesRead == -1) {
break;
}
for (int i = 0; i < bytesRead; i++) {
sb.append(buffer[i]);
}
}
System.out.println(sb);
ParserResult results = new BibtexParser(bufr).parse();
bufr.close();
return results.getDatabase();
}
public void checkEntryTypes(ParserResult _pr) {
for (BibtexEntry be : _db.getEntries()) {
if (be.getType() instanceof UnknownEntryType) {
// Look up the unknown type name in our map of parsed types:
Object o = entryTypes.get(be.getType().getName().toLowerCase());
if (o != null) {
BibtexEntryType type = (BibtexEntryType) o;
be.setType(type);
} else {
// System.out.println("Unknown entry type:
// "+be.getType().getName());
_pr.addWarning(
Globals.lang("unknown entry type")
+ ": "
+ be.getType().getName()
+ ". "
+ Globals.lang("Type set to 'other'")
+ ".");
be.setType(BibtexEntryType.OTHER);
}
}
}
}
void readRouteCharacteristics(
String testFileName,
RouteCharacteristics characteristics,
int characteristicsCount,
int[] positionCount)
throws IOException {
ParserResult result = read(testFileName);
List<BaseRoute> routes = getRouteCharacteristics(result.getAllRoutes(), characteristics);
if (routes == null || characteristicsCount == 0) {
assertNull(routes);
} else {
assertEquals(characteristicsCount, routes.size());
for (int i = 0; i < routes.size(); i++) {
BaseRoute route = routes.get(i);
assertEquals(characteristics, route.getCharacteristics());
assertEquals(positionCount[i], route.getPositionCount());
}
}
}
/** Adds a key->value assignment to the values HashMap */
private void createKeyValueAssignment(String line, int lineNr) {
String[] split = line.split("=");
if (split.length == 1) {
split = new String[] {split[0], ""};
}
if (split[0].matches(PlotConstants.KEY_INT_GRID_WIDTH)) {
parserResult.addPlotGridValue(split[0], new KeyValue(split[0], split[1], lineNr));
} else {
tempPlotValuesCache.put(split[0], new KeyValue(split[0], split[1], lineNr));
}
}
public ParserResult parse(String source) {
List<String> inputList = Arrays.asList(source.split("\n", -1));
ListIterator<String> inputIterator = inputList.listIterator();
while (inputIterator.hasNext()) {
String line = inputIterator.next();
if (line.isEmpty() || line.matches(PlotConstants.REGEX_COMMENT)) {
/* ignore empty lines and comments */
} else if (line.matches(PlotConstants.REGEX_PLOT)) {
parserResult.addPlotState(createPlotStateObject(line.split(" "), inputIterator));
} else if (line.matches(PlotConstants.REGEX_PLOT_ADD)) {
List<PlotState> plotStates = parserResult.getPlotStateList();
if (plotStates.isEmpty()) {
// if no plotStates, create a new one
parserResult.addPlotState(createPlotStateObject(line.split(" "), inputIterator));
} else {
// if plots exist, add new plotState to last plotState
PlotState last = plotStates.get(plotStates.size() - 1);
last.addSubPlot(createPlotStateObject(line.split(" "), inputIterator));
}
} else if (line.matches(PlotConstants.REGEX_DATA)) {
createDatasetObject(line.split(" "), inputIterator);
} else if (line.matches(PlotConstants.REGEX_DATA_GUESS)) {
inputIterator
.previous(); // Must go 1 step back to avoid skipping the first line in
// createDatasetObject
createDatasetObject(new String[] {PlotConstants.DATA}, inputIterator);
} else if (line.matches(PlotConstants.REGEX_VALUE_ASSIGNMENT)) {
createKeyValueAssignment(line, inputIterator.nextIndex());
} else {
throw new ParserException(
"Invalid line: " + line + "(line: " + inputIterator.nextIndex() + ")");
}
}
analyseDatasets();
addDatasetsToPlotStates();
return parserResult;
}
/** Is called after parsing everything to fill datasets in each plotState Object */
private void addDatasetsToPlotStates() {
if (datasetList.isEmpty()) {
throw new ParserException("You must specify at least one dataset.");
}
int actualAutoDatasetNr = 0;
for (PlotState plotState : parserResult.getPlotStateList()) {
actualAutoDatasetNr = addDataset(plotState, actualAutoDatasetNr);
// also add datasets to subplots
for (PlotState subPlotState : plotState.getSubplots()) {
log.info("Add dataset for subplot");
actualAutoDatasetNr = addDataset(subPlotState, actualAutoDatasetNr);
}
}
}
ParserResult read(String testFileName) throws IOException {
File source = new File(testFileName);
ParserResult result = parser.read(source);
assertNotNull(result.getFormat());
assertNotNull(result.getAllRoutes());
assertTrue(result.getAllRoutes().size() > 0);
assertNotNull("Cannot read route from " + source, result.getTheRoute());
assertTrue(result.getTheRoute().getPositionCount() > 0);
return result;
}
/**
* Tries to restore the key
*
* @return rest of key on success, otherwise empty string
* @throws IOException on Reader-Error
*/
private String fixKey() throws IOException {
StringBuilder key = new StringBuilder();
int lookahead_used = 0;
char currentChar;
// Find a char which ends key (','&&'\n') or entryfield ('='):
do {
currentChar = (char) read();
key.append(currentChar);
lookahead_used++;
} while ((currentChar != ',' && currentChar != '\n' && currentChar != '=')
&& (lookahead_used < LOOKAHEAD));
// Consumed a char too much, back into reader and remove from key:
unread(currentChar);
key.deleteCharAt(key.length() - 1);
// Restore if possible:
switch (currentChar) {
case '=':
// Get entryfieldname, push it back and take rest as key
key = key.reverse();
boolean matchedAlpha = false;
for (int i = 0; i < key.length(); i++) {
currentChar = key.charAt(i);
/// Skip spaces:
if (!matchedAlpha && currentChar == ' ') {
continue;
}
matchedAlpha = true;
// Begin of entryfieldname (e.g. author) -> push back:
unread(currentChar);
if (currentChar == ' ' || currentChar == '\n') {
/*
* found whitespaces, entryfieldname completed -> key in
* keybuffer, skip whitespaces
*/
StringBuilder newKey = new StringBuilder();
for (int j = i; j < key.length(); j++) {
currentChar = key.charAt(j);
if (!Character.isWhitespace(currentChar)) {
newKey.append(currentChar);
}
}
// Finished, now reverse newKey and remove whitespaces:
_pr.addWarning(
Globals.lang("Line %0: Found corrupted BibTeX-key.", String.valueOf(line)));
key = newKey.reverse();
}
}
break;
case ',':
_pr.addWarning(
Globals.lang(
"Line %0: Found corrupted BibTeX-key (contains whitespaces).",
String.valueOf(line)));
case '\n':
_pr.addWarning(
Globals.lang(
"Line %0: Found corrupted BibTeX-key (comma missing).", String.valueOf(line)));
break;
default:
// No more lookahead, give up:
unreadBuffer(key);
return "";
}
return removeWhitespaces(key).toString();
}
/**
* Will parse the BibTex-Data found when reading from reader.
*
* <p>The reader will be consumed.
*
* <p>Multiple calls to parse() return the same results
*
* @return ParserResult
* @throws IOException
*/
public ParserResult parse() throws IOException {
// If we already parsed this, just return it.
if (_pr != null) return _pr;
_db = new BibtexDatabase(); // Bibtex related contents.
_meta = new HashMap<String, String>(); // Metadata in comments for Bibkeeper.
entryTypes = new HashMap<String, BibtexEntryType>(); // To store custem entry types parsed.
_pr = new ParserResult(_db, _meta, entryTypes);
// First see if we can find the version number of the JabRef version that
// wrote the file:
String versionNum = readJabRefVersionNumber();
if (versionNum != null) {
_pr.setJabrefVersion(versionNum);
setMajorMinorVersions();
} else {
// No version number found. However, we have only
}
skipWhitespace();
try {
while (!_eof) {
boolean found = consumeUncritically('@');
if (!found) break;
skipWhitespace();
String entryType = parseTextToken();
BibtexEntryType tp = BibtexEntryType.getType(entryType);
boolean isEntry = (tp != null);
// Util.pr(tp.getName());
if (!isEntry) {
// The entry type name was not recognized. This can mean
// that it is a string, preamble, or comment. If so,
// parse and set accordingly. If not, assume it is an entry
// with an unknown type.
if (entryType.toLowerCase().equals("preamble")) {
_db.setPreamble(parsePreamble());
} else if (entryType.toLowerCase().equals("string")) {
BibtexString bs = parseString();
try {
_db.addString(bs);
} catch (KeyCollisionException ex) {
_pr.addWarning(Globals.lang("Duplicate string name") + ": " + bs.getName());
// ex.printStackTrace();
}
} else if (entryType.toLowerCase().equals("comment")) {
StringBuffer commentBuf = parseBracketedTextExactly();
/**
* Metadata are used to store Bibkeeper-specific information in .bib files.
*
* <p>Metadata are stored in bibtex files in the format
*
* @comment{jabref-meta: type:data0;data1;data2;...}
* <p>Each comment that starts with the META_FLAG is stored in the meta HashMap,
* with type as key. Unluckily, the old META_FLAG bibkeeper-meta: was used in JabRef
* 1.0 and 1.1, so we need to support it as well. At least for a while. We'll always
* save with the new one.
*/
String comment = commentBuf.toString().replaceAll("[\\x0d\\x0a]", "");
if (comment
.substring(0, Math.min(comment.length(), GUIGlobals.META_FLAG.length()))
.equals(GUIGlobals.META_FLAG)
|| comment
.substring(0, Math.min(comment.length(), GUIGlobals.META_FLAG_OLD.length()))
.equals(GUIGlobals.META_FLAG_OLD)) {
String rest;
if (comment.substring(0, GUIGlobals.META_FLAG.length()).equals(GUIGlobals.META_FLAG))
rest = comment.substring(GUIGlobals.META_FLAG.length());
else rest = comment.substring(GUIGlobals.META_FLAG_OLD.length());
int pos = rest.indexOf(':');
if (pos > 0) _meta.put(rest.substring(0, pos), rest.substring(pos + 1));
// We remove all line breaks in the metadata - these
// will have been inserted
// to prevent too long lines when the file was
// saved, and are not part of the data.
}
/**
* A custom entry type can also be stored in a
*
* @comment:
*/
if (comment
.substring(0, Math.min(comment.length(), GUIGlobals.ENTRYTYPE_FLAG.length()))
.equals(GUIGlobals.ENTRYTYPE_FLAG)) {
CustomEntryType typ = CustomEntryType.parseEntryType(comment);
entryTypes.put(typ.getName().toLowerCase(), typ);
}
} else {
// The entry type was not recognized. This may mean that
// it is a custom entry type whose definition will
// appear
// at the bottom of the file. So we use an
// UnknownEntryType
// to remember the type name by.
tp = new UnknownEntryType(entryType.toLowerCase());
// System.out.println("unknown type: "+entryType);
isEntry = true;
}
}
if (isEntry) // True if not comment, preamble or string.
{
/**
* Morten Alver 13 Aug 2006: Trying to make the parser more robust. If an exception is
* thrown when parsing an entry, drop the entry and try to resume parsing. Add a warning
* for the user.
*
* <p>An alternative solution is to try rescuing the entry for which parsing failed, by
* returning the entry with the exception and adding it before parsing is continued.
*/
try {
BibtexEntry be = parseEntry(tp);
boolean duplicateKey = _db.insertEntry(be);
if (duplicateKey) // JZTODO lyrics
_pr.addWarning(
Globals.lang("duplicate BibTeX key")
+ ": "
+ be.getCiteKey()
+ " ("
+ Globals.lang("grouping may not work for this entry")
+ ")");
else if (be.getCiteKey() == null || be.getCiteKey().equals("")) {
_pr.addWarning(
Globals.lang("empty BibTeX key")
+ ": "
+ be.getAuthorTitleYear(40)
+ " ("
+ Globals.lang("grouping may not work for this entry")
+ ")");
}
} catch (IOException ex) {
ex.printStackTrace();
_pr.addWarning(
Globals.lang("Error occured when parsing entry")
+ ": '"
+ ex.getMessage()
+ "'. "
+ Globals.lang("Skipped entry."));
}
}
skipWhitespace();
}
// Before returning the database, update entries with unknown type
// based on parsed type definitions, if possible.
checkEntryTypes(_pr);
return _pr;
} catch (KeyCollisionException kce) {
// kce.printStackTrace();
throw new IOException("Duplicate ID in bibtex file: " + kce.toString());
}
}
public static void main(String[] args) throws Exception {
boolean createSampleSet = Boolean.parseBoolean(args[2]);
int sampleSetSize = 0;
if (createSampleSet) {
sampleSetSize = Integer.parseInt(args[3]);
}
boolean dryRun = Boolean.parseBoolean(args[1]);
File basePath = new File(args[0]);
if (basePath.exists()) {
File artistsFile = null;
File labelsFile = null;
File mastersFile = null;
File releasesFile = null;
for (File child : basePath.listFiles()) {
if (child.isFile()) {
String filename = child.getName().toLowerCase();
if (filename.endsWith("_artists.xml")) {
artistsFile = child;
} else if (filename.endsWith("_labels.xml")) {
labelsFile = child;
} else if (filename.endsWith("_masters.xml")) {
mastersFile = child;
} else if (filename.endsWith("_releases.xml")) {
releasesFile = child;
}
}
}
if (artistsFile == null
|| labelsFile == null
|| mastersFile == null
|| releasesFile == null) {
throw new IllegalStateException("Not all needed files found");
}
List<Artist> artists = null;
ParserResult<Artist> artistParserResult = null;
try (FileInputStream is = new FileInputStream(artistsFile)) {
StaxParser<Artist> parser = new ArtistStaxParser(dryRun);
artistParserResult = parser.parse(is);
artists = artistParserResult.getResult();
}
List<Label> labels = null;
ParserResult<Label> labelParserResult = null;
try (FileInputStream is = new FileInputStream(labelsFile)) {
StaxParser<Label> parser = new LabelStaxParser(dryRun);
labelParserResult = parser.parse(is);
labels = labelParserResult.getResult();
}
List<Master> masters = null;
ParserResult<Master> masterParserResult = null;
try (FileInputStream is = new FileInputStream(mastersFile)) {
StaxParser<Master> parser = new MasterStaxParser(dryRun);
masterParserResult = parser.parse(is);
masters = masterParserResult.getResult();
}
List<Release> releases = null;
ParserResult<Release> releaseParserResult = null;
try (FileInputStream is = new FileInputStream(releasesFile)) {
StaxParser<Release> parser = new ReleaseStaxParser(dryRun, sampleSetSize);
releaseParserResult = parser.parse(is);
releases = releaseParserResult.getResult();
}
System.out.println("Found " + artistParserResult);
System.out.println("Found " + labelParserResult);
System.out.println("Found " + masterParserResult);
System.out.println("Found " + releaseParserResult);
if (createSampleSet) {
System.out.println("Collecting data for sample dataset...");
Set<Artist> neededArtist = new HashSet<>(artists.size() / 1000);
for (Release release : releases) {
for (ArtistRef ref : release.getArtists()) {
Artist artist = findArtist(ref.getArtistId(), artists);
if (artist != null) {
neededArtist.add(artist);
}
}
for (ArtistRef ref : release.getExtraArtists()) {
Artist artist = findArtist(ref.getArtistId(), artists);
if (artist != null) {
neededArtist.add(artist);
}
}
}
File file = new File(basePath, "dataset.sample");
FileOutputStream fos = new FileOutputStream(file);
SerializationServiceBuilder builder = new SerializationServiceBuilder();
SerializationService ss =
builder
.setAllowUnsafe(true)
.setClassLoader(StaxParser.class.getClassLoader())
.setEnableCompression(true)
.setPartitioningStrategy(new DefaultPartitioningStrategy())
.setCheckClassDefErrors(true)
.setByteOrder(ByteOrder.BIG_ENDIAN)
.build();
BufferedOutputStream bos = new BufferedOutputStream(fos);
ObjectDataOutputStream out = new ObjectDataOutputStream(bos, ss, ByteOrder.BIG_ENDIAN);
System.out.println("Writing " + neededArtist.size() + " artists to sample dataset...");
out.writeInt(neededArtist.size());
for (Artist artist : neededArtist) {
out.writeObject(artist);
}
System.out.println("Writing " + labels.size() + " labels to sample dataset...");
out.writeInt(labels.size());
for (Label label : labels) {
out.writeObject(label);
}
System.out.println("Writing " + masters.size() + " masters to sample dataset...");
out.writeInt(masters.size());
for (Master master : masters) {
out.writeObject(master);
}
System.out.println("Writing " + releases.size() + " releases to sample dataset...");
out.writeInt(releases.size());
for (Release release : releases) {
out.writeObject(release);
}
out.flush();
out.close();
}
}
}
@Test
public void testReadWithFormatList() throws IOException {
List<NavigationFormat> formats = new ArrayList<>();
ParserResult result1 = parser.read(new File(TEST_PATH + "from.itn"), formats);
assertFalse(result1.isSuccessful());
formats.add(new TomTom8RouteFormat());
ParserResult result2 = parser.read(new File(TEST_PATH + "from.itn"), formats);
assertTrue(result2.isSuccessful());
assertEquals(0, result2.getTheRoute().getPositions().size());
assertEquals(1, result2.getAllRoutes().size());
assertEquals(result2.getFormat().getClass(), TomTom8RouteFormat.class);
formats.add(new TomTom5RouteFormat());
ParserResult result3 = parser.read(new File(TEST_PATH + "from.itn"), formats);
assertTrue(result3.isSuccessful());
assertEquals(46, result3.getTheRoute().getPositions().size());
assertEquals(1, result3.getAllRoutes().size());
assertEquals(result3.getFormat().getClass(), TomTom5RouteFormat.class);
}
@Test
public void testIsValidGoogleMapsUrl() throws IOException {
ParserResult result = read(TEST_PATH + "from-googlemaps.url");
assertEquals(GoogleMapsUrlFormat.class, result.getFormat().getClass());
}
