feat: web-ext create simple version

package.json

@@ -63,17 +63,18 @@
     "mkdirp": "0.5.1",
     "mz": "2.6.0",
     "node-firefox-connect": "1.2.0",
-    "open": "0.0.5",
     "node-notifier": "5.1.2",
+    "open": "0.0.5",
     "parse-json": "2.2.0",
     "regenerator-runtime": "0.10.5",
     "require-uncached": "1.0.3",
+    "rimraf": "2.6.1",
     "sign-addon": "0.2.1",
     "source-map-support": "0.4.15",
     "stream-to-promise": "2.2.0",
     "tmp": "0.0.30",
-    "watchpack": "1.3.0",
     "update-notifier": "2.1.0",
+    "watchpack": "1.3.0",
     "yargs": "6.6.0",
     "zip-dir": "1.0.2"
   },
@@ -115,6 +116,7 @@
     "load-grunt-tasks": "3.5.2",
     "mocha": "3.4.2",
     "mocha-multi": "0.11.0",
+    "mock-stdin": "0.3.1",
     "nsp": "2.6.3",
     "object.entries": "1.0.4",
     "object.values": "1.0.4",

src/cmd/create.js

@@ -0,0 +1,133 @@
+/* @flow */
+import path from 'path';
+import readline from 'readline';
+import tty from 'tty';
+
+import {fs} from 'mz';
+import mkdirp from 'mkdirp';
+import promisify from 'es6-promisify';
+
+import {createLogger} from '../util/logger';
+import {UsageError, isErrorWithCode} from '../errors';
+
+const log = createLogger(__filename);
+const defaultAsyncMkdirp = promisify(mkdirp);
+
+export type CreateParams = {|
+  dirPath: string,
+  stdin?: stream$Readable,
+|};
+
+export default async function create(
+  {
+    dirPath,
+    stdin = process.stdin,
+  }: CreateParams
+): Promise<void> {
+  const targetPath = path.join(process.cwd(), dirPath);
+  const name = path.basename(dirPath);
+  log.info(name, targetPath);
+
+  let userAbort = true;
+
+  try {
+    const stats = await fs.stat(targetPath);
+    if (stats.isDirectory()) {
+      if (stdin.isTTY && (stdin instanceof tty.ReadStream)) {
+        stdin.setRawMode(true);
+        readline.emitKeypressEvents(stdin);
+        let userConfirmation = false;
+
+        while (!userConfirmation) {
+          log.info(`The ${targetPath} already exists. Are you sure you want ` +
+                   'to use this directory and overwrite existing files? Y/N');
+
+          const pressed = await new Promise((resolve) => {
+            stdin.once('keypress', (str, key) => resolve(key));
+          });
+
+          if (pressed.name === 'n' || (pressed.ctrl && pressed.name === 'c')) {
+            userConfirmation = true;
+            break;
+          } else if (pressed.name === 'y') {
+            userConfirmation = true;
+            userAbort = false;
+            break;
+          }
+        }
+      } else {
+        throw new UsageError('Target dir already exist, overwrite is not ' +
+                             'allowed without user confirmation.');
+      }
+    }
+
+    if (userAbort) {
+      log.info('User aborted the command.');
+      stdin.pause();
+      return;
+    }
+
+    return await createFiles(name, targetPath).then(() => {
+      stdin.pause();
+    });
+  } catch (statErr) {
+    if (!isErrorWithCode('ENOENT', statErr)) {
+      throw statErr;
+    } else {
+      try {
+        await defaultAsyncMkdirp(targetPath);
+        await createFiles(name, targetPath);
+      } catch (mkdirErr) {
+        throw mkdirErr;
+      }
+    }
+  }
+}
+
+async function createFiles(name, targetPath): Promise<void> {
+  log.info('Creating manifest file');
+  const generatedManifest = await generateManifest(name);
+  const json = JSON.stringify(generatedManifest, null, 2);
+  try {
+    log.info('Writing files');
+    await fs.writeFile(path.join(targetPath, 'manifest.json'), json, 'utf8');
+    await fs.open(path.join(targetPath, 'background.js'), 'w');
+    await fs.open(path.join(targetPath, 'content.js'), 'w');
+  } catch (error) {
+    throw error;
+  }
+  return;
+}
+
+async function generateManifest(title) {
+  return {
+    manifest_version: 2,
+    name: `${title} (name)`,
+    description: `${title} (description)`,
+    version: 0.1,
+    default_locale: 'en',
+    icons: {
+      '48': 'icon.png',
+      '96': 'icon@2x.png',
+    },
+    browser_action: {
+      default_title: `${title} (browserAction)`,
+      default_icon: {
+        '19': 'button/button-19.png',
+        '38': 'button/button-38.png',
+      },
+    },
+    background: {
+      scripts: ['background.js'],
+      page: '',
+    },
+    content_scripts: [
+      {
+        exclude_matches: [],
+        matches: [],
+        js: ['content.js'],
+      },
+    ],
+    permissions: [],
+  };
+}

src/cmd/index.js

@@ -3,7 +3,7 @@ import build from './build';
 import lint from './lint';
 import run from './run';
 import sign from './sign';
+import create from './create';
 import docs from './docs';
 
-export default {build, lint, run, sign, docs};
-
+export default {build, lint, run, sign, create, docs};

src/program.js

@@ -431,6 +431,16 @@ Example: $0 --help run.
         default: false,
       },
     })
+    .command(
+      'create',
+      'Create basic structure of a new addon', commands.create, {
+        'dir-path': {
+          desc: 'Optional path to a directory',
+          type: 'string',
+          demand: true,
+          requiresArg: true,
+        },
+      })
     .command('docs', 'Open the web-ext documentation in a browser',
       commands.docs, {});
 

tests/unit/test-cmd/test.create.js

@@ -0,0 +1,147 @@
+/* @flow */
+import path from 'path';
+import tty from 'tty';
+
+import {fs} from 'mz';
+import {describe, it, afterEach} from 'mocha';
+import {assert} from 'chai';
+import sinon from 'sinon';
+import mockStdin from 'mock-stdin';
+import rimraf from 'rimraf';
+
+import create from '../../../src/cmd/create';
+import {withTempDir} from '../../../src/util/temp-dir';
+import {makeSureItFails} from '../helpers';
+import {onlyInstancesOf, UsageError} from '../../../src/errors';
+
+const homeDir = process.cwd();
+
+describe('create', () => {
+
+  afterEach(() => {
+    process.chdir(homeDir);
+  });
+
+  async function cleanTmpDir(dir) {
+    rimraf(dir, (error) => {
+      if (error) {
+        throw error;
+      }
+    });
+  }
+
+  it('creates files including manifest with correct name', () => withTempDir(
+    (tmpDir) => {
+      process.chdir(tmpDir.path());
+      const targetDir = path.join(tmpDir.path(), 'target');
+      const manifest = path.join(targetDir, 'manifest.json');
+      return create({dirPath: 'target'})
+        .then(() => {
+          return fs.stat(path.join(targetDir, 'content.js'))
+            .then((contentstat) => {
+              assert.equal(contentstat.isDirectory(), false);
+              return fs.stat(path.join(targetDir, 'background.js'))
+                .then((bgstat) => {
+                  assert.equal(bgstat.isDirectory(), false);
+                  return fs.readFile(manifest, 'utf-8')
+                    .then((data) => {
+                      const parsed = JSON.parse(data);
+                      assert.equal(parsed.name, 'target (name)');
+                    })
+                    .then(
+                      () => cleanTmpDir(targetDir),
+                      () => cleanTmpDir(targetDir)
+                    );
+                });
+            });
+        });
+    }));
+
+  it('creates directory recursively when needed', () => withTempDir(
+    (tmpDir) => {
+      process.chdir(tmpDir.path());
+      const targetDir = path.join(tmpDir.path(), 'sub/target');
+      const manifest = path.join(targetDir, 'manifest.json');
+      return create({dirPath: 'sub/target'})
+        .then(() => {
+          return fs.stat(path.join(targetDir))
+            .then((contentstat) => {
+              assert.equal(contentstat.isDirectory(), true);
+              return fs.readFile(manifest, 'utf-8')
+                .then((data) => {
+                  const parsed = JSON.parse(data);
+                  assert.equal(parsed.name, 'target (name)');
+                })
+                .then(
+                  () => cleanTmpDir(targetDir),
+                  () => cleanTmpDir(targetDir)
+                );
+            });
+        });
+    }));
+
+  it('does not overwrite existing directory if user aborts', () => withTempDir(
+      (tmpDir) => {
+        process.chdir(tmpDir.path());
+        const targetDir = path.join(tmpDir.path(), 'target');
+        const fakeStdin = new tty.ReadStream();
+        fs.mkdir('target');
+        setTimeout(() => {
+          fakeStdin.emit('keypress', 'n', {name: 'n', ctrl: false});
+        }, 50);
+        return create({dirPath: 'target', stdin: fakeStdin})
+          .then(() => {
+            return fs.readFile(path.join(targetDir, 'manifest.json'), 'utf-8')
+              .then(makeSureItFails())
+              .catch((error) => {
+                assert.equal(error.code, 'ENOENT');
+              })
+              .then(
+                () => cleanTmpDir(targetDir),
+                () => cleanTmpDir(targetDir)
+              );
+          });
+      }));
+
+  it('overwrites existing directory if user allows', () => withTempDir(
+    (tmpDir) => {
+      process.chdir(tmpDir.path());
+      const targetDir = path.join(tmpDir.path(), 'target');
+      const fakeStdin = new tty.ReadStream();
+      sinon.spy(fakeStdin, 'pause');
+      fs.mkdir('target');
+      setTimeout(() => {
+        fakeStdin.emit('keypress', 'y', {name: 'y', ctrl: false});
+      }, 50);
+      return create({dirPath: 'target', stdin: fakeStdin})
+        .then(() => {
+          return fs.readFile(path.join(targetDir, 'manifest.json'), 'utf-8')
+            .then((data) => {
+              const manifest = JSON.parse(data);
+              assert.equal(manifest.name, 'target (name)');
+              assert.ok(fakeStdin.pause.called);
+            })
+            .then(
+              () => cleanTmpDir(targetDir),
+              () => cleanTmpDir(targetDir)
+            );
+        });
+    }));
+
+  it('throws error when user cannot confirm overwriting', () => withTempDir(
+    (tmpDir) => {
+      process.chdir(tmpDir.path());
+      mockStdin.isTTY = false;
+      fs.mkdir('target');
+      return create({dirPath: 'target', stdin: mockStdin})
+        .then(makeSureItFails())
+        .catch(onlyInstancesOf(UsageError, (error) => {
+          assert.match(error.message, /without user confirmation/);
+        }))
+        .then(
+          () => cleanTmpDir(path.join(tmpDir.path(), 'target')),
+          () => cleanTmpDir(path.join(tmpDir.path(), 'target'))
+        );
+    }));
+
+});