Merge branch 'dev' of github.com:MitocGroup/deepify into dev

Author: mgoria

.gitignore

@@ -88,7 +88,6 @@ lib-cov
 # Coverage directory used by tools like istanbul
 coverage
 coverages
-compile
 
 # Grunt intermediate storage (http://gruntjs.com/creating-plugins#storing-task-files)
 .grunt

.travis.yml

@@ -3,7 +3,7 @@ sudo: false
 node_js:
   - '4.3'
   - '6.10'
-  - '7.7'
+  - '7.8'
 cache:
   edge: true
   directories:

src/bin/commands/bin/compile-es6.sh

@@ -7,33 +7,52 @@
 
 module.exports = function(mainPath) {
   let path = require('path');
+  let esPreset = require('./helper/es-preset');
   let Exec = require('../../../lib.compiled/Helpers/Exec').Exec;
 
   mainPath = this.normalizeInputPath(mainPath);
   let extension = this.opts.locate('extension').value || '.es6';
   let outDirectory = this.opts.locate('out-dir').value || mainPath;
-  let compileEs5 = this.opts.locate('es5').exists;
+  let compileES5 = this.opts.locate('es5').exists;
   let pipeSource = this.opts.locate('source').exists;
   let nodeModules = path.join(__dirname, '../../../node_modules');
 
   let babelCompileCommand = () => {
     let babelCmd = path.join(nodeModules, 'babel-cli/bin/babel.js');
-    let presets = [path.join(nodeModules, `babel-preset-es2015${ compileEs5 ? '' : '-node4' }`)];
-    let plugins = [
-      path.join(nodeModules, 'babel-plugin-transform-es2015-classes'),
-      path.join(nodeModules, 'babel-plugin-add-module-exports'),
-    ];
+    let presets = [];
+    let babelES6Preset = null;
+    let plugins = [ path.join(nodeModules, 'babel-plugin-add-module-exports') ];
+    
+    if (compileES5) {
+      presets.push(path.join(nodeModules, 'babel-preset-es2015'));
+    } else {
+      babelES6Preset =  esPreset();
+      
+      presets.push(path.join(nodeModules, babelES6Preset));
+    }
+    
+    if (compileES5 || babelES6Preset === 'babel-preset-es2015-node4') {
+      plugins.push(path.join(nodeModules, 'babel-plugin-transform-es2015-classes'));
+    }
 
     let compileCmd = new Exec(
       this.nodeBinary,
       babelCmd,
       mainPath
     );
 
-    compileCmd
-      .addArg(`--extensions=${extension}`)
-      .addArg(`--presets=${presets.join(',')}`)
-      .addArg(`--plugins=${plugins.join(',')}`);
+    console.log(`Plugins: ${plugins.map(p => path.basename(p)).join(', ')}`);
+    console.log(`Presets: ${presets.map(p => path.basename(p)).join(', ')}`);
+
+    compileCmd.addArg(`--extensions=${extension}`);
+    
+    if (presets.length > 0) {
+      compileCmd.addArg(`--presets=${presets.join(',')}`);
+    }
+      
+    if (plugins.length > 0) {
+      compileCmd.addArg(`--plugins=${plugins.join(',')}`);
+    }
 
     if (!pipeSource) {
       compileCmd.addArg(`--out-dir=${outDirectory}`);

src/bin/commands/compile/es6.js

@@ -0,0 +1,121 @@
+/**
+ * Created by AlexanderC on 8/4/15.
+ */
+
+'use strict';
+
+const NpmChain = require('../../../../lib.compiled/NodeJS/NpmChain').NpmChain;
+const Hash = require('deep-package-manager').Helpers_Hash;
+const helpers = require('./compile-prod');
+const tmp = require('tmp');
+const path = require('path');
+const webpackConfig = require('./webpack.prod');
+const fse = require('fs-extra');
+const pify = require('pify');
+
+module.exports = function (lambdaPath, debug, purge, libsToLink) {
+  const dry = debug ? '[DRY] ' : '';
+  
+  console.log(`Compiling lambda "${lambdaPath}" (purge=${purge ? 'true' : 'false'})`);
+  console.debug(`${dry}Purge "node_modules" in "${lambdaPath}"`);
+  
+  const prepare = (purge && !debug)
+    ? pify(fse.remove)(path.join(lambdaPath, 'node_modules'))
+    : Promise.resolve();
+  
+  return prepare
+    .then(() => {
+      if (libsToLink.length <= 0) {
+        console.debug(`No global libraries available to link for "${lambdaPath}"`);
+        
+        return Promise.resolve();
+      }
+      
+      console.debug(`${dry}Linking global libraries in "${lambdaPath}" (${libsToLink.join(', ')})`);
+      
+      return Promise.all(libsToLink.map(lib => {
+        return helpers.hasDependency(lambdaPath, lib)
+          .then(hasLib => {
+            if (!hasLib) {
+              console.debug(`Skip linking extraneous library "${lib}" in "${lambdaPath}"`);
+            }
+            
+            return Promise.resolve(hasLib);
+          });
+      })).then(libsVector => {
+        const libs = libsToLink.filter((lib, i) => {
+          return libsVector[i];
+        });
+        
+        if (libs.length <= 0) {
+          return Promise.resolve();
+        }
+        
+        return helpers.npmLink(lambdaPath, libs, debug);
+      });
+    })
+    .then(() => {
+      console.debug(`${dry}Running "npm install" on "${lambdaPath}"`);
+      
+      return helpers.npmInstall(lambdaPath, debug);
+    })
+    .then(() => {
+      const buildPath = path.join(
+        tmp.dirSync().name,
+        `${Hash.md5(lambdaPath)}_${new Date().getTime()}`
+      );
+      const configFile = path.join(buildPath, 'webpack.prod.js');
+      const bundlePath = path.join(buildPath, 'bundle');
+
+      console.debug(`Ensure working env in "${buildPath}"`);
+      
+      return pify(fse.ensureDir)(bundlePath)
+        .then(() => {
+          return webpackConfig(lambdaPath, bundlePath, libsToLink, debug)
+            .then(webpackConfig => {
+              const { rawConfig, tmpBootstrapJs } = webpackConfig;
+              
+              return pify(fse.outputFile)(configFile, rawConfig)
+                .then(() => Promise.resolve(tmpBootstrapJs));
+            });
+        })
+        .then(tmpBootstrapJs => {
+          console.debug(`Bundle "${lambdaPath}" using Webpack to "${bundlePath}"`);
+          
+          const removeTmpBootstrap = () => {
+            console.debug(`Removing temporary bootstrap file "${tmpBootstrapJs}"`);
+
+            return pify(fse.remove)(tmpBootstrapJs)
+              .catch(() => Promise.resolve());
+          };
+          
+          return helpers.bundle(configFile, debug)
+            .then(() => removeTmpBootstrap())
+            .catch(error => {
+              return removeTmpBootstrap()
+                .then(() => Promise.reject(error));
+            });
+        })
+        .then(() => Promise.resolve({ bundlePath, buildPath }));
+    })
+    .then(result => {
+      const { bundlePath, buildPath } = result;
+      const bundleDestination = path.join(
+        lambdaPath, 
+        '..', 
+        `${path.basename(lambdaPath)}.zip`
+      );
+      
+      console.info(`Archive "${lambdaPath}" build to "${bundleDestination}"`);
+      
+      return pify(fse.remove)(bundleDestination)
+        .catch(() => Promise.resolve())
+        .then(() => helpers.zip(bundlePath, bundleDestination))
+        .then(() => Promise.resolve(buildPath));
+    })
+    .then(buildPath => {
+      console.debug(`Cleanup temporary data for "${lambdaPath}"`);
+      
+      return pify(fse.remove)(buildPath);
+    });
+};