parse-domain 2.2.0 → 2.3.2

package/test/snapshots.test.js

@@ -3,10 +3,8 @@
 const fs = require("fs");
 const path = require("path");
 const chai = require("chai");
-const parsePubSuffixList = require("../lib/tries/parsePubSuffixList");
-const serializeTrie = require("../lib/tries/serializeTrie");
-const parseTrie = require("../lib/tries/parseTrie");
-const lookUp = require("../lib/tries/lookUp");
+const parsePubSuffixList = require("../lib/trie/parsePubSuffixList");
+const serializeTrie = require("../lib/trie/serializeTrie");
 
 const expect = chai.expect;
 const TEST_SNAPSHOT = true;
@@ -36,23 +34,4 @@ describe("snapshots", () => {
             fs.writeFileSync(pathToSerializeTrieSnapshot, JSON.stringify(serializedTrie));
         });
     });
-    describe("parseTrie() and lookUp() calling lookUp() with the result from parseTrie(snapshot) and hostname", () => {
-        const serializedTrie = JSON.parse(fs.readFileSync(pathToSerializeTrieSnapshot, "utf8"));
-        const parsedTrie = parseTrie(serializedTrie);
-
-        [
-            ["example.com", "com"],
-            ["example.a.com", "com"],
-            ["example.uk", "uk"],
-            ["example.co.uk", "co.uk"],
-            ["example.ab.uk", "uk"],
-        ].forEach(testArgs => {
-            const hostname = testArgs[0];
-            const expectedResult = testArgs[1];
-
-            it(`'${hostname}' returns ${expectedResult}`, () => {
-                expect(lookUp(parsedTrie, hostname)).to.equal(expectedResult);
-            });
-        });
-    });
 });

package/test/trie/lookUp.test.js

@@ -0,0 +1,99 @@
+"use strict";
+
+const chai = require("chai");
+const lookUp = require("../../lib/trie/lookUp");
+const characters = require("../../lib/trie/characters");
+const {createNode, adoptChild} = require("../../lib/trie/nodes");
+
+const expect = chai.expect;
+
+function createOneLevelDeepTrie() {
+    const root = createNode();
+    const com = createNode("com");
+
+    adoptChild(root, com);
+
+    return root;
+}
+
+function createTwoLevelDeepTrie() {
+    const root = createNode();
+    const uk = createNode("uk");
+    const co = createNode("co");
+
+    adoptChild(root, uk);
+    adoptChild(uk, co);
+
+    return root;
+}
+
+function createTrieWithWildcardAndException() {
+    const root = createNode();
+    const wildcard = createNode(characters.WILDCARD);
+    const exception = createNode(characters.EXCEPTION + "exception");
+
+    adoptChild(root, wildcard);
+    adoptChild(root, exception);
+
+    return root;
+}
+
+describe("lookUp()", () => {
+    describe("with an empty trie", () => {
+        it("returns an empty array", () => {
+            const root = createNode();
+
+            expect(lookUp(root, ["com"])).to.eql([]);
+            expect(lookUp(root, ["example", "com"])).to.eql([]);
+        });
+    });
+    describe("with a one level deep trie", () => {
+        it("returns the known TLD as array", () => {
+            const root = createOneLevelDeepTrie();
+
+            expect(lookUp(root, ["com"])).to.eql(["com"]);
+            expect(lookUp(root, ["example", "com"])).to.eql(["com"]);
+            expect(lookUp(root, ["www", "example", "com"])).to.eql(["com"]);
+        });
+        it("returns an empty array if there is no known TLD", () => {
+            const root = createOneLevelDeepTrie();
+
+            expect(lookUp(root, ["de"])).to.eql([]);
+            expect(lookUp(root, ["example", "de"])).to.eql([]);
+            expect(lookUp(root, ["www", "example", "de"])).to.eql([]);
+        });
+    });
+    describe("with a two level deep trie", () => {
+        it("returns the known TLD", () => {
+            const root = createTwoLevelDeepTrie();
+
+            expect(lookUp(root, ["uk"])).to.eql(["uk"]);
+            expect(lookUp(root, ["example", "uk"])).to.eql(["uk"]);
+            expect(lookUp(root, ["co", "uk"])).to.eql(["co", "uk"]);
+            expect(lookUp(root, ["example", "co", "uk"])).to.eql(["co", "uk"]);
+            expect(lookUp(root, ["www", "example", "co", "uk"])).to.eql(["co", "uk"]);
+        });
+
+        it("returns an empty array if there is no known TLD", () => {
+            const root = createTwoLevelDeepTrie();
+
+            expect(lookUp(root, ["de"])).to.eql([]);
+            expect(lookUp(root, ["example", "de"])).to.eql([]);
+            expect(lookUp(root, ["www", "example", "de"])).to.eql([]);
+        });
+    });
+    describe("with a wildcard and exceptions", () => {
+        it("does not accept the exception as TLD", () => {
+            const root = createTrieWithWildcardAndException();
+
+            expect(lookUp(root, ["exception"])).to.eql([]);
+            expect(lookUp(root, ["www", "exception"])).to.eql([]);
+        });
+        it("accepts all domain names as TLD in place of the wildcard", () => {
+            const root = createTrieWithWildcardAndException();
+
+            expect(lookUp(root, ["anything"])).to.eql(["anything"]);
+            expect(lookUp(root, ["www", "anything"])).to.eql(["anything"]);
+        });
+    });
+});

package/test/trie/nodes.test.js

@@ -0,0 +1,22 @@
+"use strict";
+
+const chai = require("chai");
+const {createNode, adoptChild} = require("../../lib/trie/nodes");
+
+const expect = chai.expect;
+
+describe("adoptChild()", () => {
+    it("throws an error if the child has no domain", () => {
+        expect(() => {
+            adoptChild(createNode(), createNode());
+        }).to.throw("Cannot adopt child: child.domain must be a string");
+    });
+    it("throws an error if the parent has already a child with that domain", () => {
+        expect(() => {
+            const parent = createNode();
+
+            adoptChild(parent, createNode("some-domain"));
+            adoptChild(parent, createNode("some-domain"));
+        }).to.throw("Cannot adopt child: parent has already a child with the domain 'some-domain'");
+    });
+});

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");
-    });
-});