rdflib 2.2.20 → 2.2.21-3a98cfb3

package/src/lists.ts

@@ -0,0 +1,121 @@
+/* Lists form conversion
+*/
+
+
+// import DataFactory from './factories/extended-term-factory'
+// import jsonldParser from './jsonldparser'
+// @ts-ignore is this injected?
+import { Parser as N3jsParser } from 'n3'  // @@ Goal: remove this dependency
+// import N3Parser from './n3parser'
+// import { parseRDFaDOM } from './rdfaparser'
+// import RDFParser from './rdfxmlparser'
+// import sparqlUpdateParser from './patch-parser'
+// import * as Util from './utils-js'
+import Node from './node-internal'
+// import BlankNode from './blank-node'
+// import NamedNode from './named-node'
+import Collection from './collection'
+import Statement from './statement'
+// import Formula from './formula'
+import Store from './store'
+// import { ContentType, TurtleContentType, N3ContentType, RDFXMLContentType, XHTMLContentType, HTMLContentType, SPARQLUpdateContentType, SPARQLUpdateSingleMatchContentType, JSONLDContentType, NQuadsContentType, NQuadsAltContentType } from './types'
+
+// import { Quad } from './tf-types'
+
+import {BlankNode, NamedNode, Quad, Term,} from './tf-types'
+import Namespace from './namespace'
+
+const RDF  = Namespace('http://www.w3.org/1999/02/22-rdf-syntax-ns#')
+
+/* Replace a given node with another node throughout a given document
+*
+* we do the predicate as well for complenesss though we don't expect Collections to use it
+*/
+export function substituteInDoc (store:Store, x:Term, y:Term, doc?: NamedNode ) {
+  // console.log(`substituteInDoc put ${x} for ${y} in ${doc}}`)
+  for (const quad of store.statementsMatching(y as any, null, null, doc as any)) {
+    const newStatement = new Statement(x as any, quad.predicate, quad.object, doc as any)
+    store.remove(quad)
+    store.add(newStatement)
+  }
+  for (const quad of store.statementsMatching(null, y as any, null, doc) as any) {
+    store.remove(quad)
+    // console.log(`  substituteInDoc predicate ${x} in ${quad}}`)
+    store.add(new Statement(quad.subject, x as any, quad.object, doc as any))
+  }
+  for (const quad of store.statementsMatching(null, null, y as any, doc) as any) {
+    store.remove(quad)
+    store.add(new Statement(quad.subject, quad.predicate, x as any, doc as any))
+  }
+}
+
+/* Change all lone rdf:nil nodes into empty Collections
+*/
+export function substituteNillsInDoc (store:Store, doc?: NamedNode) {
+  const x = RDF('nil')
+  for (const quad of store.statementsMatching(x as any, null, null, doc as any)) {
+    store.remove(quad)
+    const y = new Collection()
+    store.add(new Statement(y as any, quad.predicate, quad.object, doc as any))
+  }
+  for (const quad of store.statementsMatching(null, null, x as any, doc) as any) {
+    if (!quad.predicate.sameTerm(RDF('rest'))) { // If not a tail
+      store.remove(quad)
+      const y = new Collection()
+      store.add(new Statement(quad.subject, quad.predicate, y as any, doc as any))
+    }
+  }
+}
+/**
+ * Convert lists reified as rdf:first, rest
+ * Normal method is sync.
+ * Unfortunately jsdonld is currently written to need to be called async.
+ * Hence the mess below with executeCallback.
+ * @param store - The quadstore
+ * @param doc - The document in which the conversion is done
+ */
+
+
+export function convertFirstRestNil (
+  store: Store,
+  doc: NamedNode | undefined,  // Do whole store?
+) {
+
+  function preceding (ele:BlankNode, listSoFar: Node[], trash: Quad[]): undefined {
+
+    const rests = store.statementsMatching(ele, RDF('rest'), null, doc)
+    if (rests.length !== 1) throw new Error(`Bad list structure: no rest at ${ele}`)
+
+    const firsts = store.statementsMatching(ele, RDF('first'), null, doc)
+    if (firsts.length !== 1) throw new Error(`Bad list structure: rest but ${firsts.length} firsts at ${ele}`)
+    const value = firsts[0].object
+    const total = [value].concat(listSoFar as any)
+    // console.log('  List now is: ', total)
+    const totalTrash =  trash.concat(rests).concat(firsts)
+
+    const pres = store.statementsMatching(null, RDF('rest'), ele, doc)
+    if (pres.length === 0) { // Head of the list
+      const newList  = new Collection(total)
+      store.remove(totalTrash)
+      // Replace old list with new list:
+      substituteInDoc(store, newList, ele, doc)
+      return
+    }
+    if (pres.length !== 1) throw new Error(`Bad list structure: ${pres.length} pres at ${ele}`)
+    const pre = pres[0].subject
+    if (pre.termType !== 'BlankNode')  throw new Error(`Bad list element node ${pre} type: ${pre.termType} `)
+
+    preceding(pre, total, totalTrash)
+    return
+  }
+
+  substituteNillsInDoc(store, doc) // lone ones only
+
+  const tails = store.statementsMatching(null, RDF('rest'), RDF('nil'), doc)
+  tails.forEach(tail => {
+    if (tail.subject.termType !== 'BlankNode')
+      throw new Error(`Bad list element node ${tail.subject} type: ${tail.subject.termType} `)
+    preceding(tail.subject, [], [])
+  })
+
+}

package/src/statement.ts

@@ -137,6 +137,13 @@ export default class Statement<
 
   /** Creates a string representation of this statement */
   toString (): string {
+    /*
+    return [
+      this.subject.toString(),
+      this.predicate.toString(),
+      this.object.toString(),
+    ].join(' ') + ' .'
+    */
     return this.toNT()
   }
 }

package/src/store.ts

@@ -23,12 +23,14 @@ import Formula, { FormulaOpts } from './formula'
 import { ArrayIndexOf } from './utils'
 import { RDFArrayRemove } from './utils-js'
 import {
+  isRDFlibSubject,
+  isRDFlibPredicate,
   isRDFlibObject,
   isStore,
   isGraph,
-  isPredicate,
+  // isPredicate,
   isQuad,
-  isSubject
+  // isSubject
 } from './utils/terms'
 import Node from './node'
 import Variable from './variable'
@@ -429,10 +431,10 @@ export default class IndexedFormula extends Formula { // IN future - allow pass
     pred = Node.fromValue(pred)
     const objNode = Node.fromValue(obj) as Term
     why = Node.fromValue(why)
-    if (!isSubject(subj)) {
+    if (!isRDFlibSubject(subj)) {
       throw new Error('Subject is not a subject type')
     }
-    if (!isPredicate(pred)) {
+    if (!isRDFlibPredicate(pred)) {
       throw new Error(`Predicate ${pred} is not a predicate type`)
     }
     if (!isRDFlibObject(objNode)) {
@@ -920,9 +922,7 @@ export default class IndexedFormula extends Formula { // IN future - allow pass
     object?: Quad_Object | null,
     graph?: Quad_Graph | null
   ): IndexedFormula {
-    this.removeStatements(
-      this.statementsMatching(subject, predicate, object, graph)
-    )
+    this.removeMany(subject, predicate, object, graph)
     return this
   }
 

package/src/update-manager.ts

@@ -689,7 +689,7 @@ export default class UpdateManager {
       thisUpdater.update(deletions.filter(st => st.why.equals(doc)),
         insertions.filter(st => st.why.equals(doc))))
     if (updates.length > 1) {
-      console.log(`@@ updateMany to ${updates.length}: ${uniqueDocs}`)
+      // console.log(`@@ updateMany to ${updates.length}: ${uniqueDocs}`)
     }
     return Promise.all(updates)
   }
@@ -840,9 +840,10 @@ export default class UpdateManager {
 
         this.fire(doc.value, query, (uri, success, body, response) => {
           (response as any).elapsedTimeMs = Date.now() - startTime
-          console.log('    UpdateManager: Return ' +
+          /* console.log('    UpdateManager: Return ' +
             (success ? 'success ' : 'FAILURE ') + (response as Response).status +
             ' elapsed ' + (response as any).elapsedTimeMs + 'ms')
+            */
           if (success) {
             try {
               kb.remove(ds)

package/src/utils/terms.ts

@@ -33,7 +33,7 @@ export function isCollection(obj: any): obj is Collection<any> {
     && (obj as Term).termType === CollectionTermType
 }
 
-/** TypeGuard for valid RDFlib Object types, also allows Collections */
+/** TypeGuard for valid RDFlib Object types, also allows Collections, Graphs */
 export function isRDFlibObject(obj: any): obj is ObjectType {
   return obj && Object.prototype.hasOwnProperty.call(obj, 'termType') && (
     obj.termType === NamedNodeTermType ||
@@ -45,6 +45,28 @@ export function isRDFlibObject(obj: any): obj is ObjectType {
   )
 }
 
+/** TypeGuard for valid RDFlib Subject types, same as Object as RDFLib symmetrical.
+*/
+export function isRDFlibSubject(obj: any): obj is ObjectType {
+  return obj && Object.prototype.hasOwnProperty.call(obj, 'termType') && (
+    obj.termType === NamedNodeTermType ||
+    obj.termType === VariableTermType ||
+    obj.termType === BlankNodeTermType ||
+    obj.termType === CollectionTermType ||
+    obj.termType === LiteralTermType ||
+    obj.termType === GraphTermType
+  )
+}
+
+/** TypeGuard for valid RDF/JS spec Predicate types */
+export function isRDFlibPredicate(obj: any): obj is Quad_Predicate {
+  return isTerm(obj) && (
+    obj.termType === NamedNodeTermType ||
+    obj.termType === BlankNodeTermType ||
+    obj.termType === VariableTermType
+  )
+}
+
 /** TypeGuard for RDFLib Variables */
 export function isVariable(obj: any): obj is Variable {
   return isTerm(obj)