jab2870
/
Vim-Vixen
Archived
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Clean old codes

Browse Source
jh-changes
Shin'ya Ueoka 6 years ago
parent 66c23423f9
commit ccdb0a2428
32 changed files with 4 additions and 1279 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 147
      src/background/actions/command.js
  2. 41
      src/background/actions/console.js
  3. 10
      src/background/actions/find.js
  4. 11
      src/background/actions/index.js
  5. 34
      src/background/actions/tab.js
  6. 35
      src/background/components/background.js
  7. 43
      src/background/components/indicator.js
  8. 124
      src/background/components/operation.js
  9. 16
      src/background/components/tab.js
  10. 1
      src/background/domains/command-docs.js
  11. 18
      src/background/index.js
  12. 15
      src/background/reducers/find.js
  13. 8
      src/background/reducers/index.js
  14. 22
      src/background/reducers/setting.js
  15. 19
      src/background/reducers/tab.js
  16. 9
      src/background/shared/bookmarks.js
  17. 59
      src/background/shared/commands/parsers.js
  18. 14
      src/background/shared/completions/bookmarks.js
  19. 82
      src/background/shared/completions/histories.js
  20. 173
      src/background/shared/completions/index.js
  21. 8
      src/background/shared/completions/tabs.js
  22. 13
      src/background/shared/indicators.js
  23. 158
      src/background/shared/tabs.js
  24. 32
      src/background/shared/zooms.js
  25. 2
      src/background/usecases/completions.js
  26. 12
      test/background/actions/find.test.js
  27. 13
      test/background/actions/tab.test.js
  28. 18
      test/background/reducers/find.test.js
  29. 35
      test/background/reducers/setting.test.js
  30. 22
      test/background/reducers/tab.test.js
  31. 84
      test/background/shared/commands/parsers.test.js
  32. 5
      test/background/usecases/parsers.test.js

147
src/background/actions/command.js
Unescape View File

@ -1,147 +0,0 @@
import actions from '../actions';
import * as consoleActions from './console';
import * as tabs from '../shared/tabs';
import * as bookmarks from '../shared/bookmarks';
import * as parsers from 'background/shared/commands/parsers';
import * as properties from 'shared/settings/properties';
const openCommand = async(url) => {
let got = await browser.tabs.query({
active: true, currentWindow: true
});
if (got.length > 0) {
return browser.tabs.update(got[0].id, { url: url });
}
};
const tabopenCommand = (url) => {
return browser.tabs.create({ url: url });
};
const tabcloseCommand = async() => {
let got = await browser.tabs.query({
active: true, currentWindow: true
});
return browser.tabs.remove(got.map(tab => tab.id));
};
const tabcloseAllCommand = () => {
return browser.tabs.query({
currentWindow: true
}).then((tabList) => {
return browser.tabs.remove(tabList.map(tab => tab.id));
});
};
const winopenCommand = (url) => {
return browser.windows.create({ url });
};
const bufferCommand = async(keywords) => {
if (keywords.length === 0) {
return;
}
let keywordsStr = keywords.join(' ');
let got = await browser.tabs.query({
active: true, currentWindow: true
});
if (got.length === 0) {
return;
}
if (isNaN(keywordsStr)) {
return tabs.selectByKeyword(got[0], keywordsStr);
}
let index = parseInt(keywordsStr, 10) - 1;
return tabs.selectAt(index);
};
const addbookmarkCommand = async(tab, args) => {
if (!args[0]) {
return { type: '' };
}
let item = await bookmarks.create(args.join(' '), tab.url);
if (!item) {
return consoleActions.error(tab, 'Could not create a bookmark');
}
return consoleActions.info(tab, 'Saved current page: ' + item.url);
};
const setCommand = (args) => {
if (!args[0]) {
return { type: '' };
}
let [name, value] = parsers.parseSetOption(args[0], properties.types);
return {
type: actions.SETTING_SET_PROPERTY,
name,
value
};
};
// eslint-disable-next-line complexity, max-lines-per-function
const doExec = async(tab, line, settings) => {
let [name, args] = parsers.parseCommandLine(line);
switch (name) {
case 'o':
case 'open':
await openCommand(parsers.normalizeUrl(args, settings.search));
break;
case 't':
case 'tabopen':
await tabopenCommand(parsers.normalizeUrl(args, settings.search));
break;
case 'w':
case 'winopen':
await winopenCommand(parsers.normalizeUrl(args, settings.search));
break;
case 'b':
case 'buffer':
await bufferCommand(args);
break;
case 'bd':
case 'bdel':
case 'bdelete':
await tabs.closeTabByKeywords(args.join(' '));
break;
case 'bd!':
case 'bdel!':
case 'bdelete!':
await tabs.closeTabByKeywordsForce(args.join(' '));
break;
case 'bdeletes':
await tabs.closeTabsByKeywords(args.join(' '));
break;
case 'bdeletes!':
await tabs.closeTabsByKeywordsForce(args.join(' '));
break;
case 'addbookmark':
return addbookmarkCommand(tab, args);
case 'set':
return setCommand(args);
case 'q':
case 'quit':
await tabcloseCommand();
break;
case 'qa':
case 'quitall':
await tabcloseAllCommand();
break;
default:
return consoleActions.error(tab, name + ' command is not defined');
}
return { type: '' };
};
// eslint-disable-next-line complexity
const exec = async(tab, line, settings) => {
try {
let action = await doExec(tab, line, settings);
return action;
} catch (e) {
return consoleActions.error(tab, e.toString());
}
};
export { exec };

41
src/background/actions/console.js
Unescape View File

@ -1,41 +0,0 @@
import messages from 'shared/messages';
const error = async(tab, text) => {
await browser.tabs.sendMessage(tab.id, {
type: messages.CONSOLE_SHOW_ERROR,
text,
});
return { type: '' };
};
const info = async(tab, text) => {
await browser.tabs.sendMessage(tab.id, {
type: messages.CONSOLE_SHOW_INFO,
text,
});
return { type: '' };
};
const showCommand = async(tab, command) => {
await browser.tabs.sendMessage(tab.id, {
type: messages.CONSOLE_SHOW_COMMAND,
command,
});
return { type: '' };
};
const showFind = async(tab) => {
await browser.tabs.sendMessage(tab.id, {
type: messages.CONSOLE_SHOW_FIND
});
return { type: '' };
};
const hide = async(tab) => {
await browser.tabs.sendMessage(tab.id, {
type: messages.CONSOLE_HIDE,
});
return { type: '' };
};
export { error, info, showCommand, showFind, hide };

10
src/background/actions/find.js
Unescape View File

@ -1,10 +0,0 @@
import actions from './index';
const setKeyword = (keyword) => {
return {
type: actions.FIND_SET_KEYWORD,
keyword,
};
};
export { setKeyword };

11
src/background/actions/index.js
Unescape View File

@ -1,11 +0,0 @@
export default {
// Settings
SETTING_SET_SETTINGS: 'setting.set.settings',
SETTING_SET_PROPERTY: 'setting.set.property',
// Find
FIND_SET_KEYWORD: 'find.set.keyword',
// Tab
TAB_SELECTED: 'tab.selected',
};

34
src/background/actions/tab.js
Unescape View File

@ -1,34 +0,0 @@
import actions from './index';
const openNewTab = async(
url, openerTabId, background = false, adjacent = false
) => {
if (!adjacent) {
await browser.tabs.create({ url, active: !background });
return { type: '' };
}
let tabs = await browser.tabs.query({
active: true, currentWindow: true
});
await browser.tabs.create({
url,
openerTabId,
active: !background,
index: tabs[0].index + 1
});
return { type: '' };
};
const openToTab = async(url, tab) => {
await browser.tabs.update(tab.id, { url: url });
return { type: '' };
};
const selected = (tabId) => {
return {
type: actions.TAB_SELECTED,
tabId,
};
};
export { openNewTab, openToTab, selected };

35
src/background/components/background.js
Unescape View File

@ -1,35 +0,0 @@
import messages from 'shared/messages';
import * as commandActions from 'background/actions/command';
export default class BackgroundComponent {
constructor(store) {
this.store = store;
browser.runtime.onMessage.addListener((message, sender) => {
try {
return this.onMessage(message, sender);
} catch (e) {
return browser.tabs.sendMessage(sender.tab.id, {
type: messages.CONSOLE_SHOW_ERROR,
text: e.message,
});
}
});
}
onMessage(message, sender) {
let settings = this.store.getState().setting;
switch (message.type) {
}
}
async broadcastSettingsChanged() {
let tabs = await browser.tabs.query({});
for (let tab of tabs) {
browser.tabs.sendMessage(tab.id, {
type: messages.SETTINGS_CHANGED,
});
}
}
}

43
src/background/components/indicator.js
Unescape View File

@ -1,43 +0,0 @@
import * as indicators from '../shared/indicators';
import messages from 'shared/messages';
export default class IndicatorComponent {
constructor(store) {
this.store = store;
messages.onMessage(this.onMessage.bind(this));
browser.browserAction.onClicked.addListener(this.onClicked);
browser.tabs.onActivated.addListener(async(info) => {
await browser.tabs.query({ currentWindow: true });
return this.onTabActivated(info);
});
}
async onTabActivated(info) {
let { enabled } = await browser.tabs.sendMessage(info.tabId, {
type: messages.ADDON_ENABLED_QUERY,
});
return this.updateIndicator(enabled);
}
onClicked(tab) {
browser.tabs.sendMessage(tab.id, {
type: messages.ADDON_TOGGLE_ENABLED,
});
}
onMessage(message) {
switch (message.type) {
case messages.ADDON_ENABLED_RESPONSE:
return this.updateIndicator(message.enabled);
}
}
updateIndicator(enabled) {
if (enabled) {
return indicators.enable();
}
return indicators.disable();
}
}

124
src/background/components/operation.js
Unescape View File

@ -1,124 +0,0 @@
import messages from 'shared/messages';
import operations from 'shared/operations';
import * as tabs from '../shared//tabs';
import * as zooms from '../shared/zooms';
import * as consoleActions from '../actions/console';
export default class BackgroundComponent {
constructor(store) {
this.store = store;
browser.runtime.onMessage.addListener((message, sender) => {
try {
return this.onMessage(message, sender);
} catch (e) {
return browser.tabs.sendMessage(sender.tab.id, {
type: messages.CONSOLE_SHOW_ERROR,
text: e.message,
});
}
});
}
onMessage(message, sender) {
switch (message.type) {
}
}
// eslint-disable-next-line complexity, max-lines-per-function
async exec(operation, tab) {
let tabState = this.store.getState().tab;
switch (operation.type) {
case operations.TAB_CLOSE:
await tabs.closeTab(tab.id);
break;
case operations.TAB_CLOSE_FORCE:
await tabs.closeTabForce(tab.id);
break;
case operations.TAB_REOPEN:
await tabs.reopenTab();
break;
case operations.TAB_PREV:
await tabs.selectPrevTab(tab.index, operation.count);
break;
case operations.TAB_NEXT:
await tabs.selectNextTab(tab.index, operation.count);
break;
case operations.TAB_FIRST:
await tabs.selectFirstTab();
break;
case operations.TAB_LAST:
await tabs.selectLastTab();
break;
case operations.TAB_PREV_SEL:
if (tabState.previousSelected > 0) {
await tabs.selectTab(tabState.previousSelected);
}
break;
case operations.TAB_RELOAD:
await tabs.reload(tab, operation.cache);
break;
case operations.TAB_PIN:
await tabs.updateTabPinned(tab, true);
break;
case operations.TAB_UNPIN:
await tabs.updateTabPinned(tab, false);
break;
case operations.TAB_TOGGLE_PINNED:
await tabs.toggleTabPinned(tab);
break;
case operations.TAB_DUPLICATE:
await tabs.duplicate(tab.id);
break;
case operations.ZOOM_IN:
await zooms.zoomIn();
break;
case operations.ZOOM_OUT:
await zooms.zoomOut();
break;
case operations.ZOOM_NEUTRAL:
await zooms.neutral();
break;
case operations.COMMAND_SHOW:
return consoleActions.showCommand(tab, '');
case operations.COMMAND_SHOW_OPEN:
if (operation.alter) {
// alter url
return consoleActions.showCommand(tab, 'open ' + tab.url);
}
return consoleActions.showCommand(tab, 'open ');
case operations.COMMAND_SHOW_TABOPEN:
if (operation.alter) {
// alter url
return consoleActions.showCommand(tab, 'tabopen ' + tab.url);
}
return consoleActions.showCommand(tab, 'tabopen ');
case operations.COMMAND_SHOW_WINOPEN:
if (operation.alter) {
// alter url
return consoleActions.showCommand(tab, 'winopen ' + tab.url);
}
return consoleActions.showCommand(tab, 'winopen ');
case operations.COMMAND_SHOW_BUFFER:
return consoleActions.showCommand(tab, 'buffer ');
case operations.COMMAND_SHOW_ADDBOOKMARK:
if (operation.alter) {
return consoleActions.showCommand(tab, 'addbookmark ' + tab.title);
}
return consoleActions.showCommand(tab, 'addbookmark ');
case operations.FIND_START:
return consoleActions.showFind(tab);
case operations.CANCEL:
return consoleActions.hide(tab);
case operations.PAGE_SOURCE:
await browser.tabs.create({
url: 'view-source:' + tab.url,
index: tab.index + 1,
openerTabId: tab.id,
});
break;
}
return { type: '' };
}
}

16
src/background/components/tab.js
Unescape View File

@ -1,16 +0,0 @@
import * as tabActions from '../actions/tab';
export default class TabComponent {
constructor(store) {
this.store = store;
browser.tabs.onActivated.addListener(async(info) => {
await browser.tabs.query({ currentWindow: true });
return this.onTabActivated(info);
});
}
onTabActivated(info) {
return this.store.dispatch(tabActions.selected(info.tabId));
}
}

1
src/background/shared/commands/docs.js → src/background/domains/command-docs.js
Unescape View File

@ -9,3 +9,4 @@ export default {
quit: 'Close the current tab',
quitall: 'Close all tabs',
};

18
src/background/index.js
Unescape View File

@ -1,25 +1,7 @@
import BackgroundComponent from 'background/components/background';
import OperationComponent from 'background/components/operation';
import TabComponent from 'background/components/tab';
import reducers from 'background/reducers';
import { createStore, applyMiddleware } from 'redux';
import promise from 'redux-promise';
import ContentMessageListener from './infrastructures/content-message-listener';
import SettingController from './controllers/setting';
import VersionRepository from './controllers/version';
const store = createStore(
reducers,
applyMiddleware(promise),
);
/* eslint-disable no-unused-vars */
const backgroundComponent = new BackgroundComponent(store);
const operationComponent = new OperationComponent(store);
const tabComponent = new TabComponent(store);
/* eslint-enable no-unused-vars */
new SettingController().reload();
new VersionRepository().notifyIfUpdated();

15
src/background/reducers/find.js
Unescape View File

@ -1,15 +0,0 @@
import actions from 'content/actions';
const defaultState = {
keyword: null,
};
export default function reducer(state = defaultState, action = {}) {
switch (action.type) {
case actions.FIND_SET_KEYWORD:
return { ...state,
keyword: action.keyword, };
default:
return state;
}
}

8
src/background/reducers/index.js
Unescape View File

@ -1,8 +0,0 @@
import { combineReducers } from 'redux';
import setting from './setting';
import find from './find';
import tab from './tab';
export default combineReducers({
setting, find, tab,
});

22
src/background/reducers/setting.js
Unescape View File

@ -1,22 +0,0 @@
import actions from 'background/actions';
const defaultState = {
value: {},
};
export default function reducer(state = defaultState, action = {}) {
switch (action.type) {
case actions.SETTING_SET_SETTINGS:
return {
value: action.value,
};
case actions.SETTING_SET_PROPERTY:
return {
value: { ...state.value,
properties: { ...state.value.properties, [action.name]: action.value }}
};
default:
return state;
}
}

19
src/background/reducers/tab.js
Unescape View File

@ -1,19 +0,0 @@
import actions from 'background/actions';
const defaultState = {
previousSelected: -1,
currentSelected: -1,
};
export default function reducer(state = defaultState, action = {}) {
switch (action.type) {
case actions.TAB_SELECTED:
return {
previousSelected: state.currentSelected,
currentSelected: action.tabId,
};
default:
return state;
}
}

9
src/background/shared/bookmarks.js
Unescape View File

@ -1,9 +0,0 @@
const create = (title, url) => {
return browser.bookmarks.create({
type: 'bookmark',
title,
url,
});
};
export { create };

59
src/background/shared/commands/parsers.js
Unescape View File

@ -1,59 +0,0 @@
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 === undefined) {
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 };

14
src/background/shared/completions/bookmarks.js
Unescape View File

@ -1,14 +0,0 @@
const getCompletions = async(keywords) => {
let items = await browser.bookmarks.search({ query: keywords });
return items.filter((item) => {
let url = undefined;
try {
url = new URL(item.url);
} catch (e) {
return false;
}
return item.type === 'bookmark' && url.protocol !== 'place:';
}).slice(0, 10);
};
export { getCompletions };

82
src/background/shared/completions/histories.js
Unescape View File

@ -1,82 +0,0 @@
const filterHttp = (items) => {
const httpsHosts = items
.filter(item => item[1].protocol === 'https:')
.map(item => item[1].host);
const httpsHostSet = new Set(httpsHosts);
return items.filter(
item => !(item[1].protocol === 'http:' && httpsHostSet.has(item[1].host))
);
};
const filterEmptyTitle = (items) => {
return items.filter(item => item[0].title && item[0].title !== '');
};
const filterClosedPath = (items) => {
const allSimplePaths = items
.filter(item => item[1].hash === '' && item[1].search === '')
.map(item => item[1].origin + item[1].pathname);
const allSimplePathSet = new Set(allSimplePaths);
return items.filter(
item => !(item[1].hash === '' && item[1].search === '' &&
(/\/$/).test(item[1].pathname) &&
allSimplePathSet.has(
(item[1].origin + item[1].pathname).replace(/\/$/, '')
)
)
);
};
const reduceByPathname = (items, min) => {
let hash = {};
for (let item of items) {
let pathname = item[1].origin + item[1].pathname;
if (!hash[pathname]) {
hash[pathname] = item;
} else if (hash[pathname][1].href.length > item[1].href.length) {
hash[pathname] = item;
}
}
let filtered = Object.values(hash);
if (filtered.length < min) {
return items;
}
return filtered;
};
const reduceByOrigin = (items, min) => {
let hash = {};
for (let item of items) {
let origin = item[1].origin;
if (!hash[origin]) {
hash[origin] = item;
} else if (hash[origin][1].href.length > item[1].href.length) {
hash[origin] = item;
}
}
let filtered = Object.values(hash);
if (filtered.length < min) {
return items;
}
return filtered;
};
const getCompletions = async(keyword) => {
let historyItems = await browser.history.search({
text: keyword,
startTime: 0,
});
return [historyItems.map(item => [item, new URL(item.url)])]
.map(filterEmptyTitle)
.map(filterHttp)
.map(filterClosedPath)
.map(items => reduceByPathname(items, 10))
.map(items => reduceByOrigin(items, 10))
.map(items => items
.sort((x, y) => x[0].visitCount < y[0].visitCount)
.slice(0, 10)
.map(item => item[0])
)[0];
};
export { getCompletions };

173
src/background/shared/completions/index.js
Unescape View File

@ -1,173 +0,0 @@
import commandDocs from 'background/shared/commands/docs';
import * as tabs from './tabs';
import * as histories from './histories';
import * as bookmarks from './bookmarks';
import * as properties from 'shared/settings/properties';
const completeCommands = (typing) => {
let keys = Object.keys(commandDocs);
return keys
.filter(name => name.startsWith(typing))
.map(name => ({
caption: name,
content: name,
url: commandDocs[name],
}));
};
const getSearchCompletions = (command, keywords, searchConfig) => {
let engineNames = Object.keys(searchConfig.engines);
let engineItems = engineNames.filter(name => name.startsWith(keywords))
.map(name => ({
caption: name,
content: command + ' ' + name
}));
return Promise.resolve(engineItems);
};
const getHistoryCompletions = async(command, keywords) => {
let items = await histories.getCompletions(keywords);
return items.map((page) => {
return {
caption: page.title,
content: command + ' ' + page.url,
url: page.url
};
});
};
const getBookmarksCompletions = async(command, keywords) => {
let items = await bookmarks.getCompletions(keywords);
return items.map(item => ({
caption: item.title,
content: command + ' ' + item.url,
url: item.url,
}));
};
const getOpenCompletions = async(command, keywords, searchConfig) => {
let engineItems = await getSearchCompletions(command, keywords, searchConfig);
let historyItems = await getHistoryCompletions(command, keywords);
let bookmarkItems = await getBookmarksCompletions(command, keywords);
let completions = [];
if (engineItems.length > 0) {
completions.push({
name: 'Search Engines',
items: engineItems
});
}
if (historyItems.length > 0) {
completions.push({
name: 'History',
items: historyItems
});
}
if (bookmarkItems.length > 0) {
completions.push({
name: 'Bookmarks',
items: bookmarkItems
});
}
return completions;
};
const getBufferCompletions = async(command, keywords, excludePinned) => {
let items = await tabs.getCompletions(keywords, excludePinned);
items = items.map(tab => ({
caption: tab.title,
content: command + ' ' + tab.title,
url: tab.url,
icon: tab.favIconUrl
}));
return [
{
name: 'Buffers',
items: items
}
];
};
const getSetCompletions = (command, keywords) => {
let keys = Object.keys(properties.docs).filter(
name => name.startsWith(keywords)
);
let items = keys.map((key) => {
if (properties.types[key] === 'boolean') {
return [
{
caption: key,
content: command + ' ' + key,
url: 'Enable ' + properties.docs[key],
}, {
caption: 'no' + key,
content: command + ' no' + key,
url: 'Disable ' + properties.docs[key],
}
];
}
return [
{
caption: key,
content: command + ' ' + key,
url: 'Set ' + properties.docs[key],
}
];
});
items = items.reduce((acc, val) => acc.concat(val), []);
if (items.length === 0) {
return Promise.resolve([]);
}
return Promise.resolve([
{
name: 'Properties',
items,
}
]);
};
const complete = (line, settings) => {
let trimmed = line.trimStart();
let words = trimmed.split(/ +/);
let name = words[0];
if (words.length === 1) {
let items = completeCommands(name);
if (items.length === 0) {
return Promise.resolve([]);
}
return Promise.resolve([
{
name: 'Console Command',
items: completeCommands(name),
}
]);
}
let keywords = trimmed.slice(name.length).trimStart();
switch (words[0]) {
case 'o':
case 'open':
case 't':
case 'tabopen':
case 'w':
case 'winopen':
return getOpenCompletions(name, keywords, settings.search);
case 'b':
case 'buffer':
return getBufferCompletions(name, keywords, false);
case 'bd!':
case 'bdel!':
case 'bdelete!':
case 'bdeletes!':
return getBufferCompletions(name, keywords, false);
case 'bd':
case 'bdel':
case 'bdelete':
case 'bdeletes':
return getBufferCompletions(name, keywords, true);
case 'set':
return getSetCompletions(name, keywords);
}
return Promise.resolve([]);
};
export { complete };

8
src/background/shared/completions/tabs.js
Unescape View File

@ -1,8 +0,0 @@
import * as tabs from '../tabs';
const getCompletions = (keyword, excludePinned) => {
return tabs.queryByKeyword(keyword, excludePinned);
};
export { getCompletions };

13
src/background/shared/indicators.js
Unescape View File

@ -1,13 +0,0 @@
const enable = () => {
return browser.browserAction.setIcon({
path: 'resources/enabled_32x32.png',
});
};
const disable = () => {
return browser.browserAction.setIcon({
path: 'resources/disabled_32x32.png',
});
};
export { enable, disable };

158
src/background/shared/tabs.js
Unescape View File

@ -1,158 +0,0 @@
import * as tabCompletions from './completions/tabs';
const closeTab = async(id) => {
let tab = await browser.tabs.get(id);
if (!tab.pinned) {
return browser.tabs.remove(id);
}
};
const closeTabForce = (id) => {
return browser.tabs.remove(id);
};
const queryByKeyword = async(keyword, excludePinned = false) => {
let tabs = await browser.tabs.query({ currentWindow: true });
return tabs.filter((t) => {
return t.url.toLowerCase().includes(keyword.toLowerCase()) ||
t.title && t.title.toLowerCase().includes(keyword.toLowerCase());
}).filter((t) => {
return !(excludePinned && t.pinned);
});
};
const closeTabByKeywords = async(keyword) => {
let tabs = await queryByKeyword(keyword, true);
if (tabs.length === 0) {
throw new Error('No matching buffer for ' + keyword);
} else if (tabs.length > 1) {
throw new Error('More than one match for ' + keyword);
}
return browser.tabs.remove(tabs[0].id);
};
const closeTabByKeywordsForce = async(keyword) => {
let tabs = await queryByKeyword(keyword, false);
if (tabs.length === 0) {
throw new Error('No matching buffer for ' + keyword);
} else if (tabs.length > 1) {
throw new Error('More than one match for ' + keyword);
}
return browser.tabs.remove(tabs[0].id);
};
const closeTabsByKeywords = async(keyword) => {
let tabs = await tabCompletions.getCompletions(keyword);
tabs = tabs.filter(tab => !tab.pinned);
return browser.tabs.remove(tabs.map(tab => tab.id));
};
const closeTabsByKeywordsForce = async(keyword) => {
let tabs = await tabCompletions.getCompletions(keyword);
return browser.tabs.remove(tabs.map(tab => tab.id));
};
const reopenTab = async() => {
let window = await browser.windows.getCurrent();
let sessions = await browser.sessions.getRecentlyClosed();
let session = sessions.find((s) => {
return s.tab && s.tab.windowId === window.id;
});
if (!session) {
return;
}
if (session.tab) {
return browser.sessions.restore(session.tab.sessionId);
}
return browser.sessions.restore(session.window.sessionId);
};
const selectAt = async(index) => {
let tabs = await browser.tabs.query({ currentWindow: true });
if (tabs.length < 2) {
return;
}
if (index < 0 || tabs.length <= index) {
throw new RangeError(`tab ${index + 1} does not exist`);
}
let id = tabs[index].id;
return browser.tabs.update(id, { active: true });
};
const selectByKeyword = async(current, keyword) => {
let tabs = await queryByKeyword(keyword);
if (tabs.length === 0) {
throw new RangeError('No matching buffer for ' + keyword);
}
for (let tab of tabs) {
if (tab.index > current.index) {
return browser.tabs.update(tab.id, { active: true });
}
}
return browser.tabs.update(tabs[0].id, { active: true });
};
const selectPrevTab = async(current, count) => {
let tabs = await browser.tabs.query({ currentWindow: true });
if (tabs.length < 2) {
return;
}
let select = (current - count + tabs.length) % tabs.length;
let id = tabs[select].id;
return browser.tabs.update(id, { active: true });
};
const selectNextTab = async(current, count) => {
let tabs = await browser.tabs.query({ currentWindow: true });
if (tabs.length < 2) {
return;
}
let select = (current + count) % tabs.length;
let id = tabs[select].id;
return browser.tabs.update(id, { active: true });
};
const selectFirstTab = async() => {
let tabs = await browser.tabs.query({ currentWindow: true });
let id = tabs[0].id;
return browser.tabs.update(id, { active: true });
};
const selectLastTab = async() => {
let tabs = await browser.tabs.query({ currentWindow: true });
let id = tabs[tabs.length - 1].id;
return browser.tabs.update(id, { active: true });
};
const selectTab = (id) => {
return browser.tabs.update(id, { active: true });
};
const reload = (current, cache) => {
return browser.tabs.reload(
current.id,
{ bypassCache: cache }
);
};
const updateTabPinned = (current, pinned) => {
return browser.tabs.update(current.id, { pinned });
};
const toggleTabPinned = (current) => {
return updateTabPinned(current, !current.pinned);
};
const duplicate = (id) => {
return browser.tabs.duplicate(id);
};
export {
closeTab, closeTabForce,
queryByKeyword, closeTabByKeywords, closeTabByKeywordsForce,
closeTabsByKeywords, closeTabsByKeywordsForce,
reopenTab, selectAt, selectByKeyword,
selectPrevTab, selectNextTab, selectFirstTab,
selectLastTab, selectTab, reload, updateTabPinned,
toggleTabPinned, duplicate
};

32
src/background/shared/zooms.js
Unescape View File

@ -1,32 +0,0 @@
// For chromium
// const ZOOM_SETTINGS = [
// 0.25, 0.33, 0.50, 0.66, 0.75, 0.80, 0.90, 1.00,
// 1.10, 1.25, 1.50, 1.75, 2.00, 2.50, 3.00, 4.00, 5.00
// ];
const ZOOM_SETTINGS = [
0.33, 0.50, 0.66, 0.75, 0.80, 0.90, 1.00,
1.10, 1.25, 1.50, 1.75, 2.00, 2.50, 3.00
];
const zoomIn = async(tabId = undefined) => {
let current = await browser.tabs.getZoom(tabId);
let factor = ZOOM_SETTINGS.find(f => f > current);
if (factor) {
return browser.tabs.setZoom(tabId, factor);
}
};
const zoomOut = async(tabId = undefined) => {
let current = await browser.tabs.getZoom(tabId);
let factor = [].concat(ZOOM_SETTINGS).reverse().find(f => f < current);
if (factor) {
return browser.tabs.setZoom(tabId, factor);
}
};
const neutral = (tabId = undefined) => {
return browser.tabs.setZoom(tabId, 1);
};
export { zoomIn, zoomOut, neutral };

2
src/background/usecases/completions.js
Unescape View File

@ -1,8 +1,8 @@
import CompletionItem from '../domains/completion-item';
import CompletionGroup from '../domains/completion-group';
import Completions from '../domains/completions';
import CommandDocs from '../domains/command-docs';
import CompletionRepository from '../repositories/completions';
import CommandDocs from 'background/shared/commands/docs';
import * as filters from './filters';
import SettingRepository from '../repositories/setting';
import * as properties from '../../shared/settings/properties';

12
test/background/actions/find.test.js
Unescape View File

@ -1,12 +0,0 @@
import actions from 'background/actions';
import * as findActions from 'background/actions/find';
describe("find actions", () => {
describe("setKeyword", () => {
it('create FIND_SET_KEYWORD action', () => {
let action = findActions.setKeyword('banana');
expect(action.type).to.equal(actions.FIND_SET_KEYWORD);
expect(action.keyword).to.equal('banana');
});
});
});

13
test/background/actions/tab.test.js
Unescape View File

@ -1,13 +0,0 @@
import actions from 'background/actions';
import * as tabActions from 'background/actions/tab';
describe("tab actions", () => {
describe("selected", () => {
it('create TAB_SELECTED action', () => {
let action = tabActions.selected(123);
expect(action.type).to.equal(actions.TAB_SELECTED);
expect(action.tabId).to.equal(123);
});
});
});

18
test/background/reducers/find.test.js
Unescape View File

@ -1,18 +0,0 @@
import actions from 'background/actions';
import findReducer from 'background/reducers/find';
describe("find reducer", () => {
it('return the initial state', () => {
let state = findReducer(undefined, {});
expect(state).to.have.deep.property('keyword', null);
});
it('return next state for FIND_SET_KEYWORD', () => {
let action = {
type: actions.FIND_SET_KEYWORD,
keyword: 'cherry',
};
let state = findReducer(undefined, action);
expect(state).to.have.deep.property('keyword', 'cherry')
});
});

35
test/background/reducers/setting.test.js
Unescape View File

@ -1,35 +0,0 @@
import actions from 'background/actions';
import settingReducer from 'background/reducers/setting';
describe("setting reducer", () => {
it('return the initial state', () => {
let state = settingReducer(undefined, {});
expect(state).to.have.deep.property('value', {});
});
it('return next state for SETTING_SET_SETTINGS', () => {
let action = {
type: actions.SETTING_SET_SETTINGS,
value: { key: 123 },
};
let state = settingReducer(undefined, action);
expect(state).to.have.deep.property('value', { key: 123 });
});
it('return next state for SETTING_SET_PROPERTY', () => {
let state = {
value: {
properties: { smoothscroll: true }
}
}
let action = {
type: actions.SETTING_SET_PROPERTY,
name: 'encoding',
value: 'utf-8',
};
state = settingReducer(state, action);
expect(state.value.properties).to.have.property('smoothscroll', true);
expect(state.value.properties).to.have.property('encoding', 'utf-8');
});
});

22
test/background/reducers/tab.test.js
Unescape View File

@ -1,22 +0,0 @@
import actions from 'background/actions';
import tabReducer from 'background/reducers/tab';
describe("tab reducer", () => {
it('return the initial state', () => {
let state = tabReducer(undefined, {});
expect(state.previousSelected).to.equal(-1);
expect(state.currentSelected).to.equal(-1);
});
it('return next state for TAB_SELECTED', () => {
let state = undefined;
state = tabReducer(state, { type: actions.TAB_SELECTED, tabId: 123 });
expect(state.previousSelected).to.equal(-1);
expect(state.currentSelected).to.equal(123);
state = tabReducer(state, { type: actions.TAB_SELECTED, tabId: 456 });
expect(state.previousSelected).to.equal(123);
expect(state.currentSelected).to.equal(456);
});
});

84
test/background/shared/commands/parsers.test.js
Unescape View File

@ -1,84 +0,0 @@
import * as parsers from 'background/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 empty string', () => {
let [key, value] = parsers.parseSetOption('encoding=', { encoding: 'string' });
expect(key).to.equal('encoding');
expect(value).to.equal('');
});
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('charset=', { 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', []]);
});
});
});

5
test/background/usecases/parsers.test.js
Unescape View File

@ -1,6 +1,6 @@
import * as parsers from 'background/usecases/parsers';
describe("background/usecases/parsers", () => {
describe("shared/commands/parsers", () => {
describe("#parsers.parseSetOption", () => {
it('parse set string', () => {
let [key, value] = parsers.parseSetOption('encoding=utf-8', { encoding: 'string' });
@ -65,10 +65,9 @@ describe("background/usecases/parsers", () => {
.to.equal('https://yahoo.com/search?q=C%2B%2BCLI');
});
it('user default search engine', () => {
it('user default search engine', () => {
expect(parsers.normalizeUrl('apple banana', config))
.to.equal('https://google.com/search?q=apple%20banana');
});
});
});