muffin-cli/dist/lib/tasks/generate.js

The command line utility for building sites using muffin

'use strict';

var _fsExtra = require('fs-extra');

var _fsExtra2 = _interopRequireDefault(_fsExtra);

var _path = require('path');

var _path2 = _interopRequireDefault(_path);

var _ora = require('ora');

var _ora2 = _interopRequireDefault(_ora);

var _chalk = require('chalk');

var _chalk2 = _interopRequireDefault(_chalk);

var _child_process = require('child_process');

var _utils = require('../utils');

var _mongonaut = require('mongonaut');

var _mongonaut2 = _interopRequireDefault(_mongonaut);

var _insert = require('./insert');

var _insert2 = _interopRequireDefault(_insert);

var _dotenv = require('dotenv');

var _dotenv2 = _interopRequireDefault(_dotenv);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

class Generator {
  constructor(answers, targetDir) {
    this.blueprints = [];

    this.answers = answers;
    this.targetDir = targetDir;
    this.template = _path2.default.normalize(__dirname + '/../../../template');

    if (!answers.skipData) {
      this.insertSampleData();
      return;
    }

    this.findBlueprints();
  }

  insertSampleData() {
    const walker = _fsExtra2.default.walk(__dirname + '/../../../data/');
    let files = [];

    walker.on('data', item => files.push(item.path));

    walker.on('end', function () {
      files.shift();

      const relatedDB = ['host', 'name', 'user', 'password'];

      for (let kind of relatedDB) {
        let key = 'db_' + kind,
            fromAnswers = this.answers[key];

        if (!fromAnswers) {
          continue;
        }

        let inUppercase = key.toUpperCase();
        process.env[inUppercase] = fromAnswers;
      }

      new _insert2.default(files, this.findBlueprints.bind(this));
    }.bind(this));

    walker.on('error', (err, item) => {
      throw err;
    });
  }

  findBlueprints() {
    const walker = _fsExtra2.default.walk(this.template);

    walker.on('data', this.foundFile.bind(this));
    walker.on('end', this.insertBlueprints.bind(this));
  }

  foundFile(file) {
    const ignore = ['dist', 'node_modules', 'tmp'];

    for (let dir of ignore) {
      if (file.path.indexOf(dir) == -1) {
        continue;
      }

      return;
    }

    this.blueprints.push(file.path);
  }

  done() {
    if (this.spinner) {
      this.spinner.stop();
    }

    (0, _utils.log)('Generated new site in ' + _chalk2.default.gray(this.targetDir));
  }

  insertBlueprints() {
    // Strip away the "/template" folder itself
    // We only need its contents
    let files = this.blueprints;
    files.shift();

    // The properties of a parsed file path whose first
    // letter shall be replaced with a dot
    const replaceDots = ['name', 'base'];

    for (let file of files) {
      let filePath = _path2.default.parse(file);

      // Take care of the dotfiles
      for (let property of replaceDots) {
        filePath[property] = filePath[property].replace('_', '.');
      }

      // Generate the destination path
      let dest = _path2.default.join(this.targetDir, _path2.default.relative(this.template, _path2.default.format(filePath)));

      // Make sure the destination exists
      try {
        _fsExtra2.default.ensureDirSync(_path2.default.dirname(dest));
      } catch (err) {
        return (0, _utils.log)(err);
      }

      if (filePath.name == '.env') {
        let contents = false;

        try {
          contents = _fsExtra2.default.readFileSync(file, 'utf8');
        } catch (err) {
          return (0, _utils.log)(err);
        }

        // Generate random session secret
        process.env.SESSION_SECRET = Math.random().toString(36).substr(2, 20);

        // Parse content of default .env file
        let parsed = _dotenv2.default.parse(new Buffer(contents)),
            newVariables = {};

        for (let property in parsed) {
          let fromProcess = process.env[property];

          // If a new value for var exists, overwrite it in .env
          if (fromProcess) {
            let prefix = property + '=';
            contents = contents.replace(prefix + parsed[property], prefix + fromProcess);
          }
        }

        // And finally, write the modified file
        try {
          _fsExtra2.default.writeFileSync(dest, contents);
        } catch (err) {
          return (0, _utils.log)(err);
        }

        continue;
      }

      // If so, copy the blueprints
      try {
        _fsExtra2.default.copySync(file, dest);
      } catch (err) {
        return (0, _utils.log)(err);
      }
    }

    if (this.answers.skipNpm) {
      this.done();
      return;
    }

    this.spinner = (0, _ora2.default)(_chalk2.default.grey('Installing missing packages via npm'));
    this.spinner.color = 'grey';
    this.spinner.start();

    process.chdir(this.targetDir);

    (0, _child_process.exec)('npm install', function (err, stdout, stderr) {
      if (err) throw err;

      if (stdout && stdout.indexOf('example@1.0.0') > -1) {
        this.spinner.stop();
        this.done();

        return;
      }

      if (stderr) {
        (0, _utils.log)(stderr);
      }

      (0, _utils.log)(_chalk2.default.red('Not able to install dependencies!'));
    }.bind(this));
  }
}

module.exports = Generator;