jenkins-bot has submitted this change and it was merged.
Change subject: Simplify statement construction
......................................................................
Simplify statement construction
This adds a tiny DSL for writing terse munger unit tests, plus a bunch
of various support infrastructure for building statements in JUnit
tests.
MungerUnitTest is cleaned up using the above to be a bit more readable.
A similar pattern could be applied to RdfRepositoryIntegrationTests.
Change-Id: If2fc2ba2437592322c76a5655d3c4d1f6987fe0e
---
M .gitignore
A tools/src/test/java/org/wikidata/query/rdf/tool/ExpandedStatementBuilder.java
M tools/src/test/java/org/wikidata/query/rdf/tool/StatementHelper.java
M tools/src/test/java/org/wikidata/query/rdf/tool/rdf/MungerUnitTest.java
4 files changed, 668 insertions(+), 327 deletions(-)
Approvals:
Manybubbles: Looks good to me, approved
jenkins-bot: Verified
diff --git a/.gitignore b/.gitignore
index 7e54b9b..7b09129 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,9 +1,10 @@
-.classpath
-.project
-.settings/
-.metadata/
-target/
+bin/
data/
-*.iml
+.metadata/
+.settings/
+target/
+.classpath
.idea
+*.iml
+.project
**/rules.log
diff --git
a/tools/src/test/java/org/wikidata/query/rdf/tool/ExpandedStatementBuilder.java
b/tools/src/test/java/org/wikidata/query/rdf/tool/ExpandedStatementBuilder.java
new file mode 100644
index 0000000..3f85887
--- /dev/null
+++
b/tools/src/test/java/org/wikidata/query/rdf/tool/ExpandedStatementBuilder.java
@@ -0,0 +1,365 @@
+package org.wikidata.query.rdf.tool;
+
+import static org.hamcrest.Matchers.containsInAnyOrder;
+import static org.hamcrest.Matchers.equalTo;
+import static org.wikidata.query.rdf.tool.StatementHelper.statement;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Random;
+
+import org.hamcrest.Matcher;
+import org.openrdf.model.Statement;
+import org.openrdf.model.Value;
+import org.openrdf.model.impl.LiteralImpl;
+import org.wikidata.query.rdf.common.uri.Ontology;
+import org.wikidata.query.rdf.common.uri.Provenance;
+import org.wikidata.query.rdf.common.uri.RDF;
+import org.wikidata.query.rdf.common.uri.SchemaDotOrg;
+import org.wikidata.query.rdf.common.uri.WikibaseUris;
+
+import com.carrotsearch.randomizedtesting.RandomizedTest;
+
+/**
+ * Builds expanded statements in the style of Wikibase's dump flavored export
or
+ * post-munged. Because this is able to build both styles this amounts to the
+ * best way to test the munger on expanded statements. Its therefore super
+ * important that it faithfully reflects what we expect of the munger.
+ */
+public class ExpandedStatementBuilder {
+ private final List<ExtraInfo> extraInfo = new ArrayList<>();
+ private final Random random;
+ private final WikibaseUris uris;
+ private final String entity;
+ private final String property;
+ private final Object value;
+
+ private boolean includeBasicEntity = true;
+ /**
+ * Version set if includeBasicEntity is true.
+ */
+ private Value version;
+ /**
+ * Date modified set if includeBasicEntity is true.
+ */
+ private Value dateModified;
+ private ExpandedValueInfo expandedValue;
+
+ private String statementUri;
+ private String rank = Ontology.NORMAL_RANK;
+ private boolean bestRank = false;
+
+ /**
+ * Null until its built and then can't be changed.
+ */
+ private List<Statement> statements;
+
+ /*
+ * These are built as part of the build step and used later when
+ * transforming from wikibase style to munged style.
+ */
+ private Statement entityDataAboutDecl;
+ private Statement entityDataVersionDecl;
+ private Statement entityDataDateModifiedDecl;
+ private Statement statementTypeDecl;
+
+ public ExpandedStatementBuilder(Random random, WikibaseUris uris, String
entity, String property, Object value) {
+ this.random = random;
+ this.uris = uris;
+ this.entity = entity;
+ this.property = property;
+ this.value = value;
+ }
+
+ /**
+ * Get the entity of this expanded statement.
+ */
+ public String entity() {
+ return entity;
+ }
+
+ /**
+ * Get the value of this expanded statement.
+ */
+ public Object value() {
+ return value;
+ }
+
+ /**
+ * Should this statement be of best rank?
+ */
+ public ExpandedStatementBuilder bestRank(boolean bestRank) {
+ checkCanChange();
+ this.bestRank = bestRank;
+ return this;
+ }
+
+ /**
+ * Add a reference to this statement.
+ */
+ public ExpandedStatementBuilder reference(String property, Object value) {
+ extraInfo.add(new ReferenceInfo(property, value));
+ return this;
+ }
+
+ /**
+ * Add a qualifier to this statement.
+ */
+ public ExpandedStatementBuilder qualifier(String property, Object value) {
+ extraInfo.add(new QualifierInfo(property, value));
+ return this;
+ }
+
+ /**
+ * Add an expanded value statement to this statement.
+ */
+ public ExpandedStatementBuilder expandedValue(String property, Object
value) {
+ if (expandedValue == null) {
+ expandedValue = new ExpandedValueInfo(this.property, null);
+ extraInfo.add(expandedValue);
+ }
+ expandedValue.entries.add(new ExpandedValueInfoEntry(property, value));
+ return this;
+ }
+
+ /**
+ * Get the results in wikibase style.
+ */
+ public List<Statement> wikibaseStyle() {
+ return built();
+ }
+
+ /**
+ * Get the results in wikibase style but shuffled.
+ */
+ public List<Statement> wikibaseStyleShuffled() {
+ List<Statement> wikibaseStyle = wikibaseStyle();
+ Collections.shuffle(wikibaseStyle, random);
+ return wikibaseStyle;
+ }
+
+ /**
+ * Get the results in munged style.
+ */
+ public List<Statement> mungedStyle() {
+ List<Statement> st = built();
+ if (includeBasicEntity) {
+ st.remove(entityDataAboutDecl);
+ st.remove(entityDataVersionDecl);
+ st.remove(entityDataDateModifiedDecl);
+ statement(st, uris.entity() + entity, SchemaDotOrg.VERSION,
version);
+ statement(st, uris.entity() + entity, SchemaDotOrg.DATE_MODIFIED,
dateModified);
+ }
+ st.remove(statementTypeDecl);
+ for (ExtraInfo e : extraInfo) {
+ e.munge(st);
+ }
+ return st;
+ }
+
+ public List<Matcher<? super Statement>> mungedStyleMatchers() {
+ List<Matcher<? super Statement>> matchers = new ArrayList<>();
+ for (Statement s : mungedStyle()) {
+ matchers.add(equalTo(s));
+ }
+ return matchers;
+ }
+
+ public Matcher<Iterable<? extends Statement>> mungedStyleMatcher() {
+ return containsInAnyOrder(mungedStyleMatchers());
+ }
+
+ private void checkCanChange() {
+ if (statements != null) {
+ throw new IllegalStateException("Result already built");
+ }
+ }
+
+ private List<Statement> built() {
+ if (statements == null) {
+ build();
+ }
+ return new ArrayList<>(statements);
+ }
+
+ private void build() {
+ statements = new ArrayList<>();
+ buildBasicEntityIfNeeded();
+ buildStatement();
+ buildReferenceIfNeeded();
+ }
+
+ private void buildBasicEntityIfNeeded() {
+ if (!includeBasicEntity) {
+ return;
+ }
+ if (version == null) {
+ version = new LiteralImpl("a revision number I promise");
+ }
+ if (dateModified == null) {
+ dateModified = new LiteralImpl("a date I promise");
+ }
+ String entityDataUri = uris.entityData() + entity;
+ entityDataAboutDecl = statement(statements, entityDataUri,
SchemaDotOrg.ABOUT, entity);
+ entityDataVersionDecl = statement(statements, entityDataUri,
SchemaDotOrg.VERSION, version);
+ entityDataDateModifiedDecl = statement(statements, entityDataUri,
SchemaDotOrg.DATE_MODIFIED, dateModified);
+ }
+
+ private void buildStatement() {
+ if (statementUri == null) {
+ statementUri = uris.statement() + entity + "-" + randomId();
+ }
+
+ statement(statements, uris.entity() + entity, uris.entity() +
property, statementUri);
+ statementTypeDecl = statement(statements, statementUri, RDF.TYPE,
Ontology.STATEMENT);
+ statement(statements, statementUri, uris.value() + property, value);
+ statement(statements, statementUri, Ontology.RANK, rank);
+ if (bestRank) {
+ statement(statements, statementUri, Ontology.RANK,
Ontology.BEST_RANK);
+ }
+ }
+
+ private void buildReferenceIfNeeded() {
+ for (ExtraInfo e : extraInfo) {
+ e.build();
+ }
+ }
+
+ private String randomId() {
+ return RandomizedTest.randomAsciiOfLength(10);
+ }
+
+ private abstract class ExtraInfo {
+ protected final String property;
+ protected final Object value;
+
+ public ExtraInfo(String property, Object value) {
+ this.property = property;
+ this.value = value;
+ }
+
+ /**
+ * Build the statements representing this extra.
+ */
+ public abstract void build();
+
+ /**
+ * Perform whatever munging we expect the munger to perform.
+ */
+ public abstract void munge(List<Statement> statements);
+ }
+
+ private abstract class AbstractComplexExtraInfo extends ExtraInfo {
+ protected String uri;
+ private Statement typeDecl;
+
+ public AbstractComplexExtraInfo(String property, Object value) {
+ super(property, value);
+ }
+
+ @Override
+ public void build() {
+ if (uri == null) {
+ uri = namespace() + entity + "-" + randomId();
+ }
+ statement(statements, statementUri, declarationPredicate(), uri);
+ typeDecl = statement(statements, uri, RDF.TYPE, type());
+ }
+
+ @Override
+ public void munge(List<Statement> statements) {
+ statements.remove(typeDecl);
+ }
+
+ protected abstract String namespace();
+
+ protected abstract String declarationPredicate();
+
+ protected abstract String type();
+ }
+
+ private class ReferenceInfo extends AbstractComplexExtraInfo {
+ public ReferenceInfo(String property, Object value) {
+ super(property, value);
+ }
+
+ @Override
+ public void build() {
+ super.build();
+ statement(statements, uri, uris.value() + property, value);
+ }
+
+ @Override
+ protected String namespace() {
+ return uris.reference();
+ }
+
+ @Override
+ protected String declarationPredicate() {
+ return Provenance.WAS_DERIVED_FROM;
+ }
+
+ @Override
+ protected String type() {
+ return Ontology.REFERENCE;
+ }
+ }
+
+ private class QualifierInfo extends ExtraInfo {
+ public QualifierInfo(String property, Object value) {
+ super(property, value);
+ }
+
+ @Override
+ public void build() {
+ statement(statements, statementUri, uris.qualifier() + property,
value);
+ }
+
+ @Override
+ public void munge(List<Statement> statements) {
+ // Intentionally a noop
+ }
+ }
+
+ private class ExpandedValueInfo extends AbstractComplexExtraInfo {
+ private List<ExpandedValueInfoEntry> entries = new ArrayList<>();
+
+ public ExpandedValueInfo(String property, Object value) {
+ super(property, value);
+ }
+
+ @Override
+ public void build() {
+ super.build();
+ for (ExpandedValueInfoEntry e : entries) {
+ statement(statements, uri, e.predicate, e.object);
+ }
+ }
+
+ @Override
+ protected String namespace() {
+ return uris.value();
+ }
+
+ @Override
+ protected String declarationPredicate() {
+ return uris.value() + property + "-value";
+ }
+
+ @Override
+ protected String type() {
+ return Ontology.VALUE;
+ }
+ }
+
+ private static class ExpandedValueInfoEntry {
+ private final String predicate;
+ private final Object object;
+
+ public ExpandedValueInfoEntry(String predicate, Object object) {
+ this.predicate = predicate;
+ this.object = object;
+ }
+ }
+}
diff --git
a/tools/src/test/java/org/wikidata/query/rdf/tool/StatementHelper.java
b/tools/src/test/java/org/wikidata/query/rdf/tool/StatementHelper.java
index 855359d..429a0f8 100644
--- a/tools/src/test/java/org/wikidata/query/rdf/tool/StatementHelper.java
+++ b/tools/src/test/java/org/wikidata/query/rdf/tool/StatementHelper.java
@@ -1,10 +1,15 @@
package org.wikidata.query.rdf.tool;
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.Collection;
import java.util.List;
+import org.openrdf.model.Literal;
import org.openrdf.model.Statement;
import org.openrdf.model.URI;
import org.openrdf.model.Value;
+import org.openrdf.model.impl.IntegerLiteralImpl;
import org.openrdf.model.impl.LiteralImpl;
import org.openrdf.model.impl.StatementImpl;
import org.openrdf.model.impl.URIImpl;
@@ -17,37 +22,37 @@
/**
* Constructs statements for testing.
*/
+/**
+ * @author james
+ *
+ */
public class StatementHelper {
/**
- * Statement constructor taking just URIs as strings.
+ * Statement build helper.
*/
- public static Statement statement(String s, String p, String o) {
- return statement(s, p, uri(o));
+ public static Statement statement(String s, String p, Object o) {
+ Value oValue;
+ if (o instanceof String) {
+ oValue = uri(o.toString());
+ } else if (o instanceof Value) {
+ oValue = (Value) o;
+ } else if (o instanceof Integer) {
+ oValue = new IntegerLiteralImpl(BigInteger.valueOf((int) o));
+ } else if (o instanceof Long) {
+ oValue = new IntegerLiteralImpl(BigInteger.valueOf((long) o));
+ } else {
+ throw new IllegalArgumentException("Illegal object: " + o);
+ }
+ return new StatementImpl(uri(s), uri(p), oValue);
}
/**
- * Statement constructor with a value. Use this one for all values.
+ * Statement build helper.
*/
- public static Statement statement(String s, String p, Value o) {
- return new StatementImpl(uri(s), uri(p), o);
- }
-
- /**
- * Statement constructor taking just URIs as strings and appending the
- * statement to a list.
- */
- public static Statement statement(List<Statement> statements, String s,
String p, String o) {
- return statement(statements, s, p, uri(o));
- }
-
- /**
- * Statement constructor with a value appending the statement to a list.
Use
- * this one for all values.
- */
- public static Statement statement(List<Statement> statements, String s,
String p, Value o) {
- Statement statement = statement(s, p, o);
- statements.add(statement);
- return statement;
+ public static Statement statement(List<Statement> statements, String s,
String p, Object o) {
+ Statement st = statement(s, p, o);
+ statements.add(st);
+ return st;
}
/**
@@ -96,4 +101,27 @@
}
return new URIImpl(r);
}
+
+ /**
+ * Construct statements about a basic entity
+ */
+ public static List<Statement> basicEntity(WikibaseUris uris, String id) {
+ Literal version = new LiteralImpl("a revision number I promise");
+ List<Statement> statements = new ArrayList<>();
+ String entityDataUri = uris.entityData() + id;
+ // EntityData is all munged onto Entity
+ statement(statements, entityDataUri, SchemaDotOrg.ABOUT, id);
+ statement(statements, entityDataUri, SchemaDotOrg.VERSION, version);
+ statement(statements, entityDataUri, SchemaDotOrg.DATE_MODIFIED,
+ new LiteralImpl("a date I promise"));
+ return statements;
+ }
+
+ /**
+ * Convert a collection of statements into an array of statements
+ */
+ public static Statement[] toArray(Collection<Statement> xs) {
+ return xs.toArray(new Statement[xs.size()]);
+ }
+
}
diff --git
a/tools/src/test/java/org/wikidata/query/rdf/tool/rdf/MungerUnitTest.java
b/tools/src/test/java/org/wikidata/query/rdf/tool/rdf/MungerUnitTest.java
index 45eb6e2..e4f4763 100644
--- a/tools/src/test/java/org/wikidata/query/rdf/tool/rdf/MungerUnitTest.java
+++ b/tools/src/test/java/org/wikidata/query/rdf/tool/rdf/MungerUnitTest.java
@@ -1,21 +1,19 @@
package org.wikidata.query.rdf.tool.rdf;
-import static org.hamcrest.Matchers.both;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.hasItem;
import static org.hamcrest.Matchers.not;
import static org.wikidata.query.rdf.tool.StatementHelper.siteLink;
import static org.wikidata.query.rdf.tool.StatementHelper.statement;
+import static org.wikidata.query.rdf.tool.StatementHelper.toArray;
import java.math.BigInteger;
import java.util.ArrayList;
+import java.util.Collections;
import java.util.List;
-import org.hamcrest.Matcher;
-import org.hamcrest.Matchers;
import org.junit.Test;
import org.junit.runner.RunWith;
-import org.openrdf.model.Literal;
import org.openrdf.model.Statement;
import org.openrdf.model.impl.IntegerLiteralImpl;
import org.openrdf.model.impl.LiteralImpl;
@@ -27,352 +25,247 @@
import org.wikidata.query.rdf.common.uri.SKOS;
import org.wikidata.query.rdf.common.uri.SchemaDotOrg;
import org.wikidata.query.rdf.common.uri.WikibaseUris;
-import org.wikidata.query.rdf.tool.exception.ContainedException;
+import org.wikidata.query.rdf.tool.StatementHelper;
import org.wikidata.query.rdf.tool.rdf.Munger.BadSubjectException;
import com.carrotsearch.randomizedtesting.RandomizedRunner;
import com.carrotsearch.randomizedtesting.RandomizedTest;
-import com.google.common.collect.ImmutableList;
/**
* Tests Munger.
*/
@RunWith(RandomizedRunner.class)
public class MungerUnitTest extends RandomizedTest {
- private final WikibaseUris uris = WikibaseUris.WIKIDATA;
- private final Munger munger = new Munger(uris);
+
+ static final WikibaseUris uris = WikibaseUris.WIKIDATA;
+ static final Munger munger = new Munger(uris);
+ static final String bogus = "http://example.com/bogus";;
@Test
- public void mungesEntityDataOntoEntity() throws ContainedException {
- List<Statement> statements = basicEntity("Q23");
- munger.munge("Q23", statements);
- // This Matcher is so hard to build......
- ImmutableList.Builder<Matcher<? super Statement>> matchers =
ImmutableList.builder();
- matchers.add(equalTo(statement("Q23", SchemaDotOrg.VERSION, new
LiteralImpl("a revision number I promise"))));
- matchers.add(equalTo(statement("Q23", SchemaDotOrg.DATE_MODIFIED, new
LiteralImpl("a date I promise"))));
- assertThat(statements, Matchers.<Statement>
containsInAnyOrder(matchers.build()));
+ public void mungesEntityDataOntoEntity() {
+ entity("Q23") //
+ .retain(statement("Q23", SchemaDotOrg.VERSION, new
LiteralImpl("a revision number I promise")), //
+ statement("Q23", SchemaDotOrg.DATE_MODIFIED, new
LiteralImpl("a date I promise"))) //
+ .test();
}
@Test
- public void extraDataIsntModified() throws ContainedException {
- List<Statement> statements = basicEntity("Q23");
- Statement extra = statement(statements, "Q23", "P509", "Q6");
- munger.munge("Q23", statements);
- assertThat(statements, hasItem(extra));
+ public void extraDataIsntModified() {
+ entity("Q23") //
+ .retain(statement("Q23", "P509", "Q6")) //
+ .test();
}
@Test
- public void aItemIsRemoved() throws ContainedException {
- List<Statement> statements = basicEntity("Q23");
- Statement aItemDecl = statement(statements, "Q23", RDF.TYPE,
Ontology.ITEM);
- munger.munge("Q23", statements);
- assertThat(statements, not(hasItem(aItemDecl)));
+ public void aItemIsRemoved() {
+ entity("Q23") //
+ .remove(statement("Q23", RDF.TYPE, Ontology.ITEM)) //
+ .test();
}
@Test(expected = BadSubjectException.class)
- public void complainsAboutExtraSubjects() throws ContainedException {
- List<Statement> statements = basicEntity("Q23");
- statements.add(statement("http://example.com/bogus";, "Q23", "Q23"));
- munger.munge("Q23", statements);
+ public void complainsAboutExtraSubjects() {
+ entity("Q23") //
+ .retain(statement("http://example.com/bogus";, "Q23", "Q23")) //
+ .test();
}
@Test
- public void siteLinksGoThrough() throws ContainedException {
- List<Statement> statements = basicEntity("Q23");
- String bogus = "http://example.com/bogus";;
- Statement articleDecl = statement(bogus, RDF.TYPE,
SchemaDotOrg.ARTICLE);
- Statement metaDecl = statement(bogus, "Q23", new LiteralImpl("Doesn't
matter"));
- if (randomBoolean()) {
- statements.add(articleDecl);
- statements.add(metaDecl);
- } else {
- // Out of order should be ok too
- statements.add(metaDecl);
- statements.add(articleDecl);
- }
- munger.munge("Q23", statements);
- assertThat(statements,
both(hasItem(articleDecl)).and(hasItem(metaDecl)));
+ public void siteLinksGoThrough() {
+ entity("Q23") //
+ .retain(statement(bogus, RDF.TYPE, SchemaDotOrg.ARTICLE), //
+ statement(bogus, "Q23", new LiteralImpl("Doesn't
matter"))) //
+ .test();
}
@Test
- public void extraLabelsRemoved() throws ContainedException {
- List<Statement> george = basicEntity("Q23");
- Statement rdfsDecl = statement(george, "Q23", RDFS.LABEL, new
LiteralImpl("foo", "en"));
- Statement skosDecl = statement(george, "Q23", SKOS.PREF_LABEL, new
LiteralImpl("foo", "en"));
- Statement schemaDecl = statement(george, "Q23", SchemaDotOrg.NAME, new
LiteralImpl("foo", "en"));
- munger.munge("Q23", george);
- assertThat(george, hasItem(rdfsDecl));
- assertThat(george, not(hasItem(skosDecl)));
- assertThat(george, not(hasItem(schemaDecl)));
+ public void extraLabelsRemoved() {
+ entity("Q23") //
+ .retain(statement("Q23", RDFS.LABEL, new LiteralImpl("foo",
"en"))) //
+ .remove(statement("Q23", SKOS.PREF_LABEL, new
LiteralImpl("foo", "en")), //
+ statement("Q23", SchemaDotOrg.NAME, new
LiteralImpl("foo", "en"))) //
+ .test();
}
@Test
- public void labelsOnOthersRemoved() throws ContainedException {
- List<Statement> statements = basicEntity("Q23");
- Statement georgeDecl = statement(statements, "Q23", RDFS.LABEL, new
LiteralImpl("george", "en"));
- Statement marthaDecl = statement(statements, "Q191789", RDFS.LABEL,
new LiteralImpl("martha", "en"));
- munger.munge("Q23", statements);
- assertThat(statements, hasItem(georgeDecl));
- assertThat(statements, not(hasItem(marthaDecl)));
+ public void labelsOnOthersRemoved() {
+ entity("Q23") //
+ .retain(statement("Q23", RDFS.LABEL, new LiteralImpl("george",
"en"))) //
+ .remove(statement("Q191789", RDFS.LABEL, new
LiteralImpl("martha", "en"))) //
+ .test();
}
@Test
- public void basicExpandedStatement() throws ContainedException {
- List<Statement> george = basicEntity("Q23");
+ public void basicExpandedStatement() {
String statementUri = uris.statement() +
"Q23-ce976010-412f-637b-c687-9fd2d52dc140";
- Statement statementTypeDecl = statement(george, statementUri,
RDF.TYPE, Ontology.STATEMENT);
- Statement valueDecl = statement(george, statementUri, uris.value() +
"P509", "Q356405");
- Statement rankDecl = statement(george, statementUri, Ontology.RANK,
Ontology.NORMAL_RANK);
- Statement statementDecl = statement("Q23", "P509", statementUri);
- if (randomBoolean()) {
- george.add(0, statementDecl);
- } else {
- george.add(statementDecl);
- }
- munger.munge("Q23", george);
- assertThat(george, hasItem(statementDecl));
- assertThat(george, not(hasItem(statementTypeDecl)));
- assertThat(george, hasItem(valueDecl));
- assertThat(george, hasItem(rankDecl));
- // TODO can we rewrite the valueDecl into something without the
repeated
- // property?
+ entity("Q23") //
+ // TODO can we rewrite the first statement into something
+ // without the repeated property?
+ .retain(statement(statementUri, uris.value() + "P509",
"Q356405"), //
+ statement(statementUri, Ontology.RANK,
Ontology.NORMAL_RANK), //
+ statement("Q23", "P509", statementUri)) //
+ .remove(statement(statementUri, RDF.TYPE, Ontology.STATEMENT))
//
+ .test();
}
@Test
- public void expandedStatementWithReference() throws ContainedException {
- List<Statement> george = basicEntity("Q23");
+ public void expandedStatementWithReference() {
String statementUri = uris.statement() +
"Q23-9D3713FF-7BCC-489F-9386-C7322C0AC284";
String referenceUri = uris.reference() +
"e36b7373814a0b74caa84a5fc2b1e3297060ab0f";
- Statement statementDecl = statement(george, "Q23", "P19",
statementUri);
- Statement statementTypeDecl = statement(george, statementUri,
RDF.TYPE, Ontology.STATEMENT);
- Statement valueDecl = statement(george, statementUri, uris.value() +
"P19", "Q494413");
- Statement rankDecl = statement(george, statementUri, Ontology.RANK,
Ontology.NORMAL_RANK);
- Statement referenceTypeDecl = statement(george, referenceUri,
RDF.TYPE, Ontology.REFERENCE);
- Statement referenceValueDecl = statement(george, referenceUri,
uris.value() + "P854",
- "http://www.anb.org/articles/02/02-00332.html";);
- Statement referenceDecl = statement(statementUri,
Provenance.WAS_DERIVED_FROM, referenceUri);
- if (randomBoolean()) {
- george.add(0, referenceDecl);
- } else {
- george.add(referenceDecl);
- }
- munger.munge("Q23", george);
- assertThat(george, hasItem(statementDecl));
- assertThat(george, not(hasItem(statementTypeDecl)));
- assertThat(george, hasItem(valueDecl));
- assertThat(george, hasItem(rankDecl));
- assertThat(george, hasItem(referenceDecl));
- assertThat(george, not(hasItem(referenceTypeDecl)));
- assertThat(george, hasItem(referenceValueDecl));
+ entity("Q23") //
+ .retain(statement("Q23", "P19", statementUri), //
+ statement(statementUri, uris.value() + "P19",
"Q494413"), //
+ statement(statementUri, Ontology.RANK,
Ontology.NORMAL_RANK), //
+ statement(referenceUri, uris.value() + "P854",
"http://www.anb.org/articles/02/02-00332.html";), //
+ statement(statementUri, Provenance.WAS_DERIVED_FROM,
referenceUri)) //
+ .remove(statement(statementUri, RDF.TYPE, Ontology.STATEMENT),
//
+ statement(referenceUri, RDF.TYPE, Ontology.REFERENCE))
//
+ .test();
}
@Test
- public void expandedStatementWithQualifier() throws ContainedException {
- List<Statement> george = basicEntity("Q23");
+ public void expandedStatementWithQualifier() {
String statementUri = uris.statement() +
"q23-8A2F4718-6159-4E58-A8F9-6F24F5EFEC42";
- Statement statementDecl = statement(george, "Q23", "P26",
statementUri);
- Statement statementTypeDecl = statement(george, statementUri,
RDF.TYPE, Ontology.STATEMENT);
- Statement valueDecl = statement(george, statementUri, uris.value() +
"P26", "Q191789");
- Statement rankDecl = statement(george, statementUri, Ontology.RANK,
Ontology.NORMAL_RANK);
- Statement qualifierDecl = statement(george, statementUri,
uris.qualifier() + "P580",
- new LiteralImpl("1759-01-06T00:00:00Z", XMLSchema.DATETIME));
- munger.munge("Q23", george);
- assertThat(george, hasItem(statementDecl));
- assertThat(george, not(hasItem(statementTypeDecl)));
- assertThat(george, hasItem(valueDecl));
- assertThat(george, hasItem(rankDecl));
- assertThat(george, hasItem(qualifierDecl));
+ entity("Q23") //
+ .retain(statement("Q23", "P26", statementUri), //
+ statement(statementUri, uris.value() + "P26",
"Q191789"), //
+ statement(statementUri, Ontology.RANK,
Ontology.NORMAL_RANK), //
+ statement(statementUri, uris.qualifier() + "P580", new
LiteralImpl("1759-01-06T00:00:00Z", XMLSchema.DATETIME))) //
+ .remove(statement(statementUri, RDF.TYPE, Ontology.STATEMENT))
//
+ .test();
}
@Test
public void basicExpandedValue() {
- List<Statement> universe = basicEntity("Q1");
String statementUri = uris.statement() + "q1-someuuid";
String valueUri = uris.value() + "someotheruuid";
- Statement statementDecl = statement(universe, "Q1", "P580",
statementUri);
- Statement statementTypeDecl = statement(universe, statementUri,
RDF.TYPE, Ontology.STATEMENT);
- Statement valueDecl = statement(universe, statementUri, uris.value() +
"P580",
- new LiteralImpl("-13798000000-01-01T00:00:00Z",
XMLSchema.DATETIME));
- Statement expandedValueDecl = statement(universe, statementUri,
uris.value() + "P580"
- + "-value", valueUri);
- Statement expandedValueTypeDecl = statement(universe, valueUri,
RDF.TYPE, Ontology.VALUE);
- /*
- * Currently wikibase exports the deep time values as strings, not
- * dateTime.
- */
- Statement expandedValueValueDecl = statement(universe, valueUri,
Ontology.Time.VALUE,
- "-13798000000-01-01T00:00:00Z");
- Statement expandedValuePrecisionDecl = statement(universe, valueUri,
Ontology.Time.PRECISION,
- new IntegerLiteralImpl(BigInteger.valueOf(3)));
- Statement expandedValueTimezoneDecl = statement(universe, valueUri,
Ontology.Time.TIMEZONE,
- new IntegerLiteralImpl(BigInteger.valueOf(0)));
- Statement expandedValueCalendarModelDecl = statement(universe,
valueUri, Ontology.Time.CALENDAR_MODEL,
- "Q1985727");
- munger.munge("Q1", universe);
- assertThat(universe, hasItem(statementDecl));
- assertThat(universe, not(hasItem(statementTypeDecl)));
- assertThat(universe, hasItem(valueDecl));
- assertThat(universe, hasItem(expandedValueDecl));
- assertThat(universe, not(hasItem(expandedValueTypeDecl)));
- assertThat(universe, hasItem(expandedValueDecl));
- assertThat(universe, hasItem(expandedValueValueDecl));
- assertThat(universe, hasItem(expandedValuePrecisionDecl));
- assertThat(universe, hasItem(expandedValueTimezoneDecl));
- assertThat(universe, hasItem(expandedValueCalendarModelDecl));
+ entity("Q1") //
+ .retain(statement("Q1", "P580", statementUri), //
+ statement(statementUri, uris.value() + "P580", new
LiteralImpl("-13798000000-01-01T00:00:00Z", XMLSchema.DATETIME)), //
+ statement(statementUri, uris.value() + "P580" +
"-value", valueUri), //
+ // Currently wikibase exports the deep time values as
+ // strings, not dateTime.
+ statement(valueUri, Ontology.Time.VALUE,
"-13798000000-01-01T00:00:00Z"), //
+ statement(valueUri, Ontology.Time.PRECISION, new
IntegerLiteralImpl(BigInteger.valueOf(3))), //
+ statement(valueUri, Ontology.Time.TIMEZONE, new
IntegerLiteralImpl(BigInteger.valueOf(0))), //
+ statement(valueUri, Ontology.Time.CALENDAR_MODEL,
"Q1985727")) //
+ .remove(statement(statementUri, RDF.TYPE, Ontology.STATEMENT),
//
+ statement(valueUri, RDF.TYPE, Ontology.VALUE)) //
+ .testWithoutShuffle();
+
}
@Test
public void expandedValueOnQualifier() {
- List<Statement> universe = basicEntity("Q1");
String statementUri = uris.statement() + "q1-someuuid";
String valueUri = uris.value() + "someotheruuid";
- Statement statementDecl = statement(universe, "Q1", "P580",
statementUri);
- Statement statementTypeDecl = statement(universe, statementUri,
RDF.TYPE, Ontology.STATEMENT);
- Statement valueDecl = statement(universe, statementUri,
uris.qualifier() + "P580",
- new LiteralImpl("-13798000000-01-01T00:00:00Z",
XMLSchema.DATETIME));
- Statement expandedValueDecl = statement(universe, statementUri,
uris.value() + "P580"
- + "-value", valueUri);
- Statement expandedValueTypeDecl = statement(universe, valueUri,
RDF.TYPE, Ontology.VALUE);
- /*
- * Currently wikibase exports the deep time values as strings, not
- * dateTime.
- */
- Statement expandedValueValueDecl = statement(universe, valueUri,
Ontology.Time.VALUE,
- "-13798000000-01-01T00:00:00Z");
- Statement expandedValuePrecisionDecl = statement(universe, valueUri,
Ontology.Time.PRECISION,
- new IntegerLiteralImpl(BigInteger.valueOf(3)));
- Statement expandedValueTimezoneDecl = statement(universe, valueUri,
Ontology.Time.TIMEZONE,
- new IntegerLiteralImpl(BigInteger.valueOf(0)));
- Statement expandedValueCalendarModelDecl = statement(universe,
valueUri, Ontology.Time.CALENDAR_MODEL,
- "Q1985727");
- munger.munge("Q1", universe);
- assertThat(universe, hasItem(statementDecl));
- assertThat(universe, not(hasItem(statementTypeDecl)));
- assertThat(universe, hasItem(valueDecl));
- assertThat(universe, hasItem(expandedValueDecl));
- assertThat(universe, not(hasItem(expandedValueTypeDecl)));
- assertThat(universe, hasItem(expandedValueDecl));
- assertThat(universe, hasItem(expandedValueValueDecl));
- assertThat(universe, hasItem(expandedValuePrecisionDecl));
- assertThat(universe, hasItem(expandedValueTimezoneDecl));
- assertThat(universe, hasItem(expandedValueCalendarModelDecl));
+ entity("Q1") //
+ .retain(statement("Q1", "P580", statementUri), //
+ statement(statementUri, uris.qualifier() + "P580", new
LiteralImpl("-13798000000-01-01T00:00:00Z", XMLSchema.DATETIME)), //
+ statement(statementUri, uris.value() + "P580" +
"-value", valueUri), //
+ // Currently wikibase exports the deep time values as
+ // strings, not dateTime.
+ statement(valueUri, Ontology.Time.VALUE,
"-13798000000-01-01T00:00:00Z"), //
+ statement(valueUri, Ontology.Time.PRECISION, new
IntegerLiteralImpl(BigInteger.valueOf(3))), //
+ statement(valueUri, Ontology.Time.TIMEZONE, new
IntegerLiteralImpl(BigInteger.valueOf(0))), //
+ statement(valueUri, Ontology.Time.CALENDAR_MODEL,
"Q1985727")) //
+ .remove(statement(statementUri, RDF.TYPE, Ontology.STATEMENT),
//
+ statement(valueUri, RDF.TYPE, Ontology.VALUE)) //
+ .testWithoutShuffle();
}
@Test
public void basicExpandedValueOnReference() {
- List<Statement> universe = basicEntity("Q1");
String statementUri = uris.statement() + "q1-someuuid";
String valueUri = uris.value() + "someotheruuid";
String referenceUri = uris.reference() + "yetanotheruuid";
- Statement statementDecl = statement(universe, "Q1", "P580",
statementUri);
- Statement statementTypeDecl = statement(universe, statementUri,
RDF.TYPE, Ontology.STATEMENT);
- Statement valueDecl = statement(universe, statementUri, uris.value() +
"P580",
- new LiteralImpl("-13798000000-01-01T00:00:00Z",
XMLSchema.DATETIME));
- Statement referenceDecl = statement(universe, statementUri,
Provenance.WAS_DERIVED_FROM, referenceUri);
- Statement referenceTypeDecl = statement(universe, referenceUri,
RDF.TYPE, Ontology.REFERENCE);
- Statement expandedValueDecl = statement(universe, referenceUri,
uris.value() + "P580"
- + "-value", valueUri);
- Statement expandedValueTypeDecl = statement(universe, valueUri,
RDF.TYPE, Ontology.VALUE);
- /*
- * Currently wikibase exports the deep time values as strings, not
- * dateTime.
- */
- Statement expandedValueValueDecl = statement(universe, valueUri,
Ontology.Time.VALUE,
- "-13798000000-01-01T00:00:00Z");
- Statement expandedValuePrecisionDecl = statement(universe, valueUri,
Ontology.Time.PRECISION,
- new IntegerLiteralImpl(BigInteger.valueOf(3)));
- Statement expandedValueTimezoneDecl = statement(universe, valueUri,
Ontology.Time.TIMEZONE,
- new IntegerLiteralImpl(BigInteger.valueOf(0)));
- Statement expandedValueCalendarModelDecl = statement(universe,
valueUri, Ontology.Time.CALENDAR_MODEL,
- "Q1985727");
- munger.munge("Q1", universe);
- assertThat(universe, hasItem(statementDecl));
- assertThat(universe, not(hasItem(statementTypeDecl)));
- assertThat(universe, hasItem(valueDecl));
- assertThat(universe, hasItem(referenceDecl));
- assertThat(universe, not(hasItem(referenceTypeDecl)));
- assertThat(universe, hasItem(expandedValueDecl));
- assertThat(universe, not(hasItem(expandedValueTypeDecl)));
- assertThat(universe, hasItem(expandedValueDecl));
- assertThat(universe, hasItem(expandedValueValueDecl));
- assertThat(universe, hasItem(expandedValuePrecisionDecl));
- assertThat(universe, hasItem(expandedValueTimezoneDecl));
- assertThat(universe, hasItem(expandedValueCalendarModelDecl));
+ entity("Q1") //
+ .retain(statement("Q1", "P580", statementUri), //
+ statement(statementUri, uris.value() + "P580", new
LiteralImpl("-13798000000-01-01T00:00:00Z", XMLSchema.DATETIME)), //
+ statement(statementUri, Provenance.WAS_DERIVED_FROM,
referenceUri), //
+ statement(referenceUri, uris.value() + "P580" +
"-value", valueUri), //
+ // Currently wikibase exports the deep time values as
+ // strings, not dateTime.
+ statement(valueUri, Ontology.Time.VALUE,
"-13798000000-01-01T00:00:00Z"), //
+ statement(valueUri, Ontology.Time.PRECISION, new
IntegerLiteralImpl(BigInteger.valueOf(3))), //
+ statement(valueUri, Ontology.Time.TIMEZONE, new
IntegerLiteralImpl(BigInteger.valueOf(0))), //
+ statement(valueUri, Ontology.Time.CALENDAR_MODEL,
"Q1985727")) //
+ .remove(statement(statementUri, RDF.TYPE, Ontology.STATEMENT),
//
+ statement(referenceUri, RDF.TYPE, Ontology.REFERENCE),
//
+ statement(valueUri, RDF.TYPE, Ontology.VALUE)) //
+ .testWithoutShuffle();
}
+
// TODO somevalue and novalue
// TODO badges
@Test
- public void limitLanguagesLabel() throws ContainedException {
+ public void limitLanguagesLabel() {
limitLanguagesTestCase(RDFS.LABEL);
}
@Test
- public void limitLanguagesDescription() throws ContainedException {
+ public void limitLanguagesDescription() {
limitLanguagesTestCase(SchemaDotOrg.DESCRIPTION);
}
@Test
- public void limitLanguagesAlias() throws ContainedException {
+ public void limitLanguagesAlias() {
limitLanguagesTestCase(SKOS.ALT_LABEL);
}
- private void limitLanguagesTestCase(String predicate) throws
ContainedException {
- List<Statement> george = basicEntity("Q23");
- Statement enLabel = statement(george, "Q23", predicate, new
LiteralImpl("foo", "en"));
- Statement deLabel = statement(george, "Q23", predicate, new
LiteralImpl("foo", "de"));
- Statement itLabel = statement(george, "Q23", predicate, new
LiteralImpl("foo", "it"));
- Statement frLabel = statement(george, "Q23", predicate, new
LiteralImpl("foo", "fr"));
- munger.limitLabelLanguages("en", "de").munge("Q23", george);
- assertThat(george, not(hasItem(itLabel)));
- assertThat(george, not(hasItem(frLabel)));
- assertThat(george, hasItem(enLabel));
- assertThat(george, hasItem(deLabel));
+ private void limitLanguagesTestCase(String predicate) {
+ entity("Q23") //
+ .retain(statement("Q23", predicate, new LiteralImpl("foo",
"en")), //
+ statement("Q23", predicate, new LiteralImpl("foo",
"de")))//
+ .remove(statement("Q23", predicate, new LiteralImpl("foo",
"it")), //
+ statement("Q23", predicate, new LiteralImpl("foo",
"fr"))) //
+ .limitLabelLanguages("en", "de") //
+ .testWithoutShuffle();
}
@Test
- public void singleLabelModeLabel() throws ContainedException {
- singleLabelModeTestCase(RDFS.LABEL);
+ public void singleLabelModeLabel() {
+ singleLabelModeTestCases(RDFS.LABEL);
}
@Test
- public void singleLabelModeDescription() throws ContainedException {
- singleLabelModeTestCase(SchemaDotOrg.DESCRIPTION);
+ public void singleLabelModeDescription() {
+ singleLabelModeTestCases(SchemaDotOrg.DESCRIPTION);
}
- private void singleLabelModeTestCase(String predicate) throws
ContainedException {
- List<Statement> george = basicEntity("Q23");
- Statement enLabel = statement(george, "Q23", predicate, new
LiteralImpl("foo", "en"));
- Statement deLabel = statement(george, "Q23", predicate, new
LiteralImpl("foo", "de"));
- Statement itLabel = statement(george, "Q23", predicate, new
LiteralImpl("foo", "it"));
- Statement frLabel = statement(george, "Q23", predicate, new
LiteralImpl("foo", "fr"));
- /*
- * Extra garbage entityData information shouldn't break the single
label
- * mode.
- */
- if (randomBoolean()) {
- george.addAll(basicEntity("Q44"));
- }
- if (randomBoolean()) {
- george.addAll(0, basicEntity("Q78"));
- }
- /*
- * Neither should labels for other entities.
- */
- if (randomBoolean()) {
- Statement sneaky = statement("Q2344", predicate, new
LiteralImpl("sneaky", "en"));
- george.add(sneaky);
- }
- List<Statement> otherGeorge = new ArrayList<>(george);
- munger.singleLabelMode("en", "de").munge("Q23", george);
- assertThat(george, hasItem(enLabel));
- assertThat(george, not(hasItem(itLabel)));
- assertThat(george, not(hasItem(frLabel)));
- assertThat(george, not(hasItem(deLabel)));
- george = otherGeorge;
- munger.singleLabelMode("ja").munge("Q23", george);
- // There aren't any labels if none are in the languages
- for (Statement statement : george) {
+ private void singleLabelModeTestCases(String predicate) {
+ List<Statement> toRemove = new ArrayList<Statement>();
+ Collections.addAll(toRemove,//
+ statement("Q23", predicate, new LiteralImpl("foo", "de")), //
+ statement("Q23", predicate, new LiteralImpl("foo", "it")), //
+ statement("Q23", predicate, new LiteralImpl("foo", "fr")));
+ // Extra garbage entityData information shouldn't break the single
label
+ // mode.
+ Collections.addAll(toRemove, statements(entity("Q44")));
+ Collections.addAll(toRemove, statements(entity("Q78")));
+ // Neither should labels for other entities.
+ Collections.addAll(toRemove, statement("Q2344", predicate, new
LiteralImpl("sneaky", "en")));
+ singleLabelModeTestCase1(predicate, toArray(toRemove));
+ singleLabelModeTestCase2(predicate, toArray(toRemove));
+ }
+
+ private void singleLabelModeTestCase1(String predicate, Statement[]
toRemove) {
+ entity("Q23") //
+ .retain(statement("Q23", predicate, new LiteralImpl("foo",
"en"))) //
+ .remove(toRemove) //
+ .singleLabelMode("en", "de") //
+ .test();
+ }
+
+ private void singleLabelModeTestCase2(String predicate, Statement[]
toRemove) {
+ List<Statement> statements = entity("Q23") //
+ .remove(statement("Q23", predicate, new LiteralImpl("foo",
"en"))) //
+ .remove(toRemove) //
+ .singleLabelMode("ja") //
+ .test();
+ for (Statement statement : statements) {
+ // There aren't any labels if none are in the languages
assertThat(statement.getPredicate().stringValue(),
not(equalTo(RDFS.LABEL)));
}
}
@@ -382,42 +275,96 @@
* doing both is that sometimes statements are removed twice.
*/
@Test
- public void singleLabelAndLimitLanguage() throws ContainedException {
- List<Statement> george = basicEntity("Q23");
- Statement enLabel = statement(george, "Q23", RDFS.LABEL, new
LiteralImpl("foo", "en"));
- Statement deLabel = statement(george, "Q23", RDFS.LABEL, new
LiteralImpl("foo", "de"));
- Statement itLabel = statement(george, "Q23", RDFS.LABEL, new
LiteralImpl("foo", "it"));
- Statement frLabel = statement(george, "Q23", RDFS.LABEL, new
LiteralImpl("foo", "fr"));
- munger.singleLabelMode("en",
"de").limitLabelLanguages("en").munge("Q23", george);
- assertThat(george, hasItem(enLabel));
- assertThat(george, not(hasItem(itLabel)));
- assertThat(george, not(hasItem(frLabel)));
- assertThat(george, not(hasItem(deLabel)));
+ public void singleLabelAndLimitLanguage() {
+ entity("Q23") //
+ .retain(statement("Q23", RDFS.LABEL, new LiteralImpl("foo",
"en"))) //
+ .remove(statement("Q23", RDFS.LABEL, new LiteralImpl("foo",
"de")), //
+ statement("Q23", RDFS.LABEL, new LiteralImpl("foo",
"it")), //
+ statement("Q23", RDFS.LABEL, new LiteralImpl("foo",
"fr"))) //
+ .singleLabelMode("en", "de") //
+ .limitLabelLanguages("en")//
+ .test();
}
@Test
- public void skipSiteLinks() throws ContainedException {
- List<Statement> siteLink = siteLink("Q23",
"http://en.wikipedia.org/wiki/George_Washington";, "en",
- randomBoolean());
- List<Statement> george = basicEntity("Q23");
- george.addAll(siteLink);
- munger.removeSiteLinks().munge("Q23", george);
- for (Statement siteLinkPart : siteLink) {
- assertThat(george, not(hasItem(siteLinkPart)));
+ public void skipSiteLinks() {
+ entity("Q23") //
+ .remove(toArray(siteLink("Q23",
"http://en.wikipedia.org/wiki/George_Washington";, "en", randomBoolean()))) //
+ .removeSiteLinks() //
+ .test();
+ }
+
+ static Statement[] statements(Mungekin x) {
+ return toArray(x.statements);
+ }
+
+ Mungekin entity(String id) {
+ return new Mungekin(MungerUnitTest.uris, id);
+ }
+
+ class Mungekin {
+
+ private final String id;
+ private final List<Statement> statements;
+ private final List<Statement> toRetain = new ArrayList<Statement>();
+ private final List<Statement> toRemove = new ArrayList<Statement>();
+
+ // Keep our very own Munger instance so we don't conflict with external
+ // references.
+ private Munger munger;
+
+ Mungekin(WikibaseUris uris, String id) {
+ this.id = id;
+ munger = new Munger(uris);
+ statements = StatementHelper.basicEntity(uris, id);
}
+
+ private Mungekin addTo(List<Statement> list, Statement... xs) {
+ for (Statement x : xs) {
+ list.add(x);
+ }
+ return this;
+ }
+
+ Mungekin retain(Statement... xs) {
+ return addTo(statements, xs).addTo(toRetain, xs);
+ }
+
+ Mungekin remove(Statement... xs) {
+ return addTo(statements, xs).addTo(toRemove, xs);
+ }
+
+ Mungekin singleLabelMode(String... xs) {
+ munger = munger.singleLabelMode(xs);
+ return this;
+ }
+
+ Mungekin limitLabelLanguages(String... xs) {
+ munger = munger.limitLabelLanguages(xs);
+ return this;
+ }
+
+ Mungekin removeSiteLinks() {
+ munger = munger.removeSiteLinks();
+ return this;
+ }
+
+ List<Statement> test() {
+ Collections.shuffle(statements);
+ testWithoutShuffle();
+ return statements;
+ }
+
+ void testWithoutShuffle() {
+ munger.munge(id, statements);
+ for (Statement x : toRetain) {
+ assertThat(statements, hasItem(x));
+ }
+ for (Statement x : toRemove) {
+ assertThat(statements, not(hasItem(x)));
+ }
+ }
+
}
- private List<Statement> basicEntity(String entityId) {
- return basicEntity(entityId, new LiteralImpl("a revision number I
promise"));
- }
-
- private List<Statement> basicEntity(String entityId, Literal version) {
- List<Statement> statements = new ArrayList<>();
- String entityDataUri = uris.entityData() + entityId;
- // EntityData is all munged onto Entity
- statement(statements, entityDataUri, SchemaDotOrg.ABOUT, entityId);
- statement(statements, entityDataUri, SchemaDotOrg.VERSION, version);
- statement(statements, entityDataUri, SchemaDotOrg.DATE_MODIFIED, new
LiteralImpl("a date I promise"));
- return statements;
- }
-}
+}
\ No newline at end of file
--
To view, visit https://gerrit.wikimedia.org/r/203154
To unsubscribe, visit https://gerrit.wikimedia.org/r/settings
Gerrit-MessageType: merged
Gerrit-Change-Id: If2fc2ba2437592322c76a5655d3c4d1f6987fe0e
Gerrit-PatchSet: 15
Gerrit-Project: wikidata/query/rdf
Gerrit-Branch: master
Gerrit-Owner: Manybubbles <[email protected]>
Gerrit-Reviewer: Jdouglas <[email protected]>
Gerrit-Reviewer: Manybubbles <[email protected]>
Gerrit-Reviewer: jenkins-bot <>
_______________________________________________
MediaWiki-commits mailing list
[email protected]
https://lists.wikimedia.org/mailman/listinfo/mediawiki-commits
