jaredhanson/bootable

/**
 * Module dependencies.
 */
var path = require('path')
  , fs = require('fs')
  , existsSync = fs.existsSync || path.existsSync // node <=0.6
  , debug = require('debug')('bootable');


/**
 * Initializer execution phase.
 *
 * This phase will execute all initializer scripts in a directory, allowing the
 * application to initialize modules, including connecting to databases and
 * other network services.
 *
 * Examples:
 *
 *   app.phase(bootable.initializers());
 *
 *   app.phase(bootable.initializers('config/initializers'));
 *
 * @param {String|Object} options
 * @return {Function}
 * @api public
 */
module.exports = function(options) {
  if ('string' == typeof options) {
    options = { dirname: options };
  }
  options = options || {};
  var dirname = options.dirname || 'etc/init'
    , extensions = options.extensions || Object.keys(require.extensions).map(function(ext) { return ext; })
    , exts = extensions.map(function(ext) {
        if ('.' != ext[0]) { return ext; }
        return ext.slice(1);
      })
    , regex = new RegExp('\\.(' + exts.join('|') + ')$');
  
  return function initializers(done) {
    var dir = path.resolve(dirname);
    if (!existsSync(dir)) { return done(); }
    
    var self = this
      , files = fs.readdirSync(dir).sort()
      , idx = 0;
    function next(err) {
      if (err) { return done(err); }
    
      var file = files[idx++];
      // all done
      if (!file) { return done(); }
    
      if (regex.test(file)) {
        try {
          debug('initializer %s', file);
          var mod = require(path.join(dir, file));
          if (typeof mod == 'function') {
            var arity = mod.length;
            if (arity == 1) {
              // Async initializer.  Exported function will be invoked, with next
              // being called when the initializer finishes.
              mod.call(self, next);
            } else {
              // Sync initializer.  Exported function will be invoked, with next
              // being called immediately.
              mod.call(self);
              next();
            }
          } else {
            // Initializer does not export a function.  Requiring the initializer
            // is sufficient to invoke it, next immediately.
            next();
          }
        } catch (ex) {
          next(ex);
        }
      } else {
        next();
      }
    }
    next();
  };
};