diff --git a/data-model.d.ts b/data-model.d.ts index f2a3b38..905f5f0 100644 --- a/data-model.d.ts +++ b/data-model.d.ts @@ -8,7 +8,7 @@ * @see Literal * @see Variable * @see DefaultGraph - * @see Quad + * @see PlainQuad */ export type Term = NamedNode | BlankNode | Literal | Variable | DefaultGraph | BaseQuad; @@ -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 type Quad_Graph = DefaultGraph | NamedNode | BlankNode | Variable; + 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_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; @@ -202,9 +246,9 @@ export interface BaseQuad { } /** - * An RDF quad, containing the subject, predicate, object and graph terms. + * @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 { + export interface Quad extends BaseQuad { /** * The subject. * @see Quad_Subject @@ -225,18 +269,65 @@ export interface Quad extends BaseQuad { * @see Quad_Graph */ graph: Quad_Graph; +} + +/** + * An RDF quad, containing the subject, predicate, object and graph terms. + */ +export interface StarQuad extends BaseQuad { + /** + * The subject. + * @see StarRole.Subject + */ + subject: StarRole.Subject; + /** + * The predicate. + * @see StarRole.Predicate + */ + predicate: StarRole.Predicate; + /** + * The object. + * @see StarRole.Object + */ + object: StarRole.Object; + /** + * The named graph. + * @see StarRole.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 +347,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 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. @@ -192,13 +185,13 @@ export interface Dataset): Dataset; - match(subject?: Term | null, predicate?: Term | null, object?: Term | null, graph?: Term | null): Dataset; + match(subject?: InQuad['subject'] | TermPattern, predicate?: InQuad['predicate'] | TermPattern, object?: InQuad['object'] | TermPattern, graph?: InQuad['graph'] | TermPattern): 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; } diff --git a/rdf-js-tests.ts b/rdf-js-tests.ts deleted file mode 100644 index af12b23..0000000 --- a/rdf-js-tests.ts +++ /dev/null @@ -1,488 +0,0 @@ -import { BlankNode, DataFactory, Dataset, DatasetCore, DatasetCoreFactory, DatasetFactory, DefaultGraph, Literal, - NamedNode, Quad, BaseQuad, Sink, Source, Store, Stream, Term, Variable, Quad_Graph } from "."; -import { EventEmitter } from "events"; - -function test_terms() { - // Only types are checked in this tests, - // so this does not have to be functional. - const someTerm: Term = {}; - - if (someTerm.termType === 'Literal') { - console.log(someTerm.datatype); - } - const namedNode: NamedNode = {}; - const termType1: string = namedNode.termType; - const value1: string = namedNode.value; - let namedNodeEqual: boolean = namedNode.equals(someTerm); - namedNodeEqual = namedNode.equals(null); - namedNodeEqual = namedNode.equals(undefined); - - const namedNodeConstant: NamedNode<'http://example.org'> = {}; - const constantIri: 'http://example.org' = namedNodeConstant.value; - // @ts-expect-error - const otherConstantIri: 'http://not-example.org' = namedNodeConstant.value; - // @ts-expect-error - const otherNamedNodeConstant: NamedNode<'http://not-example.org'> = namedNodeConstant; - const regularNamedNode: NamedNode = namedNodeConstant; - - const blankNode: BlankNode = {}; - const termType2: string = blankNode.termType; - const value2: string = blankNode.value; - let blankNodeEqual: boolean = blankNode.equals(someTerm); - blankNodeEqual = blankNode.equals(null); - blankNodeEqual = blankNode.equals(undefined); - - const literal: Literal = {}; - const termType3: string = literal.termType; - const value3: string = literal.value; - const language3: string = literal.language; - const datatype3: NamedNode = literal.datatype; - let literalEqual: boolean = literal.equals(someTerm); - literalEqual = literal.equals(null); - literalEqual = literal.equals(undefined); - - const variable: Variable = {}; - const termType4: string = variable.termType; - const value4: string = variable.value; - let variableEqual = variable.equals(someTerm); - variableEqual = variable.equals(null); - variableEqual = variable.equals(undefined); - - const defaultGraph: DefaultGraph = {}; - const termType5: string = defaultGraph.termType; - const value5: string = defaultGraph.value; - let defaultGraphEqual: boolean = defaultGraph.equals(someTerm); - defaultGraphEqual = defaultGraph.equals(null); - defaultGraphEqual = defaultGraph.equals(undefined); -} - -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); -} - -function test_datafactory() { - const dataFactory: DataFactory = {}; - - const namedNode: NamedNode = dataFactory.namedNode('http://example.org'); - const constantValue: 'http://example.org' = dataFactory.namedNode('http://example.org').value; - // @ts-expect-error - const otherConstantValue: 'http://not-example.org' = dataFactory.namedNode('http://example.org').value; - // @ts-expect-error - const otherConstantNamedNode: NamedNode<'http://not-example.org'> = dataFactory.namedNode('http://example.org'); - - const blankNode1: BlankNode = dataFactory.blankNode('b1'); - const blankNode2: BlankNode = dataFactory.blankNode(); - - const literal1: Literal = dataFactory.literal('abc'); - const literal2: Literal = dataFactory.literal('abc', 'en-us'); - const literal3: Literal = dataFactory.literal('abc', namedNode); - - const variable: Variable = dataFactory.variable ? dataFactory.variable('v1') : {}; - - const term: NamedNode = {}; - interface QuadBnode extends BaseQuad { - subject: Term; - predicate: Term; - object: Term; - graph: Term; - } - - const quadBnodeFactory: DataFactory = {}; - const quad = quadBnodeFactory.quad(literal1, blankNode1, term, term); - const hasBnode = quad.predicate.termType === "BlankNode"; -} - -function test_datafactory_star() { - const dataFactory: DataFactory = {}; - - // Compose the triple "<> ex:certainty 0.9." - const quadBobAge: Quad = dataFactory.quad( - dataFactory.namedNode('ex:bob'), - dataFactory.namedNode('ex:age'), - dataFactory.literal('23'), - ); - const quadBobAgeCertainty: Quad = dataFactory.quad( - quadBobAge, - dataFactory.namedNode('ex:certainty'), - dataFactory.literal('0.9'), - ); - - // Decompose the triple - if (quadBobAgeCertainty.subject.termType === 'Quad') { - const quadBobAge2: Quad = quadBobAgeCertainty.subject; - - const equalToSelf: boolean = quadBobAge2.equals(quadBobAge); - const notEqualToOtherType: boolean = quadBobAge2.equals(dataFactory.namedNode('ex:something:else')); - } -} - -function test_datafactory_star_basequad() { - const dataFactory: DataFactory = {}; - - // Compose the triple "<> ex:certainty 0.9." - const quadBobAge: BaseQuad = dataFactory.quad( - dataFactory.namedNode('ex:bob'), - dataFactory.namedNode('ex:age'), - dataFactory.literal('23'), - ); - const quadBobAgeCertainty: BaseQuad = dataFactory.quad( - quadBobAge, - dataFactory.namedNode('ex:certainty'), - dataFactory.literal('0.9'), - ); - - // Decompose the triple - if (quadBobAgeCertainty.subject.termType === 'Quad') { - const quadBobAge2: BaseQuad = quadBobAgeCertainty.subject; - - const equalToSelf: boolean = quadBobAge2.equals(quadBobAge); - const notEqualToOtherType: boolean = quadBobAge2.equals(dataFactory.namedNode('ex:something:else')); - } -} - -function test_stream() { - const stream: Stream = {}; - const quad: Quad | 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 = {}; - const graph: Quad_Graph = {}; - const eventEmitter1: EventEmitter = sink.import(stream); - - const store: Store = {}; - const storeSource: Source = store; - 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 eventEmitter12: EventEmitter = store.deleteGraph(graph); - const eventEmitter13: EventEmitter = store.deleteGraph('http://example.org'); -} - -function test_datasetcore() { - interface QuadBnode extends BaseQuad { - subject: Term; - predicate: Term; - object: Term; - graph: Term; - } - - const quad: Quad = {}; - const quadBnode: QuadBnode = {}; - const term: Term = {}; - - const datasetCoreFactory1: DatasetCoreFactory = {}; - const datasetCoreFactory2: DatasetCoreFactory = {}; - - 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 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 dataset3Size: number = dataset3.size; - const dataset3Add: DatasetCore = dataset3.add(quadBnode); - const dataset3Delete: DatasetCore = dataset3.delete(quadBnode); - const dataset3Has: boolean = dataset3.has(quadBnode); - const dataset3Match1: DatasetCore = dataset3.match(); - const dataset3Match2: DatasetCore = dataset3.match(term); - const dataset3Match3: DatasetCore = dataset3.match(term, term); - const dataset3Match4: DatasetCore = dataset3.match(term, term, term); - const dataset3Match5: DatasetCore = dataset3.match(term, term, term, term); - const dataset3Iterable: Iterable = dataset3; -} - -function test_dataset() { - interface QuadBnode extends BaseQuad { - subject: Term; - predicate: Term; - object: Term; - graph: Term; - } - - const quad: Quad = {}; - const quadBnode: QuadBnode = {}; - const term: Term = {}; - - 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 dataset2Size: number = dataset2.size; - 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 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) => { - 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 dataset2ToCanonical: string = dataset2.toCanonical(); - 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 dataset4Size: number = dataset4.size; - const dataset4Add: Dataset = dataset4.add(quadBnode); - const dataset4AddAllDataset: Dataset = dataset4.addAll(dataset3); - const dataset4AddAllArray: Dataset = dataset4.addAll([quadBnode]); - const dataset4Contains: boolean = dataset4.contains(dataset3); - const dataset4Delete: Dataset = dataset4.delete(quadBnode); - const dataset4DeleteMatches1: Dataset = dataset4.deleteMatches(); - const dataset4DeleteMatches2: Dataset = dataset4.deleteMatches(term); - const dataset4DeleteMatches3: Dataset = dataset4.deleteMatches(term, term); - const dataset4DeleteMatches4: Dataset = dataset4.deleteMatches(term, term, term); - const dataset4DeleteMatches5: Dataset = dataset4.deleteMatches(term, term, term, term); - const dataset4Difference: Dataset = dataset4.difference(dataset3); - const dataset4Equals: boolean = dataset4.equals(dataset3); - const dataset4Every: boolean = dataset4.every((quad: QuadBnode, dataset: Dataset) => true); - const dataset4Filter: Dataset = dataset4.filter((quad: QuadBnode, dataset: Dataset) => true); - dataset4.forEach((quad: QuadBnode, dataset: Dataset) => { - return - }); - const dataset4Has: boolean = dataset4.has(quadBnode); - const dataset4Import: Promise> = dataset4.import(stream2); - const dataset4Intersection: Dataset = dataset4.intersection(dataset3); - const dataset4Map: Dataset = dataset4.map((quad: QuadBnode, dataset: Dataset) => quad); - const dataset4Match1: Dataset = dataset4.match(); - const dataset4Match2: Dataset = dataset4.match(term); - const dataset4Match3: Dataset = dataset4.match(term, term); - const dataset4Match4: Dataset = dataset4.match(term, term, term); - const dataset4Match5: Dataset = dataset4.match(term, term, term, term); - const dataset4Reduce1: string = dataset4.reduce((acc: string, quad: QuadBnode, dataset: Dataset) => acc); - 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 dataset4ToCanonical: string = dataset4.toCanonical(); - const dataset4ToStream: Stream = dataset4.toStream(); - const dataset4ToString: string = dataset4.toString(); - const dataset4Union: Dataset = dataset4.union(dataset3); - const dataset4Iterable: Iterable = dataset4; - const dataset4Core: DatasetCore = dataset4; -} - -function test_datasetCoreFactory_covariance() { - const quad: BaseQuad = {}; - const factory: DatasetCoreFactory = {}; - - const fromQuads = factory.dataset([quad, quad]); -} - -function test_datasetFactory_covariance() { - const quad: BaseQuad = {}; - const dataset: Dataset = {}; - const factory: DatasetFactory = {}; - - const fromQuads = factory.dataset([quad, quad]); - const fromDataset = factory.dataset(dataset); -} - -async function test_dataset_covariance(): Promise { - const quad: Quad = {}; - const dataset: Dataset = {}; - - // rdf-ext-like quad - interface QuadExt extends Quad { - 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 DatasetCoreExt implements DatasetCore { - size!: number; - - add(): this { - throw new Error("Method not implemented."); - } - - delete(): this { - throw new Error("Method not implemented."); - } - - has(): boolean { - throw new Error("Method not implemented."); - } - - match(): DatasetCore { - const newInstance: DatasetCoreExt = {}; - return newInstance; - } - - [Symbol.iterator](): Iterator { - throw new Error("Method not implemented."); - } -} - -class DatasetExt extends DatasetCoreExt implements Dataset { - addAll(): this { - throw new Error("Method not implemented."); - } - - contains(): boolean { - throw new Error("Method not implemented."); - } - - deleteMatches(): this { - throw new Error("Method not implemented."); - } - - difference(): Dataset { - const newInstance: DatasetExt = {}; - return newInstance; - } - - equals(): boolean { - throw new Error("Method not implemented."); - } - - every(): boolean { - throw new Error("Method not implemented."); - } - - filter(): Dataset { - const newInstance: DatasetExt = {}; - return newInstance; - } - - forEach(): void { - throw new Error("Method not implemented."); - } - - import(): Promise { - throw new Error("Method not implemented."); - } - - intersection(): this { - throw new Error("Method not implemented."); - } - - map(): Dataset { - const newInstance: DatasetExt = {}; - return newInstance; - } - - match(): Dataset { - const newInstance: DatasetExt = {}; - return newInstance; - } - - reduce(): any { - throw new Error("Method not implemented."); - } - - some(): boolean { - throw new Error("Method not implemented."); - } - - toArray(): Quad[] { - throw new Error("Method not implemented."); - } - - toCanonical(): string { - throw new Error("Method not implemented."); - } - - toStream(): Stream { - throw new Error("Method not implemented."); - } - - toString(): string { - throw new Error("Method not implemented."); - } - - union(): Dataset { - const newInstance: DatasetExt = {}; - return newInstance; - } -} - -function testInheritance() { - const datasetCoreExt: DatasetCoreExt = new DatasetCoreExt(); - const datasetCoreMatch: DatasetCore = datasetCoreExt.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(); -} diff --git a/rdfjs-tests.ts b/rdfjs-tests.ts new file mode 100644 index 0000000..657cc7f --- /dev/null +++ b/rdfjs-tests.ts @@ -0,0 +1,707 @@ +import { BlankNode, DataFactory, Dataset, DatasetCore, DatasetCoreFactory, DatasetFactory, DefaultGraph, Literal, + NamedNode, Quad, BaseQuad, StarQuad, PlainQuad, StarRole, PlainRole, Sink, Source, Store, Stream, Term, Variable, Quad_Graph } from "."; +import { EventEmitter } from "events"; + +function test_terms() { + // Only types are checked in this tests, + // so this does not have to be functional. + const someTerm: Term = {}; + + if (someTerm.termType === 'Literal') { + console.log(someTerm.datatype); + } + const namedNode: NamedNode = {}; + const termType1: string = namedNode.termType; + const value1: string = namedNode.value; + let namedNodeEqual: boolean = namedNode.equals(someTerm); + namedNodeEqual = namedNode.equals(null); + namedNodeEqual = namedNode.equals(undefined); + + const namedNodeConstant: NamedNode<'http://example.org'> = {}; + const constantIri: 'http://example.org' = namedNodeConstant.value; + // @ts-expect-error + const otherConstantIri: 'http://not-example.org' = namedNodeConstant.value; + // @ts-expect-error + const otherNamedNodeConstant: NamedNode<'http://not-example.org'> = namedNodeConstant; + const regularNamedNode: NamedNode = namedNodeConstant; + + const blankNode: BlankNode = {}; + const termType2: string = blankNode.termType; + const value2: string = blankNode.value; + let blankNodeEqual: boolean = blankNode.equals(someTerm); + blankNodeEqual = blankNode.equals(null); + blankNodeEqual = blankNode.equals(undefined); + + const literal: Literal = {}; + const termType3: string = literal.termType; + const value3: string = literal.value; + const language3: string = literal.language; + const datatype3: NamedNode = literal.datatype; + let literalEqual: boolean = literal.equals(someTerm); + literalEqual = literal.equals(null); + literalEqual = literal.equals(undefined); + + const variable: Variable = {}; + const termType4: string = variable.termType; + const value4: string = variable.value; + let variableEqual = variable.equals(someTerm); + variableEqual = variable.equals(null); + variableEqual = variable.equals(undefined); + + const defaultGraph: DefaultGraph = {}; + const termType5: string = defaultGraph.termType; + const value5: string = defaultGraph.value; + let defaultGraphEqual: boolean = defaultGraph.equals(someTerm); + defaultGraphEqual = defaultGraph.equals(null); + defaultGraphEqual = defaultGraph.equals(undefined); +} + +function test_quads() { + { + 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() { + const dataFactory: DataFactory = {}; + + const namedNode: NamedNode = dataFactory.namedNode('http://example.org'); + const constantValue: 'http://example.org' = dataFactory.namedNode('http://example.org').value; + // @ts-expect-error + const otherConstantValue: 'http://not-example.org' = dataFactory.namedNode('http://example.org').value; + // @ts-expect-error + const otherConstantNamedNode: NamedNode<'http://not-example.org'> = dataFactory.namedNode('http://example.org'); + + const blankNode1: BlankNode = dataFactory.blankNode('b1'); + const blankNode2: BlankNode = dataFactory.blankNode(); + + const literal1: Literal = dataFactory.literal('abc'); + const literal2: Literal = dataFactory.literal('abc', 'en-us'); + const literal3: Literal = dataFactory.literal('abc', namedNode); + + const variable: Variable = dataFactory.variable ? dataFactory.variable('v1') : {}; + + const term: NamedNode = {}; + interface QuadBnode extends BaseQuad { + subject: Term; + predicate: Term; + object: Term; + graph: Term; + } + + const quadBnodeFactory: DataFactory = {}; + const quad = quadBnodeFactory.quad(literal1, blankNode1, term, term); + const hasBnode = quad.predicate.termType === "BlankNode"; +} + +function test_datafactory_star() { + const dataFactory: DataFactory = {}; + + // Compose the triple "<> ex:certainty 0.9." + const quadBobAge: StarQuad = dataFactory.quad( + dataFactory.namedNode('ex:bob'), + dataFactory.namedNode('ex:age'), + dataFactory.literal('23'), + ); + const quadBobAgeCertainty: StarQuad = dataFactory.quad( + quadBobAge, + dataFactory.namedNode('ex:certainty'), + dataFactory.literal('0.9'), + ); + + // Decompose the triple + if (quadBobAgeCertainty.subject.termType === 'Quad') { + const quadBobAge2: StarQuad = quadBobAgeCertainty.subject; + + const equalToSelf: boolean = quadBobAge2.equals(quadBobAge); + const notEqualToOtherType: boolean = quadBobAge2.equals(dataFactory.namedNode('ex:something:else')); + } +} + +function test_datafactory_star_basequad() { + const dataFactory: DataFactory = {}; + + // Compose the triple "<> ex:certainty 0.9." + const quadBobAge: StarQuad = dataFactory.quad( + dataFactory.namedNode('ex:bob'), + dataFactory.namedNode('ex:age'), + dataFactory.literal('23'), + ); + const quadBobAgeCertainty: BaseQuad = dataFactory.quad( + quadBobAge, + dataFactory.namedNode('ex:certainty'), + dataFactory.literal('0.9'), + ); + + // Decompose the triple + if (quadBobAgeCertainty.subject.termType === 'Quad') { + const quadBobAge2: BaseQuad = quadBobAgeCertainty.subject; + + const equalToSelf: boolean = quadBobAge2.equals(quadBobAge); + const notEqualToOtherType: boolean = quadBobAge2.equals(dataFactory.namedNode('ex:something:else')); + } +} + +function test_stream() { + 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(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 eventEmitter1: EventEmitter = sink.import(stream); + + const store: Store = {}; + const storeSource: Source = store; + const storeSink: Sink = store; + const eventEmitter2: EventEmitter = store.remove(stream); + const eventEmitter3: EventEmitter = store.removeMatches(); + 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'); +} + +function test_datasetcore() { + interface QuadBnode extends BaseQuad { + subject: Term; + predicate: Term; + object: Term; + graph: Term; + } + + const quad: BaseQuad = {}; + const quadBnode: QuadBnode = {}; + const term: Term = {}; + + const datasetCoreFactory1: DatasetCoreFactory = {}; + const datasetCoreFactory2: DatasetCoreFactory = {}; + + 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 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 dataset3Size: number = dataset3.size; + const dataset3Add: DatasetCore = dataset3.add(quadBnode); + const dataset3Delete: DatasetCore = dataset3.delete(quadBnode); + const dataset3Has: boolean = dataset3.has(quadBnode); + const dataset3Match1: DatasetCore = dataset3.match(); + const dataset3Match2: DatasetCore = dataset3.match(term); + const dataset3Match3: DatasetCore = dataset3.match(term, term); + const dataset3Match4: DatasetCore = dataset3.match(term, term, term); + const dataset3Match5: DatasetCore = dataset3.match(term, term, term, term); + const dataset3Iterable: Iterable = dataset3; +} + +function test_dataset() { + interface QuadBnode extends BaseQuad { + subject: Term; + predicate: Term; + object: Term; + graph: Term; + } + + 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 stream2: Stream = {}; + 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 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 dataset2Equals: boolean = dataset2.equals(dataset1); + 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: 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]; + const dataset2ToCanonical: string = dataset2.toCanonical(); + 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 dataset4Size: number = dataset4.size; + const dataset4Add: Dataset = dataset4.add(quadBnode); + const dataset4AddAllDataset: Dataset = dataset4.addAll(dataset3); + const dataset4AddAllArray: Dataset = dataset4.addAll([quadBnode]); + const dataset4Contains: boolean = dataset4.contains(dataset3); + const dataset4Delete: Dataset = dataset4.delete(quadBnode); + const dataset4DeleteMatches1: Dataset = dataset4.deleteMatches(); + const dataset4DeleteMatches2: Dataset = dataset4.deleteMatches(term); + const dataset4DeleteMatches3: Dataset = dataset4.deleteMatches(term, term); + const dataset4DeleteMatches4: Dataset = dataset4.deleteMatches(term, term, term); + const dataset4DeleteMatches5: Dataset = dataset4.deleteMatches(term, term, term, term); + const dataset4Difference: Dataset = dataset4.difference(dataset3); + const dataset4Equals: boolean = dataset4.equals(dataset3); + const dataset4Every: boolean = dataset4.every((quad: QuadBnode, dataset: Dataset) => true); + const dataset4Filter: Dataset = dataset4.filter((quad: QuadBnode, dataset: Dataset) => true); + dataset4.forEach((quad: QuadBnode, dataset: Dataset) => { + return + }); + const dataset4Has: boolean = dataset4.has(quadBnode); + const dataset4Import: Promise> = dataset4.import(stream2); + const dataset4Intersection: Dataset = dataset4.intersection(dataset3); + const dataset4Map: Dataset = dataset4.map((quad: QuadBnode, dataset: Dataset) => quad); + const dataset4Match1: Dataset = dataset4.match(); + const dataset4Match2: Dataset = dataset4.match(term); + const dataset4Match3: Dataset = dataset4.match(term, term); + const dataset4Match4: Dataset = dataset4.match(term, term, term); + const dataset4Match5: Dataset = dataset4.match(term, term, term, term); + const dataset4Reduce1: string = dataset4.reduce((acc: string, quad: QuadBnode, dataset: Dataset) => acc); + 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]; + const dataset4ToCanonical: string = dataset4.toCanonical(); + const dataset4ToStream: Stream = dataset4.toStream(); + const dataset4ToString: string = dataset4.toString(); + 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]; + 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]; + 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() { + const quad: BaseQuad = {}; + const factory: DatasetCoreFactory = {}; + + const fromQuads = factory.dataset([quad, quad]); +} + +function test_datasetFactory_covariance() { + const quad: BaseQuad = {}; + const dataset: Dataset = {}; + const factory: DatasetFactory = {}; + + const fromQuads = factory.dataset([quad, quad]); + const fromDataset = factory.dataset(dataset); +} + +async function test_dataset_covariance(): Promise { + const quad: StarQuad = {}; + const dataset: Dataset = {}; + + // rdf-ext-like quad + interface QuadExt extends StarQuad { + 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 DatasetCoreExt implements DatasetCore { + size!: number; + + add(): this { + throw new Error("Method not implemented."); + } + + delete(): this { + throw new Error("Method not implemented."); + } + + has(): boolean { + throw new Error("Method not implemented."); + } + + match(): DatasetCore { + const newInstance: DatasetCoreExt = {}; + return newInstance; + } + + [Symbol.iterator](): Iterator { + throw new Error("Method not implemented."); + } +} + +class DatasetExt extends DatasetCoreExt implements Dataset { + addAll(): this { + throw new Error("Method not implemented."); + } + + contains(): boolean { + throw new Error("Method not implemented."); + } + + deleteMatches(): this { + throw new Error("Method not implemented."); + } + + difference(): Dataset { + const newInstance: DatasetExt = {}; + return newInstance; + } + + equals(): boolean { + throw new Error("Method not implemented."); + } + + every(): boolean { + throw new Error("Method not implemented."); + } + + filter(): Dataset { + const newInstance: DatasetExt = {}; + return newInstance; + } + + forEach(): void { + throw new Error("Method not implemented."); + } + + import(): Promise { + throw new Error("Method not implemented."); + } + + intersection(): this { + throw new Error("Method not implemented."); + } + + map(): Dataset { + const newInstance: DatasetExt = {}; + return newInstance; + } + + match(): Dataset { + const newInstance: DatasetExt = {}; + return newInstance; + } + + reduce(): any { + throw new Error("Method not implemented."); + } + + some(): boolean { + throw new Error("Method not implemented."); + } + + toCanonical(): string { + throw new Error("Method not implemented."); + } + + toStream(): Stream { + throw new Error("Method not implemented."); + } + + toString(): string { + throw new Error("Method not implemented."); + } + + 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; + } + + 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(); +} 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