move commands to background action

jh-changes
Shin'ya Ueoka 7 years ago
parent 22c34a0a6f
commit dda4e7475c
  1. 37
      src/background/actions/command.js
  2. 3
      src/background/components/background.js
  3. 3
      src/shared/commands/index.js
  4. 59
      src/shared/commands/parsers.js
  5. 31
      src/shared/commands/properties.js
  6. 78
      test/shared/commands/parsers.test.js
  7. 41
      test/shared/commands/property.test.js

@ -1,27 +1,5 @@
import * as tabs from 'background/tabs'; import * as tabs from 'background/tabs';
import * as histories from 'background/histories'; import * as parsers from 'shared/commands/parsers';
const normalizeUrl = (args, searchConfig) => {
let concat = args.join(' ');
try {
return new URL(concat).href;
} catch (e) {
if (concat.includes('.') && !concat.includes(' ')) {
return 'http://' + concat;
}
let query = concat;
let template = searchConfig.engines[
searchConfig.default
];
for (let key in searchConfig.engines) {
if (args[0] === key) {
query = args.slice(1).join(' ');
template = searchConfig.engines[key];
}
}
return template.replace('{}', encodeURIComponent(query));
}
};
const openCommand = (url) => { const openCommand = (url) => {
return browser.tabs.query({ return browser.tabs.query({
@ -60,26 +38,25 @@ const bufferCommand = (keywords) => {
}; };
const exec = (line, settings) => { const exec = (line, settings) => {
let words = line.trim().split(/ +/); let [name, args] = parsers.parseCommandLine(line);
let name = words.shift();
switch (name) { switch (name) {
case 'o': case 'o':
case 'open': case 'open':
return openCommand(normalizeUrl(words, settings.search)); return openCommand(parsers.normalizeUrl(args, settings.search));
case 't': case 't':
case 'tabopen': case 'tabopen':
return tabopenCommand(normalizeUrl(words, settings.search)); return tabopenCommand(parsers.normalizeUrl(args, settings.search));
case 'w': case 'w':
case 'winopen': case 'winopen':
return winopenCommand(normalizeUrl(words, settings.search)); return winopenCommand(parsers.normalizeUrl(args, settings.search));
case 'b': case 'b':
case 'buffer': case 'buffer':
return bufferCommand(words); return bufferCommand(args);
case '': case '':
return Promise.resolve(); return Promise.resolve();
} }
throw new Error(name + ' command is not defined'); throw new Error(name + ' command is not defined');
}; };
export default exec; export { exec };

@ -1,5 +1,6 @@
import messages from 'shared/messages'; import messages from 'shared/messages';
import * as operationActions from 'background/actions/operation'; import * as operationActions from 'background/actions/operation';
import * as commandActions from 'background/actions/command';
import * as settingActions from 'background/actions/setting'; import * as settingActions from 'background/actions/setting';
import * as tabActions from 'background/actions/tab'; import * as tabActions from 'background/actions/tab';
import * as commands from 'shared/commands'; import * as commands from 'shared/commands';
@ -35,7 +36,7 @@ export default class BackgroundComponent {
return this.store.dispatch( return this.store.dispatch(
tabActions.openToTab(message.url, sender.tab), sender); tabActions.openToTab(message.url, sender.tab), sender);
case messages.CONSOLE_ENTER_COMMAND: case messages.CONSOLE_ENTER_COMMAND:
return commands.exec(message.text, settings.value).catch((e) => { return commandActions.exec(message.text, settings.value).catch((e) => {
return browser.tabs.sendMessage(sender.tab.id, { return browser.tabs.sendMessage(sender.tab.id, {
type: messages.CONSOLE_SHOW_ERROR, type: messages.CONSOLE_SHOW_ERROR,
text: e.message, text: e.message,

@ -1,4 +1,3 @@
import exec from './exec';
import complete from './complete'; import complete from './complete';
export { exec, complete }; export { complete };

@ -0,0 +1,59 @@
const normalizeUrl = (args, searchConfig) => {
let concat = args.join(' ');
try {
return new URL(concat).href;
} catch (e) {
if (concat.includes('.') && !concat.includes(' ')) {
return 'http://' + concat;
}
let query = concat;
let template = searchConfig.engines[
searchConfig.default
];
for (let key in searchConfig.engines) {
if (args[0] === key) {
query = args.slice(1).join(' ');
template = searchConfig.engines[key];
}
}
return template.replace('{}', encodeURIComponent(query));
}
};
const mustNumber = (v) => {
let num = Number(v);
if (isNaN(num)) {
throw new Error('Not number: ' + v);
}
return num;
};
const parseSetOption = (word, types) => {
let [key, value] = word.split('=');
if (!value) {
value = !key.startsWith('no');
key = value ? key : key.slice(2);
}
let type = types[key];
if (!type) {
throw new Error('Unknown property: ' + key);
}
if (type === 'boolean' && typeof value !== 'boolean' ||
type !== 'boolean' && typeof value === 'boolean') {
throw new Error('Invalid argument: ' + word);
}
switch (type) {
case 'string': return [key, value];
case 'number': return [key, mustNumber(value)];
case 'boolean': return [key, value];
}
};
const parseCommandLine = (line) => {
let words = line.trim().split(/ +/);
let name = words.shift();
return [name, words];
};
export { normalizeUrl, parseCommandLine, parseSetOption };

@ -1,31 +0,0 @@
const mustNumber = (v) => {
let num = Number(v);
if (isNaN(num)) {
throw new Error('Not number: ' + v);
}
return num;
};
const parseProperty = (word, types) => {
let [key, value] = word.split('=');
if (!value) {
value = !key.startsWith('no');
key = value ? key : key.slice(2);
}
let type = types[key];
if (!type) {
throw new Error('Unknown property: ' + key);
}
if (type === 'boolean' && typeof value !== 'boolean' ||
type !== 'boolean' && typeof value === 'boolean') {
throw new Error('Invalid argument: ' + word);
}
switch (type) {
case 'string': return [key, value];
case 'number': return [key, mustNumber(value)];
case 'boolean': return [key, value];
}
};
export { parseProperty };

@ -0,0 +1,78 @@
import { expect } from "chai";
import * as parsers from 'shared/commands/parsers';
describe("shared/commands/parsers", () => {
describe("#parsers.parseSetOption", () => {
it('parse set string', () => {
let [key, value] = parsers.parseSetOption('encoding=utf-8', { encoding: 'string' });
expect(key).to.equal('encoding');
expect(value).to.equal('utf-8');
});
it('parse set string', () => {
let [key, value] = parsers.parseSetOption('history=50', { history: 'number' });
expect(key).to.equal('history');
expect(value).to.equal(50);
});
it('parse set boolean', () => {
let [key, value] = parsers.parseSetOption('paste', { paste: 'boolean' });
expect(key).to.equal('paste');
expect(value).to.be.true;
[key, value] = parsers.parseSetOption('nopaste', { paste: 'boolean' });
expect(key).to.equal('paste');
expect(value).to.be.false;
});
it('throws error on unknown property', () => {
expect(() => parsers.parseSetOption('charset=utf-8', {})).to.throw(Error, 'Unknown');
expect(() => parsers.parseSetOption('smoothscroll', {})).to.throw(Error, 'Unknown');
expect(() => parsers.parseSetOption('nosmoothscroll', {})).to.throw(Error, 'Unknown');
})
it('throws error on invalid property', () => {
expect(() => parsers.parseSetOption('charset=utf-8', { charset: 'number' })).to.throw(Error, 'Not number');
expect(() => parsers.parseSetOption('charset=utf-8', { charset: 'boolean' })).to.throw(Error, 'Invalid');
expect(() => parsers.parseSetOption('smoothscroll', { smoothscroll: 'string' })).to.throw(Error, 'Invalid');
expect(() => parsers.parseSetOption('smoothscroll', { smoothscroll: 'number' })).to.throw(Error, 'Invalid');
})
});
describe('#normalizeUrl', () => {
const config = {
default: 'google',
engines: {
google: 'https://google.com/search?q={}',
yahoo: 'https://yahoo.com/search?q={}',
}
};
it('convertes search url', () => {
expect(parsers.normalizeUrl(['google', 'apple'], config))
.to.equal('https://google.com/search?q=apple');
expect(parsers.normalizeUrl(['yahoo', 'apple'], config))
.to.equal('https://yahoo.com/search?q=apple');
expect(parsers.normalizeUrl(['google', 'apple', 'banana'], config))
.to.equal('https://google.com/search?q=apple%20banana');
expect(parsers.normalizeUrl(['yahoo', 'C++CLI'], config))
.to.equal('https://yahoo.com/search?q=C%2B%2BCLI');
});
it('user default search engine', () => {
expect(parsers.normalizeUrl(['apple', 'banana'], config))
.to.equal('https://google.com/search?q=apple%20banana');
});
});
describe('#parseCommandLine', () => {
it('parse command line as name and args', () => {
expect(parsers.parseCommandLine('open google apple')).to.deep.equal(['open', ['google', 'apple']]);
expect(parsers.parseCommandLine(' open google apple ')).to.deep.equal(['open', ['google', 'apple']]);
expect(parsers.parseCommandLine('')).to.deep.equal(['', []]);
expect(parsers.parseCommandLine(' ')).to.deep.equal(['', []]);
expect(parsers.parseCommandLine('exit')).to.deep.equal(['exit', []]);
expect(parsers.parseCommandLine(' exit ')).to.deep.equal(['exit', []]);
});
});
});

@ -1,41 +0,0 @@
import { expect } from "chai";
import { parseProperty } from 'shared/commands/properties';
describe("shared/commands/properties", () => {
describe("#parseProperty", () => {
it('parse set string', () => {
let [key, value] = parseProperty('encoding=utf-8', { encoding: 'string' });
expect(key).to.equal('encoding');
expect(value).to.equal('utf-8');
});
it('parse set string', () => {
let [key, value] = parseProperty('history=50', { history: 'number' });
expect(key).to.equal('history');
expect(value).to.equal(50);
});
it('parse set boolean', () => {
let [key, value] = parseProperty('paste', { paste: 'boolean' });
expect(key).to.equal('paste');
expect(value).to.be.true;
[key, value] = parseProperty('nopaste', { paste: 'boolean' });
expect(key).to.equal('paste');
expect(value).to.be.false;
});
it('throws error on unknown property', () => {
expect(() => parseProperty('charset=utf-8', {})).to.throw(Error, 'Unknown');
expect(() => parseProperty('smoothscroll', {})).to.throw(Error, 'Unknown');
expect(() => parseProperty('nosmoothscroll', {})).to.throw(Error, 'Unknown');
})
it('throws error on invalid property', () => {
expect(() => parseProperty('charset=utf-8', { charset: 'number' })).to.throw(Error, 'Not number');
expect(() => parseProperty('charset=utf-8', { charset: 'boolean' })).to.throw(Error, 'Invalid');
expect(() => parseProperty('smoothscroll', { smoothscroll: 'string' })).to.throw(Error, 'Invalid');
expect(() => parseProperty('smoothscroll', { smoothscroll: 'number' })).to.throw(Error, 'Invalid');
})
});
});