parse-domain 2.3.1 → 2.3.2

package/test/trie/parse.test.js

@@ -0,0 +1,143 @@
+"use strict";
+
+const chai = require("chai");
+const parse = require("../../lib/trie/parse");
+
+const expect = chai.expect;
+
+describe("parse()", () => {
+    describe("when called with ''", () => {
+        it("returns a node with null as domain and no children", () => {
+            const root = parse("");
+
+            expect(root.domain).to.equal(null);
+            expect(root.children.size).to.equal(0);
+        });
+    });
+    describe("when called with 'a'", () => {
+        it("adds 'a' as child of root", () => {
+            const root = parse("a");
+
+            expect(root.children.has("a")).to.be.true;
+        });
+        it("initializes 'a' with the correct domain and parent", () => {
+            const root = parse("a");
+            const a = root.children.get("a");
+
+            expect(a.domain).to.equal("a");
+            expect(a.parent).to.equal(root);
+        });
+    });
+    describe("when called with 'a,b'", () => {
+        it("adds 'a' and 'b' as child of root", () => {
+            const root = parse("a,b");
+
+            expect(root.children.has("a")).to.be.true;
+            expect(root.children.has("b")).to.be.true;
+        });
+        it("initializes 'b' with the correct domain and parent", () => {
+            const root = parse("a,b");
+            const b = root.children.get("b");
+
+            expect(b.domain).to.equal("b");
+            expect(b.parent).to.equal(root);
+        });
+    });
+    describe("when called with 'a>b'", () => {
+        it("adds 'a' as child of root and 'b' as child of 'a'", () => {
+            const root = parse("a>b");
+
+            expect(root.children.has("a")).to.be.true;
+            expect(root.children.get("a").children.has("b")).to.be.true;
+        });
+        it("initializes 'b' with the correct domain and parent", () => {
+            const root = parse("a>b");
+            const a = root.children.get("a");
+            const b = a.children.get("b");
+
+            expect(b.domain).to.equal("b");
+            expect(b.parent).to.equal(a);
+        });
+    });
+    describe("when called with 'a>b,c'", () => {
+        it("adds 'b' and 'c' as child of 'a'", () => {
+            const root = parse("a>b,c");
+            const a = root.children.get("a");
+
+            expect(a.children.has("b")).to.be.true;
+            expect(a.children.has("c")).to.be.true;
+        });
+        it("initializes 'c' with the correct domain and parent", () => {
+            const root = parse("a>b,c");
+            const a = root.children.get("a");
+            const c = a.children.get("c");
+
+            expect(c.domain).to.equal("c");
+            expect(c.parent).to.equal(a);
+        });
+    });
+    describe("when called with 'a>b<c'", () => {
+        it("adds 'b' as child of 'a' and 'c' as child of root", () => {
+            const root = parse("a>b<c");
+            const a = root.children.get("a");
+
+            expect(a.children.has("b")).to.be.true;
+            expect(root.children.has("c")).to.be.true;
+        });
+        it("initializes 'c' with the correct domain and parent", () => {
+            const root = parse("a>b<c");
+            const c = root.children.get("c");
+
+            expect(c.domain).to.equal("c");
+            expect(c.parent).to.equal(root);
+        });
+    });
+    describe("when called with 'a|b'", () => {
+        it("adds 'a' and 'b' as child of root", () => {
+            const root = parse("a|b");
+
+            expect(root.children.has("a")).to.be.true;
+            expect(root.children.has("b")).to.be.true;
+        });
+        it("initializes 'b' with the correct domain and parent", () => {
+            const root = parse("a|b");
+            const b = root.children.get("b");
+
+            expect(b.domain).to.equal("b");
+            expect(b.parent).to.equal(root);
+        });
+    });
+    describe("when called with 'a>b|c'", () => {
+        it("adds 'b' as child of 'a' and 'c' as child of root", () => {
+            const root = parse("a>b|c");
+            const a = root.children.get("a");
+
+            expect(a.children.has("b")).to.be.true;
+            expect(root.children.has("c")).to.be.true;
+        });
+    });
+    describe("when called with 'a>b<a>d'", () => {
+        it("adds 'b' and 'd' as child of 'a'", () => {
+            const root = parse("a>b<a>c");
+            const a = root.children.get("a");
+
+            expect(a.children.has("b")).to.be.true;
+            expect(a.children.has("c")).to.be.true;
+        });
+    });
+    describe("when called with 'a>b>c'", () => {
+        it("adds 'c' as child of 'b'", () => {
+            const root = parse("a>b>c");
+            const b = root.children.get("a").children.get("b");
+
+            expect(b.children.has("c")).to.be.true;
+        });
+    });
+    describe("when called with 'a>b>c>d|e'", () => {
+        it("adds 'e' as child node of root", () => {
+            const node = parse("a>b>c>d|e");
+
+            expect(node.children.has("e")).to.be.true;
+        });
+    });
+});

package/test/{tries → trie}/parsePubSuffixList.test.js

@@ -3,7 +3,7 @@
 const fs = require("fs");
 const path = require("path");
 const chai = require("chai");
-const parsePubSuffixList = require("../../lib/tries/parsePubSuffixList");
+const parsePubSuffixList = require("../../lib/trie/parsePubSuffixList");
 
 const expect = chai.expect;
 const pathToFixtures = path.resolve(__dirname, "..", "fixtures");

package/test/{tries → trie}/serializeTrie.test.js

@@ -1,7 +1,7 @@
 "use strict";
 
 const chai = require("chai");
-const serializeTrie = require("../../lib/tries/serializeTrie");
+const serializeTrie = require("../../lib/trie/serializeTrie");
 
 const expect = chai.expect;
 

package/lib/tries/lookUp.js

@@ -1,40 +0,0 @@
-"use strict";
-
-var WILDCARD = "*";
-var EXCEPTION = "!";
-
-function lookUp(trie, hostname) {
-  var domains = hostname.split(".").reverse();
-  var tlds = [];
-  var currentTrie = trie;
-
-  for (var i = 0; i < domains.length; i++) {
-    var domain = domains[i];
-    var isWildcardRule = currentTrie.has(WILDCARD);
-
-    if (isWildcardRule) {
-      if (currentTrie.has(EXCEPTION + domain) === false) {
-        tlds.push(domain);
-      }
-
-      break;
-    }
-
-    if (currentTrie.has(domain) === false) {
-      break;
-    }
-
-    tlds.push(domain);
-    var value = currentTrie.get(domain);
-
-    if (value === true) {
-      break;
-    }
-
-    currentTrie = value;
-  }
-
-  return tlds.length === 0 ? null : tlds.reverse().join(".");
-}
-
-module.exports = lookUp;

package/lib/tries/parseTrie.js

@@ -1,62 +0,0 @@
-"use strict";
-
-var SEPARATORS = require("./separators");
-
-function parseTrie(input) {
-  var map = new Map();
-  var parentMaps = [map];
-  var domain = "";
-
-  function setDomain(value) {
-    if (domain === "") {
-      return;
-    }
-
-    map.set(domain, value);
-    domain = "";
-  }
-
-  for (var i = 0; i < input.length; i++) {
-    var _char = input.charAt(i);
-
-    switch (_char) {
-      case SEPARATORS.SAME:
-        {
-          setDomain(true);
-          continue;
-        }
-
-      case SEPARATORS.DOWN:
-        {
-          var childMap = new Map();
-          setDomain(childMap);
-          parentMaps.push(map);
-          map = childMap;
-          continue;
-        }
-
-      case SEPARATORS.RESET:
-        {
-          setDomain(true); // Remove all parent maps but the top most
-
-          parentMaps.length = 1;
-          map = parentMaps[0];
-          continue;
-        }
-
-      case SEPARATORS.UP:
-        {
-          setDomain(true);
-          map = parentMaps.pop();
-          continue;
-        }
-    }
-
-    domain += _char;
-  }
-
-  setDomain(true);
-  return parentMaps[0];
-}
-
-module.exports = parseTrie;

package/lib/tries/separators.js

@@ -1,12 +0,0 @@
-"use strict";
-
-module.exports = {
-  UP: "<",
-  // one level up
-  SAME: ",",
-  // same level
-  DOWN: ">",
-  // one level down
-  RESET: "|" // reset level index and start new
-
-};

package/test/tries/lookUp.test.js

@@ -1,116 +0,0 @@
-"use strict";
-
-const chai = require("chai");
-const lookUp = require("../../lib/tries/lookUp");
-
-const expect = chai.expect;
-
-describe("lookUp()", () => {
-    it("returns null if the trie is empty", () => {
-        const trie = new Map();
-        const hostname = "a.b.c";
-
-        expect(lookUp(trie, hostname)).to.eql(null);
-    });
-    it("returns null if the trie contains no matching top-level domain", () => {
-        const trie = new Map();
-        const hostname = "a.b.c";
-
-        trie.set("cc", true);
-
-        expect(lookUp(trie, hostname)).to.eql(null);
-    });
-    it("returns the hostname if the hostname is a top-level domain", () => {
-        const trie = new Map();
-        const hostname = "a";
-
-        trie.set("a", true);
-        trie.set("b", true);
-
-        expect(lookUp(trie, hostname)).to.eql("a");
-    });
-    it("returns the top-level domain from the hostname (2 domains)", () => {
-        const trie = new Map();
-        const hostname = "b.a";
-
-        trie.set("a", true);
-        trie.set("b", true);
-
-        expect(lookUp(trie, hostname)).to.eql("a");
-    });
-    it("returns the top-level domain from the hostname (3 domains)", () => {
-        const trie = new Map();
-        const hostname = "c.b.a";
-
-        trie.set("a", true);
-        trie.set("b", true);
-
-        expect(lookUp(trie, hostname)).to.eql("a");
-    });
-    it("returns the top-level domain (2 tlds) from the hostname (3 domains)", () => {
-        const trie = new Map();
-        const trieA = new Map();
-        const hostname = "c.b.a";
-
-        trieA.set("b", true);
-        trie.set("a", trieA);
-        trie.set("b", new Map());
-
-        expect(lookUp(trie, hostname)).to.eql("b.a");
-    });
-    it("returns the top-level domain (3 tlds) from the hostname (4 domains)", () => {
-        const trie = new Map();
-        const trieA = new Map();
-        const trieAB = new Map();
-        const hostname = "d.c.b.a";
-
-        trieAB.set("c", true);
-        trieA.set("b", trieAB);
-        trieA.set("a", true);
-        trie.set("a", trieA);
-        trie.set("b", new Map());
-
-        expect(lookUp(trie, hostname)).to.eql("c.b.a");
-    });
-    it("interprets wildcards in the trie correctly (simple)", () => {
-        const trie = new Map();
-        const hostname = "a.b.c";
-
-        trie.set("*", true);
-
-        expect(lookUp(trie, hostname)).to.eql("c");
-    });
-    it("interprets wildcards in the trie correctly (nested)", () => {
-        const trie = new Map();
-        const trieA = new Map();
-        const hostname = "c.b.a";
-
-        trieA.set("*", true);
-        trie.set("a", trieA);
-
-        expect(lookUp(trie, hostname)).to.eql("b.a");
-    });
-    it("interprets exceptions of wildcards in the trie correctly (simple)", () => {
-        const trie = new Map();
-        const trieA = new Map();
-        const hostname = "c.b.a";
-
-        trieA.set("*", true);
-        trieA.set("!b", true);
-        trie.set("a", trieA);
-
-        expect(lookUp(trie, hostname)).to.eql("a");
-    });
-    it("still handles wildcards correctly if there are non-matching exceptions", () => {
-        const trie = new Map();
-        const trieA = new Map();
-        const hostname = "c.b.a";
-
-        trieA.set("*", true);
-        trieA.set("!a", true);
-        trieA.set("!c", true);
-        trie.set("a", trieA);
-
-        expect(lookUp(trie, hostname)).to.eql("b.a");
-    });
-});

package/test/tries/parseTrie.test.js

@@ -1,162 +0,0 @@
-"use strict";
-
-const chai = require("chai");
-const parseTrie = require("../../lib/tries/parseTrie");
-
-const expect = chai.expect;
-
-describe("parseTrie()", () => {
-    describe("basic cases", () => {
-        it("returns a map", () => {
-            expect(parseTrie("")).to.be.instanceOf(Map);
-        });
-
-        it("returns an empty map when an empty string is given", () => {
-            const trie = parseTrie("");
-
-            expect(trie.size).to.equal(0);
-        });
-
-        it("returns a map with the given domain as key and true as value", () => {
-            const trie = parseTrie("some-domain");
-            const someDomain = trie.get("some-domain");
-
-            expect(someDomain).to.equal(true);
-        });
-    });
-
-    describe("with SAME separator", () => {
-        it("returns a map with the given domains as key and true as value", () => {
-            const trie = parseTrie("a,b,c");
-            const a = trie.get("a");
-            const b = trie.get("b");
-            const c = trie.get("c");
-
-            expect(a).to.equal(true);
-            expect(b).to.equal(true);
-            expect(c).to.equal(true);
-        });
-    });
-
-    describe("and with DOWN separator", () => {
-        it("returns a nested map", () => {
-            const trie = parseTrie("a>a");
-            const a = trie.get("a");
-            const aa = a.get("a");
-
-            expect(aa).to.equal(true);
-        });
-
-        it("returns a deeply nested map", () => {
-            const trie = parseTrie("a>a>a");
-            const a = trie.get("a");
-            const aa = a.get("a");
-            const aaa = aa.get("a");
-
-            expect(aa).to.be.instanceOf(Map);
-            expect(aaa).to.equal(true);
-        });
-
-        it("returns a nested map with the given domains as key and true as value", () => {
-            const trie = parseTrie("a>a,b,c");
-            const a = trie.get("a");
-            const aa = a.get("a");
-            const ab = a.get("b");
-            const ac = a.get("c");
-
-            expect(aa).to.equal(true);
-            expect(ab).to.equal(true);
-            expect(ac).to.equal(true);
-        });
-    });
-
-    describe("and with UP separator", () => {
-        it("returns a map with maps", () => {
-            const trie = parseTrie("a>a,b<b>a,b");
-            const a = trie.get("a");
-            const aa = a.get("a");
-            const ab = a.get("a");
-            const b = trie.get("b");
-            const ba = b.get("a");
-            const bb = b.get("b");
-
-            expect(aa).to.equal(true);
-            expect(ab).to.equal(true);
-            expect(ba).to.equal(true);
-            expect(bb).to.equal(true);
-        });
-
-        it("goes up multiple levels", () => {
-            const trie = parseTrie("a>a>a>a<<<b");
-            const a = trie.get("a");
-            const aa = a.get("a");
-            const aaa = aa.get("a");
-            const aaaa = aaa.get("a");
-            const b = trie.get("b");
-
-            expect(aaaa).to.equal(true);
-            expect(b).to.equal(true);
-        });
-    });
-
-    describe("and with RESET separator", () => {
-        it("resets the domain level", () => {
-            const trie = parseTrie("a>a|b");
-            const a = trie.get("a");
-            const aa = a.get("a");
-            const b = trie.get("b");
-
-            expect(aa).to.equal(true);
-            expect(b).to.equal(true);
-        });
-
-        it("works also on the top-level", () => {
-            const trie = parseTrie("a|b");
-            const a = trie.get("a");
-            const b = trie.get("b");
-
-            expect(a).to.equal(true);
-            expect(b).to.equal(true);
-        });
-
-        it("returns the expected trie", () => {
-            const trie = parseTrie("a>a>a|b>a|c");
-            const a = trie.get("a");
-            const aa = a.get("a");
-            const aaa = aa.get("a");
-            const b = trie.get("b");
-            const ba = b.get("a");
-            const c = trie.get("c");
-
-            expect(aaa).to.equal(true);
-            expect(ba).to.equal(true);
-            expect(c).to.equal(true);
-        });
-    });
-
-    describe("complex cases", () => {
-        it("parses 'a>a>a>a<<b,c|b>a>a<b>a>a,b' without errors", () => {
-            const trie = parseTrie("a>a>a>a<<b,c|b>a>a<b>a>a,b");
-            const a = trie.get("a");
-            const aa = a.get("a");
-            const aaa = aa.get("a");
-            const aaaa = aaa.get("a");
-            const ab = a.get("b");
-            const ac = a.get("c");
-            const b = trie.get("b");
-            const ba = b.get("a");
-            const baa = ba.get("a");
-            const bb = b.get("b");
-            const bba = bb.get("a");
-            const bbaa = bba.get("a");
-            const bbab = bba.get("b");
-
-            expect(aaaa).to.equal(true);
-            expect(ab).to.equal(true);
-            expect(ac).to.equal(true);
-            expect(baa).to.equal(true);
-            expect(bbaa).to.equal(true);
-            expect(bbab).to.equal(true);
-        });
-    });
-});