From 4d3d5c8334606174cc2a5522831b685daaa102eb Mon Sep 17 00:00:00 2001 From: Blake Regalia Date: Sat, 10 Jul 2021 13:16:46 -0700 Subject: [PATCH 1/5] feat: Plain and Star interfaces, Roles and Patterns --- data-model.d.ts | 159 ++++++++++++++++++++++++++++++++++-------------- dataset.d.ts | 27 ++++---- stream.d.ts | 17 +++--- 3 files changed, 133 insertions(+), 70 deletions(-) diff --git a/data-model.d.ts b/data-model.d.ts index f2a3b38..a9d594d 100644 --- a/data-model.d.ts +++ b/data-model.d.ts @@ -8,9 +8,9 @@ * @see Literal * @see Variable * @see DefaultGraph - * @see Quad + * @see PlainQuad */ -export type Term = NamedNode | BlankNode | Literal | Variable | DefaultGraph | BaseQuad; +export type Term = NamedNode | BlankNode | Literal | Variable | DefaultGraph | StarQuad; /** * Contains an IRI. @@ -58,7 +58,7 @@ export interface BlankNode { /** * An RDF literal, containing a string with an optional language tag and/or datatype. */ -export interface Literal { +export interface Literal { /** * Contains the constant "Literal". */ @@ -76,7 +76,7 @@ export interface Literal { /** * A NamedNode whose IRI represents the datatype of the literal. */ - datatype: NamedNode; + datatype: Datatype; /** * @param other The term to compare with. @@ -127,38 +127,86 @@ export interface DefaultGraph { equals(other: Term | null | undefined): boolean; } + /** - * The subject, which is a NamedNode, BlankNode or Variable. - * @see NamedNode - * @see BlankNode - * @see Variable + * Type to be unioned with term types for forming role-specific pattern types */ -export type Quad_Subject = NamedNode | BlankNode | Quad | Variable; +export type TermPattern = Variable | null; + /** - * The predicate, which is a NamedNode or Variable. - * @see NamedNode - * @see Variable + * Unions of Term types for the various roles they play in 'plain' RDF 1.1 Data */ -export type Quad_Predicate = NamedNode | Variable; + export namespace PlainRole { + export type Subject = NamedNode | BlankNode; + export type Predicate = NamedNode; + export type Object = NamedNode | BlankNode | Literal; + export type Graph = DefaultGraph | NamedNode | BlankNode; + export type Datatype = NamedNode; + export type Quad = PlainQuad; + } /** - * The object, which is a NamedNode, Literal, BlankNode or Variable. - * @see NamedNode - * @see Literal - * @see BlankNode - * @see Variable + * Unions of Term types for the various */ -export type Quad_Object = NamedNode | Literal | BlankNode | Quad | Variable; + export namespace PlainPatern { + export type Subject = PlainRole.Subject | TermPattern; + export type Predicate = PlainRole.Predicate | TermPattern; + export type Object = PlainRole.Object | TermPattern; + export type Graph = PlainRole.Graph | TermPattern; + export type Datatype = PlainRole.Datatype | TermPattern; + export type Quad = PlainQuad | TermPattern; + } + /** - * The named graph, which is a DefaultGraph, NamedNode, BlankNode or Variable. - * @see DefaultGraph - * @see NamedNode - * @see BlankNode - * @see Variable + * Unions of Term types for the various roles they play in RDF-star data + */ + export namespace StarRole { + export type Subject = PlainRole.Subject | StarQuad; + export type Predicate = PlainRole.Predicate; + export type Object = NamedNode | BlankNode | Literal | StarQuad; + export type Graph = PlainRole.Graph; + export type Datatype = PlainRole.Datatype; + export type Quad = StarQuad; + } + +/** + * Unions of Term types for the various + */ +export namespace StarPatern { + export type Subject = StarRole.Subject | TermPattern; + export type Predicate = StarRole.Predicate | TermPattern; + export type Object = StarRole.Object | TermPattern; + export type Graph = StarRole.Graph | TermPattern; + export type Datatype = StarRole.Datatype | TermPattern; + export type Quad = StarQuad | TermPattern; +} + + +/** + * The subject, which is a NamedNode, BlankNode or Variable. + * @deprecated Consider using one of the following types instead: @see StarRole.Subject, @see StarPattern.Subject, @see PlainRole.Subject, or @see PlainPatern.Subject */ -export type Quad_Graph = DefaultGraph | NamedNode | BlankNode | Variable; +export type Quad_Subject = StarRole.Subject | Variable; + + /** + * The predicate, which is a NamedNode or Variable. + * @deprecated Consider using one of the following types instead: @see StarRole.Predicate, @see StarPattern.Predicate, @see PlainRole.Predicate, or @see PlainPatern.Predicate + */ +export type Quad_Predicate = StarRole.Predicate | Variable; + + /** + * The object, which is a NamedNode, Literal, BlankNode or Variable. + * @deprecated Consider using one of the following types instead: @see StarRole.Object, @see StarPattern.Object, @see PlainRole.Object, or @see PlainPatern.Object + */ +export type Quad_Object = StarRole.Object | Variable; + + /** + * The named graph, which is a DefaultGraph, NamedNode, BlankNode or Variable. + * @deprecated Consider using one of the following types instead: @see StarRole.Graph, @see StarPattern.Graph, @see PlainRole.Graph, or @see PlainPatern.Graph + */ +export type Quad_Graph = StarRole.Graph | Variable; /** * An RDF quad, taking any Term in its positions, containing the subject, predicate, object and graph terms. @@ -175,22 +223,18 @@ export interface BaseQuad { /** * The subject. - * @see Quad_Subject */ subject: Term; /** * The predicate. - * @see Quad_Predicate */ predicate: Term; /** * The object. - * @see Quad_Object */ object: Term; /** * The named graph. - * @see Quad_Graph */ graph: Term; @@ -204,39 +248,60 @@ export interface BaseQuad { /** * An RDF quad, containing the subject, predicate, object and graph terms. */ -export interface Quad extends BaseQuad { +export interface StarQuad extends BaseQuad { /** * The subject. - * @see Quad_Subject + * @see StarRole.Subject */ - subject: Quad_Subject; + subject: StarRole.Subject; /** * The predicate. - * @see Quad_Predicate + * @see StarRole.Predicate */ - predicate: Quad_Predicate; + predicate: StarRole.Predicate; /** * The object. - * @see Quad_Object + * @see StarRole.Object */ - object: Quad_Object; + object: StarRole.Object; /** * The named graph. - * @see Quad_Graph + * @see StarRole.Graph */ - graph: Quad_Graph; + graph: StarRole.Graph; +} +/** + * An RDF quad, containing the subject, predicate, object and graph terms. + */ +export interface PlainQuad extends StarQuad { /** - * @param other The term to compare with. - * @return True if and only if the argument is a) of the same type b) has all components equal. + * The subject. + * @see PlainRole.Subject */ - equals(other: Term | null | undefined): boolean; + subject: PlainRole.Subject; + /** + * The predicate. + * @see PlainRole.Predicate + */ + predicate: PlainRole.Predicate; + /** + * The object. + * @see PlainRole.Object + */ + object: PlainRole.Object; + /** + * The named graph. + * @see PlainRole.Graph + */ + graph: PlainRole.Graph; } + /** * A factory for instantiating RDF terms and quads. */ -export interface DataFactory { +export interface DataFactory { /** * @param value The IRI for the named node. * @return A new instance of NamedNode. @@ -256,10 +321,10 @@ export interface DataFactory { + +export interface DatasetCore { /** * A non-negative integer that specifies the number of quads in the set. */ @@ -42,19 +43,19 @@ export interface DatasetCore; + match(subject?: InQuad['subject'] | TermPattern, predicate?: InQuad['predicate'] | TermPattern, object?: InQuad['object'] | TermPattern, graph?: InQuad['graph'] | TermPattern): DatasetCore; [Symbol.iterator](): Iterator; } -export interface DatasetCoreFactory = DatasetCore> { +export interface DatasetCoreFactory = DatasetCore> { /** * Returns a new dataset and imports all quads, if given. */ dataset(quads?: InQuad[]): D; } -export interface Dataset extends DatasetCore { +export interface Dataset extends DatasetCore { /** * Imports the quads into this dataset. * @@ -82,7 +83,7 @@ export interface Dataset): Dataset; - - match(subject?: Term | null, predicate?: Term | null, object?: Term | null, graph?: Term | null): Dataset; } -export interface DatasetFactory = Dataset> +export interface DatasetFactory = Dataset> extends DatasetCoreFactory { /** * Returns a new dataset and imports all quads, if given. */ - dataset(quads?: Dataset|InQuad[]): D; + dataset(quads?: Dataset | InQuad[]): D; } -export interface QuadFilterIteratee { +export interface QuadFilterIteratee { /** * A callable function that returns `true` if the input quad passes the test this function implements. */ test(quad: Q, dataset: Dataset): boolean; } -export interface QuadMapIteratee { +export interface QuadMapIteratee { /** * A callable function that can be executed on a quad and returns a quad. * @@ -219,14 +218,14 @@ export interface QuadMapIteratee { map(quad: Q, dataset: Dataset): Q; } -export interface QuadReduceIteratee { +export interface QuadReduceIteratee { /** * A callable function that can be executed on an accumulator and quad and returns a new accumulator. */ run(accumulator: A, quad: Q, dataset: Dataset): A; } -export interface QuadRunIteratee { +export interface QuadRunIteratee { /** * A callable function that can be executed on a quad. */ diff --git a/stream.d.ts b/stream.d.ts index bc78df6..ea70eaa 100644 --- a/stream.d.ts +++ b/stream.d.ts @@ -1,10 +1,9 @@ /* Stream Interfaces */ /* https://rdf.js.org/stream-spec/ */ -import * as stream from "stream"; import { EventEmitter } from "events"; -import { BaseQuad, Quad, Term } from './data-model'; +import { BaseQuad, StarQuad, TermPattern } from './data-model'; /** * A quad stream. @@ -19,7 +18,7 @@ import { BaseQuad, Quad, Term } from './data-model'; * Optional events: * * prefix(prefix: string, iri: RDF.NamedNode): This event is emitted every time a prefix is mapped to some IRI. */ -export interface Stream extends EventEmitter { +export interface Stream extends EventEmitter { /** * This method pulls a quad out of the internal buffer and returns it. * If there is no quad available, then it will return null. @@ -36,7 +35,7 @@ export interface Stream extends EventEmitter { * * For example, parsers and transformations which generate quads can implement the Source interface. */ -export interface Source { +export interface Source { /** * Returns a stream that processes all quads matching the pattern. * @@ -46,7 +45,7 @@ export interface Source { * @param graph The optional graph. * @return The resulting quad stream. */ - match(subject?: Term | null, predicate?: Term | null, object?: Term | null, graph?: Term | null): Stream; + match(subject?: InQuad['subject'] | TermPattern, predicate?: InQuad['predicate'] | TermPattern, object?: InQuad['object'] | TermPattern, graph?: InQuad['graph'] | TermPattern): Stream; } /** @@ -78,7 +77,7 @@ export interface Sink extends Source, Sink, EventEmitter> { +export interface Store extends Source, Sink, EventEmitter> { /** * Removes all streamed quads. * @@ -88,7 +87,7 @@ export interface Store extends Source, Sink): EventEmitter; + remove(stream: Stream): EventEmitter; /** * All quads matching the pattern will be removed. @@ -102,7 +101,7 @@ export interface Store extends Source, Sink extends Source, Sink Date: Sat, 10 Jul 2021 13:22:26 -0700 Subject: [PATCH 2/5] fix: add deprecation notice to Quad --- data-model.d.ts | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+) diff --git a/data-model.d.ts b/data-model.d.ts index a9d594d..2b42150 100644 --- a/data-model.d.ts +++ b/data-model.d.ts @@ -245,6 +245,32 @@ export interface BaseQuad { equals(other: Term | null | undefined): boolean; } +/** + * @deprecated This interface allows for `Variable` term types in the quad components. Consider using either @see StarQuad or @see PlainQuad instead + */ + export interface Quad extends BaseQuad { + /** + * The subject. + * @see Quad_Subject + */ + subject: Quad_Subject; + /** + * The predicate. + * @see Quad_Predicate + */ + predicate: Quad_Predicate; + /** + * The object. + * @see Quad_Object + */ + object: Quad_Object; + /** + * The named graph. + * @see Quad_Graph + */ + graph: Quad_Graph; +} + /** * An RDF quad, containing the subject, predicate, object and graph terms. */ From 8388399bb8a64bba3c415ed013254b5df4da7032 Mon Sep 17 00:00:00 2001 From: Blake Regalia Date: Sat, 10 Jul 2021 14:49:56 -0700 Subject: [PATCH 3/5] tests: add Plain/Star tests --- data-model.d.ts | 2 +- dataset.d.ts | 2 + rdf-js-tests.ts | 419 +++++++++++++++++++++++++++++++++++++----------- 3 files changed, 326 insertions(+), 97 deletions(-) diff --git a/data-model.d.ts b/data-model.d.ts index 2b42150..905f5f0 100644 --- a/data-model.d.ts +++ b/data-model.d.ts @@ -10,7 +10,7 @@ * @see DefaultGraph * @see PlainQuad */ -export type Term = NamedNode | BlankNode | Literal | Variable | DefaultGraph | StarQuad; +export type Term = NamedNode | BlankNode | Literal | Variable | DefaultGraph | BaseQuad; /** * Contains an IRI. diff --git a/dataset.d.ts b/dataset.d.ts index 1e280ad..dc1b51e 100644 --- a/dataset.d.ts +++ b/dataset.d.ts @@ -192,6 +192,8 @@ export interface Dataset): Dataset; + + match(subject?: InQuad['subject'] | TermPattern, predicate?: InQuad['predicate'] | TermPattern, object?: InQuad['object'] | TermPattern, graph?: InQuad['graph'] | TermPattern): Dataset; } export interface DatasetFactory = Dataset> diff --git a/rdf-js-tests.ts b/rdf-js-tests.ts index af12b23..9930fbf 100644 --- a/rdf-js-tests.ts +++ b/rdf-js-tests.ts @@ -1,5 +1,5 @@ import { BlankNode, DataFactory, Dataset, DatasetCore, DatasetCoreFactory, DatasetFactory, DefaultGraph, Literal, - NamedNode, Quad, BaseQuad, Sink, Source, Store, Stream, Term, Variable, Quad_Graph } from "."; + NamedNode, Quad, BaseQuad, StarQuad, PlainQuad, StarRole, PlainRole, Sink, Source, Store, Stream, Term, Variable, Quad_Graph } from "."; import { EventEmitter } from "events"; function test_terms() { @@ -57,12 +57,30 @@ function test_terms() { } function test_quads() { - const quad: Quad = {}; - const s1: Term = quad.subject; - const p1: Term = quad.predicate; - const o1: Term = quad.object; - const g1: Term = quad.graph; - quad.equals(quad); + { + const quad: BaseQuad = {}; + const s1: Term = quad.subject; + const p1: Term = quad.predicate; + const o1: Term = quad.object; + const g1: Term = quad.graph; + quad.equals(quad); + } + { + const quad: StarQuad = {}; + const s1: StarRole.Subject = quad.subject; + const p1: StarRole.Predicate = quad.predicate; + const o1: StarRole.Object = quad.object; + const g1: StarRole.Graph = quad.graph; + quad.equals(quad); + } + { + const quad: PlainQuad = {}; + const s1: PlainRole.Subject = quad.subject; + const p1: PlainRole.Predicate = quad.predicate; + const o1: PlainRole.Object = quad.object; + const g1: PlainRole.Graph = quad.graph; + quad.equals(quad); + } } function test_datafactory() { @@ -92,21 +110,21 @@ function test_datafactory() { graph: Term; } - const quadBnodeFactory: DataFactory = {}; + const quadBnodeFactory: DataFactory = {}; const quad = quadBnodeFactory.quad(literal1, blankNode1, term, term); const hasBnode = quad.predicate.termType === "BlankNode"; } function test_datafactory_star() { - const dataFactory: DataFactory = {}; + const dataFactory: DataFactory = {}; // Compose the triple "<> ex:certainty 0.9." - const quadBobAge: Quad = dataFactory.quad( + const quadBobAge: StarQuad = dataFactory.quad( dataFactory.namedNode('ex:bob'), dataFactory.namedNode('ex:age'), dataFactory.literal('23'), ); - const quadBobAgeCertainty: Quad = dataFactory.quad( + const quadBobAgeCertainty: StarQuad = dataFactory.quad( quadBobAge, dataFactory.namedNode('ex:certainty'), dataFactory.literal('0.9'), @@ -114,7 +132,7 @@ function test_datafactory_star() { // Decompose the triple if (quadBobAgeCertainty.subject.termType === 'Quad') { - const quadBobAge2: Quad = quadBobAgeCertainty.subject; + const quadBobAge2: StarQuad = quadBobAgeCertainty.subject; const equalToSelf: boolean = quadBobAge2.equals(quadBobAge); const notEqualToOtherType: boolean = quadBobAge2.equals(dataFactory.namedNode('ex:something:else')); @@ -122,10 +140,10 @@ function test_datafactory_star() { } function test_datafactory_star_basequad() { - const dataFactory: DataFactory = {}; + const dataFactory: DataFactory = {}; // Compose the triple "<> ex:certainty 0.9." - const quadBobAge: BaseQuad = dataFactory.quad( + const quadBobAge: StarQuad = dataFactory.quad( dataFactory.namedNode('ex:bob'), dataFactory.namedNode('ex:age'), dataFactory.literal('23'), @@ -146,19 +164,50 @@ function test_datafactory_star_basequad() { } function test_stream() { - const stream: Stream = {}; - const quad: Quad | null = stream.read(); + const stream: Stream = {}; + const quad: BaseQuad | null = stream.read(); const term: Term = {}; + const source: Source = {}; + const matchStream1: Stream = source.match(); + const matchStream2: Stream = source.match(term); + const matchStream4: Stream = source.match(term, term); + const matchStream6: Stream = source.match(term, term, term); + const matchStream8: Stream = source.match(term, term, term, term); + + const sink: Sink, EventEmitter> = {}; + const graph: StarRole.Graph = {}; + const eventEmitter1: EventEmitter = sink.import(stream); + + const store: Store = {}; + const storeSource: Source = store; + const storeSink: Sink, EventEmitter> = store; + const eventEmitter2: EventEmitter = store.remove(stream); + const eventEmitter3: EventEmitter = store.removeMatches(); + const eventEmitter4: EventEmitter = store.removeMatches(term); + const eventEmitter6: EventEmitter = store.removeMatches(term, term); + const eventEmitter8: EventEmitter = store.removeMatches(term, term, term); + const eventEmitter10: EventEmitter = store.removeMatches(term, term, term, term); + const eventEmitter12: EventEmitter = store.deleteGraph(graph); + const eventEmitter13: EventEmitter = store.deleteGraph('http://example.org'); +} + +function test_stream_components() { + const stream: Stream = {}; + const quad: StarQuad | null = stream.read(); + + const subject: StarRole.Subject = {}; + const predicate: StarRole.Predicate = {}; + const object: StarRole.Object = {}; + const graph: StarRole.Graph = {}; const source: Source = {}; const matchStream1: Stream = source.match(); - const matchStream2: Stream = source.match(term); - const matchStream4: Stream = source.match(term, term); - const matchStream6: Stream = source.match(term, term, term); - const matchStream8: Stream = source.match(term, term, term, term); + const matchStream2: Stream = source.match(subject); + const matchStream4: Stream = source.match(subject, predicate); + const matchStream6: Stream = source.match(subject, predicate, object); + const matchStream8: Stream = source.match(subject, predicate, object, graph); const sink: Sink = {}; - const graph: Quad_Graph = {}; const eventEmitter1: EventEmitter = sink.import(stream); const store: Store = {}; @@ -166,10 +215,10 @@ function test_stream() { const storeSink: Sink = store; const eventEmitter2: EventEmitter = store.remove(stream); const eventEmitter3: EventEmitter = store.removeMatches(); - const eventEmitter4: EventEmitter = store.removeMatches(term); - const eventEmitter6: EventEmitter = store.removeMatches(term, term); - const eventEmitter8: EventEmitter = store.removeMatches(term, term, term); - const eventEmitter10: EventEmitter = store.removeMatches(term, term, term, term); + const eventEmitter4: EventEmitter = store.removeMatches(subject); + const eventEmitter6: EventEmitter = store.removeMatches(subject, predicate); + const eventEmitter8: EventEmitter = store.removeMatches(subject, predicate, object); + const eventEmitter10: EventEmitter = store.removeMatches(subject, predicate, object, graph); const eventEmitter12: EventEmitter = store.deleteGraph(graph); const eventEmitter13: EventEmitter = store.deleteGraph('http://example.org'); } @@ -182,31 +231,31 @@ function test_datasetcore() { graph: Term; } - const quad: Quad = {}; + const quad: BaseQuad = {}; const quadBnode: QuadBnode = {}; const term: Term = {}; - const datasetCoreFactory1: DatasetCoreFactory = {}; - const datasetCoreFactory2: DatasetCoreFactory = {}; + const datasetCoreFactory1: DatasetCoreFactory = {}; + const datasetCoreFactory2: DatasetCoreFactory = {}; - const dataset1: DatasetCore = datasetCoreFactory1.dataset(); - const dataset2: DatasetCore = datasetCoreFactory1.dataset([quad, quad]); + const dataset1: DatasetCore = datasetCoreFactory1.dataset(); + const dataset2: DatasetCore = datasetCoreFactory1.dataset([quad, quad]); const dataset3: DatasetCore = datasetCoreFactory2.dataset([quadBnode, quad]); const dataset2Size: number = dataset2.size; - const dataset2Add: DatasetCore = dataset2.add(quad); - const dataset2Delete: DatasetCore = dataset2.delete(quad); + const dataset2Add: DatasetCore = dataset2.add(quad); + const dataset2Delete: DatasetCore = dataset2.delete(quad); const dataset2Has: boolean = dataset2.has(quad); - const dataset2Match1: DatasetCore = dataset2.match(); - const dataset2Match2: DatasetCore = dataset2.match(term); - const dataset2Match3: DatasetCore = dataset2.match(term, term); - const dataset2Match4: DatasetCore = dataset2.match(term, term, term); - const dataset2Match5: DatasetCore = dataset2.match(term, term, term, term); - const dataset2MatchWithNull1: DatasetCore = dataset2.match(term); - const dataset2MatchWithNull2: DatasetCore = dataset2.match(null, term); - const dataset2MatchWithNull3: DatasetCore = dataset2.match(term, null, term); - const dataset2MatchWithNull4: DatasetCore = dataset2.match(term, term, null, term); - const dataset2Iterable: Iterable = dataset2; + const dataset2Match1: DatasetCore = dataset2.match(); + const dataset2Match2: DatasetCore = dataset2.match(term); + const dataset2Match3: DatasetCore = dataset2.match(term, term); + const dataset2Match4: DatasetCore = dataset2.match(term, term, term); + const dataset2Match5: DatasetCore = dataset2.match(term, term, term, term); + const dataset2MatchWithNull1: DatasetCore = dataset2.match(term); + const dataset2MatchWithNull2: DatasetCore = dataset2.match(null, term); + const dataset2MatchWithNull3: DatasetCore = dataset2.match(term, null, term); + const dataset2MatchWithNull4: DatasetCore = dataset2.match(term, term, null, term); + const dataset2Iterable: Iterable = dataset2; const dataset3Size: number = dataset3.size; const dataset3Add: DatasetCore = dataset3.add(quadBnode); @@ -228,62 +277,86 @@ function test_dataset() { graph: Term; } - const quad: Quad = {}; + interface QuadBnodeStar extends StarQuad { + subject: StarRole.Subject; + predicate: StarRole.Predicate; + object: StarRole.Object; + graph: StarRole.Graph; + } + + const quad: BaseQuad = {}; + const quadStar: StarQuad = {}; const quadBnode: QuadBnode = {}; + const quadBnodeStar: QuadBnodeStar = {}; const term: Term = {}; + const subject: StarRole.Subject = {}; + const predicate: StarRole.Predicate = {}; + const object: StarRole.Object = {}; + const graph: StarRole.Graph = {}; - const stream1: Stream = {}; + const stream1: Stream = {}; const stream2: Stream = {}; - - const datasetFactory1: DatasetFactory = {}; - const datasetFactory2: DatasetFactory = {}; - - const dataset1: Dataset = datasetFactory1.dataset(); - const dataset2: Dataset = datasetFactory1.dataset([quad, quad]); - const dataset3: Dataset = datasetFactory2.dataset(); - const dataset4: Dataset = datasetFactory2.dataset([quadBnode, quad]); - - const datasetFactory1Core: DatasetCoreFactory = datasetFactory1; - const datasetFactory2Core: DatasetCoreFactory = datasetFactory2; + const stream3: Stream = {}; + const stream4: Stream = {}; + + const datasetFactory1: DatasetFactory = {}; + const datasetFactory2: DatasetFactory = {}; + const datasetFactory3: DatasetFactory = {}; + const datasetFactory4: DatasetFactory = {}; + + const dataset1: Dataset = datasetFactory1.dataset(); + const dataset2: Dataset = datasetFactory1.dataset([quad, quad]); + const dataset3: Dataset = datasetFactory2.dataset(); + const dataset4: Dataset = datasetFactory2.dataset([quadBnode, quad]); + const dataset5: Dataset = datasetFactory3.dataset(); + const dataset6: Dataset = datasetFactory3.dataset([quadStar, quadStar]); + const dataset7: Dataset = datasetFactory4.dataset(); + const dataset8: Dataset = datasetFactory4.dataset([quadBnodeStar, quadStar]); + + const datasetFactory1Core: DatasetCoreFactory = datasetFactory1; + const datasetFactory2Core: DatasetCoreFactory = datasetFactory2; + const datasetFactory3Core: DatasetCoreFactory = datasetFactory3; + const datasetFactory4Core: DatasetCoreFactory = datasetFactory4; const dataset2Size: number = dataset2.size; - const dataset2Add: Dataset = dataset2.add(quad); - const dataset2AddAllDataset: Dataset = dataset2.addAll(dataset1); - const dataset2AddAllArray: Dataset = dataset2.addAll([quad]); + const dataset2Add: Dataset = dataset2.add(quad); + const dataset2AddAllDataset: Dataset = dataset2.addAll(dataset1); + const dataset2AddAllArray: Dataset = dataset2.addAll([quad]); const dataset2Contains: boolean = dataset2.contains(dataset1); - const dataset2Delete: Dataset = dataset2.delete(quad); - const dataset2DeleteMatches1: Dataset = dataset2.deleteMatches(); - const dataset2DeleteMatches2: Dataset = dataset2.deleteMatches(term); - const dataset2DeleteMatches3: Dataset = dataset2.deleteMatches(term, term); - const dataset2DeleteMatches4: Dataset = dataset2.deleteMatches(term, term, term); - const dataset2DeleteMatches5: Dataset = dataset2.deleteMatches(term, term, term, term); - const dataset2Difference: Dataset = dataset2.difference(dataset1); + const dataset2Delete: Dataset = dataset2.delete(quad); + const dataset2DeleteMatches1: Dataset = dataset2.deleteMatches(); + const dataset2DeleteMatches2: Dataset = dataset2.deleteMatches(term); + const dataset2DeleteMatches3: Dataset = dataset2.deleteMatches(term, term); + const dataset2DeleteMatches4: Dataset = dataset2.deleteMatches(term, term, term); + const dataset2DeleteMatches5: Dataset = dataset2.deleteMatches(term, term, term, term); + const dataset2Difference: Dataset = dataset2.difference(dataset1); const dataset2Equals: boolean = dataset2.equals(dataset1); - const dataset2Every: boolean = dataset2.every((quad: Quad, dataset: Dataset) => true); - const dataset2Filter: Dataset = dataset2.filter((quad: Quad, dataset: Dataset) => true); - dataset2.forEach((quad: Quad, dataset: Dataset) => { + const dataset2Every: boolean = dataset2.every((quad: BaseQuad, dataset: Dataset) => true); + const dataset2Filter: Dataset = dataset2.filter((quad: BaseQuad, dataset: Dataset) => true); + dataset2.forEach((quad: BaseQuad, dataset: Dataset) => { return }); const dataset2Has: boolean = dataset2.has(quad); - const dataset2Import: Promise = dataset2.import(stream1); - const dataset2Intersection: Dataset = dataset2.intersection(dataset1); - const dataset2Map: Dataset = dataset2.map((quad: Quad, dataset: Dataset) => quad); - const dataset2Match1: Dataset = dataset2.match(); - const dataset2Match2: Dataset = dataset2.match(term); - const dataset2Match3: Dataset = dataset2.match(term, term); - const dataset2Match4: Dataset = dataset2.match(term, term, term); - const dataset2Match5: Dataset = dataset2.match(term, term, term, term); - const dataset2Reduce1: string = dataset2.reduce((acc: string, quad: Quad, dataset: Dataset) => acc); - const dataset2Reduce2: boolean[] = dataset2.reduce((acc: boolean[], quad: Quad, dataset: Dataset) => acc, []); - const dataset2Reduce3: string = dataset2.reduce((acc: string, quad: Quad, dataset: Dataset) => acc, ''); - const dataset2Some: boolean = dataset2.some((quad: Quad, dataset: Dataset) => true); - const dataset2ToArray: Quad[] = dataset2.toArray(); + const dataset2Import: Promise> = dataset2.import(stream1); + const dataset2Intersection: Dataset = dataset2.intersection(dataset1); + const dataset2Map: Dataset = dataset2.map((quad: BaseQuad, dataset: Dataset) => quad); + const dataset2Match1: Dataset = dataset2.match(); + const dataset2Match2: Dataset = dataset2.match(term); + const dataset2Match3: Dataset = dataset2.match(term, term); + const dataset2Match4: Dataset = dataset2.match(term, term, term); + const dataset2Match5: Dataset = dataset2.match(term, term, term, term); + const dataset2Reduce1: string = dataset2.reduce((acc: string, quad: BaseQuad, dataset: Dataset) => acc); + const dataset2Reduce2: boolean[] = dataset2.reduce((acc: boolean[], quad: BaseQuad, dataset: Dataset) => acc, []); + const dataset2Reduce3: string = dataset2.reduce((acc: string, quad: BaseQuad, dataset: Dataset) => acc, ''); + const dataset2Some: boolean = dataset2.some((quad: BaseQuad, dataset: Dataset) => true); + const dataset2ToArray: BaseQuad[] = dataset2.toArray(); const dataset2ToCanonical: string = dataset2.toCanonical(); - const dataset2ToStream: Stream = dataset2.toStream(); + const dataset2ToStream: Stream = dataset2.toStream(); const dataset2ToString: string = dataset2.toString(); - const dataset2Union: Dataset = dataset2.union(dataset1); - const dataset2Iterable: Iterable = dataset2; - const dataset2Core: DatasetCore = dataset2; + const dataset2Union: Dataset = dataset2.union(dataset1); + const dataset2Iterable: Iterable = dataset2; + const dataset2Core: DatasetCore = dataset2; + const dataset4Size: number = dataset4.size; const dataset4Add: Dataset = dataset4.add(quadBnode); @@ -323,6 +396,86 @@ function test_dataset() { const dataset4Union: Dataset = dataset4.union(dataset3); const dataset4Iterable: Iterable = dataset4; const dataset4Core: DatasetCore = dataset4; + + const dataset6Size: number = dataset6.size; + const dataset6Add: Dataset = dataset6.add(quadStar); + const dataset6AddAllDataset: Dataset = dataset6.addAll(dataset5); + const dataset6AddAllArray: Dataset = dataset6.addAll([quadStar]); + const dataset6Contains: boolean = dataset6.contains(dataset5); + const dataset6Delete: Dataset = dataset6.delete(quadStar); + const dataset6DeleteMatches1: Dataset = dataset6.deleteMatches(); + const dataset6DeleteMatches2: Dataset = dataset6.deleteMatches(subject); + const dataset6DeleteMatches3: Dataset = dataset6.deleteMatches(subject, predicate); + const dataset6DeleteMatches4: Dataset = dataset6.deleteMatches(subject, predicate, object); + const dataset6DeleteMatches5: Dataset = dataset6.deleteMatches(subject, predicate, object, graph); + const dataset6Difference: Dataset = dataset6.difference(dataset5); + const dataset6Equals: boolean = dataset6.equals(dataset5); + const dataset6Every: boolean = dataset6.every((quad: StarQuad, dataset: Dataset) => true); + const dataset6Filter: Dataset = dataset6.filter((quad: StarQuad, dataset: Dataset) => true); + dataset6.forEach((quad: StarQuad, dataset: Dataset) => { + return + }); + const dataset6Has: boolean = dataset6.has(quadStar); + const dataset6Import: Promise = dataset6.import(stream3); + const dataset6Intersection: Dataset = dataset6.intersection(dataset5); + const dataset6Map: Dataset = dataset6.map((quad: StarQuad, dataset: Dataset) => quad); + const dataset6Match1: Dataset = dataset6.match(); + const dataset6Match2: Dataset = dataset6.match(subject); + const dataset6Match3: Dataset = dataset6.match(subject, predicate); + const dataset6Match4: Dataset = dataset6.match(subject, predicate, object); + const dataset6Match5: Dataset = dataset6.match(subject, predicate, object, graph); + const dataset6Reduce1: string = dataset6.reduce((acc: string, quad: StarQuad, dataset: Dataset) => acc); + const dataset6Reduce2: boolean[] = dataset6.reduce((acc: boolean[], quad: StarQuad, dataset: Dataset) => acc, []); + const dataset6Reduce3: string = dataset6.reduce((acc: string, quad: StarQuad, dataset: Dataset) => acc, ''); + const dataset6Some: boolean = dataset6.some((quad: StarQuad, dataset: Dataset) => true); + const dataset6ToArray: StarQuad[] = dataset6.toArray(); + const dataset6ToCanonical: string = dataset6.toCanonical(); + const dataset6ToStream: Stream = dataset6.toStream(); + const dataset6ToString: string = dataset6.toString(); + const dataset6Union: Dataset = dataset6.union(dataset5); + const dataset6Iterable: Iterable = dataset6; + const dataset6Core: DatasetCore = dataset6; + + + const dataset8Size: number = dataset8.size; + const dataset8Add: Dataset = dataset8.add(quadBnodeStar); + const dataset8AddAllDataset: Dataset = dataset8.addAll(dataset7); + const dataset8AddAllArray: Dataset = dataset8.addAll([quadBnodeStar]); + const dataset8Contains: boolean = dataset8.contains(dataset7); + const dataset8Delete: Dataset = dataset8.delete(quadBnodeStar); + const dataset8DeleteMatches1: Dataset = dataset8.deleteMatches(); + const dataset8DeleteMatches2: Dataset = dataset8.deleteMatches(subject); + const dataset8DeleteMatches3: Dataset = dataset8.deleteMatches(subject, predicate); + const dataset8DeleteMatches4: Dataset = dataset8.deleteMatches(subject, predicate, object); + const dataset8DeleteMatches5: Dataset = dataset8.deleteMatches(subject, predicate, object, graph); + const dataset8Difference: Dataset = dataset8.difference(dataset7); + const dataset8Equals: boolean = dataset8.equals(dataset7); + const dataset8Every: boolean = dataset8.every((quad: QuadBnodeStar, dataset: Dataset) => true); + const dataset8Filter: Dataset = dataset8.filter((quad: QuadBnodeStar, dataset: Dataset) => true); + dataset8.forEach((quad: QuadBnodeStar, dataset: Dataset) => { + return + }); + const dataset8Has: boolean = dataset8.has(quadBnodeStar); + const dataset8Import: Promise> = dataset8.import(stream4); + const dataset8Intersection: Dataset = dataset8.intersection(dataset7); + const dataset8Map: Dataset = dataset8.map((quad: QuadBnodeStar, dataset: Dataset) => quad); + const dataset8Match1: Dataset = dataset8.match(); + const dataset8Match2: Dataset = dataset8.match(subject); + const dataset8Match3: Dataset = dataset8.match(subject, predicate); + const dataset8Match4: Dataset = dataset8.match(subject, predicate, object); + const dataset8Match5: Dataset = dataset8.match(subject, predicate, object, graph); + const dataset8Reduce1: string = dataset8.reduce((acc: string, quad: QuadBnodeStar, dataset: Dataset) => acc); + const dataset8Reduce2: boolean[] = dataset8.reduce((acc: boolean[], quad: QuadBnodeStar, dataset: Dataset) => acc, []); + const dataset8Reduce3: string = dataset8.reduce((acc: string, quad: QuadBnodeStar, dataset: Dataset) => acc, ''); + const dataset8Some: boolean = dataset8.some((quad: QuadBnodeStar, dataset: Dataset) => true); + const dataset8ToArray: QuadBnodeStar[] = dataset8.toArray(); + const dataset8ToCanonical: string = dataset8.toCanonical(); + const dataset8ToStream: Stream = dataset8.toStream(); + const dataset8ToString: string = dataset8.toString(); + const dataset8Union: Dataset = dataset8.union(dataset7); + const dataset8Iterable: Iterable = dataset8; + const dataset8Core: DatasetCore = dataset8; + } function test_datasetCoreFactory_covariance() { @@ -342,14 +495,14 @@ function test_datasetFactory_covariance() { } async function test_dataset_covariance(): Promise { - const quad: Quad = {}; + const quad: StarQuad = {}; const dataset: Dataset = {}; // rdf-ext-like quad - interface QuadExt extends Quad { + interface QuadExt extends StarQuad { toCanonical(): string; } - let datasetExt: Dataset = {}; + let datasetExt: Dataset = {}; // stream coming from a generic parser const stream: Stream = {}; @@ -382,12 +535,12 @@ class DatasetCoreExt implements DatasetCore { throw new Error("Method not implemented."); } - match(): DatasetCore { + match(): DatasetCore { const newInstance: DatasetCoreExt = {}; return newInstance; } - [Symbol.iterator](): Iterator { + [Symbol.iterator](): Iterator { throw new Error("Method not implemented."); } } @@ -405,7 +558,7 @@ class DatasetExt extends DatasetCoreExt implements Dataset { throw new Error("Method not implemented."); } - difference(): Dataset { + difference(): Dataset { const newInstance: DatasetExt = {}; return newInstance; } @@ -418,7 +571,7 @@ class DatasetExt extends DatasetCoreExt implements Dataset { throw new Error("Method not implemented."); } - filter(): Dataset { + filter(): Dataset { const newInstance: DatasetExt = {}; return newInstance; } @@ -435,12 +588,12 @@ class DatasetExt extends DatasetCoreExt implements Dataset { throw new Error("Method not implemented."); } - map(): Dataset { + map(): Dataset { const newInstance: DatasetExt = {}; return newInstance; } - match(): Dataset { + match(): Dataset { const newInstance: DatasetExt = {}; return newInstance; } @@ -453,7 +606,7 @@ class DatasetExt extends DatasetCoreExt implements Dataset { throw new Error("Method not implemented."); } - toArray(): Quad[] { + toArray(): StarQuad[] { throw new Error("Method not implemented."); } @@ -469,20 +622,94 @@ class DatasetExt extends DatasetCoreExt implements Dataset { throw new Error("Method not implemented."); } - union(): Dataset { + union(): Dataset { const newInstance: DatasetExt = {}; return newInstance; } } + +async function test_dataset_covariance_plain(): Promise { + const quad: PlainQuad = {}; + const dataset: Dataset = {}; + + // rdf-ext-like quad + interface QuadExt extends PlainQuad { + toCanonical(): string; + } + let datasetExt: Dataset = {}; + + // stream coming from a generic parser + const stream: Stream = {}; + + datasetExt = datasetExt.add(quad); + datasetExt = datasetExt.delete(quad); + datasetExt = datasetExt.addAll([quad, quad]); + datasetExt = datasetExt.addAll(dataset); + datasetExt.contains(dataset); + datasetExt = datasetExt.difference(dataset); + datasetExt.equals(dataset); + datasetExt.has(quad); + datasetExt.intersection(dataset); + datasetExt.union(dataset); + return datasetExt.import(stream); +} + +class DatasetCoreExtPlain extends DatasetCoreExt { + match(): DatasetCore { + const newInstance: DatasetCoreExtPlain = {}; + return newInstance; + } + + [Symbol.iterator](): Iterator { + throw new Error("Method not implemented."); + } +} + +class DatasetExtPlain extends DatasetExt implements Dataset { + filter(): Dataset { + const newInstance: DatasetExtPlain = {}; + return newInstance; + } + + map(): Dataset { + const newInstance: DatasetExtPlain = {}; + return newInstance; + } + + match(): Dataset { + const newInstance: DatasetExtPlain = {}; + return newInstance; + } + + toArray(): PlainQuad[] { + throw new Error("Method not implemented."); + } + + union(): Dataset { + const newInstance: DatasetExtPlain = {}; + return newInstance; + } +} + function testInheritance() { const datasetCoreExt: DatasetCoreExt = new DatasetCoreExt(); const datasetCoreMatch: DatasetCore = datasetCoreExt.match(); + const datasetCoreExtPlain: DatasetCoreExtPlain = new DatasetCoreExtPlain(); + const datasetCorePlainMatch: DatasetCore = datasetCoreExtPlain.match(); + const datasetExt: DatasetExt = new DatasetExt(); const datasetMatch: Dataset = datasetExt.match(); const datasetMap: Dataset = datasetExt.map(); const datasetUnion: Dataset = datasetExt.union(); const datasetFilter: Dataset = datasetExt.filter(); const datasetDifference: Dataset = datasetExt.difference(); + + const datasetExtPlain: DatasetExtPlain = new DatasetExtPlain(); + const datasetPlainMatch: Dataset = datasetExtPlain.match(); + const datasetPlainMap: Dataset = datasetExtPlain.map(); + const datasetPlainUnion: Dataset = datasetExtPlain.union(); + const datasetPlainFilter: Dataset = datasetExtPlain.filter(); + const datasetPlainDifference: Dataset = datasetExtPlain.difference(); } From 0824ab67915659674c0eb730ee7c771f83ea70b9 Mon Sep 17 00:00:00 2001 From: Blake Regalia Date: Sat, 10 Jul 2021 14:54:28 -0700 Subject: [PATCH 4/5] chore: rename test file for consistency --- rdf-js-tests.ts => rdfjs-tests.ts | 0 tsconfig.json | 2 +- 2 files changed, 1 insertion(+), 1 deletion(-) rename rdf-js-tests.ts => rdfjs-tests.ts (100%) diff --git a/rdf-js-tests.ts b/rdfjs-tests.ts similarity index 100% rename from rdf-js-tests.ts rename to rdfjs-tests.ts diff --git a/tsconfig.json b/tsconfig.json index f7c711a..33b75ef 100644 --- a/tsconfig.json +++ b/tsconfig.json @@ -15,6 +15,6 @@ }, "files": [ "index.d.ts", - "rdf-js-tests.ts" + "rdfjs-tests.ts" ] } From b54f46912073add09dd388b5447d43a168e27d11 Mon Sep 17 00:00:00 2001 From: Blake Regalia Date: Sat, 10 Jul 2021 23:17:41 -0700 Subject: [PATCH 5/5] fix: remove toArray() --- dataset.d.ts | 8 -------- rdfjs-tests.ts | 16 ++++------------ tsconfig.json | 3 ++- 3 files changed, 6 insertions(+), 21 deletions(-) diff --git a/dataset.d.ts b/dataset.d.ts index dc1b51e..0ffbbae 100644 --- a/dataset.d.ts +++ b/dataset.d.ts @@ -161,14 +161,6 @@ export interface Dataset boolean): boolean; - /** - * Returns the set of quads within the dataset as a host language native sequence, for example an `Array` in - * ECMAScript-262. - * - * Since a `Dataset` is an unordered set, the order of the quads within the returned sequence is arbitrary. - */ - toArray(): OutQuad[]; - /** * Returns an N-Quads string representation of the dataset, preprocessed with * {@link https://json-ld.github.io/normalization/spec/|RDF Dataset Normalization} algorithm. diff --git a/rdfjs-tests.ts b/rdfjs-tests.ts index 9930fbf..657cc7f 100644 --- a/rdfjs-tests.ts +++ b/rdfjs-tests.ts @@ -349,7 +349,7 @@ function test_dataset() { const dataset2Reduce2: boolean[] = dataset2.reduce((acc: boolean[], quad: BaseQuad, dataset: Dataset) => acc, []); const dataset2Reduce3: string = dataset2.reduce((acc: string, quad: BaseQuad, dataset: Dataset) => acc, ''); const dataset2Some: boolean = dataset2.some((quad: BaseQuad, dataset: Dataset) => true); - const dataset2ToArray: BaseQuad[] = dataset2.toArray(); + const dataset2ToArray: BaseQuad[] = [...dataset2]; const dataset2ToCanonical: string = dataset2.toCanonical(); const dataset2ToStream: Stream = dataset2.toStream(); const dataset2ToString: string = dataset2.toString(); @@ -389,7 +389,7 @@ function test_dataset() { const dataset4Reduce2: boolean[] = dataset4.reduce((acc: boolean[], quad: QuadBnode, dataset: Dataset) => acc, []); const dataset4Reduce3: string = dataset4.reduce((acc: string, quad: QuadBnode, dataset: Dataset) => acc, ''); const dataset4Some: boolean = dataset4.some((quad: QuadBnode, dataset: Dataset) => true); - const dataset4ToArray: QuadBnode[] = dataset4.toArray(); + const dataset4ToArray: QuadBnode[] = [...dataset4]; const dataset4ToCanonical: string = dataset4.toCanonical(); const dataset4ToStream: Stream = dataset4.toStream(); const dataset4ToString: string = dataset4.toString(); @@ -428,7 +428,7 @@ function test_dataset() { const dataset6Reduce2: boolean[] = dataset6.reduce((acc: boolean[], quad: StarQuad, dataset: Dataset) => acc, []); const dataset6Reduce3: string = dataset6.reduce((acc: string, quad: StarQuad, dataset: Dataset) => acc, ''); const dataset6Some: boolean = dataset6.some((quad: StarQuad, dataset: Dataset) => true); - const dataset6ToArray: StarQuad[] = dataset6.toArray(); + const dataset6ToArray: StarQuad[] = [...dataset6]; const dataset6ToCanonical: string = dataset6.toCanonical(); const dataset6ToStream: Stream = dataset6.toStream(); const dataset6ToString: string = dataset6.toString(); @@ -468,7 +468,7 @@ function test_dataset() { const dataset8Reduce2: boolean[] = dataset8.reduce((acc: boolean[], quad: QuadBnodeStar, dataset: Dataset) => acc, []); const dataset8Reduce3: string = dataset8.reduce((acc: string, quad: QuadBnodeStar, dataset: Dataset) => acc, ''); const dataset8Some: boolean = dataset8.some((quad: QuadBnodeStar, dataset: Dataset) => true); - const dataset8ToArray: QuadBnodeStar[] = dataset8.toArray(); + const dataset8ToArray: QuadBnodeStar[] = [...dataset8]; const dataset8ToCanonical: string = dataset8.toCanonical(); const dataset8ToStream: Stream = dataset8.toStream(); const dataset8ToString: string = dataset8.toString(); @@ -606,10 +606,6 @@ class DatasetExt extends DatasetCoreExt implements Dataset { throw new Error("Method not implemented."); } - toArray(): StarQuad[] { - throw new Error("Method not implemented."); - } - toCanonical(): string { throw new Error("Method not implemented."); } @@ -682,10 +678,6 @@ class DatasetExtPlain extends DatasetExt implements Dataset { return newInstance; } - toArray(): PlainQuad[] { - throw new Error("Method not implemented."); - } - union(): Dataset { const newInstance: DatasetExtPlain = {}; return newInstance; diff --git a/tsconfig.json b/tsconfig.json index 33b75ef..79f0313 100644 --- a/tsconfig.json +++ b/tsconfig.json @@ -2,8 +2,9 @@ "compilerOptions": { "module": "commonjs", "lib": [ - "es6" + "ES6" ], + "target": "ES2015", "strict": true, "noImplicitReturns": true, "noImplicitAny": true,