rdf-dataset-ext - npm Package Compare versions

Comparing version 1.0.0 to 1.0.1

fromStream.js

@@ -0,3 +1,3 @@
+const { promisify } = require('util')
 const { finished } = require('readable-stream')
-const { promisify } = require('util')
 
@@ -4,0 +4,0 @@ async function fromStream (dataset, stream) {

package.json

 {
   "name": "rdf-dataset-ext",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Util functions for easier RDF/JS DatasetCore handling",
   "main": "index.js",
   "scripts": {
-    "test": "standard && jest --coverage"
+    "coverage": "codecov",
+    "test": "stricter-standard && c8 --reporter=lcov --reporter=text-summary mocha"
   },
@@ -27,3 +28,3 @@ "repository": {
   "dependencies": {
-    "rdf-canonize": "^1.0.3",
+    "rdf-canonize": "^3.0.0",
     "readable-stream": "^3.4.0"
@@ -35,6 +36,8 @@ },
     "@rdfjs/namespace": "^1.0.0",
+    "c8": "^7.11.0",
+    "codecov": "^3.8.3",
     "isstream": "^0.1.2",
-    "jest": "^24.8.0",
-    "standard": "^12.0.1"
+    "mocha": "^9.2.0",
+    "stricter-standard": "^0.2.0"
   }
 }

test/addAll.test.js

@@ -1,7 +0,7 @@
-/* global describe, expect, test */
-
-const addAll = require('../addAll')
+const { strictEqual } = require('assert')
+const model = require('@rdfjs/data-model')
 const dataset = require('@rdfjs/dataset')
-const model = require('@rdfjs/data-model')
 const namespace = require('@rdfjs/namespace')
+const { describe, it } = require('mocha')
+const addAll = require('../addAll')
 
@@ -12,37 +12,37 @@ const ns = namespace('http://example.org/')
 describe('addAll', () => {
-  test('adds all quads from the given dataset', () => {
+  it('should add all quads from the given dataset', () => {
     const quad1 = rdf.quad(ns.subject, ns.predicate, ns.objectA)
     const quad2 = rdf.quad(ns.subject, ns.predicate, ns.objectB)
-    const dataset1 = rdf.dataset([ quad1 ])
-    const dataset2 = rdf.dataset([ quad2 ])
+    const dataset1 = rdf.dataset([quad1])
+    const dataset2 = rdf.dataset([quad2])
 
     addAll(dataset1, dataset2)
 
-    expect(dataset1.size).toBe(2)
-    expect(dataset1.has(quad1)).toBe(true)
-    expect(dataset1.has(quad2)).toBe(true)
+    strictEqual(dataset1.size, 2)
+    strictEqual(dataset1.has(quad1), true)
+    strictEqual(dataset1.has(quad2), true)
   })
 
-  test('doesn\'t touch the added quads', () => {
+  it('should not touch the added quads', () => {
     const quad1 = rdf.quad(ns.subject, ns.predicate, ns.objectA)
     const quad2 = rdf.quad(ns.subject, ns.predicate, ns.objectB)
-    const dataset1 = rdf.dataset([ quad1 ])
-    const dataset2 = rdf.dataset([ quad2 ])
+    const dataset1 = rdf.dataset([quad1])
+    const dataset2 = rdf.dataset([quad2])
 
     addAll(dataset1, dataset2)
 
-    expect(dataset2.size).toBe(1)
-    expect(dataset2.has(quad2)).toBe(true)
+    strictEqual(dataset2.size, 1)
+    strictEqual(dataset2.has(quad2), true)
   })
 
-  test('returns the dataset instance the quads where added to', () => {
+  it('should return the dataset instance the quads where added to', () => {
     const quad1 = rdf.quad(ns.subject, ns.predicate, ns.objectA)
     const quad2 = rdf.quad(ns.subject, ns.predicate, ns.objectB)
 
-    const dataset1 = rdf.dataset([ quad1 ])
-    const dataset2 = rdf.dataset([ quad2 ])
+    const dataset1 = rdf.dataset([quad1])
+    const dataset2 = rdf.dataset([quad2])
     const dataset3 = addAll(dataset1, dataset2)
 
-    expect(dataset3).toBe(dataset1)
+    strictEqual(dataset3, dataset1)
   })
 })

test/deleteMatch.test.js

@@ -1,7 +0,7 @@
-/* global describe, expect, test */
-
-const deleteMatch = require('../deleteMatch')
+const { strictEqual } = require('assert')
+const model = require('@rdfjs/data-model')
 const dataset = require('@rdfjs/dataset')
-const model = require('@rdfjs/data-model')
 const namespace = require('@rdfjs/namespace')
+const { describe, it } = require('mocha')
+const deleteMatch = require('../deleteMatch')
 
@@ -12,3 +12,3 @@ const ns = namespace('http://example.org/')
 describe('deleteMatch', () => {
-  test('returns the given dataset instance', () => {
+  it('returns the given dataset instance', () => {
     const dataset = rdf.dataset()
@@ -18,60 +18,60 @@
 
-    expect(result).toBe(dataset)
+    strictEqual(result, dataset)
   })
 
-  test('deletes only quads which pass the subject match pattern', () => {
+  it('deletes only quads which pass the subject match pattern', () => {
     const quad1 = rdf.quad(ns.subject1, ns.predicate, ns.object, ns.graph)
     const quad2 = rdf.quad(ns.subject2, ns.predicate, ns.object, ns.graph)
-    const dataset = rdf.dataset([ quad1, quad2 ])
+    const dataset = rdf.dataset([quad1, quad2])
 
     deleteMatch(dataset, ns.subject3, null, null, null)
 
-    expect(dataset.size).toBe(2)
+    strictEqual(dataset.size, 2)
 
     deleteMatch(dataset, ns.subject2, null, null, null)
 
-    expect(dataset.size).toBe(1)
+    strictEqual(dataset.size, 1)
   })
 
-  test('deletes only quads which pass the predicate match pattern', () => {
+  it('deletes only quads which pass the predicate match pattern', () => {
     const quad1 = rdf.quad(ns.subject, ns.predicate1, ns.object, ns.graph)
     const quad2 = rdf.quad(ns.subject, ns.predicate2, ns.object, ns.graph)
-    const dataset = rdf.dataset([ quad1, quad2 ])
+    const dataset = rdf.dataset([quad1, quad2])
 
     deleteMatch(dataset, null, ns.predicate3, null, null)
 
-    expect(dataset.size).toBe(2)
+    strictEqual(dataset.size, 2)
 
     deleteMatch(dataset, null, ns.predicate2, null, null)
 
-    expect(dataset.size).toBe(1)
+    strictEqual(dataset.size, 1)
   })
 
-  test('deletes only quads which pass the object match pattern', () => {
+  it('deletes only quads which pass the object match pattern', () => {
     const quad1 = rdf.quad(ns.subject, ns.predicate, ns.object1, ns.graph)
     const quad2 = rdf.quad(ns.subject, ns.predicate, ns.object2, ns.graph)
-    const dataset = rdf.dataset([ quad1, quad2 ])
+    const dataset = rdf.dataset([quad1, quad2])
 
     deleteMatch(dataset, null, null, ns.object3, null)
 
-    expect(dataset.size).toBe(2)
+    strictEqual(dataset.size, 2)
 
     deleteMatch(dataset, null, null, ns.object2, null)
 
-    expect(dataset.size).toBe(1)
+    strictEqual(dataset.size, 1)
   })
 
-  test('deletes only quads which pass the graph match pattern', () => {
+  it('deletes only quads which pass the graph match pattern', () => {
     const quad1 = rdf.quad(ns.subject, ns.predicate, ns.object, ns.graph1)
     const quad2 = rdf.quad(ns.subject, ns.predicate, ns.object, ns.graph2)
-    const dataset = rdf.dataset([ quad1, quad2 ])
+    const dataset = rdf.dataset([quad1, quad2])
 
     deleteMatch(dataset, null, null, null, ns.graph3)
 
-    expect(dataset.size).toBe(2)
+    strictEqual(dataset.size, 2)
 
     deleteMatch(dataset, null, null, null, ns.graph2)
 
-    expect(dataset.size).toBe(1)
+    strictEqual(dataset.size, 1)
   })
 })

test/equals.test.js

@@ -1,7 +0,7 @@
-/* global describe, expect, test */
-
+const { strictEqual } = require('assert')
+const model = require('@rdfjs/data-model')
 const dataset = require('@rdfjs/dataset')
+const namespace = require('@rdfjs/namespace')
+const { describe, it } = require('mocha')
 const equals = require('../equals')
-const model = require('@rdfjs/data-model')
-const namespace = require('@rdfjs/namespace')
 
@@ -12,44 +12,44 @@ const ns = namespace('http://example.org/')
 describe('equals', () => {
-  test('returns true if both datasets are empty', () => {
+  it('returns true if both datasets are empty', () => {
     const dataset1 = rdf.dataset()
     const dataset2 = rdf.dataset()
 
-    expect(equals(dataset1, dataset2)).toBe(true)
+    strictEqual(equals(dataset1, dataset2), true)
   })
 
-  test('return true if both datasets contain the same quads', () => {
+  it('return true if both datasets contain the same quads', () => {
     const quad1 = rdf.quad(ns.subject, ns.predicate, ns.objectA)
     const quad2 = rdf.quad(ns.subject, ns.predicate, ns.objectB)
-    const dataset1 = rdf.dataset([ quad1, quad2 ])
-    const dataset2 = rdf.dataset([ quad1, quad2 ])
+    const dataset1 = rdf.dataset([quad1, quad2])
+    const dataset2 = rdf.dataset([quad1, quad2])
 
-    expect(equals(dataset1, dataset2)).toBe(true)
+    strictEqual(equals(dataset1, dataset2), true)
   })
 
-  test('return false if dataset a contains a quad not in dataset b', () => {
+  it('return false if dataset a contains a quad not in dataset b', () => {
     const quad1 = rdf.quad(ns.subject, ns.predicate, ns.objectA)
     const quad2 = rdf.quad(ns.subject, ns.predicate, ns.objectB)
-    const dataset1 = rdf.dataset([ quad1, quad2 ])
-    const dataset2 = rdf.dataset([ quad1 ])
+    const dataset1 = rdf.dataset([quad1, quad2])
+    const dataset2 = rdf.dataset([quad1])
 
-    expect(equals(dataset1, dataset2)).toBe(false)
+    strictEqual(equals(dataset1, dataset2), false)
   })
 
-  test('return false if dataset b contains a quad not in dataset a', () => {
+  it('return false if dataset b contains a quad not in dataset a', () => {
     const quad1 = rdf.quad(ns.subject, ns.predicate, ns.objectA)
     const quad2 = rdf.quad(ns.subject, ns.predicate, ns.objectB)
-    const dataset1 = rdf.dataset([ quad1 ])
-    const dataset2 = rdf.dataset([ quad1, quad2 ])
+    const dataset1 = rdf.dataset([quad1])
+    const dataset2 = rdf.dataset([quad1, quad2])
 
-    expect(equals(dataset1, dataset2)).toBe(false)
+    strictEqual(equals(dataset1, dataset2), false)
   })
 
-  test('return false if dataset a and dataset b contain the same amount of quads but different content', () => {
+  it('return false if dataset a and dataset b contain the same amount of quads but different content', () => {
     const quad1 = rdf.quad(ns.subject, ns.predicate, ns.objectA)
     const quad2 = rdf.quad(ns.subject, ns.predicate, ns.objectB)
-    const dataset1 = rdf.dataset([ quad1 ])
-    const dataset2 = rdf.dataset([ quad2 ])
+    const dataset1 = rdf.dataset([quad1])
+    const dataset2 = rdf.dataset([quad2])
 
-    expect(equals(dataset1, dataset2)).toBe(false)
+    strictEqual(equals(dataset1, dataset2), false)
   })
 })

test/fromStream.test.js

@@ -1,8 +0,8 @@
-/* global describe, expect, test */
-
-const fromStream = require('../fromStream')
+const { rejects, strictEqual } = require('assert')
+const model = require('@rdfjs/data-model')
 const dataset = require('@rdfjs/dataset')
-const model = require('@rdfjs/data-model')
 const namespace = require('@rdfjs/namespace')
+const { describe, it } = require('mocha')
 const { Readable } = require('readable-stream')
+const fromStream = require('../fromStream')
 
@@ -13,6 +13,8 @@ const ns = namespace('http://example.org/')
 describe('fromStream', () => {
-  test('returns the given dataset instance via Promise', async () => {
+  it('returns the given dataset instance via Promise', async () => {
     const stream = new Readable({
       objectMode: true,
-      read: () => { stream.push(null) }
+      read: () => {
+        stream.push(null)
+      }
     })
@@ -23,6 +25,6 @@ const dataset = rdf.dataset()
 
-    expect(result).toBe(dataset)
+    strictEqual(result, dataset)
   })
 
-  test('imports quads from stream', async () => {
+  it('imports quads from stream', async () => {
     const quad1 = rdf.quad(ns.subject1, ns.predicate, ns.object, ns.graph)
@@ -42,16 +44,18 @@ const quad2 = rdf.quad(ns.subject2, ns.predicate, ns.object, ns.graph)
 
-    expect(dataset.size).toBe(2)
-    expect(dataset.has(quad1)).toBe(true)
-    expect(dataset.has(quad2)).toBe(true)
+    strictEqual(dataset.size, 2)
+    strictEqual(dataset.has(quad1), true)
+    strictEqual(dataset.has(quad2), true)
   })
 
-  test('forwards stream errors', async () => {
+  it('forwards stream errors', async () => {
     const stream = new Readable({
       objectMode: true,
-      read: () => { stream.emit('error', new Error('test')) }
+      read: () => {
+        stream.emit('error', new Error('test'))
+      }
     })
     const dataset = rdf.dataset()
 
-    await expect(fromStream(dataset, stream)).rejects.toThrow('test')
+    await rejects(fromStream(dataset, stream))
   })
 })

test/toCanonical.test.js

@@ -1,6 +0,6 @@
-/* global describe, expect, test */
-
+const { strictEqual } = require('assert')
+const model = require('@rdfjs/data-model')
 const dataset = require('@rdfjs/dataset')
-const model = require('@rdfjs/data-model')
 const namespace = require('@rdfjs/namespace')
+const { describe, it } = require('mocha')
 const toCanonical = require('../toCanonical')
@@ -12,11 +12,11 @@
 describe('toCanonical', () => {
-  test('returns the canonical representation of the dataset', () => {
+  it('returns the canonical representation of the dataset', () => {
     const blankNode = rdf.blankNode()
     const quad1 = rdf.quad(ns.subject1, ns.predicate, blankNode, ns.graph)
     const quad2 = rdf.quad(blankNode, ns.predicate, ns.object, ns.graph)
-    const dataset = rdf.dataset([ quad1, quad2 ])
+    const dataset = rdf.dataset([quad1, quad2])
 
     const result = toCanonical(dataset)
 
-    expect(result).toBe([
+    strictEqual(result, [
       '<http://example.org/subject1> <http://example.org/predicate> _:c14n0 <http://example.org/graph> .',
@@ -28,3 +28,3 @@ '_:c14n0 <http://example.org/predicate> <http://example.org/object> <http://example.org/graph> .',
 
-  test('returns an empty string for an empty dataset', () => {
+  it('returns an empty string for an empty dataset', () => {
     const dataset = rdf.dataset()
@@ -34,4 +34,4 @@
 
-    expect(result).toBe('')
+    strictEqual(result, '')
   })
 })

test/toStream.test.js

@@ -1,10 +0,10 @@
-/* global describe, expect, test */
-
-const toStream = require('../toStream')
+const { strictEqual } = require('assert')
+const { promisify } = require('util')
+const model = require('@rdfjs/data-model')
 const dataset = require('@rdfjs/dataset')
-const model = require('@rdfjs/data-model')
+const namespace = require('@rdfjs/namespace')
 const { isReadable } = require('isstream')
-const namespace = require('@rdfjs/namespace')
+const { describe, it } = require('mocha')
 const { finished } = require('readable-stream')
-const { promisify } = require('util')
+const toStream = require('../toStream')
 
@@ -15,3 +15,3 @@ const ns = namespace('http://example.org/')
 describe('toStream', () => {
-  test('returns a Readable Stream', () => {
+  it('returns a Readable Stream', () => {
     const dataset = rdf.dataset()
@@ -21,9 +21,9 @@
 
-    expect(isReadable(result)).toBe(true)
+    strictEqual(isReadable(result), true)
   })
 
-  test('stream emits all quads of the dataset', async () => {
+  it('stream emits all quads of the dataset', async () => {
     const quad1 = rdf.quad(ns.subject1, ns.predicate, ns.object, ns.graph)
     const quad2 = rdf.quad(ns.subject2, ns.predicate, ns.object, ns.graph)
-    const dataset = rdf.dataset([ quad1, quad2 ])
+    const dataset = rdf.dataset([quad1, quad2])
 
@@ -37,6 +37,6 @@ const stream = toStream(dataset)
 
-    expect(quads.length).toBe(2)
-    expect(quads[0].equals(quad1)).toBe(true)
-    expect(quads[1].equals(quad2)).toBe(true)
+    strictEqual(quads.length, 2)
+    strictEqual(quads[0].equals(quad1), true)
+    strictEqual(quads[1].equals(quad2), true)
   })
 })

toCanonical.js

@@ -1,7 +0,7 @@
-const canonize = require('rdf-canonize')
+const URDNA2015Sync = require('rdf-canonize/lib/URDNA2015Sync.js')
 
 function toCanonical (dataset) {
-  return canonize.canonizeSync([...dataset], { algorithm: 'URDNA2015' })
+  return new URDNA2015Sync().main(dataset)
 }
 
 module.exports = toCanonical

No alert changes

Improved metrics

Total package byte prevSize

14637

increased by4.51%

Lines of code

306

increased by3.38%

Worsened metrics

Dev dependency count

8

increased by33.33%

Dependency changes

• + Addedrdf-canonize@3.4.0(transitive)

• + Addedsetimmediate@1.0.5(transitive)

• - Removednode-forge@0.10.0(transitive)

• - Removedrdf-canonize@1.2.0(transitive)

• - Removedsemver@6.3.1(transitive)

• Updatedrdf-canonize@^3.0.0