You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@commonsrdf.apache.org by st...@apache.org on 2016/09/28 13:52:13 UTC
[21/36] incubator-commonsrdf git commit: Quad-support for
RDFParserBuildler
Quad-support for RDFParserBuildler
This changes intoGraph() to target(?)
where ? can be a Graph, Dataset or Consumer<Quad>
similarly parse() returns a Future<ParseResult> rather than
Future<Graph> - as there might not be any Graph
Project: http://git-wip-us.apache.org/repos/asf/incubator-commonsrdf/repo
Commit: http://git-wip-us.apache.org/repos/asf/incubator-commonsrdf/commit/defdbd91
Tree: http://git-wip-us.apache.org/repos/asf/incubator-commonsrdf/tree/defdbd91
Diff: http://git-wip-us.apache.org/repos/asf/incubator-commonsrdf/diff/defdbd91
Branch: refs/heads/master
Commit: defdbd9160561ae93e8558a8f2c6cc27507b22bb
Parents: bb90a6e
Author: Stian Soiland-Reyes <st...@apache.org>
Authored: Wed Apr 13 16:50:31 2016 +0100
Committer: Stian Soiland-Reyes <st...@apache.org>
Committed: Wed Apr 13 16:50:31 2016 +0100
----------------------------------------------------------------------
.../commons/rdf/api/RDFParserBuilder.java | 174 ++++++++++++++-----
.../rdf/simple/AbstractRDFParserBuilder.java | 61 ++++---
.../simple/AbstractRDFParserBuilderTest.java | 40 +++--
.../rdf/simple/DummyRDFParserBuilder.java | 34 ++--
4 files changed, 209 insertions(+), 100 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/incubator-commonsrdf/blob/defdbd91/api/src/main/java/org/apache/commons/rdf/api/RDFParserBuilder.java
----------------------------------------------------------------------
diff --git a/api/src/main/java/org/apache/commons/rdf/api/RDFParserBuilder.java b/api/src/main/java/org/apache/commons/rdf/api/RDFParserBuilder.java
index 1425263..0494502 100644
--- a/api/src/main/java/org/apache/commons/rdf/api/RDFParserBuilder.java
+++ b/api/src/main/java/org/apache/commons/rdf/api/RDFParserBuilder.java
@@ -22,58 +22,71 @@ import java.io.InputStream;
import java.nio.charset.StandardCharsets;
import java.nio.file.Path;
import java.util.concurrent.Future;
+import java.util.function.Consumer;
/**
- * Builder for parsing an RDF source into a Graph.
+ * Builder for parsing an RDF source into a target (e.g. a Graph/Dataset).
* <p>
* This interface follows the
* <a href="https://en.wikipedia.org/wiki/Builder_pattern">Builder pattern</a>,
* allowing to set parser settings like {@link #contentType(RDFSyntax)} and
* {@link #base(IRI)}. A caller MUST call one of the <code>source</code> methods
* (e.g. {@link #source(IRI)}, {@link #source(Path)},
- * {@link #source(InputStream)}) before calling {@link #parse()} on the returned
+ * {@link #source(InputStream)}), and MUST call one of the <code>target</code>
+ * methods (e.g. {@link #target(Consumer)}, {@link #target(Dataset)},
+ * {@link #target(Graph)}) before calling {@link #parse()} on the returned
* RDFParserBuilder - however methods can be called in any order.
* <p>
- * The call to {@link #parse()} returns a {@link Future}, allowing asynchronous parse
- * operations. This can be combined with {@link #intoGraph(Graph)}
- * allowing access to the graph before parsing has completed,
- * however callers are still recommended to to check
- * {@link Future#get()} for any exceptions thrown during parsing.
+ * The call to {@link #parse()} returns a {@link Future}, allowing asynchronous
+ * parse operations. Callers are recommended to check {@link Future#get()} to
+ * ensure parsing completed successfully, or catch exceptions thrown during
+ * parsing.
* <p>
* Setting a method that has already been set will override any existing value
* in the returned builder - irregardless of the parameter type (e.g.
* {@link #source(IRI)} will override a previous {@link #source(Path)}. Settings
- * can be unset by passing <code>null</code> - this may require casting, e.g.
- * <code>contentType( (RDFSyntax) null )</code> to undo a previous call to
- * {@link #contentType(RDFSyntax)}.
+ * can be unset by passing <code>null</code> - note that this may
+ * require casting, e.g. <code>contentType( (RDFSyntax) null )</code>
+ * to undo a previous call to {@link #contentType(RDFSyntax)}.
* <p>
* It is undefined if a RDFParserBuilder is mutable or thread-safe, so callers
* should always use the returned modified RDFParserBuilder from the builder
- * methods. The builder may return itself, or a cloned builder with the modified
- * settings applied. Implementations are however encouraged to be
- * immutable and thread-safe and document this,
- * as an example starting point, see
+ * methods. The builder may return itself after modification,
+ * or a cloned builder with the modified settings applied.
+ * Implementations are however encouraged to be immutable,
+ * thread-safe and document this. As an example starting point, see
* {@link org.apache.commons.rdf.simple.AbstractRDFParserBuilder}.
* <p>
* Example usage:
* </p>
*
* <pre>
- * // Retrieve populated graph from the Future
- * Graph g1 = ExampleRDFParserBuilder.source("http://example.com/graph.rdf").parse().get(30, TimeUnit.Seconds);
- * // Or parsing into an existing Graph:
- * ExampleRDFParserBuilder.source(Paths.get("/tmp/graph.ttl").contentType(RDFSyntax.TURTLE).intoGraph(g1).parse();
+ * Graph g1 = rDFTermFactory.createGraph();
+ * new ExampleRDFParserBuilder()
+ * .source(Paths.get("/tmp/graph.ttl"))
+ * .contentType(RDFSyntax.TURTLE)
+ * .target(g1)
+ * .parse().get(30, TimeUnit.Seconds);
* </pre>
- *
*
*/
public interface RDFParserBuilder {
+ /**
+ * The result of {@link RDFParserBuilder#parse()} indicating
+ * parsing completed.
+ * <p>
+ * This is a marker interface that may be subclassed to include
+ * parser details, e.g. warning messages or triple counts.
+ */
+ public interface ParseResult {
+ }
+
/**
* Specify which {@link RDFTermFactory} to use for generating
* {@link RDFTerm}s.
* <p>
- * This option may be used together with {@link #intoGraph(Graph)} to
+ * This option may be used together with {@link #target(Graph)} to
* override the implementation's default factory and graph.
* <p>
* <strong>Warning:</strong> Using the same {@link RDFTermFactory} for
@@ -82,7 +95,7 @@ public interface RDFParserBuilder {
* use the {@link RDFTermFactory#createBlankNode(String)} method
* from the parsed blank node labels.
*
- * @see #intoGraph(Graph)
+ * @see #target(Graph)
* @param rdfTermFactory
* {@link RDFTermFactory} to use for generating RDFTerms.
* @return An {@link RDFParserBuilder} that will use the specified
@@ -144,30 +157,97 @@ public interface RDFParserBuilder {
RDFParserBuilder contentType(String contentType) throws IllegalArgumentException;
/**
- * Specify which {@link Graph} to add triples to.
- * <p>
- * The default (if this option has not been set) is that each call to
- * {@link #parse()} return a new {@link Graph}, which is created using
- * {@link RDFTermFactory#createGraph()} if
- * {@link #rdfTermFactory(RDFTermFactory)} has been set.
- * <p>
- * It is undefined if any triples are added to the specified
- * {@link Graph} if the {@link Future#get()} returned from
- * {@link #parse()} throws any exceptions. (However
- * implementations are free to prevent this using transaction
- * mechanisms or similar). However, if {@link Future#get()}
- * does not indicatean exception, the
- * parser implementation SHOULD have inserted all parsed triples
- * to the specified graph.
+ * Specify a {@link Graph} to add parsed triples to.
+ * <p>
+ * If the source supports datasets (e.g. the {@link #contentType(RDFSyntax)}
+ * set has {@link RDFSyntax#supportsDataset} is true)), then only quads in
+ * the <em>default graph</em> will be added to the Graph as {@link Triple}s.
+ * <p>
+ * It is undefined if any triples are added to the specified {@link Graph}
+ * if {@link #parse()} throws any exceptions. (However implementations are
+ * free to prevent this using transaction mechanisms or similar). If
+ * {@link Future#get()} does not indicate an exception, the parser
+ * implementation SHOULD have inserted all parsed triples to the specified
+ * graph.
+ * <p>
+ * Calling this method will override any earlier targets set with
+ * {@link #target(Graph)}, {@link #target(Consumer)} or
+ * {@link #target(Dataset)}.
+ * <p>
+ * The default implementation of this method calls {@link #target(Consumer)}
+ * with a {@link Consumer} that does {@link Graph#add(Triple)} with
+ * {@link Quad#asTriple()} if the quad is in the default graph.
*
* @param graph
- * The {@link Graph} to add triples into.
+ * The {@link Graph} to add triples to.
* @return An {@link RDFParserBuilder} that will insert triples into the
* specified graph.
*/
- RDFParserBuilder intoGraph(Graph graph);
+ default RDFParserBuilder target(Graph graph) {
+ return target(q -> {
+ if (! q.getGraphName().isPresent()) {
+ graph.add(q.asTriple());
+ }
+ });
+ }
/**
+ * Specify a {@link Dataset} to add parsed quads to.
+ * <p>
+ * It is undefined if any quads are added to the specified
+ * {@link Dataset} if {@link #parse()} throws any exceptions.
+ * (However implementations are free to prevent this using transaction
+ * mechanisms or similar). On the other hand, if {@link #parse()}
+ * does not indicate an exception, the
+ * implementation SHOULD have inserted all parsed quads
+ * to the specified dataset.
+ * <p>
+ * Calling this method will override any earlier targets set with
+ * {@link #target(Graph)}, {@link #target(Consumer)} or {@link #target(Dataset)}.
+ * <p>
+ * The default implementation of this method calls {@link #target(Consumer)}
+ * with a {@link Consumer} that does {@link Dataset#add(Quad)}.
+ *
+ * @param dataset
+ * The {@link Dataset} to add quads to.
+ * @return An {@link RDFParserBuilder} that will insert triples into the
+ * specified dataset.
+ */
+ default RDFParserBuilder target(Dataset dataset) {
+ return target(dataset::add);
+ }
+
+ /**
+ * Specify a consumer for parsed quads.
+ * <p>
+ * It is undefined if any quads are consumed if {@link #parse()} throws any
+ * exceptions. On the other hand, if {@link #parse()} does not indicate an
+ * exception, the implementation SHOULD have produced all parsed quads to
+ * the specified consumer.
+ * <p>
+ * Calling this method will override any earlier targets set with
+ * {@link #target(Graph)}, {@link #target(Consumer)} or
+ * {@link #target(Dataset)}.
+ * <p>
+ * The consumer is not assumed to be thread safe - only one
+ * {@link Consumer#accept(Object)} is delivered at a time for a given
+ * {@link RDFParserBuilder#parse()} call.
+ * <p>
+ * This method is typically called with a functional consumer, for example:
+ * <pre>
+ * List<Quad> quads = new ArrayList<Quad>;
+ * parserBuilder.target(quads::add).parse();
+ * </pre>
+ *
+ * @param consumer
+ * A {@link Consumer} of {@link Quad}s
+ * @return An {@link RDFParserBuilder} that will call the consumer for into
+ * the specified dataset.
+ * @return
+ */
+ RDFParserBuilder target(Consumer<Quad> consumer);
+
+ /**
* Specify a base IRI to use for parsing any relative IRI references.
* <p>
* Setting this option will override any protocol-specific base IRI (e.g.
@@ -345,6 +425,11 @@ public interface RDFParserBuilder {
* method) MUST have been called before calling this method, otherwise an
* {@link IllegalStateException} will be thrown.
* <p>
+ * A target method (e.g. {@link #target(Consumer)}, {@link #target(Dataset)}
+ * , {@link #target(Graph)} or an equivalent subclass method) MUST have been
+ * called before calling this method, otherwise an
+ * {@link IllegalStateException} will be thrown.
+ * <p>
* It is undefined if this method is thread-safe, however the
* {@link RDFParserBuilder} may be reused (e.g. setting a different source)
* as soon as the {@link Future} has been returned from this method.
@@ -357,12 +442,15 @@ public interface RDFParserBuilder {
* synchronous implementation MAY be blocking on the <code>parse()</code>
* call and return a Future that is already {@link Future#isDone()}.
* <p>
- * If {@link #intoGraph(Graph)} has been specified, this SHOULD be the same
- * {@link Graph} instance returned from {@link Future#get()} once parsing has
- * completed successfully.
+ * The returned {@link Future} contains a {@link ParseResult}.
+ * Implementations may subclass this interface to provide any
+ * parser details, e.g. list of warnings. <code>null</code> is a
+ * possible return value if no details are available, but
+ * parsing succeeded.
* <p>
* If an exception occurs during parsing, (e.g. {@link IOException} or
- * {@link java.text.ParseException}), it should be indicated as the
+ * {@link org.apache.commons.rdf.simple.AbstractRDFParserBuilder.RDFParseException}),
+ * it should be indicated as the
* {@link java.util.concurrent.ExecutionException#getCause()} in the
* {@link java.util.concurrent.ExecutionException} thrown on
* {@link Future#get()}.
@@ -380,5 +468,5 @@ public interface RDFParserBuilder {
* If the builder is in an invalid state, e.g. a
* <code>source</code> has not been set.
*/
- Future<Graph> parse() throws IOException, IllegalStateException;
+ Future<? extends ParseResult> parse() throws IOException, IllegalStateException;
}
http://git-wip-us.apache.org/repos/asf/incubator-commonsrdf/blob/defdbd91/simple/src/main/java/org/apache/commons/rdf/simple/AbstractRDFParserBuilder.java
----------------------------------------------------------------------
diff --git a/simple/src/main/java/org/apache/commons/rdf/simple/AbstractRDFParserBuilder.java b/simple/src/main/java/org/apache/commons/rdf/simple/AbstractRDFParserBuilder.java
index ab37eef..9544928 100644
--- a/simple/src/main/java/org/apache/commons/rdf/simple/AbstractRDFParserBuilder.java
+++ b/simple/src/main/java/org/apache/commons/rdf/simple/AbstractRDFParserBuilder.java
@@ -26,9 +26,10 @@ import java.util.Optional;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
+import java.util.function.Consumer;
-import org.apache.commons.rdf.api.Graph;
import org.apache.commons.rdf.api.IRI;
+import org.apache.commons.rdf.api.Quad;
import org.apache.commons.rdf.api.RDFParserBuilder;
import org.apache.commons.rdf.api.RDFSyntax;
import org.apache.commons.rdf.api.RDFTermFactory;
@@ -111,15 +112,14 @@ public abstract class AbstractRDFParserBuilder implements RDFParserBuilder, Clon
}
/**
- * Get the set {@link Graph} to insert into, if any.
+ * Get the target to consume parsed Quads.
* <p>
* From the call to {@link #parseSynchronusly()}, this
- * method is always {@link Optional#isPresent()}
- * with a new {@link Graph} instance, and
- * will be the value returned from {@link #parse()}.
+ * method is always {@link Optional#isPresent()}.
+ *
*/
- public Optional<Graph> getIntoGraph() {
- return intoGraph;
+ public Consumer<Quad> getTarget() {
+ return target;
}
/**
@@ -167,11 +167,11 @@ public abstract class AbstractRDFParserBuilder implements RDFParserBuilder, Clon
private Optional<RDFTermFactory> rdfTermFactory = Optional.empty();
private Optional<RDFSyntax> contentTypeSyntax = Optional.empty();
private Optional<String> contentType = Optional.empty();
- private Optional<Graph> intoGraph = Optional.empty();
private Optional<IRI> base = Optional.empty();
private Optional<InputStream> sourceInputStream = Optional.empty();
private Optional<Path> sourceFile = Optional.empty();
private Optional<IRI> sourceIri = Optional.empty();
+ private Consumer<Quad> target;
@Override
public AbstractRDFParserBuilder clone() {
@@ -206,13 +206,6 @@ public abstract class AbstractRDFParserBuilder implements RDFParserBuilder, Clon
}
@Override
- public RDFParserBuilder intoGraph(Graph graph) {
- AbstractRDFParserBuilder c = clone();
- c.intoGraph = Optional.ofNullable(graph);
- return c;
- }
-
- @Override
public RDFParserBuilder base(IRI base) {
AbstractRDFParserBuilder c = clone();
c.base = Optional.ofNullable(base);
@@ -361,8 +354,10 @@ public abstract class AbstractRDFParserBuilder implements RDFParserBuilder, Clon
*/
protected AbstractRDFParserBuilder prepareForParsing() throws IOException, IllegalStateException {
checkSource();
- checkBaseRequired();
+ checkBaseRequired();
checkContentType();
+ checkTarget();
+
// We'll make a clone of our current state which will be passed to
// parseSynchronously()
AbstractRDFParserBuilder c = clone();
@@ -371,10 +366,6 @@ public abstract class AbstractRDFParserBuilder implements RDFParserBuilder, Clon
if (!c.rdfTermFactory.isPresent()) {
c.rdfTermFactory = Optional.of(createRDFTermFactory());
}
- // No graph? We'll create one.
- if (!c.intoGraph.isPresent()) {
- c.intoGraph = c.rdfTermFactory.map(RDFTermFactory::createGraph);
- }
// sourceFile, but no base? Let's follow any symlinks and use
// the file:/// URI
if (c.sourceFile.isPresent() && !c.base.isPresent()) {
@@ -386,6 +377,19 @@ public abstract class AbstractRDFParserBuilder implements RDFParserBuilder, Clon
}
/**
+ * Subclasses can override this method to check the target is
+ * valid.
+ * <p>
+ * The default implementation throws an IllegalStateException if the
+ * target has not been set.
+ */
+ protected void checkTarget() {
+ if (target == null) {
+ throw new IllegalStateException("target has not been set");
+ }
+ }
+
+ /**
* Subclasses can override this method to check compatibility with the
* contentType setting.
*
@@ -441,13 +445,11 @@ public abstract class AbstractRDFParserBuilder implements RDFParserBuilder, Clon
* <p>
* This is called by {@link #parse()} to set
* {@link #rdfTermFactory(RDFTermFactory)} if it is
- * {@link Optional#empty()}, and therefore used also for
- * creating a new {@link Graph} if
- * {@link #getIntoGraph()} is {@link Optional#empty()}.
+ * {@link Optional#empty()}.
* <p>
* As parsed blank nodes might be made with
* {@link RDFTermFactory#createBlankNode(String)},
- * each call to this method should return
+ * each call to this method SHOULD return
* a new RDFTermFactory instance.
*
* @return A new {@link RDFTermFactory}
@@ -457,12 +459,19 @@ public abstract class AbstractRDFParserBuilder implements RDFParserBuilder, Clon
}
@Override
- public Future<Graph> parse() throws IOException, IllegalStateException {
+ public Future<ParseResult> parse() throws IOException, IllegalStateException {
final AbstractRDFParserBuilder c = prepareForParsing();
return threadpool.submit(() -> {
c.parseSynchronusly();
- return c.intoGraph.get();
+ return null;
});
}
+ @Override
+ public RDFParserBuilder target(Consumer<Quad> consumer) {
+ AbstractRDFParserBuilder c = clone();
+ c.target = consumer;
+ return c;
+ }
+
}
http://git-wip-us.apache.org/repos/asf/incubator-commonsrdf/blob/defdbd91/simple/src/test/java/org/apache/commons/rdf/simple/AbstractRDFParserBuilderTest.java
----------------------------------------------------------------------
diff --git a/simple/src/test/java/org/apache/commons/rdf/simple/AbstractRDFParserBuilderTest.java b/simple/src/test/java/org/apache/commons/rdf/simple/AbstractRDFParserBuilderTest.java
index d23e1c8..439bacb 100644
--- a/simple/src/test/java/org/apache/commons/rdf/simple/AbstractRDFParserBuilderTest.java
+++ b/simple/src/test/java/org/apache/commons/rdf/simple/AbstractRDFParserBuilderTest.java
@@ -17,7 +17,10 @@
*/
package org.apache.commons.rdf.simple;
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
import java.io.ByteArrayInputStream;
import java.io.IOException;
@@ -102,9 +105,10 @@ public class AbstractRDFParserBuilderTest {
}
@Test
- public void parseFile() throws Exception {
- RDFParserBuilder parser = dummyParser.source(testNt);
- Graph g = parser.parse().get(5, TimeUnit.SECONDS);
+ public void parseFile() throws Exception {
+ Graph g = factory.createGraph();
+ RDFParserBuilder parser = dummyParser.source(testNt).target(g);
+ parser.parse().get(5, TimeUnit.SECONDS);
checkGraph(g);
// FIXME: this could potentially break if the equivalent of /tmp includes
// international characters
@@ -148,8 +152,12 @@ public class AbstractRDFParserBuilderTest {
@Test
public void parseFileContentType() throws Exception {
- RDFParserBuilder parser = dummyParser.source(testNt).contentType(RDFSyntax.NTRIPLES);
- Graph g = parser.parse().get(5, TimeUnit.SECONDS);
+ Graph g = factory.createGraph();
+ RDFParserBuilder parser = dummyParser
+ .source(testNt)
+ .contentType(RDFSyntax.NTRIPLES)
+ .target(g);
+ parser.parse().get(5, TimeUnit.SECONDS);
checkGraph(g);
// FIXME: this could potentially break if the equivalent of /tmp includes
// international characters
@@ -183,8 +191,9 @@ public class AbstractRDFParserBuilderTest {
public void parseInputStreamWithBase() throws Exception {
InputStream inputStream = new ByteArrayInputStream(new byte[0]);
IRI base = dummyParser.createRDFTermFactory().createIRI("http://www.example.org/test.rdf");
- RDFParserBuilder parser = dummyParser.source(inputStream).base(base);
- Graph g = parser.parse().get(5, TimeUnit.SECONDS);
+ Graph g = factory.createGraph();
+ RDFParserBuilder parser = dummyParser.source(inputStream).base(base).target(g);
+ parser.parse().get(5, TimeUnit.SECONDS);
checkGraph(g);
assertEquals("<http://www.example.org/test.rdf>", firstPredicate(g, "base"));
// in our particular debug output,
@@ -197,8 +206,9 @@ public class AbstractRDFParserBuilderTest {
@Test
public void parseInputStreamWithNQuads() throws Exception {
InputStream inputStream = new ByteArrayInputStream(new byte[0]);
- RDFParserBuilder parser = dummyParser.source(inputStream).contentType(RDFSyntax.NQUADS);
- Graph g = parser.parse().get(5, TimeUnit.SECONDS);
+ Graph g = factory.createGraph();
+ RDFParserBuilder parser = dummyParser.source(inputStream).contentType(RDFSyntax.NQUADS).target(g);
+ parser.parse().get(5, TimeUnit.SECONDS);
checkGraph(g);
assertNull(firstPredicate(g, "base"));
// in our particular debug output,
@@ -211,8 +221,9 @@ public class AbstractRDFParserBuilderTest {
@Test
public void parseIRI() throws Exception {
IRI iri = dummyParser.createRDFTermFactory().createIRI("http://www.example.net/test.ttl");
- RDFParserBuilder parser = dummyParser.source(iri);
- Graph g = parser.parse().get(5, TimeUnit.SECONDS);
+ Graph g = factory.createGraph();
+ RDFParserBuilder parser = dummyParser.source(iri).target(g);
+ parser.parse().get(5, TimeUnit.SECONDS);
checkGraph(g);
assertEquals("<http://www.example.net/test.ttl>", firstPredicate(g, "source"));
// No base - assuming the above IRI is always
@@ -228,8 +239,9 @@ public class AbstractRDFParserBuilderTest {
@Test
public void parseIRIBaseContentType() throws Exception {
IRI iri = dummyParser.createRDFTermFactory().createIRI("http://www.example.net/test.ttl");
- RDFParserBuilder parser = dummyParser.source(iri).base(iri).contentType(RDFSyntax.TURTLE);
- Graph g = parser.parse().get(5, TimeUnit.SECONDS);
+ Graph g = factory.createGraph();
+ RDFParserBuilder parser = dummyParser.source(iri).base(iri).contentType(RDFSyntax.TURTLE).target(g);
+ parser.parse().get(5, TimeUnit.SECONDS);
checkGraph(g);
assertEquals("<http://www.example.net/test.ttl>", firstPredicate(g, "source"));
assertEquals("<http://www.example.net/test.ttl>", firstPredicate(g, "base"));
http://git-wip-us.apache.org/repos/asf/incubator-commonsrdf/blob/defdbd91/simple/src/test/java/org/apache/commons/rdf/simple/DummyRDFParserBuilder.java
----------------------------------------------------------------------
diff --git a/simple/src/test/java/org/apache/commons/rdf/simple/DummyRDFParserBuilder.java b/simple/src/test/java/org/apache/commons/rdf/simple/DummyRDFParserBuilder.java
index cc62f0c..0cb7093 100644
--- a/simple/src/test/java/org/apache/commons/rdf/simple/DummyRDFParserBuilder.java
+++ b/simple/src/test/java/org/apache/commons/rdf/simple/DummyRDFParserBuilder.java
@@ -18,11 +18,11 @@
package org.apache.commons.rdf.simple;
import java.io.IOException;
-import java.text.ParseException;
import java.util.UUID;
+import java.util.function.Consumer;
-import org.apache.commons.rdf.api.Graph;
import org.apache.commons.rdf.api.IRI;
+import org.apache.commons.rdf.api.Quad;
import org.apache.commons.rdf.api.RDFParserBuilder;
import org.apache.commons.rdf.api.RDFTermFactory;
@@ -49,47 +49,47 @@ public class DummyRDFParserBuilder extends AbstractRDFParserBuilder {
protected void parseSynchronusly() throws IOException, IllegalStateException, RDFParseException {
// From parseSynchronusly both of these are always present
RDFTermFactory factory = getRdfTermFactory().get();
- Graph graph = getIntoGraph().get();
+ Consumer<Quad> t = getTarget();
// well - each parsing is unique. This should hopefully
// catch any accidental double parsing
IRI parsing = factory.createIRI("urn:uuid:" + UUID.randomUUID());
- graph.add(parsing, factory.createIRI("http://example.com/greeting"),
- factory.createLiteral("Hello world"));
+ t.accept(factory.createQuad(null, parsing, factory.createIRI("http://example.com/greeting"),
+ factory.createLiteral("Hello world")));
// Now we'll expose the finalized AbstractRDFParserBuilder settings
// so they can be inspected by the junit test
if (getSourceIri().isPresent()) {
- graph.add(parsing,
+ t.accept(factory.createQuad(null, parsing,
factory.createIRI("http://example.com/source"),
- getSourceIri().get());
+ getSourceIri().get()));
}
if (getSourceFile().isPresent()) {
- graph.add(parsing,
+ t.accept(factory.createQuad(null, parsing,
factory.createIRI("http://example.com/source"),
- factory.createIRI(getSourceFile().get().toUri().toString()));
+ factory.createIRI(getSourceFile().get().toUri().toString())));
}
if (getSourceInputStream().isPresent()) {
- graph.add(parsing,
+ t.accept(factory.createQuad(null, parsing,
factory.createIRI("http://example.com/source"),
- factory.createBlankNode());
+ factory.createBlankNode()));
}
if (getBase().isPresent()) {
- graph.add(parsing,
+ t.accept(factory.createQuad(null, parsing,
factory.createIRI("http://example.com/base"),
- getBase().get());
+ getBase().get()));
}
if (getContentType().isPresent()) {
- graph.add(parsing,
+ t.accept(factory.createQuad(null, parsing,
factory.createIRI("http://example.com/contentType"),
- factory.createLiteral(getContentType().get()));
+ factory.createLiteral(getContentType().get())));
}
if (getContentTypeSyntax().isPresent()) {
- graph.add(parsing,
+ t.accept(factory.createQuad(null, parsing,
factory.createIRI("http://example.com/contentTypeSyntax"),
- factory.createLiteral(getContentTypeSyntax().get().name()));
+ factory.createLiteral(getContentTypeSyntax().get().name())));
}
}