feat(proofdict-tester): support whitelist and blacklist

src/TagFilter.ts

@@ -0,0 +1,27 @@
+// MIT © 2017 azu
+import { ProofdictItem, Proofdict } from "./proofdict-tester";
+
+const NOUN_TAG = "noun";
+
+/**
+ * Does the `dict` has "noun" tag?
+ * @param {ProofdictItem} dict
+ * @returns {boolean}
+ */
+export function isNoun(dict: ProofdictItem): boolean {
+    return dict.tags.indexOf(NOUN_TAG) !== -1;
+}
+
+export function filterByTags(dictionary: Proofdict, whitelistTags: string[] = [], blacklistTags: string[] = []) {
+    if (whitelistTags.length > 0) {
+        return dictionary.filter(item => {
+            return whitelistTags.every(whitelistTags => item.tags.indexOf(whitelistTags) !== -1);
+        });
+    }
+    if (blacklistTags.length > 0) {
+        return dictionary.filter(item => {
+            return !item.tags.some(tag => blacklistTags.indexOf(tag) !== -1);
+        });
+    }
+    return dictionary;
+}

src/proofdict-tester.ts

@@ -3,8 +3,11 @@ import { Diff, Engine } from "prh";
 import {
     wrapHyphenWordBoundary, wrapWordBoundaryToString
 } from "./proofdict-tester-util";
+import { filterByTags, isNoun } from "./TagFilter";
 
-export interface Proofdict {
+export type Proofdict = ProofdictItem[]
+
+export interface ProofdictItem {
     expected: string;
     patterns: string[];
     description: string;
@@ -40,20 +43,28 @@ export interface ProofdictTesterResult {
     diffs?: Diff[];
 }
 
-const NOUN_TAG = "noun";
+export interface ProofdictTesterOptions {
+    dictionary: Proofdict;
+    // Filter dictionary by whitelist or blacklist
+    // Default: Enable all terms of the dictionary.
+    // When set both options, this rule prefer whitelist to blacklist
+    whitelistTags?: string[];
+    blacklistTags?: string[];
+}
 
 export class ProofdictTester {
     private prhEngine: Engine;
+    private proofdict: Proofdict;
 
-    constructor(private proofdictData: Proofdict[]) {
-        this.proofdictData = proofdictData;
+    constructor(options: ProofdictTesterOptions) {
+        this.proofdict = options.dictionary;
+        const filteredProofdict = filterByTags(this.proofdict, options.whitelistTags, options.blacklistTags);
         this.prhEngine = new Engine({
             version: 1,
-            rules: proofdictData.map(dict => {
-                const isNoun = dict.tags.indexOf(NOUN_TAG) !== -1;
+            rules: filteredProofdict.map(dict => {
                 return {
                     expected: dict.expected,
-                    patterns: isNoun ? dict.patterns.map(pattern => {
+                    patterns: isNoun(dict) ? dict.patterns.map(pattern => {
                         return wrapWordBoundaryToString(pattern);
                     }) : dict.patterns,
                     tags: dict.tags,
@@ -82,8 +93,7 @@ export class ProofdictTester {
             }
             // Extension: "noun"
             // Automatically add word boundary to the patterns
-            const tags: string[] = diff.rule!.raw.tags;
-            if (tags.indexOf(NOUN_TAG) !== -1) {
+            if (isNoun(diff.rule!.raw)) {
                 const expectPatterns = wrapHyphenWordBoundary(diff.pattern);
                 const isExpected = expectPatterns.some(expectPattern => {
                     return expectPattern.test(currentString);

test/TagFilter-test.ts

@@ -0,0 +1,65 @@
+// MIT © 2017 azu
+import { Proofdict, ProofdictItem } from "../src/proofdict-tester";
+import { filterByTags } from "../src/TagFilter";
+import * as assert from "assert";
+
+const proofdict: Proofdict = require("./fixtures/proofdict.json");
+const shouldHaveTag = (tag: string) => {
+    return (item: ProofdictItem) => {
+        assert.ok(item.tags.indexOf(tag) !== -1, `item should have tag(${tag}). item: ${JSON.stringify(item)}`);
+    };
+};
+const shouldNotHaveTag = (tag: string) => {
+    return (item: ProofdictItem) => {
+        assert.ok(item.tags.indexOf(tag) === -1, `item should not have tag(${tag}). item: ${JSON.stringify(item)}`);
+    };
+};
+describe("TagFilter", () => {
+    describe("#filterByTags", () => {
+        it("whitelist options filter items", () => {
+            const whitelistTags = ["noun"];
+            const items = filterByTags(proofdict, whitelistTags);
+            items.forEach(item => {
+                shouldHaveTag("noun")(item);
+            });
+        });
+        it("whitelist options filter items by multiple tags", () => {
+            const whitelistTags = ["noun", "JavaScript"];
+            const items = filterByTags(proofdict, whitelistTags);
+            items.forEach(item => {
+                shouldHaveTag("noun")(item);
+                shouldHaveTag("JavaScript")(item);
+            });
+        });
+        it("blacklist options reject items", () => {
+            const blacklistTags = ["noun"];
+            const items = filterByTags(proofdict, [], blacklistTags);
+            items.forEach(item => {
+                shouldNotHaveTag("noun")(item);
+            });
+        });
+        it("blacklist options reject items by multiple tags", () => {
+            const blacklistTags = ["noun", "JavaScript"];
+            const items = filterByTags(proofdict, [], blacklistTags);
+            items.forEach(item => {
+                shouldNotHaveTag("noun")(item);
+                shouldNotHaveTag("JavaScript")(item);
+            });
+        });
+        it("whitelist options filter items", () => {
+            const whitelistTags = ["noun"];
+            const items = filterByTags(proofdict, whitelistTags);
+            items.forEach(item => {
+                shouldHaveTag("noun")(item);
+            });
+        });
+        it("whitelist/blacklist options, prefer to use whitelist", () => {
+            const whitelist = ["noun"];
+            const blacklistTags = ["noun"];
+            const items = filterByTags(proofdict, whitelist, blacklistTags);
+            items.forEach(item => {
+                shouldHaveTag("noun")(item);
+            });
+        });
+    })
+});

test/proofdict-tester-fixtures-test.ts

@@ -1,10 +1,10 @@
 // MIT © 2017 azu
-import { Proofdict, ProofdictTester } from "../src/proofdict-tester";
+import { ProofdictItem, ProofdictTester } from "../src/proofdict-tester";
 import * as assert from "assert";
 
 describe("ProofdictTester fixtures", () => {
-    const proofdict: Proofdict[] = require("./fixtures/proofdict.json");
-    const tester = new ProofdictTester(proofdict);
+    const proofdict: ProofdictItem[] = require("./fixtures/proofdict.json");
+    const tester = new ProofdictTester({ dictionary: proofdict });
     proofdict
         .filter(dict => dict.specs.length > 0)
         .forEach(dict => {

test/proofdict-tester-test.ts

@@ -1,12 +1,12 @@
 // MIT © 2017 azu
-import { Proofdict, ProofdictTester } from "../src/proofdict-tester";
+import { ProofdictItem, ProofdictTester } from "../src/proofdict-tester";
 import * as assert from "assert";
 
 describe("ProofdictTester", () => {
     describe("#replace", () => {
         it("should return replace result", () => {
-            const proofdict: Proofdict[] = require("./fixtures/proofdict.json");
-            const tester = new ProofdictTester(proofdict);
+            const proofdict: ProofdictItem[] = require("./fixtures/proofdict.json");
+            const tester = new ProofdictTester({ dictionary: proofdict });
             const text = "This is webkit desu.";
             return tester.replace(text).then(result => {
                 assert.strictEqual(result, "This is WebKit desu.")
@@ -15,8 +15,8 @@ describe("ProofdictTester", () => {
     });
     describe("#match", () => {
         it("last noun pattern", () => {
-            const proofdict: Proofdict[] = require("./fixtures/proofdict.json");
-            const tester = new ProofdictTester(proofdict);
+            const proofdict: ProofdictItem[] = require("./fixtures/proofdict.json");
+            const tester = new ProofdictTester({ dictionary: proofdict });
             const text = "This is webkit";
             return tester.match(text).then(result => {
                 assert.strictEqual(result.details.length, 1);
@@ -30,8 +30,8 @@ describe("ProofdictTester", () => {
             });
         });
         it("first noun pattern", () => {
-            const proofdict: Proofdict[] = require("./fixtures/proofdict.json");
-            const tester = new ProofdictTester(proofdict);
+            const proofdict: ProofdictItem[] = require("./fixtures/proofdict.json");
+            const tester = new ProofdictTester({ dictionary: proofdict });
             const text = "SourceMap is text.";
             return tester.match(text).then(result => {
                 assert.strictEqual(result.details.length, 1);
@@ -44,8 +44,8 @@ describe("ProofdictTester", () => {
             });
         });
         it("non-noun pattern", () => {
-            const proofdict: Proofdict[] = require("./fixtures/proofdict.json");
-            const tester = new ProofdictTester(proofdict);
+            const proofdict: ProofdictItem[] = require("./fixtures/proofdict.json");
+            const tester = new ProofdictTester({ dictionary: proofdict });
             const text = "Workaound is typo.";
             return tester.match(text).then(result => {
                 assert.strictEqual(result.details.length, 1);