updated package.json

node_modules/nconf/lib/nconf.js

@@ -0,0 +1,40 @@
+/*
+ * nconf.js: Top-level include for the nconf module
+ *
+ * (C) 2011, Nodejitsu Inc.
+ *
+ */
+
+var fs = require('fs'),
+    async = require('async'),
+    common = require('./nconf/common'),
+    Provider = require('./nconf/provider').Provider,
+    nconf = module.exports = new Provider();
+
+//
+// Expose the version from the package.json
+//
+nconf.version = require('../package.json').version;
+
+//
+// Setup all stores as lazy-loaded getters.
+//
+fs.readdirSync(__dirname + '/nconf/stores').forEach(function (file) {
+  var store = file.replace('.js', ''),
+      name  = common.capitalize(store);
+
+  nconf.__defineGetter__(name, function () {
+    return require('./nconf/stores/' + store)[name];
+  });
+});
+
+//
+// Expose the various components included with nconf
+//
+nconf.key           = common.key;
+nconf.path          = common.path;
+nconf.loadFiles     = common.loadFiles;
+nconf.loadFilesSync = common.loadFilesSync;
+nconf.formats       = require('./nconf/formats');
+nconf.Provider      = Provider;
+

node_modules/nconf/lib/nconf/common.js

@@ -0,0 +1,113 @@
+/*
+ * utils.js: Utility functions for the nconf module.
+ *
+ * (C) 2011, Nodejitsu Inc.
+ *
+ */
+
+var fs = require('fs'),
+    async = require('async'),
+    formats = require('./formats'),
+    Memory = require('./stores/memory').Memory;
+
+var common = exports;
+
+//
+// ### function path (key)
+// #### @key {string} The ':' delimited key to split
+// Returns a fully-qualified path to a nested nconf key.
+// If given null or undefined it should return an empty path.
+// '' should still be respected as a path.
+//
+common.path = function (key) {
+  return key == null ? [] : key.split(':');
+};
+
+//
+// ### function key (arguments)
+// Returns a `:` joined string from the `arguments`.
+//
+common.key = function () {
+  return Array.prototype.slice.call(arguments).join(':');
+};
+
+//
+// ### function loadFiles (files, callback)
+// #### @files {Object|Array} List of files (or settings object) to load.
+// #### @callback {function} Continuation to respond to when complete.
+// Loads all the data in the specified `files`.
+//
+common.loadFiles = function (files, callback) {
+  if (!files) {
+    return callback(null, {});
+  }
+
+  var options = Array.isArray(files) ? { files: files } : files;
+
+  //
+  // Set the default JSON format if not already
+  // specified
+  //
+  options.format = options.format || formats.json;
+
+  function parseFile (file, next) {
+    fs.readFile(file, function (err, data) {
+      return !err
+        ? next(null, options.format.parse(data.toString()))
+        : next(err);
+    });
+  }
+
+  async.map(options.files, parseFile, function (err, objs) {
+    return err ? callback(err) : callback(null, common.merge(objs));
+  });
+};
+
+//
+// ### function loadFilesSync (files)
+// #### @files {Object|Array} List of files (or settings object) to load.
+// Loads all the data in the specified `files` synchronously.
+//
+common.loadFilesSync = function (files) {
+  if (!files) {
+    return;
+  }
+
+  //
+  // Set the default JSON format if not already
+  // specified
+  //
+  var options = Array.isArray(files) ? { files: files } : files;
+  options.format = options.format || formats.json;
+
+  return common.merge(options.files.map(function (file) {
+    return options.format.parse(fs.readFileSync(file, 'utf8'));
+  }));
+};
+
+//
+// ### function merge (objs)
+// #### @objs {Array} Array of object literals to merge
+// Merges the specified `objs` using a temporary instance
+// of `stores.Memory`.
+//
+common.merge = function (objs) {
+  var store = new Memory();
+
+  objs.forEach(function (obj) {
+    Object.keys(obj).forEach(function (key) {
+      store.merge(key, obj[key]);
+    });
+  });
+
+  return store.store;
+};
+
+//
+// ### function capitalize (str)
+// #### @str {string} String to capitalize
+// Capitalizes the specified `str`.
+//
+common.capitalize = function (str) {
+  return str && str[0].toUpperCase() + str.slice(1);
+};

node_modules/nconf/lib/nconf/formats.js

@@ -0,0 +1,28 @@
+/*
+ * formats.js: Default formats supported by nconf
+ *
+ * (C) 2011, Nodejitsu Inc.
+ *
+ */
+
+var ini = require('ini');
+
+var formats = exports;
+
+//
+// ### @json
+// Standard JSON format which pretty prints `.stringify()`.
+//
+formats.json = {
+  stringify: function (obj, replacer, spacing) {
+    return JSON.stringify(obj, replacer || null, spacing || 2)
+  },
+  parse: JSON.parse
+};
+
+//
+// ### @ini
+// Standard INI format supplied from the `ini` module
+// http://en.wikipedia.org/wiki/INI_file
+//
+formats.ini = ini;

node_modules/nconf/lib/nconf/provider.js

@@ -0,0 +1,565 @@
+/*
+ * provider.js: Abstraction providing an interface into pluggable configuration storage.
+ *
+ * (C) 2011, Nodejitsu Inc.
+ *
+ */
+
+var async = require('async'),
+    common = require('./common');
+
+//
+// ### function Provider (options)
+// #### @options {Object} Options for this instance.
+// Constructor function for the Provider object responsible
+// for exposing the pluggable storage features of `nconf`.
+//
+var Provider = exports.Provider = function (options) {
+  //
+  // Setup default options for working with `stores`,
+  // `overrides`, `process.env` and `process.argv`.
+  //
+  options       = options || {};
+  this.stores  = {};
+  this.sources = [];
+  this.init(options);
+};
+
+//
+// Define wrapper functions for using basic stores
+// in this instance
+//
+['argv', 'env'].forEach(function (type) {
+  Provider.prototype[type] = function (options) {
+    return this.add(type, options);
+  };
+});
+
+//
+// ### function file (key, options)
+// #### @key {string|Object} Fully qualified options, name of file store, or path.
+// #### @path {string|Object} **Optional** Full qualified options, or path.
+// Adds a new `File` store to this instance. Accepts the following options
+//
+//    nconf.file({ file: '.jitsuconf', dir: process.env.HOME, search: true });
+//    nconf.file('path/to/config/file');
+//    nconf.file('userconfig', 'path/to/config/file');
+//    nconf.file('userconfig', { file: '.jitsuconf', search: true });
+//
+Provider.prototype.file = function (key, options) {
+  if (arguments.length == 1) {
+    options = typeof key === 'string' ? { file: key } : key;
+    key = 'file';
+  }
+  else {
+    options = typeof options === 'string'
+      ? { file: options }
+      : options;
+  }
+  
+  options.type = 'file';
+  return this.add(key, options);
+};
+
+//
+// Define wrapper functions for using 
+// overrides and defaults
+//
+['defaults', 'overrides'].forEach(function (type) {
+  Provider.prototype[type] = function (options) {
+    options = options || {};
+    if (!options.type) {
+      options.type = 'literal';
+    }
+
+    return this.add(type, options);
+  };
+});
+
+//
+// ### function use (name, options)
+// #### @type {string} Type of the nconf store to use.
+// #### @options {Object} Options for the store instance.
+// Adds (or replaces) a new store with the specified `name`
+// and `options`. If `options.type` is not set, then `name`
+// will be used instead:
+//
+//    provider.use('file');
+//    provider.use('file', { type: 'file', filename: '/path/to/userconf' })
+//
+Provider.prototype.use = function (name, options) {
+  options  = options      || {};
+  var type = options.type || name;
+
+  function sameOptions (store) {
+    return Object.keys(options).every(function (key) {
+      return options[key] === store[key];
+    });
+  }
+
+  var store = this.stores[name],
+      update = store && !sameOptions(store);
+
+  if (!store || update) {
+    if (update) {
+      this.remove(name);
+    }
+
+    this.add(name, options);
+  }
+
+  return this;
+};
+
+//
+// ### function add (name, options)
+// #### @name {string} Name of the store to add to this instance
+// #### @options {Object} Options for the store to create
+// Adds a new store with the specified `name` and `options`. If `options.type`
+// is not set, then `name` will be used instead:
+//
+//    provider.add('memory');
+//    provider.add('userconf', { type: 'file', filename: '/path/to/userconf' })
+//
+Provider.prototype.add = function (name, options) {
+  options  = options      || {};
+  var type = options.type || name;
+
+  if (!require('../nconf')[common.capitalize(type)]) {
+    throw new Error('Cannot add store with unknown type: ' + type);
+  }
+
+  this.stores[name] = this.create(type, options);
+
+  if (this.stores[name].loadSync) {
+    this.stores[name].loadSync();
+  }
+
+  return this;
+};
+
+//
+// ### function remove (name)
+// #### @name {string} Name of the store to remove from this instance
+// Removes a store with the specified `name` from this instance. Users
+// are allowed to pass in a type argument (e.g. `memory`) as name if
+// this was used in the call to `.add()`.
+//
+Provider.prototype.remove = function (name) {
+  delete this.stores[name];
+  return this;
+};
+
+//
+// ### function create (type, options)
+// #### @type {string} Type of the nconf store to use.
+// #### @options {Object} Options for the store instance.
+// Creates a store of the specified `type` using the
+// specified `options`.
+//
+Provider.prototype.create = function (type, options) {
+  return new (require('../nconf')[common.capitalize(type.toLowerCase())])(options);
+};
+
+//
+// ### function init (options)
+// #### @options {Object} Options to initialize this instance with.
+// Initializes this instance with additional `stores` or `sources` in the
+// `options` supplied.
+//
+Provider.prototype.init = function (options) {
+  var self = this;
+
+  //
+  // Add any stores passed in through the options
+  // to this instance.
+  //
+  if (options.type) {
+    this.add(options.type, options);
+  }
+  else if (options.store) {
+    this.add(options.store.name || options.store.type, options.store);
+  }
+  else if (options.stores) {
+    Object.keys(options.stores).forEach(function (name) {
+      var store = options.stores[name];
+      self.add(store.name || name || store.type, store);
+    });
+  }
+
+  //
+  // Add any read-only sources to this instance
+  //
+  if (options.source) {
+    this.sources.push(this.create(options.source.type || options.source.name, options.source));
+  }
+  else if (options.sources) {
+    Object.keys(options.sources).forEach(function (name) {
+      var source = options.sources[name];
+      self.sources.push(self.create(source.type || source.name || name, source));
+    });
+  }
+};
+
+//
+// ### function get (key, callback)
+// #### @key {string} Key to retrieve for this instance.
+// #### @callback {function} **Optional** Continuation to respond to when complete.
+// Retrieves the value for the specified key (if any).
+//
+Provider.prototype.get = function (key, callback) {
+  //
+  // If there is no callback we can short-circuit into the default
+  // logic for traversing stores.
+  //
+  if (!callback) {
+    return this._execute('get', 1, key, callback);
+  }
+
+  //
+  // Otherwise the asynchronous, hierarchical `get` is
+  // slightly more complicated because we do not need to traverse
+  // the entire set of stores, but up until there is a defined value.
+  //
+  var current = 0,
+      names = Object.keys(this.stores),
+      self = this,
+      response,
+      mergeObjs = [];
+
+  async.whilst(function () {
+    return typeof response === 'undefined' && current < names.length;
+  }, function (next) {
+    var store = self.stores[names[current]];
+    current++;
+
+    if (store.get.length >= 2) {
+      return store.get(key, function (err, value) {
+        if (err) {
+          return next(err);
+        }
+
+        response = value;
+
+        // Merge objects if necessary
+        if (typeof response === 'object' && !Array.isArray(response)) {
+          mergeObjs.push(response);
+          response = undefined;
+        }
+
+        next();
+      });
+    }
+
+    response = store.get(key);
+
+    // Merge objects if necessary
+    if (typeof response === 'object' && !Array.isArray(response)) {
+      mergeObjs.push(response);
+      response = undefined;
+    }
+
+    next();
+  }, function (err) {
+    if (!err && mergeObjs.length) {
+      response = common.merge(mergeObjs.reverse());
+    }
+    return err ? callback(err) : callback(null, response);
+  });
+};
+
+//
+// ### function set (key, value, callback)
+// #### @key {string} Key to set in this instance
+// #### @value {literal|Object} Value for the specified key
+// #### @callback {function} **Optional** Continuation to respond to when complete.
+// Sets the `value` for the specified `key` in this instance.
+//
+Provider.prototype.set = function (key, value, callback) {
+  return this._execute('set', 2, key, value, callback);
+};
+
+//
+// ### function reset (callback)
+// #### @callback {function} **Optional** Continuation to respond to when complete.
+// Clears all keys associated with this instance.
+//
+Provider.prototype.reset = function (callback) {
+  return this._execute('reset', 0, callback);
+};
+
+//
+// ### function clear (key, callback)
+// #### @key {string} Key to remove from this instance
+// #### @callback {function} **Optional** Continuation to respond to when complete.
+// Removes the value for the specified `key` from this instance.
+//
+Provider.prototype.clear = function (key, callback) {
+  return this._execute('clear', 1, key, callback);
+};
+
+//
+// ### function merge ([key,] value [, callback])
+// #### @key {string} Key to merge the value into
+// #### @value {literal|Object} Value to merge into the key
+// #### @callback {function} **Optional** Continuation to respond to when complete.
+// Merges the properties in `value` into the existing object value at `key`.
+//
+// 1. If the existing value `key` is not an Object, it will be completely overwritten.
+// 2. If `key` is not supplied, then the `value` will be merged into the root.
+//
+Provider.prototype.merge = function () {
+  var self = this,
+      args = Array.prototype.slice.call(arguments),
+      callback = typeof args[args.length - 1] === 'function' && args.pop(),
+      value = args.pop(),
+      key = args.pop();
+
+  function mergeProperty (prop, next) {
+    return self._execute('merge', 2, prop, value[prop], next);
+  }
+
+  if (!key) {
+    if (Array.isArray(value) || typeof value !== 'object') {
+      return onError(new Error('Cannot merge non-Object into top-level.'), callback);
+    }
+
+    return async.forEach(Object.keys(value), mergeProperty, callback || function () { })
+  }
+
+  return this._execute('merge', 2, key, value, callback);
+};
+
+//
+// ### function load (callback)
+// #### @callback {function} Continuation to respond to when complete.
+// Responds with an Object representing all keys associated in this instance.
+//
+Provider.prototype.load = function (callback) {
+  var self = this;
+
+  function getStores () {
+    var stores = Object.keys(self.stores);
+    stores.reverse();
+    return stores.map(function (name) {
+      return self.stores[name];
+    });
+  }
+
+  function loadStoreSync(store) {
+    if (!store.loadSync) {
+      throw new Error('nconf store ' + store.type + ' has no loadSync() method');
+    }
+
+    return store.loadSync();
+  }
+
+  function loadStore(store, next) {
+    if (!store.load && !store.loadSync) {
+      return next(new Error('nconf store ' + store.type + ' has no load() method'));
+    }
+
+    return store.loadSync
+      ? next(null, store.loadSync())
+      : store.load(next);
+  }
+
+  function loadBatch (targets, done) {
+    if (!done) {
+      return common.merge(targets.map(loadStoreSync));
+    }
+
+    async.map(targets, loadStore, function (err, objs) {
+      return err ? done(err) : done(null, common.merge(objs));
+    });
+  }
+
+  function mergeSources (data) {
+    //
+    // If `data` was returned then merge it into
+    // the system store.
+    //
+    if (data && typeof data === 'object') {
+      self.use('sources', {
+        type: 'literal',
+        store: data
+      });
+    }
+  }
+
+  function loadSources () {
+    var sourceHierarchy = self.sources.splice(0);
+    sourceHierarchy.reverse();
+
+    //
+    // If we don't have a callback and the current
+    // store is capable of loading synchronously
+    // then do so.
+    //
+    if (!callback) {
+      mergeSources(loadBatch(sourceHierarchy));
+      return loadBatch(getStores());
+    }
+
+    loadBatch(sourceHierarchy, function (err, data) {
+      if (err) {
+        return callback(err);
+      }
+
+      mergeSources(data);
+      return loadBatch(getStores(), callback);
+    });
+  }
+
+  return self.sources.length
+    ? loadSources()
+    : loadBatch(getStores(), callback);
+};
+
+//
+// ### function save (callback)
+// #### @callback {function} **optional**  Continuation to respond to when 
+// complete.
+// Instructs each provider to save.  If a callback is provided, we will attempt
+// asynchronous saves on the providers, falling back to synchronous saves if
+// this isn't possible.  If a provider does not know how to save, it will be
+// ignored.  Returns an object consisting of all of the data which was
+// actually saved.
+//
+Provider.prototype.save = function (value, callback) {
+  if (!callback && typeof value === 'function') {
+    callback = value;
+    value = null;
+  }
+
+  var self = this,
+      names = Object.keys(this.stores);
+
+  function saveStoreSync(memo, name) {
+    var store = self.stores[name];
+
+    //
+    // If the `store` doesn't have a `saveSync` method,
+    // just ignore it and continue.
+    //
+    if (store.saveSync) {
+      var ret = store.saveSync();
+      if (typeof ret == 'object' && ret !== null) {
+        memo.push(ret);
+      }
+    }
+    return memo;
+  }
+
+  function saveStore(memo, name, next) {
+    var store = self.stores[name];
+
+    //
+    // If the `store` doesn't have a `save` or saveSync`
+    // method(s), just ignore it and continue.
+    //
+
+    if (store.save) {
+      return store.save(function (err, data) {
+        if (err) {
+          return next(err);
+        }
+        
+        if (typeof data == 'object' && data !== null) {
+          memo.push(data);
+        }
+        
+        next(null, memo);
+      });
+    } 
+    else if (store.saveSync) {
+      memo.push(store.saveSync());
+    }
+    
+    next(null, memo);
+  }
+
+  //
+  // If we don't have a callback and the current
+  // store is capable of saving synchronously
+  // then do so.
+  //
+  if (!callback) {
+    return common.merge(names.reduce(saveStoreSync, []));
+  }
+
+  async.reduce(names, [], saveStore, function (err, objs) {
+    return err ? callback(err) : callback(null, common.merge(objs));
+  });
+};
+
+//
+// ### @private function _execute (action, syncLength, [arguments])
+// #### @action {string} Action to execute on `this.store`.
+// #### @syncLength {number} Function length of the sync version.
+// #### @arguments {Array} Arguments array to apply to the action
+// Executes the specified `action` on all stores for this instance, ensuring a callback supplied
+// to a synchronous store function is still invoked.
+//
+Provider.prototype._execute = function (action, syncLength /* [arguments] */) {
+  var args = Array.prototype.slice.call(arguments, 2),
+      callback = typeof args[args.length - 1] === 'function' && args.pop(),
+      destructive = ['set', 'clear', 'merge', 'reset'].indexOf(action) !== -1,
+      self = this,
+      response,
+      mergeObjs = [];
+
+  function runAction (name, next) {
+    var store = self.stores[name];
+
+    if (destructive && store.readOnly) {
+      return next();
+    }
+
+    return store[action].length > syncLength
+      ? store[action].apply(store, args.concat(next))
+      : next(null, store[action].apply(store, args));
+  }
+
+  if (callback) {
+    return async.forEach(Object.keys(this.stores), runAction, function (err) {
+      return err ? callback(err) : callback();
+    });
+  }
+
+
+  Object.keys(this.stores).forEach(function (name) {
+    if (typeof response === 'undefined') {
+      var store = self.stores[name];
+
+      if (destructive && store.readOnly) {
+        return;
+      }
+
+      response = store[action].apply(store, args);
+
+      // Merge objects if necessary
+      if (response && action === 'get' && typeof response === 'object' && !Array.isArray(response)) {
+        mergeObjs.push(response);
+        response = undefined;
+      }
+    }
+  });
+
+  if (mergeObjs.length) {
+    response = common.merge(mergeObjs.reverse());
+  }
+
+  return response;
+}
+
+//
+// Throw the `err` if a callback is not supplied
+//
+function onError(err, callback) {
+  if (callback) {
+    return callback(err);
+  }
+
+  throw err;
+}

node_modules/nconf/lib/nconf/stores/argv.js

@@ -0,0 +1,61 @@
+/*
+ * argv.js: Simple memory-based store for command-line arguments.
+ *
+ * (C) 2011, Nodejitsu Inc.
+ *
+ */
+
+var util = require('util'),
+    Memory = require('./memory').Memory;
+
+//
+// ### function Argv (options)
+// #### @options {Object} Options for this instance.
+// Constructor function for the Argv nconf store, a simple abstraction
+// around the Memory store that can read command-line arguments.
+//
+var Argv = exports.Argv = function (options) {
+  Memory.call(this, options);
+
+  this.type     = 'argv';
+  this.readOnly = true;
+  this.options  = options || false;
+};
+
+// Inherit from the Memory store
+util.inherits(Argv, Memory);
+
+//
+// ### function loadSync ()
+// Loads the data passed in from `process.argv` into this instance.
+//
+Argv.prototype.loadSync = function () {
+  this.loadArgv();
+  return this.store;
+};
+
+//
+// ### function loadArgv ()
+// Loads the data passed in from the command-line arguments
+// into this instance.
+//
+Argv.prototype.loadArgv = function () {
+  var self = this,
+      argv;
+
+  argv = typeof this.options === 'object'
+    ? require('optimist')(process.argv.slice(2)).options(this.options).argv
+    : require('optimist')(process.argv.slice(2)).argv;
+
+  if (!argv) {
+    return;
+  }
+
+  this.readOnly = false;
+  Object.keys(argv).forEach(function (key) {
+    self.set(key, argv[key]);
+  });
+
+  this.readOnly = true;
+  return this.store;
+};

node_modules/nconf/lib/nconf/stores/env.js

@@ -0,0 +1,67 @@
+/*
+ * env.js: Simple memory-based store for environment variables
+ *
+ * (C) 2011, Nodejitsu Inc.
+ *
+ */
+
+var util = require('util'),
+    common = require('../common'),
+    Memory = require('./memory').Memory;
+
+//
+// ### function Env (options)
+// #### @options {Object} Options for this instance.
+// Constructor function for the Env nconf store, a simple abstraction
+// around the Memory store that can read process environment variables.
+//
+var Env = exports.Env = function (options) {
+  Memory.call(this, options);
+
+  options        = options || {};
+  this.type      = 'env';
+  this.readOnly  = true;
+  this.whitelist = options.whitelist || [];
+  this.separator = options.separator || '';
+  if (options instanceof Array) {
+    this.whitelist = options;
+  }
+  if (typeof(options) === 'string') {
+    this.separator = options;
+  }
+};
+
+// Inherit from the Memory store
+util.inherits(Env, Memory);
+
+//
+// ### function loadSync ()
+// Loads the data passed in from `process.env` into this instance.
+//
+Env.prototype.loadSync = function () {
+  this.loadEnv();
+  return this.store;
+};
+
+//
+// ### function loadEnv ()
+// Loads the data passed in from `process.env` into this instance.
+//
+Env.prototype.loadEnv = function () {
+  var self = this;
+
+  this.readOnly = false;
+  Object.keys(process.env).filter(function (key) {
+    return !self.whitelist.length || self.whitelist.indexOf(key) !== -1;
+  }).forEach(function (key) {
+    if (self.separator) {
+      self.set(common.key.apply(common, key.split(self.separator)), process.env[key]);
+    } else {
+      self.set(key, process.env[key]);
+    }
+  });
+
+  this.readOnly = true;
+  return this.store;
+};
+

node_modules/nconf/lib/nconf/stores/file.js

@@ -0,0 +1,237 @@
+/*
+ * file.js: Simple file storage engine for nconf files
+ *
+ * (C) 2011, Nodejitsu Inc.
+ *
+ */
+
+var fs = require('fs'),
+    path = require('path'),
+    util = require('util'),
+    formats = require('../formats'),
+    Memory = require('./memory').Memory,
+    exists = fs.exists || path.exists,
+    existsSync = fs.existsSync || path.existsSync;
+
+//
+// ### function File (options)
+// #### @options {Object} Options for this instance
+// Constructor function for the File nconf store, a simple abstraction
+// around the Memory store that can persist configuration to disk.
+//
+var File = exports.File = function (options) {
+  if (!options || !options.file) {
+    throw new Error ('Missing required option `file`');
+  }
+
+  Memory.call(this, options);
+
+  this.type   = 'file';
+  this.file   = options.file;
+  this.dir    = options.dir    || process.cwd();
+  this.format = options.format || formats.json;
+  this.json_spacing = options.json_spacing || 2;
+
+  if (options.search) {
+    this.search(this.dir);
+  }
+};
+
+// Inherit from the Memory store
+util.inherits(File, Memory);
+
+//
+// ### function save (value, callback)
+// #### @value {Object} _Ignored_ Left here for consistency
+// #### @callback {function} Continuation to respond to when complete.
+// Saves the current configuration object to disk at `this.file`
+// using the format specified by `this.format`.
+//
+File.prototype.save = function (value, callback) {
+  if (!callback) {
+    callback = value;
+    value = null;
+  }
+
+  fs.writeFile(this.file, this.format.stringify(this.store, null, this.json_spacing), function (err) {
+    return err ? callback(err) : callback();
+  });
+};
+
+//
+// ### function saveSync (value, callback)
+// #### @value {Object} _Ignored_ Left here for consistency
+// #### @callback {function} **Optional** Continuation to respond to when complete.
+// Saves the current configuration object to disk at `this.file`
+// using the format specified by `this.format` synchronously.
+//
+File.prototype.saveSync = function (value) {
+  try {
+    fs.writeFileSync(this.file, this.format.stringify(this.store, null, this.json_spacing));
+  }
+  catch (ex) {
+    throw(ex);
+  }
+  return this.store;
+};
+
+//
+// ### function load (callback)
+// #### @callback {function} Continuation to respond to when complete.
+// Responds with an Object representing all keys associated in this instance.
+//
+File.prototype.load = function (callback) {
+  var self = this;
+
+  exists(self.file, function (exists) {
+    if (!exists) {
+      return callback(null, {});
+    }
+
+    //
+    // Else, the path exists, read it from disk
+    //
+    fs.readFile(self.file, function (err, data) {
+      if (err) {
+        return callback(err);
+      }
+
+      try {
+        //deals with string that include BOM
+        var stringData = data.toString();
+
+        if (stringData.charAt(0) === '\uFEFF') stringData = stringData.substr(1);
+        self.store = self.format.parse(stringData);
+
+      }
+      catch (ex) {
+        return callback(new Error("Error parsing your JSON configuration file: [" + self.file + '].'));
+      }
+
+      callback(null, self.store);
+    });
+  });
+};
+
+//
+// ### function loadSync (callback)
+// Attempts to load the data stored in `this.file` synchronously
+// and responds appropriately.
+//
+File.prototype.loadSync = function () {
+  var data, self = this;
+
+  if (!existsSync(self.file)) {
+    self.store = {};
+    data = {};
+  }
+  else {
+    //
+    // Else, the path exists, read it from disk
+    //
+    try {
+      //deals with file that include BOM
+      var fileData = fs.readFileSync(this.file, 'utf8');
+      if (fileData.charAt(0) === '\uFEFF') fileData = fileData.substr(1);
+
+      data = this.format.parse(fileData);
+      this.store = data;
+    }
+    catch (ex) {
+      throw new Error("Error parsing your JSON configuration file: [" + self.file + '].');
+    }
+  }
+
+  return data;
+};
+
+//
+// ### function search (base)
+// #### @base {string} Base directory (or file) to begin searching for the target file.
+// Attempts to find `this.file` by iteratively searching up the
+// directory structure
+//
+File.prototype.search = function (base) {
+  var looking = true,
+      fullpath,
+      previous,
+      stats;
+
+  base = base || process.cwd();
+
+  if (this.file[0] === '/') {
+    //
+    // If filename for this instance is a fully qualified path
+    // (i.e. it starts with a `'/'`) then check if it exists
+    //
+    try {
+      stats = fs.statSync(fs.realpathSync(this.file));
+      if (stats.isFile()) {
+        fullpath = this.file;
+        looking = false;
+      }
+    }
+    catch (ex) {
+      //
+      // Ignore errors
+      //
+    }
+  }
+
+  if (looking && base) {
+    //
+    // Attempt to stat the realpath located at `base`
+    // if the directory does not exist then return false.
+    //
+    try {
+      var stat = fs.statSync(fs.realpathSync(base));
+      looking = stat.isDirectory();
+    }
+    catch (ex) {
+      return false;
+    }
+  }
+
+  while (looking) {
+    //
+    // Iteratively look up the directory structure from `base`
+    //
+    try {
+      stats = fs.statSync(fs.realpathSync(fullpath = path.join(base, this.file)));
+      looking = stats.isDirectory();
+    }
+    catch (ex) {
+      previous = base;
+      base = path.dirname(base);
+
+      if (previous === base) {
+        //
+        // If we've reached the top of the directory structure then simply use
+        // the default file path.
+        //
+        try {
+          stats = fs.statSync(fs.realpathSync(fullpath = path.join(this.dir, this.file)));
+          if (stats.isDirectory()) {
+            fullpath = undefined;
+          }
+        }
+        catch (ex) {
+          //
+          // Ignore errors
+          //
+        }
+
+        looking = false;
+      }
+    }
+  }
+
+  //
+  // Set the file for this instance to the fullpath
+  // that we have found during the search. In the event that
+  // the search was unsuccessful use the original value for `this.file`.
+  //
+  this.file = fullpath || this.file;
+
+  return fullpath;
+};

node_modules/nconf/lib/nconf/stores/literal.js

@@ -0,0 +1,29 @@
+/*
+ * literal.js: Simple literal Object store for nconf.
+ *
+ * (C) 2011, Nodejitsu Inc.
+ *
+ */
+
+var util = require('util'),
+    Memory = require('./memory').Memory
+
+var Literal = exports.Literal = function Literal (options) {
+  Memory.call(this, options);
+
+  options       = options || {}
+  this.type     = 'literal';
+  this.readOnly = true;
+  this.store    = options.store || options;
+};
+
+// Inherit from Memory store.
+util.inherits(Literal, Memory);
+
+//
+// ### function loadSync (callback)
+// Returns the data stored in `this.store` synchronously.
+//
+Literal.prototype.loadSync = function () {
+  return this.store;
+};

node_modules/nconf/lib/nconf/stores/memory.js

@@ -0,0 +1,224 @@
+/*
+ * memory.js: Simple memory storage engine for nconf configuration(s)
+ *
+ * (C) 2011, Nodejitsu Inc.
+ *
+ */
+
+var common = require('../common');
+
+//
+// ### function Memory (options)
+// #### @options {Object} Options for this instance
+// Constructor function for the Memory nconf store which maintains
+// a nested json structure based on key delimiters `:`.
+//
+// e.g. `my:nested:key` ==> `{ my: { nested: { key: } } }`
+//
+var Memory = exports.Memory = function (options) {
+  options       = options || {};
+  this.type     = 'memory';
+  this.store    = {};
+  this.mtimes   = {};
+  this.readOnly = false;
+  this.loadFrom = options.loadFrom || null;
+
+  if (this.loadFrom) {
+    this.store = common.loadFilesSync(this.loadFrom);
+  }
+};
+
+//
+// ### function get (key)
+// #### @key {string} Key to retrieve for this instance.
+// Retrieves the value for the specified key (if any).
+//
+Memory.prototype.get = function (key) {
+  var target = this.store,
+      path   = common.path(key);
+
+  //
+  // Scope into the object to get the appropriate nested context
+  //
+  while (path.length > 0) {
+    key = path.shift();
+    if (target && target.hasOwnProperty(key)) {
+      target = target[key];
+      continue;
+    }
+    return undefined;
+  }
+  
+  return target;
+};
+
+//
+// ### function set (key, value)
+// #### @key {string} Key to set in this instance
+// #### @value {literal|Object} Value for the specified key
+// Sets the `value` for the specified `key` in this instance.
+//
+Memory.prototype.set = function (key, value) {
+  if (this.readOnly) {
+    return false;
+  }
+
+  var target = this.store,
+      path   = common.path(key);
+
+  if (path.length === 0) {
+    //
+    // Root must be an object
+    //
+    if (!value || typeof value !== 'object') {
+      return false;
+    }
+    else {
+      this.reset();
+      this.store = value;
+      return true;
+    }
+  }
+
+  //
+  // Update the `mtime` (modified time) of the key
+  //
+  this.mtimes[key] = Date.now();
+
+  //
+  // Scope into the object to get the appropriate nested context
+  //
+  while (path.length > 1) {
+    key = path.shift();
+    if (!target[key] || typeof target[key] !== 'object') {
+      target[key] = {};
+    }
+
+    target = target[key];
+  }
+
+  // Set the specified value in the nested JSON structure
+  key = path.shift();
+  target[key] = value;
+  return true;
+};
+
+//
+// ### function clear (key)
+// #### @key {string} Key to remove from this instance
+// Removes the value for the specified `key` from this instance.
+//
+Memory.prototype.clear = function (key) {
+  if (this.readOnly) {
+    return false;
+  }
+
+  var target = this.store,
+      value  = target,
+      path   = common.path(key);
+
+  //
+  // Remove the key from the set of `mtimes` (modified times)
+  //
+  delete this.mtimes[key];
+
+  //
+  // Scope into the object to get the appropriate nested context
+  //
+  for (var i = 0; i < path.length - 1; i++) {
+    key = path[i];
+    value = target[key];
+    if (typeof value !== 'function' && typeof value !== 'object') {
+      return false;
+    }
+    target = value;
+  }
+
+  // Delete the key from the nested JSON structure
+  key = path[i];
+  delete target[key];
+  return true;
+};
+
+//
+// ### function merge (key, value)
+// #### @key {string} Key to merge the value into
+// #### @value {literal|Object} Value to merge into the key
+// Merges the properties in `value` into the existing object value
+// at `key`. If the existing value `key` is not an Object, it will be
+// completely overwritten.
+//
+Memory.prototype.merge = function (key, value) {
+  if (this.readOnly) {
+    return false;
+  }
+
+  //
+  // If the key is not an `Object` or is an `Array`,
+  // then simply set it. Merging is for Objects.
+  //
+  if (typeof value !== 'object' || Array.isArray(value) || value === null) {
+    return this.set(key, value);
+  }
+
+  var self    = this,
+      target  = this.store,
+      path    = common.path(key),
+      fullKey = key;
+
+  //
+  // Update the `mtime` (modified time) of the key
+  //
+  this.mtimes[key] = Date.now();
+
+  //
+  // Scope into the object to get the appropriate nested context
+  //
+  while (path.length > 1) {
+    key = path.shift();
+    if (!target[key]) {
+      target[key] = {};
+    }
+
+    target = target[key];
+  }
+
+  // Set the specified value in the nested JSON structure
+  key = path.shift();
+
+  //
+  // If the current value at the key target is not an `Object`,
+  // or is an `Array` then simply override it because the new value
+  // is an Object.
+  //
+  if (typeof target[key] !== 'object' || Array.isArray(target[key])) {
+    target[key] = value;
+    return true;
+  }
+
+  return Object.keys(value).every(function (nested) {
+    return self.merge(common.key(fullKey, nested), value[nested]);
+  });
+};
+
+//
+// ### function reset (callback)
+// Clears all keys associated with this instance.
+//
+Memory.prototype.reset = function () {
+  if (this.readOnly) {
+    return false;
+  }
+
+  this.mtimes = {};
+  this.store  = {};
+  return true;
+};
+
+//
+// ### function loadSync
+// Returns the store managed by this instance
+//
+Memory.prototype.loadSync = function () {
+  return this.store || {};
+};