Add partial blacklist item

src/content/controllers/SettingController.ts

@@ -15,7 +15,8 @@ export default class SettingController {
   async initSettings(): Promise<void> {
     try {
       let current = await this.settingUseCase.reload();
-      let disabled = current.blacklist.includes(window.location.href);
+      let url = new URL(window.location.href);
+      let disabled = current.blacklist.includesEntireBlacklist(url);
       if (disabled) {
         this.addonEnabledUseCase.disable();
       } else {

src/shared/settings/Blacklist.ts

@@ -1,39 +1,117 @@
-export type BlacklistJSON = string[];
+export type BlacklistItemJSON = string | {
+  url: string,
+  keys: string[],
+};
+
+export type BlacklistJSON = BlacklistItemJSON[];
 
-const fromWildcard = (pattern: string): RegExp => {
+const regexFromWildcard = (pattern: string): RegExp => {
   let regexStr = '^' + pattern.replace(/\*/g, '.*') + '$';
   return new RegExp(regexStr);
 };
 
+const isArrayOfString = (raw: any): boolean => {
+  if (!Array.isArray(raw)) {
+    return false;
+  }
+  for (let x of Array.from(raw)) {
+    if (typeof x !== 'string') {
+      return false;
+    }
+  }
+  return true;
+};
+
+export class BlacklistItem {
+  public readonly pattern: string;
+
+  private regex: RegExp;
+
+  public readonly partial: boolean;
+
+  public readonly keys: string[];
+
+  private constructor(
+    pattern: string,
+    partial: boolean,
+    keys: string[]
+  ) {
+    this.pattern = pattern;
+    this.regex = regexFromWildcard(pattern);
+    this.partial = partial;
+    this.keys = keys;
+  }
+
+  static fromJSON(raw: any): BlacklistItem {
+    if (typeof raw === 'string') {
+      return new BlacklistItem(raw, false, []);
+    } else if (typeof raw === 'object' && raw !== null) {
+      if (!('url' in raw)) {
+        throw new TypeError(
+          `missing field "url" of blacklist item: ${JSON.stringify(raw)}`);
+      }
+      if (typeof raw.url !== 'string') {
+        throw new TypeError(
+          `invalid field "url" of blacklist item: ${JSON.stringify(raw)}`);
+      }
+      if (!('keys' in raw)) {
+        throw new TypeError(
+          `missing field "keys" of blacklist item: ${JSON.stringify(raw)}`);
+      }
+      if (!isArrayOfString(raw.keys)) {
+        throw new TypeError(
+          `invalid field "keys" of blacklist item: ${JSON.stringify(raw)}`);
+      }
+      return new BlacklistItem(raw.url as string, true, raw.keys as string[]);
+    }
+    throw new TypeError(
+      `invalid format of blacklist item: ${JSON.stringify(raw)}`);
+  }
+
+  toJSON(): BlacklistItemJSON {
+    if (!this.partial) {
+      return this.pattern;
+    }
+    return { url: this.pattern, keys: this.keys };
+  }
+
+  matches(url: URL): boolean {
+    return this.pattern.includes('/')
+      ? this.regex.test(url.host + url.pathname)
+      : this.regex.test(url.host);
+  }
+
+  includeKey(url: URL, keys: string): boolean {
+    if (!this.matches(url)) {
+      return false;
+    }
+    return !this.partial || this.keys.includes(keys);
+  }
+}
+
 export default class Blacklist {
   constructor(
-    private blacklist: string[],
+    private blacklist: BlacklistItem[],
   ) {
   }
 
   static fromJSON(json: any): Blacklist {
     if (!Array.isArray(json)) {
-      throw new TypeError(`"blacklist" is not an array of string`);
+      throw new TypeError('blacklist is not an array: ' + JSON.stringify(json));
-    }
-    for (let x of json) {
-      if (typeof x !== 'string') {
-        throw new TypeError(`"blacklist" is not an array of string`);
-      }
     }
-    return new Blacklist(json);
+    let items = Array.from(json).map(item => BlacklistItem.fromJSON(item));
+    return new Blacklist(items);
   }
 
   toJSON(): BlacklistJSON {
-    return this.blacklist;
+    return this.blacklist.map(item => item.toJSON());
   }
 
-  includes(url: string): boolean {
+  includesEntireBlacklist(url: URL): boolean {
-    let u = new URL(url);
+    return this.blacklist.some(item => !item.partial && item.matches(url));
-    return this.blacklist.some((item) => {
+  }
-      if (!item.includes('/')) {
+
-        return fromWildcard(item).test(u.host);
+  includeKey(url: URL, key: string) {
-      }
+    return this.blacklist.some(item => item.includeKey(url, key));
-      return fromWildcard(item).test(u.host + u.pathname);
-    });
   }
 }

test/shared/settings/Blacklist.test.ts

@@ -1,77 +1,155 @@
-import Blacklist from '../../../src/shared/settings/Blacklist';
+import Blacklist, { BlacklistItem } from '../../../src/shared/settings/Blacklist';
 import { expect } from 'chai';
 
-describe('Blacklist', () => {
+describe('BlacklistItem', () => {
-  describe('fromJSON', () => {
+  describe('#fromJSON', () => {
-    it('returns empty array by empty settings', () => {
+    it('parses string pattern', () => {
-      let blacklist = Blacklist.fromJSON([]);
+      let item = BlacklistItem.fromJSON('example.com');
-      expect(blacklist.toJSON()).to.be.empty;
+      expect(item.pattern).to.equal('example.com');
+      expect(item.partial).to.be.false;
     });
 
-    it('returns blacklist by valid settings', () => {
+    it('parses partial blacklist item', () => {
-      let blacklist = Blacklist.fromJSON([
+      let item = BlacklistItem.fromJSON({ url: 'example.com', keys: ['j', 'k']});
-        'github.com',
+      expect(item.pattern).to.equal('example.com');
-        'circleci.com',
+      expect(item.partial).to.be.true;
-      ]);
+      expect(item.keys).to.deep.equal(['j', 'k']);
-
-      expect(blacklist.toJSON()).to.deep.equal([
-        'github.com',
-        'circleci.com',
-      ]);
     });
 
-    it('throws a TypeError by invalid settings', () => {
+    it('throws a TypeError', () => {
-      expect(() => Blacklist.fromJSON(null)).to.throw(TypeError);
+      expect(() => BlacklistItem.fromJSON(null)).to.throw(TypeError);
-      expect(() => Blacklist.fromJSON({})).to.throw(TypeError);
+      expect(() => BlacklistItem.fromJSON(100)).to.throw(TypeError);
-      expect(() => Blacklist.fromJSON([1,2,3])).to.throw(TypeError);
+      expect(() => BlacklistItem.fromJSON({})).to.throw(TypeError);
+      expect(() => BlacklistItem.fromJSON({url: 'google.com'})).to.throw(TypeError);
+      expect(() => BlacklistItem.fromJSON({keys: ['a']})).to.throw(TypeError);
+      expect(() => BlacklistItem.fromJSON({url: 'google.com', keys: 10})).to.throw(TypeError);
+      expect(() => BlacklistItem.fromJSON({url: 'google.com', keys: ['a', 'b', 3]})).to.throw(TypeError);
     });
   });
 
-  describe('#includes', () => {
+  describe('#matches', () => {
-    it('matches by *', () => {
+    it('matches by "*"', () => {
-      let blacklist = new Blacklist(['*']);
+      let item = BlacklistItem.fromJSON('*');
-
+      expect(item.matches(new URL('https://github.com/abc'))).to.be.true;
-      expect(blacklist.includes('https://github.com/abc')).to.be.true;
     });
 
     it('matches by hostname', () => {
-      let blacklist = new Blacklist(['github.com']);
+      let item = BlacklistItem.fromJSON('github.com');
-
+      expect(item.matches(new URL('https://github.com'))).to.be.true;
-      expect(blacklist.includes('https://github.com')).to.be.true;
+      expect(item.matches(new URL('https://gist.github.com'))).to.be.false;
-      expect(blacklist.includes('https://gist.github.com')).to.be.false;
+      expect(item.matches(new URL('https://github.com/ueokande'))).to.be.true;
-      expect(blacklist.includes('https://github.com/ueokande')).to.be.true;
+      expect(item.matches(new URL('https://github.org'))).to.be.false;
-      expect(blacklist.includes('https://github.org')).to.be.false;
+      expect(item.matches(new URL('https://google.com/search?q=github.org'))).to.be.false;
-      expect(blacklist.includes('https://google.com/search?q=github.org')).to.be.false;
     });
 
     it('matches by hostname with wildcard', () => {
-      let blacklist = new Blacklist(['*.github.com']);
+      let item = BlacklistItem.fromJSON('*.github.com');
 
-      expect(blacklist.includes('https://github.com')).to.be.false;
+      expect(item.matches(new URL('https://github.com'))).to.be.false;
-      expect(blacklist.includes('https://gist.github.com')).to.be.true;
+      expect(item.matches(new URL('https://gist.github.com'))).to.be.true;
-    })
+    });
 
     it('matches by path', () => {
-      let blacklist = new Blacklist(['github.com/abc']);
+      let item = BlacklistItem.fromJSON('github.com/abc');
 
-      expect(blacklist.includes('https://github.com/abc')).to.be.true;
+      expect(item.matches(new URL('https://github.com/abc'))).to.be.true;
-      expect(blacklist.includes('https://github.com/abcdef')).to.be.false;
+      expect(item.matches(new URL('https://github.com/abcdef'))).to.be.false;
-      expect(blacklist.includes('https://gist.github.com/abc')).to.be.false;
+      expect(item.matches(new URL('https://gist.github.com/abc'))).to.be.false;
-    })
+    });
 
     it('matches by path with wildcard', () => {
-      let blacklist = new Blacklist(['github.com/abc*']);
+      let item = BlacklistItem.fromJSON('github.com/abc*');
 
-      expect(blacklist.includes('https://github.com/abc')).to.be.true;
+      expect(item.matches(new URL('https://github.com/abc'))).to.be.true;
-      expect(blacklist.includes('https://github.com/abcdef')).to.be.true;
+      expect(item.matches(new URL('https://github.com/abcdef'))).to.be.true;
-      expect(blacklist.includes('https://gist.github.com/abc')).to.be.false;
+      expect(item.matches(new URL('https://gist.github.com/abc'))).to.be.false;
-    })
+    });
 
     it('matches address and port', () => {
-      let blacklist = new Blacklist(['127.0.0.1:8888']);
+      let item = BlacklistItem.fromJSON('127.0.0.1:8888');
+
+      expect(item.matches(new URL('http://127.0.0.1:8888/'))).to.be.true;
+      expect(item.matches(new URL('http://127.0.0.1:8888/hello'))).to.be.true;
+    });
 
-      expect(blacklist.includes('http://127.0.0.1:8888/')).to.be.true;
+    it('matches with partial blacklist', () => {
-      expect(blacklist.includes('http://127.0.0.1:8888/hello')).to.be.true;
+      let item = BlacklistItem.fromJSON({ url: 'google.com', keys: ['j', 'k'] });
+
+      expect(item.matches(new URL('https://google.com'))).to.be.true;
+      expect(item.matches(new URL('https://yahoo.com'))).to.be.false;
     })
-  })
+  });
+
+  describe('#includesPartialKeys', () => {
+    it('matches with partial keys', () => {
+      let item = BlacklistItem.fromJSON({url: 'google.com', keys: ['j', 'k']});
+
+      expect(item.includeKey(new URL('http://google.com/maps'), 'j')).to.be.true;
+      expect(item.includeKey(new URL('http://google.com/maps'), 'z')).to.be.false;
+      expect(item.includeKey(new URL('http://maps.google.com/'), 'j')).to.be.false;
+    })
+  });
+});
+
+describe('Blacklist', () => {
+  describe('#fromJSON', () => {
+    it('parses string list', () => {
+      let blacklist = Blacklist.fromJSON(['example.com', 'example.org']);
+      expect(blacklist.toJSON()).to.deep.equals([
+        'example.com', 'example.org',
+      ]);
+    });
+
+    it('parses mixed blacklist', () => {
+      let blacklist = Blacklist.fromJSON([
+        { url: 'example.com', keys: ['j', 'k']},
+        'example.org',
+      ]);
+      expect(blacklist.toJSON()).to.deep.equals([
+        { url: 'example.com', keys: ['j', 'k']},
+        'example.org',
+      ]);
+    });
+
+    it('parses empty blacklist', () => {
+      let blacklist = Blacklist.fromJSON([]);
+      expect(blacklist.toJSON()).to.deep.equals([]);
+    });
+
+    it('throws a TypeError', () => {
+      expect(() => Blacklist.fromJSON(null)).to.throw(TypeError);
+      expect(() => Blacklist.fromJSON(100)).to.throw(TypeError);
+      expect(() => Blacklist.fromJSON({})).to.throw(TypeError);
+      expect(() => Blacklist.fromJSON([100])).to.throw(TypeError);
+      expect(() => Blacklist.fromJSON([{}])).to.throw(TypeError);
+    })
+  });
+
+  describe('#includesEntireBlacklist', () => {
+    it('matches a url with entire blacklist', () => {
+      let blacklist = Blacklist.fromJSON(['google.com', '*.github.com']);
+      expect(blacklist.includesEntireBlacklist(new URL('https://google.com'))).to.be.true;
+      expect(blacklist.includesEntireBlacklist(new URL('https://github.com'))).to.be.false;
+      expect(blacklist.includesEntireBlacklist(new URL('https://gist.github.com'))).to.be.true;
+    });
+
+    it('does not matches with partial blacklist', () => {
+      let blacklist = Blacklist.fromJSON(['google.com', { url: 'yahoo.com', keys: ['j', 'k'] }]);
+      expect(blacklist.includesEntireBlacklist(new URL('https://google.com'))).to.be.true;
+      expect(blacklist.includesEntireBlacklist(new URL('https://yahoo.com'))).to.be.false;
+    });
+  });
+
+  describe('#includesKeys', () => {
+    it('matches with entire blacklist or keys in the partial blacklist', () => {
+      let blacklist = Blacklist.fromJSON([
+        'google.com',
+        { url: 'github.com', keys: ['j', 'k'] },
+      ]);
+
+      expect(blacklist.includeKey(new URL('https://google.com'), 'j')).to.be.true;
+      expect(blacklist.includeKey(new URL('https://github.com'), 'j')).to.be.true;
+      expect(blacklist.includeKey(new URL('https://github.com'), 'a')).to.be.false;
+    });
+  });
 });