add getResourceDirectories as a build hook

 - copied from devkit-core
 - build hooks now return all responses and which module they came from
 - build hooks now accept hooks returning promises rather than calling a
   callback
 - fix bug returning build result from buildQueue

Author: Martin Hunt

src/build/DirectoryBuilder.js

@@ -0,0 +1,41 @@
+var path = require('path');
+var fs = require('fs');
+var logger = require('../util/logging').get('build-directories');
+
+// class for representing a list of resource directories
+function DirectoryBuilder(base) {
+  this._base = base;
+  this._directories = [];
+}
+
+DirectoryBuilder.prototype.add = function (src, target) {
+  var directory;
+  if (arguments.length === 1) {
+    directory = {
+        src: path.join(this._base, src),
+        target: src
+      };
+  } else {
+    directory = {
+        src: src,
+        target: target
+      };
+  }
+
+  if (fs.existsSync(directory.src)) {
+    this._directories.push(directory);
+  } else {
+    logger.warn('Directory does not exist, ignoring files from',
+                      directory);
+  }
+};
+
+DirectoryBuilder.prototype.getPaths = function () {
+  return this._directories.map(function (dir) { return dir.src; });
+};
+
+DirectoryBuilder.prototype.getDirectories = function () {
+  return this._directories;
+};
+
+module.exports = DirectoryBuilder;

src/build/index.js

@@ -55,15 +55,31 @@ exports.build = function (appPath, argv, cb) {
     require('./steps/createDirectories').createDirectories(app, config, f());
   }, function () {
     require('./steps/buildHooks').getDependencies(app, config, f());
-  }, function (deps) {
-    // deps is an array of objects, merge them into one object and get all keys with false values
-    deps = merge.apply(this, deps);
-    var toRemove = Object.keys(deps).filter(function (name) { return deps[name] === false; });
-    app.removeModules(toRemove);
+  }, function (res) {
+    var modules = res.reduce(function (modules, res) {
+      var toRemove = Object.keys(res.data)
+        .filter(function (name) {
+          return res.data[name] === false;
+        });
+
+      if (toRemove.length) {
+        logger.log('module', res.module.name, 'getDependencies:');
+        toRemove.forEach(function (module) {
+          logger.log('  removing module', module);
+        });
+      }
+      return modules.concat(toRemove);
+    }, []);
+
+    app.removeModules(modules);
   }, function () {
     require('./steps/addDebugCode')(app, config, f());
   }, function () {
     require('./steps/moduleConfig').getConfig(app, config, f());
+  }, function () {
+    require('./steps/buildHooks').getResourceDirectories(app, config, f());
+  }, function (directories) {
+    config.directories = directories;
   }, function () {
     require('./steps/buildHooks').onBeforeBuild(app, config, f());
   }, function () {

src/build/steps/buildHooks.js

@@ -1,32 +1,94 @@
-var ff = require('ff');
+var path = require('path');
 var Promise = require('bluebird');
 var api = require('../../api');
+var DirectoryBuilder = require('../DirectoryBuilder');
+var fs = require('fs');
+
+var readDir = Promise.promisify(fs.readdir);
+var stat = Promise.promisify(fs.stat);
 
 exports.getDependencies = function (app, config, cb) {
   app.reloadModules();
 
   // allows modules to disable other modules
-  executeHook('getDependencies', app, config, cb);
-}
+  executeHook('getDependencies', app, config)
+    .nodeify(cb);
+};
 
 exports.onBeforeBuild = function (app, config, cb) {
-  executeHook('onBeforeBuild', app, config, cb);
-}
+  executeHook('onBeforeBuild', app, config)
+    .nodeify(cb);
+};
 
 exports.onAfterBuild = function (app, config, cb) {
-  executeHook('onAfterBuild', app, config, cb);
-}
+  executeHook('onAfterBuild', app, config)
+    .nodeify(cb);
+};
+
+exports.getResourceDirectories = function (app, config, cb) {
+  var builder = new DirectoryBuilder(app.paths.root);
+  builder.add('resources');
+  executeHook('getResourceDirectories', app, config)
+    .map(function (res) {
+      var module = res.module;
+      var directories = res.data;
+      directories.forEach(function (directory) {
+        var target = path.join('modules', module.name, directory.target);
+        builder.add(directory.src, target);
+      });
+      console.log(res);
+    })
+    .then(function () {
+      // add any localized resource directories
+      return readDir(app.paths.root);
+    })
+    .filter(function (filename) {
+      if (/^resources-/.test(filename)) {
+        return stat(path.join(app.paths.root, filename)).then(function (info) {
+          return info.isDirectory();
+        }, function onStatFail() {
+          return false;
+        });
+      }
+
+      return false;
+    })
+    .map(function (filename) {
+      builder.add(filename);
+    })
+    .then(function () {
+      return builder.getDirectories();
+    })
+    .nodeify(cb);
+};
 
-function executeHook(buildHook, app, config, cb) {
+function executeHook(buildHook, app, config) {
   var modules = app.getModules();
 
-  Promise.all(Object.keys(modules).map(function (moduleName) {
-    var module = modules[moduleName];
-    var buildExtension = module.loadExtension('build');
-    if (!buildExtension || !buildExtension[buildHook]) {
-      return;
-    }
+  return Promise.resolve(Object.keys(modules))
+    .map(function (moduleName) {
+      var module = modules[moduleName];
+      var buildExtension = module.loadExtension('build');
+      if (!buildExtension || !buildExtension[buildHook]) {
+        return;
+      }
+      return new Promise(function (resolve, reject) {
+          var retVal = buildExtension[buildHook](api, app.toJSON(), config, function (err, res) {
+            if (err) {
+              reject(err);
+            } else {
+              resolve(res);
+            }
+          });
 
-    return Promise.fromNode(buildExtension[buildHook].bind(buildExtension, api, app.toJSON(), config));
-  })).nodeify(cb);
+          if (retVal) { resolve(retVal); }
+        })
+        .then(function (data) {
+          return {
+            module: module,
+            data: data
+          };
+        });
+    })
+    .filter(function (res) { return res; });
 }

src/build/steps/executeTargetBuild.js

@@ -12,7 +12,6 @@ exports.build = function (app, config, cb) {
   }
 
   moduleKeys.forEach(function (moduleName) {
-    console.log(moduleName)
     if (!buildModule) {
       var module = modules[moduleName];
       buildModule = module.loadBuildTarget(config.target);

src/serve/appRoutes.js

@@ -52,7 +52,7 @@ exports.addToAPI = function (opts, api) {
     }
 
     buildFromRequest(opts)
-      .then(function (mountInfo) {
+      .spread(function (mountInfo, buildResult) {
         res.json(mountInfo);
       })
       .catch(function (e) {
@@ -82,9 +82,10 @@ exports.addToAPI = function (opts, api) {
           output: mountInfo.buildPath
         };
 
-        return buildQueue
-          .add(mountInfo.appPath, buildOpts)
-          .return(mountInfo);
+        return buildQueue.add(mountInfo.appPath, buildOpts)
+          .then(function (buildResult) {
+            return [mountInfo, buildResult];
+          });
       });
   }
 

src/serve/buildQueue.js

@@ -107,7 +107,7 @@ var BuildItem = Class(function () {
       this.error = msg.err;
       this._reject(this.error);
     } else {
-      this._resolve();
+      this._resolve(msg.res);
     }
 
     checkQueue();