Add partial blacklist item

jh-changes
Shin'ya UEOKA 5 years ago
parent 8eddcc1785
commit 9ff80fcac3
  1. 3
      src/content/controllers/SettingController.ts
  2. 114
      src/shared/settings/Blacklist.ts
  3. 176
      test/shared/settings/Blacklist.test.ts

@ -15,7 +15,8 @@ export default class SettingController {
async initSettings(): Promise<void> { async initSettings(): Promise<void> {
try { try {
let current = await this.settingUseCase.reload(); 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) { if (disabled) {
this.addonEnabledUseCase.disable(); this.addonEnabledUseCase.disable();
} else { } else {

@ -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, '.*') + '$'; let regexStr = '^' + pattern.replace(/\*/g, '.*') + '$';
return new RegExp(regexStr); 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 { export default class Blacklist {
constructor( constructor(
private blacklist: string[], private blacklist: BlacklistItem[],
) { ) {
} }
static fromJSON(json: any): Blacklist { static fromJSON(json: any): Blacklist {
if (!Array.isArray(json)) { 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`);
} }
} let items = Array.from(json).map(item => BlacklistItem.fromJSON(item));
return new Blacklist(json); return new Blacklist(items);
} }
toJSON(): BlacklistJSON { 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);
} }
return fromWildcard(item).test(u.host + u.pathname);
}); includeKey(url: URL, key: string) {
return this.blacklist.some(item => item.includeKey(url, key));
} }
} }

@ -1,77 +1,155 @@
import Blacklist from '../../../src/shared/settings/Blacklist'; import Blacklist, { BlacklistItem } from '../../../src/shared/settings/Blacklist';
import { expect } from 'chai'; 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', () => { 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', () => { 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', () => { 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', () => { 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', () => { it('matches address and port', () => {
let blacklist = new Blacklist(['127.0.0.1:8888']); let item = BlacklistItem.fromJSON('127.0.0.1:8888');
expect(blacklist.includes('http://127.0.0.1:8888/')).to.be.true; expect(item.matches(new URL('http://127.0.0.1:8888/'))).to.be.true;
expect(blacklist.includes('http://127.0.0.1:8888/hello')).to.be.true; expect(item.matches(new URL('http://127.0.0.1:8888/hello'))).to.be.true;
});
it('matches with partial blacklist', () => {
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;
});
});
}); });