@lblod/graph-rdfa-processor 0.13.2

package/src/uri-resolver.js

@@ -0,0 +1,264 @@
+export default class URIResolver {
+  parseURI(uri) {
+    uri = uri.replace("\n", ""); // bugfix: sometimes there is a \n in the 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;
+  }
+
+  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(
+              "Unescaped character " +
+              check[j].charAt(0) +
+              " (" +
+              check[j].charCodeAt(0) +
+              ") in URI " +
+              parsed.spec,
+            );
+          }
+        }
+      }
+    }
+    parsed.isGeneric = true;
+  }
+}
+
+URIResolver.SCHEME = /^[A-Za-z][A-Za-z0-9\+\-\.]*\:/;

package/test/test.js

@@ -0,0 +1,50 @@
+import { jsdom } from "jsdom";
+import assert from "assert";
+import getRDFaGraph from "../src";
+import { readFileSync, writeFileSync } from "fs";
+describe("getRDFaGraph", function() {
+  let html = `<div typeof="rdfs:Class" resource="http://schema.org/CreativeWork">
+        <span class="h" property="rdfs:label">CreativeWork</span>
+        <span property="rdfs:comment">The most generic kind of creative work, including books, movies, photographs, software programs, etc.</span>
+        <span>Subclass of: <a property="rdfs:subClassOf" href="http://schema.org/Thing">Thing</a></span>
+        <span>Source:  <a property="dc:source" href="http://www.w3.org/wiki/WebSchemas/SchemaDotOrgSources#source_rNews">rNews</a></span>
+     </div>`;
+
+  let expected = `<http://schema.org/CreativeWork> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://www.w3.org/2000/01/rdf-schema#Class>;
+ <http://www.w3.org/2000/01/rdf-schema#label> "CreativeWork";
+ <http://www.w3.org/2000/01/rdf-schema#comment> "The most generic kind of creative work, including books, movies, photographs, software programs, etc.";
+ <http://www.w3.org/2000/01/rdf-schema#subClassOf> <http://schema.org/Thing>;
+ <http://purl.org/dc/terms/source> <http://www.w3.org/wiki/WebSchemas/SchemaDotOrgSources#source_rNews> .
+`;
+
+  it("should getRDFaGraph from a document", function() {
+    let { document } = jsdom(html).defaultView.window;
+    let graph = getRDFaGraph(document, { baseURI: "http://localhost" });
+    assert.equal(graph.toString(), expected);
+  });
+
+  it.only("whatever", () => {
+    let ht = readFileSync("./bug6.html");
+    let { document } = jsdom(ht).defaultView.window;
+
+    let graph = getRDFaGraph(document, {
+      baseURI: "http://localhost",
+      specialHtmlPredicates: [
+        {
+          source: "http://www.w3.org/ns/prov#value",
+          target:
+            "http://lblod.data.gift/vocabularies/besluit/extractedDecisionContent",
+        },
+      ],
+    });
+    writeFileSync("/tmp/x.ttl", graph.toString(), "utf8");
+  });
+
+  it("should getRDFaGraph from a node", function() {
+    let { document } = jsdom(html).defaultView.window;
+    let graph = getRDFaGraph(document.getElementsByTagName("div")[0], {
+      baseURI: "http://localhost",
+    });
+    assert.equal(graph.toString(), expected);
+  });
+});