various
/
Nativefier
mirror of https://github.com/jiahaog/Nativefier
1
0
Fork 0
Code Issues Releases Wiki Activity

Update eslint and use Airbnb style 

- Add `npm run lint:fix` command
- Cleanup inferIcon.js logic slightly
This commit is contained in:
Jia Hao Goh 2017-04-29 22:52:12 +08:00
parent 461c7a38f0
commit 8f78dd03af
48 changed files with 1795 additions and 1850 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

49
.eslintrc.js
View File

@ -1,49 +0,0 @@
module.exports = {
globals: {
// mocha
describe: false,
it: false,
before: false,
beforeEach: false,
after: false,
afterEach: false
},
rules: {
indent: [
2,
4,
{SwitchCase: 1}
],
quotes: [
2,
'single'
],
'linebreak-style': [
2,
'unix'
],
semi: [
2,
'always'
],
'max-len': 0,
'require-jsdoc': 0,
'padded-blocks': 0,
'no-throw-literal': 0,
camelcase: 0,
'valid-jsdoc': 0,
'no-path-concat': 1,
'quote-props': [2, 'as-needed'],
'no-warning-comments': 1,
'no-control-regex': 0
},
env: {
es6: true,
browser: true,
node: true
},
ecmaFeatures: {
modules: true
},
extends: 'google'
};

8
.eslintrc.yml Normal file
View File

@ -0,0 +1,8 @@
extends: airbnb-base
plugins:
- import
rules:
# TODO: Remove this when we have shifted away from the async package
no-shadow: 'warn'
# Gulpfiles and tests use dev dependencies
import/no-extraneous-dependencies: ['error', { devDependencies: ['gulpfile.babel.js', 'gulp/**/**.js', 'test/**/**.js']}]

20
.github/CONTRIBUTING.md vendored
View File

@ -15,23 +15,19 @@ Please include the following in your new issue:
See [here](https://github.com/jiahaog/nativefier#development) for instructions on how to set up a development environment. See [here](https://github.com/jiahaog/nativefier#development) for instructions on how to set up a development environment.
Follow the current code style, and make sure tests and lints pass before submitting with the following commands: We follow the [Airbnb Style Guide](https://github.com/airbnb/javascript), please make sure tests and lints pass when you submit your pull request.
Run the following command before submitting the pull request: The following commands might be helpful:
```bash ```bash
# Run tests and linting # Run specs and lint
$ npm run ci npm run ci
```
Or you can run them separately: # Run specs only
npm run test
```bash # Run linter only
# Tests npm run lint
$ npm run test
# Lint source files
$ npm run lint
``` ```
Thank you so much for your contribution! Thank you so much for your contribution!

2
app/.eslintrc.yml Normal file
View File

@ -0,0 +1,2 @@
settings:
import/core-modules: [ electron ]

79
app/src/components/contextMenu/contextMenu.js
View File

@ -1,47 +1,48 @@
import {Menu, ipcMain, shell, clipboard, BrowserWindow} from 'electron'; // Because we are changing the properties of `mainWindow` in initContextMenu()
/* eslint-disable no-param-reassign */
import { Menu, ipcMain, shell, clipboard, BrowserWindow } from 'electron';
function initContextMenu(mainWindow) { function initContextMenu(mainWindow) {
ipcMain.on('contextMenuOpened', (event, targetHref) => { ipcMain.on('contextMenuOpened', (event, targetHref) => {
const contextMenuTemplate = [ const contextMenuTemplate = [
{ {
label: 'Open with default browser', label: 'Open with default browser',
click: () => { click: () => {
if (targetHref) { if (targetHref) {
shell.openExternal(targetHref); shell.openExternal(targetHref);
return; }
} },
} },
}, {
{ label: 'Open in new window',
label: 'Open in new window', click: () => {
click: () => { if (targetHref) {
if (targetHref) { new BrowserWindow().loadURL(targetHref);
new BrowserWindow().loadURL(targetHref); return;
return; }
}
mainWindow.useDefaultWindowBehaviour = true; mainWindow.useDefaultWindowBehaviour = true;
mainWindow.webContents.send('contextMenuClosed'); mainWindow.webContents.send('contextMenuClosed');
} },
}, },
{ {
label: 'Copy link location', label: 'Copy link location',
click: () => { click: () => {
if (targetHref) { if (targetHref) {
clipboard.writeText(targetHref); clipboard.writeText(targetHref);
return; return;
} }
mainWindow.useDefaultWindowBehaviour = true; mainWindow.useDefaultWindowBehaviour = true;
mainWindow.webContents.send('contextMenuClosed'); mainWindow.webContents.send('contextMenuClosed');
} },
} },
]; ];
const contextMenu = Menu.buildFromTemplate(contextMenuTemplate); const contextMenu = Menu.buildFromTemplate(contextMenuTemplate);
contextMenu.popup(mainWindow); contextMenu.popup(mainWindow);
mainWindow.contextMenuOpen = true; mainWindow.contextMenuOpen = true;
}); });
} }
export default initContextMenu; export default initContextMenu;

26
app/src/components/login/loginWindow.js
View File

@ -1,20 +1,20 @@
import {BrowserWindow, ipcMain} from 'electron'; import { BrowserWindow, ipcMain } from 'electron';
import path from 'path'; import path from 'path';
function createLoginWindow(loginCallback) { function createLoginWindow(loginCallback) {
var loginWindow = new BrowserWindow({ const loginWindow = new BrowserWindow({
width: 300, width: 300,
height: 400, height: 400,
frame: false, frame: false,
resizable: false resizable: false,
}); });
loginWindow.loadURL('file://' + path.join(__dirname, '/static/login/login.html')); loginWindow.loadURL(`file://${path.join(__dirname, '/static/login/login.html')}`);
ipcMain.once('login-message', function(event, usernameAndPassword) { ipcMain.once('login-message', (event, usernameAndPassword) => {
loginCallback(usernameAndPassword[0], usernameAndPassword[1]); loginCallback(usernameAndPassword[0], usernameAndPassword[1]);
loginWindow.close(); loginWindow.close();
}); });
return loginWindow; return loginWindow;
} }
export default createLoginWindow; export default createLoginWindow;

378
app/src/components/mainWindow/mainWindow.js
View File

@ -1,232 +1,234 @@
import fs from 'fs'; import fs from 'fs';
import path from 'path'; import path from 'path';
import {BrowserWindow, shell, ipcMain, dialog} from 'electron'; import { BrowserWindow, shell, ipcMain, dialog } from 'electron';
import windowStateKeeper from 'electron-window-state'; import windowStateKeeper from 'electron-window-state';
import helpers from './../../helpers/helpers'; import helpers from './../../helpers/helpers';
import createMenu from './../menu/menu'; import createMenu from './../menu/menu';
import initContextMenu from './../contextMenu/contextMenu'; import initContextMenu from './../contextMenu/contextMenu';
const {isOSX, linkIsInternal, getCssToInject, shouldInjectCss} = helpers; const { isOSX, linkIsInternal, getCssToInject, shouldInjectCss } = helpers;
const ZOOM_INTERVAL = 0.1; const ZOOM_INTERVAL = 0.1;
function maybeHideWindow(window, event, fastQuit) {
if (isOSX() && !fastQuit) {
// this is called when exiting from clicking the cross button on the window
event.preventDefault();
window.hide();
}
// will close the window on other platforms
}
function maybeInjectCss(browserWindow) {
if (!shouldInjectCss()) {
return;
}
const cssToInject = getCssToInject();
const injectCss = () => {
browserWindow.webContents.insertCSS(cssToInject);
};
browserWindow.webContents.on('did-finish-load', () => {
// remove the injection of css the moment the page is loaded
browserWindow.webContents.removeListener('did-get-response-details', injectCss);
});
// on every page navigation inject the css
browserWindow.webContents.on('did-navigate', () => {
// we have to inject the css in did-get-response-details to prevent the fouc
// will run multiple times
browserWindow.webContents.on('did-get-response-details', injectCss);
});
}
/** /**
* *
* @param {{}} options AppArgs from nativefier.json * @param {{}} inpOptions AppArgs from nativefier.json
* @param {function} onAppQuit * @param {function} onAppQuit
* @param {function} setDockBadge * @param {function} setDockBadge
* @returns {electron.BrowserWindow} * @returns {electron.BrowserWindow}
*/ */
function createMainWindow(options, onAppQuit, setDockBadge) { function createMainWindow(inpOptions, onAppQuit, setDockBadge) {
const mainWindowState = windowStateKeeper({ const options = Object.assign({}, inpOptions);
defaultWidth: options.width || 1280, const mainWindowState = windowStateKeeper({
defaultHeight: options.height || 800 defaultWidth: options.width || 1280,
}); defaultHeight: options.height || 800,
});
const mainWindow = new BrowserWindow({ const mainWindow = new BrowserWindow({
frame: !options.hideWindowFrame, frame: !options.hideWindowFrame,
width: mainWindowState.width, width: mainWindowState.width,
height: mainWindowState.height, height: mainWindowState.height,
minWidth: options.minWidth, minWidth: options.minWidth,
minHeight: options.minHeight, minHeight: options.minHeight,
maxWidth: options.maxWidth, maxWidth: options.maxWidth,
maxHeight: options.maxHeight, maxHeight: options.maxHeight,
x: mainWindowState.x, x: mainWindowState.x,
y: mainWindowState.y, y: mainWindowState.y,
autoHideMenuBar: !options.showMenuBar, autoHideMenuBar: !options.showMenuBar,
// Convert dashes to spaces because on linux the app name is joined with dashes // Convert dashes to spaces because on linux the app name is joined with dashes
title: options.name, title: options.name,
webPreferences: { webPreferences: {
javascript: true, javascript: true,
plugins: true, plugins: true,
// node globals causes problems with sites like messenger.com // node globals causes problems with sites like messenger.com
nodeIntegration: false, nodeIntegration: false,
webSecurity: !options.insecure, webSecurity: !options.insecure,
preload: path.join(__dirname, 'static', 'preload.js'), preload: path.join(__dirname, 'static', 'preload.js'),
zoomFactor: options.zoom zoomFactor: options.zoom,
}, },
// after webpack path here should reference `resources/app/` // after webpack path here should reference `resources/app/`
icon: path.join(__dirname, '../', '/icon.png'), icon: path.join(__dirname, '../', '/icon.png'),
// set to undefined and not false because explicitly setting to false will disable full screen // set to undefined and not false because explicitly setting to false will disable full screen
fullscreen: options.fullScreen || undefined fullscreen: options.fullScreen || undefined,
}); });
mainWindowState.manage(mainWindow); mainWindowState.manage(mainWindow);
// after first run, no longer force full screen to be true // after first run, no longer force full screen to be true
if (options.fullScreen) { if (options.fullScreen) {
options.fullScreen = undefined; options.fullScreen = undefined;
fs.writeFileSync(path.join(__dirname, '..', 'nativefier.json'), JSON.stringify(options)); fs.writeFileSync(path.join(__dirname, '..', 'nativefier.json'), JSON.stringify(options));
} }
// after first run, no longer force maximize to be true // after first run, no longer force maximize to be true
if (options.maximize) { if (options.maximize) {
mainWindow.maximize(); mainWindow.maximize();
options.maximize = undefined; options.maximize = undefined;
fs.writeFileSync(path.join(__dirname, '..', 'nativefier.json'), JSON.stringify(options)); fs.writeFileSync(path.join(__dirname, '..', 'nativefier.json'), JSON.stringify(options));
} }
let currentZoom = options.zoom; let currentZoom = options.zoom;
const onZoomIn = () => { const onZoomIn = () => {
currentZoom += ZOOM_INTERVAL; currentZoom += ZOOM_INTERVAL;
mainWindow.webContents.send('change-zoom', currentZoom); mainWindow.webContents.send('change-zoom', currentZoom);
}; };
const onZoomOut = () => { const onZoomOut = () => {
currentZoom -= ZOOM_INTERVAL; currentZoom -= ZOOM_INTERVAL;
mainWindow.webContents.send('change-zoom', currentZoom); mainWindow.webContents.send('change-zoom', currentZoom);
}; };
const onZoomReset = () => { const onZoomReset = () => {
mainWindow.webContents.send('change-zoom', options.zoom); mainWindow.webContents.send('change-zoom', options.zoom);
}; };
const clearAppData = () => { const clearAppData = () => {
dialog.showMessageBox(mainWindow, { dialog.showMessageBox(mainWindow, {
type: 'warning', type: 'warning',
buttons: ['Yes', 'Cancel'], buttons: ['Yes', 'Cancel'],
defaultId: 1, defaultId: 1,
title: 'Clear cache confirmation', title: 'Clear cache confirmation',
message: 'This will clear all data (cookies, local storage etc) from this app. Are you sure you wish to proceed?' message: 'This will clear all data (cookies, local storage etc) from this app. Are you sure you wish to proceed?',
}, response => { }, (response) => {
if (response === 0) { if (response !== 0) {
const session = mainWindow.webContents.session; return;
session.clearStorageData(() => { }
session.clearCache(() => { const session = mainWindow.webContents.session;
mainWindow.loadURL(options.targetUrl); session.clearStorageData(() => {
}); session.clearCache(() => {
}); mainWindow.loadURL(options.targetUrl);
}
}); });
}; });
});
};
const onGoBack = () => { const onGoBack = () => {
mainWindow.webContents.goBack(); mainWindow.webContents.goBack();
}; };
const onGoForward = () => { const onGoForward = () => {
mainWindow.webContents.goForward(); mainWindow.webContents.goForward();
}; };
const getCurrentUrl = () => { const getCurrentUrl = () => mainWindow.webContents.getURL();
return mainWindow.webContents.getURL();
};
const menuOptions = { const menuOptions = {
nativefierVersion: options.nativefierVersion, nativefierVersion: options.nativefierVersion,
appQuit: onAppQuit, appQuit: onAppQuit,
zoomIn: onZoomIn, zoomIn: onZoomIn,
zoomOut: onZoomOut, zoomOut: onZoomOut,
zoomReset: onZoomReset, zoomReset: onZoomReset,
zoomBuildTimeValue: options.zoom, zoomBuildTimeValue: options.zoom,
goBack: onGoBack, goBack: onGoBack,
goForward: onGoForward, goForward: onGoForward,
getCurrentUrl: getCurrentUrl, getCurrentUrl,
clearAppData: clearAppData, clearAppData,
disableDevTools: options.disableDevTools disableDevTools: options.disableDevTools,
}; };
createMenu(menuOptions); createMenu(menuOptions);
if (!options.disableContextMenu) { if (!options.disableContextMenu) {
initContextMenu(mainWindow); initContextMenu(mainWindow);
}
if (options.userAgent) {
mainWindow.webContents.setUserAgent(options.userAgent);
}
maybeInjectCss(mainWindow);
mainWindow.webContents.on('did-finish-load', () => {
mainWindow.webContents.send('params', JSON.stringify(options));
});
if (options.counter) {
mainWindow.on('page-title-updated', (e, title) => {
const itemCountRegex = /[([{](\d*?)[}\])]/;
const match = itemCountRegex.exec(title);
if (match) {
setDockBadge(match[1]);
} else {
setDockBadge('');
}
});
} else {
ipcMain.on('notification', () => {
if (!isOSX() || mainWindow.isFocused()) {
return;
}
setDockBadge('•');
});
mainWindow.on('focus', () => {
setDockBadge('');
});
}
mainWindow.webContents.on('new-window', (event, urlToGo) => {
if (mainWindow.useDefaultWindowBehaviour) {
mainWindow.useDefaultWindowBehaviour = false;
return;
} }
if (options.userAgent) { if (linkIsInternal(options.targetUrl, urlToGo, options.internalUrls)) {
mainWindow.webContents.setUserAgent(options.userAgent); return;
} }
event.preventDefault();
shell.openExternal(urlToGo);
});
maybeInjectCss(mainWindow); mainWindow.loadURL(options.targetUrl);
mainWindow.webContents.on('did-finish-load', () => {
mainWindow.webContents.send('params', JSON.stringify(options));
});
if (options.counter) { mainWindow.on('close', (event) => {
mainWindow.on('page-title-updated', (e, title) => { if (mainWindow.isFullScreen()) {
const itemCountRegex = /[\(\[{](\d*?)[}\]\)]/; mainWindow.setFullScreen(false);
const match = itemCountRegex.exec(title); mainWindow.once('leave-full-screen', maybeHideWindow.bind(this, mainWindow, event, options.fastQuit));
if (match) {
setDockBadge(match[1]);
} else {
setDockBadge('');
}
});
} else {
ipcMain.on('notification', () => {
if (!isOSX() || mainWindow.isFocused()) {
return;
}
setDockBadge('•');
});
mainWindow.on('focus', () => {
setDockBadge('');
});
} }
maybeHideWindow(mainWindow, event, options.fastQuit);
});
mainWindow.webContents.on('new-window', (event, urlToGo) => { return mainWindow;
if (mainWindow.useDefaultWindowBehaviour) {
mainWindow.useDefaultWindowBehaviour = false;
return;
}
if (linkIsInternal(options.targetUrl, urlToGo, options.internalUrls)) {
return;
}
event.preventDefault();
shell.openExternal(urlToGo);
});
mainWindow.loadURL(options.targetUrl);
mainWindow.on('close', event => {
if (mainWindow.isFullScreen()) {
mainWindow.setFullScreen(false);
mainWindow.once('leave-full-screen', maybeHideWindow.bind(this, mainWindow, event, options.fastQuit));
}
maybeHideWindow(mainWindow, event, options.fastQuit);
});
return mainWindow;
} }
ipcMain.on('cancelNewWindowOverride', () => { ipcMain.on('cancelNewWindowOverride', () => {
const allWindows = BrowserWindow.getAllWindows(); const allWindows = BrowserWindow.getAllWindows();
allWindows.forEach(window => { allWindows.forEach((window) => {
window.useDefaultWindowBehaviour = false; // eslint-disable-next-line no-param-reassign
}); window.useDefaultWindowBehaviour = false;
});
}); });
function maybeHideWindow(window, event, fastQuit) {
if (isOSX() && !fastQuit) {
// this is called when exiting from clicking the cross button on the window
event.preventDefault();
window.hide();
}
// will close the window on other platforms
}
function maybeInjectCss(browserWindow) {
if (!shouldInjectCss()) {
return;
}
const cssToInject = getCssToInject();
const injectCss = () => {
browserWindow.webContents.insertCSS(cssToInject);
};
browserWindow.webContents.on('did-finish-load', () => {
// remove the injection of css the moment the page is loaded
browserWindow.webContents.removeListener('did-get-response-details', injectCss);
});
// on every page navigation inject the css
browserWindow.webContents.on('did-navigate', () => {
// we have to inject the css in did-get-response-details to prevent the fouc
// will run multiple times
browserWindow.webContents.on('did-get-response-details', injectCss);
});
}
export default createMainWindow; export default createMainWindow;

486
app/src/components/menu/menu.js
View File

@ -1,4 +1,4 @@
import {Menu, shell, clipboard} from 'electron'; import { Menu, shell, clipboard } from 'electron';
/** /**
* @param nativefierVersion * @param nativefierVersion
@ -13,255 +13,265 @@ import {Menu, shell, clipboard} from 'electron';
* @param clearAppData * @param clearAppData
* @param disableDevTools * @param disableDevTools
*/ */
function createMenu({nativefierVersion, appQuit, zoomIn, zoomOut, zoomReset, zoomBuildTimeValue, goBack, goForward, getCurrentUrl, clearAppData, disableDevTools}) { function createMenu({ nativefierVersion,
if (Menu.getApplicationMenu()) { appQuit,
return; zoomIn,
} zoomOut,
const zoomResetLabel = (zoomBuildTimeValue === 1.0) ? zoomReset,
zoomBuildTimeValue,
goBack,
goForward,
getCurrentUrl,
clearAppData,
disableDevTools }) {
if (Menu.getApplicationMenu()) {
return;
}
const zoomResetLabel = (zoomBuildTimeValue === 1.0) ?
'Reset Zoom' : 'Reset Zoom' :
`Reset Zoom (to ${zoomBuildTimeValue * 100}%, set at build time)`; `Reset Zoom (to ${zoomBuildTimeValue * 100}%, set at build time)`;
const template = [ const template = [
{
label: 'Edit',
submenu: [
{ {
label: 'Edit', label: 'Undo',
submenu: [ accelerator: 'CmdOrCtrl+Z',
{ role: 'undo',
label: 'Undo',
accelerator: 'CmdOrCtrl+Z',
role: 'undo'
},
{
label: 'Redo',
accelerator: 'Shift+CmdOrCtrl+Z',
role: 'redo'
},
{
type: 'separator'
},
{
label: 'Cut',
accelerator: 'CmdOrCtrl+X',
role: 'cut'
},
{
label: 'Copy',
accelerator: 'CmdOrCtrl+C',
role: 'copy'
},
{
label: 'Copy Current URL',
accelerator: 'CmdOrCtrl+L',
click: () => {
const currentURL = getCurrentUrl();
clipboard.writeText(currentURL);
}
},
{
label: 'Paste',
accelerator: 'CmdOrCtrl+V',
role: 'paste'
},
{
label: 'Select All',
accelerator: 'CmdOrCtrl+A',
role: 'selectall'
},
{
label: 'Clear App Data',
click: () => {
clearAppData();
}
}
]
}, },
{ {
label: 'View', label: 'Redo',
submenu: [ accelerator: 'Shift+CmdOrCtrl+Z',
{ role: 'redo',
label: 'Back',
accelerator: 'CmdOrCtrl+[',
click: () => {
goBack();
}
},
{
label: 'Forward',
accelerator: 'CmdOrCtrl+]',
click: () => {
goForward();
}
},
{
label: 'Reload',
accelerator: 'CmdOrCtrl+R',
click: (item, focusedWindow) => {
if (focusedWindow) {
focusedWindow.reload();
}
}
},
{
type: 'separator'
},
{
label: 'Toggle Full Screen',
accelerator: (() => {
if (process.platform === 'darwin') {
return 'Ctrl+Command+F';
}
return 'F11';
})(),
click: (item, focusedWindow) => {
if (focusedWindow) {
focusedWindow.setFullScreen(!focusedWindow.isFullScreen());
}
}
},
{
label: 'Zoom In',
accelerator: (() => {
if (process.platform === 'darwin') {
return 'Command+=';
}
return 'Ctrl+=';
})(),
click: () => {
zoomIn();
}
},
{
label: 'Zoom Out',
accelerator: (() => {
if (process.platform === 'darwin') {
return 'Command+-';
}
return 'Ctrl+-';
})(),
click: () => {
zoomOut();
}
},
{
label: zoomResetLabel,
accelerator: (() => {
if (process.platform === 'darwin') {
return 'Command+0';
}
return 'Ctrl+0';
})(),
click: () => {
zoomReset();
}
},
{
label: 'Toggle Developer Tools',
accelerator: (() => {
if (process.platform === 'darwin') {
return 'Alt+Command+I';
}
return 'Ctrl+Shift+I';
})(),
click: (item, focusedWindow) => {
if (focusedWindow) {
focusedWindow.toggleDevTools();
}
}
}
]
}, },
{ {
label: 'Window', type: 'separator',
role: 'window',
submenu: [
{
label: 'Minimize',
accelerator: 'CmdOrCtrl+M',
role: 'minimize'
},
{
label: 'Close',
accelerator: 'CmdOrCtrl+W',
role: 'close'
}
]
}, },
{ {
label: 'Help', label: 'Cut',
role: 'help', accelerator: 'CmdOrCtrl+X',
submenu: [ role: 'cut',
{ },
label: `Built with Nativefier v${nativefierVersion}`, {
click: () => { label: 'Copy',
shell.openExternal('https://github.com/jiahaog/nativefier'); accelerator: 'CmdOrCtrl+C',
} role: 'copy',
}, },
{ {
label: 'Report an Issue', label: 'Copy Current URL',
click: () => { accelerator: 'CmdOrCtrl+L',
shell.openExternal('https://github.com/jiahaog/nativefier/issues'); click: () => {
} const currentURL = getCurrentUrl();
} clipboard.writeText(currentURL);
] },
} },
]; {
label: 'Paste',
if (disableDevTools) { accelerator: 'CmdOrCtrl+V',
// remove last item (dev tools) from menu > view role: 'paste',
const submenu = template[1].submenu; },
submenu.splice(submenu.length - 1, 1); {
} label: 'Select All',
accelerator: 'CmdOrCtrl+A',
if (process.platform === 'darwin') { role: 'selectall',
template.unshift({ },
label: 'Electron', {
submenu: [ label: 'Clear App Data',
{ click: () => {
label: 'Services', clearAppData();
role: 'services', },
submenu: [] },
}, ],
{ },
type: 'separator' {
}, label: 'View',
{ submenu: [
label: 'Hide App', {
accelerator: 'Command+H', label: 'Back',
role: 'hide' accelerator: 'CmdOrCtrl+[',
}, click: () => {
{ goBack();
label: 'Hide Others', },
accelerator: 'Command+Shift+H', },
role: 'hideothers' {
}, label: 'Forward',
{ accelerator: 'CmdOrCtrl+]',
label: 'Show All', click: () => {
role: 'unhide' goForward();
}, },
{ },
type: 'separator' {
}, label: 'Reload',
{ accelerator: 'CmdOrCtrl+R',
label: 'Quit', click: (item, focusedWindow) => {
accelerator: 'Command+Q', if (focusedWindow) {
click: () => { focusedWindow.reload();
appQuit();
}
}
]
});
template[3].submenu.push(
{
type: 'separator'
},
{
label: 'Bring All to Front',
role: 'front'
} }
); },
} },
{
type: 'separator',
},
{
label: 'Toggle Full Screen',
accelerator: (() => {
if (process.platform === 'darwin') {
return 'Ctrl+Command+F';
}
return 'F11';
})(),
click: (item, focusedWindow) => {
if (focusedWindow) {
focusedWindow.setFullScreen(!focusedWindow.isFullScreen());
}
},
},
{
label: 'Zoom In',
accelerator: (() => {
if (process.platform === 'darwin') {
return 'Command+=';
}
return 'Ctrl+=';
})(),
click: () => {
zoomIn();
},
},
{
label: 'Zoom Out',
accelerator: (() => {
if (process.platform === 'darwin') {
return 'Command+-';
}
return 'Ctrl+-';
})(),
click: () => {
zoomOut();
},
},
{
label: zoomResetLabel,
accelerator: (() => {
if (process.platform === 'darwin') {
return 'Command+0';
}
return 'Ctrl+0';
})(),
click: () => {
zoomReset();
},
},
{
label: 'Toggle Developer Tools',
accelerator: (() => {
if (process.platform === 'darwin') {
return 'Alt+Command+I';
}
return 'Ctrl+Shift+I';
})(),
click: (item, focusedWindow) => {
if (focusedWindow) {
focusedWindow.toggleDevTools();
}
},
},
],
},
{
label: 'Window',
role: 'window',
submenu: [
{
label: 'Minimize',
accelerator: 'CmdOrCtrl+M',
role: 'minimize',
},
{
label: 'Close',
accelerator: 'CmdOrCtrl+W',
role: 'close',
},
],
},
{
label: 'Help',
role: 'help',
submenu: [
{
label: `Built with Nativefier v${nativefierVersion}`,
click: () => {
shell.openExternal('https://github.com/jiahaog/nativefier');
},
},
{
label: 'Report an Issue',
click: () => {
shell.openExternal('https://github.com/jiahaog/nativefier/issues');
},
},
],
},
];
const menu = Menu.buildFromTemplate(template); if (disableDevTools) {
Menu.setApplicationMenu(menu); // remove last item (dev tools) from menu > view
const submenu = template[1].submenu;
submenu.splice(submenu.length - 1, 1);
}
if (process.platform === 'darwin') {
template.unshift({
label: 'Electron',
submenu: [
{
label: 'Services',
role: 'services',
submenu: [],
},
{
type: 'separator',
},
{
label: 'Hide App',
accelerator: 'Command+H',
role: 'hide',
},
{
label: 'Hide Others',
accelerator: 'Command+Shift+H',
role: 'hideothers',
},
{
label: 'Show All',
role: 'unhide',
},
{
type: 'separator',
},
{
label: 'Quit',
accelerator: 'Command+Q',
click: () => {
appQuit();
},
},
],
});
template[3].submenu.push(
{
type: 'separator',
},
{
label: 'Bring All to Front',
role: 'front',
},
);
}
const menu = Menu.buildFromTemplate(template);
Menu.setApplicationMenu(menu);
} }
export default createMenu; export default createMenu;

59
app/src/helpers/helpers.js
View File

@ -6,39 +6,39 @@ import path from 'path';
const INJECT_CSS_PATH = path.join(__dirname, '..', 'inject/inject.css'); const INJECT_CSS_PATH = path.join(__dirname, '..', 'inject/inject.css');
function isOSX() { function isOSX() {
return os.platform() === 'darwin'; return os.platform() === 'darwin';
} }
function isLinux() { function isLinux() {
return os.platform() === 'linux'; return os.platform() === 'linux';
} }
function isWindows() { function isWindows() {
return os.platform() === 'win32'; return os.platform() === 'win32';
} }
function linkIsInternal(currentUrl, newUrl, internalUrlRegex) { function linkIsInternal(currentUrl, newUrl, internalUrlRegex) {
if (internalUrlRegex) { if (internalUrlRegex) {
var regex = RegExp(internalUrlRegex); const regex = RegExp(internalUrlRegex);
return regex.test(newUrl); return regex.test(newUrl);
} }
var currentDomain = wurl('domain', currentUrl); const currentDomain = wurl('domain', currentUrl);
var newDomain = wurl('domain', newUrl); const newDomain = wurl('domain', newUrl);
return currentDomain === newDomain; return currentDomain === newDomain;
} }
function shouldInjectCss() { function shouldInjectCss() {
try { try {
fs.accessSync(INJECT_CSS_PATH, fs.F_OK); fs.accessSync(INJECT_CSS_PATH, fs.F_OK);
return true; return true;
} catch (e) { } catch (e) {
return false; return false;
} }
} }
function getCssToInject() { function getCssToInject() {
return fs.readFileSync(INJECT_CSS_PATH).toString(); return fs.readFileSync(INJECT_CSS_PATH).toString();
} }
/** /**
@ -47,19 +47,20 @@ function getCssToInject() {
* @param message * @param message
*/ */
function debugLog(browserWindow, message) { function debugLog(browserWindow, message) {
// need the timeout as it takes time for the preload javascript to be loaded in the window // need the timeout as it takes time for the preload javascript to be loaded in the window
setTimeout(() => { setTimeout(() => {
browserWindow.webContents.send('debug', message); browserWindow.webContents.send('debug', message);
}, 3000); }, 3000);
console.log(message); // eslint-disable-next-line no-console
console.log(message);
} }
export default { export default {
isOSX, isOSX,
isLinux, isLinux,
isWindows, isWindows,
linkIsInternal, linkIsInternal,
getCssToInject, getCssToInject,
debugLog, debugLog,
shouldInjectCss shouldInjectCss,
}; };

108
app/src/helpers/inferFlash.js
View File

@ -2,23 +2,7 @@ import fs from 'fs';
import path from 'path'; import path from 'path';
import helpers from './helpers'; import helpers from './helpers';
const {isOSX, isWindows, isLinux} = helpers; const { isOSX, isWindows, isLinux } = helpers;
function inferFlash() {
if (isOSX()) {
return darwinMatch();
}
if (isWindows()) {
return windowsMatch();
}
if (isLinux()) {
return linuxMatch();
}
console.warn('Unable to determine OS to infer flash player');
}
/** /**
* Synchronously find a file or directory * Synchronously find a file or directory
@ -27,56 +11,72 @@ function inferFlash() {
* @param {boolean} [findDir] if true, search results will be limited to only directories * @param {boolean} [findDir] if true, search results will be limited to only directories
* @returns {Array} * @returns {Array}
*/ */
function findSync(pattern, base, findDir) { function findSync(pattern, basePath, findDir) {
const matches = []; const matches = [];
(function findSyncRecurse(base) { (function findSyncRecurse(base) {
let children; let children;
try { try {
children = fs.readdirSync(base); children = fs.readdirSync(base);
} catch (exception) { } catch (exception) {
if (exception.code === 'ENOENT') { if (exception.code === 'ENOENT') {
return; return;
} }
throw exception; throw exception;
}
children.forEach((child) => {
const childPath = path.join(base, child);
const childIsDirectory = fs.lstatSync(childPath).isDirectory();
const patternMatches = pattern.test(childPath);
if (!patternMatches) {
if (!childIsDirectory) {
return;
} }
findSyncRecurse(childPath);
return;
}
children.forEach(child => { if (!findDir) {
const childPath = path.join(base, child); matches.push(childPath);
const childIsDirectory = fs.lstatSync(childPath).isDirectory(); return;
const patternMatches = pattern.test(childPath); }
if (!patternMatches) { if (childIsDirectory) {
if (!childIsDirectory) { matches.push(childPath);
return; }
} });
findSyncRecurse(childPath); }(basePath));
return; return matches;
}
if (!findDir) {
matches.push(childPath);
return;
}
if (childIsDirectory) {
matches.push(childPath);
}
});
})(base);
return matches;
} }
function linuxMatch() { function linuxMatch() {
return findSync(/libpepflashplayer\.so/, '/opt/google/chrome')[0]; return findSync(/libpepflashplayer\.so/, '/opt/google/chrome')[0];
} }
function windowsMatch() { function windowsMatch() {
return findSync(/pepflashplayer\.dll/, 'C:\\Program Files (x86)\\Google\\Chrome')[0]; return findSync(/pepflashplayer\.dll/, 'C:\\Program Files (x86)\\Google\\Chrome')[0];
} }
function darwinMatch() { function darwinMatch() {
return findSync(/PepperFlashPlayer.plugin/, '/Applications/Google Chrome.app/', true)[0]; return findSync(/PepperFlashPlayer.plugin/, '/Applications/Google Chrome.app/', true)[0];
} }
function inferFlash() {
if (isOSX()) {
return darwinMatch();
}
if (isWindows()) {
return windowsMatch();
}
if (isLinux()) {
return linuxMatch();
}
console.warn('Unable to determine OS to infer flash player');
return null;
}
export default inferFlash; export default inferFlash;

90
app/src/main.js
View File

@ -1,14 +1,15 @@
import 'source-map-support/register'; import 'source-map-support/register';
import fs from 'fs'; import fs from 'fs';
import path from 'path'; import path from 'path';
import {app, crashReporter} from 'electron'; import { app, crashReporter } from 'electron';
import electronDownload from 'electron-dl';
import createLoginWindow from './components/login/loginWindow'; import createLoginWindow from './components/login/loginWindow';
import createMainWindow from './components/mainWindow/mainWindow'; import createMainWindow from './components/mainWindow/mainWindow';
import helpers from './helpers/helpers'; import helpers from './helpers/helpers';
import inferFlash from './helpers/inferFlash'; import inferFlash from './helpers/inferFlash';
import electronDownload from 'electron-dl';
const {isOSX} = helpers; const { isOSX } = helpers;
electronDownload(); electronDownload();
@ -18,83 +19,82 @@ const appArgs = JSON.parse(fs.readFileSync(APP_ARGS_FILE_PATH, 'utf8'));
let mainWindow; let mainWindow;
if (typeof appArgs.flashPluginDir === 'string') { if (typeof appArgs.flashPluginDir === 'string') {
app.commandLine.appendSwitch('ppapi-flash-path', appArgs.flashPluginDir); app.commandLine.appendSwitch('ppapi-flash-path', appArgs.flashPluginDir);
} else if (appArgs.flashPluginDir) { } else if (appArgs.flashPluginDir) {
const flashPath = inferFlash(); const flashPath = inferFlash();
app.commandLine.appendSwitch('ppapi-flash-path', flashPath); app.commandLine.appendSwitch('ppapi-flash-path', flashPath);
} }
if (appArgs.ignoreCertificate) { if (appArgs.ignoreCertificate) {
app.commandLine.appendSwitch('ignore-certificate-errors'); app.commandLine.appendSwitch('ignore-certificate-errors');
} }
// do nothing for setDockBadge if not OSX // do nothing for setDockBadge if not OSX
let setDockBadge = () => {}; let setDockBadge = () => {};
if (isOSX()) { if (isOSX()) {
setDockBadge = app.dock.setBadge; setDockBadge = app.dock.setBadge;
} }
app.on('window-all-closed', () => { app.on('window-all-closed', () => {
if (!isOSX() || appArgs.fastQuit) { if (!isOSX() || appArgs.fastQuit) {
app.quit(); app.quit();
} }
}); });
app.on('activate', (event, hasVisibleWindows) => { app.on('activate', (event, hasVisibleWindows) => {
if (isOSX()) { if (isOSX()) {
// this is called when the dock is clicked // this is called when the dock is clicked
if (!hasVisibleWindows) { if (!hasVisibleWindows) {
mainWindow.show(); mainWindow.show();
}
} }
}
}); });
app.on('before-quit', () => { app.on('before-quit', () => {
// not fired when the close button on the window is clicked // not fired when the close button on the window is clicked
if (isOSX()) { if (isOSX()) {
// need to force a quit as a workaround here to simulate the osx app hiding behaviour // need to force a quit as a workaround here to simulate the osx app hiding behaviour
// Somehow sokution at https://github.com/atom/electron/issues/444#issuecomment-76492576 does not work, // Somehow sokution at https://github.com/atom/electron/issues/444#issuecomment-76492576 does not work,
// e.prevent default appears to persist // e.prevent default appears to persist
// might cause issues in the future as before-quit and will-quit events are not called // might cause issues in the future as before-quit and will-quit events are not called
app.exit(0); app.exit(0);
} }
}); });
if (appArgs.crashReporter) { if (appArgs.crashReporter) {
app.on('will-finish-launching', () => { app.on('will-finish-launching', () => {
crashReporter.start({ crashReporter.start({
productName: appArgs.name, productName: appArgs.name,
submitURL: appArgs.crashReporter, submitURL: appArgs.crashReporter,
autoSubmit: true autoSubmit: true,
});
}); });
});
} }
app.on('ready', () => { app.on('ready', () => {
mainWindow = createMainWindow(appArgs, app.quit, setDockBadge); mainWindow = createMainWindow(appArgs, app.quit, setDockBadge);
}); });
app.on('login', (event, webContents, request, authInfo, callback) => { app.on('login', (event, webContents, request, authInfo, callback) => {
// for http authentication // for http authentication
event.preventDefault(); event.preventDefault();
createLoginWindow(callback); createLoginWindow(callback);
}); });
if (appArgs.singleInstance) { if (appArgs.singleInstance) {
const shouldQuit = app.makeSingleInstance(() => { const shouldQuit = app.makeSingleInstance(() => {
// Someone tried to run a second instance, we should focus our window. // Someone tried to run a second instance, we should focus our window.
if (mainWindow) { if (mainWindow) {
if (mainWindow.isMinimized()) { if (mainWindow.isMinimized()) {
mainWindow.restore(); mainWindow.restore();
} }
mainWindow.focus(); mainWindow.focus();
}
});
if (shouldQuit) {
app.quit();
} }
});
if (shouldQuit) {
app.quit();
}
} }

2
app/src/static/.eslintrc.yml Normal file
View File

@ -0,0 +1,2 @@
env:
browser: true

13
app/src/static/login/login.js
View File

@ -1,11 +1,12 @@
import electron from 'electron'; import electron from 'electron';
const {ipcRenderer} = electron;
const { ipcRenderer } = electron;
const form = document.getElementById('login-form'); const form = document.getElementById('login-form');
form.addEventListener('submit', event => { form.addEventListener('submit', (event) => {
event.preventDefault(); event.preventDefault();
const username = document.getElementById('username-input').value; const username = document.getElementById('username-input').value;
const password = document.getElementById('password-input').value; const password = document.getElementById('password-input').value;
ipcRenderer.send('login-message', [username, password]); ipcRenderer.send('login-message', [username, password]);
}); });

129
app/src/static/preload.js
View File

@ -1,86 +1,85 @@
/** /**
Preload file that will be executed in the renderer process Preload file that will be executed in the renderer process
*/ */
import {ipcRenderer, webFrame} from 'electron'; import { ipcRenderer, webFrame } from 'electron';
import path from 'path'; import path from 'path';
import fs from 'fs'; import fs from 'fs';
const INJECT_JS_PATH = path.join(__dirname, '../../', 'inject/inject.js'); const INJECT_JS_PATH = path.join(__dirname, '../../', 'inject/inject.js');
setNotificationCallback((title, opt) => {
ipcRenderer.send('notification', title, opt);
});
document.addEventListener('DOMContentLoaded', () => {
// do things
window.addEventListener('contextmenu', event => {
event.preventDefault();
let targetElement = event.srcElement;
// the clicked element is the deepest in the DOM, and may not be the <a> bearing the href
// for example, <a href="..."><span>Google</span></a>
while (!targetElement.href && targetElement.parentElement) {
targetElement = targetElement.parentElement;
}
const targetHref = targetElement.href;
if (!targetHref) {
ipcRenderer.once('contextMenuClosed', () => {
clickSelector(event.target);
ipcRenderer.send('cancelNewWindowOverride');
});
}
ipcRenderer.send('contextMenuOpened', targetHref);
}, false);
injectScripts();
});
ipcRenderer.on('params', (event, message) => {
const appArgs = JSON.parse(message);
console.log('nativefier.json', appArgs);
});
ipcRenderer.on('debug', (event, message) => {
console.log('debug:', message);
});
ipcRenderer.on('change-zoom', (event, message) => {
webFrame.setZoomFactor(message);
});
/** /**
* Patches window.Notification to set a callback on a new Notification * Patches window.Notification to set a callback on a new Notification
* @param callback * @param callback
*/ */
function setNotificationCallback(callback) { function setNotificationCallback(callback) {
const OldNotify = window.Notification;
const newNotify = (title, opt) => {
callback(title, opt);
return new OldNotify(title, opt);
};
newNotify.requestPermission = OldNotify.requestPermission.bind(OldNotify);
Object.defineProperty(newNotify, 'permission', {
get: () => OldNotify.permission,
});
const OldNotify = window.Notification; window.Notification = newNotify;
const newNotify = (title, opt) => {
callback(title, opt);
return new OldNotify(title, opt);
};
newNotify.requestPermission = OldNotify.requestPermission.bind(OldNotify);
Object.defineProperty(newNotify, 'permission', {
get: () => {
return OldNotify.permission;
}
});
window.Notification = newNotify;
} }
function clickSelector(element) { function clickSelector(element) {
const mouseEvent = new MouseEvent('click'); const mouseEvent = new MouseEvent('click');
element.dispatchEvent(mouseEvent); element.dispatchEvent(mouseEvent);
} }
function injectScripts() { function injectScripts() {
const needToInject = fs.existsSync(INJECT_JS_PATH); const needToInject = fs.existsSync(INJECT_JS_PATH);
if (!needToInject) { if (!needToInject) {
return; return;
} }
require(INJECT_JS_PATH); // Dynamically require scripts
// eslint-disable-next-line global-require, import/no-dynamic-require
require(INJECT_JS_PATH);
} }
setNotificationCallback((title, opt) => {
ipcRenderer.send('notification', title, opt);
});
document.addEventListener('DOMContentLoaded', () => {
window.addEventListener('contextmenu', (event) => {
event.preventDefault();
let targetElement = event.srcElement;
// the clicked element is the deepest in the DOM, and may not be the <a> bearing the href
// for example, <a href="..."><span>Google</span></a>
while (!targetElement.href && targetElement.parentElement) {
targetElement = targetElement.parentElement;
}
const targetHref = targetElement.href;
if (!targetHref) {
ipcRenderer.once('contextMenuClosed', () => {
clickSelector(event.target);
ipcRenderer.send('cancelNewWindowOverride');
});
}
ipcRenderer.send('contextMenuOpened', targetHref);
}, false);
injectScripts();
});
ipcRenderer.on('params', (event, message) => {
const appArgs = JSON.parse(message);
console.log('nativefier.json', appArgs);
});
ipcRenderer.on('debug', (event, message) => {
// eslint-disable-next-line no-console
console.log('debug:', message);
});
ipcRenderer.on('change-zoom', (event, message) => {
webFrame.setZoomFactor(message);
});

21
gulp/build.js
View File

@ -1,19 +1,18 @@
import gulp from 'gulp'; import gulp from 'gulp';
import PATHS from './helpers/src-paths';
import del from 'del'; import del from 'del';
import runSequence from 'run-sequence'; import runSequence from 'run-sequence';
import PATHS from './helpers/src-paths';
gulp.task('build', callback => { gulp.task('build', (callback) => {
runSequence('clean', ['build-cli', 'build-app', 'build-tests'], callback); runSequence('clean', ['build-cli', 'build-app', 'build-tests'], callback);
}); });
gulp.task('clean', callback => { gulp.task('clean', (callback) => {
del(PATHS.CLI_DEST).then(() => { del(PATHS.CLI_DEST).then(() => {
del(PATHS.APP_DEST).then(() => { del(PATHS.APP_DEST).then(() => {
del(PATHS.TEST_DEST).then(() => { del(PATHS.TEST_DEST).then(() => {
callback(); callback();
}); });
});
}); });
});
}); });

11
gulp/build/build-app.js
View File

@ -1,10 +1,9 @@
import gulp from 'gulp'; import gulp from 'gulp';
import webpack from 'webpack-stream';
import PATHS from './../helpers/src-paths'; import PATHS from './../helpers/src-paths';
import webpack from 'webpack-stream'; const webpackConfig = require('./../../webpack.config.js');
gulp.task('build-app', ['build-static'], () => { gulp.task('build-app', ['build-static'], () => gulp.src(PATHS.APP_MAIN_JS)
return gulp.src(PATHS.APP_MAIN_JS) .pipe(webpack(webpackConfig))
.pipe(webpack(require('./../../webpack.config.js'))) .pipe(gulp.dest(PATHS.APP_DEST)));
.pipe(gulp.dest(PATHS.APP_DEST));
});

6
gulp/build/build-cli.js
View File

@ -2,8 +2,6 @@ import gulp from 'gulp';
import PATHS from './../helpers/src-paths'; import PATHS from './../helpers/src-paths';
import helpers from './../helpers/gulp-helpers'; import helpers from './../helpers/gulp-helpers';
const {buildES6} = helpers; const { buildES6 } = helpers;
gulp.task('build-cli', done => { gulp.task('build-cli', done => buildES6(PATHS.CLI_SRC_JS, PATHS.CLI_DEST, done));
return buildES6(PATHS.CLI_SRC_JS, PATHS.CLI_DEST, done);
});

12
gulp/build/build-static.js
View File

@ -2,15 +2,11 @@ import gulp from 'gulp';
import PATHS from './../helpers/src-paths'; import PATHS from './../helpers/src-paths';
import helpers from './../helpers/gulp-helpers'; import helpers from './../helpers/gulp-helpers';
const {buildES6} = helpers; const { buildES6 } = helpers;
gulp.task('build-static-not-js', () => { gulp.task('build-static-not-js', () => gulp.src([PATHS.APP_STATIC_ALL, '!**/*.js'])
return gulp.src([PATHS.APP_STATIC_ALL, '!**/*.js']) .pipe(gulp.dest(PATHS.APP_STATIC_DEST)));
.pipe(gulp.dest(PATHS.APP_STATIC_DEST));
});
gulp.task('build-static-js', done => { gulp.task('build-static-js', done => buildES6(PATHS.APP_STATIC_JS, PATHS.APP_STATIC_DEST, done));
return buildES6(PATHS.APP_STATIC_JS, PATHS.APP_STATIC_DEST, done);
});
gulp.task('build-static', ['build-static-js', 'build-static-not-js']); gulp.task('build-static', ['build-static-js', 'build-static-not-js']);

20
gulp/helpers/gulp-helpers.js
View File

@ -4,17 +4,17 @@ import sourcemaps from 'gulp-sourcemaps';
import babel from 'gulp-babel'; import babel from 'gulp-babel';
function shellExec(cmd, silent, callback) { function shellExec(cmd, silent, callback) {
shellJs.exec(cmd, {silent: silent}, (code, stdout, stderr) => { shellJs.exec(cmd, { silent }, (code, stdout, stderr) => {
if (code) { if (code) {
callback(JSON.stringify({code, stdout, stderr})); callback(JSON.stringify({ code, stdout, stderr }));
return; return;
} }
callback(); callback();
}); });
} }
function buildES6(src, dest, callback) { function buildES6(src, dest, callback) {
return gulp.src(src) return gulp.src(src)
.pipe(sourcemaps.init()) .pipe(sourcemaps.init())
.pipe(babel()) .pipe(babel())
.on('error', callback) .on('error', callback)
@ -23,6 +23,6 @@ function buildES6(src, dest, callback) {
} }
export default { export default {
shellExec, shellExec,
buildES6 buildES6,
}; };

26
gulp/helpers/src-paths.js
View File

@ -1,22 +1,22 @@
import path from 'path'; import path from 'path';
const paths = { const paths = {
APP_SRC: 'app/src', APP_SRC: 'app/src',
APP_DEST: 'app/lib', APP_DEST: 'app/lib',
CLI_SRC: 'src', CLI_SRC: 'src',
CLI_DEST: 'lib', CLI_DEST: 'lib',
TEST_SRC: 'test', TEST_SRC: 'test',
TEST_DEST: 'built-tests' TEST_DEST: 'built-tests',
}; };
paths.APP_MAIN_JS = path.join(paths.APP_SRC, '/main.js'); paths.APP_MAIN_JS = path.join(paths.APP_SRC, '/main.js');
paths.APP_ALL = paths.APP_SRC + '/**/*'; paths.APP_ALL = `${paths.APP_SRC}/**/*`;
paths.APP_STATIC_ALL = path.join(paths.APP_SRC, 'static') + '/**/*'; paths.APP_STATIC_ALL = `${path.join(paths.APP_SRC, 'static')}/**/*`;
paths.APP_STATIC_JS = path.join(paths.APP_SRC, 'static') + '/**/*.js'; paths.APP_STATIC_JS = `${path.join(paths.APP_SRC, 'static')}/**/*.js`;
paths.APP_STATIC_DEST = path.join(paths.APP_DEST, 'static'); paths.APP_STATIC_DEST = path.join(paths.APP_DEST, 'static');
paths.CLI_SRC_JS = paths.CLI_SRC + '/**/*.js'; paths.CLI_SRC_JS = `${paths.CLI_SRC}/**/*.js`;
paths.CLI_DEST_JS = paths.CLI_DEST + '/**/*.js'; paths.CLI_DEST_JS = `${paths.CLI_DEST}/**/*.js`;
paths.TEST_SRC_JS = paths.TEST_SRC + '/**/*.js'; paths.TEST_SRC_JS = `${paths.TEST_SRC}/**/*.js`;
paths.TEST_DEST_JS = paths.TEST_DEST + '/**/*.js'; paths.TEST_DEST_JS = `${paths.TEST_DEST}/**/*.js`;
export default paths; export default paths;

10
gulp/release.js
View File

@ -2,12 +2,10 @@ import gulp from 'gulp';
import runSequence from 'run-sequence'; import runSequence from 'run-sequence';
import helpers from './helpers/gulp-helpers'; import helpers from './helpers/gulp-helpers';
const {shellExec} = helpers; const { shellExec } = helpers;
gulp.task('publish', done => { gulp.task('publish', (done) => {
shellExec('npm publish', false, done); shellExec('npm publish', false, done);
}); });
gulp.task('release', callback => { gulp.task('release', callback => runSequence('build', 'publish', callback));
return runSequence('build', 'publish', callback);
});

10
gulp/test.js
View File

@ -2,12 +2,10 @@ import gulp from 'gulp';
import runSequence from 'run-sequence'; import runSequence from 'run-sequence';
import helpers from './helpers/gulp-helpers'; import helpers from './helpers/gulp-helpers';
const {shellExec} = helpers; const { shellExec } = helpers;
gulp.task('prune', done => { gulp.task('prune', (done) => {
shellExec('npm prune', true, done); shellExec('npm prune', true, done);
}); });
gulp.task('test', callback => { gulp.task('test', callback => runSequence('prune', 'mocha', callback));
return runSequence('prune', 'mocha', callback);
});

6
gulp/tests/build-tests.js
View File

@ -2,8 +2,6 @@ import gulp from 'gulp';
import PATHS from './../helpers/src-paths'; import PATHS from './../helpers/src-paths';
import helpers from './../helpers/gulp-helpers'; import helpers from './../helpers/gulp-helpers';
const {buildES6} = helpers; const { buildES6 } = helpers;
gulp.task('build-tests', done => { gulp.task('build-tests', done => buildES6(PATHS.TEST_SRC_JS, PATHS.TEST_DEST, done));
return buildES6(PATHS.TEST_SRC_JS, PATHS.TEST_DEST, done);
});

49
gulp/tests/mocha.js
View File

@ -1,32 +1,27 @@
import gulp from 'gulp'; import gulp from 'gulp';
import istanbul from 'gulp-istanbul';
import { Instrumenter } from 'isparta';
import mocha from 'gulp-mocha';
import PATHS from './../helpers/src-paths'; import PATHS from './../helpers/src-paths';
import istanbul from 'gulp-istanbul'; gulp.task('mocha', (done) => {
import {Instrumenter} from 'isparta'; gulp.src([PATHS.CLI_SRC_JS, '!src/cli.js'])
import mocha from 'gulp-mocha'; .pipe(istanbul({
instrumenter: Instrumenter,
gulp.task('mocha', done => { includeUntested: true,
gulp.src([PATHS.CLI_SRC_JS, '!src/cli.js']) }))
.pipe(istanbul({ .pipe(istanbul.hookRequire()) // Force `require` to return covered files
instrumenter: Instrumenter, .on('finish', () => gulp.src(PATHS.TEST_SRC, { read: false })
includeUntested: true .pipe(mocha({
})) compilers: 'js:babel-core/register',
.pipe(istanbul.hookRequire()) // Force `require` to return covered files recursive: true,
.on('finish', () => { }))
return gulp.src(PATHS.TEST_SRC, {read: false}) .pipe(istanbul.writeReports({
.pipe(mocha({ dir: './coverage',
compilers: 'js:babel-core/register', reporters: ['lcov'],
recursive: true reportOpts: { dir: './coverage' },
})) }))
.pipe(istanbul.writeReports({ .on('end', done));
dir: './coverage',
reporters: ['lcov'],
reportOpts: {dir: './coverage'}
}))
.on('end', done);
});
}); });
gulp.task('tdd', ['mocha'], () => { gulp.task('tdd', ['mocha'], () => gulp.watch(['src/**/*.js', 'test/**/*.js'], ['mocha']));
return gulp.watch(['src/**/*.js', 'test/**/*.js'], ['mocha']);
});

12
gulp/watch.js
View File

@ -2,15 +2,15 @@ import gulp from 'gulp';
import PATHS from './helpers/src-paths'; import PATHS from './helpers/src-paths';
gulp.task('watch', ['build'], () => { gulp.task('watch', ['build'], () => {
var handleError = function(error) { const handleError = function (error) {
console.error(error); console.error(error);
}; };
gulp.watch(PATHS.APP_ALL, ['build-app']) gulp.watch(PATHS.APP_ALL, ['build-app'])
.on('error', handleError); .on('error', handleError);
gulp.watch(PATHS.CLI_SRC_JS, ['build-cli']) gulp.watch(PATHS.CLI_SRC_JS, ['build-cli'])
.on('error', handleError); .on('error', handleError);
gulp.watch(PATHS.TEST_SRC_JS, ['build-tests']) gulp.watch(PATHS.TEST_SRC_JS, ['build-tests'])
.on('error', handleError); .on('error', handleError);
}); });

4
gulpfile.babel.js
View File

@ -2,8 +2,8 @@ import gulp from 'gulp';
import requireDir from 'require-dir'; import requireDir from 'require-dir';
requireDir('./gulp', { requireDir('./gulp', {
recurse: true, recurse: true,
duplicates: true duplicates: true,
}); });
gulp.task('default', ['build']); gulp.task('default', ['build']);

6
package.json
View File

@ -15,6 +15,7 @@
"test": "gulp test", "test": "gulp test",
"tdd": "gulp tdd", "tdd": "gulp tdd",
"lint": "eslint .", "lint": "eslint .",
"lint:fix": "eslint . --fix",
"ci": "gulp build test && npm run lint", "ci": "gulp build test && npm run lint",
"clean": "gulp clean", "clean": "gulp clean",
"build": "gulp build", "build": "gulp build",
@ -68,8 +69,9 @@
"babel-register": "^6.6.0", "babel-register": "^6.6.0",
"chai": "^3.4.1", "chai": "^3.4.1",
"del": "^2.2.0", "del": "^2.2.0",
"eslint": "^2.10.2", "eslint": "^3.19.0",
"eslint-config-google": "^0.5.0", "eslint-config-airbnb-base": "^11.1.3",
"eslint-plugin-import": "^2.2.0",
"gulp": "^3.9.0", "gulp": "^3.9.0",
"gulp-babel": "^6.1.1", "gulp-babel": "^6.1.1",
"gulp-istanbul": "^1.1.1", "gulp-istanbul": "^1.1.1",

220
src/build/buildApp.js
View File

@ -7,8 +7,100 @@ import ncp from 'ncp';
const copy = ncp.ncp; const copy = ncp.ncp;
/** /**
* Creates a temporary directory and copies the './app folder' inside, and adds a text file with the configuration * Only picks certain app args to pass to nativefier.json
* for the single page app. * @param options
*/
function selectAppArgs(options) {
return {
name: options.name,
targetUrl: options.targetUrl,
counter: options.counter,
width: options.width,
height: options.height,
minWidth: options.minWidth,
minHeight: options.minHeight,
maxWidth: options.maxWidth,
maxHeight: options.maxHeight,
showMenuBar: options.showMenuBar,
fastQuit: options.fastQuit,
userAgent: options.userAgent,
nativefierVersion: options.nativefierVersion,
ignoreCertificate: options.ignoreCertificate,
insecure: options.insecure,
flashPluginDir: options.flashPluginDir,
fullScreen: options.fullScreen,
hideWindowFrame: options.hideWindowFrame,
maximize: options.maximize,
disableContextMenu: options.disableContextMenu,
disableDevTools: options.disableDevTools,
zoom: options.zoom,
internalUrls: options.internalUrls,
crashReporter: options.crashReporter,
singleInstance: options.singleInstance,
};
}
function maybeCopyScripts(srcs, dest) {
if (!srcs) {
return new Promise((resolve) => {
resolve();
});
}
const promises = srcs.map(src => new Promise((resolve, reject) => {
if (!fs.existsSync(src)) {
reject('Error copying injection files: file not found');
return;
}
let destFileName;
if (path.extname(src) === '.js') {
destFileName = 'inject.js';
} else if (path.extname(src) === '.css') {
destFileName = 'inject.css';
} else {
resolve();
return;
}
copy(src, path.join(dest, 'inject', destFileName), (error) => {
if (error) {
reject(`Error Copying injection files: ${error}`);
return;
}
resolve();
});
}));
return new Promise((resolve, reject) => {
Promise.all(promises)
.then(() => {
resolve();
})
.catch((error) => {
reject(error);
});
});
}
function normalizeAppName(appName, url) {
// use a simple 3 byte random string to prevent collision
const hash = crypto.createHash('md5');
hash.update(url);
const postFixHash = hash.digest('hex').substring(0, 6);
const normalized = _.kebabCase(appName.toLowerCase());
return `${normalized}-nativefier-${postFixHash}`;
}
function changeAppPackageJsonName(appPath, name, url) {
const packageJsonPath = path.join(appPath, '/package.json');
const packageJson = JSON.parse(fs.readFileSync(packageJsonPath));
packageJson.name = normalizeAppName(name, url);
fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson));
}
/**
* Creates a temporary directory and copies the './app folder' inside,
* and adds a text file with the configuration for the single page app.
* *
* @param {string} src * @param {string} src
* @param {string} dest * @param {string} dest
@ -16,119 +108,25 @@ const copy = ncp.ncp;
* @param callback * @param callback
*/ */
function buildApp(src, dest, options, callback) { function buildApp(src, dest, options, callback) {
const appArgs = selectAppArgs(options); const appArgs = selectAppArgs(options);
copy(src, dest, error => { copy(src, dest, (error) => {
if (error) { if (error) {
callback(`Error Copying temporary directory: ${error}`); callback(`Error Copying temporary directory: ${error}`);
return; return;
}
fs.writeFileSync(path.join(dest, '/nativefier.json'), JSON.stringify(appArgs));
maybeCopyScripts(options.inject, dest)
.catch(error => {
console.warn(error);
})
.then(() => {
changeAppPackageJsonName(dest, appArgs.name, appArgs.targetUrl);
callback();
});
});
}
function maybeCopyScripts(srcs, dest) {
if (!srcs) {
return new Promise(resolve => {
resolve();
});
} }
const promises = srcs.map(src => {
return new Promise((resolve, reject) => {
if (!fs.existsSync(src)) {
reject('Error copying injection files: file not found');
return;
}
let destFileName; fs.writeFileSync(path.join(dest, '/nativefier.json'), JSON.stringify(appArgs));
if (path.extname(src) === '.js') {
destFileName = 'inject.js';
} else if (path.extname(src) === '.css') {
destFileName = 'inject.css';
} else {
resolve();
return;
}
copy(src, path.join(dest, 'inject', destFileName), error => { maybeCopyScripts(options.inject, dest)
if (error) { .catch((error) => {
reject(`Error Copying injection files: ${error}`); console.warn(error);
return; })
} .then(() => {
resolve(); changeAppPackageJsonName(dest, appArgs.name, appArgs.targetUrl);
}); callback();
}); });
}); });
return new Promise((resolve, reject) => {
Promise.all(promises)
.then(() => {
resolve();
})
.catch(error => {
reject(error);
});
});
} }
function changeAppPackageJsonName(appPath, name, url) {
const packageJsonPath = path.join(appPath, '/package.json');
const packageJson = JSON.parse(fs.readFileSync(packageJsonPath));
packageJson.name = normalizeAppName(name, url);
fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson));
}
/**
* Only picks certain app args to pass to nativefier.json
* @param options
* @returns {{name: (*|string), targetUrl: (string|*), counter: *, width: *, height: *, showMenuBar: *, userAgent: *, nativefierVersion: *, insecure: *, disableWebSecurity: *}}
*/
function selectAppArgs(options) {
return {
name: options.name,
targetUrl: options.targetUrl,
counter: options.counter,
width: options.width,
height: options.height,
minWidth: options.minWidth,
minHeight: options.minHeight,
maxWidth: options.maxWidth,
maxHeight: options.maxHeight,
showMenuBar: options.showMenuBar,
fastQuit: options.fastQuit,
userAgent: options.userAgent,
nativefierVersion: options.nativefierVersion,
ignoreCertificate: options.ignoreCertificate,
insecure: options.insecure,
flashPluginDir: options.flashPluginDir,
fullScreen: options.fullScreen,
hideWindowFrame: options.hideWindowFrame,
maximize: options.maximize,
disableContextMenu: options.disableContextMenu,
disableDevTools: options.disableDevTools,
zoom: options.zoom,
internalUrls: options.internalUrls,
crashReporter: options.crashReporter,
singleInstance: options.singleInstance
};
}
function normalizeAppName(appName, url) {
// use a simple 3 byte random string to prevent collision
let hash = crypto.createHash('md5');
hash.update(url);
const postFixHash = hash.digest('hex').substring(0, 6);
const normalized = _.kebabCase(appName.toLowerCase());
return `${normalized}-nativefier-${postFixHash}`;
}
export default buildApp; export default buildApp;

225
src/build/buildMain.js
View File

@ -15,118 +15,39 @@ import buildApp from './buildApp';
const copy = ncp.ncp; const copy = ncp.ncp;
const isWindows = helpers.isWindows; const isWindows = helpers.isWindows;
/**
* @callback buildAppCallback
* @param error
* @param {string} appPath
*/
/**
*
* @param {{}} options
* @param {buildAppCallback} callback
*/
function buildMain(options, callback) {
// pre process app
const tmpObj = tmp.dirSync({unsafeCleanup: true});
const tmpPath = tmpObj.name;
// todo check if this is still needed on later version of packager
const packagerConsole = new PackagerConsole();
const progress = new DishonestProgress(5);
async.waterfall([
callback => {
progress.tick('inferring');
optionsFactory(options, callback);
},
(options, callback) => {
progress.tick('copying');
buildApp(options.dir, tmpPath, options, error => {
if (error) {
callback(error);
return;
}
// dir now correctly references the app folder to package
options.dir = tmpPath;
callback(null, options);
});
},
(options, callback) => {
progress.tick('icons');
iconBuild(options, (error, optionsWithIcon) => {
callback(null, optionsWithIcon);
});
},
(options, callback) => {
progress.tick('packaging');
// maybe skip passing icon parameter to electron packager
const packageOptions = maybeNoIconOption(options);
packagerConsole.override();
packager(packageOptions, (error, appPathArray) => {
// restore console.error
packagerConsole.restore();
// pass options which still contains the icon to waterfall
callback(error, options, appPathArray);
});
},
(options, appPathArray, callback) => {
progress.tick('finalizing');
// somehow appPathArray is a 1 element array
const appPath = getAppPath(appPathArray);
if (!appPath) {
callback();
return;
}
maybeCopyIcons(options, appPath, error => {
callback(error, appPath);
});
}
], (error, appPath) => {
packagerConsole.playback();
callback(error, appPath);
});
}
/** /**
* Checks the app path array to determine if the packaging was completed successfully * Checks the app path array to determine if the packaging was completed successfully
* @param appPathArray Result from electron-packager * @param appPathArray Result from electron-packager
* @returns {*} * @returns {*}
*/ */
function getAppPath(appPathArray) { function getAppPath(appPathArray) {
if (appPathArray.length === 0) { if (appPathArray.length === 0) {
// directory already exists, --overwrite is not set // directory already exists, --overwrite is not set
// exit here // exit here
return null; return null;
} }
if (appPathArray.length > 1) { if (appPathArray.length > 1) {
log.warn('Warning: This should not be happening, packaged app path contains more than one element:', appPathArray); log.warn('Warning: This should not be happening, packaged app path contains more than one element:', appPathArray);
} }
return appPathArray[0]; return appPathArray[0];
} }
/** /**
* Removes the `icon` parameter from options if building for Windows while not on Windows and Wine is not installed * Removes the `icon` parameter from options if building for Windows while not on Windows
* and Wine is not installed
* @param options * @param options
*/ */
function maybeNoIconOption(options) { function maybeNoIconOption(options) {
const packageOptions = JSON.parse(JSON.stringify(options)); const packageOptions = JSON.parse(JSON.stringify(options));
if (options.platform === 'win32' && !isWindows()) { if (options.platform === 'win32' && !isWindows()) {
if (!hasBinary.sync('wine')) { if (!hasBinary.sync('wine')) {
log.warn('Wine is required to set the icon for a Windows app when packaging on non-windows platforms'); log.warn('Wine is required to set the icon for a Windows app when packaging on non-windows platforms');
packageOptions.icon = null; packageOptions.icon = null;
}
} }
return packageOptions; }
return packageOptions;
} }
/** /**
@ -137,23 +58,105 @@ function maybeNoIconOption(options) {
* @param callback * @param callback
*/ */
function maybeCopyIcons(options, appPath, callback) { function maybeCopyIcons(options, appPath, callback) {
if (!options.icon) { if (!options.icon) {
callback();
return;
}
if (options.platform === 'darwin') {
callback();
return;
}
// windows & linux
// put the icon file into the app
const destIconPath = path.join(appPath, 'resources/app');
const destFileName = `icon${path.extname(options.icon)}`;
copy(options.icon, path.join(destIconPath, destFileName), (error) => {
callback(error);
});
}
/**
* @callback buildAppCallback
* @param error
* @param {string} appPath
*/
/**
*
* @param {{}} inpOptions
* @param {buildAppCallback} callback
*/
function buildMain(inpOptions, callback) {
const options = Object.assign({}, inpOptions);
// pre process app
const tmpObj = tmp.dirSync({ unsafeCleanup: true });
const tmpPath = tmpObj.name;
// todo check if this is still needed on later version of packager
const packagerConsole = new PackagerConsole();
const progress = new DishonestProgress(5);
async.waterfall([
(callback) => {
progress.tick('inferring');
optionsFactory(options, callback);
},
(options, callback) => {
progress.tick('copying');
buildApp(options.dir, tmpPath, options, (error) => {
if (error) {
callback(error);
return;
}
// Change the reference file for the Electron app to be the temporary path
const newOptions = Object.assign({}, options, { dir: tmpPath });
callback(null, newOptions);
});
},
(options, callback) => {
progress.tick('icons');
iconBuild(options, (error, optionsWithIcon) => {
callback(null, optionsWithIcon);
});
},
(options, callback) => {
progress.tick('packaging');
// maybe skip passing icon parameter to electron packager
const packageOptions = maybeNoIconOption(options);
packagerConsole.override();
packager(packageOptions, (error, appPathArray) => {
// restore console.error
packagerConsole.restore();
// pass options which still contains the icon to waterfall
callback(error, options, appPathArray);
});
},
(options, appPathArray, callback) => {
progress.tick('finalizing');
// somehow appPathArray is a 1 element array
const appPath = getAppPath(appPathArray);
if (!appPath) {
callback(); callback();
return; return;
} }
if (options.platform === 'darwin') { maybeCopyIcons(options, appPath, (error) => {
callback(); callback(error, appPath);
return; });
} },
], (error, appPath) => {
// windows & linux packagerConsole.playback();
// put the icon file into the app callback(error, appPath);
const destIconPath = path.join(appPath, 'resources/app'); });
const destFileName = `icon${path.extname(options.icon)}`;
copy(options.icon, path.join(destIconPath, destFileName), error => {
callback(error);
});
} }
export default buildMain; export default buildMain;

144
src/build/iconBuild.js
View File

@ -3,8 +3,20 @@ import log from 'loglevel';
import helpers from './../helpers/helpers'; import helpers from './../helpers/helpers';
import iconShellHelpers from './../helpers/iconShellHelpers'; import iconShellHelpers from './../helpers/iconShellHelpers';
const {isOSX} = helpers; const { isOSX } = helpers;
const {convertToPng, convertToIco, convertToIcns} = iconShellHelpers; const { convertToPng, convertToIco, convertToIcns } = iconShellHelpers;
function iconIsIco(iconPath) {
return path.extname(iconPath) === '.ico';
}
function iconIsPng(iconPath) {
return path.extname(iconPath) === '.png';
}
function iconIsIcns(iconPath) {
return path.extname(iconPath) === '.icns';
}
/** /**
* @callback augmentIconsCallback * @callback augmentIconsCallback
@ -16,88 +28,76 @@ const {convertToPng, convertToIco, convertToIcns} = iconShellHelpers;
* Will check and convert a `.png` to `.icns` if necessary and augment * Will check and convert a `.png` to `.icns` if necessary and augment
* options.icon with the result * options.icon with the result
* *
* @param options will need options.platform and options.icon * @param inpOptions will need options.platform and options.icon
* @param {augmentIconsCallback} callback * @param {augmentIconsCallback} callback
*/ */
function iconBuild(options, callback) { function iconBuild(inpOptions, callback) {
const options = Object.assign({}, inpOptions);
const returnCallback = () => {
callback(null, options);
};
const returnCallback = () => { if (!options.icon) {
callback(null, options); returnCallback();
}; return;
}
if (!options.icon) { if (options.platform === 'win32') {
if (iconIsIco(options.icon)) {
returnCallback();
return;
}
convertToIco(options.icon)
.then((outPath) => {
options.icon = outPath;
returnCallback(); returnCallback();
return; })
} .catch((error) => {
log.warn('Skipping icon conversion to .ico', error);
if (options.platform === 'win32') {
if (iconIsIco(options.icon)) {
returnCallback();
return;
}
convertToIco(options.icon)
.then(outPath => {
options.icon = outPath;
returnCallback();
})
.catch(error => {
log.warn('Skipping icon conversion to .ico', error);
returnCallback();
});
return;
}
if (options.platform === 'linux') {
if (iconIsPng(options.icon)) {
returnCallback();
return;
}
convertToPng(options.icon)
.then(outPath => {
options.icon = outPath;
returnCallback();
})
.catch(error => {
log.warn('Skipping icon conversion to .png', error);
returnCallback();
});
return;
}
if (iconIsIcns(options.icon)) {
returnCallback(); returnCallback();
return; });
return;
}
if (options.platform === 'linux') {
if (iconIsPng(options.icon)) {
returnCallback();
return;
} }
if (!isOSX()) { convertToPng(options.icon)
log.warn('Skipping icon conversion to .icns, conversion is only supported on OSX'); .then((outPath) => {
options.icon = outPath;
returnCallback(); returnCallback();
return; })
} .catch((error) => {
log.warn('Skipping icon conversion to .png', error);
returnCallback();
});
return;
}
convertToIcns(options.icon) if (iconIsIcns(options.icon)) {
.then(outPath => { returnCallback();
options.icon = outPath; return;
returnCallback(); }
})
.catch(error => {
log.warn('Skipping icon conversion to .icns', error);
returnCallback();
});
}
function iconIsIco(iconPath) { if (!isOSX()) {
return path.extname(iconPath) === '.ico'; log.warn('Skipping icon conversion to .icns, conversion is only supported on OSX');
} returnCallback();
return;
}
function iconIsPng(iconPath) { convertToIcns(options.icon)
return path.extname(iconPath) === '.png'; .then((outPath) => {
} options.icon = outPath;
returnCallback();
function iconIsIcns(iconPath) { })
return path.extname(iconPath) === '.icns'; .catch((error) => {
log.warn('Skipping icon conversion to .icns', error);
returnCallback();
});
} }
export default iconBuild; export default iconBuild;

118
src/cli.js
View File

@ -1,75 +1,73 @@
#! /usr/bin/env node #! /usr/bin/env node
import 'source-map-support/register'; import 'source-map-support/register';
import path from 'path';
import program from 'commander'; import program from 'commander';
import nativefier from './index'; import nativefier from './index';
const packageJson = require(path.join('..', 'package'));
const packageJson = require('./../package');
function collect(val, memo) { function collect(val, memo) {
memo.push(val); memo.push(val);
return memo; return memo;
} }
if (require.main === module) { if (require.main === module) {
program
.version(packageJson.version)
.arguments('<targetUrl> [dest]')
.action((targetUrl, appDir) => {
program.targetUrl = targetUrl;
program.out = appDir;
})
.option('-n, --name <value>', 'app name')
.option('-p, --platform <value>', '\'osx\', \'linux\' or \'windows\'')
.option('-a, --arch <value>', '\'ia32\' or \'x64\'')
.option('-e, --electron-version <value>', 'electron version to package, without the \'v\', see https://github.com/atom/electron/releases')
.option('--no-overwrite', 'do not override output directory if it already exists, defaults to false')
.option('-c, --conceal', 'packages the source code within your app into an archive, defaults to false, see http://electron.atom.io/docs/v0.36.0/tutorial/application-packaging/')
.option('--counter', 'if the target app should use a persistant counter badge in the dock (OSX only), defaults to false')
.option('-i, --icon <value>', 'the icon file to use as the icon for the app (should be a .icns file on OSX, .png for Windows and Linux)')
.option('--width <value>', 'set window default width, defaults to 1280px', parseInt)
.option('--height <value>', 'set window default height, defaults to 800px', parseInt)
.option('--min-width <value>', 'set window minimum width, defaults to 0px', parseInt)
.option('--min-height <value>', 'set window minimum height, defaults to 0px', parseInt)
.option('--max-width <value>', 'set window maximum width, default is no limit', parseInt)
.option('--max-height <value>', 'set window maximum height, default is no limit', parseInt)
.option('-m, --show-menu-bar', 'set menu bar visible, defaults to false')
.option('-f, --fast-quit', 'quit app after window close (OSX only), defaults to false')
.option('-u, --user-agent <value>', 'set the user agent string for the app')
.option('--honest', 'prevent the nativefied app from changing the user agent string to masquerade as a regular chrome browser')
.option('--ignore-certificate', 'ignore certificate related errors')
.option('--insecure', 'enable loading of insecure content, defaults to false')
.option('--flash', 'if flash should be enabled')
.option('--flash-path <value>', 'path to Chrome flash plugin, find it in `Chrome://plugins`')
.option('--inject <value>', 'path to a CSS/JS file to be injected', collect, [])
.option('--full-screen', 'if the app should always be started in full screen')
.option('--maximize', 'if the app should always be started maximized')
.option('--hide-window-frame', 'disable window frame and controls')
.option('--verbose', 'if verbose logs should be displayed')
.option('--disable-context-menu', 'disable the context menu')
.option('--disable-dev-tools', 'disable developer tools')
.option('--zoom <value>', 'default zoom factor to use when the app is opened, defaults to 1.0', parseFloat)
.option('--internal-urls <value>', 'regular expression of URLs to consider "internal"; all other URLs will be opened in an external browser. (default: URLs on same second-level domain as app)')
.option('--crash-reporter <value>', 'remote server URL to send crash reports')
.option('--single-instance', 'allow only a single instance of the application')
.parse(process.argv);
program if (!process.argv.slice(2).length) {
.version(packageJson.version) program.help();
.arguments('<targetUrl> [dest]') }
.action(function(targetUrl, appDir) {
program.targetUrl = targetUrl;
program.out = appDir;
})
.option('-n, --name <value>', 'app name')
.option('-p, --platform <value>', '\'osx\', \'linux\' or \'windows\'')
.option('-a, --arch <value>', '\'ia32\' or \'x64\'')
.option('-e, --electron-version <value>', 'electron version to package, without the \'v\', see https://github.com/atom/electron/releases')
.option('--no-overwrite', 'do not override output directory if it already exists, defaults to false')
.option('-c, --conceal', 'packages the source code within your app into an archive, defaults to false, see http://electron.atom.io/docs/v0.36.0/tutorial/application-packaging/')
.option('--counter', 'if the target app should use a persistant counter badge in the dock (OSX only), defaults to false')
.option('-i, --icon <value>', 'the icon file to use as the icon for the app (should be a .icns file on OSX, .png for Windows and Linux)')
.option('--width <value>', 'set window default width, defaults to 1280px', parseInt)
.option('--height <value>', 'set window default height, defaults to 800px', parseInt)
.option('--min-width <value>', 'set window minimum width, defaults to 0px', parseInt)
.option('--min-height <value>', 'set window minimum height, defaults to 0px', parseInt)
.option('--max-width <value>', 'set window maximum width, default is no limit', parseInt)
.option('--max-height <value>', 'set window maximum height, default is no limit', parseInt)
.option('-m, --show-menu-bar', 'set menu bar visible, defaults to false')
.option('-f, --fast-quit', 'quit app after window close (OSX only), defaults to false')
.option('-u, --user-agent <value>', 'set the user agent string for the app')
.option('--honest', 'prevent the nativefied app from changing the user agent string to masquerade as a regular chrome browser')
.option('--ignore-certificate', 'ignore certificate related errors')
.option('--insecure', 'enable loading of insecure content, defaults to false')
.option('--flash', 'if flash should be enabled')
.option('--flash-path <value>', 'path to Chrome flash plugin, find it in `Chrome://plugins`')
.option('--inject <value>', 'path to a CSS/JS file to be injected', collect, [])
.option('--full-screen', 'if the app should always be started in full screen')
.option('--maximize', 'if the app should always be started maximized')
.option('--hide-window-frame', 'disable window frame and controls')
.option('--verbose', 'if verbose logs should be displayed')
.option('--disable-context-menu', 'disable the context menu')
.option('--disable-dev-tools', 'disable developer tools')
.option('--zoom <value>', 'default zoom factor to use when the app is opened, defaults to 1.0', parseFloat)
.option('--internal-urls <value>', 'regular expression of URLs to consider "internal"; all other URLs will be opened in an external browser. (default: URLs on same second-level domain as app)')
.option('--crash-reporter <value>', 'remote server URL to send crash reports')
.option('--single-instance', 'allow only a single instance of the application')
.parse(process.argv);
if (!process.argv.slice(2).length) { nativefier(program, (error, appPath) => {
program.help(); if (error) {
console.error(error);
return;
} }
nativefier(program, (error, appPath) => { if (!appPath) {
if (error) { // app exists and --overwrite is not passed
console.error(error); return;
return; }
} console.log(`App built to ${appPath}`);
});
if (!appPath) {
// app exists and --overwrite is not passed
return;
}
console.log(`App built to ${appPath}`);
});
} }

43
src/helpers/convertToIcns.js
View File

@ -2,6 +2,7 @@ import shell from 'shelljs';
import path from 'path'; import path from 'path';
import tmp from 'tmp'; import tmp from 'tmp';
import helpers from './helpers'; import helpers from './helpers';
const isOSX = helpers.isOSX; const isOSX = helpers.isOSX;
tmp.setGracefulCleanup(); tmp.setGracefulCleanup();
@ -20,27 +21,27 @@ const PNG_TO_ICNS_BIN_PATH = path.join(__dirname, '../..', 'bin/convertToIcns');
* @param {pngToIcnsCallback} callback * @param {pngToIcnsCallback} callback
*/ */
function convertToIcns(pngSrc, icnsDest, callback) { function convertToIcns(pngSrc, icnsDest, callback) {
if (!isOSX()) { if (!isOSX()) {
callback('OSX is required to convert .png to .icns icon', pngSrc); callback('OSX is required to convert .png to .icns icon', pngSrc);
return;
}
shell.exec(`${PNG_TO_ICNS_BIN_PATH} ${pngSrc} ${icnsDest}`, { silent: true }, (exitCode, stdOut, stdError) => {
if (stdOut.includes('icon.iconset:error') || exitCode) {
if (exitCode) {
callback({
stdOut,
stdError,
}, pngSrc);
return; return;
}
callback(stdOut, pngSrc);
return;
} }
shell.exec(`${PNG_TO_ICNS_BIN_PATH} ${pngSrc} ${icnsDest}`, {silent: true}, (exitCode, stdOut, stdError) => { callback(null, icnsDest);
if (stdOut.includes('icon.iconset:error') || exitCode) { });
if (exitCode) {
callback({
stdOut: stdOut,
stdError: stdError
}, pngSrc);
return;
}
callback(stdOut, pngSrc);
return;
}
callback(null, icnsDest);
});
} }
/** /**
@ -49,9 +50,9 @@ function convertToIcns(pngSrc, icnsDest, callback) {
* @param {pngToIcnsCallback} callback * @param {pngToIcnsCallback} callback
*/ */
function convertToIcnsTmp(pngSrc, callback) { function convertToIcnsTmp(pngSrc, callback) {
const tempIconDirObj = tmp.dirSync({unsafeCleanup: true}); const tempIconDirObj = tmp.dirSync({ unsafeCleanup: true });
const tempIconDirPath = tempIconDirObj.name; const tempIconDirPath = tempIconDirObj.name;
convertToIcns(pngSrc, `${tempIconDirPath}/icon.icns`, callback); convertToIcns(pngSrc, `${tempIconDirPath}/icon.icns`, callback);
} }
export default convertToIcnsTmp; export default convertToIcnsTmp;

116
src/helpers/dishonestProgress.js
View File

@ -1,68 +1,70 @@
import ProgressBar from 'progress'; import ProgressBar from 'progress';
class DishonestProgress { class DishonestProgress {
constructor(total) { constructor(total) {
this.tickParts = total * 10; this.tickParts = total * 10;
this.bar = new ProgressBar(' :task [:bar] :percent', { this.bar = new ProgressBar(' :task [:bar] :percent', {
complete: '=', complete: '=',
incomplete: ' ', incomplete: ' ',
total: total * this.tickParts, total: total * this.tickParts,
width: 50, width: 50,
clear: true clear: true,
}); });
this.tickingPrevious = { this.tickingPrevious = {
message: '', message: '',
remainder: 0, remainder: 0,
interval: null interval: null,
}; };
}
tick(message) {
const {
remainder: prevRemainder,
message: prevMessage,
interval: prevInterval,
} = this.tickingPrevious;
if (prevRemainder) {
this.bar.tick(prevRemainder, {
task: prevMessage,
});
clearInterval(prevInterval);
} }
tick(message) { const realRemainder = this.bar.total - this.bar.curr;
if (realRemainder === this.tickParts) {
const {remainder: prevRemainder, message: prevMessage, interval: prevInterval} = this.tickingPrevious; this.bar.tick(this.tickParts, {
task: message,
if (prevRemainder) { });
this.bar.tick(prevRemainder, { return;
task: prevMessage
});
clearInterval(prevInterval);
}
const realRemainder = this.bar.total - this.bar.curr;
if (realRemainder === this.tickParts) {
this.bar.tick(this.tickParts, {
task: message
});
return;
}
this.bar.tick({
task: message
});
this.tickingPrevious = {
message: message,
remainder: this.tickParts,
interval: null
};
this.tickingPrevious.remainder -= 1;
this.tickingPrevious.interval = setInterval(() => {
if (this.tickingPrevious.remainder === 1) {
clearInterval(this.tickingPrevious.interval);
return;
}
this.bar.tick({
task: message
});
this.tickingPrevious.remainder -= 1;
}, 200);
} }
this.bar.tick({
task: message,
});
this.tickingPrevious = {
message,
remainder: this.tickParts,
interval: null,
};
this.tickingPrevious.remainder -= 1;
this.tickingPrevious.interval = setInterval(() => {
if (this.tickingPrevious.remainder === 1) {
clearInterval(this.tickingPrevious.interval);
return;
}
this.bar.tick({
task: message,
});
this.tickingPrevious.remainder -= 1;
}, 200);
}
} }
export default DishonestProgress; export default DishonestProgress;

154
src/helpers/helpers.js
View File

@ -4,100 +4,100 @@ import hasBinary from 'hasbin';
import path from 'path'; import path from 'path';
function isOSX() { function isOSX() {
return os.platform() === 'darwin'; return os.platform() === 'darwin';
} }
function isWindows() { function isWindows() {
return os.platform() === 'win32'; return os.platform() === 'win32';
} }
function downloadFile(fileUrl) { function downloadFile(fileUrl) {
return axios.get( return axios.get(
fileUrl, { fileUrl, {
responseType: 'arraybuffer' responseType: 'arraybuffer',
}) })
.then(function(response) { .then((response) => {
if (!response.data) { if (!response.data) {
return null; return null;
} }
return { return {
data: response.data, data: response.data,
ext: path.extname(fileUrl) ext: path.extname(fileUrl),
}; };
}); });
} }
function allowedIconFormats(platform) { function allowedIconFormats(platform) {
const hasIdentify = hasBinary.sync('identify'); const hasIdentify = hasBinary.sync('identify');
const hasConvert = hasBinary.sync('convert'); const hasConvert = hasBinary.sync('convert');
const hasIconUtil = hasBinary.sync('iconutil'); const hasIconUtil = hasBinary.sync('iconutil');
const pngToIcns = hasConvert && hasIconUtil; const pngToIcns = hasConvert && hasIconUtil;
const pngToIco = hasConvert; const pngToIco = hasConvert;
const icoToIcns = pngToIcns && hasIdentify; const icoToIcns = pngToIcns && hasIdentify;
const icoToPng = hasConvert; const icoToPng = hasConvert;
// todo scripts for the following // todo scripts for the following
const icnsToPng = false; const icnsToPng = false;
const icnsToIco = false; const icnsToIco = false;
const formats = []; const formats = [];
// todo shell scripting is not supported on windows, temporary override
if (isWindows()) {
switch (platform) {
case 'darwin':
formats.push('.icns');
break;
case 'linux':
formats.push('.png');
break;
case 'win32':
formats.push('.ico');
break;
default:
throw `function allowedIconFormats error: Unknown platform ${platform}`;
}
return formats;
}
// todo shell scripting is not supported on windows, temporary override
if (isWindows()) {
switch (platform) { switch (platform) {
case 'darwin': case 'darwin':
formats.push('.icns'); formats.push('.icns');
if (pngToIcns) { break;
formats.push('.png'); case 'linux':
} formats.push('.png');
if (icoToIcns) { break;
formats.push('.ico'); case 'win32':
} formats.push('.ico');
break; break;
case 'linux': default:
formats.push('.png'); throw new Error(`function allowedIconFormats error: Unknown platform ${platform}`);
if (icoToPng) {
formats.push('.ico');
}
if (icnsToPng) {
formats.push('.icns');
}
break;
case 'win32':
formats.push('.ico');
if (pngToIco) {
formats.push('.png');
}
if (icnsToIco) {
formats.push('.icns');
}
break;
default:
throw `function allowedIconFormats error: Unknown platform ${platform}`;
} }
return formats; return formats;
}
switch (platform) {
case 'darwin':
formats.push('.icns');
if (pngToIcns) {
formats.push('.png');
}
if (icoToIcns) {
formats.push('.ico');
}
break;
case 'linux':
formats.push('.png');
if (icoToPng) {
formats.push('.ico');
}
if (icnsToPng) {
formats.push('.icns');
}
break;
case 'win32':
formats.push('.ico');
if (pngToIco) {
formats.push('.png');
}
if (icnsToIco) {
formats.push('.icns');
}
break;
default:
throw new Error(`function allowedIconFormats error: Unknown platform ${platform}`);
}
return formats;
} }
export default { export default {
isOSX, isOSX,
isWindows, isWindows,
downloadFile, downloadFile,
allowedIconFormats allowedIconFormats,
}; };

67
src/helpers/iconShellHelpers.js
View File

@ -2,15 +2,16 @@ import shell from 'shelljs';
import path from 'path'; import path from 'path';
import tmp from 'tmp'; import tmp from 'tmp';
import helpers from './helpers'; import helpers from './helpers';
const {isWindows, isOSX} = helpers;
const { isWindows, isOSX } = helpers;
tmp.setGracefulCleanup(); tmp.setGracefulCleanup();
const SCRIPT_PATHS = { const SCRIPT_PATHS = {
singleIco: path.join(__dirname, '../..', 'bin/singleIco'), singleIco: path.join(__dirname, '../..', 'bin/singleIco'),
convertToPng: path.join(__dirname, '../..', 'bin/convertToPng'), convertToPng: path.join(__dirname, '../..', 'bin/convertToPng'),
convertToIco: path.join(__dirname, '../..', 'bin/convertToIco'), convertToIco: path.join(__dirname, '../..', 'bin/convertToIco'),
convertToIcns: path.join(__dirname, '../..', 'bin/convertToIcns') convertToIcns: path.join(__dirname, '../..', 'bin/convertToIcns'),
}; };
/** /**
@ -20,29 +21,29 @@ const SCRIPT_PATHS = {
* @param {string} dest has to be a .ico path * @param {string} dest has to be a .ico path
*/ */
function iconShellHelper(shellScriptPath, icoSrc, dest) { function iconShellHelper(shellScriptPath, icoSrc, dest) {
return new Promise((resolve, reject) => { return new Promise((resolve, reject) => {
if (isWindows()) { if (isWindows()) {
reject('OSX or Linux is required'); reject('OSX or Linux is required');
return; return;
} }
shell.exec(`${shellScriptPath} ${icoSrc} ${dest}`, {silent: true}, (exitCode, stdOut, stdError) => { shell.exec(`${shellScriptPath} ${icoSrc} ${dest}`, { silent: true }, (exitCode, stdOut, stdError) => {
if (exitCode) { if (exitCode) {
reject({ reject({
stdOut: stdOut, stdOut,
stdError: stdError stdError,
});
return;
}
resolve(dest);
}); });
return;
}
resolve(dest);
}); });
});
} }
function getTmpDirPath() { function getTmpDirPath() {
const tempIconDirObj = tmp.dirSync({unsafeCleanup: true}); const tempIconDirObj = tmp.dirSync({ unsafeCleanup: true });
return tempIconDirObj.name; return tempIconDirObj.name;
} }
/** /**
@ -52,27 +53,27 @@ function getTmpDirPath() {
*/ */
function singleIco(icoSrc) { function singleIco(icoSrc) {
return iconShellHelper(SCRIPT_PATHS.singleIco, icoSrc, `${getTmpDirPath()}/icon.ico`); return iconShellHelper(SCRIPT_PATHS.singleIco, icoSrc, `${getTmpDirPath()}/icon.ico`);
} }
function convertToPng(icoSrc) { function convertToPng(icoSrc) {
return iconShellHelper(SCRIPT_PATHS.convertToPng, icoSrc, `${getTmpDirPath()}/icon.png`); return iconShellHelper(SCRIPT_PATHS.convertToPng, icoSrc, `${getTmpDirPath()}/icon.png`);
} }
function convertToIco(icoSrc) { function convertToIco(icoSrc) {
return iconShellHelper(SCRIPT_PATHS.convertToIco, icoSrc, `${getTmpDirPath()}/icon.ico`); return iconShellHelper(SCRIPT_PATHS.convertToIco, icoSrc, `${getTmpDirPath()}/icon.ico`);
} }
function convertToIcns(icoSrc) { function convertToIcns(icoSrc) {
if (!isOSX()) { if (!isOSX()) {
return new Promise((resolve, reject) => reject('OSX is required to convert to a .icns icon')); return new Promise((resolve, reject) => reject('OSX is required to convert to a .icns icon'));
} }
return iconShellHelper(SCRIPT_PATHS.convertToIcns, icoSrc, `${getTmpDirPath()}/icon.icns`); return iconShellHelper(SCRIPT_PATHS.convertToIcns, icoSrc, `${getTmpDirPath()}/icon.icns`);
} }
export default { export default {
singleIco, singleIco,
convertToPng, convertToPng,
convertToIco, convertToIco,
convertToIcns convertToIcns,
}; };

36
src/helpers/packagerConsole.js
View File

@ -1,27 +1,29 @@
// TODO: remove this file and use quiet mode of new version of electron packager
class PackagerConsole { class PackagerConsole {
constructor() { constructor() {
this.logs = []; this.logs = [];
} }
_log(...messages) { _log(...messages) {
this.logs.push(...messages); this.logs.push(...messages);
} }
override() { override() {
this.consoleError = console.error; this.consoleError = console.error;
// need to bind because somehow when _log() is called this refers to console // need to bind because somehow when _log() is called this refers to console
console.error = this._log.bind(this); // eslint-disable-next-line no-underscore-dangle
} console.error = this._log.bind(this);
}
restore() { restore() {
console.error = this.consoleError; console.error = this.consoleError;
} }
playback() { playback() {
console.log(this.logs.join(' ')); console.log(this.logs.join(' '));
} }
} }
export default PackagerConsole; export default PackagerConsole;

192
src/infer/inferIcon.js
View File

@ -5,117 +5,100 @@ import tmp from 'tmp';
import gitCloud from 'gitcloud'; import gitCloud from 'gitcloud';
import helpers from './../helpers/helpers'; import helpers from './../helpers/helpers';
const {downloadFile, allowedIconFormats} = helpers; const { downloadFile, allowedIconFormats } = helpers;
tmp.setGracefulCleanup(); tmp.setGracefulCleanup();
const GITCLOUD_SPACE_DELIMITER = '-'; const GITCLOUD_SPACE_DELIMITER = '-';
function inferIconFromStore(targetUrl, platform) {
const allowedFormats = allowedIconFormats(platform);
return gitCloud('http://jiahaog.com/nativefier-icons/')
.then(fileIndex => {
const iconWithScores = mapIconWithMatchScore(fileIndex, targetUrl);
const maxScore = getMaxMatchScore(iconWithScores);
if (maxScore === 0) {
return null;
}
const matchingIcons = getMatchingIcons(iconWithScores, maxScore);
let matchingUrl;
for (let format of allowedFormats) {
for (let icon of matchingIcons) {
if (icon.ext !== format) {
continue;
}
matchingUrl = icon.url;
}
}
if (!matchingUrl) {
return null;
}
return downloadFile(matchingUrl);
});
}
function mapIconWithMatchScore(fileIndex, targetUrl) {
const normalisedTargetUrl = targetUrl.toLowerCase();
return fileIndex
.map(item => {
const itemWords = item.name.split(GITCLOUD_SPACE_DELIMITER);
const score = itemWords.reduce((currentScore, word) => {
if (normalisedTargetUrl.includes(word)) {
return currentScore + 1;
}
return currentScore;
}, 0);
return Object.assign({},
item,
{score}
);
});
}
function getMaxMatchScore(iconWithScores) { function getMaxMatchScore(iconWithScores) {
return iconWithScores.reduce((maxScore, currentIcon) => { return iconWithScores.reduce((maxScore, currentIcon) => {
const currentScore = currentIcon.score; const currentScore = currentIcon.score;
if (currentScore > maxScore) { if (currentScore > maxScore) {
return currentScore; return currentScore;
} }
return maxScore; return maxScore;
}, 0); }, 0);
} }
/** /**
* also maps ext to icon object * also maps ext to icon object
*/ */
function getMatchingIcons(iconWithScores, maxScore) { function getMatchingIcons(iconsWithScores, maxScore) {
return iconWithScores return iconsWithScores
.filter(item => { .filter(item => item.score === maxScore)
return item.score === maxScore; .map(item => Object.assign({}, item, { ext: path.extname(item.url) }));
})
.map(item => {
return Object.assign(
{},
item,
{ext: path.extname(item.url)}
);
});
} }
function writeFilePromise(outPath, data) { function mapIconWithMatchScore(fileIndex, targetUrl) {
return new Promise((resolve, reject) => { const normalisedTargetUrl = targetUrl.toLowerCase();
fs.writeFile(outPath, data, error => { return fileIndex
if (error) { .map((item) => {
reject(error); const itemWords = item.name.split(GITCLOUD_SPACE_DELIMITER);
return; const score = itemWords.reduce((currentScore, word) => {
} if (normalisedTargetUrl.includes(word)) {
resolve(outPath); return currentScore + 1;
}); }
return currentScore;
}, 0);
return Object.assign({}, item, { score });
}); });
} }
function inferFromPage(targetUrl, platform, outDir) { function inferIconFromStore(targetUrl, platform) {
let preferredExt = '.png'; const allowedFormats = new Set(allowedIconFormats(platform));
if (platform === 'win32') {
preferredExt = '.ico';
}
// todo might want to pass list of preferences instead return gitCloud('http://jiahaog.com/nativefier-icons/')
return pageIcon(targetUrl, {ext: preferredExt}) .then((fileIndex) => {
.then(icon => { const iconWithScores = mapIconWithMatchScore(fileIndex, targetUrl);
if (!icon) { const maxScore = getMaxMatchScore(iconWithScores);
return null;
}
const outfilePath = path.join(outDir, `/icon${icon.ext}`); if (maxScore === 0) {
return writeFilePromise(outfilePath, icon.data); return null;
}); }
const iconsMatchingScore = getMatchingIcons(iconWithScores, maxScore);
const iconsMatchingExt = iconsMatchingScore.filter(icon => allowedFormats.has(icon.ext));
const matchingIcon = iconsMatchingExt[0];
const iconUrl = matchingIcon && matchingIcon.url;
if (!iconUrl) {
return null;
}
return downloadFile(iconUrl);
});
} }
function writeFilePromise(outPath, data) {
return new Promise((resolve, reject) => {
fs.writeFile(outPath, data, (error) => {
if (error) {
reject(error);
return;
}
resolve(outPath);
});
});
}
function inferFromPage(targetUrl, platform, outDir) {
let preferredExt = '.png';
if (platform === 'win32') {
preferredExt = '.ico';
}
// todo might want to pass list of preferences instead
return pageIcon(targetUrl, { ext: preferredExt })
.then((icon) => {
if (!icon) {
return null;
}
const outfilePath = path.join(outDir, `/icon${icon.ext}`);
return writeFilePromise(outfilePath, icon.data);
});
}
/** /**
* *
* @param {string} targetUrl * @param {string} targetUrl
@ -123,16 +106,15 @@ function inferFromPage(targetUrl, platform, outDir) {
* @param {string} outDir * @param {string} outDir
*/ */
function inferIconFromUrlToPath(targetUrl, platform, outDir) { function inferIconFromUrlToPath(targetUrl, platform, outDir) {
return inferIconFromStore(targetUrl, platform)
.then((icon) => {
if (!icon) {
return inferFromPage(targetUrl, platform, outDir);
}
return inferIconFromStore(targetUrl, platform) const outfilePath = path.join(outDir, `/icon${icon.ext}`);
.then(icon => { return writeFilePromise(outfilePath, icon.data);
if (!icon) { });
return inferFromPage(targetUrl, platform, outDir);
}
const outfilePath = path.join(outDir, `/icon${icon.ext}`);
return writeFilePromise(outfilePath, icon.data);
});
} }
/** /**
@ -140,9 +122,9 @@ function inferIconFromUrlToPath(targetUrl, platform, outDir) {
* @param {string} platform * @param {string} platform
*/ */
function inferIcon(targetUrl, platform) { function inferIcon(targetUrl, platform) {
const tmpObj = tmp.dirSync({unsafeCleanup: true}); const tmpObj = tmp.dirSync({ unsafeCleanup: true });
const tmpPath = tmpObj.name; const tmpPath = tmpObj.name;
return inferIconFromUrlToPath(targetUrl, platform, tmpPath); return inferIconFromUrlToPath(targetUrl, platform, tmpPath);
} }
export default inferIcon; export default inferIcon;

24
src/infer/inferOs.js
View File

@ -1,23 +1,23 @@
import os from 'os'; import os from 'os';
function inferPlatform() { function inferPlatform() {
const platform = os.platform(); const platform = os.platform();
if (platform === 'darwin' || platform === 'win32' || platform === 'linux') { if (platform === 'darwin' || platform === 'win32' || platform === 'linux') {
return platform; return platform;
} }
throw `Untested platform ${platform} detected`; throw new Error(`Untested platform ${platform} detected`);
} }
function inferArch() { function inferArch() {
const arch = os.arch(); const arch = os.arch();
if (arch !== 'ia32' && arch !== 'x64') { if (arch !== 'ia32' && arch !== 'x64') {
throw `Incompatible architecture ${arch} detected`; throw new Error(`Incompatible architecture ${arch} detected`);
} }
return arch; return arch;
} }
export default { export default {
inferPlatform: inferPlatform, inferPlatform,
inferArch: inferArch inferArch,
}; };

24
src/infer/inferTitle.js
View File

@ -4,19 +4,19 @@ import cheerio from 'cheerio';
const USER_AGENT = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/41.0.2227.1 Safari/537.36'; const USER_AGENT = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/41.0.2227.1 Safari/537.36';
function inferTitle(url) { function inferTitle(url) {
const options = { const options = {
method: 'get', method: 'get',
url, url,
headers: { headers: {
// fake a user agent because pages like http://messenger.com will throw 404 error // fake a user agent because pages like http://messenger.com will throw 404 error
'User-Agent': USER_AGENT 'User-Agent': USER_AGENT,
} },
}; };
return axios(options).then(({data}) => { return axios(options).then(({ data }) => {
const $ = cheerio.load(data); const $ = cheerio.load(data);
return $('title').first().text().replace(/\//g, ''); return $('title').first().text().replace(/\//g, '');
}); });
} }
export default inferTitle; export default inferTitle;

69
src/infer/inferUserAgent.js
View File

@ -6,50 +6,49 @@ const ELECTRON_VERSIONS_URL = 'https://atom.io/download/atom-shell/index.json';
const DEFAULT_CHROME_VERSION = '56.0.2924.87'; const DEFAULT_CHROME_VERSION = '56.0.2924.87';
function getChromeVersionForElectronVersion(electronVersion, url = ELECTRON_VERSIONS_URL) { function getChromeVersionForElectronVersion(electronVersion, url = ELECTRON_VERSIONS_URL) {
return axios.get(url, {timeout: 5000}) return axios.get(url, { timeout: 5000 })
.then(response => { .then((response) => {
if (response.status !== 200) { if (response.status !== 200) {
throw `Bad request: Status code ${response.status}`; throw new Error(`Bad request: Status code ${response.status}`);
} }
const data = response.data; const data = response.data;
const electronVersionToChromeVersion = _.zipObject(data.map(d => d.version), data.map(d => d.chrome)); const electronVersionToChromeVersion = _.zipObject(data.map(d => d.version),
data.map(d => d.chrome));
if (!(electronVersion in electronVersionToChromeVersion)) { if (!(electronVersion in electronVersionToChromeVersion)) {
throw `Electron version '${electronVersion}' not found in retrieved version list!`; throw new Error(`Electron version '${electronVersion}' not found in retrieved version list!`);
} }
return electronVersionToChromeVersion[electronVersion]; return electronVersionToChromeVersion[electronVersion];
}); });
} }
export function getUserAgentString(chromeVersion, platform) { export function getUserAgentString(chromeVersion, platform) {
let userAgent; let userAgent;
switch (platform) { switch (platform) {
case 'darwin': case 'darwin':
userAgent = `Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/${chromeVersion} Safari/537.36`; userAgent = `Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/${chromeVersion} Safari/537.36`;
break; break;
case 'win32': case 'win32':
userAgent = `Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/${chromeVersion} Safari/537.36`; userAgent = `Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/${chromeVersion} Safari/537.36`;
break; break;
case 'linux': case 'linux':
userAgent = `Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/${chromeVersion} Safari/537.36`; userAgent = `Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/${chromeVersion} Safari/537.36`;
break; break;
default: default:
throw 'Error invalid platform specified to getUserAgentString()'; throw new Error('Error invalid platform specified to getUserAgentString()');
} }
return userAgent; return userAgent;
} }
function inferUserAgent(electronVersion, platform, url = ELECTRON_VERSIONS_URL) { function inferUserAgent(electronVersion, platform, url = ELECTRON_VERSIONS_URL) {
return getChromeVersionForElectronVersion(electronVersion, url) return getChromeVersionForElectronVersion(electronVersion, url)
.then(chromeVersion => { .then(chromeVersion => getUserAgentString(chromeVersion, platform))
return getUserAgentString(chromeVersion, platform); .catch(() => {
}) log.warn(`Unable to infer chrome version for user agent, using ${DEFAULT_CHROME_VERSION}`);
.catch(() => { return getUserAgentString(DEFAULT_CHROME_VERSION, platform);
log.warn(`Unable to infer chrome version for user agent, using ${DEFAULT_CHROME_VERSION}`); });
return getUserAgentString(DEFAULT_CHROME_VERSION, platform);
});
} }
export default inferUserAgent; export default inferUserAgent;

30
src/options/normalizeUrl.js
View File

@ -2,25 +2,25 @@ import url from 'url';
import validator from 'validator'; import validator from 'validator';
function appendProtocol(testUrl) { function appendProtocol(testUrl) {
const parsed = url.parse(testUrl); const parsed = url.parse(testUrl);
if (!parsed.protocol) { if (!parsed.protocol) {
return `http://${testUrl}`; return `http://${testUrl}`;
} }
return testUrl; return testUrl;
} }
function normalizeUrl(testUrl) { function normalizeUrl(testUrl) {
const urlWithProtocol = appendProtocol(testUrl); const urlWithProtocol = appendProtocol(testUrl);
const validatorOptions = { const validatorOptions = {
require_protocol: true, require_protocol: true,
require_tld: false, require_tld: false,
allow_trailing_dot: true // mDNS addresses, https://github.com/jiahaog/nativefier/issues/308 allow_trailing_dot: true, // mDNS addresses, https://github.com/jiahaog/nativefier/issues/308
}; };
if (!validator.isURL(urlWithProtocol, validatorOptions)) { if (!validator.isURL(urlWithProtocol, validatorOptions)) {
throw `Your Url: "${urlWithProtocol}" is invalid!`; throw new Error(`Your Url: "${urlWithProtocol}" is invalid!`);
} }
return urlWithProtocol; return urlWithProtocol;
} }
export default normalizeUrl; export default normalizeUrl;

275
src/options/optionsMain.js
View File

@ -11,13 +11,31 @@ import inferUserAgent from './../infer/inferUserAgent';
import normalizeUrl from './normalizeUrl'; import normalizeUrl from './normalizeUrl';
import packageJson from './../../package.json'; import packageJson from './../../package.json';
const {inferPlatform, inferArch} = inferOs; const { inferPlatform, inferArch } = inferOs;
const PLACEHOLDER_APP_DIR = path.join(__dirname, '../../', 'app'); const PLACEHOLDER_APP_DIR = path.join(__dirname, '../../', 'app');
const ELECTRON_VERSION = '1.6.6'; const ELECTRON_VERSION = '1.6.6';
const DEFAULT_APP_NAME = 'APP'; const DEFAULT_APP_NAME = 'APP';
function sanitizeFilename(platform, str) {
let result = sanitizeFilenameLib(str);
// remove all non ascii or use default app name
// eslint-disable-next-line no-control-regex
result = result.replace(/[^\x00-\x7F]/g, '') || DEFAULT_APP_NAME;
// spaces will cause problems with Ubuntu when pinned to the dock
if (platform === 'linux') {
return _.kebabCase(result);
}
return result;
}
function sanitizeOptions(options) {
const name = sanitizeFilename(options.platform, options.name);
return Object.assign({}, options, { name });
}
/** /**
* @callback optionsCallback * @callback optionsCallback
* @param error * @param error
@ -30,143 +48,128 @@ const DEFAULT_APP_NAME = 'APP';
* @param {optionsCallback} callback * @param {optionsCallback} callback
*/ */
function optionsFactory(inpOptions, callback) { function optionsFactory(inpOptions, callback) {
const options = {
const options = { dir: PLACEHOLDER_APP_DIR,
dir: PLACEHOLDER_APP_DIR, name: inpOptions.name,
name: inpOptions.name, targetUrl: normalizeUrl(inpOptions.targetUrl),
targetUrl: normalizeUrl(inpOptions.targetUrl), platform: inpOptions.platform || inferPlatform(),
platform: inpOptions.platform || inferPlatform(), arch: inpOptions.arch || inferArch(),
arch: inpOptions.arch || inferArch(), electronVersion: inpOptions.electronVersion || ELECTRON_VERSION,
electronVersion: inpOptions.electronVersion || ELECTRON_VERSION, nativefierVersion: packageJson.version,
nativefierVersion: packageJson.version, out: inpOptions.out || process.cwd(),
out: inpOptions.out || process.cwd(), overwrite: inpOptions.overwrite,
overwrite: inpOptions.overwrite, asar: inpOptions.conceal || false,
asar: inpOptions.conceal || false, icon: inpOptions.icon,
icon: inpOptions.icon, counter: inpOptions.counter || false,
counter: inpOptions.counter || false, width: inpOptions.width || 1280,
width: inpOptions.width || 1280, height: inpOptions.height || 800,
height: inpOptions.height || 800, minWidth: inpOptions.minWidth,
minWidth: inpOptions.minWidth, minHeight: inpOptions.minHeight,
minHeight: inpOptions.minHeight, maxWidth: inpOptions.maxWidth,
maxWidth: inpOptions.maxWidth, maxHeight: inpOptions.maxHeight,
maxHeight: inpOptions.maxHeight, showMenuBar: inpOptions.showMenuBar || false,
showMenuBar: inpOptions.showMenuBar || false, fastQuit: inpOptions.fastQuit || false,
fastQuit: inpOptions.fastQuit || false, userAgent: inpOptions.userAgent,
userAgent: inpOptions.userAgent, ignoreCertificate: inpOptions.ignoreCertificate || false,
ignoreCertificate: inpOptions.ignoreCertificate || false, insecure: inpOptions.insecure || false,
insecure: inpOptions.insecure || false, flashPluginDir: inpOptions.flashPath || inpOptions.flash || null,
flashPluginDir: inpOptions.flashPath || inpOptions.flash || null, inject: inpOptions.inject || null,
inject: inpOptions.inject || null, ignore: 'src',
ignore: 'src', fullScreen: inpOptions.fullScreen || false,
fullScreen: inpOptions.fullScreen || false, maximize: inpOptions.maximize || false,
maximize: inpOptions.maximize || false, hideWindowFrame: inpOptions.hideWindowFrame,
hideWindowFrame: inpOptions.hideWindowFrame, verbose: inpOptions.verbose,
verbose: inpOptions.verbose, disableContextMenu: inpOptions.disableContextMenu,
disableContextMenu: inpOptions.disableContextMenu, disableDevTools: inpOptions.disableDevTools,
disableDevTools: inpOptions.disableDevTools, crashReporter: inpOptions.crashReporter,
crashReporter: inpOptions.crashReporter,
// workaround for electron-packager#375 // workaround for electron-packager#375
tmpdir: false, tmpdir: false,
zoom: inpOptions.zoom || 1.0, zoom: inpOptions.zoom || 1.0,
internalUrls: inpOptions.internalUrls || null, internalUrls: inpOptions.internalUrls || null,
singleInstance: inpOptions.singleInstance || false singleInstance: inpOptions.singleInstance || false,
}; };
if (options.verbose) { if (options.verbose) {
log.setLevel('trace'); log.setLevel('trace');
} else { } else {
log.setLevel('error'); log.setLevel('error');
}
if (options.flashPluginDir) {
options.insecure = true;
}
if (inpOptions.honest) {
options.userAgent = null;
}
if (options.platform.toLowerCase() === 'windows') {
options.platform = 'win32';
}
if (options.platform.toLowerCase() === 'osx' || options.platform.toLowerCase() === 'mac') {
options.platform = 'darwin';
}
if (options.width > options.maxWidth) {
options.width = options.maxWidth;
}
if (options.height > options.maxHeight) {
options.height = options.maxHeight;
}
async.waterfall([
(callback) => {
if (options.userAgent) {
callback();
return;
}
inferUserAgent(options.electronVersion, options.platform)
.then((userAgent) => {
options.userAgent = userAgent;
callback();
})
.catch(callback);
},
(callback) => {
if (options.icon) {
callback();
return;
}
inferIcon(options.targetUrl, options.platform)
.then((pngPath) => {
options.icon = pngPath;
callback();
})
.catch((error) => {
log.warn('Cannot automatically retrieve the app icon:', error);
callback();
});
},
(callback) => {
// length also checks if its the commanderJS function or a string
if (options.name && options.name.length > 0) {
callback();
return;
}
options.name = DEFAULT_APP_NAME;
inferTitle(options.targetUrl).then((pageTitle) => {
options.name = pageTitle;
}).catch((error) => {
log.warn(`Unable to automatically determine app name, falling back to '${DEFAULT_APP_NAME}'. Reason: ${error}`);
}).then(() => {
callback();
});
},
], (error) => {
if (error) {
callback(error);
return;
} }
callback(null, sanitizeOptions(options));
if (options.flashPluginDir) { });
options.insecure = true;
}
if (inpOptions.honest) {
options.userAgent = null;
}
if (options.platform.toLowerCase() === 'windows') {
options.platform = 'win32';
}
if (options.platform.toLowerCase() === 'osx' || options.platform.toLowerCase() === 'mac') {
options.platform = 'darwin';
}
if (options.width > options.maxWidth) {
options.width = options.maxWidth;
}
if (options.height > options.maxHeight) {
options.height = options.maxHeight;
}
async.waterfall([
callback => {
if (options.userAgent) {
callback();
return;
}
inferUserAgent(options.electronVersion, options.platform)
.then(userAgent => {
options.userAgent = userAgent;
callback();
})
.catch(callback);
},
callback => {
if (options.icon) {
callback();
return;
}
inferIcon(options.targetUrl, options.platform)
.then(pngPath => {
options.icon = pngPath;
callback();
})
.catch(error => {
log.warn('Cannot automatically retrieve the app icon:', error);
callback();
});
},
callback => {
// length also checks if its the commanderJS function or a string
if (options.name && options.name.length > 0) {
callback();
return;
}
options.name = DEFAULT_APP_NAME;
inferTitle(options.targetUrl).then(pageTitle => {
options.name = pageTitle;
}).catch(error => {
log.warn(`Unable to automatically determine app name, falling back to '${DEFAULT_APP_NAME}'. Reason: ${error}`);
}).then(() => {
callback();
});
}
], error => {
callback(error, sanitizeOptions(options));
});
}
function sanitizeFilename(platform, str) {
let result = sanitizeFilenameLib(str);
// remove all non ascii or use default app name
result = result.replace(/[^\x00-\x7F]/g, '') || DEFAULT_APP_NAME;
// spaces will cause problems with Ubuntu when pinned to the dock
if (platform === 'linux') {
return _.kebabCase(result);
}
return result;
}
function sanitizeOptions(options) {
options.name = sanitizeFilename(options.platform, options.name);
return options;
} }
export default optionsFactory; export default optionsFactory;

2
test/module/.eslintrc.yml Normal file
View File

@ -0,0 +1,2 @@
env:
mocha: true

46
test/module/getIconSpec.js
View File

@ -7,36 +7,36 @@ import os from 'os';
import path from 'path'; import path from 'path';
import convertToIcns from './../../lib/helpers/convertToIcns'; import convertToIcns from './../../lib/helpers/convertToIcns';
let assert = chai.assert; const assert = chai.assert;
// Prerequisite for test: to use OSX with sips, iconutil and imagemagick convert // Prerequisite for test: to use OSX with sips, iconutil and imagemagick convert
function testConvertPng(pngName, done) { function testConvertPng(pngName, done) {
convertToIcns(path.join(__dirname, '../../', 'test-resources', pngName), (error, icnsPath) => { convertToIcns(path.join(__dirname, '../../', 'test-resources', pngName), (error, icnsPath) => {
if (error) { if (error) {
done(error); done(error);
return; return;
} }
let stat = fs.statSync(icnsPath); const stat = fs.statSync(icnsPath);
assert.isTrue(stat.isFile(), 'Output icns file should be a path'); assert.isTrue(stat.isFile(), 'Output icns file should be a path');
done(); done();
}); });
} }
describe('Get Icon Module', function() { describe('Get Icon Module', () => {
it('Can convert icons', function() { it('Can convert icons', () => {
if (os.platform() !== 'darwin') { if (os.platform() !== 'darwin') {
console.warn('Skipping png conversion tests, OSX is required'); console.warn('Skipping png conversion tests, OSX is required');
return; return;
} }
it('Can convert a rgb png to icns', function(done) { it('Can convert a rgb png to icns', (done) => {
testConvertPng('iconSample.png', done); testConvertPng('iconSample.png', done);
});
it('Can convert a grey png to icns', function(done) {
testConvertPng('iconSampleGrey.png', done);
});
}); });
it('Can convert a grey png to icns', (done) => {
testConvertPng('iconSampleGrey.png', done);
});
});
}); });

102
test/module/indexSpec.js
View File

@ -11,65 +11,65 @@ tmp.setGracefulCleanup();
const assert = chai.assert; const assert = chai.assert;
function checkApp(appPath, inputOptions, callback) { function checkApp(appPath, inputOptions, callback) {
try { try {
let relPathToConfig; let relPathToConfig;
switch (inputOptions.platform) { switch (inputOptions.platform) {
case 'darwin': case 'darwin':
relPathToConfig = path.join('google-test-app.app', 'Contents/Resources/app'); relPathToConfig = path.join('google-test-app.app', 'Contents/Resources/app');
break; break;
case 'linux': case 'linux':
relPathToConfig = 'resources/app'; relPathToConfig = 'resources/app';
break; break;
case 'win32': case 'win32':
relPathToConfig = 'resources/app'; relPathToConfig = 'resources/app';
break; break;
default: default:
throw 'Unknown app platform'; throw new Error('Unknown app platform');
}
const nativefierConfigPath = path.join(appPath, relPathToConfig, 'nativefier.json');
const nativefierConfig = JSON.parse(fs.readFileSync(nativefierConfigPath));
assert.strictEqual(inputOptions.targetUrl, nativefierConfig.targetUrl, 'Packaged app must have the same targetUrl as the input parameters');
// app name is not consistent for linux
// assert.strictEqual(inputOptions.appName, nativefierConfig.name, 'Packaged app must have the same name as the input parameters');
callback();
} catch (exception) {
callback(exception);
} }
const nativefierConfigPath = path.join(appPath, relPathToConfig, 'nativefier.json');
const nativefierConfig = JSON.parse(fs.readFileSync(nativefierConfigPath));
assert.strictEqual(inputOptions.targetUrl, nativefierConfig.targetUrl, 'Packaged app must have the same targetUrl as the input parameters');
// app name is not consistent for linux
// assert.strictEqual(inputOptions.appName, nativefierConfig.name,
// 'Packaged app must have the same name as the input parameters');
callback();
} catch (exception) {
callback(exception);
}
} }
describe('Nativefier Module', function() { describe('Nativefier Module', function () {
this.timeout(240000); this.timeout(240000);
it('Can build an app from a target url', function(done) { it('Can build an app from a target url', (done) => {
async.eachSeries(PLATFORMS, (platform, callback) => { async.eachSeries(PLATFORMS, (platform, callback) => {
const tmpObj = tmp.dirSync({ unsafeCleanup: true });
const tmpObj = tmp.dirSync({unsafeCleanup: true}); const tmpPath = tmpObj.name;
const options = {
name: 'google-test-app',
targetUrl: 'http://google.com',
out: tmpPath,
overwrite: true,
platform: null,
};
const tmpPath = tmpObj.name; options.platform = platform;
const options = { nativefier(options, (error, appPath) => {
name: 'google-test-app', if (error) {
targetUrl: 'http://google.com', callback(error);
out: tmpPath, return;
overwrite: true, }
platform: null
};
options.platform = platform; checkApp(appPath, options, (error) => {
nativefier(options, (error, appPath) => { callback(error);
if (error) {
callback(error);
return;
}
checkApp(appPath, options, error => {
callback(error);
});
});
}, error => {
done(error);
}); });
});
}, (error) => {
done(error);
}); });
});
}); });

50
test/module/inferUserAgentSpec.js
View File

@ -1,49 +1,47 @@
import inferUserAgent from './../../lib/infer/inferUserAgent';
import chai from 'chai'; import chai from 'chai';
import _ from 'lodash'; import _ from 'lodash';
import inferUserAgent from './../../lib/infer/inferUserAgent';
const assert = chai.assert; const assert = chai.assert;
const TEST_RESULT = { const TEST_RESULT = {
darwin: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/49.0.2623.75 Safari/537.36', darwin: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/49.0.2623.75 Safari/537.36',
win32: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/49.0.2623.75 Safari/537.36', win32: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/49.0.2623.75 Safari/537.36',
linux: 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/49.0.2623.75 Safari/537.36' linux: 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/49.0.2623.75 Safari/537.36',
}; };
function testPlatform(platform) { function testPlatform(platform) {
return inferUserAgent('0.37.1', platform) return inferUserAgent('0.37.1', platform)
.then(userAgent => { .then((userAgent) => {
assert.equal(userAgent, TEST_RESULT[platform], 'Correct user agent should be inferred'); assert.equal(userAgent, TEST_RESULT[platform], 'Correct user agent should be inferred');
}); });
} }
describe('Infer User Agent', function() { describe('Infer User Agent', function () {
this.timeout(15000); this.timeout(15000);
it('Can infer userAgent for all platforms', function(done) { it('Can infer userAgent for all platforms', (done) => {
const testPromises = _.keys(TEST_RESULT).map(platform => { const testPromises = _.keys(TEST_RESULT).map(platform => testPlatform(platform));
return testPlatform(platform); Promise
});
Promise
.all(testPromises) .all(testPromises)
.then(() => { .then(() => {
done(); done();
}) })
.catch(error => { .catch((error) => {
done(error); done(error);
}); });
}); });
it('Connection error will still get a user agent', function(done) { it('Connection error will still get a user agent', (done) => {
const TIMEOUT_URL = 'http://www.google.com:81/'; const TIMEOUT_URL = 'http://www.google.com:81/';
inferUserAgent('1.6.7', 'darwin', TIMEOUT_URL) inferUserAgent('1.6.7', 'darwin', TIMEOUT_URL)
.then(userAgent => { .then((userAgent) => {
assert.equal( assert.equal(
userAgent, userAgent,
'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/56.0.2924.87 Safari/537.36', 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/56.0.2924.87 Safari/537.36',
'Expect default user agent on connection error' 'Expect default user agent on connection error',
); );
done(); done();
}) })
.catch(done); .catch(done);
}); });
}); });

28
test/module/options/normalizeUrlSpec.js
View File

@ -1,25 +1,25 @@
import normalizeUrl from '../../../src/options/normalizeUrl';
import chai from 'chai'; import chai from 'chai';
import normalizeUrl from '../../../src/options/normalizeUrl';
const assert = chai.assert; const assert = chai.assert;
const expect = chai.expect; const expect = chai.expect;
describe('Normalize URL', () => { describe('Normalize URL', () => {
describe('given a valid URL without a protocol', () => {
describe('given a valid URL without a protocol', () => { it('should allow the url', () => {
it('should allow the url', () => { assert.equal(normalizeUrl('http://www.google.com'), 'http://www.google.com');
assert.equal(normalizeUrl('http://www.google.com'), 'http://www.google.com');
});
}); });
});
describe('given a valid URL without a protocol', () => { describe('given a valid URL without a protocol', () => {
it('should allow the url and prepend the HTTP protocol', () => { it('should allow the url and prepend the HTTP protocol', () => {
assert.equal(normalizeUrl('www.google.com'), 'http://www.google.com'); assert.equal(normalizeUrl('www.google.com'), 'http://www.google.com');
});
}); });
});
describe('given an invalid URL', () => { describe('given an invalid URL', () => {
it('should throw an exception', () => { it('should throw an exception', () => {
expect(() => normalizeUrl('http://ssddfoo bar')).to.throw('Your Url: "http://ssddfoo bar" is invalid!'); expect(() => normalizeUrl('http://ssddfoo bar')).to.throw('Your Url: "http://ssddfoo bar" is invalid!');
});
}); });
});
}); });

38
webpack.config.js
View File

@ -1,24 +1,24 @@
var electronPublicApi = ['electron']; const electronPublicApi = ['electron'];
var nodeModules = {}; const nodeModules = {};
electronPublicApi.forEach(apiString => { electronPublicApi.forEach((apiString) => {
nodeModules[apiString] = 'commonjs ' + apiString; nodeModules[apiString] = `commonjs ${apiString}`;
}); });
module.exports = { module.exports = {
target: 'node', target: 'node',
output: { output: {
filename: 'main.js' filename: 'main.js',
}, },
node: { node: {
global: false, global: false,
__dirname: false __dirname: false,
}, },
externals: nodeModules, externals: nodeModules,
module: { module: {
loaders: [ loaders: [
{test: /\.js$/, exclude: /node_modules/, loader: 'babel-loader'} { test: /\.js$/, exclude: /node_modules/, loader: 'babel-loader' },
] ],
}, },
devtool: 'source-map' devtool: 'source-map',
}; };