rdflib 2.2.19 → 2.2.20-506bc192

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/serializer.js

@@ -40,7 +40,7 @@ export class Serializer {
     this.keywords = ['a'] // The only one we generate at the moment
     this.prefixchars = 'abcdefghijklmnopqustuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
     this.incoming = null // Array not calculated yet
-    this.formulas = [] // remebering original formulae from hashes
+    this.formulas = [] // remembering original formulae from hashes
     this.store = store
     this.rdfFactory = store.rdfFactory || CanonicalDataFactory
     this.xsd = createXSD(this.rdfFactory)
@@ -74,7 +74,7 @@ export class Serializer {
   }
 
   /**
-   * Defines a set of [prefix, namespace] pairs to be uised by this Serializer instance.
+   * Defines a set of [prefix, namespace] pairs to be used by this Serializer instance.
    * Overrides previous prefixes if any
    * @param namespaces
    * @return {Serializer}
@@ -536,7 +536,7 @@ export class Serializer {
             case 'http://www.w3.org/2001/XMLSchema#integer':
               return val
 
-            case 'http://www.w3.org/2001/XMLSchema#decimal': // In urtle must have dot
+            case 'http://www.w3.org/2001/XMLSchema#decimal': // In Turtle, must have dot
               if (val.indexOf('.') < 0) val += '.0'
               return val
 
@@ -561,6 +561,8 @@ export class Serializer {
         return str
       case 'NamedNode':
         return this.symbolToN3(expr)
+      case 'DefaultGraph':
+        return '';
       default:
         throw new Error('Internal: atomicTermToN3 cannot handle ' + expr + ' of termType: ' + expr.termType)
     }
@@ -1031,4 +1033,4 @@ function backslashUify (str) {
     }
   }
   return res
-}
+}

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

@@ -5,26 +5,16 @@
 ** 2010-12-07 TimBL addred local file write code
 */
 import IndexedFormula from './store'
-import { docpart } from './uri'
-import Fetcher from './fetcher'
+import {docpart, join as uriJoin} from './uri'
+import Fetcher, {Options} from './fetcher'
 import Namespace from './namespace'
 import Serializer from './serializer'
-import { join as uriJoin } from './uri'
-import { isStore, isBlankNode } from './utils/terms'
+import {isBlankNode, isStore} from './utils/terms'
 import * as Util from './utils-js'
 import Statement from './statement'
 import RDFlibNamedNode from './named-node'
-import { termValue } from './utils/termValue'
-import {
-  BlankNode,
-  NamedNode,
-  Quad_Graph,
-  Quad_Object,
-  Quad_Predicate,
-  Quad_Subject,
-  Quad,
-  Term,
-} from './tf-types'
+import {termValue} from './utils/termValue'
+import {BlankNode, NamedNode, Quad, Quad_Graph, Quad_Object, Quad_Predicate, Quad_Subject, Term,} from './tf-types'
 
 interface UpdateManagerFormula extends IndexedFormula {
   fetcher: Fetcher
@@ -205,6 +195,10 @@ export default class UpdateManager {
       this.anonymize(stmt.object) + ' .'
   }
 
+  nTriples(stmt) {
+    return `${stmt.subject.toNT()} ${stmt.predicate.toNT()} ${stmt.object.toNT()} .`
+  }
+
   /**
    * Returns a list of all bnodes occurring in a statement
    * @private
@@ -365,7 +359,8 @@ export default class UpdateManager {
   fire (
     uri: string,
     query: string,
-    callbackFunction: CallBackFunction
+    callbackFunction: CallBackFunction,
+    options: Options = {}
   ): Promise<void> {
     return Promise.resolve()
       .then(() => {
@@ -374,11 +369,9 @@ export default class UpdateManager {
         }
         // console.log('UpdateManager: sending update to <' + uri + '>')
 
-        let options = {
-          noMeta: true,
-          contentType: 'application/sparql-update',
-          body: query
-        }
+        options.noMeta = true;
+        options.contentType = 'application/sparql-update';
+        options.body = query;
 
         return this.store.fetcher.webOperation('PATCH', uri, options)
       })
@@ -696,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)
   }
@@ -709,6 +702,7 @@ export default class UpdateManager {
    * @param insertions - Statement or statements to be inserted.
    * @param callback - called as callbackFunction(uri, success, errorbody)
    *           OR returns a promise
+   * @param options - Options for the fetch call
    */
   update(
       deletions: ReadonlyArray<Statement>,
@@ -719,7 +713,8 @@ export default class UpdateManager {
         errorBody?: string,
         response?: Response | Error
       ) => void,
-      secondTry?: boolean
+      secondTry?: boolean,
+      options: Options = {}
   ): void | Promise<void> {
     if (!callback) {
       var thisUpdater = this
@@ -730,7 +725,7 @@ export default class UpdateManager {
           } else {
             resolve()
           }
-        }) // callbackFunction
+        }, secondTry, options) // callbackFunction
       }) // promise
     } // if
 
@@ -787,10 +782,10 @@ export default class UpdateManager {
         }
         // console.log(`Update: have not loaded ${doc} before: loading now...`);
         (this.store.fetcher.load(doc) as Promise<Response>).then(response => {
-          this.update(deletions, insertions, callback, true)
+          this.update(deletions, insertions, callback, true, options)
         }, err => {
             if (err.response.status === 404) { // nonexistent files are fine
-              this.update(deletions, insertions, callback, true)
+              this.update(deletions, insertions, callback, true, options)
             } else  {
               throw new Error(`Update: Can't get updatability status ${doc} before patching: ${err}`)
             }
@@ -831,7 +826,7 @@ export default class UpdateManager {
             if (ds.length) query += ' ; '
             query += 'INSERT DATA { '
             for (let i = 0; i < is.length; i++) {
-              query += this.anonymizeNT(is[i]) + '\n'
+              query += this.nTriples(is[i]) + '\n'
             }
             query += ' }\n'
           }
@@ -845,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)
@@ -869,13 +865,13 @@ export default class UpdateManager {
             // console.log('delayed downstream action:')
             downstreamAction(doc)
           }
-        })
+        }, options)
       } else if ((protocol as string).indexOf('DAV') >= 0) {
-        this.updateDav(doc, ds, is, callback)
+        this.updateDav(doc, ds, is, callback, options)
       } else {
         if ((protocol as string).indexOf('LOCALFILE') >= 0) {
           try {
-            this.updateLocalFile(doc, ds, is, callback)
+            this.updateLocalFile(doc, ds, is, callback, options)
           } catch (e) {
             callback(doc.value, false,
               'Exception trying to write back file <' + doc.value + '>\n'
@@ -896,7 +892,8 @@ export default class UpdateManager {
     doc: Quad_Subject,
     ds,
     is,
-    callbackFunction
+    callbackFunction,
+    options: Options = {}
   ): null | Promise<void> {
     let kb = this.store
     // The code below is derived from Kenny's UpdateCenter.js
@@ -929,11 +926,9 @@ export default class UpdateManager {
       targetURI = uriJoin(candidateTarget.value, targetURI)
     }
 
-    let options = {
-      contentType,
-      noMeta: true,
-      body: documentString
-    }
+    options.contentType = contentType
+    options.noMeta = true
+    options.body = documentString
 
     return kb.fetcher.webOperation('PUT', targetURI, options)
       .then(response => {
@@ -962,8 +957,9 @@ export default class UpdateManager {
    * @param ds
    * @param is
    * @param callbackFunction
+   * @param options
    */
-  updateLocalFile (doc: NamedNode, ds, is, callbackFunction): void {
+  updateLocalFile (doc: NamedNode, ds, is, callbackFunction, options: Options = {}): void {
     const kb = this.store
     // console.log('Writing back to local file\n')
 
@@ -988,12 +984,10 @@ export default class UpdateManager {
       throw new Error('File extension .' + ext + ' not supported for data write')
     }
 
-    const documentString = this.serialize(doc.value, newSts, contentType)
+    options.body = this.serialize(doc.value, newSts, contentType);
+    options.contentType = contentType;
 
-    kb.fetcher.webOperation('PUT',doc.value,{
-      "body"      : documentString,
-      contentType : contentType,
-    }).then( (response)=>{
+    kb.fetcher.webOperation('PUT', doc.value, options).then( (response)=>{
       if(!response.ok) return callbackFunction(doc.value,false,response.error)
       for (let i = 0; i < ds.length; i++) {
         kb.remove(ds[i]);

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)