getLanguage();
+ default BaseDirection getBaseDirection() {
+ return BaseDirection.NONE;
+ }
+
/**
* Gets the datatype for this literal.
*
diff --git a/core/model-api/src/main/java/org/eclipse/rdf4j/model/Triple.java b/core/model-api/src/main/java/org/eclipse/rdf4j/model/Triple.java
index 29ad625bae7..5593d787306 100644
--- a/core/model-api/src/main/java/org/eclipse/rdf4j/model/Triple.java
+++ b/core/model-api/src/main/java/org/eclipse/rdf4j/model/Triple.java
@@ -13,8 +13,8 @@
import org.eclipse.rdf4j.common.annotation.Experimental;
/**
- * An RDF-star embedded triple. Embedded triples have a subject, predicate and object. Unlike {@link Statement}, a
- * triple never has an associated context.
+ * An embedded triple. Embedded triples have a subject, predicate and object. Unlike {@link Statement}, a triple never
+ * has an associated context.
*
* Additional utility functionality for working with {@code Triple} objects is available in the
* {@link org.eclipse.rdf4j.model.util.Statements} and {@link org.eclipse.rdf4j.model.util.Values} utility classes.
@@ -23,10 +23,9 @@
* @implNote In order to ensure interoperability of concrete classes implementing this interface,
* {@link #equals(Object)} and {@link #hashCode()} methods must be implemented exactly as described in their
* specs.
- * @see RDF-star and SPARQL-star Draft Community Group Report
*/
@Experimental
-public interface Triple extends Resource {
+public interface Triple extends Value {
@Override
default boolean isTriple() {
diff --git a/core/model-api/src/main/java/org/eclipse/rdf4j/model/ValueFactory.java b/core/model-api/src/main/java/org/eclipse/rdf4j/model/ValueFactory.java
index 00441731e57..774433b0ce2 100644
--- a/core/model-api/src/main/java/org/eclipse/rdf4j/model/ValueFactory.java
+++ b/core/model-api/src/main/java/org/eclipse/rdf4j/model/ValueFactory.java
@@ -86,6 +86,18 @@ public interface ValueFactory {
*/
Literal createLiteral(String label, String language);
+ /**
+ * Creates a new literal with the supplied label and language attribute. The return value of
+ * {@link Literal#getDatatype()} for the returned object must be
+ * {@code rdf:langString}.
+ *
+ * @param label The literal's label, must not be null.
+ * @param language The literal's language attribute, must not be null.
+ * @param baseDirection The literal's base direction, either "", "--ltr", or "--rtl".
+ * @return A literal for the specified value and language attribute.
+ */
+ Literal createLiteral(String label, String language, Literal.BaseDirection baseDirection);
+
/**
* Creates a new literal with the supplied label and datatype.
*
@@ -265,11 +277,11 @@ default Literal createLiteral(TemporalAmount value) {
Statement createStatement(Resource subject, IRI predicate, Value object, Resource context);
/**
- * Creates a new RDF-star triple with the supplied subject, predicate and object.
+ * Creates a new triple term with the supplied subject, predicate and object.
*
- * @param subject The statement's subject.
- * @param predicate The statement's predicate.
- * @param object The statement's object.
+ * @param subject The triple's subject.
+ * @param predicate The triple's predicate.
+ * @param object The triple's object.
* @return The created triple.
* @implNote This temporary default method is only supplied as a stop-gap for backward compatibility, but throws an
* {@link UnsupportedOperationException}. Concrete implementations are expected to override.
diff --git a/core/model-api/src/main/java/org/eclipse/rdf4j/model/base/AbstractLiteral.java b/core/model-api/src/main/java/org/eclipse/rdf4j/model/base/AbstractLiteral.java
index 635c12a8847..d64ae697c1f 100644
--- a/core/model-api/src/main/java/org/eclipse/rdf4j/model/base/AbstractLiteral.java
+++ b/core/model-api/src/main/java/org/eclipse/rdf4j/model/base/AbstractLiteral.java
@@ -77,11 +77,12 @@ public abstract class AbstractLiteral implements Literal {
private static final long serialVersionUID = -1286527360744086451L;
static boolean reserved(IRI datatype) {
- return CoreDatatype.RDF.LANGSTRING.getIri().equals(datatype);
+ return CoreDatatype.RDF.LANGSTRING.getIri().equals(datatype)
+ || CoreDatatype.RDF.DIRLANGSTRING.getIri().equals(datatype);
}
static boolean reserved(CoreDatatype datatype) {
- return CoreDatatype.RDF.LANGSTRING == datatype;
+ return CoreDatatype.RDF.LANGSTRING == datatype || CoreDatatype.RDF.DIRLANGSTRING == datatype;
}
/**
@@ -186,7 +187,7 @@ public String toString() {
return getLanguage()
- .map(language -> label + '@' + language)
+ .map(language -> label + '@' + language + getBaseDirection())
.orElseGet(() -> CoreDatatype.XSD.STRING == getCoreDatatype() ? label
: label + "^^<" + getDatatype().stringValue() + ">");
@@ -268,10 +269,16 @@ static class TaggedLiteral extends AbstractLiteral {
private final String label;
private final String language;
+ private final BaseDirection baseDirection;
TaggedLiteral(String label, String language) {
+ this(label, language, BaseDirection.NONE);
+ }
+
+ TaggedLiteral(String label, String language, BaseDirection baseDirection) {
this.label = label;
this.language = language;
+ this.baseDirection = baseDirection;
}
@Override
@@ -284,14 +291,20 @@ public Optional getLanguage() {
return Optional.of(language);
}
+ @Override
+ public BaseDirection getBaseDirection() {
+ return baseDirection;
+ }
+
@Override
public IRI getDatatype() {
- return CoreDatatype.RDF.LANGSTRING.getIri();
+ return baseDirection == BaseDirection.NONE ? CoreDatatype.RDF.LANGSTRING.getIri()
+ : CoreDatatype.RDF.DIRLANGSTRING.getIri();
}
@Override
public CoreDatatype.RDF getCoreDatatype() {
- return CoreDatatype.RDF.LANGSTRING;
+ return baseDirection == BaseDirection.NONE ? CoreDatatype.RDF.LANGSTRING : CoreDatatype.RDF.DIRLANGSTRING;
}
}
diff --git a/core/model-api/src/main/java/org/eclipse/rdf4j/model/base/AbstractTriple.java b/core/model-api/src/main/java/org/eclipse/rdf4j/model/base/AbstractTriple.java
index d4508225dc1..0a8d4497168 100644
--- a/core/model-api/src/main/java/org/eclipse/rdf4j/model/base/AbstractTriple.java
+++ b/core/model-api/src/main/java/org/eclipse/rdf4j/model/base/AbstractTriple.java
@@ -30,7 +30,7 @@ public abstract class AbstractTriple implements Triple {
@Override
public String stringValue() {
- return "<<" + getSubject() + " " + getPredicate() + " " + getObject() + ">>";
+ return "<<(" + getSubject() + " " + getPredicate() + " " + getObject() + ")>>";
}
@Override
diff --git a/core/model-api/src/main/java/org/eclipse/rdf4j/model/base/AbstractValueFactory.java b/core/model-api/src/main/java/org/eclipse/rdf4j/model/base/AbstractValueFactory.java
index e88070a5af3..4d5ba3f39a3 100644
--- a/core/model-api/src/main/java/org/eclipse/rdf4j/model/base/AbstractValueFactory.java
+++ b/core/model-api/src/main/java/org/eclipse/rdf4j/model/base/AbstractValueFactory.java
@@ -146,15 +146,21 @@ public Literal createLiteral(String label, IRI datatype, CoreDatatype coreDataty
@Override
public Literal createLiteral(String label, String language) {
+ return createLiteral(label, language, Literal.BaseDirection.NONE);
+ }
+
+ @Override
+ public Literal createLiteral(String label, String language, Literal.BaseDirection baseDirection) {
Objects.requireNonNull(label, "null label");
Objects.requireNonNull(language, "null language");
+ Objects.requireNonNull(baseDirection, "null baseDirection");
if (language.isEmpty()) {
throw new IllegalArgumentException("empty language tag");
}
- return new TaggedLiteral(label, language);
+ return new TaggedLiteral(label, language, baseDirection);
}
@Override
diff --git a/core/model-api/src/main/java/org/eclipse/rdf4j/model/base/CoreDatatype.java b/core/model-api/src/main/java/org/eclipse/rdf4j/model/base/CoreDatatype.java
index 50af84d1df3..c48be81ccfd 100644
--- a/core/model-api/src/main/java/org/eclipse/rdf4j/model/base/CoreDatatype.java
+++ b/core/model-api/src/main/java/org/eclipse/rdf4j/model/base/CoreDatatype.java
@@ -283,7 +283,9 @@ public String toString() {
enum RDF implements CoreDatatype {
HTML(iri("HTML")),
+ JSON(iri("JSON")),
XMLLITERAL(iri("XMLLiteral")),
+ DIRLANGSTRING(iri("dirLangString")),
LANGSTRING(iri("langString"));
public static final String NAMESPACE = "http://www.w3.org/1999/02/22-rdf-syntax-ns#";
diff --git a/core/model-api/src/test/java/org/eclipse/rdf4j/model/LiteralTest.java b/core/model-api/src/test/java/org/eclipse/rdf4j/model/LiteralTest.java
index be492efbef6..d7ddc088be3 100644
--- a/core/model-api/src/test/java/org/eclipse/rdf4j/model/LiteralTest.java
+++ b/core/model-api/src/test/java/org/eclipse/rdf4j/model/LiteralTest.java
@@ -85,6 +85,7 @@ public abstract class LiteralTest {
static final String XSD_DURATION_YEARMONTH = XSD + "yearMonthDuration";
static final String RDF_LANG_STRING = RDF + "langString";
+ static final String RDF_DIR_LANG_STRING = RDF + "dirLangString";
/**
* Creates a test literal instance.
@@ -103,6 +104,16 @@ public abstract class LiteralTest {
*/
protected abstract Literal literal(String label, String language);
+ /**
+ * Creates a test literal instance.
+ *
+ * @param label the label of the literal
+ * @param language the language of the literal
+ * @param dir the language direction of the literal
+ * @return a new instance of the concrete literal class under test
+ */
+ protected abstract Literal literal(String label, String language, Literal.BaseDirection dir);
+
/**
* Creates a test literal instance.
*
@@ -168,14 +179,24 @@ public final void testTaggedConstructor() {
final String label = "label";
final String language = "en";
- final Literal literal = literal(label, language);
+ final Literal languageLiteral = literal(label, language);
- assertThat(literal.getLabel()).isEqualTo(label);
- assertThat(literal.getLanguage()).contains(language);
- assertThat(literal.getDatatype().stringValue()).isEqualTo(RDF_LANG_STRING);
+ assertThat(languageLiteral.getLabel()).isEqualTo(label);
+ assertThat(languageLiteral.getLanguage()).contains(language);
+ assertEquals(Literal.BaseDirection.NONE, languageLiteral.getBaseDirection());
+ assertThat(languageLiteral.getDatatype().stringValue()).isEqualTo(RDF_LANG_STRING);
+
+ final Literal directedLanguageLiteral = literal(label, language, Literal.BaseDirection.LTR);
+
+ assertThat(directedLanguageLiteral.getLabel()).isEqualTo(label);
+ assertThat(directedLanguageLiteral.getLanguage()).contains(language);
+ assertThat(directedLanguageLiteral.getBaseDirection().toString()).isEqualTo(Literal.LTR_SUFFIX);
+ assertThat(directedLanguageLiteral.getDatatype().stringValue()).isEqualTo(RDF_DIR_LANG_STRING);
assertThatNullPointerException().isThrownBy(() -> literal(null, (String) null));
assertThatNullPointerException().isThrownBy(() -> literal("", (String) null));
+ assertThatNullPointerException().isThrownBy(() -> literal("", (String) null, Literal.BaseDirection.NONE));
+ assertThatNullPointerException().isThrownBy(() -> literal("", (String) null, Literal.BaseDirection.LTR));
assertThatNullPointerException().isThrownBy(() -> literal(null, ""));
assertThatNullPointerException().isThrownBy(() -> literal(null, (IRI) null));
@@ -198,8 +219,10 @@ public final void testTypedConstructor() {
assertThatNullPointerException().isThrownBy(() -> literal(null, (IRI) null));
assertThatNullPointerException().isThrownBy(() -> literal(null, datatype(XSD_STRING)));
assertThatNullPointerException().isThrownBy(() -> literal(null, datatype(RDF_LANG_STRING)));
+ assertThatNullPointerException().isThrownBy(() -> literal(null, datatype(RDF_DIR_LANG_STRING)));
assertThatIllegalArgumentException().isThrownBy(() -> literal("", datatype(RDF_LANG_STRING)));
+ assertThatIllegalArgumentException().isThrownBy(() -> literal("", datatype(RDF_DIR_LANG_STRING)));
}
@@ -763,10 +786,13 @@ public void testEqualsAndHashCode() {
final Literal plain = literal("plain");
final Literal tagged = literal("tagged", "en");
+ final Literal tagged_with_direction = literal("tagged", "en--ltr");
final Literal typed = literal("typed", datatype("http://example.org/datatype"));
final Literal _plain = literal(plain.getLabel());
final Literal _tagged = literal(tagged.getLabel(), tagged.getLanguage().orElse(""));
+ final Literal _tagged_with_direction = literal(tagged_with_direction.getLabel(),
+ tagged_with_direction.getLanguage().orElse(""));
final Literal _typed = literal(typed.getLabel(), typed.getDatatype());
assertThat(plain).isEqualTo(plain);
@@ -775,6 +801,9 @@ public void testEqualsAndHashCode() {
assertThat(tagged).isEqualTo(tagged);
assertThat(tagged).isEqualTo(_tagged);
+ assertThat(tagged_with_direction).isEqualTo(tagged_with_direction);
+ assertThat(tagged_with_direction).isEqualTo(_tagged_with_direction);
+
assertThat(typed).isEqualTo(typed);
assertThat(typed).isEqualTo(_typed);
@@ -784,16 +813,21 @@ public void testEqualsAndHashCode() {
assertThat(plain).isNotEqualTo(tagged);
assertThat(plain).isNotEqualTo(typed);
assertThat(tagged).isNotEqualTo(typed);
+ assertThat(tagged_with_direction).isNotEqualTo(plain);
+ assertThat(tagged_with_direction).isNotEqualTo(tagged);
+ assertThat(tagged_with_direction).isNotEqualTo(typed);
assertThat(plain).isNotEqualTo(literal("other"));
assertThat(tagged).isNotEqualTo(literal(tagged.getLabel(), "other"));
assertThat(typed).isNotEqualTo(literal(typed.getLabel(), datatype("http://example.org/other")));
+ assertThat(_tagged_with_direction).isNotEqualTo(literal(tagged_with_direction.getLabel(), "en--rtl"));
// hashCode() should return identical values for literals for which equals() is true
- assertThat(plain.hashCode()).isEqualTo(_plain.hashCode());
- assertThat(tagged.hashCode()).isEqualTo(_tagged.hashCode());
- assertThat(typed.hashCode()).isEqualTo(_typed.hashCode());
+ assertThat(plain).hasSameHashCodeAs(_plain);
+ assertThat(tagged).hasSameHashCodeAs(_tagged);
+ assertThat(tagged_with_direction).hasSameHashCodeAs(_tagged_with_direction);
+ assertThat(typed).hasSameHashCodeAs(_typed);
assertThat(tagged.hashCode())
.as("computed according to contract")
@@ -860,11 +894,20 @@ public final void testCoreDatatypeTaggedConstructor() {
String label = "label";
String language = "en";
- Literal literal = literal(label, language);
+ Literal languageLiteral = literal(label, language);
+ Literal directedLanguageLiteral = literal(label, language, Literal.BaseDirection.LTR);
- assertThat(literal.getLabel()).isEqualTo(label);
- assertThat(literal.getLanguage()).contains(language);
- assertThat(literal.getCoreDatatype()).isEqualTo(CoreDatatype.RDF.LANGSTRING);
+ assertThat(languageLiteral.getLabel()).isEqualTo(label);
+ assertThat(languageLiteral.getLanguage()).contains(language);
+ assertEquals(Literal.BaseDirection.NONE, languageLiteral.getBaseDirection());
+ assertThat(languageLiteral.getCoreDatatype()).isEqualTo(CoreDatatype.RDF.LANGSTRING);
+ assertEquals("\"label\"@en", languageLiteral.toString());
+
+ assertThat(directedLanguageLiteral.getLabel()).isEqualTo(label);
+ assertThat(directedLanguageLiteral.getLanguage()).contains(language);
+ assertEquals(Literal.BaseDirection.LTR, directedLanguageLiteral.getBaseDirection());
+ assertThat(directedLanguageLiteral.getCoreDatatype()).isEqualTo(CoreDatatype.RDF.DIRLANGSTRING);
+ assertEquals("\"label\"@en--ltr", directedLanguageLiteral.toString());
assertThatNullPointerException().isThrownBy(() -> literal(null, (String) null));
assertThatNullPointerException().isThrownBy(() -> literal("", (String) null));
@@ -890,8 +933,10 @@ public final void testCoreDatatypeTypedConstructor() {
assertThatNullPointerException().isThrownBy(() -> literal(null, (CoreDatatype) null));
assertThatNullPointerException().isThrownBy(() -> literal(null, CoreDatatype.XSD.STRING));
assertThatNullPointerException().isThrownBy(() -> literal(null, CoreDatatype.RDF.LANGSTRING));
+ assertThatNullPointerException().isThrownBy(() -> literal(null, CoreDatatype.RDF.DIRLANGSTRING));
assertThatIllegalArgumentException().isThrownBy(() -> literal("", CoreDatatype.RDF.LANGSTRING));
+ assertThatIllegalArgumentException().isThrownBy(() -> literal("", CoreDatatype.RDF.DIRLANGSTRING));
}
@@ -911,6 +956,7 @@ public void testCoreDatatypeStringValue() {
assertThat(literal(label).stringValue()).isEqualTo(label);
assertThat(literal(label, language).stringValue()).isEqualTo(label);
+ assertThat(literal(label, language, Literal.BaseDirection.LTR).stringValue()).isEqualTo(label);
assertThat(literal(label, datatype).stringValue()).isEqualTo(label);
}
@@ -1442,49 +1488,6 @@ public final void testCoreDatatypeCalendarValue() throws DatatypeConfigurationEx
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- @Test
- public void testCoreDatatypeEqualsAndHashCode() {
-
- Literal plain = literal("plain");
- Literal tagged = literal("tagged", "en");
- Literal typed = literal("typed", datatype("http://example.org/datatype"));
-
- Literal _plain = literal(plain.getLabel());
- Literal _tagged = literal(tagged.getLabel(), tagged.getLanguage().orElse(""));
- Literal _typed = literal(typed.getLabel(), typed.getDatatype());
-
- assertThat(plain).isEqualTo(plain);
- assertThat(plain).isEqualTo(_plain);
-
- assertThat(tagged).isEqualTo(tagged);
- assertThat(tagged).isEqualTo(_tagged);
-
- assertThat(typed).isEqualTo(typed);
- assertThat(typed).isEqualTo(_typed);
-
- assertThat(plain).isNotEqualTo(null);
- assertThat(plain).isNotEqualTo(new Object());
-
- assertThat(plain).isNotEqualTo(tagged);
- assertThat(plain).isNotEqualTo(typed);
- assertThat(tagged).isNotEqualTo(typed);
-
- assertThat(plain).isNotEqualTo(literal("other"));
- assertThat(tagged).isNotEqualTo(literal(tagged.getLabel(), "other"));
- assertThat(typed).isNotEqualTo(literal(typed.getLabel(), "http://example.org/other"));
-
- // hashCode() should return identical values for literals for which equals() is true
-
- assertThat(plain.hashCode()).isEqualTo(_plain.hashCode());
- assertThat(tagged.hashCode()).isEqualTo(_tagged.hashCode());
- assertThat(typed.hashCode()).isEqualTo(_typed.hashCode());
-
- assertThat(tagged.hashCode())
- .as("computed according to contract")
- .isEqualTo(tagged.getLabel().hashCode()); // !!! label >> label+language+datatype
-
- }
-
@Test
public final void testCoreDatatypeEqualsAndHashCodeCaseInsensitiveLanguage() {
@@ -1528,6 +1531,23 @@ public final void testSerializationWithCoreDatatypeRdfLangString() {
assertEquals(CoreDatatype.RDF.LANGSTRING, roundTrip.getCoreDatatype());
}
+ @Test
+ public final void testSerializationWithCoreDatatypeRdfDirLangString() {
+ Literal literal = literal("hello", "en", Literal.BaseDirection.LTR);
+ assertEquals(CoreDatatype.RDF.DIRLANGSTRING, literal.getCoreDatatype());
+ assertThat(literal.getLanguage()).isPresent();
+ assertEquals("en", literal.getLanguage().get());
+ assertEquals(Literal.BaseDirection.LTR, literal.getBaseDirection());
+
+ byte[] bytes = objectToBytes(literal);
+ Literal roundTrip = (Literal) bytesToObject(bytes);
+
+ assertEquals(CoreDatatype.RDF.DIRLANGSTRING, roundTrip.getCoreDatatype());
+ assertThat(roundTrip.getLanguage()).isPresent();
+ assertEquals("en", roundTrip.getLanguage().get());
+ assertEquals(Literal.BaseDirection.LTR, roundTrip.getBaseDirection());
+ }
+
@Test
public final void testSerializationWithCoreDatatypeGEO() {
Literal literal = literal("1", CoreDatatype.GEO.WKT_LITERAL);
@@ -1549,6 +1569,22 @@ public final void testSerializationWithCoreDatatype4() {
assertEquals(CoreDatatype.XSD.NONE, roundTrip.getCoreDatatype());
}
+ @Test
+ void testBaseDirectionEnumFromString() {
+ assertThat(Literal.BaseDirection.fromString("")).isEqualTo(Literal.BaseDirection.NONE);
+ assertThat(Literal.BaseDirection.fromString(null)).isEqualTo(Literal.BaseDirection.NONE);
+ assertThat(Literal.BaseDirection.fromString(Literal.LTR_SUFFIX)).isEqualTo(Literal.BaseDirection.LTR);
+ assertThat(Literal.BaseDirection.fromString(Literal.RTL_SUFFIX)).isEqualTo(Literal.BaseDirection.RTL);
+ assertThrows(IllegalArgumentException.class, () -> Literal.BaseDirection.fromString("--invalid"));
+ }
+
+ @Test
+ void testBaseDirectionEnumSuffix() {
+ assertThat(Literal.BaseDirection.LTR.toString()).isEqualTo(Literal.LTR_SUFFIX);
+ assertThat(Literal.BaseDirection.RTL.toString()).isEqualTo(Literal.RTL_SUFFIX);
+ assertThat(Literal.BaseDirection.NONE.toString()).isEmpty();
+ }
+
private byte[] objectToBytes(Serializable object) {
try (var byteArrayOutputStream = new ByteArrayOutputStream()) {
try (var objectOutputStream = new ObjectOutputStream(byteArrayOutputStream)) {
diff --git a/core/model-api/src/test/java/org/eclipse/rdf4j/model/ValueFactoryTest.java b/core/model-api/src/test/java/org/eclipse/rdf4j/model/ValueFactoryTest.java
index 197b7a45369..5f051a81170 100644
--- a/core/model-api/src/test/java/org/eclipse/rdf4j/model/ValueFactoryTest.java
+++ b/core/model-api/src/test/java/org/eclipse/rdf4j/model/ValueFactoryTest.java
@@ -71,6 +71,7 @@
import javax.xml.datatype.DatatypeFactory;
import javax.xml.datatype.XMLGregorianCalendar;
+import org.eclipse.rdf4j.model.base.CoreDatatype;
import org.junit.jupiter.api.Test;
/**
@@ -537,4 +538,16 @@ public void testCreateLiteralDate() throws DatatypeConfigurationException {
}
+ @Test
+ public void testCreateDirLangLiteral() {
+ final Literal literal = factory().createLiteral("label", "he", Literal.BaseDirection.RTL);
+
+ assertThat(literal).isNotNull();
+ assertThat(literal.getLabel()).isEqualTo("label");
+ assertThat(literal.getLanguage()).contains("he");
+ assertThat(literal.getBaseDirection()).isEqualTo(Literal.BaseDirection.RTL);
+ assertThat(literal.getBaseDirection().toString()).isEqualTo("--rtl");
+ assertThat(literal.getDatatype()).isEqualTo(CoreDatatype.RDF.DIRLANGSTRING.getIri());
+ }
+
}
diff --git a/core/model-api/src/test/java/org/eclipse/rdf4j/model/base/AbstractLiteralTest.java b/core/model-api/src/test/java/org/eclipse/rdf4j/model/base/AbstractLiteralTest.java
index 03849f7a2c5..148f1693d96 100644
--- a/core/model-api/src/test/java/org/eclipse/rdf4j/model/base/AbstractLiteralTest.java
+++ b/core/model-api/src/test/java/org/eclipse/rdf4j/model/base/AbstractLiteralTest.java
@@ -11,11 +11,14 @@
package org.eclipse.rdf4j.model.base;
+import static org.assertj.core.api.Assertions.assertThat;
+
import org.eclipse.rdf4j.model.IRI;
import org.eclipse.rdf4j.model.Literal;
import org.eclipse.rdf4j.model.LiteralTest;
import org.eclipse.rdf4j.model.ValueFactory;
import org.eclipse.rdf4j.model.base.AbstractValueFactoryTest.GenericValueFactory;
+import org.junit.jupiter.api.Test;
/**
* Unit tests for {@link AbstractLiteral}.
@@ -37,6 +40,11 @@ protected Literal literal(String label, String language) {
return factory.createLiteral(label, language);
}
+ @Override
+ protected Literal literal(String label, String language, Literal.BaseDirection dir) {
+ return factory.createLiteral(label, language, dir);
+ }
+
@Override
protected Literal literal(String label, IRI datatype) {
return factory.createLiteral(label, datatype);
@@ -51,5 +59,4 @@ protected Literal literal(String label, CoreDatatype datatype) {
protected IRI datatype(String iri) {
return factory.createIRI(iri);
}
-
}
diff --git a/core/model-vocabulary/pom.xml b/core/model-vocabulary/pom.xml
index bd27791c1d8..3716904ecc4 100644
--- a/core/model-vocabulary/pom.xml
+++ b/core/model-vocabulary/pom.xml
@@ -4,7 +4,7 @@
org.eclipse.rdf4j
rdf4j-core
- 5.1.0-SNAPSHOT
+ 6.0.0
rdf4j-model-vocabulary
RDF4J: RDF Vocabularies
diff --git a/core/model-vocabulary/src/main/java/org/eclipse/rdf4j/model/vocabulary/RDF.java b/core/model-vocabulary/src/main/java/org/eclipse/rdf4j/model/vocabulary/RDF.java
index 92bb07e4fe4..e53679ff122 100644
--- a/core/model-vocabulary/src/main/java/org/eclipse/rdf4j/model/vocabulary/RDF.java
+++ b/core/model-vocabulary/src/main/java/org/eclipse/rdf4j/model/vocabulary/RDF.java
@@ -57,6 +57,9 @@ public class RDF {
/** http://www.w3.org/1999/02/22-rdf-syntax-ns#Statement */
public final static IRI STATEMENT = Vocabularies.createIRI(RDF.NAMESPACE, "Statement");
+ /** http://www.w3.org/1999/02/22-rdf-syntax-ns#reifies */
+ public final static IRI REIFIES = Vocabularies.createIRI(RDF.NAMESPACE, "reifies");
+
/** http://www.w3.org/1999/02/22-rdf-syntax-ns#Bag */
public final static IRI BAG = Vocabularies.createIRI(RDF.NAMESPACE, "Bag");
@@ -87,7 +90,13 @@ public class RDF {
/** http://www.w3.org/1999/02/22-rdf-syntax-ns#langString */
public static final IRI LANGSTRING = CoreDatatype.RDF.LANGSTRING.getIri();
+ /** http://www.w3.org/1999/02/22-rdf-syntax-ns#dirLangString */
+ public static final IRI DIRLANGSTRING = CoreDatatype.RDF.DIRLANGSTRING.getIri();
+
/** http://www.w3.org/1999/02/22-rdf-syntax-ns#HTML */
public static final IRI HTML = CoreDatatype.RDF.HTML.getIri();
+ /** http://www.w3.org/1999/02/22-rdf-syntax-ns#JSON */
+ public static final IRI JSON = CoreDatatype.RDF.JSON.getIri();
+
}
diff --git a/core/model/pom.xml b/core/model/pom.xml
index 17a4deb868b..0d8795571cb 100644
--- a/core/model/pom.xml
+++ b/core/model/pom.xml
@@ -4,7 +4,7 @@
org.eclipse.rdf4j
rdf4j-core
- 5.1.0-SNAPSHOT
+ 6.0.0
rdf4j-model
RDF4J: Model
diff --git a/core/model/src/main/java/org/eclipse/rdf4j/model/impl/SimpleLiteral.java b/core/model/src/main/java/org/eclipse/rdf4j/model/impl/SimpleLiteral.java
index fb86f383183..e39a424760f 100644
--- a/core/model/src/main/java/org/eclipse/rdf4j/model/impl/SimpleLiteral.java
+++ b/core/model/src/main/java/org/eclipse/rdf4j/model/impl/SimpleLiteral.java
@@ -63,6 +63,11 @@ public class SimpleLiteral extends AbstractLiteral {
// Cached CoreDatatype, or null if not yet computed.
private CoreDatatype coreDatatype = null;
+ /**
+ * The literal's base direction.
+ */
+ private BaseDirection baseDirection = BaseDirection.NONE;
+
/*--------------*
* Constructors *
*--------------*/
@@ -88,8 +93,13 @@ protected SimpleLiteral(String label) {
* @param language The language tag for the literal, must not be null and not be empty.
*/
protected SimpleLiteral(String label, String language) {
+ this(label, language, BaseDirection.NONE);
+ }
+
+ protected SimpleLiteral(String label, String language, BaseDirection baseDirection) {
setLabel(label);
setLanguage(language);
+ setBaseDirection(baseDirection);
}
/**
@@ -100,8 +110,9 @@ protected SimpleLiteral(String label, String language) {
*/
protected SimpleLiteral(String label, IRI datatype) {
setLabel(label);
- if (org.eclipse.rdf4j.model.vocabulary.RDF.LANGSTRING.equals(datatype)) {
- throw new IllegalArgumentException("datatype rdf:langString requires a language tag");
+ if (org.eclipse.rdf4j.model.vocabulary.RDF.LANGSTRING.equals(datatype)
+ || org.eclipse.rdf4j.model.vocabulary.RDF.DIRLANGSTRING.equals(datatype)) {
+ throw new IllegalArgumentException("datatype rdf:langString or rdf:dirLangString requires a language tag");
} else if (datatype == null) {
setDatatype(CoreDatatype.XSD.STRING);
} else {
@@ -122,8 +133,8 @@ protected SimpleLiteral(String label, IRI datatype, CoreDatatype coreDatatype) {
assert datatype != null;
assert coreDatatype == CoreDatatype.NONE || datatype == coreDatatype.getIri();
- if (CoreDatatype.RDF.LANGSTRING == coreDatatype) {
- throw new IllegalArgumentException("datatype rdf:langString requires a language tag");
+ if (CoreDatatype.RDF.LANGSTRING == coreDatatype || CoreDatatype.RDF.DIRLANGSTRING == coreDatatype) {
+ throw new IllegalArgumentException("datatype rdf:langString or rdf:dirLangString requires a language tag");
}
setLabel(label);
@@ -133,8 +144,8 @@ protected SimpleLiteral(String label, IRI datatype, CoreDatatype coreDatatype) {
protected SimpleLiteral(String label, CoreDatatype datatype) {
setLabel(label);
- if (datatype == CoreDatatype.RDF.LANGSTRING) {
- throw new IllegalArgumentException("datatype rdf:langString requires a language tag");
+ if (datatype == CoreDatatype.RDF.LANGSTRING || datatype == CoreDatatype.RDF.DIRLANGSTRING) {
+ throw new IllegalArgumentException("datatype rdf:langString or rdf:dirLangString requires a language tag");
} else {
setDatatype(datatype);
}
@@ -163,7 +174,16 @@ protected void setLanguage(String language) {
}
this.language = language;
optionalLanguageCache = Optional.of(language);
- setDatatype(CoreDatatype.RDF.LANGSTRING);
+ }
+
+ protected void setBaseDirection(BaseDirection baseDirection) {
+ Objects.requireNonNull(baseDirection, "null baseDirection");
+ this.baseDirection = baseDirection;
+ if (this.baseDirection != BaseDirection.NONE) {
+ setDatatype(CoreDatatype.RDF.DIRLANGSTRING);
+ } else {
+ setDatatype(CoreDatatype.RDF.LANGSTRING);
+ }
}
@Override
@@ -174,6 +194,10 @@ public Optional getLanguage() {
return optionalLanguageCache;
}
+ public BaseDirection getBaseDirection() {
+ return baseDirection;
+ }
+
protected void setDatatype(IRI datatype) {
this.datatype = datatype;
coreDatatype = CoreDatatype.from(datatype);
@@ -260,6 +284,7 @@ public String toString() {
StringBuilder sb = new StringBuilder(label.length() + language.length() + 3);
sb.append('"').append(label).append('"');
sb.append('@').append(language);
+ sb.append(getBaseDirection());
return sb.toString();
} else if (org.eclipse.rdf4j.model.vocabulary.XSD.STRING.equals(datatype) || datatype == null) {
StringBuilder sb = new StringBuilder(label.length() + 2);
diff --git a/core/model/src/main/java/org/eclipse/rdf4j/model/impl/SimpleTriple.java b/core/model/src/main/java/org/eclipse/rdf4j/model/impl/SimpleTriple.java
index 50584bfb482..ca6c4ac1a82 100644
--- a/core/model/src/main/java/org/eclipse/rdf4j/model/impl/SimpleTriple.java
+++ b/core/model/src/main/java/org/eclipse/rdf4j/model/impl/SimpleTriple.java
@@ -77,13 +77,13 @@ public Value getObject() {
public String stringValue() {
StringBuilder sb = new StringBuilder(256);
- sb.append("<<");
+ sb.append("<<( ");
sb.append(getSubject());
sb.append(" ");
sb.append(getPredicate());
sb.append(" ");
sb.append(getObject());
- sb.append(">>");
+ sb.append(" )>>");
return sb.toString();
}
diff --git a/core/model/src/main/java/org/eclipse/rdf4j/model/impl/SimpleValueFactory.java b/core/model/src/main/java/org/eclipse/rdf4j/model/impl/SimpleValueFactory.java
index b9b685b7fcd..e0b208b6c15 100644
--- a/core/model/src/main/java/org/eclipse/rdf4j/model/impl/SimpleValueFactory.java
+++ b/core/model/src/main/java/org/eclipse/rdf4j/model/impl/SimpleValueFactory.java
@@ -103,6 +103,11 @@ public Literal createLiteral(String value, String language) {
return new SimpleLiteral(value, language);
}
+ @Override
+ public Literal createLiteral(String value, String language, Literal.BaseDirection baseDirection) {
+ return new SimpleLiteral(value, language, baseDirection);
+ }
+
@Override
public Literal createLiteral(boolean b) {
return b ? BooleanLiteral.TRUE : BooleanLiteral.FALSE;
diff --git a/core/model/src/main/java/org/eclipse/rdf4j/model/impl/ValidatingValueFactory.java b/core/model/src/main/java/org/eclipse/rdf4j/model/impl/ValidatingValueFactory.java
index 0cfe2860938..7bddd6d8b15 100644
--- a/core/model/src/main/java/org/eclipse/rdf4j/model/impl/ValidatingValueFactory.java
+++ b/core/model/src/main/java/org/eclipse/rdf4j/model/impl/ValidatingValueFactory.java
@@ -134,10 +134,15 @@ public Literal createLiteral(String label, IRI datatype, CoreDatatype coreDataty
@Override
public Literal createLiteral(String label, String language) {
+ return createLiteral(label, language, Literal.BaseDirection.NONE);
+ }
+
+ @Override
+ public Literal createLiteral(String label, String language, Literal.BaseDirection baseDirection) {
if (!Literals.isValidLanguageTag(language)) {
throw new IllegalArgumentException("Not a valid language tag: " + language);
}
- return delegate.createLiteral(label, language);
+ return delegate.createLiteral(label, language, baseDirection);
}
@Override
diff --git a/core/model/src/main/java/org/eclipse/rdf4j/model/util/GraphComparisons.java b/core/model/src/main/java/org/eclipse/rdf4j/model/util/GraphComparisons.java
index 1f3ceb59c80..85509db575b 100644
--- a/core/model/src/main/java/org/eclipse/rdf4j/model/util/GraphComparisons.java
+++ b/core/model/src/main/java/org/eclipse/rdf4j/model/util/GraphComparisons.java
@@ -11,6 +11,7 @@
package org.eclipse.rdf4j.model.util;
import static org.eclipse.rdf4j.model.util.Values.bnode;
+import static org.eclipse.rdf4j.model.util.Values.triple;
import java.math.BigInteger;
import java.nio.charset.StandardCharsets;
@@ -34,6 +35,7 @@
import org.eclipse.rdf4j.model.Model;
import org.eclipse.rdf4j.model.Resource;
import org.eclipse.rdf4j.model.Statement;
+import org.eclipse.rdf4j.model.Triple;
import org.eclipse.rdf4j.model.Value;
import org.eclipse.rdf4j.model.impl.DynamicModelFactory;
import org.slf4j.Logger;
@@ -213,6 +215,18 @@ protected static Set getBlankNodes(Model m) {
if (st.getContext() != null && st.getContext().isBNode()) {
blankNodes.add((BNode) st.getContext());
}
+
+ Triple t = triple(st);
+ while (t.getObject().isTriple()) {
+ t = (Triple) t.getObject();
+
+ if (t.getSubject().isBNode()) {
+ blankNodes.add((BNode) t.getSubject());
+ }
+ if (t.getObject().isBNode()) {
+ blankNodes.add((BNode) t.getObject());
+ }
+ }
});
return blankNodes;
}
@@ -306,18 +320,31 @@ private static Model labelModel(Model original, Map hash) {
Model result = new DynamicModelFactory().createEmptyModel();
for (Statement st : original) {
- if (st.getSubject().isBNode() || st.getObject().isBNode()
+ if (st.getSubject().isBNode() || st.getObject().isBNode() || st.getObject().isTriple()
|| (st.getContext() != null && st.getContext().isBNode())) {
Resource subject = st.getSubject().isBNode()
? createCanonicalBNode((BNode) st.getSubject(), hash)
: st.getSubject();
IRI predicate = st.getPredicate();
- Value object = st.getObject().isBNode()
- ? createCanonicalBNode((BNode) st.getObject(), hash)
- : st.getObject();
Resource context = (st.getContext() != null && st.getContext().isBNode())
? createCanonicalBNode((BNode) st.getContext(), hash)
: st.getContext();
+ Value object;
+ if (st.getObject().isBNode()) {
+ object = createCanonicalBNode((BNode) st.getObject(), hash);
+ } else if (st.getObject().isTriple()) {
+ Triple triple = (Triple) st.getObject();
+ object = triple(
+ triple.getSubject().isBNode()
+ ? createCanonicalBNode((BNode) triple.getSubject(), hash)
+ : triple.getSubject(),
+ triple.getPredicate(),
+ triple.getObject().isBNode()
+ ? createCanonicalBNode((BNode) triple.getObject(), hash)
+ : triple.getObject());
+ } else {
+ object = st.getObject();
+ }
result.add(subject, predicate, object, context);
} else {
@@ -357,12 +384,41 @@ private static Partitioning hashBNodes(Model m, Partitioning partitioning) {
partitioning.setCurrentHashCode(b,
hashBag(c, partitioning.getCurrentHashCode(b)));
}
+
+ for (Statement st : m.getStatements(null, null, null)) {
+ if (st.getObject().isTriple()) {
+ hashBNodeInTripleTerms((Triple) st.getObject(), b, partitioning);
+ }
+ }
+
}
} while (!partitioning.isFullyDistinguished());
}
return partitioning;
}
+ private static void hashBNodeInTripleTerms(Triple t, BNode b, Partitioning partitioning) {
+ if (t.getSubject().equals(b)) {
+ HashCode c = hashTuple(
+ partitioning.getPreviousHashCode(t.getObject()),
+ partitioning.getPreviousHashCode(t.getPredicate()),
+ outgoing);
+ partitioning.setCurrentHashCode(b,
+ hashBag(c, partitioning.getCurrentHashCode(b)));
+ }
+ if (t.getObject().equals(b)) {
+ HashCode c = hashTuple(
+ partitioning.getPreviousHashCode(t.getSubject()),
+ partitioning.getPreviousHashCode(t.getPredicate()),
+ incoming);
+ partitioning.setCurrentHashCode(b,
+ hashBag(c, partitioning.getCurrentHashCode(b)));
+ }
+ if (t.getObject().isTriple()) {
+ hashBNodeInTripleTerms((Triple) t.getObject(), b, partitioning);
+ }
+ }
+
protected static HashCode hashTuple(HashCode... hashCodes) {
return Hashing.combineOrdered(Arrays.asList(hashCodes));
}
@@ -430,6 +486,11 @@ public HashCode getPreviousHashCode(Value value) {
if (value.isLiteral()) {
return getStaticLiteralHashCode((Literal) value);
}
+ if (value.isTriple()) {
+ return hashTuple(getPreviousHashCode(((Triple) value).getSubject()),
+ getPreviousHashCode(((Triple) value).getPredicate()),
+ getPreviousHashCode(((Triple) value).getObject()));
+ }
return staticValueMapping.computeIfAbsent(value,
v -> hashFunction.hashString(v.stringValue(), StandardCharsets.UTF_8));
diff --git a/core/model/src/main/java/org/eclipse/rdf4j/model/util/Literals.java b/core/model/src/main/java/org/eclipse/rdf4j/model/util/Literals.java
index cfd77d59ebe..671aa1fc06e 100644
--- a/core/model/src/main/java/org/eclipse/rdf4j/model/util/Literals.java
+++ b/core/model/src/main/java/org/eclipse/rdf4j/model/util/Literals.java
@@ -473,7 +473,8 @@ public static boolean canCreateLiteral(Object object) {
* @return True if the literal has a language tag attached to it and false otherwise.
*/
public static boolean isLanguageLiteral(Literal literal) {
- return literal.getCoreDatatype() == CoreDatatype.RDF.LANGSTRING;
+ return literal.getCoreDatatype() == CoreDatatype.RDF.LANGSTRING
+ || literal.getCoreDatatype() == CoreDatatype.RDF.DIRLANGSTRING;
}
/**
@@ -495,7 +496,7 @@ public static String normalizeLanguageTag(String languageTag) throws IllformedLo
new Locale.Builder().setLanguageTag(languageTag);
// all subtags are case-insensitive
- String normalizedTag = languageTag.toLowerCase();
+ final String normalizedTag = languageTag.toLowerCase();
String[] subtags = normalizedTag.split("-");
for (int i = 1; i < subtags.length; i++) {
diff --git a/core/model/src/main/java/org/eclipse/rdf4j/model/util/Models.java b/core/model/src/main/java/org/eclipse/rdf4j/model/util/Models.java
index 2ca46af582f..52824b66e54 100644
--- a/core/model/src/main/java/org/eclipse/rdf4j/model/util/Models.java
+++ b/core/model/src/main/java/org/eclipse/rdf4j/model/util/Models.java
@@ -821,7 +821,7 @@ public static Model synchronizedModel(Model toSynchronize) {
}
/**
- * Converts the supplied RDF-star model to RDF reification statements. The converted statements are sent to the
+ * Converts the supplied RDF 1.2 model to RDF 1.1 reification statements. The converted statements are sent to the
* supplied consumer function.
*
* The supplied value factory is used to create all new statements.
@@ -831,68 +831,68 @@ public static Model synchronizedModel(Model toSynchronize) {
* @param consumer the {@link Consumer} function for the produced statements.
*/
@Experimental
- public static void convertRDFStarToReification(ValueFactory vf, Model model, Consumer consumer) {
- model.forEach(st -> Statements.convertRDFStarToReification(vf, st, consumer));
+ public static void convertRDF12ReificationToRDF11(ValueFactory vf, Model model, Consumer consumer) {
+ model.forEach(st -> Statements.convertRDF12ReificationToRDF11(vf, st, consumer));
}
/**
- * Converts the supplied RDF-star model to RDF reification statements. The converted statements are sent to the
+ * Converts the supplied RDF 1.2 model to RDF 1.1 reification statements. The converted statements are sent to the
* supplied consumer function.
*
* @param model the {@link Model} to convert.
* @param consumer the {@link Consumer} function for the produced statements.
*/
@Experimental
- public static void convertRDFStarToReification(Model model, Consumer consumer) {
- convertRDFStarToReification(SimpleValueFactory.getInstance(), model, consumer);
+ public static void convertRDF12ReificationToRDF11(Model model, Consumer consumer) {
+ convertRDF12ReificationToRDF11(SimpleValueFactory.getInstance(), model, consumer);
}
/**
- * Converts the statements in supplied RDF-star model to a new RDF model using reificiation.
+ * Converts the statements in supplied RDF 1.2 model to a new RDF 1.1 model using reificiation.
*
* The supplied value factory is used to create all new statements.
*
* @param vf the {@link ValueFactory} to use for creating statements.
* @param model the {@link Model} to convert.
- * @return a new {@link Model} with RDF-star statements converted to reified triples.
+ * @return a new {@link Model} with RDF 1.2 statements converted to reified triples.
*/
@Experimental
- public static Model convertRDFStarToReification(ValueFactory vf, Model model) {
+ public static Model convertRDF12ReificationToRDF11(ValueFactory vf, Model model) {
Model reificationModel = new LinkedHashModel();
- convertRDFStarToReification(vf, model, (Consumer) reificationModel::add);
+ convertRDF12ReificationToRDF11(vf, model, (Consumer) reificationModel::add);
return reificationModel;
}
/**
- * Converts the statements in supplied RDF-star model to a new RDF model using reificiation.
+ * Converts the statements in supplied RDF 1.2 model to a new RDF 1.1 model using reificiation.
*
* The supplied value factory is used to create all new statements.
*
* @param vf the {@link ValueFactory} to use for creating statements.
* @param model the {@link Model} to convert.
* @param modelFactory the {@link ModelFactory} used to create the new output {@link Model}.
- * @return a new {@link Model} with RDF-star statements converted to reified triples.
+ * @return a new {@link Model} with RDF 1.2 statements converted to reified triples.
*/
@Experimental
- public static Model convertRDFStarToReification(ValueFactory vf, Model model, ModelFactory modelFactory) {
+ public static Model convertRDF12ReificationToRDF11(ValueFactory vf, Model model, ModelFactory modelFactory) {
Model reificationModel = modelFactory.createEmptyModel();
- convertRDFStarToReification(vf, model, (Consumer) reificationModel::add);
+ convertRDF12ReificationToRDF11(vf, model, (Consumer) reificationModel::add);
return reificationModel;
}
/**
- * Converts the statements in the supplied RDF-star model to a new RDF model using reification.
+ * Converts the statements in the supplied RDF 1.2 model to a new RDF 1.1 model using reification.
*
* @param model the {@link Model} to convert.
- * @return a new {@link Model} with RDF-star statements converted to reified triples.
+ * @return a new {@link Model} with RDF 1.2 statements converted to reified triples.
*/
@Experimental
- public static Model convertRDFStarToReification(Model model) {
- return convertRDFStarToReification(SimpleValueFactory.getInstance(), model);
+ public static Model convertRDF12ReificationToRDF11(Model model) {
+ return convertRDF12ReificationToRDF11(SimpleValueFactory.getInstance(), model);
}
/**
- * Converts the supplied RDF reification model to RDF-star statements. The converted statements are sent to the
+ * Converts the supplied RDF 1.1 reification model to RDF-12 statements. The converted statements are sent to the
* supplied consumer function.
*
* The supplied value factory is used to create all new statements.
@@ -902,110 +902,93 @@ public static Model convertRDFStarToReification(Model model) {
* @param consumer the {@link Consumer} function for the produced statements.
*/
@Experimental
- public static void convertReificationToRDFStar(ValueFactory vf, Model model, Consumer consumer) {
- Map convertedStatements = new HashMap<>();
+ public static void convertReificationToRDF12(ValueFactory vf, Model model, Consumer consumer) {
+ Set reifiers = new HashSet<>();
model.filter(null, RDF.TYPE, RDF.STATEMENT).forEach((s) -> {
- Value subject = object(model.filter(s.getSubject(), RDF.SUBJECT, null)).orElse(null);
- if (!(subject instanceof IRI) && !(subject instanceof BNode)) {
+ Resource reifier = s.getSubject();
+ Value subject = object(model.filter(reifier, RDF.SUBJECT, null)).orElse(null);
+ if (!(subject instanceof Resource)) {
return;
}
- Value predicate = object(model.filter(s.getSubject(), RDF.PREDICATE, null)).orElse(null);
+ Value predicate = object(model.filter(reifier, RDF.PREDICATE, null)).orElse(null);
if (!(predicate instanceof IRI)) {
return;
}
- Value object = object(model.filter(s.getSubject(), RDF.OBJECT, null)).orElse(null);
+ Value object = object(model.filter(reifier, RDF.OBJECT, null)).orElse(null);
if (!(object instanceof Value)) {
return;
}
+
+ // Statement successfully converted - add reifier to list of successfully converted reifiers
+ reifiers.add(reifier);
Triple t = vf.createTriple((Resource) subject, (IRI) predicate, object);
- convertedStatements.put(s.getSubject(), t);
+ consumer.accept(vf.createStatement(reifier, RDF.REIFIES, t, s.getContext()));
});
- for (Map.Entry e : convertedStatements.entrySet()) {
- Triple t = e.getValue();
- Resource subject = convertedStatements.get(t.getSubject());
- Resource object = convertedStatements.get(t.getObject());
- if (subject != null || object != null) {
- // Triples within triples, replace them in the map
- Triple nt = vf.createTriple(subject != null ? subject : t.getSubject(), t.getPredicate(),
- object != null ? object : t.getObject());
- e.setValue(nt);
- }
- }
-
model.forEach((s) -> {
Resource subject = s.getSubject();
IRI predicate = s.getPredicate();
Value object = s.getObject();
- Triple subjectTriple = convertedStatements.get(subject);
- Triple objectTriple = convertedStatements.get(object);
-
- if (subjectTriple == null && objectTriple == null) {
- // Statement not part of detected reification, add it as is
+ if (!(reifiers.contains(subject)
+ && ((predicate.equals(RDF.TYPE) && object.equals(RDF.STATEMENT)) || predicate.equals(RDF.SUBJECT)
+ || predicate.equals(RDF.OBJECT) || predicate.equals(RDF.PREDICATE)))) {
consumer.accept(s);
- } else if (subjectTriple == null || ((!RDF.TYPE.equals(predicate) || !RDF.STATEMENT.equals(object))
- && !RDF.SUBJECT.equals(predicate) && !RDF.PREDICATE.equals(predicate)
- && !RDF.OBJECT.equals(predicate))) {
- // Statement uses reified data and needs to be converted
- Statement ns = vf.createStatement(subjectTriple != null ? subjectTriple : s.getSubject(),
- s.getPredicate(), objectTriple != null ? objectTriple : s.getObject(), s.getContext());
- consumer.accept(ns);
- } // else: Statement part of reification and needs to be removed (skipped)
+ } // else: Statement part of original RDF 1.1 reification and needs to be removed (skipped)
});
}
/**
- * Converts the supplied RDF reification model to RDF-star statements. The converted statements are sent to the
+ * Converts the supplied RDF 1.1 reification model to RDF 1.2 statements. The converted statements are sent to the
* supplied consumer function.
*
* @param model the {@link Model} to convert.
* @param consumer the {@link Consumer} function for the produced statements.
*/
@Experimental
- public static void convertReificationToRDFStar(Model model, Consumer consumer) {
- convertReificationToRDFStar(SimpleValueFactory.getInstance(), model, consumer);
+ public static void convertReificationToRDF12(Model model, Consumer consumer) {
+ convertReificationToRDF12(SimpleValueFactory.getInstance(), model, consumer);
}
/**
- * Converts the statements in supplied RDF reification model to a new RDF-star model.
+ * Converts the statements in supplied RDF 1.1 reification model to a new RDF 1.2 model.
*
* The supplied value factory is used to create all new statements.
*
* @param vf the {@link ValueFactory} to use for creating statements.
* @param model the {@link Model} to convert.
* @param modelFactory the {@link ModelFactory} to use for creating a new Model object for the output.
- * @return a new {@link Model} with reification statements converted to RDF-star {@link Triple}s.
+ * @return a new {@link Model} with reification statements converted to RDF 1.2 {@link Triple}s.
*/
@Experimental
- public static Model convertReificationToRDFStar(ValueFactory vf, Model model, ModelFactory modelFactory) {
- Model rdfStarModel = modelFactory.createEmptyModel();
- convertReificationToRDFStar(vf, model, (Consumer) rdfStarModel::add);
- return rdfStarModel;
+ public static Model convertReificationToRDF12(ValueFactory vf, Model model, ModelFactory modelFactory) {
+ Model rdf11Model = modelFactory.createEmptyModel();
+ convertReificationToRDF12(vf, model, (Consumer) rdf11Model::add);
+ return rdf11Model;
}
/**
- * Converts the statements in supplied RDF reification model to a new RDF-star model.
+ * Converts the statements in supplied RDF 1.1 reification model to a new RDF 1.2 model.
*
* The supplied value factory is used to create all new statements.
*
* @param vf the {@link ValueFactory} to use for creating statements.
* @param model the {@link Model} to convert.
- * @return a new {@link Model} with reification statements converted to RDF-star {@link Triple}s.
+ * @return a new {@link Model} with reification statements converted to RDF 1.2 {@link Triple}s.
*/
@Experimental
- public static Model convertReificationToRDFStar(ValueFactory vf, Model model) {
- return convertReificationToRDFStar(vf, model, new DynamicModelFactory());
+ public static Model convertReificationToRDF12(ValueFactory vf, Model model) {
+ return convertReificationToRDF12(vf, model, new DynamicModelFactory());
}
/**
- * Converts the supplied RDF reification model to a new RDF-star model.
+ * Converts the supplied RDF 1.1 reification model to a new RDF 1.2 model.
*
* @param model the {@link Model} to convert.
- * @return a new {@link Model} with reification statements converted to RDF-star {@link Triple}s.
+ * @return a new {@link Model} with reification statements converted to RDF 1.2 {@link Triple}s.
*/
@Experimental
- public static Model convertReificationToRDFStar(Model model) {
- return convertReificationToRDFStar(SimpleValueFactory.getInstance(), model);
+ public static Model convertReificationToRDF12(Model model) {
+ return convertReificationToRDF12(SimpleValueFactory.getInstance(), model);
}
private static boolean isSubsetInternal(Set model1, Model model2) {
diff --git a/core/model/src/main/java/org/eclipse/rdf4j/model/util/Statements.java b/core/model/src/main/java/org/eclipse/rdf4j/model/util/Statements.java
index bea10611167..3c7f6b82e28 100644
--- a/core/model/src/main/java/org/eclipse/rdf4j/model/util/Statements.java
+++ b/core/model/src/main/java/org/eclipse/rdf4j/model/util/Statements.java
@@ -28,8 +28,8 @@
import org.eclipse.rdf4j.model.vocabulary.RDF;
/**
- * Utility methods for working with {@link Statement} objects, including conversion to/from {@link Triple RDF-star
- * triple objects}.
+ * Utility methods for working with {@link Statement} objects, including conversion to/from {@link Triple RDF 1.2 triple
+ * objects}.
*
* @author Jeen Broekstra
*/
@@ -125,10 +125,10 @@ public static Statement stripContext(ValueFactory vf, Statement statement) {
}
/**
- * Create an {@link Triple RDF-star triple} from the supplied {@link Statement}
+ * Create an {@link Triple RDF 1.2 triple} from the supplied {@link Statement}
*
- * @param statement a statement to convert to an RDF-star triple
- * @return an {@link Triple RDF-star triple} with the same subject, predicate and object as the input statement.
+ * @param statement a statement to convert to an RDF 1.2 triple
+ * @return an {@link Triple RDF 1.2 triple} with the same subject, predicate and object as the input statement.
* @since 3.4.0
* @deprecated Use {@link Values#triple(Statement)} instead
*/
@@ -138,11 +138,11 @@ public static Triple toTriple(Statement statement) {
}
/**
- * Create an {@link Triple RDF-star triple} from the supplied {@link Statement}
+ * Create an {@link Triple RDF 1.2 triple} from the supplied {@link Statement}
*
* @param vf the {@link ValueFactory} to use for creating the {@link Triple} object.
- * @param statement a statement to convert to an RDF-star triple
- * @return an {@link Triple RDF-star triple} with the same subject, predicate and object as the input statement.
+ * @param statement a statement to convert to an RDF 1.2 triple
+ * @return an {@link Triple RDF 1.2 triple} with the same subject, predicate and object as the input statement.
* @since 3.4.0
* @deprecated Use {@link Values#triple(ValueFactory, Statement)} instead
*/
@@ -152,9 +152,9 @@ public static Triple toTriple(ValueFactory vf, Statement statement) {
}
/**
- * Create a {@link Statement} from the supplied {@link Triple RDF-star triple}
+ * Create a {@link Statement} from the supplied {@link Triple RDF 1.2 triple}
*
- * @param triple an RDF-star triple to convert to a {@link Statement}.
+ * @param triple an RDF 1.2 triple to convert to a {@link Statement}.
* @return an {@link Statement} with the same subject, predicate and object as the input triple, and no context.
* @since 3.4.0
* @deprecated Use {@link #statement(Triple)} instead
@@ -164,9 +164,9 @@ public static Statement toStatement(Triple triple) {
}
/**
- * Create a {@link Statement} from the supplied {@link Triple RDF-star triple}
+ * Create a {@link Statement} from the supplied {@link Triple RDF 1.2 triple}
*
- * @param triple an RDF-star triple to convert to a {@link Statement}.
+ * @param triple an RDF 1.2 triple to convert to a {@link Statement}.
* @return an {@link Statement} with the same subject, predicate and object as the input triple, and no context.
* @since 3.4.0
*/
@@ -175,9 +175,9 @@ public static Statement statement(Triple triple) {
}
/**
- * Create a {@link Statement} from the supplied {@link Triple RDF-star triple} and context.
+ * Create a {@link Statement} from the supplied {@link Triple RDF 1.2 triple} and context.
*
- * @param triple an RDF-star triple to convert to a {@link Statement}.
+ * @param triple an RDF 1.2 triple to convert to a {@link Statement}.
* @param context the context to assign to the {@link Statement}.
* @return an {@link Statement} with the same subject, predicate and object as the input triple, and having the
* supplied context.
@@ -188,9 +188,9 @@ public static Statement statement(Triple triple, Resource context) {
}
/**
- * Create a {@link Statement} from the supplied {@link Triple RDF-star triple} and context.
+ * Create a {@link Statement} from the supplied {@link Triple RDF 1.2 triple} and context.
*
- * @param triple an RDF-star triple to convert to a {@link Statement}.
+ * @param triple an RDF 1.2 triple to convert to a {@link Statement}.
* @param context the context to assign to the {@link Statement}.
* @return an {@link Statement} with the same subject, predicate and object as the input triple, and having the
* supplied context.
@@ -202,10 +202,10 @@ public static Statement toStatement(Triple triple, Resource context) {
}
/**
- * Create a {@link Statement} from the supplied {@link Triple RDF-star triple} and context.
+ * Create a {@link Statement} from the supplied {@link Triple RDF 1.2 triple} and context.
*
* @param vf the {@link ValueFactory} to use for creating the {@link Statement} object.
- * @param triple an RDF-star triple to convert to a {@link Statement}.
+ * @param triple an RDF 1.2 triple to convert to a {@link Statement}.
* @param context the context to assign to the {@link Statement}. May be null to indicate no context.
* @return an {@link Statement} with the same subject, predicate and object as the input triple, and having the
* supplied context.
@@ -217,10 +217,10 @@ public static Statement toStatement(ValueFactory vf, Triple triple, Resource con
}
/**
- * Create a {@link Statement} from the supplied {@link Triple RDF-star triple} and context.
+ * Create a {@link Statement} from the supplied {@link Triple RDF 1.2 triple} and context.
*
* @param vf the {@link ValueFactory} to use for creating the {@link Statement} object.
- * @param triple an RDF-star triple to convert to a {@link Statement}.
+ * @param triple an RDF 1.2 triple to convert to a {@link Statement}.
* @param context the context to assign to the {@link Statement}. May be null to indicate no context.
* @return an {@link Statement} with the same subject, predicate and object as the input triple, and having the
* supplied context.
@@ -284,8 +284,8 @@ public static boolean isSameTriple(Statement st1, Statement st2) {
}
/**
- * Converts the supplied RDF-star statement to RDF reification statements, and sends the resultant statements to the
- * supplied consumer. If the supplied statement is not RDF-star it will be sent to the consumer as is.
+ * Converts the supplied RDF 1.2 statement to RDF reification statements, and sends the resultant statements to the
+ * supplied consumer. If the supplied statement is not RDF 1.2 it will be sent to the consumer as is.
*
* The statements needed to represent reification will use blank nodes.
*
@@ -293,85 +293,43 @@ public static boolean isSameTriple(Statement st1, Statement st2) {
* @param consumer the {@link Consumer} function for the produced statements.
*/
@Experimental
- public static void convertRDFStarToReification(Statement st, Consumer consumer) {
- convertRDFStarToReification(SimpleValueFactory.getInstance(), st, consumer);
+ public static void convertRDF12ReificationToRDF11(Statement st, Consumer consumer) {
+ convertRDF12ReificationToRDF11(SimpleValueFactory.getInstance(), st, consumer);
}
/**
- * Converts the supplied RDF-star statement to RDF reification statements, and sends the resultant statements to the
- * supplied consumer. If the supplied statement is not RDF-star it will be sent to the consumer as is.
+ * Converts the supplied RDF 1.2 statement to RDF 1.1 reification statements, and sends the resultant statements to
+ * the supplied consumer. If the supplied statement does not contain a triple term it will be sent to the consumer
+ * as is.
*
- * The statements needed to represent reification will use blank nodes.
- *
- * The supplied value factory is used to create all new statements and blank nodes.
+ * The supplied value factory is used to create all new statements.
*
* @param vf the {@link ValueFactory} to use for creating statements.
- * @param st the {@link Statement} to convert.
+ * @param st the {@link Statement} to convert,
* @param consumer the {@link Consumer} function for the produced statements.
*/
@Experimental
- public static void convertRDFStarToReification(ValueFactory vf, Statement st, Consumer consumer) {
- convertRDFStarToReification(vf, TRIPLE_BNODE_MAPPER, st, consumer);
- }
-
- /**
- * Converts the supplied RDF-star statement to RDF reification statements, and sends the resultant statements to the
- * supplied consumer. If the supplied statement is not RDF-star it will be sent to the consumer as is.
- *
- * The supplied value factory is used to create all new statements.
- *
- * The supplied mapper function maps a {@link Triple} to a {@link Resource} and is used to create the ID of the RDF
- * reification statement corresponding to the converted triple. The function must return the same value for
- * identical triples in order to produce consistent results between invocations. See {@link #TRIPLE_BNODE_MAPPER}.
- *
- * @param vf the {@link ValueFactory} to use for creating statements.
- * @param reifiedIdMapper the mapper {@link Function} from {@link Triple} to {@link Resource}.
- * @param st the {@link Statement} to convert,
- * @param consumer the {@link Consumer} function for the produced statements.
- */
- @Experimental
- public static void convertRDFStarToReification(ValueFactory vf, Function reifiedIdMapper,
- Statement st, Consumer consumer) {
+ public static void convertRDF12ReificationToRDF11(ValueFactory vf, Statement st, Consumer consumer) {
Resource subject = st.getSubject();
+ IRI predicate = st.getPredicate();
Value object = st.getObject();
- if (subject instanceof Triple || object instanceof Triple) {
- if (subject instanceof Triple) {
- subject = createReifiedStatement(vf, reifiedIdMapper, (Triple) subject, st.getContext(), consumer);
+ Resource context = st.getContext();
+
+ if (object.isTriple()) {
+ if (!predicate.equals(RDF.REIFIES)) {
+ throw new IllegalArgumentException(
+ "Cannot convert triple term statement with predicate other than rdf:reifies");
}
- if (object instanceof Triple) {
- object = createReifiedStatement(vf, reifiedIdMapper, (Triple) object, st.getContext(), consumer);
+ Triple triple = (Triple) object;
+ if (triple.getObject().isTriple()) {
+ throw new IllegalArgumentException("Nested triples cannot be converted to RDF 1.1 reification");
}
- st = vf.createStatement(subject, st.getPredicate(), object, st.getContext());
+ consumer.accept(vf.createStatement(subject, RDF.TYPE, RDF.STATEMENT, context));
+ consumer.accept(vf.createStatement(subject, RDF.SUBJECT, triple.getSubject(), context));
+ consumer.accept(vf.createStatement(subject, RDF.PREDICATE, triple.getPredicate(), context));
+ consumer.accept(vf.createStatement(subject, RDF.OBJECT, triple.getObject(), context));
+ } else {
+ consumer.accept(st);
}
- consumer.accept(st);
- }
-
- /**
- * Converts the supplied RDF-star triple to a series of RDF reification statements and sends the statements to the
- * supplied consumer. The subject of the created statements is returned.
- *
- * The supplied value factory is used to create all new statements.
- *
- * The supplied mapper function maps a {@link Triple} to a {@link Resource} and is used to create the ID of the RDF
- * reification statement corresponding to the converted triple.
- *
- * @param vf the {@link ValueFactory} to use for creating statements.
- * @param reifiedIdMapper the mapper {@link Function} from {@link Triple} to {@link Resource}.
- * @param triple the {@link Triple} to convert.
- * @param consumer the {@link Consumer} function for the produced statements.
- * @return the {@link Resource} that was used as the subject of the created RDF reification statements.
- */
- private static Resource createReifiedStatement(ValueFactory vf, Function reifiedIdMapper,
- Triple triple, Resource context, Consumer consumer) {
- Resource stId = reifiedIdMapper.apply(triple);
- Statement reifiedSt = vf.createStatement(stId, RDF.TYPE, RDF.STATEMENT, context);
- consumer.accept(reifiedSt);
- Statement reifiedStSubject = vf.createStatement(stId, RDF.SUBJECT, triple.getSubject(), context);
- convertRDFStarToReification(vf, reifiedIdMapper, reifiedStSubject, consumer);
- Statement reifiedStPredicate = vf.createStatement(stId, RDF.PREDICATE, triple.getPredicate(), context);
- consumer.accept(reifiedStPredicate);
- Statement reifiedStObject = vf.createStatement(stId, RDF.OBJECT, triple.getObject(), context);
- convertRDFStarToReification(vf, reifiedIdMapper, reifiedStObject, consumer);
- return stId;
}
}
diff --git a/core/model/src/main/java/org/eclipse/rdf4j/model/util/Values.java b/core/model/src/main/java/org/eclipse/rdf4j/model/util/Values.java
index 6eeb898002e..1a41acaa207 100644
--- a/core/model/src/main/java/org/eclipse/rdf4j/model/util/Values.java
+++ b/core/model/src/main/java/org/eclipse/rdf4j/model/util/Values.java
@@ -609,7 +609,7 @@ public static Literal literal(ValueFactory vf, Object object, boolean failOnUnkn
/* triple factory methods */
/**
- * Creates a new {@link Triple RDF-star embedded triple} with the supplied subject, predicate, and object.
+ * Creates a new {@link Triple embedded triple} with the supplied subject, predicate, and object.
*
* @param subject the Triple subject
* @param predicate the Triple predicate
@@ -622,7 +622,7 @@ public static Triple triple(Resource subject, IRI predicate, Value object) {
}
/**
- * Creates a new {@link Triple RDF-star embedded triple} with the supplied subject, predicate, and object.
+ * Creates a new {@link Triple embedded triple} with the supplied subject, predicate, and object.
*
* @param vf the {@link ValueFactory} to use for creation of the {@link Triple}
* @param subject the Triple subject
@@ -640,7 +640,7 @@ public static Triple triple(ValueFactory vf, Resource subject, IRI predicate, Va
}
/**
- * Creates a new {@link Triple RDF-star embedded triple} using the subject, predicate and object from the supplied
+ * Creates a new {@link Triple embedded triple} using the subject, predicate and object from the supplied
* {@link Statement}.
*
* @param statement the {@link Statement} from which to construct a {@link Triple}
@@ -653,7 +653,7 @@ public static Triple triple(Statement statement) {
}
/**
- * Creates a new {@link Triple RDF-star embedded triple} using the subject, predicate and object from the supplied
+ * Creates a new {@link Triple embedded triple} using the subject, predicate and object from the supplied
* {@link Statement}.
*
* @param vf the {@link ValueFactory} to use for creation of the {@link Triple}
diff --git a/core/model/src/test/java/org/eclipse/rdf4j/model/impl/SimpleLiteralTest.java b/core/model/src/test/java/org/eclipse/rdf4j/model/impl/SimpleLiteralTest.java
index 61dab2ff8e3..82b6a40d8f6 100644
--- a/core/model/src/test/java/org/eclipse/rdf4j/model/impl/SimpleLiteralTest.java
+++ b/core/model/src/test/java/org/eclipse/rdf4j/model/impl/SimpleLiteralTest.java
@@ -30,6 +30,11 @@ protected Literal literal(String label, String language) {
return new SimpleLiteral(label, language);
}
+ @Override
+ protected Literal literal(String label, String language, Literal.BaseDirection dir) {
+ return new SimpleLiteral(label, language, dir);
+ }
+
@Override
protected Literal literal(String label, IRI datatype) {
return new SimpleLiteral(label, datatype);
diff --git a/core/model/src/test/java/org/eclipse/rdf4j/model/util/ModelReificationTestHelper.java b/core/model/src/test/java/org/eclipse/rdf4j/model/util/ModelReificationTestHelper.java
new file mode 100644
index 00000000000..5f93cf69e97
--- /dev/null
+++ b/core/model/src/test/java/org/eclipse/rdf4j/model/util/ModelReificationTestHelper.java
@@ -0,0 +1,187 @@
+/*******************************************************************************
+ * Copyright (c) 2020 Eclipse RDF4J contributors.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Distribution License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ *******************************************************************************/
+package org.eclipse.rdf4j.model.util;
+
+import org.eclipse.rdf4j.model.BNode;
+import org.eclipse.rdf4j.model.IRI;
+import org.eclipse.rdf4j.model.Literal;
+import org.eclipse.rdf4j.model.Model;
+import org.eclipse.rdf4j.model.ValueFactory;
+import org.eclipse.rdf4j.model.impl.LinkedHashModel;
+import org.eclipse.rdf4j.model.impl.SimpleValueFactory;
+import org.eclipse.rdf4j.model.vocabulary.RDF;
+
+public class ModelReificationTestHelper {
+ private final static ValueFactory VF = SimpleValueFactory.getInstance();
+
+ private final static IRI GRAPH_NULL = null;
+ private final static IRI GRAPH_1 = VF.createIRI("urn:graph1");
+ private final static IRI GRAPH_2 = VF.createIRI("urn:graph2");
+ private final static IRI IRI_1 = VF.createIRI("urn:a");
+ private final static IRI IRI_2 = VF.createIRI("urn:b");
+ private final static IRI IRI_3 = VF.createIRI("urn:c");
+ private final static IRI IRI_4 = VF.createIRI("urn:d");
+ private final static IRI IRI_5 = VF.createIRI("urn:e");
+ private final static IRI IRI_6 = VF.createIRI("urn:f");
+ private final static Literal LITERAL_1 = VF.createLiteral("literal 1");
+ private final static Literal LITERAL_2 = VF.createLiteral("literal 2");
+ private final static BNode BNODE_1 = VF.createBNode("bnode1");
+ private final static BNode BNODE_2 = VF.createBNode("bnode2");
+
+ public static Model createRDF12ReificationModel() {
+ Model rdf12Model = new LinkedHashModel();
+ Statements.create(VF, IRI_1, IRI_2, IRI_3, rdf12Model, GRAPH_NULL);
+
+ // maps iri1 iri2 <> to RDF 1.2 reification
+ BNode t1 = VF.createBNode();
+ Statements.create(VF, IRI_1, IRI_2, t1, rdf12Model, GRAPH_1);
+ Statements.create(VF, t1, RDF.REIFIES, VF.createTriple(IRI_4, IRI_5, LITERAL_1), rdf12Model, GRAPH_1);
+
+ // maps iri1 iri3 <> to reification
+ // same triple/reification statements as previous entry
+ Statements.create(VF, IRI_1, IRI_3, t1, rdf12Model, GRAPH_1);
+
+ // maps <> iri3 _:bnode1 to reification
+ BNode t2 = VF.createBNode();
+ Statements.create(VF, t2, IRI_3, BNODE_1, rdf12Model, GRAPH_2);
+ Statements.create(VF, t2, RDF.REIFIES, VF.createTriple(IRI_5, IRI_6, IRI_4), rdf12Model, GRAPH_2);
+
+ // maps a complex nested statement to reification
+ // subj: << <> iri3 <> >>
+ // pred: iri2
+ // obj: << <<_:bnode2 iri3 "literal2">> iri4 <> >>
+ BNode t3 = VF.createBNode();
+ BNode t4 = VF.createBNode();
+ BNode t5 = VF.createBNode();
+ BNode t6 = VF.createBNode();
+ BNode t7 = VF.createBNode();
+ BNode t8 = VF.createBNode();
+ Statements.create(VF, t3, IRI_2, t4, rdf12Model, GRAPH_2);
+ Statements.create(VF, t3, RDF.REIFIES, VF.createTriple(t5, IRI_3, t6), rdf12Model, GRAPH_2);
+ Statements.create(VF, t4, RDF.REIFIES, VF.createTriple(t7, IRI_4, t8), rdf12Model, GRAPH_2);
+ Statements.create(VF, t5, RDF.REIFIES, VF.createTriple(IRI_1, IRI_2, LITERAL_2), rdf12Model, GRAPH_2);
+ Statements.create(VF, t6, RDF.REIFIES, VF.createTriple(IRI_4, IRI_5, IRI_6), rdf12Model, GRAPH_2);
+ Statements.create(VF, t7, RDF.REIFIES, VF.createTriple(BNODE_2, IRI_3, LITERAL_2), rdf12Model, GRAPH_2);
+ Statements.create(VF, t8, RDF.REIFIES, VF.createTriple(IRI_3, IRI_6, IRI_1), rdf12Model, GRAPH_2);
+
+ return rdf12Model;
+ }
+
+ public static Model createRDF11ReificationModel() {
+ Model rdf11Model = new LinkedHashModel();
+ Statements.create(VF, IRI_1, IRI_2, IRI_3, rdf11Model, GRAPH_NULL);
+
+ // maps iri1 iri2 <> to RDF 1.1 reification
+ BNode t1 = VF.createBNode();
+ Statements.create(VF, IRI_1, IRI_2, t1, rdf11Model, GRAPH_1);
+ Statements.create(VF, t1, RDF.TYPE, RDF.STATEMENT, rdf11Model, GRAPH_1);
+ Statements.create(VF, t1, RDF.SUBJECT, IRI_4, rdf11Model, GRAPH_1);
+ Statements.create(VF, t1, RDF.PREDICATE, IRI_5, rdf11Model, GRAPH_1);
+ Statements.create(VF, t1, RDF.OBJECT, LITERAL_1, rdf11Model, GRAPH_1);
+
+ // maps iri1 iri3 <> to reification
+ // same triple/reification statements as previous entry
+ Statements.create(VF, IRI_1, IRI_3, t1, rdf11Model, GRAPH_1);
+ Statements.create(VF, t1, RDF.TYPE, RDF.STATEMENT, rdf11Model, GRAPH_1);
+ Statements.create(VF, t1, RDF.SUBJECT, IRI_4, rdf11Model, GRAPH_1);
+ Statements.create(VF, t1, RDF.PREDICATE, IRI_5, rdf11Model, GRAPH_1);
+ Statements.create(VF, t1, RDF.OBJECT, LITERAL_1, rdf11Model, GRAPH_1);
+
+ // maps <> iri3 _:bnode1 to reification
+ BNode t2 = VF.createBNode();
+ Statements.create(VF, t2, IRI_3, BNODE_1, rdf11Model, GRAPH_2);
+ Statements.create(VF, t2, RDF.TYPE, RDF.STATEMENT, rdf11Model, GRAPH_2);
+ Statements.create(VF, t2, RDF.SUBJECT, IRI_5, rdf11Model, GRAPH_2);
+ Statements.create(VF, t2, RDF.PREDICATE, IRI_6, rdf11Model, GRAPH_2);
+ Statements.create(VF, t2, RDF.OBJECT, IRI_4, rdf11Model, GRAPH_2);
+
+ // maps a complex nested statement to reification
+ // t3
+ // t5 t6
+ // subj: << <> iri3 <> >>
+ // pred: iri2
+ // obj: << <<_:bnode2 iri3 "literal2">> iri4 <> >>
+ // t7 t8
+ // t4
+ BNode t3 = VF.createBNode();
+ BNode t4 = VF.createBNode();
+ BNode t5 = VF.createBNode();
+ BNode t6 = VF.createBNode();
+ BNode t7 = VF.createBNode();
+ BNode t8 = VF.createBNode();
+ Statements.create(VF, t3, IRI_2, t4, rdf11Model, GRAPH_2);
+ Statements.create(VF, t3, RDF.TYPE, RDF.STATEMENT, rdf11Model, GRAPH_2);
+ Statements.create(VF, t3, RDF.SUBJECT, t5, rdf11Model, GRAPH_2);
+ Statements.create(VF, t3, RDF.PREDICATE, IRI_3, rdf11Model, GRAPH_2);
+ Statements.create(VF, t3, RDF.OBJECT, t6, rdf11Model, GRAPH_2);
+ Statements.create(VF, t5, RDF.TYPE, RDF.STATEMENT, rdf11Model, GRAPH_2);
+ Statements.create(VF, t5, RDF.SUBJECT, IRI_1, rdf11Model, GRAPH_2);
+ Statements.create(VF, t5, RDF.PREDICATE, IRI_2, rdf11Model, GRAPH_2);
+ Statements.create(VF, t5, RDF.OBJECT, LITERAL_2, rdf11Model, GRAPH_2);
+ Statements.create(VF, t6, RDF.TYPE, RDF.STATEMENT, rdf11Model, GRAPH_2);
+ Statements.create(VF, t6, RDF.SUBJECT, IRI_4, rdf11Model, GRAPH_2);
+ Statements.create(VF, t6, RDF.PREDICATE, IRI_5, rdf11Model, GRAPH_2);
+ Statements.create(VF, t6, RDF.OBJECT, IRI_6, rdf11Model, GRAPH_2);
+ Statements.create(VF, t4, RDF.TYPE, RDF.STATEMENT, rdf11Model, GRAPH_2);
+ Statements.create(VF, t4, RDF.SUBJECT, t7, rdf11Model, GRAPH_2);
+ Statements.create(VF, t4, RDF.PREDICATE, IRI_4, rdf11Model, GRAPH_2);
+ Statements.create(VF, t4, RDF.OBJECT, t8, rdf11Model, GRAPH_2);
+ Statements.create(VF, t7, RDF.TYPE, RDF.STATEMENT, rdf11Model, GRAPH_2);
+ Statements.create(VF, t7, RDF.SUBJECT, BNODE_2, rdf11Model, GRAPH_2);
+ Statements.create(VF, t7, RDF.PREDICATE, IRI_3, rdf11Model, GRAPH_2);
+ Statements.create(VF, t7, RDF.OBJECT, LITERAL_2, rdf11Model, GRAPH_2);
+ Statements.create(VF, t8, RDF.TYPE, RDF.STATEMENT, rdf11Model, GRAPH_2);
+ Statements.create(VF, t8, RDF.SUBJECT, IRI_3, rdf11Model, GRAPH_2);
+ Statements.create(VF, t8, RDF.PREDICATE, IRI_6, rdf11Model, GRAPH_2);
+ Statements.create(VF, t8, RDF.OBJECT, IRI_1, rdf11Model, GRAPH_2);
+
+ return rdf11Model;
+ }
+
+ public static Model createIncompleteRDF11ReificationModel() {
+ Model reifiedModel = new LinkedHashModel();
+ Statements.create(VF, IRI_1, IRI_2, IRI_3, reifiedModel, GRAPH_NULL);
+
+ // maps iri1 iri2 <> to reification
+ BNode t1 = VF.createBNode();
+ Statements.create(VF, IRI_1, IRI_2, t1, reifiedModel, GRAPH_1);
+ // Incomplete reification: missing t1 RDF.TYPE RDF.STATEMENT
+ Statements.create(VF, t1, RDF.SUBJECT, IRI_4, reifiedModel, GRAPH_1);
+ Statements.create(VF, t1, RDF.PREDICATE, IRI_5, reifiedModel, GRAPH_1);
+ Statements.create(VF, t1, RDF.OBJECT, LITERAL_1, reifiedModel, GRAPH_1);
+
+ // maps <> iri3 _:bnode1 to reification
+ BNode t2 = VF.createBNode();
+ Statements.create(VF, t2, IRI_3, BNODE_1, reifiedModel, GRAPH_2);
+ Statements.create(VF, t2, RDF.TYPE, RDF.STATEMENT, reifiedModel, GRAPH_2);
+ // Incomplete reification: missing t2 RDF.SUBJECT iri5
+ Statements.create(VF, t2, RDF.PREDICATE, IRI_6, reifiedModel, GRAPH_2);
+ Statements.create(VF, t2, RDF.OBJECT, IRI_4, reifiedModel, GRAPH_2);
+
+ // maps <> iri3 iri6 to reification
+ BNode t3 = VF.createBNode();
+ Statements.create(VF, t3, IRI_3, IRI_6, reifiedModel, GRAPH_2);
+ Statements.create(VF, t3, RDF.TYPE, RDF.STATEMENT, reifiedModel, GRAPH_2);
+ Statements.create(VF, t3, RDF.SUBJECT, IRI_1, reifiedModel, GRAPH_2);
+ // Incomplete reification: missing t3 RDF.PREDICATE iri2
+ Statements.create(VF, t3, RDF.OBJECT, IRI_4, reifiedModel, GRAPH_2);
+
+ // maps iri6 iri3 <> to reification
+ BNode t4 = VF.createBNode();
+ Statements.create(VF, IRI_6, IRI_3, t4, reifiedModel, GRAPH_2);
+ Statements.create(VF, t4, RDF.TYPE, RDF.STATEMENT, reifiedModel, GRAPH_2);
+ Statements.create(VF, t4, RDF.SUBJECT, IRI_1, reifiedModel, GRAPH_2);
+ Statements.create(VF, t4, RDF.PREDICATE, IRI_2, reifiedModel, GRAPH_2);
+ // Incomplete reification: missing t4 RDF.OBJECT "literal2"
+
+ return reifiedModel;
+ }
+}
diff --git a/core/model/src/test/java/org/eclipse/rdf4j/model/util/ModelsTest.java b/core/model/src/test/java/org/eclipse/rdf4j/model/util/ModelsTest.java
index 0e48d4daa87..38fcd03eb9e 100644
--- a/core/model/src/test/java/org/eclipse/rdf4j/model/util/ModelsTest.java
+++ b/core/model/src/test/java/org/eclipse/rdf4j/model/util/ModelsTest.java
@@ -136,6 +136,27 @@ public void testModelsIsomorphic_BlankNodeContext() {
assertTrue(Models.isomorphic(model1, model2));
}
+ @Test
+ public void testModelsIsomorphic_TripleTerms_SingleContext() {
+ model1.add(VF.createBNode("X"), RDF.REIFIES, VF.createTriple(VF.createBNode("a"), RDF.TYPE, bar), foo);
+ model2.add(VF.createBNode("Y"), RDF.REIFIES, VF.createTriple(VF.createBNode("b"), RDF.TYPE, bar), foo);
+
+ assertTrue(Models.isomorphic(model1, model2));
+ }
+
+ @Test
+ public void testModelsIsomorphic_TripleTerms_MultipleContexts() {
+ model1.add(VF.createBNode("X"), RDF.REIFIES, VF.createTriple(VF.createBNode("a"), RDF.TYPE, bar), foo);
+ model2.add(VF.createBNode("Y"), RDF.REIFIES, VF.createTriple(VF.createBNode("b"), RDF.TYPE, bar), foo);
+
+ model1.add(VF.createBNode("Z"), RDF.REIFIES,
+ VF.createTriple(VF.createBNode("A"), RDF.ALT, VF.createLiteral("some text")), bar);
+ model2.add(VF.createBNode("W"), RDF.REIFIES,
+ VF.createTriple(VF.createBNode("B"), RDF.ALT, VF.createLiteral("some text")), bar);
+
+ assertTrue(Models.isomorphic(model1, model2));
+ }
+
@Test
public void testIsSubset() {
@@ -456,75 +477,75 @@ public void testStripContextsSpecificContext() {
}
@Test
- public void testConvertReificationToRDFStar() {
- Model reificationModel = RDFStarTestHelper.createRDFReificationModel();
- Model referenceRDFStarModel = RDFStarTestHelper.createRDFStarModel();
-
- Model rdfStarModel1 = Models.convertReificationToRDFStar(VF, reificationModel);
- assertTrue("RDF reification conversion to RDF-star with explicit VF, model-to-model",
- Models.isomorphic(rdfStarModel1, referenceRDFStarModel));
-
- Model rdfStarModel2 = Models.convertReificationToRDFStar(reificationModel);
- assertTrue("RDF reification conversion to RDF-star with implicit VF, model-to-model",
- Models.isomorphic(rdfStarModel2, referenceRDFStarModel));
-
- Model rdfStarModel3 = new TreeModel();
- Models.convertReificationToRDFStar(VF, reificationModel, (Consumer) rdfStarModel3::add);
- assertTrue("RDF reification conversion to RDF-star with explicit VF, model-to-consumer",
- Models.isomorphic(rdfStarModel3, referenceRDFStarModel));
-
- Model rdfStarModel4 = new TreeModel();
- Models.convertReificationToRDFStar(reificationModel, rdfStarModel4::add);
- assertTrue("RDF reification conversion to RDF-star with implicit VF, model-to-consumer",
- Models.isomorphic(rdfStarModel4, referenceRDFStarModel));
+ public void testConvertReificationToRDF12() {
+ Model rdf11Model = ModelReificationTestHelper.createRDF11ReificationModel();
+ Model referenceRdf12Model = ModelReificationTestHelper.createRDF12ReificationModel();
+
+ Model convertedRdf11Model = Models.convertReificationToRDF12(VF, rdf11Model);
+ assertTrue("RDF 1.1 reification conversion to RDF 1.2 with explicit VF, model-to-model",
+ Models.isomorphic(convertedRdf11Model, referenceRdf12Model));
+
+ Model convertedRdf11Model2 = Models.convertReificationToRDF12(rdf11Model);
+ assertTrue("RDF reification conversion to RDF 1.2 with implicit VF, model-to-model",
+ Models.isomorphic(convertedRdf11Model2, referenceRdf12Model));
+
+ Model convertedRdf11Model3 = new TreeModel();
+ Models.convertReificationToRDF12(VF, rdf11Model, (Consumer) convertedRdf11Model3::add);
+ assertTrue("RDF reification conversion to RDF 1.2 with explicit VF, model-to-consumer",
+ Models.isomorphic(convertedRdf11Model3, referenceRdf12Model));
+
+ Model convertedRdf11Model4 = new TreeModel();
+ Models.convertReificationToRDF12(rdf11Model, convertedRdf11Model4::add);
+ assertTrue("RDF reification conversion to RDF 1.2 with implicit VF, model-to-consumer",
+ Models.isomorphic(convertedRdf11Model4, referenceRdf12Model));
}
@Test
public void testConvertIncompleteReificationToRDFStar() {
// Incomplete RDF reification (missing type, subject, predicate or object) should not add statements
// and should not remove any of the existing incomplete reification statements.
- Model incompleteReificationModel = RDFStarTestHelper.createIncompleteRDFReificationModel();
+ Model incompleteReificationModel = ModelReificationTestHelper.createIncompleteRDF11ReificationModel();
- Model rdfStarModel1 = Models.convertReificationToRDFStar(VF, incompleteReificationModel);
- assertTrue("Incomplete RDF reification conversion to RDF-star with explicit VF, model-to-model",
+ Model rdfStarModel1 = Models.convertReificationToRDF12(VF, incompleteReificationModel);
+ assertTrue("Incomplete RDF reification conversion to RDF 1.2 with explicit VF, model-to-model",
Models.isomorphic(rdfStarModel1, incompleteReificationModel));
- Model rdfStarModel2 = Models.convertReificationToRDFStar(incompleteReificationModel);
- assertTrue("Incomplete RDF reification conversion to RDF-star with implicit VF, model-to-model",
+ Model rdfStarModel2 = Models.convertReificationToRDF12(incompleteReificationModel);
+ assertTrue("Incomplete RDF reification conversion to RDF 1.2 with implicit VF, model-to-model",
Models.isomorphic(rdfStarModel2, incompleteReificationModel));
Model rdfStarModel3 = new TreeModel();
- Models.convertReificationToRDFStar(VF, incompleteReificationModel, (Consumer) rdfStarModel3::add);
- assertTrue("Incomplete RDF reification conversion to RDF-star with explicit VF, model-to-consumer",
+ Models.convertReificationToRDF12(VF, incompleteReificationModel, (Consumer) rdfStarModel3::add);
+ assertTrue("Incomplete RDF reification conversion to RDF 1.2 with explicit VF, model-to-consumer",
Models.isomorphic(rdfStarModel3, incompleteReificationModel));
Model rdfStarModel4 = new TreeModel();
- Models.convertReificationToRDFStar(incompleteReificationModel, rdfStarModel4::add);
- assertTrue("Incomplete RDF reification conversion to RDF-star with implicit VF, model-to-consumer",
+ Models.convertReificationToRDF12(incompleteReificationModel, rdfStarModel4::add);
+ assertTrue("Incomplete RDF reification conversion to RDF 1.2 with implicit VF, model-to-consumer",
Models.isomorphic(rdfStarModel4, incompleteReificationModel));
}
@Test
public void testConvertRDFStarToReification() {
- Model rdfStarModel = RDFStarTestHelper.createRDFStarModel();
- Model referenceModel = RDFStarTestHelper.createRDFReificationModel();
+ Model rdf12ReificationModel = ModelReificationTestHelper.createRDF12ReificationModel();
+ Model referenceModel = ModelReificationTestHelper.createRDF11ReificationModel();
- Model reificationModel1 = Models.convertRDFStarToReification(VF, rdfStarModel);
- assertTrue("RDF-star conversion to reification with explicit VF, model-to-model",
+ Model reificationModel1 = Models.convertRDF12ReificationToRDF11(VF, rdf12ReificationModel);
+ assertTrue("RDF 1.2 conversion to RDF 1.1 reification with explicit VF, model-to-model",
Models.isomorphic(reificationModel1, referenceModel));
- Model reificationModel2 = Models.convertRDFStarToReification(rdfStarModel);
- assertTrue("RDF-star conversion to reification with implicit VF, model-to-model",
+ Model reificationModel2 = Models.convertRDF12ReificationToRDF11(rdf12ReificationModel);
+ assertTrue("RDF 1.2 conversion to RDF 1.1 reification with implicit VF, model-to-model",
Models.isomorphic(reificationModel2, referenceModel));
Model reificationModel3 = new TreeModel();
- Models.convertRDFStarToReification(VF, rdfStarModel, (Consumer) reificationModel3::add);
- assertTrue("RDF-star conversion to reification with explicit VF, model-to-consumer",
+ Models.convertRDF12ReificationToRDF11(VF, rdf12ReificationModel, (Consumer) reificationModel3::add);
+ assertTrue("RDF 1.2 conversion to RDF 1.1 reification with explicit VF, model-to-consumer",
Models.isomorphic(reificationModel3, referenceModel));
Model reificationModel4 = new TreeModel();
- Models.convertRDFStarToReification(rdfStarModel, reificationModel4::add);
- assertTrue("RDF-star conversion to reification with explicit VF, model-to-consumer",
+ Models.convertRDF12ReificationToRDF11(rdf12ReificationModel, reificationModel4::add);
+ assertTrue("RDF 1.2 conversion to RDF 1.1 reification with explicit VF, model-to-consumer",
Models.isomorphic(reificationModel4, referenceModel));
}
diff --git a/core/model/src/test/java/org/eclipse/rdf4j/model/util/RDFStarTestHelper.java b/core/model/src/test/java/org/eclipse/rdf4j/model/util/RDFStarTestHelper.java
deleted file mode 100644
index f1eac83b89a..00000000000
--- a/core/model/src/test/java/org/eclipse/rdf4j/model/util/RDFStarTestHelper.java
+++ /dev/null
@@ -1,164 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2020 Eclipse RDF4J contributors.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Distribution License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/org/documents/edl-v10.php.
- *
- * SPDX-License-Identifier: BSD-3-Clause
- *******************************************************************************/
-package org.eclipse.rdf4j.model.util;
-
-import org.eclipse.rdf4j.model.BNode;
-import org.eclipse.rdf4j.model.IRI;
-import org.eclipse.rdf4j.model.Literal;
-import org.eclipse.rdf4j.model.Model;
-import org.eclipse.rdf4j.model.ValueFactory;
-import org.eclipse.rdf4j.model.impl.LinkedHashModel;
-import org.eclipse.rdf4j.model.impl.SimpleValueFactory;
-import org.eclipse.rdf4j.model.vocabulary.RDF;
-
-public class RDFStarTestHelper {
- private final static ValueFactory VF = SimpleValueFactory.getInstance();
-
- private final static IRI GRAPH_NULL = null;
- private final static IRI GRAPH_1 = VF.createIRI("urn:graph1");
- private final static IRI GRAPH_2 = VF.createIRI("urn:graph2");
- private final static IRI IRI_1 = VF.createIRI("urn:a");
- private final static IRI IRI_2 = VF.createIRI("urn:b");
- private final static IRI IRI_3 = VF.createIRI("urn:c");
- private final static IRI IRI_4 = VF.createIRI("urn:d");
- private final static IRI IRI_5 = VF.createIRI("urn:e");
- private final static IRI IRI_6 = VF.createIRI("urn:f");
- private final static Literal LITERAL_1 = VF.createLiteral("literal 1");
- private final static Literal LITERAL_2 = VF.createLiteral("literal 2");
- private final static BNode BNODE_1 = VF.createBNode("bnode1");
- private final static BNode BNODE_2 = VF.createBNode("bnode2");
-
- public static Model createRDFStarModel() {
- Model rdfStarModel = new LinkedHashModel();
- Statements.create(VF, IRI_1, IRI_2, IRI_3, rdfStarModel, GRAPH_NULL);
- // The same triple repeated twice
- Statements.create(VF, IRI_1, IRI_2, VF.createTriple(IRI_4, IRI_5, LITERAL_1), rdfStarModel, GRAPH_1);
- Statements.create(VF, IRI_1, IRI_3, VF.createTriple(IRI_4, IRI_5, LITERAL_1), rdfStarModel, GRAPH_1);
- Statements.create(VF, VF.createTriple(IRI_5, IRI_6, IRI_4), IRI_3, BNODE_1, rdfStarModel, GRAPH_2);
- Statements.create(VF, VF.createTriple(VF.createTriple(IRI_1, IRI_2, LITERAL_2),
- IRI_3, VF.createTriple(IRI_4, IRI_5, IRI_6)),
- IRI_2, VF.createTriple(VF.createTriple(BNODE_2, IRI_3, LITERAL_2),
- IRI_4, VF.createTriple(IRI_3, IRI_6, IRI_1)),
- rdfStarModel, GRAPH_2);
-
- return rdfStarModel;
- }
-
- public static Model createRDFReificationModel() {
- Model reifiedModel = new LinkedHashModel();
- Statements.create(VF, IRI_1, IRI_2, IRI_3, reifiedModel, GRAPH_NULL);
-
- // maps iri1 iri2 <> to reification
- BNode t1 = VF.createBNode();
- Statements.create(VF, IRI_1, IRI_2, t1, reifiedModel, GRAPH_1);
- Statements.create(VF, t1, RDF.TYPE, RDF.STATEMENT, reifiedModel, GRAPH_1);
- Statements.create(VF, t1, RDF.SUBJECT, IRI_4, reifiedModel, GRAPH_1);
- Statements.create(VF, t1, RDF.PREDICATE, IRI_5, reifiedModel, GRAPH_1);
- Statements.create(VF, t1, RDF.OBJECT, LITERAL_1, reifiedModel, GRAPH_1);
-
- // maps iri1 iri2 <> to reification
- // same triple/reification statements as previous entry
- Statements.create(VF, IRI_1, IRI_3, t1, reifiedModel, GRAPH_1);
- Statements.create(VF, t1, RDF.TYPE, RDF.STATEMENT, reifiedModel, GRAPH_1);
- Statements.create(VF, t1, RDF.SUBJECT, IRI_4, reifiedModel, GRAPH_1);
- Statements.create(VF, t1, RDF.PREDICATE, IRI_5, reifiedModel, GRAPH_1);
- Statements.create(VF, t1, RDF.OBJECT, LITERAL_1, reifiedModel, GRAPH_1);
-
- // maps <> iri3 _:bnode1 to reification
- BNode t2 = VF.createBNode();
- Statements.create(VF, t2, IRI_3, BNODE_1, reifiedModel, GRAPH_2);
- Statements.create(VF, t2, RDF.TYPE, RDF.STATEMENT, reifiedModel, GRAPH_2);
- Statements.create(VF, t2, RDF.SUBJECT, IRI_5, reifiedModel, GRAPH_2);
- Statements.create(VF, t2, RDF.PREDICATE, IRI_6, reifiedModel, GRAPH_2);
- Statements.create(VF, t2, RDF.OBJECT, IRI_4, reifiedModel, GRAPH_2);
-
- // maps a complex nested statement to reification
- // t3
- // t5 t6
- // subj: << <> iri3 <> >>
- // pred: iri2
- // obj: << <<_:bnode2 iri3 "literal2">> iri4 <> >>
- // t7 t8
- // t4
- BNode t3 = VF.createBNode();
- BNode t4 = VF.createBNode();
- BNode t5 = VF.createBNode();
- BNode t6 = VF.createBNode();
- BNode t7 = VF.createBNode();
- BNode t8 = VF.createBNode();
- Statements.create(VF, t3, IRI_2, t4, reifiedModel, GRAPH_2);
- Statements.create(VF, t3, RDF.TYPE, RDF.STATEMENT, reifiedModel, GRAPH_2);
- Statements.create(VF, t3, RDF.SUBJECT, t5, reifiedModel, GRAPH_2);
- Statements.create(VF, t3, RDF.PREDICATE, IRI_3, reifiedModel, GRAPH_2);
- Statements.create(VF, t3, RDF.OBJECT, t6, reifiedModel, GRAPH_2);
- Statements.create(VF, t5, RDF.TYPE, RDF.STATEMENT, reifiedModel, GRAPH_2);
- Statements.create(VF, t5, RDF.SUBJECT, IRI_1, reifiedModel, GRAPH_2);
- Statements.create(VF, t5, RDF.PREDICATE, IRI_2, reifiedModel, GRAPH_2);
- Statements.create(VF, t5, RDF.OBJECT, LITERAL_2, reifiedModel, GRAPH_2);
- Statements.create(VF, t6, RDF.TYPE, RDF.STATEMENT, reifiedModel, GRAPH_2);
- Statements.create(VF, t6, RDF.SUBJECT, IRI_4, reifiedModel, GRAPH_2);
- Statements.create(VF, t6, RDF.PREDICATE, IRI_5, reifiedModel, GRAPH_2);
- Statements.create(VF, t6, RDF.OBJECT, IRI_6, reifiedModel, GRAPH_2);
- Statements.create(VF, t4, RDF.TYPE, RDF.STATEMENT, reifiedModel, GRAPH_2);
- Statements.create(VF, t4, RDF.SUBJECT, t7, reifiedModel, GRAPH_2);
- Statements.create(VF, t4, RDF.PREDICATE, IRI_4, reifiedModel, GRAPH_2);
- Statements.create(VF, t4, RDF.OBJECT, t8, reifiedModel, GRAPH_2);
- Statements.create(VF, t7, RDF.TYPE, RDF.STATEMENT, reifiedModel, GRAPH_2);
- Statements.create(VF, t7, RDF.SUBJECT, BNODE_2, reifiedModel, GRAPH_2);
- Statements.create(VF, t7, RDF.PREDICATE, IRI_3, reifiedModel, GRAPH_2);
- Statements.create(VF, t7, RDF.OBJECT, LITERAL_2, reifiedModel, GRAPH_2);
- Statements.create(VF, t8, RDF.TYPE, RDF.STATEMENT, reifiedModel, GRAPH_2);
- Statements.create(VF, t8, RDF.SUBJECT, IRI_3, reifiedModel, GRAPH_2);
- Statements.create(VF, t8, RDF.PREDICATE, IRI_6, reifiedModel, GRAPH_2);
- Statements.create(VF, t8, RDF.OBJECT, IRI_1, reifiedModel, GRAPH_2);
-
- return reifiedModel;
- }
-
- public static Model createIncompleteRDFReificationModel() {
- Model reifiedModel = new LinkedHashModel();
- Statements.create(VF, IRI_1, IRI_2, IRI_3, reifiedModel, GRAPH_NULL);
-
- // maps iri1 iri2 <> to reification
- BNode t1 = VF.createBNode();
- Statements.create(VF, IRI_1, IRI_2, t1, reifiedModel, GRAPH_1);
- // Incomplete reification: missing t1 RDF.TYPE RDF.STATEMENT
- Statements.create(VF, t1, RDF.SUBJECT, IRI_4, reifiedModel, GRAPH_1);
- Statements.create(VF, t1, RDF.PREDICATE, IRI_5, reifiedModel, GRAPH_1);
- Statements.create(VF, t1, RDF.OBJECT, LITERAL_1, reifiedModel, GRAPH_1);
-
- // maps <> iri3 _:bnode1 to reification
- BNode t2 = VF.createBNode();
- Statements.create(VF, t2, IRI_3, BNODE_1, reifiedModel, GRAPH_2);
- Statements.create(VF, t2, RDF.TYPE, RDF.STATEMENT, reifiedModel, GRAPH_2);
- // Incomplete reification: missing t2 RDF.SUBJECT iri5
- Statements.create(VF, t2, RDF.PREDICATE, IRI_6, reifiedModel, GRAPH_2);
- Statements.create(VF, t2, RDF.OBJECT, IRI_4, reifiedModel, GRAPH_2);
-
- // maps <> iri3 iri6 to reification
- BNode t3 = VF.createBNode();
- Statements.create(VF, t3, IRI_3, IRI_6, reifiedModel, GRAPH_2);
- Statements.create(VF, t3, RDF.TYPE, RDF.STATEMENT, reifiedModel, GRAPH_2);
- Statements.create(VF, t3, RDF.SUBJECT, IRI_1, reifiedModel, GRAPH_2);
- // Incomplete reification: missing t3 RDF.PREDICATE iri2
- Statements.create(VF, t3, RDF.OBJECT, IRI_4, reifiedModel, GRAPH_2);
-
- // maps iri6 iri3 <> to reification
- BNode t4 = VF.createBNode();
- Statements.create(VF, IRI_6, IRI_3, t4, reifiedModel, GRAPH_2);
- Statements.create(VF, t4, RDF.TYPE, RDF.STATEMENT, reifiedModel, GRAPH_2);
- Statements.create(VF, t4, RDF.SUBJECT, IRI_1, reifiedModel, GRAPH_2);
- Statements.create(VF, t4, RDF.PREDICATE, IRI_2, reifiedModel, GRAPH_2);
- // Incomplete reification: missing t4 RDF.OBJECT "literal2"
-
- return reifiedModel;
- }
-}
diff --git a/core/model/src/test/java/org/eclipse/rdf4j/model/util/StatementsTest.java b/core/model/src/test/java/org/eclipse/rdf4j/model/util/StatementsTest.java
index 53281bd9aab..f8cc6c61cf0 100644
--- a/core/model/src/test/java/org/eclipse/rdf4j/model/util/StatementsTest.java
+++ b/core/model/src/test/java/org/eclipse/rdf4j/model/util/StatementsTest.java
@@ -86,25 +86,19 @@ public void testInvalidInput() {
@Test
public void testRDFStarReification() {
- Model rdfStarModel = RDFStarTestHelper.createRDFStarModel();
+ Model rdfStarModel = ModelReificationTestHelper.createRDF12ReificationModel();
- Model reifiedModel = RDFStarTestHelper.createRDFReificationModel();
+ Model reifiedModel = ModelReificationTestHelper.createRDF11ReificationModel();
Model convertedModel1 = new LinkedHashModel();
- rdfStarModel.forEach((s) -> Statements.convertRDFStarToReification(s, convertedModel1::add));
- assertTrue("RDF-star conversion to reification with implicit VF",
+ rdfStarModel.forEach((s) -> Statements.convertRDF12ReificationToRDF11(s, convertedModel1::add));
+ assertTrue("RDF 1.2 conversion to reification with implicit VF",
Models.isomorphic(reifiedModel, convertedModel1));
Model convertedModel2 = new LinkedHashModel();
- rdfStarModel.forEach((s) -> Statements.convertRDFStarToReification(vf, s, convertedModel2::add));
- assertTrue("RDF-star conversion to reification with explicit VF",
+ rdfStarModel.forEach((s) -> Statements.convertRDF12ReificationToRDF11(vf, s, convertedModel2::add));
+ assertTrue("RDF 1.2 conversion to reification with explicit VF",
Models.isomorphic(reifiedModel, convertedModel2));
-
- Model convertedModel3 = new LinkedHashModel();
- rdfStarModel.forEach((s) -> Statements.convertRDFStarToReification(vf, (t) -> vf.createBNode(t.stringValue()),
- s, convertedModel3::add));
- assertTrue("RDF-star conversion to reification with explicit VF and custom BNode mapping",
- Models.isomorphic(reifiedModel, convertedModel3));
}
@Test
diff --git a/core/pom.xml b/core/pom.xml
index ed94faedcde..2fa72088ce1 100644
--- a/core/pom.xml
+++ b/core/pom.xml
@@ -4,7 +4,7 @@
org.eclipse.rdf4j
rdf4j
- 5.1.0-SNAPSHOT
+ 6.0.0
rdf4j-core
pom
diff --git a/core/query/pom.xml b/core/query/pom.xml
index 6600bd51a4e..e7a555297dd 100644
--- a/core/query/pom.xml
+++ b/core/query/pom.xml
@@ -4,7 +4,7 @@
org.eclipse.rdf4j
rdf4j-core
- 5.1.0-SNAPSHOT
+ 6.0.0
rdf4j-query
RDF4J: Query
diff --git a/core/queryalgebra/evaluation/pom.xml b/core/queryalgebra/evaluation/pom.xml
index a29c5f1ab29..03d9f01ad14 100644
--- a/core/queryalgebra/evaluation/pom.xml
+++ b/core/queryalgebra/evaluation/pom.xml
@@ -4,7 +4,7 @@
org.eclipse.rdf4j
rdf4j-queryalgebra
- 5.1.0-SNAPSHOT
+ 6.0.0
rdf4j-queryalgebra-evaluation
RDF4J: Query algebra - evaluation
diff --git a/core/queryalgebra/evaluation/src/test/java/org/eclipse/rdf4j/query/algebra/evaluation/function/triple/StatementFunctionTest.java b/core/queryalgebra/evaluation/src/test/java/org/eclipse/rdf4j/query/algebra/evaluation/function/triple/StatementFunctionTest.java
index b491dd19312..0eaf4074476 100644
--- a/core/queryalgebra/evaluation/src/test/java/org/eclipse/rdf4j/query/algebra/evaluation/function/triple/StatementFunctionTest.java
+++ b/core/queryalgebra/evaluation/src/test/java/org/eclipse/rdf4j/query/algebra/evaluation/function/triple/StatementFunctionTest.java
@@ -156,58 +156,6 @@ public void testEvaluateBNodeAndTriple() {
assertEquals(value, other, "expect to be the same");
}
- @Test
- public void testEvaluateTripleAndIRI() {
- IRI pred = f.createIRI("urn:b");
- IRI obj = f.createIRI("urn:c");
- Triple subj = f.createTriple(pred, pred, pred);
-
- Value value = function.evaluate(f, subj, pred, obj);
- assertNotNull(value);
- assertTrue(value instanceof Triple, "expect Triple");
- Triple other = f.createTriple(subj, pred, obj);
- assertEquals(value, other, "expect to be the same");
- }
-
- @Test
- public void testEvaluateTripleAndBNode() {
- IRI pred = f.createIRI("urn:b");
- BNode obj = f.createBNode();
- Triple subj = f.createTriple(pred, pred, pred);
-
- Value value = function.evaluate(f, subj, pred, obj);
- assertNotNull(value);
- assertTrue(value instanceof Triple, "expect Triple");
- Triple other = f.createTriple(subj, pred, obj);
- assertEquals(value, other, "expect to be the same");
- }
-
- @Test
- public void testEvaluateTripleAndLiteral() {
- IRI pred = f.createIRI("urn:b");
- Literal obj = f.createLiteral(1);
- Triple subj = f.createTriple(pred, pred, pred);
-
- Value value = function.evaluate(f, subj, pred, obj);
- assertNotNull(value);
- assertTrue(value instanceof Triple, "expect Triple");
- Triple other = f.createTriple(subj, pred, obj);
- assertEquals(value, other, "expect to be the same");
- }
-
- @Test
- public void testEvaluateTripleAndTriple() {
- IRI pred = f.createIRI("urn:b");
- Triple obj = f.createTriple(pred, pred, pred);
- Triple subj = f.createTriple(pred, pred, pred);
-
- Value value = function.evaluate(f, subj, pred, obj);
- assertNotNull(value);
- assertTrue(value instanceof Triple, "expect Triple");
- Triple other = f.createTriple(subj, pred, obj);
- assertEquals(value, other, "expect to be the same");
- }
-
@Test
public void testNegariveWrongNumberOfArguments() {
IRI subj = f.createIRI("urn:a");
diff --git a/core/queryalgebra/evaluation/src/test/java/org/eclipse/rdf4j/query/algebra/evaluation/impl/EvaluationStrategyWithRDFStarTest.java b/core/queryalgebra/evaluation/src/test/java/org/eclipse/rdf4j/query/algebra/evaluation/impl/EvaluationStrategyWithRDFStarTest.java
index a7dfebcf593..5daccd06b6e 100644
--- a/core/queryalgebra/evaluation/src/test/java/org/eclipse/rdf4j/query/algebra/evaluation/impl/EvaluationStrategyWithRDFStarTest.java
+++ b/core/queryalgebra/evaluation/src/test/java/org/eclipse/rdf4j/query/algebra/evaluation/impl/EvaluationStrategyWithRDFStarTest.java
@@ -1,358 +1,358 @@
-/*******************************************************************************
- * Copyright (c) 2020 Eclipse RDF4J contributors.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Distribution License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/org/documents/edl-v10.php.
- *
- * SPDX-License-Identifier: BSD-3-Clause
- *******************************************************************************/
-package org.eclipse.rdf4j.query.algebra.evaluation.impl;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-
-import java.util.ArrayList;
-import java.util.Iterator;
-
-import org.eclipse.rdf4j.common.iteration.AbstractCloseableIteration;
-import org.eclipse.rdf4j.common.iteration.CloseableIteration;
-import org.eclipse.rdf4j.common.iteration.ConvertingIteration;
-import org.eclipse.rdf4j.model.IRI;
-import org.eclipse.rdf4j.model.Resource;
-import org.eclipse.rdf4j.model.Statement;
-import org.eclipse.rdf4j.model.Triple;
-import org.eclipse.rdf4j.model.Value;
-import org.eclipse.rdf4j.model.ValueFactory;
-import org.eclipse.rdf4j.model.impl.SimpleValueFactory;
-import org.eclipse.rdf4j.model.vocabulary.RDF;
-import org.eclipse.rdf4j.query.BindingSet;
-import org.eclipse.rdf4j.query.QueryEvaluationException;
-import org.eclipse.rdf4j.query.algebra.TripleRef;
-import org.eclipse.rdf4j.query.algebra.Var;
-import org.eclipse.rdf4j.query.algebra.evaluation.EvaluationStrategy;
-import org.eclipse.rdf4j.query.algebra.evaluation.QueryBindingSet;
-import org.eclipse.rdf4j.query.algebra.evaluation.RDFStarTripleSource;
-import org.eclipse.rdf4j.query.algebra.evaluation.TripleSource;
-import org.eclipse.rdf4j.query.impl.EmptyBindingSet;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.ValueSource;
-
-/**
- * The test verifies the evaluation of TripleRef nodes through evaluation strategy that uses a tripleSource implementing
- * either {@link TripleSource} or {@link RDFStarTripleSource} interfaces
- *
- * @author damyan.ognyanov
- */
-public class EvaluationStrategyWithRDFStarTest {
-
- // the triples over which the evaluations is carried
- private final ArrayList triples = new ArrayList<>();
-
- ValueFactory vf = SimpleValueFactory.getInstance();
-
- TripleRef tripleRefNode;
-
- CommonBaseSource baseSource;
-
- /**
- * this class does it all over a collection of triples but do not IMPLEMENT either TripleSource nor
- * RDFStarTripleSource The sources for the eval strategies just forward the evaluation to an instance of that
- *
- * @author damyan.ognyanov
- */
- class CommonBaseSource {
- public CloseableIteration getRdfStarTriples(Resource subj,
- IRI pred, Value obj)
- throws QueryEvaluationException {
- return new AbstractCloseableIteration<>() {
-
- final Iterator iter = triples.iterator();
-
- @Override
- public boolean hasNext()
- throws QueryEvaluationException {
- return iter.hasNext();
- }
-
- @Override
- public Triple next()
- throws QueryEvaluationException {
- return iter.next();
- }
-
- @Override
- public void remove()
- throws QueryEvaluationException {
- }
-
- @Override
- protected void handleClose() {
-
- }
- };
- }
-
- public CloseableIteration getStatements(Resource subj,
- IRI pred, Value obj, Resource... contexts)
- throws QueryEvaluationException {
- // handle only arguments with reification vocabulary
- // and return iterations accordingly from the same set of Triples
-
- // handle (*, rdf:type, rdf:Statement)
- if (pred != null && pred.equals(RDF.TYPE) && obj != null && obj.equals(RDF.STATEMENT)) {
- return new ConvertingIteration(
- getRdfStarTriples(null, null, null)) {
- @Override
- protected Statement convert(Triple sourceObject)
- throws QueryEvaluationException {
- return vf.createStatement(sourceObject, RDF.TYPE, RDF.STATEMENT);
- }
- };
- } else if (pred != null && pred.equals(RDF.SUBJECT)) {
- // handle (*, rdf:subject, *)
- return new ConvertingIteration(
- getRdfStarTriples(null, null, null)) {
- @Override
- protected Statement convert(Triple sourceObject)
- throws QueryEvaluationException {
- return vf.createStatement(sourceObject, RDF.SUBJECT, sourceObject.getSubject());
- }
- };
- } else if (pred != null && pred.equals(RDF.PREDICATE)) {
- // handle (*, rdf:predicate, *)
- return new ConvertingIteration(
- getRdfStarTriples(null, null, null)) {
- @Override
- protected Statement convert(Triple sourceObject)
- throws QueryEvaluationException {
- return vf.createStatement(sourceObject, RDF.PREDICATE, sourceObject.getPredicate());
- }
- };
- } else if (pred != null && pred.equals(RDF.OBJECT)) {
- // handle (*, rdf:object, *)
- return new ConvertingIteration(
- getRdfStarTriples(null, null, null)) {
- @Override
- protected Statement convert(Triple sourceObject)
- throws QueryEvaluationException {
- return vf.createStatement(sourceObject, RDF.OBJECT, sourceObject.getObject());
- }
- };
- }
- // DO NOT handle anything else
- return null;
- }
-
- }
-
- @BeforeEach
- public void setUp() {
- // prepare data
- triples.clear();
- triples.add(vf.createTriple(vf.createIRI("urn:a"), vf.createIRI("urn:p"), vf.createIRI("urn:b")));
- triples.add(vf.createTriple(vf.createIRI("urn:a"), vf.createIRI("urn:q"), vf.createIRI("urn:b:1")));
- triples.add(vf.createTriple(vf.createIRI("urn:a:1"), vf.createIRI("urn:p"), vf.createIRI("urn:b")));
- triples.add(vf.createTriple(vf.createIRI("urn:a:2"), vf.createIRI("urn:q"), vf.createIRI("urn:c")));
-
- baseSource = new CommonBaseSource();
-
- tripleRefNode = new TripleRef(new Var("s"), new Var("p"), new Var("o"), new Var("extern"));
- }
-
- /**
- * parametrized: either {@link RDFStarTripleSource} or {@link TripleSource}
- *
- * @param bRDFStarData
- */
- private TripleSource createSource(boolean bRDFStarData) {
- if (bRDFStarData) {
- return new RDFStarTripleSource() {
-
- @Override
- public ValueFactory getValueFactory() {
- return vf;
- }
-
- @Override
- public CloseableIteration getStatements(Resource subj,
- IRI pred, Value obj, Resource... contexts)
- throws QueryEvaluationException {
- return baseSource.getStatements(subj, pred, obj, contexts);
- }
-
- @Override
- public CloseableIteration getRdfStarTriples(Resource subj,
- IRI pred, Value obj)
- throws QueryEvaluationException {
- return baseSource.getRdfStarTriples(subj, pred, obj);
- }
- };
- } else {
- return new TripleSource() {
- @Override
- public ValueFactory getValueFactory() {
- return vf;
- }
-
- @Override
- public CloseableIteration getStatements(Resource subj,
- IRI pred, Value obj, Resource... contexts)
- throws QueryEvaluationException {
- return baseSource.getStatements(subj, pred, obj, contexts);
- }
- };
- }
- }
-
- @ParameterizedTest(name = "RDF-star={0}")
- @ValueSource(booleans = { false, true })
- public void testMatchAllUnbound(boolean bRDFStarData) {
- EvaluationStrategy strategy = new StrictEvaluationStrategy(createSource(bRDFStarData), null);
- // case check all unbound
- try (CloseableIteration iter = strategy.precompile(tripleRefNode)
- .evaluate(
- new EmptyBindingSet())) {
- ArrayList expected = new ArrayList<>();
- triples.forEach(t -> {
- expected.add(fromTriple(t));
- });
- ArrayList received = new ArrayList<>();
- while (iter.hasNext()) {
- received.add(iter.next());
- }
- assertTrue(received.containsAll(expected), "all expected must be received");
- assertTrue(expected.containsAll(received), "all received must be expected");
- }
- }
-
- @ParameterizedTest(name = "RDF-star={0}")
- @ValueSource(booleans = { false, true })
- public void testSubjVarBound(boolean bRDFStarData) {
- EvaluationStrategy strategy = new StrictEvaluationStrategy(createSource(bRDFStarData), null);
- try (CloseableIteration iter = strategy.precompile(tripleRefNode)
- .evaluate(
- createWithVarValue(tripleRefNode.getSubjectVar(), vf.createIRI("urn:a")))) {
- ArrayList expected = new ArrayList<>();
- triples.forEach(t -> {
- if (t.getSubject().equals(vf.createIRI("urn:a"))) {
- expected.add(fromTriple(t));
- }
- });
- ArrayList received = new ArrayList<>();
- while (iter.hasNext()) {
- received.add(iter.next());
- }
- assertTrue(received.containsAll(expected), "all expected must be received");
- assertTrue(expected.containsAll(received), "all received must be expected");
- }
- }
-
- @ParameterizedTest(name = "RDF-star={0}")
- @ValueSource(booleans = { false, true })
- public void testPredVarBound(boolean bRDFStarData) {
- EvaluationStrategy strategy = new StrictEvaluationStrategy(createSource(bRDFStarData), null);
- try (CloseableIteration iter = strategy.precompile(tripleRefNode)
- .evaluate(
- createWithVarValue(tripleRefNode.getPredicateVar(), vf.createIRI("urn:p")))) {
-
- ArrayList expected = new ArrayList<>();
- triples.forEach(t -> {
- if (t.getPredicate().equals(vf.createIRI("urn:p"))) {
- expected.add(fromTriple(t));
- }
- });
- ArrayList received = new ArrayList<>();
- while (iter.hasNext()) {
- received.add(iter.next());
- }
- assertTrue(received.containsAll(expected), "all expected must be received");
- assertTrue(expected.containsAll(received), "all received must be expected");
- }
- }
-
- @ParameterizedTest(name = "RDF-star={0}")
- @ValueSource(booleans = { false, true })
- public void testObjVarBound(boolean bRDFStarData) {
- EvaluationStrategy strategy = new StrictEvaluationStrategy(createSource(bRDFStarData), null);
- try (CloseableIteration iter = strategy.precompile(tripleRefNode)
- .evaluate(
- createWithVarValue(tripleRefNode.getObjectVar(), vf.createIRI("urn:b")))) {
-
- ArrayList expected = new ArrayList<>();
- triples.forEach(t -> {
- if (t.getObject().equals(vf.createIRI("urn:b"))) {
- expected.add(fromTriple(t));
- }
- });
- ArrayList received = new ArrayList<>();
- while (iter.hasNext()) {
- received.add(iter.next());
- }
- assertTrue(received.containsAll(expected), "all expected must be received");
- assertTrue(expected.containsAll(received), "all received must be expected");
- }
- }
-
- @ParameterizedTest(name = "RDF-star={0}")
- @ValueSource(booleans = { false, true })
- public void testSubjAndObjVarBound(boolean bRDFStarData) {
- QueryBindingSet set = (QueryBindingSet) createWithVarValue(tripleRefNode.getObjectVar(), vf.createIRI("urn:c"));
- set.addBinding(tripleRefNode.getSubjectVar().getName(), vf.createIRI("urn:a:2"));
-
- EvaluationStrategy strategy = new StrictEvaluationStrategy(createSource(bRDFStarData), null);
- try (CloseableIteration iter = strategy.precompile(tripleRefNode).evaluate(set)) {
-
- ArrayList expected = new ArrayList<>();
- triples.forEach(t -> {
- if (t.getObject().equals(vf.createIRI("urn:c")) && t.getSubject().equals(vf.createIRI("urn:a:2"))) {
- expected.add(fromTriple(t));
- }
- });
- ArrayList received = new ArrayList<>();
- while (iter.hasNext()) {
- received.add(iter.next());
- }
- assertTrue(received.containsAll(expected), "all expected must be received");
- assertTrue(expected.containsAll(received), "all received must be expected");
- }
- }
-
- @ParameterizedTest(name = "RDF-star={0}")
- @ValueSource(booleans = { false, true })
- public void testExtVarBound(boolean bRDFStarData) {
- Triple triple = triples.get(0);
- QueryBindingSet set = (QueryBindingSet) createWithVarValue(tripleRefNode.getExprVar(), triple);
-
- EvaluationStrategy strategy = new StrictEvaluationStrategy(createSource(bRDFStarData), null);
- try (CloseableIteration iter = strategy.precompile(tripleRefNode).evaluate(set)) {
-
- ArrayList expected = new ArrayList<>();
- expected.add(fromTriple(triple));
- ArrayList received = new ArrayList<>();
- while (iter.hasNext()) {
- received.add(iter.next());
- }
-
- assertThat(received).containsAll(expected);
- assertThat(expected).containsAll(received);
- }
- }
-
- private BindingSet createWithVarValue(Var var, Value value) {
- QueryBindingSet ret = new QueryBindingSet();
- ret.addBinding(var.getName(), value);
- return ret;
- }
-
- private BindingSet fromTriple(Triple t) {
- QueryBindingSet ret = new QueryBindingSet();
- ret.addBinding("extern", t);
- ret.addBinding("s", t.getSubject());
- ret.addBinding("p", t.getPredicate());
- ret.addBinding("o", t.getObject());
- return ret;
- }
-}
+///*******************************************************************************
+// * Copyright (c) 2020 Eclipse RDF4J contributors.
+// *
+// * All rights reserved. This program and the accompanying materials
+// * are made available under the terms of the Eclipse Distribution License v1.0
+// * which accompanies this distribution, and is available at
+// * http://www.eclipse.org/org/documents/edl-v10.php.
+// *
+// * SPDX-License-Identifier: BSD-3-Clause
+// *******************************************************************************/
+//package org.eclipse.rdf4j.query.algebra.evaluation.impl;
+//
+//import static org.assertj.core.api.Assertions.assertThat;
+//import static org.junit.jupiter.api.Assertions.assertTrue;
+//
+//import java.util.ArrayList;
+//import java.util.Iterator;
+//
+//import org.eclipse.rdf4j.common.iteration.AbstractCloseableIteration;
+//import org.eclipse.rdf4j.common.iteration.CloseableIteration;
+//import org.eclipse.rdf4j.common.iteration.ConvertingIteration;
+//import org.eclipse.rdf4j.model.IRI;
+//import org.eclipse.rdf4j.model.Resource;
+//import org.eclipse.rdf4j.model.Statement;
+//import org.eclipse.rdf4j.model.Triple;
+//import org.eclipse.rdf4j.model.Value;
+//import org.eclipse.rdf4j.model.ValueFactory;
+//import org.eclipse.rdf4j.model.impl.SimpleValueFactory;
+//import org.eclipse.rdf4j.model.vocabulary.RDF;
+//import org.eclipse.rdf4j.query.BindingSet;
+//import org.eclipse.rdf4j.query.QueryEvaluationException;
+//import org.eclipse.rdf4j.query.algebra.TripleRef;
+//import org.eclipse.rdf4j.query.algebra.Var;
+//import org.eclipse.rdf4j.query.algebra.evaluation.EvaluationStrategy;
+//import org.eclipse.rdf4j.query.algebra.evaluation.QueryBindingSet;
+//import org.eclipse.rdf4j.query.algebra.evaluation.RDFStarTripleSource;
+//import org.eclipse.rdf4j.query.algebra.evaluation.TripleSource;
+//import org.eclipse.rdf4j.query.impl.EmptyBindingSet;
+//import org.junit.jupiter.api.BeforeEach;
+//import org.junit.jupiter.params.ParameterizedTest;
+//import org.junit.jupiter.params.provider.ValueSource;
+//
+///**
+// * The test verifies the evaluation of TripleRef nodes through evaluation strategy that uses a tripleSource implementing
+// * either {@link TripleSource} or {@link RDFStarTripleSource} interfaces
+// *
+// * @author damyan.ognyanov
+// */
+//public class EvaluationStrategyWithRDFStarTest {
+//
+// // the triples over which the evaluations is carried
+// private final ArrayList triples = new ArrayList<>();
+//
+// ValueFactory vf = SimpleValueFactory.getInstance();
+//
+// TripleRef tripleRefNode;
+//
+// CommonBaseSource baseSource;
+//
+// /**
+// * this class does it all over a collection of triples but do not IMPLEMENT either TripleSource nor
+// * RDFStarTripleSource The sources for the eval strategies just forward the evaluation to an instance of that
+// *
+// * @author damyan.ognyanov
+// */
+// class CommonBaseSource {
+// public CloseableIteration getRdfStarTriples(Resource subj,
+// IRI pred, Value obj)
+// throws QueryEvaluationException {
+// return new AbstractCloseableIteration<>() {
+//
+// final Iterator iter = triples.iterator();
+//
+// @Override
+// public boolean hasNext()
+// throws QueryEvaluationException {
+// return iter.hasNext();
+// }
+//
+// @Override
+// public Triple next()
+// throws QueryEvaluationException {
+// return iter.next();
+// }
+//
+// @Override
+// public void remove()
+// throws QueryEvaluationException {
+// }
+//
+// @Override
+// protected void handleClose() {
+//
+// }
+// };
+// }
+//
+// public CloseableIteration getStatements(Resource subj,
+// IRI pred, Value obj, Resource... contexts)
+// throws QueryEvaluationException {
+// // handle only arguments with reification vocabulary
+// // and return iterations accordingly from the same set of Triples
+//
+// // handle (*, rdf:type, rdf:Statement)
+// if (pred != null && pred.equals(RDF.TYPE) && obj != null && obj.equals(RDF.STATEMENT)) {
+// return new ConvertingIteration(
+// getRdfStarTriples(null, null, null)) {
+// @Override
+// protected Statement convert(Triple sourceObject)
+// throws QueryEvaluationException {
+// return vf.createStatement(sourceObject, RDF.TYPE, RDF.STATEMENT);
+// }
+// };
+// } else if (pred != null && pred.equals(RDF.SUBJECT)) {
+// // handle (*, rdf:subject, *)
+// return new ConvertingIteration(
+// getRdfStarTriples(null, null, null)) {
+// @Override
+// protected Statement convert(Triple sourceObject)
+// throws QueryEvaluationException {
+// return vf.createStatement(sourceObject, RDF.SUBJECT, sourceObject.getSubject());
+// }
+// };
+// } else if (pred != null && pred.equals(RDF.PREDICATE)) {
+// // handle (*, rdf:predicate, *)
+// return new ConvertingIteration(
+// getRdfStarTriples(null, null, null)) {
+// @Override
+// protected Statement convert(Triple sourceObject)
+// throws QueryEvaluationException {
+// return vf.createStatement(sourceObject, RDF.PREDICATE, sourceObject.getPredicate());
+// }
+// };
+// } else if (pred != null && pred.equals(RDF.OBJECT)) {
+// // handle (*, rdf:object, *)
+// return new ConvertingIteration(
+// getRdfStarTriples(null, null, null)) {
+// @Override
+// protected Statement convert(Triple sourceObject)
+// throws QueryEvaluationException {
+// return vf.createStatement(sourceObject, RDF.OBJECT, sourceObject.getObject());
+// }
+// };
+// }
+// // DO NOT handle anything else
+// return null;
+// }
+//
+// }
+//
+// @BeforeEach
+// public void setUp() {
+// // prepare data
+// triples.clear();
+// triples.add(vf.createTriple(vf.createIRI("urn:a"), vf.createIRI("urn:p"), vf.createIRI("urn:b")));
+// triples.add(vf.createTriple(vf.createIRI("urn:a"), vf.createIRI("urn:q"), vf.createIRI("urn:b:1")));
+// triples.add(vf.createTriple(vf.createIRI("urn:a:1"), vf.createIRI("urn:p"), vf.createIRI("urn:b")));
+// triples.add(vf.createTriple(vf.createIRI("urn:a:2"), vf.createIRI("urn:q"), vf.createIRI("urn:c")));
+//
+// baseSource = new CommonBaseSource();
+//
+// tripleRefNode = new TripleRef(new Var("s"), new Var("p"), new Var("o"), new Var("extern"));
+// }
+//
+// /**
+// * parametrized: either {@link RDFStarTripleSource} or {@link TripleSource}
+// *
+// * @param bRDFStarData
+// */
+// private TripleSource createSource(boolean bRDFStarData) {
+// if (bRDFStarData) {
+// return new RDFStarTripleSource() {
+//
+// @Override
+// public ValueFactory getValueFactory() {
+// return vf;
+// }
+//
+// @Override
+// public CloseableIteration getStatements(Resource subj,
+// IRI pred, Value obj, Resource... contexts)
+// throws QueryEvaluationException {
+// return baseSource.getStatements(subj, pred, obj, contexts);
+// }
+//
+// @Override
+// public CloseableIteration getRdfStarTriples(Resource subj,
+// IRI pred, Value obj)
+// throws QueryEvaluationException {
+// return baseSource.getRdfStarTriples(subj, pred, obj);
+// }
+// };
+// } else {
+// return new TripleSource() {
+// @Override
+// public ValueFactory getValueFactory() {
+// return vf;
+// }
+//
+// @Override
+// public CloseableIteration getStatements(Resource subj,
+// IRI pred, Value obj, Resource... contexts)
+// throws QueryEvaluationException {
+// return baseSource.getStatements(subj, pred, obj, contexts);
+// }
+// };
+// }
+// }
+//
+// @ParameterizedTest(name = "RDF-star={0}")
+// @ValueSource(booleans = { false, true })
+// public void testMatchAllUnbound(boolean bRDFStarData) {
+// EvaluationStrategy strategy = new StrictEvaluationStrategy(createSource(bRDFStarData), null);
+// // case check all unbound
+// try (CloseableIteration iter = strategy.precompile(tripleRefNode)
+// .evaluate(
+// new EmptyBindingSet())) {
+// ArrayList expected = new ArrayList<>();
+// triples.forEach(t -> {
+// expected.add(fromTriple(t));
+// });
+// ArrayList received = new ArrayList<>();
+// while (iter.hasNext()) {
+// received.add(iter.next());
+// }
+// assertTrue(received.containsAll(expected), "all expected must be received");
+// assertTrue(expected.containsAll(received), "all received must be expected");
+// }
+// }
+//
+// @ParameterizedTest(name = "RDF-star={0}")
+// @ValueSource(booleans = { false, true })
+// public void testSubjVarBound(boolean bRDFStarData) {
+// EvaluationStrategy strategy = new StrictEvaluationStrategy(createSource(bRDFStarData), null);
+// try (CloseableIteration iter = strategy.precompile(tripleRefNode)
+// .evaluate(
+// createWithVarValue(tripleRefNode.getSubjectVar(), vf.createIRI("urn:a")))) {
+// ArrayList expected = new ArrayList<>();
+// triples.forEach(t -> {
+// if (t.getSubject().equals(vf.createIRI("urn:a"))) {
+// expected.add(fromTriple(t));
+// }
+// });
+// ArrayList received = new ArrayList<>();
+// while (iter.hasNext()) {
+// received.add(iter.next());
+// }
+// assertTrue(received.containsAll(expected), "all expected must be received");
+// assertTrue(expected.containsAll(received), "all received must be expected");
+// }
+// }
+//
+// @ParameterizedTest(name = "RDF-star={0}")
+// @ValueSource(booleans = { false, true })
+// public void testPredVarBound(boolean bRDFStarData) {
+// EvaluationStrategy strategy = new StrictEvaluationStrategy(createSource(bRDFStarData), null);
+// try (CloseableIteration iter = strategy.precompile(tripleRefNode)
+// .evaluate(
+// createWithVarValue(tripleRefNode.getPredicateVar(), vf.createIRI("urn:p")))) {
+//
+// ArrayList expected = new ArrayList<>();
+// triples.forEach(t -> {
+// if (t.getPredicate().equals(vf.createIRI("urn:p"))) {
+// expected.add(fromTriple(t));
+// }
+// });
+// ArrayList received = new ArrayList<>();
+// while (iter.hasNext()) {
+// received.add(iter.next());
+// }
+// assertTrue(received.containsAll(expected), "all expected must be received");
+// assertTrue(expected.containsAll(received), "all received must be expected");
+// }
+// }
+//
+// @ParameterizedTest(name = "RDF-star={0}")
+// @ValueSource(booleans = { false, true })
+// public void testObjVarBound(boolean bRDFStarData) {
+// EvaluationStrategy strategy = new StrictEvaluationStrategy(createSource(bRDFStarData), null);
+// try (CloseableIteration iter = strategy.precompile(tripleRefNode)
+// .evaluate(
+// createWithVarValue(tripleRefNode.getObjectVar(), vf.createIRI("urn:b")))) {
+//
+// ArrayList expected = new ArrayList<>();
+// triples.forEach(t -> {
+// if (t.getObject().equals(vf.createIRI("urn:b"))) {
+// expected.add(fromTriple(t));
+// }
+// });
+// ArrayList received = new ArrayList<>();
+// while (iter.hasNext()) {
+// received.add(iter.next());
+// }
+// assertTrue(received.containsAll(expected), "all expected must be received");
+// assertTrue(expected.containsAll(received), "all received must be expected");
+// }
+// }
+//
+// @ParameterizedTest(name = "RDF-star={0}")
+// @ValueSource(booleans = { false, true })
+// public void testSubjAndObjVarBound(boolean bRDFStarData) {
+// QueryBindingSet set = (QueryBindingSet) createWithVarValue(tripleRefNode.getObjectVar(), vf.createIRI("urn:c"));
+// set.addBinding(tripleRefNode.getSubjectVar().getName(), vf.createIRI("urn:a:2"));
+//
+// EvaluationStrategy strategy = new StrictEvaluationStrategy(createSource(bRDFStarData), null);
+// try (CloseableIteration iter = strategy.precompile(tripleRefNode).evaluate(set)) {
+//
+// ArrayList expected = new ArrayList<>();
+// triples.forEach(t -> {
+// if (t.getObject().equals(vf.createIRI("urn:c")) && t.getSubject().equals(vf.createIRI("urn:a:2"))) {
+// expected.add(fromTriple(t));
+// }
+// });
+// ArrayList received = new ArrayList<>();
+// while (iter.hasNext()) {
+// received.add(iter.next());
+// }
+// assertTrue(received.containsAll(expected), "all expected must be received");
+// assertTrue(expected.containsAll(received), "all received must be expected");
+// }
+// }
+//
+// @ParameterizedTest(name = "RDF-star={0}")
+// @ValueSource(booleans = { false, true })
+// public void testExtVarBound(boolean bRDFStarData) {
+// Triple triple = triples.get(0);
+// QueryBindingSet set = (QueryBindingSet) createWithVarValue(tripleRefNode.getExprVar(), triple);
+//
+// EvaluationStrategy strategy = new StrictEvaluationStrategy(createSource(bRDFStarData), null);
+// try (CloseableIteration iter = strategy.precompile(tripleRefNode).evaluate(set)) {
+//
+// ArrayList expected = new ArrayList<>();
+// expected.add(fromTriple(triple));
+// ArrayList received = new ArrayList<>();
+// while (iter.hasNext()) {
+// received.add(iter.next());
+// }
+//
+// assertThat(received).containsAll(expected);
+// assertThat(expected).containsAll(received);
+// }
+// }
+//
+// private BindingSet createWithVarValue(Var var, Value value) {
+// QueryBindingSet ret = new QueryBindingSet();
+// ret.addBinding(var.getName(), value);
+// return ret;
+// }
+//
+// private BindingSet fromTriple(Triple t) {
+// QueryBindingSet ret = new QueryBindingSet();
+// ret.addBinding("extern", t);
+// ret.addBinding("s", t.getSubject());
+// ret.addBinding("p", t.getPredicate());
+// ret.addBinding("o", t.getObject());
+// return ret;
+// }
+//}
diff --git a/core/queryalgebra/geosparql/pom.xml b/core/queryalgebra/geosparql/pom.xml
index 10fcbc837ce..897e591ea62 100644
--- a/core/queryalgebra/geosparql/pom.xml
+++ b/core/queryalgebra/geosparql/pom.xml
@@ -4,7 +4,7 @@
org.eclipse.rdf4j
rdf4j-queryalgebra
- 5.1.0-SNAPSHOT
+ 6.0.0
rdf4j-queryalgebra-geosparql
RDF4J: Query algebra - GeoSPARQL
diff --git a/core/queryalgebra/model/pom.xml b/core/queryalgebra/model/pom.xml
index c561441a066..c0c7117e2ca 100644
--- a/core/queryalgebra/model/pom.xml
+++ b/core/queryalgebra/model/pom.xml
@@ -4,7 +4,7 @@
org.eclipse.rdf4j
rdf4j-queryalgebra
- 5.1.0-SNAPSHOT
+ 6.0.0
rdf4j-queryalgebra-model
RDF4J: Query algebra - model
diff --git a/core/queryalgebra/pom.xml b/core/queryalgebra/pom.xml
index fb04d8339cd..f58e10187ff 100644
--- a/core/queryalgebra/pom.xml
+++ b/core/queryalgebra/pom.xml
@@ -4,7 +4,7 @@
org.eclipse.rdf4j
rdf4j-core
- 5.1.0-SNAPSHOT
+ 6.0.0
rdf4j-queryalgebra
pom
diff --git a/core/queryparser/api/pom.xml b/core/queryparser/api/pom.xml
index 6450c375f42..1f26f7e08be 100644
--- a/core/queryparser/api/pom.xml
+++ b/core/queryparser/api/pom.xml
@@ -4,7 +4,7 @@
org.eclipse.rdf4j
rdf4j-queryparser
- 5.1.0-SNAPSHOT
+ 6.0.0
rdf4j-queryparser-api
RDF4J: Query parser - API
diff --git a/core/queryparser/pom.xml b/core/queryparser/pom.xml
index 0dfcb8573d3..5f85d8284fb 100644
--- a/core/queryparser/pom.xml
+++ b/core/queryparser/pom.xml
@@ -4,7 +4,7 @@
org.eclipse.rdf4j
rdf4j-core
- 5.1.0-SNAPSHOT
+ 6.0.0
rdf4j-queryparser
pom
diff --git a/core/queryparser/sparql/pom.xml b/core/queryparser/sparql/pom.xml
index d21ecf2b1b2..9b5e1ed30da 100644
--- a/core/queryparser/sparql/pom.xml
+++ b/core/queryparser/sparql/pom.xml
@@ -4,7 +4,7 @@
org.eclipse.rdf4j
rdf4j-queryparser
- 5.1.0-SNAPSHOT
+ 6.0.0
rdf4j-queryparser-sparql
RDF4J: Query parser - SPARQL
diff --git a/core/queryparser/sparql/src/main/java/org/eclipse/rdf4j/query/parser/sparql/SPARQLUpdateDataBlockParser.java b/core/queryparser/sparql/src/main/java/org/eclipse/rdf4j/query/parser/sparql/SPARQLUpdateDataBlockParser.java
index df080232afb..d1d6f0635fa 100644
--- a/core/queryparser/sparql/src/main/java/org/eclipse/rdf4j/query/parser/sparql/SPARQLUpdateDataBlockParser.java
+++ b/core/queryparser/sparql/src/main/java/org/eclipse/rdf4j/query/parser/sparql/SPARQLUpdateDataBlockParser.java
@@ -19,25 +19,24 @@
import org.eclipse.rdf4j.rio.RDFFormat;
import org.eclipse.rdf4j.rio.RDFHandlerException;
import org.eclipse.rdf4j.rio.RDFParseException;
-import org.eclipse.rdf4j.rio.trigstar.TriGStarParser;
+import org.eclipse.rdf4j.rio.trig.TriGParser;
import org.eclipse.rdf4j.rio.turtle.TurtleUtil;
/**
- * An extension of {@link TriGStarParser} that processes data in the format specified in the SPARQL 1.1 grammar for Quad
+ * An extension of {@link TriGParser} that processes data in the format specified in the SPARQL 1.1 grammar for Quad
* data (assuming no variables, as is the case for INSERT DATA and DELETE DATA operations). This format is almost
* completely compatible with TriG, except for three differences:
*
* - it introduces the 'GRAPH' keyword in front of each named graph identifier
*
- it does not allow the occurrence of blank nodes.
*
- it does not require curly braces around the default graph.
- *
- it adds support for RDF-star triples (from TriG-star).
*
*
* @author Jeen Broekstra
* @see SPARQL 1.1 Grammar production for INSERT DATA
* @see SPARQL 1.1 Grammar production for DELETE DATA
*/
-public class SPARQLUpdateDataBlockParser extends TriGStarParser {
+public class SPARQLUpdateDataBlockParser extends TriGParser {
private boolean allowBlankNodes = true;
private int lineNumberOffset;
diff --git a/core/queryparser/sparql/src/test/java/org/eclipse/rdf4j/query/parser/sparql/SPARQLUpdateDataBlockParserTest.java b/core/queryparser/sparql/src/test/java/org/eclipse/rdf4j/query/parser/sparql/SPARQLUpdateDataBlockParserTest.java
index 87cb15e3283..a76940efd13 100644
--- a/core/queryparser/sparql/src/test/java/org/eclipse/rdf4j/query/parser/sparql/SPARQLUpdateDataBlockParserTest.java
+++ b/core/queryparser/sparql/src/test/java/org/eclipse/rdf4j/query/parser/sparql/SPARQLUpdateDataBlockParserTest.java
@@ -15,6 +15,7 @@
import org.eclipse.rdf4j.rio.RDFHandlerException;
import org.eclipse.rdf4j.rio.RDFParseException;
+import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.Test;
/**
@@ -37,6 +38,7 @@ public void testParseGraph() throws RDFParseException, RDFHandlerException, IOEx
}
@Test
+ @Disabled("pending SPARQL 1.2 implementation and updating test for RDF 1.2")
public void testParseRDFStar() throws IOException {
SPARQLUpdateDataBlockParser parser = new SPARQLUpdateDataBlockParser();
diff --git a/core/queryrender/pom.xml b/core/queryrender/pom.xml
index 8db12169a80..73703896a03 100644
--- a/core/queryrender/pom.xml
+++ b/core/queryrender/pom.xml
@@ -4,7 +4,7 @@
org.eclipse.rdf4j
rdf4j-core
- 5.1.0-SNAPSHOT
+ 6.0.0
rdf4j-queryrender
RDF4J: Query Rendering
diff --git a/core/queryresultio/api/pom.xml b/core/queryresultio/api/pom.xml
index 273fe3b9801..c9771d0de15 100644
--- a/core/queryresultio/api/pom.xml
+++ b/core/queryresultio/api/pom.xml
@@ -4,7 +4,7 @@
org.eclipse.rdf4j
rdf4j-queryresultio
- 5.1.0-SNAPSHOT
+ 6.0.0
rdf4j-queryresultio-api
RDF4J: Query result IO - API
diff --git a/core/queryresultio/api/src/main/java/org/eclipse/rdf4j/query/resultio/AbstractQueryResultParser.java b/core/queryresultio/api/src/main/java/org/eclipse/rdf4j/query/resultio/AbstractQueryResultParser.java
index 9da3659335b..a182c974998 100644
--- a/core/queryresultio/api/src/main/java/org/eclipse/rdf4j/query/resultio/AbstractQueryResultParser.java
+++ b/core/queryresultio/api/src/main/java/org/eclipse/rdf4j/query/resultio/AbstractQueryResultParser.java
@@ -88,8 +88,8 @@ public QueryResultParser setValueFactory(ValueFactory valueFactory) {
@Override
public QueryResultParser setQueryResultHandler(QueryResultHandler handler) {
- if (getParserConfig().get(BasicParserSettings.PROCESS_ENCODED_RDF_STAR)) {
- handler = new RDFStarDecodingQueryResultHandler(handler);
+ if (getParserConfig().get(BasicParserSettings.PROCESS_ENCODED_TRIPLE_TERMS)) {
+ handler = new TripleTermDecodingQueryResultHandler(handler);
}
this.handler = handler;
return this;
diff --git a/core/queryresultio/api/src/main/java/org/eclipse/rdf4j/query/resultio/AbstractQueryResultWriter.java b/core/queryresultio/api/src/main/java/org/eclipse/rdf4j/query/resultio/AbstractQueryResultWriter.java
index a595504cb09..eb5ed45764c 100644
--- a/core/queryresultio/api/src/main/java/org/eclipse/rdf4j/query/resultio/AbstractQueryResultWriter.java
+++ b/core/queryresultio/api/src/main/java/org/eclipse/rdf4j/query/resultio/AbstractQueryResultWriter.java
@@ -21,7 +21,7 @@
import org.eclipse.rdf4j.rio.RioSetting;
import org.eclipse.rdf4j.rio.WriterConfig;
import org.eclipse.rdf4j.rio.helpers.BasicWriterSettings;
-import org.eclipse.rdf4j.rio.helpers.RDFStarUtil;
+import org.eclipse.rdf4j.rio.helpers.TripleTermUtil;
/**
* Base class for {@link QueryResultWriter}s offering common functionality for query result writers.
@@ -32,7 +32,7 @@ public abstract class AbstractQueryResultWriter implements QueryResultWriter, Si
private WriterConfig writerConfig = new WriterConfig();
- private boolean encodeRDFStar;
+ private boolean encodeTripleTerms;
@Override
public void setWriterConfig(WriterConfig config) {
@@ -46,7 +46,7 @@ public WriterConfig getWriterConfig() {
@Override
public Collection> getSupportedSettings() {
- return Arrays.asList(BasicWriterSettings.ENCODE_RDF_STAR, BasicWriterSettings.XSD_STRING_TO_PLAIN_LITERAL);
+ return Arrays.asList(BasicWriterSettings.ENCODE_TRIPLE_TERMS, BasicWriterSettings.XSD_STRING_TO_PLAIN_LITERAL);
}
@Override
@@ -56,17 +56,17 @@ public FileFormat getFileFormat() {
@Override
public void startQueryResult(List bindingNames) throws TupleQueryResultHandlerException {
- // Formats without native RDF-star support obey the ENCODE_RDF_STAR setting and may encode RDF-star triples to
+ // Formats without native RDF 1.2 support obey the ENCODE_TRIPLE_TERMS setting and may encode RDF 1.2 triples to
// IRIs
- encodeRDFStar = this instanceof TupleQueryResultWriter
+ encodeTripleTerms = this instanceof TupleQueryResultWriter
&& !((TupleQueryResultWriter) this).getTupleQueryResultFormat().supportsRDFStar()
- && getWriterConfig().get(BasicWriterSettings.ENCODE_RDF_STAR);
+ && getWriterConfig().get(BasicWriterSettings.ENCODE_TRIPLE_TERMS);
}
@Override
public void handleSolution(BindingSet bindingSet) throws TupleQueryResultHandlerException {
- if (encodeRDFStar) {
- handleSolutionImpl(new ValueMappingBindingSet(bindingSet, RDFStarUtil::toRDFEncodedValue));
+ if (encodeTripleTerms) {
+ handleSolutionImpl(new ValueMappingBindingSet(bindingSet, TripleTermUtil::toRDFEncodedValue));
} else {
handleSolutionImpl(bindingSet);
}
@@ -74,7 +74,7 @@ public void handleSolution(BindingSet bindingSet) throws TupleQueryResultHandler
/**
* Extending classes must implement this method instead of overriding {@link #handleSolution(BindingSet)} in order
- * to benefit from automatic handling of RDF-star encoding.
+ * to benefit from automatic handling of RDF 1.2 encoding.
*
* @param bindings the solution to handle
* @throws TupleQueryResultHandlerException
diff --git a/core/queryresultio/api/src/main/java/org/eclipse/rdf4j/query/resultio/RDFStarDecodingQueryResultHandler.java b/core/queryresultio/api/src/main/java/org/eclipse/rdf4j/query/resultio/TripleTermDecodingQueryResultHandler.java
similarity index 87%
rename from core/queryresultio/api/src/main/java/org/eclipse/rdf4j/query/resultio/RDFStarDecodingQueryResultHandler.java
rename to core/queryresultio/api/src/main/java/org/eclipse/rdf4j/query/resultio/TripleTermDecodingQueryResultHandler.java
index c3d1c10959d..a2e1f077391 100644
--- a/core/queryresultio/api/src/main/java/org/eclipse/rdf4j/query/resultio/RDFStarDecodingQueryResultHandler.java
+++ b/core/queryresultio/api/src/main/java/org/eclipse/rdf4j/query/resultio/TripleTermDecodingQueryResultHandler.java
@@ -18,7 +18,7 @@
import org.eclipse.rdf4j.query.QueryResultHandlerException;
import org.eclipse.rdf4j.query.TupleQueryResultHandler;
import org.eclipse.rdf4j.query.TupleQueryResultHandlerException;
-import org.eclipse.rdf4j.rio.helpers.RDFStarUtil;
+import org.eclipse.rdf4j.rio.helpers.TripleTermUtil;
/**
* A {@link QueryResultHandler} that delegates all results to another handler and processes RDF-star triples encoded as
@@ -26,10 +26,10 @@
*
* @author Pavel Mihaylov
*/
-class RDFStarDecodingQueryResultHandler implements TupleQueryResultHandler, BooleanQueryResultHandler {
+class TripleTermDecodingQueryResultHandler implements TupleQueryResultHandler, BooleanQueryResultHandler {
private final QueryResultHandler delegate;
- RDFStarDecodingQueryResultHandler(QueryResultHandler delegate) {
+ TripleTermDecodingQueryResultHandler(QueryResultHandler delegate) {
this.delegate = delegate;
}
@@ -55,6 +55,6 @@ public void endQueryResult() throws TupleQueryResultHandlerException {
@Override
public void handleSolution(BindingSet bindingSet) throws TupleQueryResultHandlerException {
- delegate.handleSolution(new ValueMappingBindingSet(bindingSet, RDFStarUtil::fromRDFEncodedValue));
+ delegate.handleSolution(new ValueMappingBindingSet(bindingSet, TripleTermUtil::fromRDFEncodedValue));
}
}
diff --git a/core/queryresultio/binary/pom.xml b/core/queryresultio/binary/pom.xml
index 34df6c0b64f..973051441c8 100644
--- a/core/queryresultio/binary/pom.xml
+++ b/core/queryresultio/binary/pom.xml
@@ -4,7 +4,7 @@
org.eclipse.rdf4j
rdf4j-queryresultio
- 5.1.0-SNAPSHOT
+ 6.0.0
rdf4j-queryresultio-binary
RDF4J: Query result IO - binary
diff --git a/core/queryresultio/pom.xml b/core/queryresultio/pom.xml
index c1ba95a8c53..c297b87b0c5 100644
--- a/core/queryresultio/pom.xml
+++ b/core/queryresultio/pom.xml
@@ -4,7 +4,7 @@
org.eclipse.rdf4j
rdf4j-core
- 5.1.0-SNAPSHOT
+ 6.0.0
rdf4j-queryresultio
pom
diff --git a/core/queryresultio/sparqljson/pom.xml b/core/queryresultio/sparqljson/pom.xml
index c5f589b6457..22f021982ef 100644
--- a/core/queryresultio/sparqljson/pom.xml
+++ b/core/queryresultio/sparqljson/pom.xml
@@ -4,7 +4,7 @@
org.eclipse.rdf4j
rdf4j-queryresultio
- 5.1.0-SNAPSHOT
+ 6.0.0
rdf4j-queryresultio-sparqljson
RDF4J: Query result IO - SPARQL/JSON
diff --git a/core/queryresultio/sparqljson/src/test/java/org/eclipse/rdf4j/query/resultio/sparqljson/SPARQLJSONTupleTest.java b/core/queryresultio/sparqljson/src/test/java/org/eclipse/rdf4j/query/resultio/sparqljson/SPARQLJSONTupleTest.java
index 050f0237250..d12747f389e 100644
--- a/core/queryresultio/sparqljson/src/test/java/org/eclipse/rdf4j/query/resultio/sparqljson/SPARQLJSONTupleTest.java
+++ b/core/queryresultio/sparqljson/src/test/java/org/eclipse/rdf4j/query/resultio/sparqljson/SPARQLJSONTupleTest.java
@@ -34,6 +34,7 @@
import org.eclipse.rdf4j.query.resultio.TupleQueryResultFormat;
import org.eclipse.rdf4j.query.resultio.helpers.QueryResultCollector;
import org.eclipse.rdf4j.testsuite.query.resultio.AbstractQueryResultIOTupleTest;
+import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.Test;
/**
@@ -291,6 +292,7 @@ public void testOtherKeys() throws Exception {
}
@Test
+ @Disabled("pending implementation of SPARQL 1.2 and adjusting RDFStar tests to RDF 1.2")
public void testRDFStar_extendedFormatRDF4J() throws Exception {
SPARQLResultsJSONParser parser = new SPARQLResultsJSONParser(SimpleValueFactory.getInstance());
QueryResultCollector handler = new QueryResultCollector();
@@ -309,6 +311,7 @@ public void testRDFStar_extendedFormatRDF4J() throws Exception {
}
@Test
+ @Disabled("pending implementation of SPARQL 1.2 and adjusting RDFStar tests to RDF 1.2")
public void testRDFStar_extendedFormatRDF4J_incompleteTriple() {
SPARQLResultsJSONParser parser = new SPARQLResultsJSONParser(SimpleValueFactory.getInstance());
QueryResultCollector handler = new QueryResultCollector();
@@ -322,6 +325,7 @@ public void testRDFStar_extendedFormatRDF4J_incompleteTriple() {
}
@Test
+ @Disabled("pending implementation of SPARQL 1.2 and adjusting RDFStar tests to RDF 1.2")
public void testRDFStar_extendedFormatRDF4J_doubleSubject() {
SPARQLResultsJSONParser parser = new SPARQLResultsJSONParser(SimpleValueFactory.getInstance());
QueryResultCollector handler = new QueryResultCollector();
@@ -335,6 +339,7 @@ public void testRDFStar_extendedFormatRDF4J_doubleSubject() {
}
@Test
+ @Disabled("pending implementation of SPARQL 1.2 and adjusting RDFStar tests to RDF 1.2")
public void testRDFStar_extendedFormatStardog() throws Exception {
SPARQLResultsJSONParser parser = new SPARQLResultsJSONParser(SimpleValueFactory.getInstance());
QueryResultCollector handler = new QueryResultCollector();
@@ -353,6 +358,7 @@ public void testRDFStar_extendedFormatStardog() throws Exception {
}
@Test
+ @Disabled("pending implementation of SPARQL 1.2 and adjusting RDFStar tests to RDF 1.2")
public void testRDFStar_extendedFormatStardog_NamedGraph() throws Exception {
SPARQLResultsJSONParser parser = new SPARQLResultsJSONParser(SimpleValueFactory.getInstance());
QueryResultCollector handler = new QueryResultCollector();
@@ -372,6 +378,7 @@ public void testRDFStar_extendedFormatStardog_NamedGraph() throws Exception {
}
@Test
+ @Disabled("pending implementation of SPARQL 1.2 and adjusting RDFStar tests to RDF 1.2")
public void testRDFStar_extendedFormatJena() throws Exception {
SPARQLResultsJSONParser parser = new SPARQLResultsJSONParser(SimpleValueFactory.getInstance());
QueryResultCollector handler = new QueryResultCollector();
diff --git a/core/queryresultio/sparqljson/src/test/java/org/eclipse/rdf4j/query/resultio/sparqljson/SPARQLResultsJSONWriterTest.java b/core/queryresultio/sparqljson/src/test/java/org/eclipse/rdf4j/query/resultio/sparqljson/SPARQLResultsJSONWriterTest.java
index 8d5555127d9..7d0592a7c2a 100644
--- a/core/queryresultio/sparqljson/src/test/java/org/eclipse/rdf4j/query/resultio/sparqljson/SPARQLResultsJSONWriterTest.java
+++ b/core/queryresultio/sparqljson/src/test/java/org/eclipse/rdf4j/query/resultio/sparqljson/SPARQLResultsJSONWriterTest.java
@@ -34,7 +34,7 @@ protected RioSetting[] getExpectedSupportedSettings() {
return new RioSetting[] {
BasicWriterSettings.PRETTY_PRINT,
BasicWriterSettings.XSD_STRING_TO_PLAIN_LITERAL,
- BasicWriterSettings.ENCODE_RDF_STAR,
+ BasicWriterSettings.ENCODE_TRIPLE_TERMS,
BasicQueryWriterSettings.JSONP_CALLBACK
};
}
diff --git a/core/queryresultio/sparqljson/src/test/java/org/eclipse/rdf4j/query/resultio/sparqljson/SPARQLStarResultsJSONWriterTest.java b/core/queryresultio/sparqljson/src/test/java/org/eclipse/rdf4j/query/resultio/sparqljson/SPARQLStarResultsJSONWriterTest.java
index ec82419e01e..71b22b6893e 100644
--- a/core/queryresultio/sparqljson/src/test/java/org/eclipse/rdf4j/query/resultio/sparqljson/SPARQLStarResultsJSONWriterTest.java
+++ b/core/queryresultio/sparqljson/src/test/java/org/eclipse/rdf4j/query/resultio/sparqljson/SPARQLStarResultsJSONWriterTest.java
@@ -34,7 +34,7 @@ protected RioSetting[] getExpectedSupportedSettings() {
return new RioSetting[] {
BasicWriterSettings.PRETTY_PRINT,
BasicWriterSettings.XSD_STRING_TO_PLAIN_LITERAL,
- BasicWriterSettings.ENCODE_RDF_STAR,
+ BasicWriterSettings.ENCODE_TRIPLE_TERMS,
BasicQueryWriterSettings.JSONP_CALLBACK
};
}
diff --git a/core/queryresultio/sparqlxml/pom.xml b/core/queryresultio/sparqlxml/pom.xml
index 8d7bee2745b..764a510127f 100644
--- a/core/queryresultio/sparqlxml/pom.xml
+++ b/core/queryresultio/sparqlxml/pom.xml
@@ -4,7 +4,7 @@
org.eclipse.rdf4j
rdf4j-queryresultio
- 5.1.0-SNAPSHOT
+ 6.0.0
rdf4j-queryresultio-sparqlxml
RDF4J: Query result IO - SPARQL/XML
diff --git a/core/queryresultio/sparqlxml/src/main/java/org/eclipse/rdf4j/query/resultio/sparqlxml/AbstractSPARQLXMLWriter.java b/core/queryresultio/sparqlxml/src/main/java/org/eclipse/rdf4j/query/resultio/sparqlxml/AbstractSPARQLXMLWriter.java
index 20f17a74b57..b1e26014526 100644
--- a/core/queryresultio/sparqlxml/src/main/java/org/eclipse/rdf4j/query/resultio/sparqlxml/AbstractSPARQLXMLWriter.java
+++ b/core/queryresultio/sparqlxml/src/main/java/org/eclipse/rdf4j/query/resultio/sparqlxml/AbstractSPARQLXMLWriter.java
@@ -366,7 +366,7 @@ public final Collection> getSupportedSettings() {
result.add(BasicWriterSettings.PRETTY_PRINT);
result.add(BasicWriterSettings.XSD_STRING_TO_PLAIN_LITERAL);
- result.add(BasicWriterSettings.ENCODE_RDF_STAR);
+ result.add(BasicWriterSettings.ENCODE_TRIPLE_TERMS);
result.add(BasicQueryWriterSettings.ADD_SESAME_QNAME);
result.add(XMLWriterSettings.INCLUDE_XML_PI);
diff --git a/core/queryresultio/sparqlxml/src/test/java/org/eclipse/rdf4j/query/resultio/sparqlxml/SPARQLStarXMLTupleQueryResultWriterTest.java b/core/queryresultio/sparqlxml/src/test/java/org/eclipse/rdf4j/query/resultio/sparqlxml/SPARQLStarXMLTupleQueryResultWriterTest.java
index e9df638284a..d0a5abdc91d 100644
--- a/core/queryresultio/sparqlxml/src/test/java/org/eclipse/rdf4j/query/resultio/sparqlxml/SPARQLStarXMLTupleQueryResultWriterTest.java
+++ b/core/queryresultio/sparqlxml/src/test/java/org/eclipse/rdf4j/query/resultio/sparqlxml/SPARQLStarXMLTupleQueryResultWriterTest.java
@@ -39,7 +39,7 @@ protected RioSetting[] getExpectedSupportedSettings() {
BasicQueryWriterSettings.ADD_SESAME_QNAME,
BasicWriterSettings.PRETTY_PRINT,
BasicWriterSettings.XSD_STRING_TO_PLAIN_LITERAL,
- BasicWriterSettings.ENCODE_RDF_STAR,
+ BasicWriterSettings.ENCODE_TRIPLE_TERMS,
XMLWriterSettings.INCLUDE_XML_PI
};
}
diff --git a/core/queryresultio/sparqlxml/src/test/java/org/eclipse/rdf4j/query/resultio/sparqlxml/SPARQLXMLTupleQueryResultWriterTest.java b/core/queryresultio/sparqlxml/src/test/java/org/eclipse/rdf4j/query/resultio/sparqlxml/SPARQLXMLTupleQueryResultWriterTest.java
index 52a5e48faad..12552f5d5f9 100644
--- a/core/queryresultio/sparqlxml/src/test/java/org/eclipse/rdf4j/query/resultio/sparqlxml/SPARQLXMLTupleQueryResultWriterTest.java
+++ b/core/queryresultio/sparqlxml/src/test/java/org/eclipse/rdf4j/query/resultio/sparqlxml/SPARQLXMLTupleQueryResultWriterTest.java
@@ -39,7 +39,7 @@ protected RioSetting[] getExpectedSupportedSettings() {
BasicQueryWriterSettings.ADD_SESAME_QNAME,
BasicWriterSettings.PRETTY_PRINT,
BasicWriterSettings.XSD_STRING_TO_PLAIN_LITERAL,
- BasicWriterSettings.ENCODE_RDF_STAR,
+ BasicWriterSettings.ENCODE_TRIPLE_TERMS,
XMLWriterSettings.INCLUDE_XML_PI
};
}
diff --git a/core/queryresultio/text/pom.xml b/core/queryresultio/text/pom.xml
index e5f67e0b32e..ce9f0da2e9a 100644
--- a/core/queryresultio/text/pom.xml
+++ b/core/queryresultio/text/pom.xml
@@ -4,7 +4,7 @@
org.eclipse.rdf4j
rdf4j-queryresultio
- 5.1.0-SNAPSHOT
+ 6.0.0
rdf4j-queryresultio-text
RDF4J: Query result IO - plain text booleans
diff --git a/core/queryresultio/text/src/main/java/org/eclipse/rdf4j/query/resultio/text/tsv/SPARQLResultsTSVWriter.java b/core/queryresultio/text/src/main/java/org/eclipse/rdf4j/query/resultio/text/tsv/SPARQLResultsTSVWriter.java
index 3bcbfc74a1a..5991298f931 100644
--- a/core/queryresultio/text/src/main/java/org/eclipse/rdf4j/query/resultio/text/tsv/SPARQLResultsTSVWriter.java
+++ b/core/queryresultio/text/src/main/java/org/eclipse/rdf4j/query/resultio/text/tsv/SPARQLResultsTSVWriter.java
@@ -137,13 +137,13 @@ public final TupleQueryResultFormat getQueryResultFormat() {
protected void writeValue(Value val) throws IOException {
if (val instanceof Triple) {
- writer.write("<<");
+ writer.write("<<( ");
writeValue(((Triple) val).getSubject());
writer.write(' ');
writeValue(((Triple) val).getPredicate());
writer.write(' ');
writeValue(((Triple) val).getObject());
- writer.write(">>");
+ writer.write(" )>>");
} else if (val instanceof Resource) {
writeResource((Resource) val);
} else {
diff --git a/core/queryresultio/text/src/test/java/org/eclipse/rdf4j/query/resultio/text/csv/SPARQLCSVTupleBackgroundTest.java b/core/queryresultio/text/src/test/java/org/eclipse/rdf4j/query/resultio/text/csv/SPARQLCSVTupleBackgroundTest.java
index 3e43c729d38..5aed51ec4b5 100644
--- a/core/queryresultio/text/src/test/java/org/eclipse/rdf4j/query/resultio/text/csv/SPARQLCSVTupleBackgroundTest.java
+++ b/core/queryresultio/text/src/test/java/org/eclipse/rdf4j/query/resultio/text/csv/SPARQLCSVTupleBackgroundTest.java
@@ -99,7 +99,7 @@ public void testSingleVarResults() {
+ "\"\"\"\"\"double-quoted string\"\r\n" + "space at the end \r\n"
+ "space at the end \r\n" + "\"\"\"\"\"double-quoted string with no datatype\"\r\n"
+ "\"newline at the end \n\"(\r\n)?"
- + "urn:rdf4j:triple:PDw8dXJuOmE-IDxodHRwOi8vd3d3LnczLm9yZy8xOTk5LzAyLzIyLXJkZi1zeW50YXgtbnMjdHlwZT4gPHVybjpiPj4-(\r\n)?",
+ + "urn:rdf4j:triple:PDwoIDx1cm46YT4gPGh0dHA6Ly93d3cudzMub3JnLzE5OTkvMDIvMjItcmRmLXN5bnRheC1ucyN0eXBlPiA8dXJuOmI-ICk-Pg==(\r\n)?",
out.toString(StandardCharsets.UTF_8));
}
diff --git a/core/queryresultio/text/src/test/java/org/eclipse/rdf4j/query/resultio/text/csv/SPARQLCSVTupleQueryResultWriterTest.java b/core/queryresultio/text/src/test/java/org/eclipse/rdf4j/query/resultio/text/csv/SPARQLCSVTupleQueryResultWriterTest.java
index 5a9f3d2761f..ab4f8025e32 100644
--- a/core/queryresultio/text/src/test/java/org/eclipse/rdf4j/query/resultio/text/csv/SPARQLCSVTupleQueryResultWriterTest.java
+++ b/core/queryresultio/text/src/test/java/org/eclipse/rdf4j/query/resultio/text/csv/SPARQLCSVTupleQueryResultWriterTest.java
@@ -48,7 +48,7 @@ public void testRDFStarHandling_DeepNesting() {
@Override
protected RioSetting[] getExpectedSupportedSettings() {
return new RioSetting[] {
- BasicWriterSettings.ENCODE_RDF_STAR,
+ BasicWriterSettings.ENCODE_TRIPLE_TERMS,
BasicWriterSettings.XSD_STRING_TO_PLAIN_LITERAL
};
}
diff --git a/core/queryresultio/text/src/test/java/org/eclipse/rdf4j/query/resultio/text/csv/SPARQLCSVTupleTest.java b/core/queryresultio/text/src/test/java/org/eclipse/rdf4j/query/resultio/text/csv/SPARQLCSVTupleTest.java
index 2280c3800f1..fd08e12c259 100644
--- a/core/queryresultio/text/src/test/java/org/eclipse/rdf4j/query/resultio/text/csv/SPARQLCSVTupleTest.java
+++ b/core/queryresultio/text/src/test/java/org/eclipse/rdf4j/query/resultio/text/csv/SPARQLCSVTupleTest.java
@@ -99,7 +99,7 @@ public void testSingleVarResults() {
+ "\"\"\"\"\"double-quoted string\"\r\n" + "space at the end \r\n"
+ "space at the end \r\n" + "\"\"\"\"\"double-quoted string with no datatype\"\r\n"
+ "\"newline at the end \n\"(\r\n)?"
- + "urn:rdf4j:triple:PDw8dXJuOmE-IDxodHRwOi8vd3d3LnczLm9yZy8xOTk5LzAyLzIyLXJkZi1zeW50YXgtbnMjdHlwZT4gPHVybjpiPj4-(\r\n)?",
+ + "urn:rdf4j:triple:PDwoIDx1cm46YT4gPGh0dHA6Ly93d3cudzMub3JnLzE5OTkvMDIvMjItcmRmLXN5bnRheC1ucyN0eXBlPiA8dXJuOmI-ICk-Pg==(\r\n)?",
out.toString(StandardCharsets.UTF_8));
}
diff --git a/core/queryresultio/text/src/test/java/org/eclipse/rdf4j/query/resultio/text/tsv/SPARQLStarTSVTupleBackgroundTest.java b/core/queryresultio/text/src/test/java/org/eclipse/rdf4j/query/resultio/text/tsv/SPARQLStarTSVTupleBackgroundTest.java
index f36ae4986ce..278a625f6b6 100644
--- a/core/queryresultio/text/src/test/java/org/eclipse/rdf4j/query/resultio/text/tsv/SPARQLStarTSVTupleBackgroundTest.java
+++ b/core/queryresultio/text/src/test/java/org/eclipse/rdf4j/query/resultio/text/tsv/SPARQLStarTSVTupleBackgroundTest.java
@@ -1,50 +1,50 @@
-/*******************************************************************************
- * Copyright (c) 2020 Eclipse RDF4J contributors.
- *
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Distribution License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/org/documents/edl-v10.php.
- *
- * SPDX-License-Identifier: BSD-3-Clause
- *******************************************************************************/
-package org.eclipse.rdf4j.query.resultio.text.tsv;
-
-import java.io.IOException;
-import java.io.InputStream;
-
-import org.eclipse.rdf4j.query.TupleQueryResult;
-import org.eclipse.rdf4j.query.TupleQueryResultHandlerException;
-import org.eclipse.rdf4j.query.resultio.BooleanQueryResultFormat;
-import org.eclipse.rdf4j.query.resultio.QueryResultIO;
-import org.eclipse.rdf4j.query.resultio.QueryResultParseException;
-import org.eclipse.rdf4j.query.resultio.TupleQueryResultFormat;
-import org.eclipse.rdf4j.query.resultio.UnsupportedQueryResultFormatException;
-import org.eclipse.rdf4j.testsuite.query.resultio.AbstractQueryResultIOTupleTest;
-
-/**
- * @author Pavel Mihaylov
- */
-public class SPARQLStarTSVTupleBackgroundTest extends AbstractQueryResultIOTupleTest {
-
- @Override
- protected String getFileName() {
- return "test.tsvs";
- }
-
- @Override
- protected TupleQueryResultFormat getTupleFormat() {
- return TupleQueryResultFormat.TSV_STAR;
- }
-
- @Override
- protected BooleanQueryResultFormat getMatchingBooleanFormatOrNull() {
- return null;
- }
-
- @Override
- protected TupleQueryResult parseTupleInternal(TupleQueryResultFormat format, InputStream in) throws IOException,
- QueryResultParseException, TupleQueryResultHandlerException, UnsupportedQueryResultFormatException {
- return QueryResultIO.parseTupleBackground(in, format, null);
- }
-}
+///*******************************************************************************
+// * Copyright (c) 2020 Eclipse RDF4J contributors.
+// *
+// * All rights reserved. This program and the accompanying materials
+// * are made available under the terms of the Eclipse Distribution License v1.0
+// * which accompanies this distribution, and is available at
+// * http://www.eclipse.org/org/documents/edl-v10.php.
+// *
+// * SPDX-License-Identifier: BSD-3-Clause
+// *******************************************************************************/
+//package org.eclipse.rdf4j.query.resultio.text.tsv;
+//
+//import java.io.IOException;
+//import java.io.InputStream;
+//
+//import org.eclipse.rdf4j.query.TupleQueryResult;
+//import org.eclipse.rdf4j.query.TupleQueryResultHandlerException;
+//import org.eclipse.rdf4j.query.resultio.BooleanQueryResultFormat;
+//import org.eclipse.rdf4j.query.resultio.QueryResultIO;
+//import org.eclipse.rdf4j.query.resultio.QueryResultParseException;
+//import org.eclipse.rdf4j.query.resultio.TupleQueryResultFormat;
+//import org.eclipse.rdf4j.query.resultio.UnsupportedQueryResultFormatException;
+//import org.eclipse.rdf4j.testsuite.query.resultio.AbstractQueryResultIOTupleTest;
+//
+///**
+// * @author Pavel Mihaylov
+// */
+//public class SPARQLStarTSVTupleBackgroundTest extends AbstractQueryResultIOTupleTest {
+//
+// @Override
+// protected String getFileName() {
+// return "test.tsvs";
+// }
+//
+// @Override
+// protected TupleQueryResultFormat getTupleFormat() {
+// return TupleQueryResultFormat.TSV_STAR;
+// }
+//
+// @Override
+// protected BooleanQueryResultFormat getMatchingBooleanFormatOrNull() {
+// return null;
+// }
+//
+// @Override
+// protected TupleQueryResult parseTupleInternal(TupleQueryResultFormat format, InputStream in) throws IOException,
+// QueryResultParseException, TupleQueryResultHandlerException, UnsupportedQueryResultFormatException {
+// return QueryResultIO.parseTupleBackground(in, format, null);
+// }
+//}
diff --git a/core/queryresultio/text/src/test/java/org/eclipse/rdf4j/query/resultio/text/tsv/SPARQLStarTSVTupleQueryResultWriterTest.java b/core/queryresultio/text/src/test/java/org/eclipse/rdf4j/query/resultio/text/tsv/SPARQLStarTSVTupleQueryResultWriterTest.java
index c55edb55774..4a441b7885a 100644
--- a/core/queryresultio/text/src/test/java/org/eclipse/rdf4j/query/resultio/text/tsv/SPARQLStarTSVTupleQueryResultWriterTest.java
+++ b/core/queryresultio/text/src/test/java/org/eclipse/rdf4j/query/resultio/text/tsv/SPARQLStarTSVTupleQueryResultWriterTest.java
@@ -15,6 +15,7 @@
import org.eclipse.rdf4j.rio.RioSetting;
import org.eclipse.rdf4j.rio.helpers.BasicWriterSettings;
import org.eclipse.rdf4j.testsuite.query.resultio.AbstractTupleQueryResultWriterTest;
+import org.junit.jupiter.api.Disabled;
/**
* @author Jeen Broekstra
@@ -34,7 +35,7 @@ protected TupleQueryResultWriterFactory getWriterFactory() {
@Override
protected RioSetting[] getExpectedSupportedSettings() {
return new RioSetting[] {
- BasicWriterSettings.ENCODE_RDF_STAR,
+ BasicWriterSettings.ENCODE_TRIPLE_TERMS,
BasicWriterSettings.XSD_STRING_TO_PLAIN_LITERAL
};
}
diff --git a/core/queryresultio/text/src/test/java/org/eclipse/rdf4j/query/resultio/text/tsv/SPARQLTSVTupleBackgroundTest.java b/core/queryresultio/text/src/test/java/org/eclipse/rdf4j/query/resultio/text/tsv/SPARQLTSVTupleBackgroundTest.java
index 858ce74271b..9b8de46d8ad 100644
--- a/core/queryresultio/text/src/test/java/org/eclipse/rdf4j/query/resultio/text/tsv/SPARQLTSVTupleBackgroundTest.java
+++ b/core/queryresultio/text/src/test/java/org/eclipse/rdf4j/query/resultio/text/tsv/SPARQLTSVTupleBackgroundTest.java
@@ -81,7 +81,7 @@ public void testSingleVarResults() {
+ "\"?space at the end (\"(\\^\\^)?)?\n"
+ "\"\\\\\"\\\\\"double-quoted string with no datatype\"(\\^\\^)?\n"
+ "\"newline at the end \\\\n\"(\\^\\^)?\n?"
- + "\n?",
+ + "\n?",
toString(createTupleSingleVarMultipleBindingSets()));
}
diff --git a/core/queryresultio/text/src/test/java/org/eclipse/rdf4j/query/resultio/text/tsv/SPARQLTSVTupleQueryResultWriterTest.java b/core/queryresultio/text/src/test/java/org/eclipse/rdf4j/query/resultio/text/tsv/SPARQLTSVTupleQueryResultWriterTest.java
index 4a33c527bc9..fbd88bd76be 100644
--- a/core/queryresultio/text/src/test/java/org/eclipse/rdf4j/query/resultio/text/tsv/SPARQLTSVTupleQueryResultWriterTest.java
+++ b/core/queryresultio/text/src/test/java/org/eclipse/rdf4j/query/resultio/text/tsv/SPARQLTSVTupleQueryResultWriterTest.java
@@ -34,7 +34,7 @@ protected TupleQueryResultWriterFactory getWriterFactory() {
@Override
protected RioSetting[] getExpectedSupportedSettings() {
return new RioSetting[] {
- BasicWriterSettings.ENCODE_RDF_STAR,
+ BasicWriterSettings.ENCODE_TRIPLE_TERMS,
BasicWriterSettings.XSD_STRING_TO_PLAIN_LITERAL
};
}
diff --git a/core/queryresultio/text/src/test/java/org/eclipse/rdf4j/query/resultio/text/tsv/SPARQLTSVTupleTest.java b/core/queryresultio/text/src/test/java/org/eclipse/rdf4j/query/resultio/text/tsv/SPARQLTSVTupleTest.java
index 90b74ceef1a..6655eff191c 100644
--- a/core/queryresultio/text/src/test/java/org/eclipse/rdf4j/query/resultio/text/tsv/SPARQLTSVTupleTest.java
+++ b/core/queryresultio/text/src/test/java/org/eclipse/rdf4j/query/resultio/text/tsv/SPARQLTSVTupleTest.java
@@ -71,7 +71,7 @@ public void testSingleVarResults() {
+ "\"?space at the end (\"(\\^\\^)?)?\n"
+ "\"\\\\\"\\\\\"double-quoted string with no datatype\"(\\^\\^)?\n"
+ "\"newline at the end \\\\n\"(\\^\\^)?\n?"
- + "\n?",
+ + "\n?",
toString(createTupleSingleVarMultipleBindingSets()));
}
diff --git a/core/repository/api/pom.xml b/core/repository/api/pom.xml
index 48fdeecfad7..2bcbbd59395 100644
--- a/core/repository/api/pom.xml
+++ b/core/repository/api/pom.xml
@@ -4,7 +4,7 @@
org.eclipse.rdf4j
rdf4j-repository
- 5.1.0-SNAPSHOT
+ 6.0.0
rdf4j-repository-api
RDF4J: Repository - API
diff --git a/core/repository/contextaware/pom.xml b/core/repository/contextaware/pom.xml
index 39bcbf0668c..6b579fce3e2 100644
--- a/core/repository/contextaware/pom.xml
+++ b/core/repository/contextaware/pom.xml
@@ -4,7 +4,7 @@
org.eclipse.rdf4j
rdf4j-repository
- 5.1.0-SNAPSHOT
+ 6.0.0
rdf4j-repository-contextaware
RDF4J: Repository - context aware (wrapper)
diff --git a/core/repository/dataset/pom.xml b/core/repository/dataset/pom.xml
index c843dccda42..434a6c7f8d9 100644
--- a/core/repository/dataset/pom.xml
+++ b/core/repository/dataset/pom.xml
@@ -4,7 +4,7 @@
org.eclipse.rdf4j
rdf4j-repository
- 5.1.0-SNAPSHOT
+ 6.0.0
rdf4j-repository-dataset
RDF4J: DatasetRepository (wrapper)
diff --git a/core/repository/event/pom.xml b/core/repository/event/pom.xml
index 3a3109cf967..baa24c1b0d6 100644
--- a/core/repository/event/pom.xml
+++ b/core/repository/event/pom.xml
@@ -4,7 +4,7 @@
org.eclipse.rdf4j
rdf4j-repository
- 5.1.0-SNAPSHOT
+ 6.0.0
rdf4j-repository-event
RDF4J: Repository - event (wrapper)
diff --git a/core/repository/http/pom.xml b/core/repository/http/pom.xml
index 4fc07dc06e9..5c47e620b5b 100644
--- a/core/repository/http/pom.xml
+++ b/core/repository/http/pom.xml
@@ -4,7 +4,7 @@
org.eclipse.rdf4j
rdf4j-repository
- 5.1.0-SNAPSHOT
+ 6.0.0
rdf4j-repository-http
RDF4J: HTTPRepository
diff --git a/core/repository/http/src/main/java/org/eclipse/rdf4j/repository/http/HTTPRepositoryConnection.java b/core/repository/http/src/main/java/org/eclipse/rdf4j/repository/http/HTTPRepositoryConnection.java
index ceccfdeaaeb..a06e1460508 100644
--- a/core/repository/http/src/main/java/org/eclipse/rdf4j/repository/http/HTTPRepositoryConnection.java
+++ b/core/repository/http/src/main/java/org/eclipse/rdf4j/repository/http/HTTPRepositoryConnection.java
@@ -462,7 +462,7 @@ private RDFFormat getBackwardCompatibleFormat(RDFFormat format) {
// default MIME-type.
return new RDFFormat(NTRIPLES.getName(), List.of("text/plain"), NTRIPLES.getCharset(),
NTRIPLES.getFileExtensions(), NTRIPLES.supportsNamespaces(), NTRIPLES.supportsContexts(),
- NTRIPLES.supportsRDFStar());
+ NTRIPLES.supportsTripleTerms());
}
return format;
diff --git a/core/repository/manager/pom.xml b/core/repository/manager/pom.xml
index bad53d7101e..e08dbc4005a 100644
--- a/core/repository/manager/pom.xml
+++ b/core/repository/manager/pom.xml
@@ -4,7 +4,7 @@
org.eclipse.rdf4j
rdf4j-repository
- 5.1.0-SNAPSHOT
+ 6.0.0
rdf4j-repository-manager
RDF4J: Repository manager
diff --git a/core/repository/pom.xml b/core/repository/pom.xml
index 873757a9580..1681b340b3e 100644
--- a/core/repository/pom.xml
+++ b/core/repository/pom.xml
@@ -4,7 +4,7 @@
org.eclipse.rdf4j
rdf4j-core
- 5.1.0-SNAPSHOT
+ 6.0.0
rdf4j-repository
pom
diff --git a/core/repository/sail/pom.xml b/core/repository/sail/pom.xml
index fb8fc483b2b..e951b9095b5 100644
--- a/core/repository/sail/pom.xml
+++ b/core/repository/sail/pom.xml
@@ -4,7 +4,7 @@
org.eclipse.rdf4j
rdf4j-repository
- 5.1.0-SNAPSHOT
+ 6.0.0
rdf4j-repository-sail
RDF4J: SailRepository
diff --git a/core/repository/sparql/pom.xml b/core/repository/sparql/pom.xml
index 66d5ee263ce..0fd771c98f7 100644
--- a/core/repository/sparql/pom.xml
+++ b/core/repository/sparql/pom.xml
@@ -4,7 +4,7 @@
org.eclipse.rdf4j
rdf4j-repository
- 5.1.0-SNAPSHOT
+ 6.0.0
rdf4j-repository-sparql
RDF4J: SPARQL Repository
diff --git a/core/rio/api/pom.xml b/core/rio/api/pom.xml
index 3733b074423..f63d2ed8920 100644
--- a/core/rio/api/pom.xml
+++ b/core/rio/api/pom.xml
@@ -4,7 +4,7 @@
org.eclipse.rdf4j
rdf4j-rio
- 5.1.0-SNAPSHOT
+ 6.0.0
rdf4j-rio-api
RDF4J: Rio - API
diff --git a/core/rio/api/src/main/java/org/eclipse/rdf4j/rio/LanguageHandler.java b/core/rio/api/src/main/java/org/eclipse/rdf4j/rio/LanguageHandler.java
index 935e87ebbb4..40bbb1cf7df 100644
--- a/core/rio/api/src/main/java/org/eclipse/rdf4j/rio/LanguageHandler.java
+++ b/core/rio/api/src/main/java/org/eclipse/rdf4j/rio/LanguageHandler.java
@@ -86,6 +86,28 @@ public interface LanguageHandler {
Literal normalizeLanguage(String literalValue, String languageTag, ValueFactory valueFactory)
throws LiteralUtilException;
+ /**
+ * Normalize both the language tag and the language if appropriate, and use the given value factory to generate a
+ * literal matching the literal value and language tag.
+ *
+ * This method must only be called after verifying that {@link #isRecognizedLanguage(String)} returns true for the
+ * given language tag, and {@link #verifyLanguage(String, String)} also returns true for the given language and
+ * literal value.
+ *
+ * @param literalValue Required literal value to use in the normalization process and to provide the value for the
+ * resulting literal.
+ * @param languageTag The language tag which is to be normalized. This tag is available in normalized form from the
+ * result using {@link Literal#getLanguage()}.
+ * @param baseDir
+ * @param valueFactory The {@link ValueFactory} to use to create the result literal.
+ * @return A {@link Literal} containing the normalized literal value and language tag.
+ * @throws LiteralUtilException If the language tag was not recognized or verified, or the literal value could not
+ * be normalized due to an error.
+ */
+ Literal normalizeLanguage(String literalValue, String languageTag, Literal.BaseDirection baseDir,
+ ValueFactory valueFactory)
+ throws LiteralUtilException;
+
/**
* A unique key for this language handler to identify it in the LanguageHandlerRegistry.
*
diff --git a/core/rio/api/src/main/java/org/eclipse/rdf4j/rio/RDFFormat.java b/core/rio/api/src/main/java/org/eclipse/rdf4j/rio/RDFFormat.java
index 1bb56957b9d..28fa48334d4 100644
--- a/core/rio/api/src/main/java/org/eclipse/rdf4j/rio/RDFFormat.java
+++ b/core/rio/api/src/main/java/org/eclipse/rdf4j/rio/RDFFormat.java
@@ -59,14 +59,14 @@ public class RDFFormat extends FileFormat {
public static final boolean NO_CONTEXTS = false;
/**
- * Indicates that RDF-star triples can be serialized natively for this format.
+ * Indicates that triple terms can be serialized natively for this format.
*/
- public static final boolean SUPPORTS_RDF_STAR = true;
+ public static final boolean SUPPORTS_TRIPLE_TERMS = true;
/**
- * Indicates that RDF-star triples will NOT be serialized natively for this format.
+ * Indicates that triple terms will NOT be serialized natively for this format.
*/
- public static final boolean NO_RDF_STAR = false;
+ public static final boolean NO_TRIPLE_TERMS = false;
/**
* The RDF/XML file format.
@@ -83,7 +83,8 @@ public class RDFFormat extends FileFormat {
Arrays.asList("application/rdf+xml", "application/xml", "text/xml"), StandardCharsets.UTF_8,
Arrays.asList("rdf", "rdfs", "owl", "xml"),
SimpleValueFactory.getInstance().createIRI("http://www.w3.org/ns/formats/RDF_XML"), SUPPORTS_NAMESPACES,
- NO_CONTEXTS, NO_RDF_STAR);
+ NO_CONTEXTS, NO_TRIPLE_TERMS
+ );
/**
* The N-Triples file format.
@@ -97,7 +98,8 @@ public class RDFFormat extends FileFormat {
public static final RDFFormat NTRIPLES = new RDFFormat("N-Triples",
Arrays.asList("application/n-triples", "text/plain"), StandardCharsets.UTF_8, List.of("nt"),
SimpleValueFactory.getInstance().createIRI("http://www.w3.org/ns/formats/N-Triples"), NO_NAMESPACES,
- NO_CONTEXTS, NO_RDF_STAR);
+ NO_CONTEXTS, SUPPORTS_TRIPLE_TERMS
+ );
/**
* The Turtle file format.
@@ -111,22 +113,8 @@ public class RDFFormat extends FileFormat {
public static final RDFFormat TURTLE = new RDFFormat("Turtle", Arrays.asList("text/turtle", "application/x-turtle"),
StandardCharsets.UTF_8, List.of("ttl"),
SimpleValueFactory.getInstance().createIRI("http://www.w3.org/ns/formats/Turtle"), SUPPORTS_NAMESPACES,
- NO_CONTEXTS, NO_RDF_STAR);
-
- /**
- * The Turtle-star file format, a Turtle-based RDF serialization format that supports RDF-star triples.
- *
- * The file extension .ttls is recommended for Turtle-star documents. The media type is
- * application/x-turtlestar and the encoding is UTF-8.
- *
- *
- * @see Foundations of an Alternative Approach to Reification in
- * RDF
- * @see RDF-star and SPARQL-star Draft Community Group Report
- */
- public static final RDFFormat TURTLESTAR = new RDFFormat("Turtle-star",
- Arrays.asList("text/x-turtlestar", "application/x-turtlestar"), StandardCharsets.UTF_8,
- List.of("ttls"), SUPPORTS_NAMESPACES, NO_CONTEXTS, SUPPORTS_RDF_STAR);
+ NO_CONTEXTS, SUPPORTS_TRIPLE_TERMS
+ );
/**
* The N3/Notation3 file format.
@@ -140,7 +128,8 @@ public class RDFFormat extends FileFormat {
public static final RDFFormat N3 = new RDFFormat("N3", Arrays.asList("text/n3", "text/rdf+n3"),
StandardCharsets.UTF_8, List.of("n3"),
SimpleValueFactory.getInstance().createIRI("http://www.w3.org/ns/formats/N3"), SUPPORTS_NAMESPACES,
- NO_CONTEXTS, NO_RDF_STAR);
+ NO_CONTEXTS, NO_TRIPLE_TERMS
+ );
/**
* The TriX file format, an XML-based RDF serialization format that
@@ -154,7 +143,8 @@ public class RDFFormat extends FileFormat {
*/
public static final RDFFormat TRIX = new RDFFormat("TriX", List.of("application/trix"),
StandardCharsets.UTF_8, Arrays.asList("xml", "trix"), null, SUPPORTS_NAMESPACES, SUPPORTS_CONTEXTS,
- NO_RDF_STAR);
+ NO_TRIPLE_TERMS
+ );
/**
* The TriG file format, a Turtle-based RDF serialization format that
@@ -169,22 +159,8 @@ public class RDFFormat extends FileFormat {
public static final RDFFormat TRIG = new RDFFormat("TriG", Arrays.asList("application/trig", "application/x-trig"),
StandardCharsets.UTF_8, List.of("trig"),
SimpleValueFactory.getInstance().createIRI("http://www.w3.org/ns/formats/TriG"), SUPPORTS_NAMESPACES,
- SUPPORTS_CONTEXTS, NO_RDF_STAR);
-
- /**
- * The TriG-star file format, a TriG-based RDF serialization format that supports RDF-star triples. This builds upon
- * the idea for the Turtle-star format but adds support for named graphs.
- *
- * The file extension .trigs is recommended for TriG-star documents. The media type is
- * application/x-trigstar and the encoding is UTF-8.
- *
- *
- * @see Foundations of an Alternative Approach to Reification in
- * RDF
- * @see RDF-star and SPARQL-star Draft Community Group Report
- */
- public static final RDFFormat TRIGSTAR = new RDFFormat("TriG-star", "application/x-trigstar",
- StandardCharsets.UTF_8, "trigs", SUPPORTS_NAMESPACES, SUPPORTS_CONTEXTS, SUPPORTS_RDF_STAR);
+ SUPPORTS_CONTEXTS, SUPPORTS_TRIPLE_TERMS
+ );
/**
* A binary RDF format.
@@ -196,7 +172,7 @@ public class RDFFormat extends FileFormat {
* @see Binary RDF in Sesame
*/
public static final RDFFormat BINARY = new RDFFormat("BinaryRDF", List.of("application/x-binary-rdf"), null,
- List.of("brf"), null, SUPPORTS_NAMESPACES, SUPPORTS_CONTEXTS, SUPPORTS_RDF_STAR);
+ List.of("brf"), null, SUPPORTS_NAMESPACES, SUPPORTS_CONTEXTS, NO_TRIPLE_TERMS);
/**
* The N-Quads file format, an RDF serialization format that supports
@@ -211,7 +187,8 @@ public class RDFFormat extends FileFormat {
public static final RDFFormat NQUADS = new RDFFormat("N-Quads",
Arrays.asList("application/n-quads", "text/x-nquads", "text/nquads"), StandardCharsets.UTF_8,
List.of("nq"), SimpleValueFactory.getInstance().createIRI("http://www.w3.org/ns/formats/N-Quads"),
- NO_NAMESPACES, SUPPORTS_CONTEXTS, NO_RDF_STAR);
+ NO_NAMESPACES, SUPPORTS_CONTEXTS, SUPPORTS_TRIPLE_TERMS
+ );
/**
* The JSON-LD file format, an RDF serialization format that supports
@@ -226,7 +203,8 @@ public class RDFFormat extends FileFormat {
public static final RDFFormat JSONLD = new RDFFormat("JSON-LD", List.of("application/ld+json"),
StandardCharsets.UTF_8, List.of("jsonld"),
SimpleValueFactory.getInstance().createIRI("http://www.w3.org/ns/formats/JSON-LD"), SUPPORTS_NAMESPACES,
- SUPPORTS_CONTEXTS, NO_RDF_STAR);
+ SUPPORTS_CONTEXTS, NO_TRIPLE_TERMS
+ );
/**
* The NDJSON-LD is a Newline Delimited JSON-LD format.
@@ -237,7 +215,8 @@ public class RDFFormat extends FileFormat {
*/
public static final RDFFormat NDJSONLD = new RDFFormat("NDJSON-LD", List.of("application/x-ld+ndjson"),
StandardCharsets.UTF_8, Arrays.asList("ndjsonld", "jsonl", "ndjson"), null, SUPPORTS_NAMESPACES,
- SUPPORTS_CONTEXTS, NO_RDF_STAR);
+ SUPPORTS_CONTEXTS, NO_TRIPLE_TERMS
+ );
/**
* The RDF/JSON file format, an RDF serialization format that supports
@@ -252,7 +231,8 @@ public class RDFFormat extends FileFormat {
public static final RDFFormat RDFJSON = new RDFFormat("RDF/JSON", List.of("application/rdf+json"),
StandardCharsets.UTF_8, List.of("rj"),
SimpleValueFactory.getInstance().createIRI("http://www.w3.org/ns/formats/RDF_JSON"), NO_NAMESPACES,
- SUPPORTS_CONTEXTS, NO_RDF_STAR);
+ SUPPORTS_CONTEXTS, NO_TRIPLE_TERMS
+ );
/**
* The RDFa file format, an RDF serialization format.
@@ -267,7 +247,8 @@ public class RDFFormat extends FileFormat {
Arrays.asList("application/xhtml+xml", "application/html", "text/html"), StandardCharsets.UTF_8,
Arrays.asList("xhtml", "html"),
SimpleValueFactory.getInstance().createIRI("http://www.w3.org/ns/formats/RDFa"), SUPPORTS_NAMESPACES,
- NO_CONTEXTS, NO_RDF_STAR);
+ NO_CONTEXTS, NO_TRIPLE_TERMS
+ );
/**
* The HDT file format, an RDF serialization format.
@@ -279,7 +260,8 @@ public class RDFFormat extends FileFormat {
*/
public static final RDFFormat HDT = new RDFFormat("HDT",
List.of("application/vnd.hdt"), null, List.of("hdt"), null,
- SUPPORTS_NAMESPACES, NO_CONTEXTS, NO_RDF_STAR);
+ SUPPORTS_NAMESPACES, NO_CONTEXTS, NO_TRIPLE_TERMS
+ );
/*----------------*
* Static methods *
@@ -358,9 +340,9 @@ public static List getAcceptParams(Iterable rdfFormats, boole
private final boolean supportsContexts;
/**
- * Flag indicating whether the RDFFormat can encode RDF-star triples natively.
+ * Flag indicating whether the RDFFormat can encode triples natively.
*/
- private final boolean supportsRDFStar;
+ private final boolean supportsTripleTerms;
/**
* A standard URI published by the W3C or another standards body to uniquely denote this format.
@@ -392,30 +374,30 @@ public static List getAcceptParams(Iterable rdfFormats, boole
@Deprecated(since = "3.2.0")
public RDFFormat(String name, String mimeType, Charset charset, String fileExtension, boolean supportsNamespaces,
boolean supportsContexts) {
- this(name, mimeType, charset, fileExtension, supportsNamespaces, supportsContexts, NO_RDF_STAR);
+ this(name, mimeType, charset, fileExtension, supportsNamespaces, supportsContexts, NO_TRIPLE_TERMS);
}
/**
* Creates a new RDFFormat object.
*
- * @param name The name of the RDF file format, e.g. "RDF/XML".
- * @param mimeType The MIME type of the RDF file format, e.g. application/rdf+xml for the
- * RDF/XML file format.
- * @param charset The default character encoding of the RDF file format. Specify null if not
- * applicable.
- * @param fileExtension The (default) file extension for the RDF file format, e.g. rdf for RDF/XML
- * files.
- * @param supportsNamespaces True if the RDFFormat supports the encoding of namespace/prefix information
- * and false otherwise.
- * @param supportsContexts True if the RDFFormat supports the encoding of contexts/named graphs and
- * false otherwise.
- * @param supportsRDFStar True if the RDFFormat supports the encoding of RDF-star triples natively and
- * false otherwise.
+ * @param name The name of the RDF file format, e.g. "RDF/XML".
+ * @param mimeType The MIME type of the RDF file format, e.g. application/rdf+xml for the
+ * RDF/XML file format.
+ * @param charset The default character encoding of the RDF file format. Specify null if not
+ * applicable.
+ * @param fileExtension The (default) file extension for the RDF file format, e.g. rdf for RDF/XML
+ * files.
+ * @param supportsNamespaces True if the RDFFormat supports the encoding of namespace/prefix information
+ * and false otherwise.
+ * @param supportsContexts True if the RDFFormat supports the encoding of contexts/named graphs and
+ * false otherwise.
+ * @param supportsTripleTerms True if the RDFFormat supports the encoding of triple terms natively and
+ * false otherwise.
*/
public RDFFormat(String name, String mimeType, Charset charset, String fileExtension, boolean supportsNamespaces,
- boolean supportsContexts, boolean supportsRDFStar) {
+ boolean supportsContexts, boolean supportsTripleTerms) {
this(name, List.of(mimeType), charset, List.of(fileExtension), supportsNamespaces,
- supportsContexts, supportsRDFStar);
+ supportsContexts, supportsTripleTerms);
}
/**
@@ -437,30 +419,30 @@ public RDFFormat(String name, String mimeType, Charset charset, String fileExten
@Deprecated(since = "3.2.0")
public RDFFormat(String name, String mimeType, Charset charset, Collection fileExtensions,
boolean supportsNamespaces, boolean supportsContexts) {
- this(name, mimeType, charset, fileExtensions, supportsNamespaces, supportsContexts, NO_RDF_STAR);
+ this(name, mimeType, charset, fileExtensions, supportsNamespaces, supportsContexts, NO_TRIPLE_TERMS);
}
/**
* Creates a new RDFFormat object.
*
- * @param name The name of the RDF file format, e.g. "RDF/XML".
- * @param mimeType The MIME type of the RDF file format, e.g. application/rdf+xml for the
- * RDF/XML file format.
- * @param charset The default character encoding of the RDF file format. Specify null if not
- * applicable.
- * @param fileExtensions The RDF format's file extensions, e.g. rdf for RDF/XML files. The first item
- * in the list is interpreted as the default file extension for the format.
- * @param supportsNamespaces True if the RDFFormat supports the encoding of namespace/prefix information
- * and false otherwise.
- * @param supportsContexts True if the RDFFormat supports the encoding of contexts/named graphs and
- * false otherwise.
- * @param supportsRDFStar True if the RDFFormat supports the encoding of RDF-star triples natively and
- * false otherwise.
+ * @param name The name of the RDF file format, e.g. "RDF/XML".
+ * @param mimeType The MIME type of the RDF file format, e.g. application/rdf+xml for the
+ * RDF/XML file format.
+ * @param charset The default character encoding of the RDF file format. Specify null if not
+ * applicable.
+ * @param fileExtensions The RDF format's file extensions, e.g. rdf for RDF/XML files. The first
+ * item in the list is interpreted as the default file extension for the format.
+ * @param supportsNamespaces True if the RDFFormat supports the encoding of namespace/prefix information
+ * and false otherwise.
+ * @param supportsContexts True if the RDFFormat supports the encoding of contexts/named graphs and
+ * false otherwise.
+ * @param supportsTripleTerms True if the RDFFormat supports the encoding of triple terms natively and
+ * false otherwise.
*/
public RDFFormat(String name, String mimeType, Charset charset, Collection fileExtensions,
- boolean supportsNamespaces, boolean supportsContexts, boolean supportsRDFStar) {
+ boolean supportsNamespaces, boolean supportsContexts, boolean supportsTripleTerms) {
this(name, List.of(mimeType), charset, fileExtensions, supportsNamespaces, supportsContexts,
- supportsRDFStar);
+ supportsTripleTerms);
}
/**
@@ -483,31 +465,31 @@ public RDFFormat(String name, String mimeType, Charset charset, Collection mimeTypes, Charset charset, Collection fileExtensions,
boolean supportsNamespaces, boolean supportsContexts) {
- this(name, mimeTypes, charset, fileExtensions, null, supportsNamespaces, supportsContexts, NO_RDF_STAR);
+ this(name, mimeTypes, charset, fileExtensions, null, supportsNamespaces, supportsContexts, NO_TRIPLE_TERMS);
}
/**
* Creates a new RDFFormat object.
*
- * @param name The name of the RDF file format, e.g. "RDF/XML".
- * @param mimeTypes The MIME types of the RDF file format, e.g. application/rdf+xml for the
- * RDF/XML file format. The first item in the list is interpreted as the default MIME type
- * for the format.
- * @param charset The default character encoding of the RDF file format. Specify null if not
- * applicable.
- * @param fileExtensions The RDF format's file extensions, e.g. rdf for RDF/XML files. The first item
- * in the list is interpreted as the default file extension for the format.
- * @param supportsNamespaces True if the RDFFormat supports the encoding of namespace/prefix information
- * and false otherwise.
- * @param supportsContexts True if the RDFFormat supports the encoding of contexts/named graphs and
- * false otherwise.
- * @param supportsRDFStar True if the RDFFormat supports the encoding of RDF-star triples natively and
- * false otherwise.
+ * @param name The name of the RDF file format, e.g. "RDF/XML".
+ * @param mimeTypes The MIME types of the RDF file format, e.g. application/rdf+xml for the
+ * RDF/XML file format. The first item in the list is interpreted as the default MIME
+ * type for the format.
+ * @param charset The default character encoding of the RDF file format. Specify null if not
+ * applicable.
+ * @param fileExtensions The RDF format's file extensions, e.g. rdf for RDF/XML files. The first
+ * item in the list is interpreted as the default file extension for the format.
+ * @param supportsNamespaces True if the RDFFormat supports the encoding of namespace/prefix information
+ * and false otherwise.
+ * @param supportsContexts True if the RDFFormat supports the encoding of contexts/named graphs and
+ * false otherwise.
+ * @param supportsTripleTerms True if the RDFFormat supports the encoding of triple terms natively and
+ * false otherwise.
*/
public RDFFormat(String name, Collection mimeTypes, Charset charset, Collection fileExtensions,
- boolean supportsNamespaces, boolean supportsContexts, boolean supportsRDFStar) {
+ boolean supportsNamespaces, boolean supportsContexts, boolean supportsTripleTerms) {
this(name, mimeTypes, charset, fileExtensions, null, supportsNamespaces, supportsContexts,
- supportsRDFStar);
+ supportsTripleTerms);
}
/**
@@ -532,37 +514,39 @@ public RDFFormat(String name, Collection mimeTypes, Charset charset, Col
@Deprecated(since = "3.2.0")
public RDFFormat(String name, Collection mimeTypes, Charset charset, Collection fileExtensions,
IRI standardURI, boolean supportsNamespaces, boolean supportsContexts) {
- this(name, mimeTypes, charset, fileExtensions, standardURI, supportsNamespaces, supportsContexts, NO_RDF_STAR);
+ this(name, mimeTypes, charset, fileExtensions, standardURI, supportsNamespaces, supportsContexts,
+ NO_TRIPLE_TERMS
+ );
}
/**
* Creates a new RDFFormat object.
*
- * @param name The name of the RDF file format, e.g. "RDF/XML".
- * @param mimeTypes The MIME types of the RDF file format, e.g. application/rdf+xml for the
- * RDF/XML file format. The first item in the list is interpreted as the default MIME type
- * for the format.
- * @param charset The default character encoding of the RDF file format. Specify null if not
- * applicable.
- * @param fileExtensions The RDF format's file extensions, e.g. rdf for RDF/XML files. The first item
- * in the list is interpreted as the default file extension for the format.
- * @param standardURI The standard URI that has been assigned to this format by a standards organisation or
- * null if it does not currently have a standard URI.
- * @param supportsNamespaces True if the RDFFormat supports the encoding of namespace/prefix information
- * and false otherwise.
- * @param supportsContexts True if the RDFFormat supports the encoding of contexts/named graphs and
- * false otherwise.
- * @param supportsRDFStar True if the RDFFormat supports the encoding of RDF-star triples natively and
- * false otherwise.
+ * @param name The name of the RDF file format, e.g. "RDF/XML".
+ * @param mimeTypes The MIME types of the RDF file format, e.g. application/rdf+xml for the
+ * RDF/XML file format. The first item in the list is interpreted as the default MIME
+ * type for the format.
+ * @param charset The default character encoding of the RDF file format. Specify null if not
+ * applicable.
+ * @param fileExtensions The RDF format's file extensions, e.g. rdf for RDF/XML files. The first
+ * item in the list is interpreted as the default file extension for the format.
+ * @param standardURI The standard URI that has been assigned to this format by a standards organisation or
+ * null if it does not currently have a standard URI.
+ * @param supportsNamespaces True if the RDFFormat supports the encoding of namespace/prefix information
+ * and false otherwise.
+ * @param supportsContexts True if the RDFFormat supports the encoding of contexts/named graphs and
+ * false otherwise.
+ * @param supportsTripleTerms True if the RDFFormat supports the encoding of triple terms natively and
+ * false otherwise.
*/
public RDFFormat(String name, Collection mimeTypes, Charset charset, Collection fileExtensions,
- IRI standardURI, boolean supportsNamespaces, boolean supportsContexts, boolean supportsRDFStar) {
+ IRI standardURI, boolean supportsNamespaces, boolean supportsContexts, boolean supportsTripleTerms) {
super(name, mimeTypes, charset, fileExtensions);
this.standardURI = standardURI;
this.supportsNamespaces = supportsNamespaces;
this.supportsContexts = supportsContexts;
- this.supportsRDFStar = supportsRDFStar;
+ this.supportsTripleTerms = supportsTripleTerms;
}
/*---------*
@@ -584,10 +568,10 @@ public boolean supportsContexts() {
}
/**
- * Return true if the RDFFormat supports the encoding of RDF-star triples natively.
+ * Return true if the RDFFormat supports the encoding of triple terms natively.
*/
- public boolean supportsRDFStar() {
- return supportsRDFStar;
+ public boolean supportsTripleTerms() {
+ return supportsTripleTerms;
}
/**
diff --git a/core/rio/api/src/main/java/org/eclipse/rdf4j/rio/helpers/AbstractRDFParser.java b/core/rio/api/src/main/java/org/eclipse/rdf4j/rio/helpers/AbstractRDFParser.java
index e1aeb14ca83..02ea1378e3a 100644
--- a/core/rio/api/src/main/java/org/eclipse/rdf4j/rio/helpers/AbstractRDFParser.java
+++ b/core/rio/api/src/main/java/org/eclipse/rdf4j/rio/helpers/AbstractRDFParser.java
@@ -291,8 +291,8 @@ protected void clear() {
nextBNodePrefix = createUniqueBNodePrefix();
namespaceTable.clear();
// Don't use the setter setValueFactory() as it will update originalValueFactory too
- if (getParserConfig().get(BasicParserSettings.PROCESS_ENCODED_RDF_STAR)) {
- valueFactory = new RDFStarDecodingValueFactory(originalValueFactory);
+ if (getParserConfig().get(BasicParserSettings.PROCESS_ENCODED_TRIPLE_TERMS)) {
+ valueFactory = new TripleTermDecodingValueFactory(originalValueFactory);
} else {
valueFactory = originalValueFactory;
}
diff --git a/core/rio/api/src/main/java/org/eclipse/rdf4j/rio/helpers/AbstractRDFWriter.java b/core/rio/api/src/main/java/org/eclipse/rdf4j/rio/helpers/AbstractRDFWriter.java
index 205f7590b5b..bb72af30bac 100644
--- a/core/rio/api/src/main/java/org/eclipse/rdf4j/rio/helpers/AbstractRDFWriter.java
+++ b/core/rio/api/src/main/java/org/eclipse/rdf4j/rio/helpers/AbstractRDFWriter.java
@@ -93,13 +93,14 @@ public void startRDF() throws RDFHandlerException {
writingStarted = true;
statementConsumer = this::consumeStatement;
- if (getWriterConfig().get(BasicWriterSettings.CONVERT_RDF_STAR_TO_REIFICATION)) {
- // All writers can convert RDF-star to reification on request
- statementConsumer = this::handleStatementConvertRDFStar;
- } else if (!getRDFFormat().supportsRDFStar() && getWriterConfig().get(BasicWriterSettings.ENCODE_RDF_STAR)) {
- // By default non-RDF-star writers encode RDF-star to special RDF IRIs
- // (all parsers, including RDF-star will convert back the encoded IRIs)
- statementConsumer = this::handleStatementEncodeRDFStar;
+ if (getWriterConfig().get(BasicWriterSettings.CONVERT_RDF_12_REIFICATION)) {
+ // All writers can convert RDF 1.2 to reification on request
+ statementConsumer = this::handleStatementConvertTripleTerms;
+ } else if (!getRDFFormat().supportsTripleTerms()
+ && getWriterConfig().get(BasicWriterSettings.ENCODE_TRIPLE_TERMS)) {
+ // By default, non-RDF-12 writers encode triple terms to special RDF IRIs
+ // (all parsers, including RDF 1.2 will convert back the encoded IRIs)
+ statementConsumer = this::handleStatementEncodeTripleTerms;
}
}
@@ -113,7 +114,7 @@ public void handleStatement(Statement st) throws RDFHandlerException {
* Consume a statement.
*
* Extending classes must override this method instead of overriding {@link #handleStatement(Statement)} in order to
- * benefit from automatic handling of RDF-star conversion or encoding.
+ * benefit from automatic handling of RDF 1.2 conversion or encoding.
*
* @param st the statement to consume.
*/
@@ -141,15 +142,15 @@ protected void checkWritingStarted() {
}
}
- private void handleStatementConvertRDFStar(Statement st) {
- Statements.convertRDFStarToReification(st, this::consumeStatement);
+ private void handleStatementConvertTripleTerms(Statement st) {
+ Statements.convertRDF12ReificationToRDF11(st, this::consumeStatement);
}
- private void handleStatementEncodeRDFStar(Statement st) {
+ private void handleStatementEncodeTripleTerms(Statement st) {
Resource s = st.getSubject();
Value o = st.getObject();
if (s instanceof Triple || o instanceof Triple) {
- consumeStatement(new RDFStarEncodingStatement(st));
+ consumeStatement(new TripleTermEncodingStatement(st));
} else {
consumeStatement(st);
}
diff --git a/core/rio/api/src/main/java/org/eclipse/rdf4j/rio/helpers/BasicParserSettings.java b/core/rio/api/src/main/java/org/eclipse/rdf4j/rio/helpers/BasicParserSettings.java
index e6dc74eecee..87bdaf598a6 100644
--- a/core/rio/api/src/main/java/org/eclipse/rdf4j/rio/helpers/BasicParserSettings.java
+++ b/core/rio/api/src/main/java/org/eclipse/rdf4j/rio/helpers/BasicParserSettings.java
@@ -117,7 +117,7 @@ public class BasicParserSettings {
* Can be overridden by setting system property {@code org.eclipse.rdf4j.rio.normalize_language_tags}.
*/
public static final BooleanRioSetting NORMALIZE_LANGUAGE_TAGS = new BooleanRioSetting(
- "org.eclipse.rdf4j.rio.normalize_language_tags", "Normalize recognised language tags", Boolean.FALSE);
+ "org.eclipse.rdf4j.rio.normalize_language_tags", "Normalize recognised language tags", Boolean.TRUE);
/**
* Setting used to specify which {@link LanguageHandler} implementations are to be used for a given parser
@@ -217,19 +217,19 @@ public class BasicParserSettings {
Namespaces.DEFAULT_RDF4J);
/**
- * Boolean setting for parser to determine whether it should process RDF-star triples encoded as RDF-compatible
- * special IRIs back to RDF-star values. These IRIs start with urn:rdf4j:triple: followed by the base64-encoding of
- * the N-Triples serialization of the RDF-star triple value.
+ * Boolean setting for parser to determine whether it should process RDF 1.2 triples encoded as RDF-compatible
+ * special IRIs back to RDF 1.2 values. These IRIs start with urn:rdf4j:triple: followed by the base64-encoding of
+ * the N-Triples serialization of the RDF 1.2 triple value.
*
- * Parsers that support RDF-star natively will honour this setting too.
+ * Parsers that support RDF 1.2 natively will honour this setting too.
*
* Defaults to true.
*
- * Can be overridden by setting system property {@code org.eclipse.rdf4j.rio.process_encoded_rdf_star}.
+ * Can be overridden by setting system property {@code org.eclipse.rdf4j.rio.process_encoded_triple_terms}.
*/
- public static final BooleanRioSetting PROCESS_ENCODED_RDF_STAR = new BooleanRioSetting(
- "org.eclipse.rdf4j.rio.process_encoded_rdf_star",
- "Converts RDF-star triples encoded as RDF-compatible IRIs back to triple values", Boolean.TRUE);
+ public static final BooleanRioSetting PROCESS_ENCODED_TRIPLE_TERMS = new BooleanRioSetting(
+ "org.eclipse.rdf4j.rio.process_encoded_triple_terms",
+ "Converts RDF 1.2 triples encoded as RDF-compatible IRIs back to triple values", Boolean.TRUE);
static {
List defaultDatatypeHandlers = new ArrayList<>(5);
diff --git a/core/rio/api/src/main/java/org/eclipse/rdf4j/rio/helpers/BasicWriterSettings.java b/core/rio/api/src/main/java/org/eclipse/rdf4j/rio/helpers/BasicWriterSettings.java
index 87083c8b22b..a99f05ba6a3 100644
--- a/core/rio/api/src/main/java/org/eclipse/rdf4j/rio/helpers/BasicWriterSettings.java
+++ b/core/rio/api/src/main/java/org/eclipse/rdf4j/rio/helpers/BasicWriterSettings.java
@@ -92,30 +92,30 @@ public class BasicWriterSettings {
"org.eclipse.rdf4j.rio.base_directive", "Serialize base directive", Boolean.TRUE);
/**
- * Boolean setting for writer to determine whether it should convert RDF-star statements to standard RDF
- * reification.
+ * Boolean setting for writer to determine whether it should convert RDF 1.2 statements to standard RDF reification.
*
* Defaults to false
*
- * Can be overridden by setting system property {@code org.eclipse.rdf4j.rio.convert_rdf_star}.
+ * Can be overridden by setting system property {@code org.eclipse.rdf4j.rio.convert_rdf_12_reification}.
*/
- public static final BooleanRioSetting CONVERT_RDF_STAR_TO_REIFICATION = new BooleanRioSetting(
- "org.eclipse.rdf4j.rio.convert_rdf_star", "Convert RDF-star statements to RDF reification", Boolean.FALSE);
+ public static final BooleanRioSetting CONVERT_RDF_12_REIFICATION = new BooleanRioSetting(
+ "org.eclipse.rdf4j.rio.convert_rdf_12_reification", "Convert RDF 1.2 statements to RDF 1.1 reification",
+ Boolean.FALSE);
/**
- * Boolean setting for writer to determine whether it should encode RDF-star triple values to RDF-compatible special
+ * Boolean setting for writer to determine whether it should encode RDF 1.2 triple values to RDF-compatible special
* IRIs. These IRIs start with urn:rdf4j:triple: followed by the base64-encoding of the N-Triples serialization of
- * the RDF-star triple value.
+ * the RDF 1.2 triple value.
*
- * Writers that support RDF-star natively will ignore this setting and always serialize RDF-star triples.
+ * Writers that support RDF 1.2 natively will ignore this setting and always serialize RDF 1.2 triples.
*
* Defaults to true.
*
- * Can be overridden by setting system property {@code org.eclipse.rdf4j.rio.encode_rdf_star}.
+ * Can be overridden by setting system property {@code org.eclipse.rdf4j.rio.encode_triple_terms}.
*/
- public static final BooleanRioSetting ENCODE_RDF_STAR = new BooleanRioSetting(
- "org.eclipse.rdf4j.rio.encode_rdf_star",
- "Encodes RDF-star triples to special IRIs for compatibility with RDF", Boolean.TRUE);
+ public static final BooleanRioSetting ENCODE_TRIPLE_TERMS = new BooleanRioSetting(
+ "org.eclipse.rdf4j.rio.encode_triple_terms",
+ "Encodes triple terms to special IRIs for compatibility with RDF 1.1", Boolean.TRUE);
/**
* Private default constructor.
diff --git a/core/rio/api/src/main/java/org/eclipse/rdf4j/rio/helpers/NTriplesUtil.java b/core/rio/api/src/main/java/org/eclipse/rdf4j/rio/helpers/NTriplesUtil.java
index ad2195abaf0..f20d3905e97 100644
--- a/core/rio/api/src/main/java/org/eclipse/rdf4j/rio/helpers/NTriplesUtil.java
+++ b/core/rio/api/src/main/java/org/eclipse/rdf4j/rio/helpers/NTriplesUtil.java
@@ -97,9 +97,7 @@ public static Value parseValue(String nTriplesValue, ValueFactory valueFactory)
*/
public static Resource parseResource(String nTriplesResource, ValueFactory valueFactory)
throws IllegalArgumentException {
- if (nTriplesResource.startsWith("<<")) {
- return parseTriple(nTriplesResource, valueFactory);
- } else if (nTriplesResource.startsWith("<")) {
+ if (nTriplesResource.startsWith("<")) {
return parseURI(nTriplesResource, valueFactory);
} else if (nTriplesResource.startsWith("_:")) {
return parseBNode(nTriplesResource, valueFactory);
@@ -119,7 +117,7 @@ public static Resource parseResource(String nTriplesResource, ValueFactory value
public static IRI parseURI(String nTriplesURI, ValueFactory valueFactory) throws IllegalArgumentException {
if (nTriplesURI.startsWith("<") && nTriplesURI.endsWith(">")) {
String uri = nTriplesURI.substring(1, nTriplesURI.length() - 1);
- // Disambiguate with RDF-star triple
+ // Disambiguate with triple term
if (!uri.startsWith("<")) {
uri = unescapeString(uri);
return valueFactory.createIRI(uri);
@@ -189,10 +187,9 @@ public static Literal parseLiteral(String nTriplesLiteral, ValueFactory valueFac
}
/**
- * Parses an RDF-star triple (non-standard N-Triples), creates an object for it using the supplied ValueFactory and
- * returns this object.
+ * Parses a tripleterm, creates an object for it using the supplied ValueFactory and returns this object.
*
- * @param nTriplesTriple The RDF-star triple to parse.
+ * @param nTriplesTriple The triple term to parse.
* @param valueFactory The ValueFactory to use for creating the object.
* @return An object representing the parsed triple.
* @throws IllegalArgumentException If the supplied triple could not be parsed correctly.
@@ -206,18 +203,18 @@ public static Triple parseTriple(String nTriplesTriple, ValueFactory valueFactor
}
/**
- * Parses an RDF-star triple (non-standard N-Triples), creates an object for it using the supplied ValueFactory and
- * returns an object that contains the parsed triple and the length of the parsed text.
+ * Parses a triple term, creates an object for it using the supplied ValueFactory and returns an object that
+ * contains the parsed triple and the length of the parsed text.
*
- * @param nTriplesTriple The RDF-star triple to parse.
+ * @param nTriplesTriple The triple to parse.
* @param valueFactory The ValueFactory to use for creating the object.
* @return An object representing the parsed triple and the length of the matching text.
* @throws IllegalArgumentException If the supplied triple could not be parsed correctly.
*/
private static TripleMatch parseTripleInternal(String nTriplesTriple, ValueFactory valueFactory) {
- if (nTriplesTriple.startsWith("<<")) {
- String triple = nTriplesTriple.substring(2);
- int offset = 2;
+ if (nTriplesTriple.startsWith("<<(")) {
+ String triple = nTriplesTriple.substring(3);
+ int offset = 3;
while (!triple.isEmpty() && Character.isWhitespace(triple.charAt(0))) {
triple = triple.substring(1);
@@ -283,8 +280,8 @@ private static TripleMatch parseTripleInternal(String nTriplesTriple, ValueFacto
}
}
- if (triple.endsWith(">>")) {
- offset += 2;
+ if (triple.endsWith(")>>")) {
+ offset += 3;
return new TripleMatch(valueFactory.createTriple(subject, predicate, object), offset);
}
}
@@ -347,6 +344,8 @@ public static String toNTriplesString(Value value, boolean xsdStringToPlainLiter
return toNTriplesString((Resource) value);
} else if (value instanceof Literal) {
return toNTriplesString((Literal) value, xsdStringToPlainLiteral);
+ } else if (value instanceof Triple) {
+ return toNTriplesString((Triple) value);
} else {
throw new IllegalArgumentException("Unknown value type: " + value.getClass());
}
@@ -383,6 +382,8 @@ public static void append(Value value, Appendable appendable, boolean xsdStringT
append((Resource) value, appendable);
} else if (value instanceof Literal) {
append((Literal) value, appendable, xsdStringToPlainLiteral, escapeUnicode);
+ } else if (value instanceof Triple) {
+ append((Triple) value, appendable);
} else {
throw new IllegalArgumentException("Unknown value type: " + value.getClass());
}
@@ -399,8 +400,6 @@ public static String toNTriplesString(Resource resource) {
return toNTriplesString((IRI) resource);
} else if (resource instanceof BNode) {
return toNTriplesString((BNode) resource);
- } else if (resource instanceof Triple) {
- return toNTriplesString((Triple) resource);
} else {
throw new IllegalArgumentException("Unknown resource type: " + resource.getClass());
}
@@ -418,8 +417,6 @@ public static void append(Resource resource, Appendable appendable) throws IOExc
append((IRI) resource, appendable);
} else if (resource instanceof BNode) {
append((BNode) resource, appendable);
- } else if (resource instanceof Triple) {
- append((Triple) resource, appendable);
} else {
throw new IllegalArgumentException("Unknown resource type: " + resource.getClass());
}
@@ -565,6 +562,7 @@ public static void append(Literal lit, Appendable appendable, boolean xsdStringT
// Append the literal's language
appendable.append("@");
appendable.append(lit.getLanguage().get());
+ appendable.append(lit.getBaseDirection().toString());
} else {
// SES-1917 : In RDF-1.1, all literals have a type, and if they are not
// language literals we display the type for backwards compatibility
@@ -579,15 +577,15 @@ public static void append(Literal lit, Appendable appendable, boolean xsdStringT
}
/**
- * Creates an N-Triples (non-standard) string for the supplied RDF-star triple.
+ * Creates an N-Triples string for the supplied triple.
*
* @param triple
* @return string
*/
public static String toNTriplesString(Triple triple) {
- return "<<" + NTriplesUtil.toNTriplesString(triple.getSubject()) + " "
+ return "<<( " + NTriplesUtil.toNTriplesString(triple.getSubject()) + " "
+ NTriplesUtil.toNTriplesString(triple.getPredicate()) + " "
- + NTriplesUtil.toNTriplesString(triple.getObject()) + ">>";
+ + NTriplesUtil.toNTriplesString(triple.getObject()) + " )>>";
}
/**
@@ -598,13 +596,13 @@ public static String toNTriplesString(Triple triple) {
* @throws IOException
*/
public static void append(Triple triple, Appendable appendable) throws IOException {
- appendable.append("<<");
+ appendable.append("<<( ");
append(triple.getSubject(), appendable);
appendable.append(' ');
append(triple.getPredicate(), appendable);
appendable.append(' ');
append(triple.getObject(), appendable);
- appendable.append(">>");
+ appendable.append(" )>>");
}
/**
@@ -747,8 +745,12 @@ public static void escapeString(String label, Appendable appendable, boolean esc
appendable.append("\\r");
} else if (c == '\t') {
appendable.append("\\t");
- } else if (cInt >= 0x0 && cInt <= 0x8 || cInt == 0xB || cInt == 0xC || cInt >= 0xE && cInt <= 0x1F
- || cInt >= 0x7F && cInt <= 0xFFFF) {
+ } else if (c == '\b') {
+ appendable.append("\\b");
+ } else if (c == '\f') {
+ appendable.append("\\f");
+ } else if (cInt >= 0x0 && cInt <= 0x0007 || cInt >= 0xE && cInt <= 0x1F || cInt == 0xB || cInt == 0x7F
+ || cInt >= 0xFFFE) {
if (escapeUnicode) {
appendable.append("\\u");
appendable.append(toHexString(cInt, 4));
diff --git a/core/rio/api/src/main/java/org/eclipse/rdf4j/rio/helpers/RDFParserHelper.java b/core/rio/api/src/main/java/org/eclipse/rdf4j/rio/helpers/RDFParserHelper.java
index fbb27d608ab..fad0afc2c7b 100644
--- a/core/rio/api/src/main/java/org/eclipse/rdf4j/rio/helpers/RDFParserHelper.java
+++ b/core/rio/api/src/main/java/org/eclipse/rdf4j/rio/helpers/RDFParserHelper.java
@@ -99,6 +99,7 @@ public static Literal createLiteral(String label, String lang, IRI datatype, Par
Literal result = null;
String workingLabel = label;
Optional workingLang = Optional.ofNullable(lang);
+ Literal.BaseDirection workingBaseDirection = Literal.BaseDirection.NONE;
IRI workingDatatype = datatype;
// In RDF-1.1 we must do lang check first as language literals will all
@@ -106,31 +107,50 @@ public static Literal createLiteral(String label, String lang, IRI datatype, Par
// non-null lang
if (workingLang.isPresent() && (workingDatatype == null || RDF.LANGSTRING.equals(workingDatatype))) {
boolean recognisedLanguage = false;
+
+ // Split workingLang into language tag and base direction so both can be separately verified
+ final int index = lang.indexOf(Literal.BASE_DIR_SEPARATOR);
+ if (index != -1) {
+ workingLang = Optional.of(lang.substring(0, index));
+ final String baseDirectionString = lang.substring(index);
+
+ try {
+ workingBaseDirection = Literal.BaseDirection.fromString(baseDirectionString);
+ } catch (IllegalArgumentException e) {
+ reportFatalError("'" + baseDirectionString + "' is not a valid base direction ", lineNo, columnNo,
+ errListener);
+ }
+ }
+
for (LanguageHandler nextHandler : parserConfig.get(BasicParserSettings.LANGUAGE_HANDLERS)) {
if (nextHandler.isRecognizedLanguage(workingLang.get())) {
recognisedLanguage = true;
if (parserConfig.get(BasicParserSettings.VERIFY_LANGUAGE_TAGS)) {
try {
if (!nextHandler.verifyLanguage(workingLabel, workingLang.get())) {
- reportError("'" + lang + "' is not a valid language tag ", lineNo, columnNo,
+ reportError("'" + workingLang.get() + "' is not a valid language tag ", lineNo,
+ columnNo,
BasicParserSettings.VERIFY_LANGUAGE_TAGS, parserConfig, errListener);
}
} catch (LiteralUtilException e) {
reportError("'" + label
+ " could not be verified by a language handler that recognised it. language was "
- + lang, lineNo, columnNo, BasicParserSettings.VERIFY_LANGUAGE_TAGS, parserConfig,
+ + workingLang.get(), lineNo, columnNo, BasicParserSettings.VERIFY_LANGUAGE_TAGS,
+ parserConfig,
errListener);
}
}
if (parserConfig.get(BasicParserSettings.NORMALIZE_LANGUAGE_TAGS)) {
try {
- result = nextHandler.normalizeLanguage(workingLabel, workingLang.get(), valueFactory);
+ result = nextHandler.normalizeLanguage(workingLabel, workingLang.get(),
+ workingBaseDirection, valueFactory);
workingLabel = result.getLabel();
workingLang = result.getLanguage();
workingDatatype = result.getDatatype();
} catch (LiteralUtilException e) {
reportError(
- "'" + label + "' did not have a valid value for language " + lang + ": "
+ "'" + label + "' did not have a valid value for language " + workingLang.get()
+ + ": "
+ e.getMessage() + " and could not be normalised",
lineNo, columnNo, BasicParserSettings.NORMALIZE_LANGUAGE_TAGS, parserConfig,
errListener);
@@ -141,7 +161,8 @@ public static Literal createLiteral(String label, String lang, IRI datatype, Par
if (!recognisedLanguage) {
reportError("'" + label
+ "' was not recognised as a language literal, and could not be verified, with language "
- + lang, lineNo, columnNo, BasicParserSettings.FAIL_ON_UNKNOWN_LANGUAGES, parserConfig,
+ + workingLang.get(), lineNo, columnNo, BasicParserSettings.FAIL_ON_UNKNOWN_LANGUAGES,
+ parserConfig,
errListener);
}
} else if (workingDatatype != null) {
@@ -189,15 +210,18 @@ public static Literal createLiteral(String label, String lang, IRI datatype, Par
if (result == null) {
try {
// Removes datatype for langString datatype with no language tag when VERIFY_DATATYPE_VALUES is False.
- if ((workingDatatype == null || RDF.LANGSTRING.equals(workingDatatype))
+ if ((workingDatatype == null || RDF.LANGSTRING.equals(workingDatatype)
+ || RDF.DIRLANGSTRING.equals(workingDatatype))
&& (workingLang.isEmpty() || workingLang.get().isEmpty())
&& !parserConfig.get(BasicParserSettings.VERIFY_DATATYPE_VALUES)) {
workingLang = Optional.ofNullable(null);
workingDatatype = null;
}
// Backup for unnormalised language literal creation
- if (workingLang.isPresent() && (workingDatatype == null || RDF.LANGSTRING.equals(workingDatatype))) {
- result = valueFactory.createLiteral(workingLabel, workingLang.get().intern());
+ if (workingLang.isPresent()
+ && (workingDatatype == null || RDF.LANGSTRING.equals(workingDatatype)
+ || RDF.DIRLANGSTRING.equals(workingDatatype))) {
+ result = valueFactory.createLiteral(workingLabel, workingLang.get().intern(), workingBaseDirection);
}
// Backup for unnormalised datatype literal creation
else if (workingDatatype != null) {
diff --git a/core/rio/api/src/main/java/org/eclipse/rdf4j/rio/helpers/RDFStarDecodingValueFactory.java b/core/rio/api/src/main/java/org/eclipse/rdf4j/rio/helpers/TripleTermDecodingValueFactory.java
similarity index 87%
rename from core/rio/api/src/main/java/org/eclipse/rdf4j/rio/helpers/RDFStarDecodingValueFactory.java
rename to core/rio/api/src/main/java/org/eclipse/rdf4j/rio/helpers/TripleTermDecodingValueFactory.java
index a324b58c748..17d563f6227 100644
--- a/core/rio/api/src/main/java/org/eclipse/rdf4j/rio/helpers/RDFStarDecodingValueFactory.java
+++ b/core/rio/api/src/main/java/org/eclipse/rdf4j/rio/helpers/TripleTermDecodingValueFactory.java
@@ -30,14 +30,14 @@
/**
* A {@link ValueFactory} that will delegate everything to another {@link ValueFactory} and create statements whose
- * subject and object will be converted from RDF-star triples encoded as special IRIs back to RDF-star values.
+ * subject and object will be converted from RDF 1.2 triples encoded as special IRIs back to RDF 1.2 values.
*
* All other values in the subject and object position will be used as is.
*/
-class RDFStarDecodingValueFactory implements ValueFactory {
+class TripleTermDecodingValueFactory implements ValueFactory {
private final ValueFactory delegate;
- RDFStarDecodingValueFactory(ValueFactory delegate) {
+ TripleTermDecodingValueFactory(ValueFactory delegate) {
this.delegate = delegate;
}
@@ -71,6 +71,11 @@ public Literal createLiteral(String label, String language) {
return delegate.createLiteral(label, language);
}
+ @Override
+ public Literal createLiteral(String label, String language, Literal.BaseDirection baseDirection) {
+ return delegate.createLiteral(label, language, baseDirection);
+ }
+
@Override
public Literal createLiteral(String label, IRI datatype) {
return delegate.createLiteral(label, datatype);
@@ -154,16 +159,16 @@ public Literal createLiteral(Date date) {
@Override
public Statement createStatement(Resource subject,
IRI predicate, Value object) {
- return delegate.createStatement(RDFStarUtil.fromRDFEncodedValue(subject), predicate,
- RDFStarUtil.fromRDFEncodedValue(object));
+ return delegate.createStatement(subject, predicate,
+ TripleTermUtil.fromRDFEncodedValue(object));
}
@Override
public Statement createStatement(Resource subject,
IRI predicate, Value object,
Resource context) {
- return delegate.createStatement(RDFStarUtil.fromRDFEncodedValue(subject), predicate,
- RDFStarUtil.fromRDFEncodedValue(object), context);
+ return delegate.createStatement(subject, predicate,
+ TripleTermUtil.fromRDFEncodedValue(object), context);
}
@Override
diff --git a/core/rio/api/src/main/java/org/eclipse/rdf4j/rio/helpers/RDFStarEncodingStatement.java b/core/rio/api/src/main/java/org/eclipse/rdf4j/rio/helpers/TripleTermEncodingStatement.java
similarity index 79%
rename from core/rio/api/src/main/java/org/eclipse/rdf4j/rio/helpers/RDFStarEncodingStatement.java
rename to core/rio/api/src/main/java/org/eclipse/rdf4j/rio/helpers/TripleTermEncodingStatement.java
index 2e5d4b5f6ce..bf3e263dbee 100644
--- a/core/rio/api/src/main/java/org/eclipse/rdf4j/rio/helpers/RDFStarEncodingStatement.java
+++ b/core/rio/api/src/main/java/org/eclipse/rdf4j/rio/helpers/TripleTermEncodingStatement.java
@@ -18,21 +18,21 @@
import org.eclipse.rdf4j.model.Value;
/**
- * Represents a {@link Statement} whose subject or object may be an RDF-star triple that will be encoded as a special
- * IRI value on {@link #getSubject()} and {@link #getObject()}.
+ * Represents a {@link Statement} whose object may be a triple term that will be encoded as a special IRI value on
+ * {@link #getObject()}.
*
* @author Pavel Mihaylov
*/
-class RDFStarEncodingStatement implements Statement {
+class TripleTermEncodingStatement implements Statement {
private final Statement delegate;
- RDFStarEncodingStatement(Statement delegate) {
+ TripleTermEncodingStatement(Statement delegate) {
this.delegate = delegate;
}
@Override
public Resource getSubject() {
- return RDFStarUtil.toRDFEncodedValue(delegate.getSubject());
+ return TripleTermUtil.toRDFEncodedValue(delegate.getSubject());
}
@Override
@@ -42,7 +42,7 @@ public IRI getPredicate() {
@Override
public Value getObject() {
- return RDFStarUtil.toRDFEncodedValue(delegate.getObject());
+ return TripleTermUtil.toRDFEncodedValue(delegate.getObject());
}
@Override
diff --git a/core/rio/api/src/main/java/org/eclipse/rdf4j/rio/helpers/RDFStarUtil.java b/core/rio/api/src/main/java/org/eclipse/rdf4j/rio/helpers/TripleTermUtil.java
similarity index 70%
rename from core/rio/api/src/main/java/org/eclipse/rdf4j/rio/helpers/RDFStarUtil.java
rename to core/rio/api/src/main/java/org/eclipse/rdf4j/rio/helpers/TripleTermUtil.java
index 283c88b7e7d..8922619bf87 100644
--- a/core/rio/api/src/main/java/org/eclipse/rdf4j/rio/helpers/RDFStarUtil.java
+++ b/core/rio/api/src/main/java/org/eclipse/rdf4j/rio/helpers/TripleTermUtil.java
@@ -20,27 +20,27 @@
import org.eclipse.rdf4j.model.impl.SimpleValueFactory;
/**
- * Utility methods for RDF-star triples.
+ * Utility methods for RDF 1.2 triples.
*
* @author Pavel Mihaylov
*/
-public class RDFStarUtil {
+public class TripleTermUtil {
/**
- * IRI prefix for RDF-star triples encoded as IRIs.
+ * IRI prefix for RDF 1.2 triples encoded as IRIs.
*/
public static final String TRIPLE_PREFIX = "urn:rdf4j:triple:";
private static final ValueFactory VF = SimpleValueFactory.getInstance();
/**
- * Converts the supplied value from RDF-star to an RDF-compatible representation.
+ * Converts the supplied value from RDF 1.2 to an RDF-compatible representation.
*
- * RDF-star triples are encoded as IRIs that start with {@link #TRIPLE_PREFIX}, followed by the base64 encoding of
+ * RDF 1.2 triples are encoded as IRIs that start with {@link #TRIPLE_PREFIX}, followed by the base64 encoding of
* the N-Triples serialization of the triple.
*
- * All other RDF-star values are valid in RDF as well and remain unchanged.
+ * All other RDF 1.2 values are valid in RDF as well and remain unchanged.
*
- * @param value a RDF-star {@link Value} to encode.
+ * @param value a RDF 1.2 {@link Value} to encode.
* @param
* @return the RDF-compatible encoded value, if a {@link Triple} was supplied, or the supplied value otherwise.
*/
@@ -51,15 +51,15 @@ public static T toRDFEncodedValue(T value) {
}
/**
- * Converts the supplied value from an RDF-compatible representation to an RDF-star value.
+ * Converts the supplied value from an RDF-compatible representation to an RDF 1.2 value.
*
* See {@link #toRDFEncodedValue(Value)}.
*
- * @param encodedValue an RDF {@link Value} to convert to RDF-star.
+ * @param encodedValue an RDF {@link Value} to convert to RDF 1.2.
* @param
- * @return the decoded RDF-star triple, if a {@link Triple} encoded as {@link IRI} was supplied, or the supplied
+ * @return the decoded RDF 1.2 triple, if a {@link Triple} encoded as {@link IRI} was supplied, or the supplied
* value otherwise.
- * @throws IllegalArgumentException if the supplied value looked like an RDF-star triple encoded as an IRI but it
+ * @throws IllegalArgumentException if the supplied value looked like an RDF 1.2 triple encoded as an IRI but it
* could not be decoded successfully.
*/
public static T fromRDFEncodedValue(T encodedValue) {
@@ -69,21 +69,21 @@ public static T fromRDFEncodedValue(T encodedValue) {
encodedValue.stringValue().substring(TRIPLE_PREFIX.length())), VF)
: encodedValue;
} catch (IllegalArgumentException e) {
- throw new IllegalArgumentException("Invalid RDF-star encoded triple: " + encodedValue);
+ throw new IllegalArgumentException("Invalid RDF 1.2 encoded triple: " + encodedValue);
}
}
/**
- * Converts the supplied value from an RDF-compatible representation to an RDF-star value.
+ * Converts the supplied value from an RDF-compatible representation to an RDF 1.2 value.
*
* See {@link #toRDFEncodedValue(Value)}.
*
- * @param encodedValue an RDF {@link Value} to convert to RDF-star.
+ * @param encodedValue an RDF {@link Value} to convert to RDF 1.2.
* @param valueFactory the {@link ValueFactory} to use for parsing the triple.
* @param
- * @return the decoded RDF-star triple, if a {@link Triple} encoded as {@link IRI} was supplied, or the supplied
+ * @return the decoded RDF 1.2 triple, if a {@link Triple} encoded as {@link IRI} was supplied, or the supplied
* value otherwise.
- * @throws IllegalArgumentException if the supplied value looked like an RDF-star triple encoded as an IRI but it
+ * @throws IllegalArgumentException if the supplied value looked like an RDF 1.2 triple encoded as an IRI but it
* could not be decoded successfully.
*/
public static T fromRDFEncodedValue(T encodedValue, ValueFactory valueFactory) {
@@ -93,15 +93,15 @@ public static T fromRDFEncodedValue(T encodedValue, ValueFacto
encodedValue.stringValue().substring(TRIPLE_PREFIX.length())), valueFactory)
: encodedValue;
} catch (IllegalArgumentException e) {
- throw new IllegalArgumentException("Invalid RDF-star encoded triple: " + encodedValue);
+ throw new IllegalArgumentException("Invalid RDF 1.2 encoded triple: " + encodedValue);
}
}
/**
- * Checks if the supplied {@link Value} represents an RDF-star triple encoded as an IRI.
+ * Checks if the supplied {@link Value} represents an RDF 1.2 triple encoded as an IRI.
*
* @param value the value to check.
- * @return True if the value is an RDF-star triple encoded as an IRI, false otherwise.
+ * @return True if the value is an RDF 1.2 triple encoded as an IRI, false otherwise.
*/
public static boolean isEncodedTriple(Value value) {
return value instanceof IRI && value.stringValue().startsWith(TRIPLE_PREFIX);
diff --git a/core/rio/api/src/test/java/org/eclipse/rdf4j/rio/AbstractParserHandlingTest.java b/core/rio/api/src/test/java/org/eclipse/rdf4j/rio/AbstractParserHandlingTest.java
index 2623b94c14d..70d8cb9b424 100644
--- a/core/rio/api/src/test/java/org/eclipse/rdf4j/rio/AbstractParserHandlingTest.java
+++ b/core/rio/api/src/test/java/org/eclipse/rdf4j/rio/AbstractParserHandlingTest.java
@@ -22,7 +22,6 @@
import java.io.OutputStream;
import java.util.Collection;
import java.util.Collections;
-import java.util.Date;
import java.util.HashSet;
import java.util.Locale;
import java.util.Map;
@@ -42,8 +41,8 @@
import org.eclipse.rdf4j.model.vocabulary.XSD;
import org.eclipse.rdf4j.rio.helpers.BasicParserSettings;
import org.eclipse.rdf4j.rio.helpers.ParseErrorCollector;
-import org.eclipse.rdf4j.rio.helpers.RDFStarUtil;
import org.eclipse.rdf4j.rio.helpers.StatementCollector;
+import org.eclipse.rdf4j.rio.helpers.TripleTermUtil;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
@@ -1002,19 +1001,20 @@ public void testSkolemization() throws Exception {
}
@Test
- public void testRDFStarCompatibility1() throws Exception {
+ public void testRDF12Compatibility1() throws Exception {
Model expectedModel = new LinkedHashModel();
Triple t1 = vf.createTriple(vf.createIRI("http://example.com/1"), vf.createIRI("http://example.com/2"),
vf.createLiteral("example", vf.createIRI("http://example.com/3")));
- expectedModel.add(vf.createStatement(t1, DC.SOURCE, vf.createIRI("http://example.com/4")));
- Triple t2 = vf.createTriple(t1, DC.DATE, vf.createLiteral(new Date()));
+ expectedModel.add(vf.createStatement(vf.createIRI("http://example.com/4"), DC.SOURCE, t1));
+ Triple t2 = vf.createTriple(vf.createIRI("http://example.com/s"), DC.DATE, t1);
expectedModel.add(vf.createStatement(vf.createIRI("http://example.com/5"), DC.RELATION, t2));
- Triple t3 = vf.createTriple(vf.createTriple(vf.createTriple(vf.createIRI("urn:a"), RDF.TYPE,
- vf.createIRI("urn:b")), vf.createIRI("urn:c"), vf.createIRI("urn:d")), vf.createIRI("urn:e"),
- vf.createIRI("urn:f"));
- expectedModel.add(vf.createStatement(t3, vf.createIRI("urn:same"), t3));
+ Triple t3 = vf.createTriple(vf.createIRI("urn:e"),
+ vf.createIRI("urn:f"),
+ vf.createTriple(vf.createIRI("urn:c"), vf.createIRI("urn:d"),
+ vf.createTriple(vf.createIRI("urn:a"), RDF.TYPE,
+ vf.createIRI("urn:b"))));
+ expectedModel.add(vf.createStatement(vf.createIRI("http://example.com/s2"), vf.createIRI("urn:same"), t3));
- // Default: formats with RDF-star support handle it natively and non-RDF-star use a compatibility encoding
InputStream input1 = serialize(expectedModel);
testParser.parse(input1, BASE_URI);
assertErrorListener(0, 0, 0);
@@ -1022,36 +1022,38 @@ public void testRDFStarCompatibility1() throws Exception {
}
@Test
- public void testRDFStarCompatibility2() throws Exception {
+ public void testRDF12Compatibility2() throws Exception {
Model expectedModel = new LinkedHashModel();
Triple t1 = vf.createTriple(vf.createIRI("http://example.com/1"), vf.createIRI("http://example.com/2"),
vf.createLiteral("example", vf.createIRI("http://example.com/3")));
- expectedModel.add(vf.createStatement(t1, DC.SOURCE, vf.createIRI("http://example.com/4")));
- Triple t2 = vf.createTriple(t1, DC.DATE, vf.createLiteral(new Date()));
+ expectedModel.add(vf.createStatement(vf.createIRI("http://example.com/4"), DC.SOURCE, t1));
+ Triple t2 = vf.createTriple(vf.createIRI("http://example.com/s"), DC.DATE, t1);
expectedModel.add(vf.createStatement(vf.createIRI("http://example.com/5"), DC.RELATION, t2));
- Triple t3 = vf.createTriple(vf.createTriple(vf.createTriple(vf.createIRI("urn:a"), RDF.TYPE,
- vf.createIRI("urn:b")), vf.createIRI("urn:c"), vf.createIRI("urn:d")), vf.createIRI("urn:e"),
- vf.createIRI("urn:f"));
- expectedModel.add(vf.createStatement(t3, vf.createIRI("urn:same"), t3));
-
- // Turn off compatibility on parsing: formats with RDF-star support will produce RDF-star triples,
- // non-RDF-star formats will produce IRIs of the kind urn:rdf4j:triple:xxx
+ Triple t3 = vf.createTriple(vf.createIRI("urn:e"),
+ vf.createIRI("urn:f"),
+ vf.createTriple(vf.createIRI("urn:c"), vf.createIRI("urn:d"),
+ vf.createTriple(vf.createIRI("urn:a"), RDF.TYPE,
+ vf.createIRI("urn:b"))));
+ expectedModel.add(vf.createStatement(vf.createIRI("http://example.com/s2"), vf.createIRI("urn:same"), t3));
+
+ // Turn off compatibility on parsing: formats with triple term support will produce triple term triples,
+ // non-triple term formats will produce IRIs of the kind urn:rdf4j:triple:xxx
InputStream input2 = serialize(expectedModel);
- testParser.getParserConfig().set(BasicParserSettings.PROCESS_ENCODED_RDF_STAR, false);
+ testParser.getParserConfig().set(BasicParserSettings.PROCESS_ENCODED_TRIPLE_TERMS, false);
testParser.parse(input2, BASE_URI);
assertErrorListener(0, 0, 0);
- if (testParser.getRDFFormat().supportsRDFStar()) {
+ if (testParser.getRDFFormat().supportsTripleTerms()) {
assertModel(expectedModel);
} else {
assertTrue(testStatements.getStatements()
- .contains(vf.createStatement(RDFStarUtil.toRDFEncodedValue(t1), DC.SOURCE,
- vf.createIRI("http://example.com/4"))));
+ .contains(vf.createStatement(vf.createIRI("http://example.com/4"), DC.SOURCE,
+ TripleTermUtil.toRDFEncodedValue(t1))));
assertTrue(testStatements.getStatements()
.contains(vf.createStatement(vf.createIRI("http://example.com/5"), DC.RELATION,
- RDFStarUtil.toRDFEncodedValue(t2))));
+ TripleTermUtil.toRDFEncodedValue(t2))));
assertTrue(testStatements.getStatements()
- .contains(vf.createStatement(RDFStarUtil.toRDFEncodedValue(t3), vf.createIRI("urn:same"),
- RDFStarUtil.toRDFEncodedValue(t3))));
+ .contains(vf.createStatement(vf.createIRI("http://example.com/s2"), vf.createIRI("urn:same"),
+ TripleTermUtil.toRDFEncodedValue(t3))));
assertEquals(3, testStatements.getStatements().size());
}
}
diff --git a/core/rio/api/src/test/java/org/eclipse/rdf4j/rio/AbstractParserTest.java b/core/rio/api/src/test/java/org/eclipse/rdf4j/rio/AbstractParserTest.java
new file mode 100644
index 00000000000..ec21623b260
--- /dev/null
+++ b/core/rio/api/src/test/java/org/eclipse/rdf4j/rio/AbstractParserTest.java
@@ -0,0 +1,113 @@
+/*******************************************************************************
+ * Copyright (c) 2025 Eclipse RDF4J contributors, Aduna, and others.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Distribution License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ *******************************************************************************/
+package org.eclipse.rdf4j.rio;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
+
+import java.io.StringReader;
+import java.util.Collection;
+
+import org.eclipse.rdf4j.model.Literal;
+import org.eclipse.rdf4j.model.Statement;
+import org.eclipse.rdf4j.model.base.CoreDatatype;
+import org.eclipse.rdf4j.rio.helpers.BasicParserSettings;
+import org.eclipse.rdf4j.rio.helpers.ParseErrorCollector;
+import org.eclipse.rdf4j.rio.helpers.SimpleParseLocationListener;
+import org.eclipse.rdf4j.rio.helpers.StatementCollector;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+/*
+* Testing base class for Turtle, TriG, NTriples, and NQuads parsers
+ */
+public abstract class AbstractParserTest {
+ protected RDFParser parser;
+ protected ParseErrorCollector errorCollector = new ParseErrorCollector();
+ protected StatementCollector statementCollector = new StatementCollector();
+ protected TestParseLocationListener locationListener = new TestParseLocationListener();
+
+ @BeforeEach
+ public void setUp() {
+ parser = createRDFParser();
+ parser.setParseErrorListener(errorCollector);
+ parser.setRDFHandler(statementCollector);
+ parser.setParseLocationListener(locationListener);
+ }
+
+ protected void dirLangStringTestHelper(
+ final String data, final String expectedLang, final String expectedBaseDir, final boolean normalize,
+ final boolean shouldFail) {
+ parser.getParserConfig().set(BasicParserSettings.FAIL_ON_UNKNOWN_LANGUAGES, true);
+ parser.getParserConfig().set(BasicParserSettings.NORMALIZE_LANGUAGE_TAGS, normalize);
+
+ try {
+ parser.parse(new StringReader(data));
+
+ if (shouldFail) {
+ fail("default config should result in fatal error / parse exception");
+ }
+
+ assertThat(errorCollector.getErrors()).isEmpty();
+
+ final Collection stmts = statementCollector.getStatements();
+
+ assertThat(stmts).hasSize(1);
+
+ final Statement stmt = stmts.iterator().next();
+
+ assertEquals(CoreDatatype.RDF.DIRLANGSTRING.getIri(), ((Literal) stmt.getObject()).getDatatype());
+ assertTrue(((Literal) stmt.getObject()).getLanguage().isPresent());
+ assertEquals(expectedLang, ((Literal) stmt.getObject()).getLanguage().get());
+ assertEquals(expectedBaseDir, ((Literal) stmt.getObject()).getBaseDirection().toString());
+ } catch (final Exception e) {
+ if (!shouldFail) {
+ fail("parse error on correct data: " + e.getMessage());
+ }
+ }
+ }
+
+ protected void dirLangStringNoLanguageTestHelper(String data) {
+ try {
+ parser.parse(new StringReader(data));
+
+ assertThat(errorCollector.getErrors()).isEmpty();
+
+ Collection stmts = statementCollector.getStatements();
+
+ assertThat(stmts).hasSize(1);
+
+ Statement stmt = stmts.iterator().next();
+
+ assertEquals(CoreDatatype.XSD.STRING.getIri(), ((Literal) stmt.getObject()).getDatatype());
+ } catch (Exception e) {
+ fail("parse error on correct data: " + e.getMessage());
+ }
+ }
+
+ protected abstract RDFParser createRDFParser();
+
+ protected static class TestParseLocationListener extends SimpleParseLocationListener {
+
+ public void assertListener(int row, int col) {
+ assertEquals(row, this.getLineNo(), "Unexpected last row");
+ assertEquals(col, this.getColumnNo(), "Unexpected last col");
+ }
+
+ }
+
+ @Test
+ public void dummy() {
+ }
+
+}
diff --git a/core/rio/api/src/test/java/org/eclipse/rdf4j/rio/RDFWriterTest.java b/core/rio/api/src/test/java/org/eclipse/rdf4j/rio/RDFWriterTest.java
index 3a4125c54ac..115bf5dc0ff 100644
--- a/core/rio/api/src/test/java/org/eclipse/rdf4j/rio/RDFWriterTest.java
+++ b/core/rio/api/src/test/java/org/eclipse/rdf4j/rio/RDFWriterTest.java
@@ -31,6 +31,7 @@
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Reader;
+import java.io.StringWriter;
import java.io.Writer;
import java.util.ArrayList;
import java.util.Arrays;
@@ -50,6 +51,7 @@
import org.eclipse.rdf4j.model.Triple;
import org.eclipse.rdf4j.model.Value;
import org.eclipse.rdf4j.model.ValueFactory;
+import org.eclipse.rdf4j.model.impl.DynamicModelFactory;
import org.eclipse.rdf4j.model.impl.LinkedHashModel;
import org.eclipse.rdf4j.model.impl.SimpleValueFactory;
import org.eclipse.rdf4j.model.util.Models;
@@ -131,10 +133,6 @@ public abstract class RDFWriterTest {
private final Triple triple4;
- private final Triple triple5;
-
- private final Triple triple6;
-
private final Literal plainLit;
private final Literal dtLit;
@@ -203,8 +201,6 @@ protected RDFWriterTest(RDFWriterFactory writerF, RDFParserFactory parserF) {
triple2 = vf.createTriple(bnode, uri3, litWithMultipleNewlines);
triple3 = vf.createTriple(uri3, uri4, bnodeSingleLetter);
triple4 = vf.createTriple(uri5, uri1, uri3);
- triple5 = vf.createTriple(triple1, uri3, litBigPlaceholder);
- triple6 = vf.createTriple(triple2, uri4, triple5);
potentialSubjects = new ArrayList<>();
potentialSubjects.add(bnode);
@@ -219,7 +215,6 @@ protected RDFWriterTest(RDFWriterFactory writerF, RDFParserFactory parserF) {
potentialSubjects.add(uri3);
potentialSubjects.add(uri4);
potentialSubjects.add(uri5);
- potentialSubjects.addAll(Arrays.asList(triple1, triple2, triple2, triple3, triple4, triple5, triple6));
for (int i = 0; i < 50; i++) {
potentialSubjects.add(vf.createBNode());
}
@@ -242,7 +237,7 @@ protected RDFWriterTest(RDFWriterFactory writerF, RDFParserFactory parserF) {
potentialObjects.add(plainLit);
potentialObjects.add(dtLit);
potentialObjects.add(langLit);
- potentialObjects.addAll(Arrays.asList(triple1, triple2, triple2, triple3, triple4, triple5, triple6));
+ potentialObjects.addAll(Arrays.asList(triple1, triple2, triple2, triple3, triple4));
// FIXME: SES-879: The following break the RDF/XML parser/writer
// combination in terms of getting the same number of triples back as we
// start with
@@ -756,7 +751,7 @@ private void testPerformanceInternal(boolean storeParsedStatements) throws Excep
IRI pred = potentialPredicates.get(prng.nextInt(potentialPredicates.size()));
while (obj instanceof Triple && pred.equals(RDF.TYPE)) {
// Avoid statements "x rdf:type <>" as those use the shorter syntax in RDFXMLPrettyWriter
- // and the writer produces invalid XML in that case. Even though the RDF-star triples are encoded as
+ // and the writer produces invalid XML in that case. Even though the triples are encoded as
// valid IRIs, XML has limitations on what characters may form an XML tag name and thus a limitation
// on what IRIs may be used in predicates (predicates are XML tags) or the short form of rdf:type
// (where the type is also an XML tag).
@@ -1828,15 +1823,31 @@ public void testBogusIRICharacters() throws Exception {
}
@Test
- public void testRDFStarConversion() throws IOException {
+ public void testReificationConversion() throws IOException {
Model model = new LinkedHashModel();
- model.add(vf.createStatement(triple3, uri1, triple6, uri4));
+
+ BNode triple1Reifier = vf.createBNode();
+ BNode triple2Reifier = vf.createBNode();
+ BNode triple3Reifier = vf.createBNode();
+ BNode triple5Reifier = vf.createBNode();
+ BNode triple6Reifier = vf.createBNode();
+
+ Triple triple5 = vf.createTriple(triple1Reifier, uri3, litBigPlaceholder);
+ Triple triple6 = vf.createTriple(triple2Reifier, uri4, triple5Reifier);
+
+ model.add(vf.createStatement(triple1Reifier, RDF.REIFIES, triple1, uri4));
+ model.add(vf.createStatement(triple2Reifier, RDF.REIFIES, triple2, uri4));
+ model.add(vf.createStatement(triple3Reifier, RDF.REIFIES, triple3, uri4));
+ model.add(vf.createStatement(triple5Reifier, RDF.REIFIES, triple5, uri4));
+ model.add(vf.createStatement(triple6Reifier, RDF.REIFIES, triple6, uri4));
+
+ model.add(vf.createStatement(triple3Reifier, uri1, triple6Reifier, uri4));
model.add(vf.createStatement(uri1, uri2, uri3, uri5));
ByteArrayOutputStream outputWriter = new ByteArrayOutputStream();
RDFWriter rdfWriter = rdfWriterFactory.getWriter(outputWriter);
setupWriterConfig(rdfWriter.getWriterConfig());
- rdfWriter.getWriterConfig().set(BasicWriterSettings.CONVERT_RDF_STAR_TO_REIFICATION, true);
+ rdfWriter.getWriterConfig().set(BasicWriterSettings.CONVERT_RDF_12_REIFICATION, true);
rdfWriter.startRDF();
model.forEach(rdfWriter::handleStatement);
rdfWriter.endRDF();
@@ -1848,13 +1859,8 @@ public void testRDFStarConversion() throws IOException {
rdfParser.setRDFHandler(new StatementCollector(parsedOutput));
rdfParser.parse(inputReader, "");
- // 1 non-RDF-star statement
- // 1 RDF-star statement whose conversion yields 20 additional statements:
- // 4 for triple3
- // 4 for triple6
- // 4 for triple2 (contained in triple6)
- // 4 for triple5 (contained in triple6)
- // 4 for triple1 (contained in triple5)
+ // 2 statements without triple terms
+ // 5 reification statements using RDF 1.2, each translates to 4 RDF 1.1 statements
assertEquals(22, parsedOutput.size());
}
@@ -1938,4 +1944,21 @@ private void assertSameModel(Model expected, Model actual) {
assertEquals(actual.filter(subj, pred, obj).size(), actual.filter(subj, pred, obj).size());
}
}
+
+ // Helper method for testing dirLangString literals in supported formats (Turtle, NTriples, TriG, NQuads)
+ public void dirLangStringTest(RDFFormat format) throws Exception {
+ Model model = new DynamicModelFactory().createEmptyModel();
+ String ns = "http://example.org/";
+ IRI uri1 = vf.createIRI(ns, "uri1");
+ IRI uri2 = vf.createIRI(ns, "uri2");
+ model.add(vf.createStatement(uri1, uri2, vf.createLiteral("hello", "en", Literal.BaseDirection.LTR)));
+ model.add(vf.createStatement(uri1, uri2, vf.createLiteral("שלום", "he", Literal.BaseDirection.RTL)));
+
+ StringWriter stringWriter = new StringWriter();
+ Rio.write(model, stringWriter, format);
+ String output = stringWriter.toString();
+
+ assertThat(output).contains("\"hello\"@en--ltr");
+ assertThat(output).contains("\"שלום\"@he--rtl");
+ }
}
diff --git a/core/rio/api/src/test/java/org/eclipse/rdf4j/rio/helpers/NTriplesUtilTest.java b/core/rio/api/src/test/java/org/eclipse/rdf4j/rio/helpers/NTriplesUtilTest.java
index ea59547447e..dded09b9a1f 100644
--- a/core/rio/api/src/test/java/org/eclipse/rdf4j/rio/helpers/NTriplesUtilTest.java
+++ b/core/rio/api/src/test/java/org/eclipse/rdf4j/rio/helpers/NTriplesUtilTest.java
@@ -52,37 +52,36 @@ public void testAppendWithoutEncoding() throws Exception {
@Test
public void testAppendWithEncoding() throws Exception {
- Literal l = f.createLiteral("Äbc");
+ Literal l = f.createLiteral("\bbc");
NTriplesUtil.append(l, appendable, true, true);
- assertThat(appendable.toString()).isEqualTo("\"\\u00C4bc\"");
+ assertThat(appendable.toString()).isEqualTo("\"\\bbc\"");
}
@Test
public void testSerializeTriple() throws IOException {
Object[] triples = new Object[] {
f.createTriple(f.createIRI("urn:a"), f.createIRI("urn:b"), f.createIRI("urn:c")),
- "<< >>",
- //
- f.createTriple(f.createTriple(f.createIRI("urn:a"), f.createIRI("urn:b"), f.createIRI("urn:c")),
- DC.SOURCE, f.createLiteral("news")),
- "<<<< >> \"news\">>",
- //
+ "<<( )>>",
+
+ f.createTriple(f.createIRI("urn:subject"),
+ DC.SOURCE, f.createTriple(f.createIRI("urn:a"), f.createIRI("urn:b"), f.createIRI("urn:c"))),
+ "<<( <<( )>> )>>",
+
f.createTriple(f.createBNode("bnode1"), f.createIRI("urn:x"),
f.createTriple(f.createIRI("urn:a"), f.createIRI("urn:b"), f.createIRI("urn:c"))),
- "<<_:bnode1 << >>>>"
+ "<<( _:bnode1 <<( )>> )>>"
};
for (int i = 0; i < triples.length; i += 2) {
assertEquals(triples[i + 1], NTriplesUtil.toNTriplesString((Triple) triples[i]));
- assertEquals(triples[i + 1], NTriplesUtil.toNTriplesString((Resource) triples[i]));
assertEquals(triples[i + 1], NTriplesUtil.toNTriplesString((Value) triples[i]));
NTriplesUtil.append((Triple) triples[i], appendable);
assertEquals(triples[i + 1], appendable.toString());
appendable = new StringBuilder();
- NTriplesUtil.append((Resource) triples[i], appendable);
+ NTriplesUtil.append((Triple) triples[i], appendable);
assertEquals(triples[i + 1], appendable.toString());
appendable = new StringBuilder();
- NTriplesUtil.append((Value) triples[i], appendable);
+ NTriplesUtil.append((Triple) triples[i], appendable);
assertEquals(triples[i + 1], appendable.toString());
appendable = new StringBuilder();
}
@@ -91,48 +90,41 @@ public void testSerializeTriple() throws IOException {
@Test
public void testParseTriple() {
String[] triples = new String[] {
- "<<<<\"täst\"@de-DE>>>>",
- "<>>>",
- //
- "<< << \"täst\"@de-DE >> >>",
- "<>>>",
- //
- "<<<<_:bnode1foobar\"literál за проба\"^^>>\"test\\\\\\\"lit\">>",
- "<<<<_:bnode1foobar urn:täst \"literál за проба\"^^>> http://test/baz \"test\\\"lit\">>",
+ "<<(<<(\"täst\"@de-DE)>>)>>",
+ "<<( http://foo.com/bar#baz%20 http://example.com/test <<( urn:foo urn:р \"täst\"@de-DE )>> )>>",
//
- "<< <<_:bnode1foobar \"literál за проба\"^^ >> \"test\\\\\\\"lit\" >>",
- "<<<<_:bnode1foobar urn:täst \"literál за проба\"^^>> http://test/baz \"test\\\"lit\">>",
+ "<<( <<( \"täst\"@de-DE )>> )>>",
+ "<<( http://foo.com/bar#baz%20 http://example.com/test <<( urn:foo urn:р \"täst\"@de-DE )>> )>>",
// test surrogate pair range in bnode
- "<<_:test_\uD800\uDC00_\uD840\uDC00_bnode >>",
- "<<_:test_\uD800\uDC00_\uD840\uDC00_bnode urn:x urn:y>>",
+ "<<( _:test_\uD800\uDC00_\uD840\uDC00_bnode )>>",
+ "<<( _:test_\uD800\uDC00_\uD840\uDC00_bnode urn:x urn:y )>>",
// invalid: missing closing >> for inner triple
- "<<<<_:bnode1foobar\"literál за проба\"^^\"test\\\\\\\"lit\">>",
+ "<<(<<(_:bnode1foobar\"literál за проба\"^^\"test\\\\\\\"lit\">>",
null,
// invalid: missing closing >> for outer triple
- "<<<<_:bnode1foobar\"literál за проба\"^^>>\"test\\\\\\\"lit\"",
+ "<<(<<(_:bnode1foobar\"literál за проба\"^^)>>\"test\\\\\\\"lit\"",
null,
// invalid: literal subject
- "<<\"test\" \"test\">>",
+ "<<(\"test\" \"test\")>>",
null,
// invalid: bnode predicate
- "<< _:test \"test\">>",
+ "<<( _:test \"test\")>>",
null,
// invalid: triple predicate
- "<< << >> >>",
+ "<<( <<( )>> )>>",
null,
// tests with empty literal,
- "<< \"\">>",
- "<