rdflib 2.2.17 → 2.2.18-12f6a201

package/lib/serializer.js

@@ -122,6 +122,50 @@ var Serializer = /*#__PURE__*/function () {
 
       return this.store.fromNT(s);
     }
+    /**
+     * Defines a set of [prefix, namespace] pairs to be uised by this Serializer instance.
+     * Overrides previous prefixes if any
+     * @param namespaces
+     * @return {Serializer}
+     */
+
+  }, {
+    key: "setNamespaces",
+    value: function setNamespaces(namespaces) {
+      for (var px in namespaces) {
+        this.setPrefix(px, namespaces[px]);
+      }
+
+      return this;
+    }
+    /**
+     * Defines a namespace prefix, overriding any existing prefix for that URI
+     * @param prefix
+     * @param uri
+     */
+
+  }, {
+    key: "setPrefix",
+    value: function setPrefix(prefix, uri) {
+      if (prefix.slice(0, 7) === 'default') return; // Try to weed these out
+
+      if (prefix.slice(0, 2) === 'ns') return; //  From others inferior algos
+
+      if (!prefix || !uri) return; // empty strings not suitable
+      // remove any existing prefix targeting this uri
+      // for (let existingPrefix in this.namespaces) {
+      //   if (this.namespaces[existingPrefix] == uri)
+      //     delete this.namespaces[existingPrefix];
+      // }
+      // remove any existing mapping for this prefix
+
+      for (var existingNs in this.prefixes) {
+        if (this.prefixes[existingNs] == prefix) delete this.prefixes[existingNs];
+      }
+
+      this.prefixes[uri] = prefix;
+      this.namespaces[prefix] = uri;
+    }
     /* Accumulate Namespaces
     **
     ** These are only hints.  If two overlap, only one gets used
@@ -405,13 +449,13 @@ var Serializer = /*#__PURE__*/function () {
 
         for (var i = 0; i < tree.length; i++) {
           var branch = tree[i];
-          var s2 = typeof branch === 'string' ? branch : treeToLine(branch); // Note the space before the dot in case statement ends 123. which is in fact allowed but be conservative.
+          var s2 = typeof branch === 'string' ? branch : treeToLine(branch); // Note the space before the dot in case statement ends with 123 or colon. which is in fact allowed but be conservative.
 
           if (i !== 0) {
             var ch = str.slice(-1) || ' ';
 
             if (s2 === ',' || s2 === ';') {// no gap
-            } else if (s2 === '.' && !'0123456789.'.includes(ch)) {// no gap except after number
+            } else if (s2 === '.' && !'0123456789.:'.includes(ch)) {// no gap except after number and colon
               // no gap
             } else {
               str += ' '; // separate from previous token
@@ -454,7 +498,14 @@ var Serializer = /*#__PURE__*/function () {
           if (typeof branch === 'string') {
             if (branch.length === 1 && str.slice(-1) === '\n') {
               if (',.;'.indexOf(branch) >= 0) {
-                str = str.slice(0, -1) + branch + '\n'; //  slip punct'n on end
+                str = str.slice(0, -1); // be conservative and ensure a whitespace between some chars and a final dot, as in treeToLine above
+
+                if (branch == '.' && '0123456789.:'.includes(str.charAt(str.length - 1))) {
+                  str += ' ';
+                  lastLength += 1;
+                }
+
+                str += branch + '\n'; //  slip punct'n on end
 
                 lastLength += 1;
                 continue;

package/lib/store.d.ts

@@ -299,4 +299,5 @@ export default class IndexedFormula extends Formula {
      * @param term
      */
     uris(term: Quad_Subject): string[];
+    serialize(base: any, contentType: any, provenance: any, options?: any): string | undefined;
 }

package/lib/store.js

@@ -51,12 +51,18 @@ var _namedNode = _interopRequireDefault(require("./named-node"));
 
 var _index = require("./index");
 
+var _serialize2 = _interopRequireDefault(require("./serialize"));
+
 var _blankNode = _interopRequireDefault(require("./blank-node"));
 
 var _defaultGraph = _interopRequireDefault(require("./default-graph"));
 
 var _literal = _interopRequireDefault(require("./literal"));
 
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
 function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
 
 function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
@@ -1159,6 +1165,11 @@ var IndexedFormula = /*#__PURE__*/function (_Formula) {
 
       if (prefix.slice(0, 2) === 'ns' || prefix.slice(0, 7) === 'default') {
         return;
+      } // remove any prefix that currently targets nsuri
+
+
+      for (var existingPrefix in this.namespaces) {
+        if (this.namespaces[existingPrefix] == nsuri) delete this.namespaces[existingPrefix];
       }
 
       this.namespaces[prefix] = nsuri;
@@ -1291,6 +1302,20 @@ var IndexedFormula = /*#__PURE__*/function (_Formula) {
 
       return res;
     }
+  }, {
+    key: "serialize",
+    value: function serialize(base, contentType, provenance, options) {
+      var _options;
+
+      // override Formula.serialize to force the serializer namespace prefixes
+      // to those of this IndexedFormula
+      // if namespaces are explicitly passed in options, let them override the existing namespaces in this formula
+      var namespaces = (_options = options) !== null && _options !== void 0 && _options.namespaces ? _objectSpread(_objectSpread({}, this.namespaces), options.namespaces) : _objectSpread({}, this.namespaces);
+      options = _objectSpread(_objectSpread({}, options || {}), {}, {
+        namespaces: namespaces
+      });
+      return (0, _serialize2.default)(provenance, this, base, contentType, undefined, options);
+    }
   }], [{
     key: "defaultGraphURI",
     get: function get() {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "rdflib",
   "description": "an RDF library for node.js. Suitable for client and server side.",
-  "version": "2.2.17",
+  "version": "2.2.18-12f6a201",
   "engines": {
     "node": ">=6.0"
   },

package/src/formula.ts

@@ -5,7 +5,7 @@ import log from './log'
 import RDFlibNamedNode from './named-node'
 import Namespace from './namespace'
 import Node from './node-internal'
-import Serializer from './serialize'
+import serialize from './serialize'
 import Statement from './statement'
 import {
   Bindings,
@@ -721,33 +721,11 @@ export default class Formula extends Node {
    * @param base - The base string
    * @param contentType - The content type of the syntax to use
    * @param provenance - The provenance URI
+   * @param options  - options to pass to the serializer, as defined in serialize method
    */
-  serialize (base, contentType, provenance) {
-    let documentString
-    let sts
-    let sz
-    sz = Serializer(this)
-    sz.suggestNamespaces(this.ns)
-    sz.setBase(base)
-    if (provenance) {
-      sts = this.statementsMatching(void 0, void 0, void 0, provenance)
-    } else {
-      sts = this.statements
-    }
-    switch (
-    contentType != null ? contentType : 'text/n3') {
-      case 'application/rdf+xml':
-        documentString = sz.statementsToXML(sts)
-        break
-      case 'text/n3':
-      case 'text/turtle':
-        documentString = sz.statementsToN3(sts)
-        break
-      default:
-        throw new Error('serialize: Content-type ' + contentType +
-          ' not supported.')
-    }
-    return documentString
+  serialize (base, contentType, provenance, options?) {
+    // delegate the graph serialization to the implementation in ./serialize
+    return serialize(provenance, this, base, contentType, undefined, options);
   }
 
   /**

package/src/index.ts

@@ -120,6 +120,9 @@ export {
 export { termValue } from './utils/termValue'
 
 export class ConnectedStore extends Store {
+
+  fetcher: Fetcher;
+
   constructor (features) {
     super(features)
     this.fetcher = new Fetcher(this, {})
@@ -127,6 +130,9 @@ export class ConnectedStore extends Store {
 }
 
 export class  LiveStore extends ConnectedStore {
+
+  updater: UpdateManager;
+  
   constructor (features) {
     super(features)
     this.updater = new UpdateManager(this)

package/src/jsonldparser.js

@@ -73,23 +73,8 @@ export default function jsonldParser (str, kb, base, callback) {
   return jsonld
     .flatten(JSON.parse(str), null, { base: baseString })
     .then((flattened) => flattened.reduce((store, flatResource) => {
-      const id = flatResource['@id']
-        ? kb.rdfFactory.namedNode(flatResource['@id'])
-        : kb.rdfFactory.blankNode()
-
-      for (const property of Object.keys(flatResource)) {
-        if (property === '@id') {
-          continue
-        }
-        const value = flatResource[property]
-        if (Array.isArray(value)) {
-          for (let i = 0; i < value.length; i++) {
-            kb.addStatement(createStatement(kb, id, property, value[i], base))
-          }
-        } else {
-          kb.addStatement(createStatement(kb, id, property, value, base))
-        }
-      }
+
+      kb = processResource(kb, base, flatResource)
 
       return kb
     }, kb))
@@ -97,6 +82,41 @@ export default function jsonldParser (str, kb, base, callback) {
     .catch(callback)
 }
 
+
+function processResource(kb, base, flatResource) {
+  const id = flatResource['@id']
+    ? kb.rdfFactory.namedNode(flatResource['@id'])
+    : kb.rdfFactory.blankNode()
+
+  for (const property of Object.keys(flatResource)) {
+    if (property === '@id') {
+      continue
+    } else if (property == '@graph') {
+      // the JSON-LD flattened structure may contain nested graphs
+      // the id value for this object is the new base (named graph id) for all nested flat resources
+      const graphId = id
+      // this is an array of resources
+      const nestedFlatResources = flatResource[property]
+
+      // recursively process all flat resources in the array, but with the graphId as base.
+      for (let i = 0; i < nestedFlatResources.length; i++ ) {
+        kb = processResource(kb, graphId, nestedFlatResources[i])
+      }
+    }
+
+    const value = flatResource[property]
+    if (Array.isArray(value)) {
+      for (let i = 0; i < value.length; i++) {
+        kb.addStatement(createStatement(kb, id, property, value[i], base))
+      }
+    } else {
+      kb.addStatement(createStatement(kb, id, property, value, base))
+    }
+  }
+
+  return kb
+}
+
 /**
  * Create statement quad depending on @type being a type node
  * @param kb
@@ -107,6 +127,7 @@ export default function jsonldParser (str, kb, base, callback) {
  */
 function createStatement(kb, id, property, value, base) {
   let predicate, object
+
   if (property === "@type") {
     predicate = kb.rdfFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#type")
     object = kb.rdfFactory.namedNode(value)

package/src/rdfxmlparser.js

@@ -198,7 +198,7 @@ export default class RDFParser {
 
   /**
    * Build our initial scope frame and parse the DOM into triples
-   * @param {DOMTree} document The DOM to parse
+   * @param {HTMLDocument} document The DOM to parse
    * @param {String} base The base URL to use
    * @param {Object} why The context to which this resource belongs
    */

package/src/serialize.ts

@@ -21,9 +21,9 @@ import { BlankNode, NamedNode } from './tf-types'
  */
 export default function serialize (
   /** The graph or nodes that should be serialized */
-  target: Formula | NamedNode | BlankNode,
+  target: Formula | NamedNode | BlankNode | null,
   /** The store */
-  kb?: IndexedFormula,
+  kb: Formula,
   base?: unknown,
   /**
    * The mime type.
@@ -36,10 +36,14 @@ export default function serialize (
      * A string of letters, each of which set an options
      * e.g. `deinprstux`
      */
-    flags: string
+    flags?: string,
+    /**
+     * A set of [prefix, uri] pairs that define namespace prefixes
+     */
+    namespaces?: Record<string, string>
   }
 ): string | undefined {
-  base = base || target.value
+  base = base || target?.value
   const opts = options || {}
   contentType = contentType || TurtleContentType // text/n3 if complex?
   var documentString: string | undefined = undefined
@@ -48,7 +52,17 @@ export default function serialize (
     if ((opts as any).flags) sz.setFlags((opts as any).flags)
     var newSts = kb!.statementsMatching(undefined, undefined, undefined, target as NamedNode)
     var n3String: string
-    sz.suggestNamespaces(kb!.namespaces)
+
+    // If an IndexedFormula, use the namespaces from the given graph as suggestions
+    if ('namespaces' in kb) {
+      sz.suggestNamespaces( (kb as IndexedFormula).namespaces);
+    }
+
+    // use the provided options.namespaces are mandatory prefixes
+    if (opts.namespaces) {
+      sz.setNamespaces( opts.namespaces);
+    }
+
     sz.setBase(base)
     switch (contentType) {
       case RDFXMLContentType:

package/src/serializer.js

@@ -73,6 +73,46 @@ export class Serializer {
     return this.store.fromNT(s)
   }
 
+  /**
+   * Defines a set of [prefix, namespace] pairs to be uised by this Serializer instance.
+   * Overrides previous prefixes if any
+   * @param namespaces
+   * @return {Serializer}
+   */
+  setNamespaces(namespaces) {
+    for (var px in namespaces) {
+      this.setPrefix(px, namespaces[px])
+    }
+    return this
+  }
+
+  /**
+   * Defines a namespace prefix, overriding any existing prefix for that URI
+   * @param prefix
+   * @param uri
+   */
+  setPrefix(prefix, uri) {
+    if (prefix.slice(0, 7) === 'default') return // Try to weed these out
+    if (prefix.slice(0, 2) === 'ns') return //  From others inferior algos
+    if (!prefix || !uri) return // empty strings not suitable
+
+    // remove any existing prefix targeting this uri
+    // for (let existingPrefix in this.namespaces) {
+    //   if (this.namespaces[existingPrefix] == uri)
+    //     delete this.namespaces[existingPrefix];
+    // }
+
+    // remove any existing mapping for this prefix
+    for (let existingNs in this.prefixes) {
+      if (this.prefixes[existingNs] == prefix)
+        delete this.prefixes[existingNs];
+    }
+
+    this.prefixes[uri] = prefix
+    this.namespaces[prefix] = uri
+  }
+
+
   /* Accumulate Namespaces
   **
   ** These are only hints.  If two overlap, only one gets used
@@ -300,12 +340,12 @@ export class Serializer {
       for (var i = 0; i < tree.length; i++) {
         var branch = tree[i]
         var s2 = (typeof branch === 'string') ? branch : treeToLine(branch)
-        // Note the space before the dot in case statement ends 123. which is in fact allowed but be conservative.
+        // Note the space before the dot in case statement ends with 123 or colon. which is in fact allowed but be conservative.
         if (i !== 0) {
           var ch = str.slice(-1) || ' '
           if (s2 === ',' || s2 === ';') {
             // no gap
-          } else if (s2 === '.' && !('0123456789.'.includes(ch))) { // no gap except after number
+          } else if (s2 === '.' && !('0123456789.:'.includes(ch))) { // no gap except after number and colon
             // no gap
           } else {
             str += ' ' // separate from previous token
@@ -340,7 +380,13 @@ export class Serializer {
         if (typeof branch === 'string') {
           if (branch.length === 1 && str.slice(-1) === '\n') {
             if (',.;'.indexOf(branch) >= 0) {
-              str = str.slice(0, -1) + branch + '\n' //  slip punct'n on end
+              str = str.slice(0, -1)
+              // be conservative and ensure a whitespace between some chars and a final dot, as in treeToLine above
+              if (branch == '.' && '0123456789.:'.includes(str.charAt(str.length-1))) {
+                str += ' '
+                lastLength += 1
+              }
+              str += branch + '\n' //  slip punct'n on end
               lastLength += 1
               continue
             }

package/src/store.ts

@@ -52,6 +52,7 @@ import {
   Term,
 } from './tf-types'
 import { namedNode } from './index'
+import serialize from "./serialize";
 import BlankNode from './blank-node'
 import DefaultGraph from './default-graph'
 import Empty from './empty'
@@ -1046,6 +1047,13 @@ export default class IndexedFormula extends Formula { // IN future - allow pass
     if (prefix.slice(0, 2) === 'ns' || prefix.slice(0, 7) === 'default') {
       return
     }
+
+    // remove any prefix that currently targets nsuri
+    for (let existingPrefix in this.namespaces) {
+      if (this.namespaces[existingPrefix] == nsuri)
+        delete this.namespaces[existingPrefix];
+    }
+
     this.namespaces[prefix] = nsuri
   }
 
@@ -1154,5 +1162,20 @@ export default class IndexedFormula extends Formula { // IN future - allow pass
     }
     return res
   }
+
+  serialize (base, contentType, provenance, options?) {
+
+    // override Formula.serialize to force the serializer namespace prefixes
+    // to those of this IndexedFormula
+
+    // if namespaces are explicitly passed in options, let them override the existing namespaces in this formula
+    const namespaces = options?.namespaces ? {...this.namespaces, ...options.namespaces} : {...this.namespaces};
+
+    options = {
+      ...(options || {}),
+      namespaces
+    }
+    return serialize(provenance, this, base, contentType, undefined, options);
+  }
 }
 IndexedFormula.handleRDFType = handleRDFType