@lblod/graph-rdfa-processor 2.1.0

package/dist/uri-resolver.js

@@ -0,0 +1,274 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+var URIResolver =
+/*#__PURE__*/
+function () {
+  function URIResolver() {
+    _classCallCheck(this, URIResolver);
+  }
+
+  _createClass(URIResolver, [{
+    key: "parseURI",
+    value: function parseURI(uri) {
+      var match = URIResolver.SCHEME.exec(uri);
+
+      if (!match) {
+        throw new Error("Bad URI value, no scheme: " + uri);
+      }
+
+      var parsed = {
+        spec: uri
+      };
+      parsed.scheme = match[0].substring(0, match[0].length - 1);
+      parsed.schemeSpecificPart = parsed.spec.substring(match[0].length);
+
+      if (parsed.schemeSpecificPart.charAt(0) == '/' && parsed.schemeSpecificPart.charAt(1) == '/') {
+        this.parseGeneric(parsed);
+      } else {
+        parsed.isGeneric = false;
+      }
+
+      parsed.normalize = function () {
+        if (!this.isGeneric) {
+          return;
+        }
+
+        if (this.segments.length == 0) {
+          return;
+        } // edge case of ending in "/."
+
+
+        if (this.path.length > 1 && this.path.substring(this.path.length - 2) == "/.") {
+          this.path = this.path.substring(0, this.path.length - 1);
+          this.segments.splice(this.segments.length - 1, 1);
+          this.schemeSpecificPart = "//" + this.authority + this.path;
+
+          if (typeof this.query != "undefined") {
+            this.schemeSpecificPart += "?" + this.query;
+          }
+
+          if (typeof this.fragment != "undefined") {
+            this.schemeSpecificPart += "#" + this.fragment;
+          }
+
+          this.spec = this.scheme + ":" + this.schemeSpecificPart;
+          return;
+        }
+
+        var end = this.path.charAt(this.path.length - 1);
+
+        if (end != "/") {
+          end = "";
+        }
+
+        for (var i = 0; i < this.segments.length; i++) {
+          if (i > 0 && this.segments[i] == "..") {
+            this.segments.splice(i - 1, 2);
+            i -= 2;
+          }
+
+          if (this.segments[i] == ".") {
+            this.segments.splice(i, 1);
+            i--;
+          }
+        }
+
+        this.path = this.segments.length == 0 ? "/" : "/" + this.segments.join("/") + end;
+        this.schemeSpecificPart = "//" + this.authority + this.path;
+
+        if (typeof this.query != "undefined") {
+          this.schemeSpecificPart += "?" + this.query;
+        }
+
+        if (typeof this.fragment != "undefined") {
+          this.schemeSpecificPart += "#" + this.fragment;
+        }
+
+        this.spec = this.scheme + ":" + this.schemeSpecificPart;
+      };
+
+      parsed.resolve = function (href) {
+        if (!href) {
+          return this.spec;
+        }
+
+        if (href.charAt(0) == '#') {
+          var lastHash = this.spec.lastIndexOf('#');
+          return lastHash < 0 ? this.spec + href : this.spec.substring(0, lastHash) + href;
+        }
+
+        if (!this.isGeneric) {
+          throw new Error("Cannot resolve uri against non-generic URI: " + this.spec);
+        }
+
+        var colon = href.indexOf(':');
+
+        if (href.charAt(0) == '/') {
+          return this.scheme + "://" + this.authority + href;
+        } else if (href.charAt(0) == '.' && href.charAt(1) == '/') {
+          if (this.path.charAt(this.path.length - 1) == '/') {
+            return this.scheme + "://" + this.authority + this.path + href.substring(2);
+          } else {
+            var last = this.path.lastIndexOf('/');
+            return this.scheme + "://" + this.authority + this.path.substring(0, last) + href.substring(1);
+          }
+        } else if (URIResolver.SCHEME.test(href)) {
+          return href;
+        } else if (href.charAt(0) == "?") {
+          return this.scheme + "://" + this.authority + this.path + href;
+        } else {
+          if (this.path.charAt(this.path.length - 1) == '/') {
+            return this.scheme + "://" + this.authority + this.path + href;
+          } else {
+            var last = this.path.lastIndexOf('/');
+            return this.scheme + "://" + this.authority + this.path.substring(0, last + 1) + href;
+          }
+        }
+      };
+
+      parsed.relativeTo = function (otherURI) {
+        if (otherURI.scheme != this.scheme) {
+          return this.spec;
+        }
+
+        if (!this.isGeneric) {
+          throw new Error("A non generic URI cannot be made relative: " + this.spec);
+        }
+
+        if (!otherURI.isGeneric) {
+          throw new Error("Cannot make a relative URI against a non-generic URI: " + otherURI.spec);
+        }
+
+        if (otherURI.authority != this.authority) {
+          return this.spec;
+        }
+
+        var i = 0;
+
+        for (; i < this.segments.length && i < otherURI.segments.length; i++) {
+          if (this.segments[i] != otherURI.segments[i]) {
+            //alert(this.path+" different from "+otherURI.path+" at '"+this.segments[i]+"' vs '"+otherURI.segments[i]+"'");
+            var offset = otherURI.path.charAt(otherURI.path.length - 1) == '/' ? 0 : -1;
+            var relative = "";
+
+            for (var j = i; j < otherURI.segments.length + offset; j++) {
+              relative += "../";
+            }
+
+            for (var j = i; j < this.segments.length; j++) {
+              relative += this.segments[j];
+
+              if (j + 1 < this.segments.length) {
+                relative += "/";
+              }
+            }
+
+            if (this.path.charAt(this.path.length - 1) == '/') {
+              relative += "/";
+            }
+
+            return relative;
+          }
+        }
+
+        if (this.segments.length == otherURI.segments.length) {
+          return this.hash ? this.hash : this.query ? this.query : "";
+        } else if (i < this.segments.length) {
+          var relative = "";
+
+          for (var j = i; j < this.segments.length; j++) {
+            relative += this.segments[j];
+
+            if (j + 1 < this.segments.length) {
+              relative += "/";
+            }
+          }
+
+          if (this.path.charAt(this.path.length - 1) == '/') {
+            relative += "/";
+          }
+
+          return relative;
+        } else {
+          throw new Error("Cannot calculate a relative URI for " + this.spec + " against " + otherURI.spec);
+        }
+      };
+
+      return parsed;
+    }
+  }, {
+    key: "parseGeneric",
+    value: function parseGeneric(parsed) {
+      if (parsed.schemeSpecificPart.charAt(0) != '/' || parsed.schemeSpecificPart.charAt(1) != '/') {
+        throw new Error("Generic URI values should start with '//':" + parsed.spec);
+      }
+
+      var work = parsed.schemeSpecificPart.substring(2);
+      var pathStart = work.indexOf("/");
+      parsed.authority = pathStart < 0 ? work : work.substring(0, pathStart);
+      parsed.path = pathStart < 0 ? "" : work.substring(pathStart);
+      var hash = parsed.path.indexOf('#');
+
+      if (hash >= 0) {
+        parsed.fragment = parsed.path.substring(hash + 1);
+        parsed.path = parsed.path.substring(0, hash);
+      }
+
+      var questionMark = parsed.path.indexOf('?');
+
+      if (questionMark >= 0) {
+        parsed.query = parsed.path.substring(questionMark + 1);
+        parsed.path = parsed.path.substring(0, questionMark);
+      }
+
+      if (parsed.path == "/" || parsed.path == "") {
+        parsed.segments = [];
+      } else {
+        parsed.segments = parsed.path.split(/\//);
+
+        if (parsed.segments.length > 0 && parsed.segments[0] == '' && parsed.path.length > 1 && parsed.path.charAt(1) != '/') {
+          // empty segment at the start, remove it
+          parsed.segments.shift();
+        }
+
+        if (parsed.segments.length > 0 && parsed.path.length > 0 && parsed.path.charAt(parsed.path.length - 1) == '/' && parsed.segments[parsed.segments.length - 1] == '') {
+          // we may have an empty the end
+          // check to see if it is legimate
+          if (parsed.path.length > 1 && parsed.path.charAt(parsed.path.length - 2) != '/') {
+            parsed.segments.pop();
+          }
+        } // check for non-escaped characters
+
+
+        for (var i = 0; i < parsed.segments.length; i++) {
+          var check = parsed.segments[i].split(/%[A-Za-z0-9][A-Za-z0-9]|[\ud800-\udfff][\ud800-\udfff]|[A-Za-z0-9\-\._~!$&'()*+,;=@:\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+/);
+
+          for (var j = 0; j < check.length; j++) {
+            if (check[j].length > 0) {
+              throw new Error("Unecaped character " + check[j].charAt(0) + " (" + check[j].charCodeAt(0) + ") in URI " + parsed.spec);
+            }
+          }
+        }
+      }
+
+      parsed.isGeneric = true;
+    }
+  }]);
+
+  return URIResolver;
+}();
+
+exports.default = URIResolver;
+URIResolver.SCHEME = /^[A-Za-z][A-Za-z0-9\+\-\.]*\:/;
+module.exports = exports.default;

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@lblod/graph-rdfa-processor",
+  "version": "2.1.0",
+  "description": "Green turtle GraphRdfaProcessor extracted and available as a commonJS module",
+  "main": "dist/index.js",
+  "module": "src/index.js",
+  "scripts": {
+    "test": "mocha --require @babel/register --exit",
+    "prepare": "rm -rf dist && babel src --out-dir dist",
+    "postversion": "git push && git push --tags"
+  },
+  "babel": {
+    "presets": [
+      [
+        "@babel/preset-env",
+        {
+          "targets": "> 0.25%, not dead"
+        }
+      ]
+    ],
+    "plugins": [
+      "add-module-exports"
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/science-periodicals/graph-rdfa-processor.git"
+  },
+  "keywords": [
+    "RDFa"
+  ],
+  "author": "Sebastien Ballesteros",
+  "license": "Apache-2.0",
+  "bugs": {
+    "url": "https://github.com/science-periodicals/graph-rdfa-processor/issues"
+  },
+  "homepage": "https://github.com/science-periodicals/graph-rdfa-processor#readme",
+  "devDependencies": {
+    "@babel/cli": "^7.5.5",
+    "@babel/core": "^7.5.5",
+    "@babel/preset-env": "^7.5.5",
+    "@babel/register": "^7.5.5",
+    "babel-plugin-add-module-exports": "^1.0.2",
+    "jsdom": "^9.11.0",
+    "mocha": "^6.2.0"
+  }
+}

package/release.sh

@@ -0,0 +1,15 @@
+# usage: bash release.sh 0.1.2
+git checkout master
+git pull
+
+npm version $1
+npm i
+git add .
+git commit -m "version $1"
+
+echo "push tag $1..."
+git push origin v$1
+
+git push
+
+echo "done."

package/src/graph-rdfa-processor.js

@@ -0,0 +1,177 @@
+import RDFaProcessor from './rdfa-processor';
+import { RDFaSubject, RDFaPredicate } from './rdfa-graph';
+
+export default class GraphRDFaProcessor extends RDFaProcessor {
+  constructor(target) {
+    super(target);
+  }
+
+  getObjectSize(obj) {
+    var size = 0;
+    for (var key in obj) {
+      if (obj.hasOwnProperty(key)) {
+        size++;
+      }
+    }
+    return size;
+  }
+
+  init() {
+    var thisObj = this;
+    this.finishedHandlers.push(function(node) {
+      for (var subject in thisObj.target.graph.subjects) {
+        var snode = thisObj.target.graph.subjects[subject];
+        if (thisObj.getObjectSize(snode.predicates)==0) {
+          delete thisObj.target.graph.subjects[subject];
+        }
+      }
+    });
+  }
+
+  newBlankNode() {
+    return this.target.graph.newBlankNode();
+  }
+
+  newSubjectOrigin(origin,subject) {
+    var snode = this.newSubject(null,subject);
+    for (var i=0; i < snode.origins.length; i++) {
+      if (snode.origins[i]===origin) {
+        return;
+      }
+    }
+    snode.origins.push(origin);
+    if (!origin.data) {
+      Object.defineProperty(origin,"data", {
+        value: snode,
+        writable: false,
+        configurable: true,
+        enumerable: true
+      });
+    }
+  }
+
+  newSubject(origin,subject) {
+    var snode = this.target.graph.subjects[subject];
+    if (!snode) {
+      snode = new RDFaSubject(this.target.graph,subject);
+      this.target.graph.subjects[subject] = snode;
+    }
+    return snode;
+  }
+
+
+  addTriple(origin,subject,predicate,object) {
+    var snode = this.newSubject(origin,subject);
+    var pnode = snode.predicates[predicate];
+    if (!pnode) {
+      pnode = new RDFaPredicate(predicate);
+      snode.predicates[predicate] = pnode;
+    }
+
+    for (var i=0; i < pnode.objects.length; i++) {
+      if (pnode.objects[i].type==object.type && pnode.objects[i].value==object.value) {
+        if (pnode.objects[i].origin!==origin) {
+          if (!Array.isArray(pnode.objects[i].origin)) {
+            var origins = [];
+            origins.push(pnode.objects[i].origin);
+            pnode.objects[i].origin = origins;
+          }
+          pnode.objects[i].origin.push(origin);
+        }
+        return;
+      }
+    }
+    pnode.objects.push(object);
+    object.origin = origin;
+    if (predicate==RDFaProcessor.typeURI) {
+      snode.types.push(object.value);
+    }
+  }
+
+
+  copyProperties() {
+    var copySubjects = [];
+    var patternSubjects = {};
+    for (var subject in this.target.graph.subjects) {
+      var snode = this.target.graph.subjects[subject];
+      var pnode = snode.predicates[GraphRDFaProcessor.rdfaCopyPredicate];
+      if (!pnode) {
+        continue;
+      }
+      copySubjects.push(subject);
+      for (var i=0; i < pnode.objects.length; i++) {
+        if (pnode.objects[i].type!=RDFaProcessor.objectURI) {
+          continue;
+        }
+        var target = pnode.objects[i].value;
+        var patternSubjectNode = this.target.graph.subjects[target];
+        if (!patternSubjectNode) {
+          continue;
+        }
+        var patternTypes = patternSubjectNode.predicates[RDFaProcessor.typeURI];
+        if (!patternTypes) {
+          continue;
+        }
+        var isPattern = false;
+        for (var j=0; j < patternTypes.objects.length && !isPattern; j++) {
+          if (patternTypes.objects[j].value==GraphRDFaProcessor.rdfaPatternType &&
+            patternTypes.objects[j].type==RDFaProcessor.objectURI) {
+              isPattern = true;
+          }
+        }
+        if (!isPattern) {
+          continue;
+        }
+        patternSubjects[target] = true;
+        for (var predicate in patternSubjectNode.predicates) {
+          var targetPNode = patternSubjectNode.predicates[predicate];
+          if (predicate==RDFaProcessor.typeURI) {
+            if (targetPNode.objects.length==1) {
+              continue;
+            }
+            for (var j=0; j < targetPNode.objects.length; j++) {
+              if (targetPNode.objects[j].value!=GraphRDFaProcessor.rdfaPatternType) {
+                var subjectPNode = snode.predicates[predicate];
+                if (!subjectPNode) {
+                  subjectPNode = new RDFaPredicate(predicate);
+                  snode.predicates[predicate] = subjectPNode;
+                }
+                subjectPNode.objects.push(
+                  { type: targetPNode.objects[j].type,
+                    value: targetPNode.objects[j].value,
+                    language: targetPNode.objects[j].language,
+                    origin: targetPNode.objects[j].origin}
+                );
+                snode.types.push(targetPNode.objects[j].value);
+              }
+            }
+          } else {
+            var subjectPNode = snode.predicates[predicate];
+            if (!subjectPNode) {
+              subjectPNode = new RDFaPredicate(predicate);
+              snode.predicates[predicate] = subjectPNode;
+            }
+            for (var j=0; j < targetPNode.objects.length; j++) {
+              subjectPNode.objects.push(
+                { type: targetPNode.objects[j].type,
+                  value: targetPNode.objects[j].value,
+                  language: targetPNode.objects[j].language,
+                  origin: targetPNode.objects[j].origin}
+              );
+            }
+          }
+        }
+      }
+    }
+    for (var i=0; i < copySubjects.length; i++) {
+      var snode = this.target.graph.subjects[copySubjects[i]];
+      delete snode.predicates[GraphRDFaProcessor.rdfaCopyPredicate];
+    }
+    for (var subject in patternSubjects) {
+      delete this.target.graph.subjects[subject];
+    }
+  }
+};
+
+GraphRDFaProcessor.rdfaCopyPredicate = "http://www.w3.org/ns/rdfa#copy";
+GraphRDFaProcessor.rdfaPatternType = "http://www.w3.org/ns/rdfa#Pattern";

package/src/index.js

@@ -0,0 +1,21 @@
+import URIResolver from "./uri-resolver";
+import GraphRDFaProcessor from "./graph-rdfa-processor";
+import { RDFaGraph } from "./rdfa-graph";
+
+export default function(document, options = {}) {
+  let node = document.documentElement || document;
+  let baseURI = options.baseURI ? options.baseURI : node.baseURI;
+  let specialHtmlPredicates = options.specialHtmlPredicates || [];
+
+  let graph = new RDFaGraph();
+
+  let target = {
+    graph,
+    baseURI: new URIResolver().parseURI(baseURI),
+    specialHtmlPredicates,
+  };
+
+  var processor = new GraphRDFaProcessor(target);
+  processor.process(node, options);
+  return target.graph;
+}

package/src/node.js

@@ -0,0 +1,16 @@
+const Node = {
+  ELEMENT_NODE: 1,
+  ATTRIBUTE_NODE: 2,
+  TEXT_NODE: 3,
+  CDATA_SECTION_NODE: 4,
+  ENTITY_REFERENCE_NODE: 5,
+  ENTITY_NODE: 6,
+  PROCESSING_INSTRUCTION_NODE: 7,
+  COMMENT_NODE: 8,
+  DOCUMENT_NODE: 9,
+  DOCUMENT_TYPE_NODE: 10,
+  DOCUMENT_FRAGMENT_NODE: 11,
+  NOTATION_NODE:12
+};
+
+export default Node;