rdflib 2.2.10 → 2.2.12-5f141ca2

package/esm/named-node.js

@@ -0,0 +1,154 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _assertThisInitialized from "@babel/runtime/helpers/assertThisInitialized";
+import _inherits from "@babel/runtime/helpers/inherits";
+import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+import ClassOrder from './class-order';
+import Node from './node-internal';
+import { NamedNodeTermType } from './types';
+import { termValue } from './utils/termValue';
+import { isTerm } from './utils/terms';
+/**
+ * A named (IRI) RDF node
+ */
+
+var NamedNode = /*#__PURE__*/function (_Node) {
+  _inherits(NamedNode, _Node);
+
+  var _super = _createSuper(NamedNode);
+
+  /**
+   * Create a named (IRI) RDF Node
+   * @constructor
+   * @param iri - The IRI for this node
+   */
+  function NamedNode(iri) {
+    var _this;
+
+    _classCallCheck(this, NamedNode);
+
+    _this = _super.call(this, termValue(iri));
+
+    _defineProperty(_assertThisInitialized(_this), "termType", NamedNodeTermType);
+
+    _defineProperty(_assertThisInitialized(_this), "classOrder", ClassOrder.NamedNode);
+
+    if (!_this.value) {
+      throw new Error('Missing IRI for NamedNode');
+    }
+
+    if (!_this.value.includes(':')) {
+      throw new Error('NamedNode IRI "' + iri + '" must be absolute.');
+    }
+
+    if (_this.value.includes(' ')) {
+      var message = 'Error: NamedNode IRI "' + iri + '" must not contain unencoded spaces.';
+      throw new Error(message);
+    }
+
+    return _this;
+  }
+  /**
+   * Returns an $rdf node for the containing directory, ending in slash.
+   */
+
+
+  _createClass(NamedNode, [{
+    key: "dir",
+    value: function dir() {
+      var str = this.value.split('#')[0];
+      var p = str.slice(0, -1).lastIndexOf('/');
+      var q = str.indexOf('//');
+      if (q >= 0 && p < q + 2 || p < 0) return null;
+      return new NamedNode(str.slice(0, p + 1));
+    }
+    /**
+     * Returns an NN for the whole web site, ending in slash.
+     * Contrast with the "origin" which does NOT have a trailing slash
+     */
+
+  }, {
+    key: "site",
+    value: function site() {
+      var str = this.value.split('#')[0];
+      var p = str.indexOf('//');
+      if (p < 0) throw new Error('This URI does not have a web site part (origin)');
+      var q = str.indexOf('/', p + 2);
+
+      if (q < 0) {
+        return new NamedNode(str.slice(0) + '/'); // Add slash to a bare origin
+      } else {
+        return new NamedNode(str.slice(0, q + 1));
+      }
+    }
+    /**
+     * Creates the fetchable named node for the document.
+     * Removes everything from the # anchor tag.
+     */
+
+  }, {
+    key: "doc",
+    value: function doc() {
+      if (this.value.indexOf('#') < 0) {
+        return this;
+      } else {
+        return new NamedNode(this.value.split('#')[0]);
+      }
+    }
+    /**
+     * Returns the URI including <brackets>
+     */
+
+  }, {
+    key: "toString",
+    value: function toString() {
+      return '<' + this.value + '>';
+    }
+    /** The local identifier with the document */
+
+  }, {
+    key: "id",
+    value: function id() {
+      return this.value.split('#')[1];
+    }
+    /** Alias for value, favored by Tim */
+
+  }, {
+    key: "uri",
+    get: function get() {
+      return this.value;
+    },
+    set: function set(uri) {
+      this.value = uri;
+    }
+    /**
+     * Creates a named node from the specified input value
+     * @param value - An input value
+     */
+
+  }], [{
+    key: "fromValue",
+    value: function fromValue(value) {
+      if (typeof value === 'undefined' || value === null) {
+        return value;
+      }
+
+      if (isTerm(value)) {
+        return value;
+      }
+
+      return new NamedNode(value);
+    }
+  }]);
+
+  return NamedNode;
+}(Node);
+
+export { NamedNode as default };

package/esm/namespace.js

@@ -0,0 +1,17 @@
+import RDFlibNamedNode from './named-node';
+
+/**
+ * Gets a namespace for the specified namespace's URI
+ * @param nsuri - The URI for the namespace
+ * @param [factory] - The factory for creating named nodes with
+ */
+export default function Namespace(nsuri, factory) {
+  var dataFactory = factory || {
+    namedNode: function namedNode(value) {
+      return new RDFlibNamedNode(value);
+    }
+  };
+  return function (ln) {
+    return dataFactory.namedNode(nsuri + (ln || ''));
+  };
+}

package/esm/node-internal.js

@@ -0,0 +1,151 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+
+/**
+ * The superclass of all RDF Statement objects, that is
+ * NamedNode, Literal, BlankNode, etc.
+ * Should not be instantiated directly.
+ * Also called Term.
+ * @link https://rdf.js.org/data-model-spec/#term-interface
+ * @class Node
+ */
+var Node = /*#__PURE__*/function () {
+  // Specified in './node.ts' to prevent circular dependency
+  // Specified in './node.ts' to prevent circular dependency
+
+  /** The type of node */
+
+  /** The class order for this node */
+
+  /** The node's value */
+  function Node(value) {
+    _classCallCheck(this, Node);
+
+    _defineProperty(this, "termType", void 0);
+
+    _defineProperty(this, "classOrder", void 0);
+
+    _defineProperty(this, "value", void 0);
+
+    this.value = value;
+  }
+  /**
+   * Creates the substituted node for this one, according to the specified bindings
+   * @param bindings - Bindings of identifiers to nodes
+   */
+
+
+  _createClass(Node, [{
+    key: "substitute",
+    value: function substitute(bindings) {
+      console.log('@@@ node substitute' + this);
+      return this;
+    }
+    /**
+     * Compares this node with another
+     * @see {equals} to check if two nodes are equal
+     * @param other - The other node
+     */
+
+  }, {
+    key: "compareTerm",
+    value: function compareTerm(other) {
+      if (this.classOrder < other.classOrder) {
+        return -1;
+      }
+
+      if (this.classOrder > other.classOrder) {
+        return +1;
+      }
+
+      if (this.value < other.value) {
+        return -1;
+      }
+
+      if (this.value > other.value) {
+        return +1;
+      }
+
+      return 0;
+    }
+    /**
+     * Compares whether the two nodes are equal
+     * @param other The other node
+     */
+
+  }, {
+    key: "equals",
+    value: function equals(other) {
+      if (!other) {
+        return false;
+      }
+
+      return this.termType === other.termType && this.value === other.value;
+    }
+    /**
+     * Creates a hash for this node
+     * @deprecated use {rdfFactory.id} instead if possible
+     */
+
+  }, {
+    key: "hashString",
+    value: function hashString() {
+      return this.toCanonical();
+    }
+    /**
+     * Compares whether this node is the same as the other one
+     * @param other - Another node
+     */
+
+  }, {
+    key: "sameTerm",
+    value: function sameTerm(other) {
+      return this.equals(other);
+    }
+    /**
+     * Creates a canonical string representation of this node
+     */
+
+  }, {
+    key: "toCanonical",
+    value: function toCanonical() {
+      return this.toNT();
+    }
+    /**
+     * Creates a n-triples string representation of this node
+     */
+
+  }, {
+    key: "toNT",
+    value: function toNT() {
+      return this.toString();
+    }
+    /**
+     * Creates a n-quads string representation of this node
+     */
+
+  }, {
+    key: "toNQ",
+    value: function toNQ() {
+      return this.toNT();
+    }
+    /**
+     * Creates a string representation of this node
+     */
+
+  }, {
+    key: "toString",
+    value: function toString() {
+      throw new Error('Node.toString() is abstract - see the subclasses instead');
+    }
+  }]);
+
+  return Node;
+}();
+
+_defineProperty(Node, "fromValue", void 0);
+
+_defineProperty(Node, "toJS", void 0);
+
+export { Node as default };

package/esm/node.js

@@ -0,0 +1,46 @@
+// This file attaches all functionality to Node
+// that would otherwise require circular dependencies.
+import { fromValue } from './collection';
+import Node from './node-internal';
+import Namespace from './namespace';
+import { isCollection, isLiteral } from './utils/terms';
+
+/**
+ * Creates an RDF Node from a native javascript value.
+ * RDF Nodes are returned unchanged, undefined returned as itself.
+ * @method fromValue
+ * @static
+ * @param value {Node|Date|String|Number|Boolean|Undefined}
+ * @return {Node|Collection}
+ */
+Node.fromValue = fromValue;
+export default Node;
+var ns = {
+  xsd: Namespace('http://www.w3.org/2001/XMLSchema#')
+};
+/**
+ * Gets the javascript object equivalent to a node
+ * @param term The RDF node
+ */
+
+Node.toJS = function (term) {
+  if (isCollection(term)) {
+    return term.elements.map(Node.toJS); // Array node (not standard RDFJS)
+  }
+
+  if (!isLiteral(term)) return term;
+
+  if (term.datatype.equals(ns.xsd('boolean'))) {
+    return term.value === '1' || term.value === 'true';
+  }
+
+  if (term.datatype.equals(ns.xsd('dateTime')) || term.datatype.equals(ns.xsd('date'))) {
+    return new Date(term.value);
+  }
+
+  if (term.datatype.equals(ns.xsd('integer')) || term.datatype.equals(ns.xsd('float')) || term.datatype.equals(ns.xsd('decimal'))) {
+    return Number(term.value);
+  }
+
+  return term.value;
+};

package/esm/parse.js

@@ -0,0 +1,138 @@
+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 { TurtleContentType, N3ContentType, RDFXMLContentType, XHTMLContentType, HTMLContentType, SPARQLUpdateContentType, SPARQLUpdateSingleMatchContentType, JSONLDContentType, NQuadsContentType, NQuadsAltContentType } from './types';
+
+/**
+ * Parse a string and put the result into the graph kb.
+ * Normal method is sync.
+ * Unfortunately jsdonld is currently written to need to be called async.
+ * Hence the mess below with executeCallback.
+ * @param str - The input string to parse
+ * @param kb - The store to use
+ * @param base - The base URI to use
+ * @param contentType - The MIME content type string for the input - defaults to text/turtle
+ * @param [callback] - The callback to call when the data has been loaded
+ */
+export default function parse(str, kb, base) {
+  var contentType = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 'text/turtle';
+  var callback = arguments.length > 4 ? arguments[4] : undefined;
+  contentType = contentType || TurtleContentType;
+  contentType = contentType.split(';')[0];
+
+  try {
+    if (contentType === N3ContentType || contentType === TurtleContentType) {
+      var p = N3Parser(kb, kb, base, base, null, null, '', null);
+      p.loadBuf(str);
+      executeCallback();
+    } else if (contentType === RDFXMLContentType) {
+      var parser = new RDFParser(kb);
+      parser.parse(Util.parseXML(str), base, kb.sym(base));
+      executeCallback();
+    } else if (contentType === XHTMLContentType) {
+      parseRDFaDOM(Util.parseXML(str, {
+        contentType: XHTMLContentType
+      }), kb, base);
+      executeCallback();
+    } else if (contentType === HTMLContentType) {
+      parseRDFaDOM(Util.parseXML(str, {
+        contentType: HTMLContentType
+      }), kb, base);
+      executeCallback();
+    } else if (contentType === SPARQLUpdateContentType || contentType === SPARQLUpdateSingleMatchContentType) {
+      // @@ we handle a subset
+      sparqlUpdateParser(str, kb, base);
+      executeCallback();
+    } else if (contentType === JSONLDContentType) {
+      jsonldParser(str, kb, base, executeCallback);
+    } else if (contentType === NQuadsContentType || contentType === NQuadsAltContentType) {
+      var n3Parser = new N3jsParser({
+        factory: DataFactory
+      });
+      nquadCallback(null, str);
+    } else if (contentType === undefined) {
+      throw new Error("contentType is undefined");
+    } else {
+      throw new Error("Don't know how to parse " + contentType + ' yet');
+    }
+  } catch (e) {
+    // @ts-ignore
+    executeErrorCallback(e);
+  }
+
+  parse.handled = {
+    'text/n3': true,
+    'text/turtle': true,
+    'application/rdf+xml': true,
+    'application/xhtml+xml': true,
+    'text/html': true,
+    'application/sparql-update': true,
+    'application/sparql-update-single-match': true,
+    'application/ld+json': true,
+    'application/nquads': true,
+    'application/n-quads': true
+  };
+
+  function executeCallback() {
+    if (callback) {
+      callback(null, kb);
+    } else {
+      return;
+    }
+  }
+
+  function executeErrorCallback(e) {
+    if ( // TODO: Always true, what is the right behavior
+    contentType !== JSONLDContentType || // @ts-ignore always true?
+    contentType !== NQuadsContentType || // @ts-ignore always true?
+    contentType !== NQuadsAltContentType) {
+      if (callback) {
+        callback(e, kb);
+      } else {
+        var e2 = new Error('' + e + ' while trying to parse <' + base + '> as ' + contentType); //@ts-ignore .cause is not a default error property
+
+        e2.cause = e;
+        throw e2;
+      }
+    }
+  }
+  /*
+    function setJsonLdBase (doc, base) {
+      if (doc instanceof Array) {
+        return
+      }
+      if (!('@context' in doc)) {
+        doc['@context'] = {}
+      }
+      doc['@context']['@base'] = base
+    }
+  */
+
+
+  function nquadCallback(err, nquads) {
+    if (err) {
+      callback(err, kb);
+    }
+
+    try {
+      n3Parser.parse(nquads, tripleCallback);
+    } catch (err) {
+      callback(err, kb);
+    }
+  }
+
+  function tripleCallback(err, triple) {
+    if (triple) {
+      kb.add(triple.subject, triple.predicate, triple.object, triple.graph);
+    } else {
+      callback(err, kb);
+    }
+  }
+}

package/esm/patch-parser.js

@@ -0,0 +1,110 @@
+// Parse a simple SPARL-Update subset syntax for patches.
+//
+//  This parses
+//   WHERE {xxx} DELETE {yyy} INSERT DATA {zzz}
+// (not necessarily in that order)
+// as though it were the n3
+//   <#query> patch:where {xxx}; patch:delete {yyy}; patch:insert {zzz}.
+import N3Parser from './n3parser';
+import Namespace from './namespace';
+export default function sparqlUpdateParser(str, kb, base) {
+  var i, j, k;
+  var keywords = ['INSERT', 'DELETE', 'WHERE'];
+  var SQNS = Namespace('http://www.w3.org/ns/pim/patch#');
+  var p = N3Parser(kb, kb, base, base, null, null, '', null);
+  var clauses = {};
+
+  var badSyntax = function badSyntax(uri, lines, str, i, why) {
+    return 'Line ' + (lines + 1) + ' of <' + uri + '>: Bad syntax:\n   ' + why + '\n   at: "' + str.slice(i, i + 30) + '"';
+  }; // var check = function (next, last, message) {
+  //   if (next < 0) {
+  //     throw badSyntax(p._thisDoc, p.lines, str, j, last, message)
+  //   }
+  //   return next
+  // }
+
+
+  i = 0;
+  var query = kb.sym(base + '#query'); // Invent a URI for the query
+
+  clauses['query'] = query; // A way of accessing it in its N3 model.
+
+  while (true) {
+    // console.log("A Now at i = " + i)
+    j = p.skipSpace(str, i);
+
+    if (j < 0) {
+      return clauses;
+    } // console.log("B After space at j= " + j)
+
+
+    if (str[j] === ';') {
+      i = p.skipSpace(str, j + 1);
+
+      if (i < 0) {
+        return clauses; // Allow end in a
+      }
+
+      j = i;
+    }
+
+    var found = false;
+
+    for (k = 0; k < keywords.length; k++) {
+      var key = keywords[k];
+
+      if (str.slice(j, j + key.length) === key) {
+        i = p.skipSpace(str, j + key.length);
+
+        if (i < 0) {
+          throw badSyntax(p._thisDoc, p.lines, str, j + key.length, 'found EOF, needed {...} after ' + key);
+        }
+
+        if ((key === 'INSERT' || key === 'DELETE') && str.slice(i, i + 4) === 'DATA') {
+          // Some wanted 'DATA'. Whatever
+          j = p.skipSpace(str, i + 4);
+
+          if (j < 0) {
+            throw badSyntax(p._thisDoc, p.lines, str, i + 4, 'needed {...} after INSERT DATA ' + key);
+          }
+
+          i = j;
+        }
+
+        var res2 = [];
+        j = p.node(str, i, res2); // Parse all the complexity of the clause
+
+        if (j < 0) {
+          throw badSyntax(p._thisDoc, p.lines, str, i, 'bad syntax or EOF in {...} after ' + key);
+        }
+
+        clauses[key.toLowerCase()] = res2[0];
+        kb.add(query, SQNS(key.toLowerCase()), res2[0]); // , kb.sym(base)
+        // key is the keyword and res2 has the contents
+
+        found = true;
+        i = j;
+      }
+    }
+
+    if (!found && str.slice(j, j + 7) === '@prefix') {
+      i = p.directive(str, j);
+
+      if (i < 0) {
+        throw badSyntax(p._thisDoc, p.lines, str, i, 'bad syntax or EOF after @prefix ');
+      } // console.log("P before dot i= " + i)
+
+
+      i = p.checkDot(str, i); // console.log("Q after dot i= " + i)
+
+      found = true;
+    }
+
+    if (!found) {
+      // console.log("Bad syntax " + j)
+      throw badSyntax(p._thisDoc, p.lines, str, j, "Unknown syntax at start of statememt: '" + str.slice(j).slice(0, 20) + "'");
+    }
+  } // while
+  // return clauses
+
+}

package/esm/query-to-sparql.js

@@ -0,0 +1,83 @@
+import log from './log';
+export default function queryToSPARQL(query) {
+  var indent = 0;
+
+  function getSelect(query) {
+    var str = addIndent() + 'SELECT ';
+
+    for (var i = 0; i < query.vars.length; i++) {
+      str += query.vars[i] + ' ';
+    }
+
+    str += '\n';
+    return str;
+  }
+
+  function getPattern(pat) {
+    var str = '';
+    var st = pat.statements;
+
+    for (var x in st) {
+      log.debug('Found statement: ' + st);
+      str += addIndent() + st[x] + '\n';
+    }
+
+    return str;
+  }
+
+  function getConstraints(pat) {
+    var str = '';
+
+    for (var v in pat.constraints) {
+      var foo = pat.constraints[v];
+      str += addIndent() + 'FILTER ( ' + foo.describe(v) + ' ) ' + '\n';
+    }
+
+    return str;
+  }
+
+  function getOptionals(pat) {
+    var str = '';
+
+    for (var x = 0; x < pat.optional.length; x++) {
+      // alert(pat.optional.termType)
+      log.debug('Found optional query');
+      str += addIndent() + 'OPTIONAL { ' + '\n';
+      indent++;
+      str += getPattern(pat.optional[x]);
+      str += getConstraints(pat.optional[x]);
+      str += getOptionals(pat.optional[x]);
+      indent--;
+      str += addIndent() + '}' + '\n';
+    }
+
+    return str;
+  }
+
+  function getWhere(pat) {
+    var str = addIndent() + 'WHERE \n' + '{ \n';
+    indent++;
+    str += getPattern(pat);
+    str += getConstraints(pat);
+    str += getOptionals(pat);
+    indent--;
+    str += '}';
+    return str;
+  }
+
+  function addIndent() {
+    var str = '';
+
+    for (var i = 0; i < indent; i++) {
+      str += '    ';
+    }
+
+    return str;
+  }
+
+  function getSPARQL(query) {
+    return getSelect(query) + getWhere(query.pat);
+  }
+
+  return getSPARQL(query);
+}