feat(importer): create inital import logic

src/electron-forge-import.js

@@ -0,0 +1,143 @@
+import debug from 'debug';
+import fs from 'fs-promise';
+import inquirer from 'inquirer';
+import ora from 'ora';
+import path from 'path';
+import pify from 'pify';
+import program from 'commander';
+import rimraf from 'rimraf';
+import { spawn as yarnOrNPMSpawn, hasYarn } from 'yarn-or-npm';
+
+import initGit from './init/init-git';
+import { deps, devDeps } from './init/init-npm';
+
+import installDepList from './util/install-dependencies';
+
+import './util/terminate';
+
+const d = debug('electron-forge:import');
+
+const main = async () => {
+ let dir = process.cwd();
+ program
+ .version(require('../package.json').version)
+ .arguments('[name]')
+ .action((name) => {
+ if (!name) return;
+ if (path.isAbsolute(name)) {
+ dir = name;
+ } else {
+ dir = path.resolve(dir, name);
+ }
+ })
+ .parse(process.argv);
+
+ d(`Attempting to import project in: ${dir}`);
+ if (!await fs.exists(dir) || !await fs.exists(path.resolve(dir, 'package.json'))) {
+ console.error(`We couldn't find a project in: ${dir}`.red);
+ process.exit(1);
+ }
+
+ const { confirm } = await inquirer.createPromptModule()({
+ type: 'confirm',
+ name: 'confirm',
+ message: `WARNING: We will now attempt to import: "${dir}". This will involve modifying some files, are you sure you want to continue?`,
+ });
+ if (!confirm) {
+ process.exit(1);
+ }
+
+ await initGit(dir);
+
+ const packageJSONPath = path.resolve(dir, 'package.json');
+ let packageJSON = JSON.parse(await fs.readFile(packageJSONPath, 'utf8'));
+ if (packageJSON.config && packageJSON.config.forge) {
+ console.warn('It looks like this project is already configured for "electron-forge"'.green);
+ const { shouldContinue } = await inquirer.createPromptModule()({
+ type: 'confirm',
+ name: 'shouldContinue',
+ message: 'Are you sure you want to continue?',
+ });
+ if (!shouldContinue) {
+ process.exit(0);
+ }
+ }
+
+ const { shouldChangeMain } = await inquirer.createPromptModule()({
+ type: 'confirm',
+ name: 'shouldChangeMain',
+ message: 'Do you want us to change the "main" attribute of your package.json? If you are currently using babel and pointint to a "build" directory say yes.', // eslint-disable-line
+ });
+ if (shouldChangeMain) {
+ const { newMain } = await inquirer.createPromptModule()({
+ type: 'input',
+ name: 'newMain',
+ default: packageJSON.main,
+ message: 'Enter the relative path to your uncompiled main file',
+ });
+ packageJSON.main = newMain;
+ }
+
+ packageJSON.dependencies = packageJSON.dependencies || {};
+ packageJSON.devDependencies = packageJSON.devDependencies || {};
+
+ const keys = Object.keys(packageJSON.dependencies).concat(Object.keys(packageJSON.devDependencies));
+ let electronName;
+ for (const key of keys) {
+ if (key === 'electron' || key === 'electron-prebuilt') {
+ delete packageJSON.dependencies[key];
+ delete packageJSON.devDependencies[key];
+ electronName = key;
+ }
+ }
+
+ const writeChanges = async () => {
+ const writeSpinner = ora.ora('Writing modified package.json file').start();
+ await fs.writeFile(packageJSONPath, `${JSON.stringify(packageJSON, null, 2)}\n`);
+ writeSpinner.succeed();
+ };
+
+ let electronVersion;
+ if (electronName) {
+ electronVersion = JSON.parse(await fs.readFile(path.resolve(dir, 'node_modules', electronName, 'package.json'))).version;
+ packageJSON.devDependencies['electron-prebuilt-compile'] = electronVersion;
+ }
+
+ await writeChanges();
+
+ if (electronName) {
+ const pruneSpinner = ora.ora('Pruning deleted modules').start();
+ await new Promise((resolve) => {
+ d('attempting to prune node_modules in:', dir);
+ const child = yarnOrNPMSpawn(hasYarn() ? [] : ['prune'], {
+ cwd: dir,
+ stdio: 'ignore',
+ });
+ child.on('exit', () => resolve());
+ });
+ pruneSpinner.succeed();
+
+ const installSpinner = ora.ora('Installing dependencies').start();
+
+ await pify(rimraf)(path.resolve(dir, 'node_modules/.bin/electron'));
+ await pify(rimraf)(path.resolve(dir, 'node_modules/.bin/electron.cmd'));
+ await pify(rimraf)(path.resolve(dir, 'node_modules', electronName));
+
+ d('installing dependencies');
+ await installDepList(dir, deps);
+ d('installing devDependencies');
+ await installDepList(dir, devDeps, true);
+ d('installing electron-prebuilt-compile');
+ await installDepList(dir, [`electron-prebuilt-compile@${electronVersion}`], false, true);
+ installSpinner.succeed();
+ }
+
+ packageJSON = JSON.parse(await fs.readFile(packageJSONPath, 'utf8'));
+
+ packageJSON.config = packageJSON.config || {};
+ packageJSON.config.forge = JSON.parse(await fs.readFile(path.resolve(__dirname, '../tmpl/package.json'))).config.forge;
+
+ await writeChanges();
+};
+
+main();

src/electron-forge-start.js

@@ -25,7 +25,7 @@ const main = async () => {
  dir = path.resolve(dir, cwd);
  }
  })
- .parse(process.argv);
+ .parse(process.argv.slice(0, 2));
 
  dir = await resolveDir(dir);
  if (!dir) {

src/electron-forge.js

@@ -21,6 +21,7 @@ checkSystem()
  .version(require('../package.json').version)
  .option('--verbose', 'Enables verbose mode')
  .command('init', 'Initialize a new Electron application')
+ .command('import', 'Attempts to navigate you through the process of importing an existing project to "electron-forge"')
  .command('lint', 'Lints the current Electron application')
  .command('package', 'Package the current Electron application')
  .command('make', 'Generate distributables for the current Electron application')

src/init/init-git.js

@@ -1,12 +1,19 @@
 import { exec } from 'child_process';
 import debug from 'debug';
+import fs from 'fs-promise';
 import ora from 'ora';
+import path from 'path';
 
 const d = debug('electron-forge:init:git');
 
 export default async dir =>
- new Promise((resolve, reject) => {
+ new Promise(async (resolve, reject) => {
  const spinner = ora.ora('Initializing Git Repository').start();
+ if (await fs.exists(path.resolve(dir, '.git'))) {
+ d('.git directory already exists, skipping git initialization');
+ spinner.succeed();
+ return resolve();
+ }
  d('executing "git init" in directory:', dir);
  exec('git init', {
  cwd: dir,

src/init/init-npm.js

@@ -9,11 +9,11 @@ import readPackageJSON from '../util/read-package-json';
 
 const d = debug('electron-forge:init:npm');
 
-const deps = ['electron-compile'];
-const devDeps = ['babel-preset-stage-0'];
-const exactDevDeps = ['electron-prebuilt-compile'];
-const standardDeps = ['standard'];
-const airbnDeps = ['eslint', 'eslint-config-airbnb', 'eslint-plugin-import',
+export const deps = ['electron-compile'];
+export const devDeps = ['babel-preset-stage-0'];
+export const exactDevDeps = ['electron-prebuilt-compile'];
+export const standardDeps = ['standard'];
+export const airbnDeps = ['eslint', 'eslint-config-airbnb', 'eslint-plugin-import',
  'eslint-plugin-jsx-a11y@^2.2.3', 'eslint-plugin-react'];
 
 export default async (dir, lintStyle) => {
@@ -27,9 +27,11 @@ export default async (dir, lintStyle) => {
  packageJSON.scripts.lint = 'standard';
  break;
  case 'airbnb':
- default:
  packageJSON.scripts.lint = 'eslint src';
  break;
+ default:
+ packageJSON.scripts.lint = 'echo "No linting yet..."';
+ break;
  }
  d('writing package.json to:', dir);
  await fs.writeFile(path.resolve(dir, 'package.json'), JSON.stringify(packageJSON, null, 4));

src/util/terminate.js

@@ -4,13 +4,17 @@ import ora from 'ora';
 
 const d = debug('electron-forge:lifecycle');
 
+const runningOras = {};
+
 process.on('unhandledRejection', (err) => {
+ Object.keys(runningOras).forEach(key => runningOras[key].fail());
  process.stdout.write('\n\nAn unhandled rejection has occurred inside Forge:\n');
  console.error(colors.red(err.stack || JSON.stringify(err)));
  process.exit(1);
 });
 
 process.on('uncaughtException', (err) => {
+ Object.keys(runningOras).forEach(key => runningOras[key].fail());
  process.stdout.write('\n\nAn unhandled exception has occurred inside Forge:\n');
  console.error(colors.red(err.stack || JSON.stringify(err)));
  process.exit(1);
@@ -40,5 +44,28 @@ if (process.env.DEBUG && process.env.DEBUG.includes('electron-forge')) {
  return fake;
  };
 } else {
- ora.ora = ora;
+ let oraID = 1;
+ ora.ora = (name) => {
+ const createdOra = ora(name);
+ createdOra.id = oraID;
+ const fns = {};
+ fns.start = createdOra.start.bind(createdOra);
+ fns.stop = createdOra.stop.bind(createdOra);
+ fns.succeed = createdOra.succeed.bind(createdOra);
+ fns.fail = createdOra.fail.bind(createdOra);
+ createdOra.start = () => {
+ runningOras[createdOra.id] = createdOra;
+ fns.start();
+ return createdOra;
+ };
+ ['stop', 'succeed', 'fail'].forEach((fnName) => {
+ createdOra[fnName] = (...args) => {
+ delete runningOras[createdOra.id];
+ fns[fnName](...args);
+ return createdOra;
+ };
+ });
+ oraID += 1;
+ return createdOra;
+ };
 }