[DX-185] install compiler inside each components' dir

src/cli/domain/handle-dependencies/ensure-compiler-is-declared-as-devDependency.js

@@ -0,0 +1,17 @@
+'use strict';
+
+const format = require('stringformat');
+
+const strings = require('../../../resources');
+
+module.exports = (options, cb) => {
+  const { componentPath, pkg, template } = options;
+  const compilerDep = `${template}-compiler`;
+  const isOk = pkg.devDependencies[compilerDep];
+
+  const err = isOk
+    ? null
+    : format(strings.errors.cli.TEMPLATE_DEP_MISSING, template, componentPath);
+
+  cb(err, compilerDep);
+};

src/cli/domain/handle-dependencies/get-compiler.js

@@ -0,0 +1,31 @@
+'use strict';
+
+const path = require('path');
+
+const cleanRequire = require('../../../utils/clean-require');
+const installCompiler = require('./install-compiler');
+
+module.exports = (options, cb) => {
+  const { compilerDep, componentPath, logger, pkg } = options;
+  const compilerPath = path.join(componentPath, 'node_modules', compilerDep);
+  const compiler = cleanRequire(compilerPath, { justTry: true });
+
+  if (compiler) {
+    return cb(null, compiler);
+  }
+
+  let dependency = compilerDep;
+  if (pkg.devDependencies[compilerDep]) {
+    dependency += `@${pkg.devDependencies[compilerDep]}`;
+  }
+
+  const installOptions = {
+    compilerPath,
+    componentName: pkg.name,
+    componentPath,
+    dependency,
+    logger
+  };
+
+  installCompiler(installOptions, cb);
+};

src/cli/domain/handle-dependencies/get-missing-dependencies.js

@@ -0,0 +1,17 @@
+'use strict';
+
+const path = require('path');
+const _ = require('lodash');
+
+const cleanRequire = require('../../../utils/clean-require');
+
+module.exports = dependencies => {
+  const missing = [];
+  _.each(dependencies, (version, dependency) => {
+    const pathToModule = path.resolve('node_modules/', dependency);
+    if (!cleanRequire(pathToModule, { justTry: true })) {
+      missing.push(`${dependency}@${version || 'latest'}`);
+    }
+  });
+  return missing;
+};

src/cli/domain/handle-dependencies/index.js

@@ -0,0 +1,80 @@
+'use strict';
+
+const async = require('async');
+const coreModules = require('builtin-modules');
+const fs = require('fs-extra');
+const path = require('path');
+const _ = require('lodash');
+
+const ensureCompilerIsDeclaredAsDevDependency = require('./ensure-compiler-is-declared-as-devDependency');
+const getCompiler = require('./get-compiler');
+const installMissingDependencies = require('./install-missing-dependencies');
+const isTemplateLegacy = require('./is-template-legacy');
+const strings = require('../../../resources');
+
+const getComponentPackageJson = (componentPath, cb) =>
+  fs.readJson(path.join(componentPath, 'package.json'), cb);
+
+module.exports = (options, callback) => {
+  const { components, logger } = options;
+
+  const dependencies = {};
+  const addDependencies = componentDependencies =>
+    _.each(componentDependencies || {}, (version, dependency) => {
+      dependencies[dependency] = version;
+    });
+
+  const templates = {};
+  const addTemplate = (templateName, template) => {
+    templates[templateName] = template;
+  };
+
+  const setupComponentDependencies = (componentPath, done) =>
+    async.waterfall(
+      [
+        cb => getComponentPackageJson(componentPath, cb),
+        (pkg, cb) => {
+          addDependencies(pkg.dependencies);
+
+          const template = pkg.oc.files.template.type;
+          if (isTemplateLegacy(template)) {
+            return done();
+          }
+
+          cb(null, { componentPath, logger, pkg, template });
+        },
+
+        (options, cb) =>
+          ensureCompilerIsDeclaredAsDevDependency(options, (err, compilerDep) =>
+            cb(err, _.extend(options, { compilerDep }))
+          ),
+
+        (options, cb) =>
+          getCompiler(options, (err, compiler) =>
+            cb(err, _.extend(options, { compiler }))
+          ),
+
+        (options, cb) => {
+          const { compiler, template } = options;
+          addTemplate(template, compiler);
+          cb();
+        }
+      ],
+      done
+    );
+
+  logger.warn(strings.messages.cli.CHECKING_DEPENDENCIES);
+  async.eachSeries(components, setupComponentDependencies, err => {
+    if (err) {
+      return callback(err);
+    }
+
+    const result = {
+      modules: _.union(coreModules, _.keys(dependencies)).sort(),
+      templates: _.values(templates)
+    };
+
+    const installOptions = { dependencies, logger };
+    installMissingDependencies(installOptions, err => callback(err, result));
+  });
+};

src/cli/domain/handle-dependencies/install-compiler.js

@@ -0,0 +1,35 @@
+'use strict';
+
+const format = require('stringformat');
+
+const cleanRequire = require('../../../utils/clean-require');
+const isTemplateValid = require('../../../utils/is-template-valid');
+const npm = require('../../../utils/npm-utils');
+const strings = require('../../../resources/index');
+
+module.exports = (options, cb) => {
+  const {
+    compilerPath,
+    componentName,
+    componentPath,
+    dependency,
+    logger
+  } = options;
+
+  logger.warn(format(strings.messages.cli.INSTALLING_DEPS, dependency), true);
+
+  const npmOptions = {
+    dependency,
+    installPath: componentPath,
+    save: false,
+    silent: true
+  };
+
+  npm.installDependency(npmOptions, err => {
+    err ? logger.err('FAIL') : logger.ok('OK');
+    const compiler = cleanRequire(compilerPath, { justTry: true });
+    const isOk = isTemplateValid(compiler);
+    const errorMsg = 'There was a problem while installing the compiler';
+    cb(!err && isOk ? null : errorMsg, compiler);
+  });
+};

src/cli/domain/handle-dependencies/install-missing-dependencies.js

@@ -0,0 +1,40 @@
+'use strict';
+
+const format = require('stringformat');
+const path = require('path');
+const _ = require('lodash');
+
+const getMissingDependencies = require('./get-missing-dependencies');
+const npm = require('../../../utils/npm-utils');
+const strings = require('../../../resources/index');
+
+module.exports = (options, callback) => {
+  const { dependencies, logger } = options;
+
+  const missing = getMissingDependencies(dependencies);
+
+  if (_.isEmpty(missing)) {
+    return callback(null);
+  }
+
+  logger.warn(
+    format(strings.messages.cli.INSTALLING_DEPS, missing.join(', ')),
+    true
+  );
+
+  const npmOptions = {
+    dependencies: missing,
+    installPath: path.resolve('.'),
+    save: false,
+    silent: true
+  };
+
+  npm.installDependencies(npmOptions, err => {
+    if (err || !_.isEmpty(getMissingDependencies(dependencies))) {
+      logger.fail('FAIL');
+      return callback(strings.errors.cli.DEPENDENCIES_INSTALL_FAIL);
+    }
+    logger.ok('OK');
+    callback(null);
+  });
+};

src/cli/domain/handle-dependencies/is-template-legacy.js

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = template => !!{ jade: true, handlebars: true }[template];

src/cli/domain/handle-dependencies/require-template.js

@@ -0,0 +1,51 @@
+'use strict';
+
+const format = require('stringformat');
+const path = require('path');
+
+const cleanRequire = require('../../../utils/clean-require');
+const isTemplateLegacy = require('./is-template-legacy');
+const isTemplateValid = require('../../../utils/is-template-valid');
+const strings = require('../../../resources');
+
+module.exports = function(template, options) {
+  const requireOptions = options || {};
+  let ocTemplate;
+
+  if (isTemplateLegacy(template)) {
+    template = `oc-template-${template}`;
+  }
+
+  if (requireOptions.compiler) {
+    template = `${template}-compiler`;
+  }
+
+  const localTemplate = path.join(__dirname, '../../node_modules', template);
+  const relativeTemplate = path.resolve('.', 'node_modules', template);
+  const componentRelativePath = path.join(
+    requireOptions.componentPath,
+    'node_modules',
+    template
+  );
+
+  [
+    componentRelativePath,
+    template,
+    localTemplate,
+    relativeTemplate
+  ].forEach(pathToTry => {
+    ocTemplate = ocTemplate || cleanRequire(pathToTry, { justTry: true });
+  });
+
+  if (!ocTemplate) {
+    throw new Error(format(strings.errors.cli.TEMPLATE_NOT_FOUND, template));
+  }
+
+  if (!isTemplateValid(ocTemplate, requireOptions)) {
+    throw new Error(
+      format(strings.errors.cli.TEMPLATE_TYPE_NOT_VALID, template)
+    );
+  }
+
+  return ocTemplate;
+};